From e02c9e1086fb78b0e78039fbd62d5980c1bd0c8b Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Thu, 5 Jan 2023 17:51:38 +0000
Subject: [PATCH 001/657] Beta-reduce directly applied PolymorphicFunction

---
 .../tools/dotc/inlines/InlineReducer.scala    |  5 +-
 .../tools/dotc/transform/BetaReduce.scala     | 53 ++++++++++++++-----
 .../tools/dotc/transform/InlinePatterns.scala |  3 +-
 .../tools/dotc/transform/PickleQuotes.scala   |  2 +-
 .../quoted/runtime/impl/QuotesImpl.scala      |  3 +-
 .../backend/jvm/InlineBytecodeTests.scala     | 26 +++++++++
 6 files changed, 73 insertions(+), 19 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/inlines/InlineReducer.scala b/compiler/src/dotty/tools/dotc/inlines/InlineReducer.scala
index 42e86b71eff8..80a1546e0356 100644
--- a/compiler/src/dotty/tools/dotc/inlines/InlineReducer.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/InlineReducer.scala
@@ -165,12 +165,13 @@ class InlineReducer(inliner: Inliner)(using Context):
     */
   def betaReduce(tree: Tree)(using Context): Tree = tree match {
     case Apply(Select(cl, nme.apply), args) if defn.isFunctionType(cl.tpe) =>
-      val bindingsBuf = new mutable.ListBuffer[ValDef]
+      val bindingsBuf = new mutable.ListBuffer[DefTree]
       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 =>
-              Some(BetaReduce.reduceApplication(ddef, args, bindingsBuf))
+              // TODO beta reduce PolyType
+              Some(BetaReduce.reduceApplication(ddef, List(args), bindingsBuf))
             case _ => None
         case Block(stats, expr) if stats.forall(isPureBinding) =>
           recur(expr).map(cpy.Block(cl)(stats, _))
diff --git a/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala b/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala
index 7ac3dc972ad1..00bb83175627 100644
--- a/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala
+++ b/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala
@@ -40,13 +40,16 @@ class BetaReduce extends MiniPhase:
 
   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)
+      val app1 = BetaReduce(app, fn, List(app.args))
+      if app1 ne app then report.log(i"beta reduce $app -> $app1")
+      app1
+    case TypeApply(Select(fn, nme.apply), targs) if fn.tpe.typeSymbol eq defn.PolyFunctionClass =>
+      val app1 = BetaReduce(app, fn, List(targs, app.args))
       if app1 ne app then report.log(i"beta reduce $app -> $app1")
       app1
     case _ =>
       app
 
-
 object BetaReduce:
   import ast.tpd._
 
@@ -54,18 +57,24 @@ object 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 =
+  def apply(original: Tree, fn: Tree, argss: List[List[Tree]])(using Context): Tree =
     fn match
       case Typed(expr, _) =>
-        BetaReduce(original, expr, args)
+        BetaReduce(original, expr, argss)
       case Block((anonFun: DefDef) :: Nil, closure: Closure) =>
-        BetaReduce(anonFun, args)
+        BetaReduce(anonFun, argss)
+      case Block((TypeDef(_, template: Template)) :: Nil, Typed(Apply(Select(New(_), _), _), _)) if template.constr.rhs.isEmpty =>
+        template.body match
+          case (anonFun: DefDef) :: Nil =>
+            BetaReduce(anonFun, argss)
+          case _ =>
+            original
       case Block(stats, expr) =>
-        val tree = BetaReduce(original, expr, args)
+        val tree = BetaReduce(original, expr, argss)
         if tree eq original then original
         else cpy.Block(fn)(stats, tree)
       case Inlined(call, bindings, expr) =>
-        val tree = BetaReduce(original, expr, args)
+        val tree = BetaReduce(original, expr, argss)
         if tree eq original then original
         else cpy.Inlined(fn)(call, bindings, tree)
       case _ =>
@@ -73,16 +82,32 @@ object BetaReduce:
   end apply
 
   /** Beta-reduces a call to `ddef` with arguments `args` */
-  def apply(ddef: DefDef, args: List[Tree])(using Context) =
-    val bindings = new ListBuffer[ValDef]()
-    val expansion1 = reduceApplication(ddef, args, bindings)
+  def apply(ddef: DefDef, argss: List[List[Tree]])(using Context) =
+    val bindings = new ListBuffer[DefTree]()
+    val expansion1 = reduceApplication(ddef, argss, bindings)
     val bindings1 = bindings.result()
     seq(bindings1, expansion1)
 
   /** Beta-reduces a call to `ddef` with arguments `args` and registers new bindings */
-  def reduceApplication(ddef: DefDef, args: List[Tree], bindings: ListBuffer[ValDef])(using Context): Tree =
-    val vparams = ddef.termParamss.iterator.flatten.toList
+  def reduceApplication(ddef: DefDef, argss: List[List[Tree]], bindings: ListBuffer[DefTree])(using Context): Tree =
+    assert(argss.size == 1 || argss.size == 2)
+    val targs = if argss.size == 2 then argss.head else Nil
+    val args = argss.last
+    val tparams = ddef.leadingTypeParams
+    val vparams = ddef.termParamss.flatten
+    assert(targs.hasSameLengthAs(tparams))
     assert(args.hasSameLengthAs(vparams))
+
+    val targSyms =
+      for (targ, tparam) <- targs.zip(tparams) yield
+        targ.tpe.dealias match
+          case ref @ TypeRef(NoPrefix, _) =>
+            ref.symbol
+          case _ =>
+            val binding = TypeDef(newSymbol(ctx.owner, tparam.name, EmptyFlags, targ.tpe, coord = targ.span)).withSpan(targ.span)
+            bindings += binding
+            binding.symbol
+
     val argSyms =
       for (arg, param) <- args.zip(vparams) yield
         arg.tpe.dealias match
@@ -99,8 +124,8 @@ object BetaReduce:
     val expansion = TreeTypeMap(
       oldOwners = ddef.symbol :: Nil,
       newOwners = ctx.owner :: Nil,
-      substFrom = vparams.map(_.symbol),
-      substTo = argSyms
+      substFrom = (tparams ::: vparams).map(_.symbol),
+      substTo = targSyms ::: argSyms
     ).transform(ddef.rhs)
 
     val expansion1 = new TreeMap {
diff --git a/compiler/src/dotty/tools/dotc/transform/InlinePatterns.scala b/compiler/src/dotty/tools/dotc/transform/InlinePatterns.scala
index 6edb60a77245..b1d3bb68cf76 100644
--- a/compiler/src/dotty/tools/dotc/transform/InlinePatterns.scala
+++ b/compiler/src/dotty/tools/dotc/transform/InlinePatterns.scala
@@ -51,11 +51,12 @@ class InlinePatterns extends MiniPhase:
         case Apply(App(fn, argss), args) => (fn, argss :+ args)
         case _ => (app, Nil)
 
+  // TODO merge with BetaReduce.scala
   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 List(ddef @ DefDef(`name`, _, _, _)) => BetaReduce(ddef, List(args))
           case _ => tree
       case _ => tree
 
diff --git a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
index 21fc27cec0dd..732d8d41b8d6 100644
--- a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
@@ -322,7 +322,7 @@ object PickleQuotes {
                   }
                   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))
+                  BetaReduce(ddef, List(spliceArgs)).select(nme.apply).appliedTo(args(2).asInstance(quotesType))
                 }
                 CaseDef(Literal(Constant(idx)), EmptyTree, rhs)
               }
diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
index 1ec13ba832c9..7cbf05871e08 100644
--- a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
+++ b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
@@ -362,8 +362,9 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
     object Term extends TermModule:
       def betaReduce(tree: Term): Option[Term] =
         tree match
+          // TODO support TypeApply. Would fix #15968.
           case app @ tpd.Apply(tpd.Select(fn, nme.apply), args) if dotc.core.Symbols.defn.isFunctionType(fn.tpe) =>
-            val app1 = dotc.transform.BetaReduce(app, fn, args)
+            val app1 = dotc.transform.BetaReduce(app, fn, List(args))
             if app1 eq app then None
             else Some(app1.withSpan(tree.span))
           case tpd.Block(Nil, expr) =>
diff --git a/compiler/test/dotty/tools/backend/jvm/InlineBytecodeTests.scala b/compiler/test/dotty/tools/backend/jvm/InlineBytecodeTests.scala
index 33e898718b33..a9cec06880a2 100644
--- a/compiler/test/dotty/tools/backend/jvm/InlineBytecodeTests.scala
+++ b/compiler/test/dotty/tools/backend/jvm/InlineBytecodeTests.scala
@@ -582,6 +582,32 @@ class InlineBytecodeTests extends DottyBytecodeTest {
     }
   }
 
+  @Test def beta_reduce_polymorphic_function = {
+    val source = """class Test:
+                   |  def test =
+                   |    ([Z] => (arg: Z) => { val a: Z = arg; a }).apply[Int](2)
+                 """.stripMargin
+
+    checkBCode(source) { dir =>
+      val clsIn      = dir.lookupName("Test.class", directory = false).input
+      val clsNode    = loadClassNode(clsIn)
+
+      val fun = getMethod(clsNode, "test")
+      val instructions = instructionsFromMethod(fun)
+      val expected =
+        List(
+          Op(ICONST_2),
+          VarOp(ISTORE, 1),
+          VarOp(ILOAD, 1),
+          Op(IRETURN)
+        )
+
+      assert(instructions == expected,
+        "`i was not properly beta-reduced in `test`\n" + diffInstructions(instructions, expected))
+
+    }
+  }
+
   @Test def i9456 = {
     val source = """class Foo {
                    |  def test: Int = inline2(inline1(2.+))

From 223c8b7d697638b9a1fd971552753b78d78da0e7 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 9 Jan 2023 09:32:33 +0100
Subject: [PATCH 002/657] `Expr.betaReduce` support for polymorphic function

Fixes #15968
---
 .../scala/quoted/runtime/impl/QuotesImpl.scala    |  5 ++++-
 tests/run-macros/i15968.check                     |  5 +++++
 tests/run-macros/i15968/Macro_1.scala             | 15 +++++++++++++++
 tests/run-macros/i15968/Test_2.scala              |  3 +++
 4 files changed, 27 insertions(+), 1 deletion(-)
 create mode 100644 tests/run-macros/i15968.check
 create mode 100644 tests/run-macros/i15968/Macro_1.scala
 create mode 100644 tests/run-macros/i15968/Test_2.scala

diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
index 7cbf05871e08..277cfd9f8cfb 100644
--- a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
+++ b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
@@ -362,11 +362,14 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
     object Term extends TermModule:
       def betaReduce(tree: Term): Option[Term] =
         tree match
-          // TODO support TypeApply. Would fix #15968.
           case app @ tpd.Apply(tpd.Select(fn, nme.apply), args) if dotc.core.Symbols.defn.isFunctionType(fn.tpe) =>
             val app1 = dotc.transform.BetaReduce(app, fn, List(args))
             if app1 eq app then None
             else Some(app1.withSpan(tree.span))
+          case app @ tpd.Apply(tpd.TypeApply(tpd.Select(fn, nme.apply), targs), args) if fn.tpe.typeSymbol eq dotc.core.Symbols.defn.PolyFunctionClass =>
+            val app1 = dotc.transform.BetaReduce(app, fn, List(targs, app.args))
+            if app1 eq app then None
+            else Some(app1.withSpan(tree.span))
           case tpd.Block(Nil, expr) =>
             for e <- betaReduce(expr) yield tpd.cpy.Block(tree)(Nil, e)
           case tpd.Inlined(_, Nil, expr) =>
diff --git a/tests/run-macros/i15968.check b/tests/run-macros/i15968.check
new file mode 100644
index 000000000000..c7f3847d404c
--- /dev/null
+++ b/tests/run-macros/i15968.check
@@ -0,0 +1,5 @@
+{
+  type Z = java.lang.String
+  "foo".toString()
+}
+"foo".toString()
diff --git a/tests/run-macros/i15968/Macro_1.scala b/tests/run-macros/i15968/Macro_1.scala
new file mode 100644
index 000000000000..ea2728840d6e
--- /dev/null
+++ b/tests/run-macros/i15968/Macro_1.scala
@@ -0,0 +1,15 @@
+import scala.quoted.*
+
+inline def macroPolyFun[A](inline arg: A, inline f: [Z] => Z => String): String =
+  ${ macroPolyFunImpl[A]('arg, 'f) }
+
+private def macroPolyFunImpl[A: Type](arg: Expr[A], f: Expr[[Z] => Z => String])(using Quotes): Expr[String] =
+  Expr(Expr.betaReduce('{ $f($arg) }).show)
+
+
+inline def macroFun[A](inline arg: A, inline f: A => String): String =
+  ${ macroFunImpl[A]('arg, 'f) }
+
+private def macroFunImpl[A: Type](arg: Expr[A], f: Expr[A => String])(using Quotes): Expr[String] =
+  Expr(Expr.betaReduce('{ $f($arg) }).show)
+
diff --git a/tests/run-macros/i15968/Test_2.scala b/tests/run-macros/i15968/Test_2.scala
new file mode 100644
index 000000000000..6c6826f96b34
--- /dev/null
+++ b/tests/run-macros/i15968/Test_2.scala
@@ -0,0 +1,3 @@
+@main def Test: Unit =
+  println(macroPolyFun("foo", [Z] => (arg: Z) => arg.toString))
+  println(macroFun("foo", arg => arg.toString))

From d37902d9983397e1bf6ce6ad34bdb00788fbb661 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 9 Jan 2023 10:21:46 +0100
Subject: [PATCH 003/657] Support polymorphic beta-reduction while inlining

---
 .../tools/dotc/inlines/InlineReducer.scala    | 41 ------------
 .../dotty/tools/dotc/inlines/Inliner.scala    |  7 ++-
 .../tools/dotc/transform/BetaReduce.scala     | 62 +++++++++++++++++++
 .../inline-beta-reduce-polyfunction.check     |  7 +++
 .../inline-beta-reduce-polyfunction.scala     |  5 ++
 5 files changed, 78 insertions(+), 44 deletions(-)
 create mode 100644 tests/run-macros/inline-beta-reduce-polyfunction.check
 create mode 100644 tests/run-macros/inline-beta-reduce-polyfunction.scala

diff --git a/compiler/src/dotty/tools/dotc/inlines/InlineReducer.scala b/compiler/src/dotty/tools/dotc/inlines/InlineReducer.scala
index 80a1546e0356..547160340238 100644
--- a/compiler/src/dotty/tools/dotc/inlines/InlineReducer.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/InlineReducer.scala
@@ -12,8 +12,6 @@ import NameKinds.{InlineAccessorName, InlineBinderName, InlineScrutineeName}
 import config.Printers.inlining
 import util.SimpleIdentityMap
 
-import dotty.tools.dotc.transform.BetaReduce
-
 import collection.mutable
 
 /** A utility class offering methods for rewriting inlined code */
@@ -150,45 +148,6 @@ class InlineReducer(inliner: Inliner)(using Context):
     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 mutable.ListBuffer[DefTree]
-      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 =>
-              // TODO beta reduce PolyType
-              Some(BetaReduce.reduceApplication(ddef, List(args), bindingsBuf))
-            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) =>
-          seq(bindingsBuf.result(), 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.
diff --git a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
index c71648984664..40b0b383a4e3 100644
--- a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
@@ -21,6 +21,7 @@ import collection.mutable
 import reporting.trace
 import util.Spans.Span
 import dotty.tools.dotc.transform.Splicer
+import dotty.tools.dotc.transform.BetaReduce
 import quoted.QuoteUtils
 import scala.annotation.constructorOnly
 
@@ -811,7 +812,7 @@ class Inliner(val call: tpd.Tree)(using Context):
           case Quoted(Spliced(inner)) => inner
           case _ => tree
       val locked = ctx.typerState.ownedVars
-      val res = cancelQuotes(constToLiteral(betaReduce(super.typedApply(tree, pt)))) match {
+      val res = cancelQuotes(constToLiteral(BetaReduce(super.typedApply(tree, pt)))) match {
         case res: Apply if res.symbol == defn.QuotedRuntime_exprSplice
                         && StagingContext.level == 0
                         && !hasInliningErrors =>
@@ -824,7 +825,7 @@ class Inliner(val call: tpd.Tree)(using Context):
 
     override def typedTypeApply(tree: untpd.TypeApply, pt: Type)(using Context): Tree =
       val locked = ctx.typerState.ownedVars
-      val tree1 = inlineIfNeeded(constToLiteral(betaReduce(super.typedTypeApply(tree, pt))), pt, locked)
+      val tree1 = inlineIfNeeded(constToLiteral(BetaReduce(super.typedTypeApply(tree, pt))), pt, locked)
       if tree1.symbol.isQuote then
         ctx.compilationUnit.needsStaging = true
       tree1
@@ -1005,7 +1006,7 @@ class Inliner(val call: tpd.Tree)(using Context):
             super.transform(t1)
           case t: Apply =>
             val t1 = super.transform(t)
-            if (t1 `eq` t) t else reducer.betaReduce(t1)
+            if (t1 `eq` t) t else BetaReduce(t1)
           case Block(Nil, expr) =>
             super.transform(expr)
           case _ =>
diff --git a/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala b/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala
index 00bb83175627..32e26bcbc883 100644
--- a/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala
+++ b/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala
@@ -56,6 +56,68 @@ object BetaReduce:
   val name: String = "betaReduce"
   val description: String = "reduce closure applications"
 
+  /** 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.
+   *
+   *  Similarly, rewrites type applications
+   *
+   *    ([X1, ..., Xm] => (x1, ..., xn) => b).apply[T1, .., Tm](e1, ..., en)
+   *
+   *  to
+   *
+   *    type X1 = T1; ...; type Xm = Tm;val/def x1 = e1; ...; val/def xn = en; b
+   *
+   *  This beta-reduction preserves the integrity of `Inlined` tree nodes.
+   */
+  def apply(tree: Tree)(using Context): Tree =
+    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 =>
+        ddef.tpe.widen match // TODO can these guards be removed?
+          case mt: MethodType if ddef.paramss.head.length == argss.head.length =>
+            Some(reduceApplication(ddef, argss, bindingsBuf))
+          case _ => None
+      case Block((TypeDef(_, template: Template)) :: Nil, Typed(Apply(Select(New(_), _), _), _)) if template.constr.rhs.isEmpty =>
+        template.body match
+          case (ddef: DefDef) :: Nil =>
+            ddef.tpe.widen match // TODO can these guards be removed?
+              case mt: MethodType if ddef.paramss.head.length == argss.head.length =>
+                Some(reduceApplication(ddef, argss, bindingsBuf))
+              case mt: PolyType if ddef.paramss.head.length == argss.head.length && ddef.paramss.last.length == argss.last.length =>
+                Some(reduceApplication(ddef, argss, bindingsBuf))
+              case _ => None
+          case _ => None
+      case Block(stats, expr) if stats.forall(isPureBinding) =>
+        recur(expr, argss).map(cpy.Block(fn)(stats, _))
+      case Inlined(call, bindings, expr) if bindings.forall(isPureBinding) =>
+        recur(expr, argss).map(cpy.Inlined(fn)(call, bindings, _))
+      case Typed(expr, tpt) =>
+        recur(expr, argss)
+      case _ => None
+    tree match
+      case Apply(Select(fn, nme.apply), args) if defn.isFunctionType(fn.tpe) =>
+        recur(fn, List(args)) match
+          case Some(reduced) =>
+            seq(bindingsBuf.result(), reduced).withSpan(tree.span)
+          case None =>
+            tree
+      case Apply(TypeApply(Select(fn, nme.apply), targs), args) if fn.tpe.typeSymbol eq dotc.core.Symbols.defn.PolyFunctionClass =>
+        recur(fn, List(targs, args)) match
+          case Some(reduced) =>
+            seq(bindingsBuf.result(), reduced).withSpan(tree.span)
+          case None =>
+            tree
+      case _ =>
+        tree
+
   /** Beta-reduces a call to `fn` with arguments `argSyms` or returns `tree` */
   def apply(original: Tree, fn: Tree, argss: List[List[Tree]])(using Context): Tree =
     fn match
diff --git a/tests/run-macros/inline-beta-reduce-polyfunction.check b/tests/run-macros/inline-beta-reduce-polyfunction.check
new file mode 100644
index 000000000000..7793e273864f
--- /dev/null
+++ b/tests/run-macros/inline-beta-reduce-polyfunction.check
@@ -0,0 +1,7 @@
+{
+  type X = Int
+  {
+    println(1)
+    1
+  }
+}
diff --git a/tests/run-macros/inline-beta-reduce-polyfunction.scala b/tests/run-macros/inline-beta-reduce-polyfunction.scala
new file mode 100644
index 000000000000..60ef889e7260
--- /dev/null
+++ b/tests/run-macros/inline-beta-reduce-polyfunction.scala
@@ -0,0 +1,5 @@
+transparent inline def foo(inline f: [X] => X => X): Int = f[Int](1)
+
+@main def Test: Unit =
+  val code = compiletime.codeOf(foo([X] => (x: X) => { println(x); x }))
+  println(code)
\ No newline at end of file

From a6de5e4e7eae9d550dd07962b9efddb62075e6a0 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 9 Jan 2023 10:36:58 +0100
Subject: [PATCH 004/657] Reuse beta-reduction logic

---
 .../tools/dotc/transform/BetaReduce.scala     | 40 ++-----------------
 .../quoted/runtime/impl/QuotesImpl.scala      | 13 ++----
 2 files changed, 8 insertions(+), 45 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala b/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala
index 32e26bcbc883..565d04599ca5 100644
--- a/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala
+++ b/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala
@@ -38,17 +38,10 @@ class BetaReduce extends MiniPhase:
 
   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, List(app.args))
-      if app1 ne app then report.log(i"beta reduce $app -> $app1")
-      app1
-    case TypeApply(Select(fn, nme.apply), targs) if fn.tpe.typeSymbol eq defn.PolyFunctionClass =>
-      val app1 = BetaReduce(app, fn, List(targs, app.args))
-      if app1 ne app then report.log(i"beta reduce $app -> $app1")
-      app1
-    case _ =>
-      app
+  override def transformApply(app: Apply)(using Context): Tree =
+    val app1 = BetaReduce(app)
+    if app1 ne app then report.log(i"beta reduce $app -> $app1")
+    app1
 
 object BetaReduce:
   import ast.tpd._
@@ -118,31 +111,6 @@ object BetaReduce:
       case _ =>
         tree
 
-  /** Beta-reduces a call to `fn` with arguments `argSyms` or returns `tree` */
-  def apply(original: Tree, fn: Tree, argss: List[List[Tree]])(using Context): Tree =
-    fn match
-      case Typed(expr, _) =>
-        BetaReduce(original, expr, argss)
-      case Block((anonFun: DefDef) :: Nil, closure: Closure) =>
-        BetaReduce(anonFun, argss)
-      case Block((TypeDef(_, template: Template)) :: Nil, Typed(Apply(Select(New(_), _), _), _)) if template.constr.rhs.isEmpty =>
-        template.body match
-          case (anonFun: DefDef) :: Nil =>
-            BetaReduce(anonFun, argss)
-          case _ =>
-            original
-      case Block(stats, expr) =>
-        val tree = BetaReduce(original, expr, argss)
-        if tree eq original then original
-        else cpy.Block(fn)(stats, tree)
-      case Inlined(call, bindings, expr) =>
-        val tree = BetaReduce(original, expr, argss)
-        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 `args` */
   def apply(ddef: DefDef, argss: List[List[Tree]])(using Context) =
     val bindings = new ListBuffer[DefTree]()
diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
index 277cfd9f8cfb..15ed447fd680 100644
--- a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
+++ b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
@@ -362,20 +362,15 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
     object Term extends TermModule:
       def betaReduce(tree: Term): Option[Term] =
         tree match
-          case app @ tpd.Apply(tpd.Select(fn, nme.apply), args) if dotc.core.Symbols.defn.isFunctionType(fn.tpe) =>
-            val app1 = dotc.transform.BetaReduce(app, fn, List(args))
-            if app1 eq app then None
-            else Some(app1.withSpan(tree.span))
-          case app @ tpd.Apply(tpd.TypeApply(tpd.Select(fn, nme.apply), targs), args) if fn.tpe.typeSymbol eq dotc.core.Symbols.defn.PolyFunctionClass =>
-            val app1 = dotc.transform.BetaReduce(app, fn, List(targs, app.args))
-            if app1 eq app then None
-            else Some(app1.withSpan(tree.span))
           case tpd.Block(Nil, expr) =>
             for e <- betaReduce(expr) yield tpd.cpy.Block(tree)(Nil, e)
           case tpd.Inlined(_, Nil, expr) =>
             betaReduce(expr)
           case _ =>
-            None
+            val tree1 = dotc.transform.BetaReduce(tree)
+            if tree1 eq tree then None
+            else Some(tree1.withSpan(tree.span))
+
     end Term
 
     given TermMethods: TermMethods with

From 43c6ba7d05d3f16e16c650ec54b531402aa641bd Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 9 Jan 2023 11:04:56 +0100
Subject: [PATCH 005/657] Refactor BetaReduce logic

---
 .../src/dotty/tools/dotc/transform/BetaReduce.scala | 13 +------------
 .../dotty/tools/dotc/transform/InlinePatterns.scala | 12 +++++++++---
 .../dotty/tools/dotc/transform/PickleQuotes.scala   |  5 ++++-
 3 files changed, 14 insertions(+), 16 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala b/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala
index 565d04599ca5..c33a1d6d8b10 100644
--- a/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala
+++ b/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala
@@ -111,22 +111,11 @@ object BetaReduce:
       case _ =>
         tree
 
-  /** Beta-reduces a call to `ddef` with arguments `args` */
-  def apply(ddef: DefDef, argss: List[List[Tree]])(using Context) =
-    val bindings = new ListBuffer[DefTree]()
-    val expansion1 = reduceApplication(ddef, argss, bindings)
-    val bindings1 = bindings.result()
-    seq(bindings1, expansion1)
-
   /** 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 =
-    assert(argss.size == 1 || argss.size == 2)
-    val targs = if argss.size == 2 then argss.head else Nil
-    val args = argss.last
+    val (targs, args) = argss.flatten.partition(_.isType)
     val tparams = ddef.leadingTypeParams
     val vparams = ddef.termParamss.flatten
-    assert(targs.hasSameLengthAs(tparams))
-    assert(args.hasSameLengthAs(vparams))
 
     val targSyms =
       for (targ, tparam) <- targs.zip(tparams) yield
diff --git a/compiler/src/dotty/tools/dotc/transform/InlinePatterns.scala b/compiler/src/dotty/tools/dotc/transform/InlinePatterns.scala
index b1d3bb68cf76..798f34757b35 100644
--- a/compiler/src/dotty/tools/dotc/transform/InlinePatterns.scala
+++ b/compiler/src/dotty/tools/dotc/transform/InlinePatterns.scala
@@ -8,6 +8,8 @@ import Symbols._, Contexts._, Types._, Decorators._
 import NameOps._
 import Names._
 
+import scala.collection.mutable.ListBuffer
+
 /** Rewrite an application
  *
  *    {new { def unapply(x0: X0)(x1: X1,..., xn: Xn) = b }}.unapply(y0)(y1, ..., yn)
@@ -38,7 +40,7 @@ class InlinePatterns extends MiniPhase:
     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)
+          val app1 = betaReduce(app, fn, name, argss)
           if app1 ne app then report.log(i"beta reduce $app -> $app1")
           app1
         case _ =>
@@ -52,11 +54,15 @@ class InlinePatterns extends MiniPhase:
         case _ => (app, Nil)
 
   // TODO merge with BetaReduce.scala
-  private def betaReduce(tree: Apply, fn: Tree, name: Name, args: List[Tree])(using Context): Tree =
+  private def betaReduce(tree: Apply, fn: Tree, name: Name, argss: List[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, List(args))
+          case List(ddef @ DefDef(`name`, _, _, _)) =>
+            val bindings = new ListBuffer[DefTree]()
+            val expansion1 = BetaReduce.reduceApplication(ddef, argss, bindings)
+            val bindings1 = bindings.result()
+            seq(bindings1, expansion1)
           case _ => tree
       case _ => tree
 
diff --git a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
index 732d8d41b8d6..c56bac4d66af 100644
--- a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
@@ -322,7 +322,10 @@ object PickleQuotes {
                   }
                   val Block(List(ddef: DefDef), _) = splice: @unchecked
                   // TODO: beta reduce inner closure? Or wait until BetaReduce phase?
-                  BetaReduce(ddef, List(spliceArgs)).select(nme.apply).appliedTo(args(2).asInstance(quotesType))
+                  BetaReduce(
+                    splice
+                      .select(nme.apply).appliedToArgs(spliceArgs))
+                      .select(nme.apply).appliedTo(args(2).asInstance(quotesType))
                 }
                 CaseDef(Literal(Constant(idx)), EmptyTree, rhs)
               }

From f7f61c088d41297277993fc15586a81b3dfb531a Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 9 Jan 2023 11:29:03 +0100
Subject: [PATCH 006/657] Update documentation

---
 compiler/src/dotty/tools/dotc/transform/BetaReduce.scala | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala b/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala
index c33a1d6d8b10..2a9cb7c8e9a7 100644
--- a/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala
+++ b/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala
@@ -13,13 +13,14 @@ import scala.collection.mutable.ListBuffer
 
 /** Rewrite an application
  *
- *    (((x1, ..., xn) => b): T)(y1, ..., yn)
+ *    (([X1, ..., Xm] => (x1, ..., xn) => b): T)[T1, ..., Tm](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
+ *    - the type parameters Xi and type arguments Ti are optional
+ *    - the type ascription ...: T is optional
  *
  *  to
  *

From 60c2d70aadcb620e495832a630dda0670fa93f0f Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 9 Jan 2023 11:39:35 +0100
Subject: [PATCH 007/657] Remove unnecessary guards

Number of arguments should be correct or it would not typecheck.
---
 .../src/dotty/tools/dotc/transform/BetaReduce.scala | 13 ++-----------
 1 file changed, 2 insertions(+), 11 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala b/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala
index 2a9cb7c8e9a7..bdfd4ec76515 100644
--- a/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala
+++ b/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala
@@ -75,19 +75,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 =>
-        ddef.tpe.widen match // TODO can these guards be removed?
-          case mt: MethodType if ddef.paramss.head.length == argss.head.length =>
-            Some(reduceApplication(ddef, argss, bindingsBuf))
-          case _ => None
+        Some(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 =>
-            ddef.tpe.widen match // TODO can these guards be removed?
-              case mt: MethodType if ddef.paramss.head.length == argss.head.length =>
-                Some(reduceApplication(ddef, argss, bindingsBuf))
-              case mt: PolyType if ddef.paramss.head.length == argss.head.length && ddef.paramss.last.length == argss.last.length =>
-                Some(reduceApplication(ddef, argss, bindingsBuf))
-              case _ => None
+          case (ddef: DefDef) :: Nil => Some(reduceApplication(ddef, argss, bindingsBuf))
           case _ => None
       case Block(stats, expr) if stats.forall(isPureBinding) =>
         recur(expr, argss).map(cpy.Block(fn)(stats, _))

From 4523a6f4c7acc2811da3643d95b27768c08635b5 Mon Sep 17 00:00:00 2001
From: Jan Chyb <jan.chyb.99@gmail.com>
Date: Thu, 5 Jan 2023 13:23:55 +0100
Subject: [PATCH 008/657] Fix #16405 - wildcards prematurely resolving to
 Nothing

This was a problem because it could it get in the way of some
metaprogramming techniques. The main issue was the fact that when typing
functions, the type inference would first look at the types from the
source method (resolving type wildcards to Nothing) and only after that,
it could look at the target method.
Now, in the case of wildcards we save that fact for later (while still
resolving the prototype parameter to Nothing) and we in that case we
prioritize according to the target method, after which we fallback to
the default procedure.
---
 .../src/dotty/tools/dotc/typer/Typer.scala    | 47 +++++++++++++------
 tests/run/16405.scala                         | 31 ++++++++++++
 2 files changed, 63 insertions(+), 15 deletions(-)
 create mode 100644 tests/run/16405.scala

diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 79a4e9afbc7f..44ae2ac7a46c 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -1197,7 +1197,8 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     )
   end typedIf
 
-  /** Decompose function prototype into a list of parameter prototypes and a result prototype
+  /** Decompose function prototype into a list of parameter prototypes, an optional list 
+   *  describing whether the parameter prototypes come from WildcardTypes, 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
@@ -1206,7 +1207,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
    *     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) = {
+  private def decomposeProtoFunction(pt: Type, defaultArity: Int, pos: SrcPos)(using Context): (List[Type], Option[List[Boolean]], untpd.Tree) = {
     def typeTree(tp: Type) = tp match {
       case _: WildcardType => new untpd.InferredTypeTree()
       case _ => untpd.InferredTypeTree(tp)
@@ -1234,18 +1235,26 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           // 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)))
+          // However, we still keep the information on whether expected parameter types were 
+          // wildcards, in case of types inferred from target being more specific
+
+          val fromWildcards = pt1.argInfos.init.map{
+            case bounds @ TypeBounds(nt, at) if nt == defn.NothingType && at == defn.AnyType => true
+            case bounds => false
+          }
+
+          (pt1.argTypesLo.init, Some(fromWildcards), 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))))
+          (formals, None, untpd.DependentTypeTree(syms => restpe.substParams(mt, syms.map(_.termRef))))
         case SAMType(mt @ MethodTpe(_, formals, restpe)) =>
-          (formals,
+          (formals, None, 
            if (mt.isResultDependent)
              untpd.DependentTypeTree(syms => restpe.substParams(mt, syms.map(_.termRef)))
            else
              typeTree(restpe))
         case _ =>
-          (List.tabulate(defaultArity)(alwaysWildcardType), untpd.TypeTree())
+          (List.tabulate(defaultArity)(alwaysWildcardType), None, untpd.TypeTree())
       }
     }
   }
@@ -1267,7 +1276,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
    *  If both attempts fail, return `NoType`.
    */
   def inferredFromTarget(
-      param: untpd.ValDef, formal: Type, calleeType: Type, paramIndex: Name => Int)(using Context): Type =
+      param: untpd.ValDef, formal: Type, calleeType: Type, paramIndex: Name => Int, isWildcardParam: Boolean)(using Context): Type =
     val target = calleeType.widen match
       case mtpe: MethodType =>
         val pos = paramIndex(param.name)
@@ -1280,7 +1289,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         else NoType
       case _ => NoType
     if target.exists then formal <:< target
-    if isFullyDefined(formal, ForceDegree.flipBottom) then formal
+    if !isWildcardParam && isFullyDefined(formal, ForceDegree.flipBottom) then formal
     else if target.exists && isFullyDefined(target, ForceDegree.flipBottom) then target
     else NoType
 
@@ -1457,7 +1466,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       case _ =>
     }
 
-    val (protoFormals, resultTpt) = decomposeProtoFunction(pt, params.length, tree.srcPos)
+    val (protoFormals, areWildcardParams, resultTpt) = decomposeProtoFunction(pt, params.length, tree.srcPos)
 
     def protoFormal(i: Int): Type =
       if (protoFormals.length == params.length) protoFormals(i)
@@ -1500,13 +1509,21 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           if (!param.tpt.isEmpty) param
           else
             val formal = protoFormal(i)
+            val isWildcardParam = areWildcardParams.map(list => if i < list.length then list(i) else false).getOrElse(false)
             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))
+            // Since decomposeProtoFunction eagerly approximates function arguments
+            // from below, then in the case that the argument was also identified as
+            // a wildcard type we try to prioritize inferring from target, if possible.
+            // See issue 16405 (tests/run/16405.scala)
+            val (usingFormal, paramType) =
+              if !isWildcardParam && knownFormal then (true, formal)
+              else 
+                val fromTarget = inferredFromTarget(param, formal, calleeType, paramIndex, isWildcardParam)
+                if fromTarget.exists then (false, fromTarget)
+                else if knownFormal then (true, formal)
+                else (false, errorType(AnonymousFunctionMissingParamType(param, tree, formal), param.srcPos))
             val paramTpt = untpd.TypedSplice(
-                (if knownFormal then InferredTypeTree() else untpd.TypeTree())
+                (if usingFormal then InferredTypeTree() else untpd.TypeTree())
                   .withType(paramType.translateFromRepeated(toArray = false))
                   .withSpan(param.span.endPos)
               )
@@ -1577,7 +1594,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           typedMatchFinish(tree, tpd.EmptyTree, defn.ImplicitScrutineeTypeRef, cases1, pt)
         }
         else {
-          val (protoFormals, _) = decomposeProtoFunction(pt, 1, tree.srcPos)
+          val (protoFormals, _, _) = decomposeProtoFunction(pt, 1, tree.srcPos)
           val checkMode =
             if (pt.isRef(defn.PartialFunctionClass)) desugar.MatchCheck.None
             else desugar.MatchCheck.Exhaustive
diff --git a/tests/run/16405.scala b/tests/run/16405.scala
new file mode 100644
index 000000000000..fa0681683c42
--- /dev/null
+++ b/tests/run/16405.scala
@@ -0,0 +1,31 @@
+import scala.compiletime.summonInline
+
+case class TypeDesc[T](tpe: String)
+object TypeDesc {
+  given nothing: TypeDesc[Nothing] = TypeDesc("Nothing")
+  given string: TypeDesc[String] = TypeDesc("String")
+  given int: TypeDesc[Int] = TypeDesc("Int")
+}
+
+def exampleFn(s: String, i: Int): Unit = ()
+
+inline def argumentTypesOf[R](fun: (_, _) => R): (TypeDesc[?], TypeDesc[?]) = {
+  inline fun match {
+    case x: ((a, b) => R) =>
+      (scala.compiletime.summonInline[TypeDesc[a]], scala.compiletime.summonInline[TypeDesc[b]])
+  }
+}
+inline def argumentTypesOfNoWildCard[A, B, R](fun: (A, B) => R): (TypeDesc[?], TypeDesc[?]) = argumentTypesOf(fun)
+inline def argumentTypesOfAllWildCard(fun: (?, ?) => ?): (TypeDesc[?], TypeDesc[?]) = argumentTypesOf(fun)
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    val expected = (TypeDesc.string, TypeDesc.int)
+    assert(argumentTypesOf(exampleFn) == expected)
+    assert(argumentTypesOf(exampleFn(_, _)) == expected)
+    assert(argumentTypesOfNoWildCard(exampleFn) == expected)
+    assert(argumentTypesOfNoWildCard(exampleFn(_, _)) == expected)
+    assert(argumentTypesOfAllWildCard(exampleFn) == expected)
+    assert(argumentTypesOfAllWildCard(exampleFn(_, _)) == expected)
+  } 
+}
\ No newline at end of file

From 80c155691ea996d708448fd44c01bec29caf6be6 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Wed, 11 Jan 2023 14:29:33 +0100
Subject: [PATCH 009/657] Use `Object.toString` for `quoted.{Expr, Type}`

---
 compiler/src/scala/quoted/runtime/impl/ExprImpl.scala | 2 --
 compiler/src/scala/quoted/runtime/impl/TypeImpl.scala | 2 --
 2 files changed, 4 deletions(-)

diff --git a/compiler/src/scala/quoted/runtime/impl/ExprImpl.scala b/compiler/src/scala/quoted/runtime/impl/ExprImpl.scala
index b33ba14b9e70..5fac91124187 100644
--- a/compiler/src/scala/quoted/runtime/impl/ExprImpl.scala
+++ b/compiler/src/scala/quoted/runtime/impl/ExprImpl.scala
@@ -20,6 +20,4 @@ final class ExprImpl(val tree: tpd.Tree, val scope: Scope) extends Expr[Any] {
   }
 
   override def hashCode(): Int = tree.hashCode()
-
-  override def toString: String = "'{ ... }"
 }
diff --git a/compiler/src/scala/quoted/runtime/impl/TypeImpl.scala b/compiler/src/scala/quoted/runtime/impl/TypeImpl.scala
index 36da30e112c8..d4cea83efde8 100644
--- a/compiler/src/scala/quoted/runtime/impl/TypeImpl.scala
+++ b/compiler/src/scala/quoted/runtime/impl/TypeImpl.scala
@@ -14,6 +14,4 @@ final class TypeImpl(val typeTree: tpd.Tree, val scope: Scope) extends Type[?] {
   }
 
   override def hashCode(): Int = typeTree.hashCode()
-
-  override def toString: String = "Type.of[...]"
 }

From 027923ce325ef1c4b487c2aeaf1c41a9771de5e3 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Tue, 17 Jan 2023 12:22:47 +0100
Subject: [PATCH 010/657] Fix check whether classTag can be generated for match
 types

The previous check, meant to address #15618, tested whether all alternatives
of a match type had the same class tag and only then permitted a classtag
for the match type. This was the wrong test. It did not work for recursive
match types, because it could lead to stack overflow for them. And it did
not take into account that match types could be reduced.

A better test is to simply declare that match types themselves don't have a stable
erasure, just like TypeBounds don't have a stable erasure. If we find an applied
type with a match type as definition, we proceed to its translucent superytype,
which will try a match type reduction. If that succeeds we produce the classtag
of the redux. If not, we end up with an unreduced matchtype and refuse to generate
a classtag for it.

Fixes #16706
Fixes #16707
---
 .../src/dotty/tools/dotc/core/TypeErasure.scala |  5 +++--
 compiler/src/dotty/tools/dotc/core/Types.scala  |  2 +-
 .../dotty/tools/dotc/typer/Synthesizer.scala    |  9 +--------
 tests/neg/i15618.check                          |  6 ++++++
 tests/neg/i15618.scala                          |  8 ++++++++
 tests/pos/i16706.scala                          | 17 +++++++++++++++++
 tests/pos/i16707.scala                          | 11 +++++++++++
 7 files changed, 47 insertions(+), 11 deletions(-)
 create mode 100644 tests/pos/i16706.scala
 create mode 100644 tests/pos/i16707.scala

diff --git a/compiler/src/dotty/tools/dotc/core/TypeErasure.scala b/compiler/src/dotty/tools/dotc/core/TypeErasure.scala
index 0e67fd40991b..67839d10c8cd 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeErasure.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeErasure.scala
@@ -520,8 +520,9 @@ object TypeErasure {
         case _: ClassInfo => true
         case _ => false
       }
-    case tp: TypeParamRef => false
-    case tp: TypeBounds => false
+    case _: TypeParamRef => false
+    case _: TypeBounds => false
+    case _: MatchType => 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)
diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index 0c5614e29a60..78364a3d21f0 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -1071,7 +1071,7 @@ object Types {
      *  @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
-     * 
+     *
      *  @param isSubType      a function used for checking subtype relationships.
      */
     final def overrides(that: Type, relaxedCheck: Boolean, matchLoosely: => Boolean, checkClassInfo: Boolean = true,
diff --git a/compiler/src/dotty/tools/dotc/typer/Synthesizer.scala b/compiler/src/dotty/tools/dotc/typer/Synthesizer.scala
index 71efc27bf673..1a7a4b97855b 100644
--- a/compiler/src/dotty/tools/dotc/typer/Synthesizer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Synthesizer.scala
@@ -52,14 +52,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
             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)
+              val ctype = escapeJavaArray(erasure(tp))
               if ctype.exists then
                 classTagModul.select(nme.apply)
                   .appliedToType(tp)
diff --git a/tests/neg/i15618.check b/tests/neg/i15618.check
index 91f557b12dcf..16fadcd9b886 100644
--- a/tests/neg/i15618.check
+++ b/tests/neg/i15618.check
@@ -16,3 +16,9 @@
    |
    |                                                case Float32 => Float
    |                                                case Int32 => Int
+-- [E172] Type Error: tests/neg/i15618.scala:21:33 ---------------------------------------------------------------------
+21 |  def toArray: Array[T] = Array() // error
+   |                                 ^
+   |                                 No ClassTag available for T
+   |
+   |                                 where:    T is a type in class Tensor2 with bounds <: Int | Float
diff --git a/tests/neg/i15618.scala b/tests/neg/i15618.scala
index fd38c8c48f6b..087bc462b211 100644
--- a/tests/neg/i15618.scala
+++ b/tests/neg/i15618.scala
@@ -16,8 +16,16 @@ class Tensor[T <: DType](dtype: T):
   def toSeq: Seq[ScalaType[T]] = Seq()
   def toArray: Array[ScalaType[T]] = Array() // error
 
+class Tensor2[T <: Int | Float](dtype: T):
+  def toSeq: Seq[T] = Seq()
+  def toArray: Array[T] = Array() // error
+
 @main
 def Test =
   val t = Tensor(Float32) // Tensor[Float32]
   println(t.toSeq.headOption) // works, Seq[Float]
   println(t.toArray.headOption) // ClassCastException
+
+  val t2 = Tensor2(0.0f) // Tensor2[Float]
+  println(t.toSeq.headOption)
+  println(t.toArray.headOption)
diff --git a/tests/pos/i16706.scala b/tests/pos/i16706.scala
new file mode 100644
index 000000000000..87fd015c69bb
--- /dev/null
+++ b/tests/pos/i16706.scala
@@ -0,0 +1,17 @@
+import scala.deriving.Mirror
+import scala.reflect.ClassTag
+
+type TupleUnionLub[T <: Tuple, Lub, Acc <: Lub] <: Lub = T match {
+  case (h & Lub) *: t => TupleUnionLub[t, Lub, Acc | h]
+  case EmptyTuple     => Acc
+}
+
+transparent inline given derived[A](
+    using m: Mirror.SumOf[A],
+    idClassTag: ClassTag[TupleUnionLub[m.MirroredElemTypes, A, Nothing]]
+): Unit = ()
+
+sealed trait Foo
+case class FooA(a: Int) extends Foo
+
+val instance = derived[Foo] // error
\ No newline at end of file
diff --git a/tests/pos/i16707.scala b/tests/pos/i16707.scala
new file mode 100644
index 000000000000..6181471f5246
--- /dev/null
+++ b/tests/pos/i16707.scala
@@ -0,0 +1,11 @@
+import scala.deriving.Mirror
+import scala.reflect.ClassTag
+
+transparent inline given derived[A](
+      using m: Mirror.ProductOf[A],
+      idClassTag: ClassTag[Tuple.Union[m.MirroredElemTypes]]
+  ): Unit = ???
+
+case class Foo(a: Int)
+
+val instance = derived[Foo] // error

From db2d3eb9d04dc10f8db8649541d73059b2d91f3b Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 17 Jan 2023 14:04:17 +0100
Subject: [PATCH 011/657] Support beta reduction of functions with opaque types

---
 .../tools/dotc/transform/BetaReduce.scala     |  2 ++
 .../backend/jvm/InlineBytecodeTests.scala     | 31 +++++++++++++++++++
 2 files changed, 33 insertions(+)

diff --git a/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala b/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala
index bdfd4ec76515..97dc4697db6d 100644
--- a/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala
+++ b/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala
@@ -86,6 +86,8 @@ object BetaReduce:
         recur(expr, argss).map(cpy.Inlined(fn)(call, bindings, _))
       case Typed(expr, tpt) =>
         recur(expr, argss)
+      case TypeApply(Select(expr, nme.asInstanceOfPM), List(tpt)) =>
+        recur(expr, argss)
       case _ => None
     tree match
       case Apply(Select(fn, nme.apply), args) if defn.isFunctionType(fn.tpe) =>
diff --git a/compiler/test/dotty/tools/backend/jvm/InlineBytecodeTests.scala b/compiler/test/dotty/tools/backend/jvm/InlineBytecodeTests.scala
index a9cec06880a2..5f9318c0c3f0 100644
--- a/compiler/test/dotty/tools/backend/jvm/InlineBytecodeTests.scala
+++ b/compiler/test/dotty/tools/backend/jvm/InlineBytecodeTests.scala
@@ -608,6 +608,37 @@ class InlineBytecodeTests extends DottyBytecodeTest {
     }
   }
 
+  @Test def beta_reduce_function_of_opaque_types = {
+    val source = """object foo:
+                   |  opaque type T = Int
+                   |  inline def apply(inline op: T => T): T = op(2)
+                   |
+                   |class Test:
+                   | def test = foo { n => n }
+                 """.stripMargin
+
+    checkBCode(source) { dir =>
+      val clsIn      = dir.lookupName("Test.class", directory = false).input
+      val clsNode    = loadClassNode(clsIn)
+
+      val fun = getMethod(clsNode, "test")
+      val instructions = instructionsFromMethod(fun)
+      val expected =
+        List(
+          Field(GETSTATIC, "foo$", "MODULE$", "Lfoo$;"),
+          VarOp(ASTORE, 1),
+          VarOp(ALOAD, 1),
+          VarOp(ASTORE, 2),
+          Op(ICONST_2),
+          Op(IRETURN),
+        )
+
+      assert(instructions == expected,
+        "`i was not properly beta-reduced in `test`\n" + diffInstructions(instructions, expected))
+
+    }
+  }
+
   @Test def i9456 = {
     val source = """class Foo {
                    |  def test: Int = inline2(inline1(2.+))

From b439deb62cf76f56ea9edbbcd709b9411dda2b98 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Thu, 19 Jan 2023 21:56:53 +0000
Subject: [PATCH 012/657] Don't capture wildcards if in closure or by-name

---
 .../src/dotty/tools/dotc/core/Types.scala     |  2 ++
 .../dotty/tools/dotc/typer/ProtoTypes.scala   | 10 ++++++++-
 .../src/dotty/tools/dotc/typer/Typer.scala    |  4 ++++
 tests/neg/t9419.scala                         | 22 +++++++++++++++++++
 4 files changed, 37 insertions(+), 1 deletion(-)
 create mode 100644 tests/neg/t9419.scala

diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index 0c5614e29a60..403fe7021152 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -4470,6 +4470,8 @@ object Types {
 
     def hasWildcardArg(using Context): Boolean = args.exists(isBounds)
 
+    def hasCaptureConversionArg(using Context): Boolean = args.exists(_.typeSymbol == defn.TypeBox_CAP)
+
     def derivedAppliedType(tycon: Type, args: List[Type])(using Context): Type =
       if ((tycon eq this.tycon) && (args eq this.args)) this
       else tycon.appliedTo(args)
diff --git a/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala b/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
index 8ba842ad695f..53c4022417a3 100644
--- a/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
+++ b/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
@@ -13,6 +13,7 @@ import Decorators._
 import Uniques._
 import inlines.Inlines
 import config.Printers.typr
+import ErrorReporting.*
 import util.SourceFile
 import TypeComparer.necessarySubType
 
@@ -492,7 +493,14 @@ object ProtoTypes {
       val targ = cacheTypedArg(arg,
         typer.typedUnadapted(_, wideFormal, locked)(using argCtx),
         force = true)
-      typer.adapt(targ, wideFormal, locked)
+      val targ1 = typer.adapt(targ, wideFormal, locked)
+      if wideFormal eq formal then targ1
+      else targ1.tpe match
+        case tp: AppliedType if tp.hasCaptureConversionArg =>
+          errorTree(targ1,
+            em"""argument for by-name parameter contains capture conversion skolem types:
+                |$tp""")
+        case _ => targ1
     }
 
     /** The type of the argument `arg`, or `NoType` if `arg` has not been typed before
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 3384c27c0194..54eb8bc2ab1e 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -1568,6 +1568,10 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
                 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 if mt.resType.match { case tp: AppliedType => tp.hasCaptureConversionArg case _ => false } then
+                  errorTree(tree,
+                    em"""cannot turn method type $mt into closure
+                        |because it has capture conversion skolem types""")
                 else
                   EmptyTree
             }
diff --git a/tests/neg/t9419.scala b/tests/neg/t9419.scala
new file mode 100644
index 000000000000..75534e8311c6
--- /dev/null
+++ b/tests/neg/t9419.scala
@@ -0,0 +1,22 @@
+trait Magic[S]:
+  def init: S
+  def step(s: S): String
+
+object IntMagic extends Magic[Int]:
+  def init = 0
+  def step(s: Int): String = (s - 1).toString
+
+object StrMagic extends Magic[String]:
+  def init = "hi"
+  def step(s: String): String = s.reverse
+
+object Main:
+  def onestep[T](m: () => Magic[T]): String = m().step(m().init)
+  def unostep[T](m:    => Magic[T]): String = m.step(m.init)
+
+  val iter: Iterator[Magic[?]] = Iterator(IntMagic, StrMagic)
+
+  // was: class java.lang.String cannot be cast to class java.lang.Integer
+  def main(args: Array[String]): Unit =
+    onestep(() => iter.next()) // error
+    unostep(iter.next())       // error

From df0d9eadf789b1315a1c73522c5642127cdbdeff Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Thu, 17 Nov 2022 15:51:15 +0100
Subject: [PATCH 013/657] Disallow local term references in staged types

Fixes #16355
Fixes #15917
---
 .../dotc/transform/PCPCheckAndHeal.scala      |  8 +++--
 tests/neg-macros/i15917.scala                 |  6 ++++
 tests/neg-macros/i16355a.scala                | 35 +++++++++++++++++++
 tests/neg-macros/i16355b.scala                |  4 +++
 4 files changed, 51 insertions(+), 2 deletions(-)
 create mode 100644 tests/neg-macros/i15917.scala
 create mode 100644 tests/neg-macros/i16355a.scala
 create mode 100644 tests/neg-macros/i16355b.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala b/compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala
index 1d0ed035df09..4669dc86982d 100644
--- a/compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala
@@ -176,8 +176,10 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
   /** 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 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 higher level, then it is inconsistent.
+   *    It can not be healed because the term will not exists in the any future stage.
    *
    *  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]`.
@@ -206,6 +208,8 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
               tryHeal(prefix.symbol, tp, pos)
             case _ =>
               mapOver(tp)
+        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 =>
diff --git a/tests/neg-macros/i15917.scala b/tests/neg-macros/i15917.scala
new file mode 100644
index 000000000000..3eecc38b21f9
--- /dev/null
+++ b/tests/neg-macros/i15917.scala
@@ -0,0 +1,6 @@
+import scala.quoted.*
+
+def m(using Quotes): Expr[Option[_]] =
+  val s = 3
+  type st = s.type
+  '{ Some(${ Expr(s) }: st) } // error
diff --git a/tests/neg-macros/i16355a.scala b/tests/neg-macros/i16355a.scala
new file mode 100644
index 000000000000..8870b7777263
--- /dev/null
+++ b/tests/neg-macros/i16355a.scala
@@ -0,0 +1,35 @@
+//> using scala "3.2.1"
+import scala.quoted.Expr
+import scala.quoted.Type
+import scala.quoted.quotes
+import scala.quoted.Quotes
+
+object macros {
+
+  inline transparent def mkNames[A]: List[Any] = ${ mkNamesImpl[A] }
+
+  def mkNamesImpl[A: Type](using Quotes): Expr[List[Any]] = {
+    import quotes.reflect._
+
+    val fieldNames = TypeRepr.of[A].typeSymbol.declaredFields.map(_.name)
+
+    val types = fieldNames
+      .map { f =>
+        val t1 = ConstantType(StringConstant(f))
+        t1.asType match {
+          case '[t1Type] => TypeRepr.of[(t1Type, "aa")]
+        }
+      }
+      .reduceLeft[TypeRepr](OrType(_, _))
+
+    types.asType match {
+      case '[ttt] =>
+        Expr.ofList[ttt](
+          fieldNames.map { v =>
+            Expr[(v.type, "aa")](v -> "aa").asExprOf[ttt] // error
+          }
+        )
+    }
+  }
+
+}
diff --git a/tests/neg-macros/i16355b.scala b/tests/neg-macros/i16355b.scala
new file mode 100644
index 000000000000..763810979ddf
--- /dev/null
+++ b/tests/neg-macros/i16355b.scala
@@ -0,0 +1,4 @@
+import scala.quoted._
+def test(v: String)(using Quotes): Any =
+  Type.of : Type[v.type] // error
+  Type.of[v.type] // error

From 0893dc39cb243d95bbb7337b25f53fce48c316a1 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Fri, 20 Jan 2023 10:05:03 +0000
Subject: [PATCH 014/657] Allow wildcard capture of by-name values

---
 .../dotty/tools/dotc/typer/ProtoTypes.scala   | 12 ++++++++---
 tests/neg/t9419.scala                         |  4 +++-
 tests/pos/t9419.jackson.scala                 | 20 +++++++++++++++++++
 3 files changed, 32 insertions(+), 4 deletions(-)
 create mode 100644 tests/pos/t9419.jackson.scala

diff --git a/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala b/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
index 53c4022417a3..170d12b998de 100644
--- a/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
+++ b/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
@@ -497,9 +497,15 @@ object ProtoTypes {
       if wideFormal eq formal then targ1
       else targ1.tpe match
         case tp: AppliedType if tp.hasCaptureConversionArg =>
-          errorTree(targ1,
-            em"""argument for by-name parameter contains capture conversion skolem types:
-                |$tp""")
+          stripCast(targ1).tpe match
+            case tp: AppliedType if tp.hasWildcardArg =>
+              errorTree(targ1,
+                em"""argument for by-name parameter is not a value
+                    |and contains wildcard arguments: $tp
+                    |
+                    |Assign it to a val and pass that instead.
+                    |""")
+            case _ => targ1
         case _ => targ1
     }
 
diff --git a/tests/neg/t9419.scala b/tests/neg/t9419.scala
index 75534e8311c6..e9358c0ba641 100644
--- a/tests/neg/t9419.scala
+++ b/tests/neg/t9419.scala
@@ -14,9 +14,11 @@ object Main:
   def onestep[T](m: () => Magic[T]): String = m().step(m().init)
   def unostep[T](m:    => Magic[T]): String = m.step(m.init)
 
-  val iter: Iterator[Magic[?]] = Iterator(IntMagic, StrMagic)
+  val iter: Iterator[Magic[?]] = Iterator.tabulate(Int.MaxValue)(i => if i % 2 == 0 then IntMagic else StrMagic)
 
   // was: class java.lang.String cannot be cast to class java.lang.Integer
   def main(args: Array[String]): Unit =
     onestep(() => iter.next()) // error
     unostep(iter.next())       // error
+    val m = iter.next()
+    unostep(m)                 // ok, because m is a value
diff --git a/tests/pos/t9419.jackson.scala b/tests/pos/t9419.jackson.scala
new file mode 100644
index 000000000000..bf26c7e4c672
--- /dev/null
+++ b/tests/pos/t9419.jackson.scala
@@ -0,0 +1,20 @@
+// from failure in the community project
+// jackson-module-scala
+// in ScalaAnnotationIntrospectorModule.scala:139:12
+
+import scala.language.implicitConversions
+
+trait EnrichedType[X]:
+  def value: X
+
+trait ClassW extends EnrichedType[Class[_]]:
+  def extendsScalaClass = false
+
+class Test:
+  implicit def mkClassW(c: => Class[_]): ClassW = new ClassW:
+    lazy val value = c
+
+  def test1(c1: Class[_]) = c1.extendsScalaClass           // ok: c1 is a value
+  def test2(c2: Class[_]) = mkClassW(c2).extendsScalaClass // ok: c2 is a value
+  // c1 in test1 goes throw adapting to find the extension method and gains the wildcard capture cast then
+  // c2 in test2 goes straight to typedArg, as it's already an arg, so it never gets wildcard captured

From d3f4770c2e9157e96fa8a0f755457615681d1cd1 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Fri, 20 Jan 2023 15:38:13 +0100
Subject: [PATCH 015/657] -Xcheck-macros: add hint when a symbol in created
 twice

Closes #16363
---
 .../src/scala/quoted/runtime/impl/QuotesImpl.scala  | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
index dd6471a882bd..7f90b018bea0 100644
--- a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
+++ b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
@@ -2973,12 +2973,16 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
           t match
             case t: tpd.DefTree =>
               val defOwner = t.symbol.owner
-              assert(defOwner == owner,
+              assert(defOwner == owner, {
+                val ownerName = owner.fullName
+                val defOwnerName = defOwner.fullName
+                val duplicateSymbolHint =
+                  if ownerName == defOwnerName then "These are two different symbols instances with the same name. The symbol should have been instantiated only once.\n"
+                  else ""
                 s"""Tree had an unexpected owner for ${t.symbol}
                    |Expected: $owner (${owner.fullName})
                    |But was: $defOwner (${defOwner.fullName})
-                   |
-                   |
+                   |$duplicateSymbolHint
                    |The code of the definition of ${t.symbol} is
                    |${Printer.TreeCode.show(t)}
                    |
@@ -2992,7 +2996,8 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
                    |
                    |Tip: The owner of a tree can be changed using method `Tree.changeOwner`.
                    |Tip: The default owner of definitions created in quotes can be changed using method `Symbol.asQuotes`.
-                   |""".stripMargin)
+                   |""".stripMargin
+              })
             case _ => traverseChildren(t)
       }.traverse(tree)
 

From ea13cad629f85cb3156753dc784e4af0438d0167 Mon Sep 17 00:00:00 2001
From: ysthakur <45539777+ysthakur@users.noreply.github.com>
Date: Fri, 20 Jan 2023 15:53:55 -0500
Subject: [PATCH 016/657] Search for Conversions if implicit search fails

---
 compiler/src/dotty/tools/dotc/reporting/messages.scala | 8 +++++++-
 compiler/src/dotty/tools/dotc/typer/Implicits.scala    | 9 ++++++++-
 2 files changed, 15 insertions(+), 2 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/reporting/messages.scala b/compiler/src/dotty/tools/dotc/reporting/messages.scala
index e8029d790d0a..692e72d504ad 100644
--- a/compiler/src/dotty/tools/dotc/reporting/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/messages.scala
@@ -2554,7 +2554,8 @@ class MissingImplicitArgument(
     pt: Type,
     where: String,
     paramSymWithMethodCallTree: Option[(Symbol, tpd.Tree)] = None,
-    ignoredInstanceNormalImport: => Option[SearchSuccess]
+    ignoredInstanceNormalImport: => Option[SearchSuccess],
+    ignoredConversions: => Set[SearchSuccess]
   )(using Context) extends TypeMsg(MissingImplicitArgumentID), ShowMatchTrace(pt):
 
   arg.tpe match
@@ -2743,8 +2744,13 @@ class MissingImplicitArgument(
         // 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`."
+        def noChainConversionsNote(s: Set[SearchSuccess]): Option[String] =
+          Option.when(s.isEmpty)(
+              i"\n\nNote: Chaining implicit conversions is no longer allowed in Scala. The following conversions were ignored: ${s.map(_.ref.symbol.showLocated).mkString("\n")}"
+          )
         super.msgPostscript
         ++ ignoredInstanceNormalImport.map(hiddenImplicitNote)
+            .orElse(noChainConversionsNote(ignoredConversions))
             .getOrElse(ctx.typer.importSuggestionAddendum(pt))
 
   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 3e0e7dd5879d..f373e0563154 100644
--- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -923,7 +923,14 @@ trait Implicits:
           // example where searching for a nested type causes an infinite loop.
           None
 
-    MissingImplicitArgument(arg, pt, where, paramSymWithMethodCallTree, ignoredInstanceNormalImport)
+    def ignoredConversions = arg.tpe match
+      case fail: SearchFailureType =>
+        if (fail.expectedType eq pt) || isFullyDefined(fail.expectedType, ForceDegree.none) then
+          ImplicitSearch(fail.expectedType, dummyTreeOfType(WildcardType), arg.span).allImplicits
+        else
+          Set.empty
+
+    MissingImplicitArgument(arg, pt, where, paramSymWithMethodCallTree, ignoredInstanceNormalImport, ignoredConversions)
   }
 
   /** A string indicating the formal parameter corresponding to a  missing argument */

From fc9acd7fbd37c1e84bc178dab86f1cd0779f2caf Mon Sep 17 00:00:00 2001
From: ysthakur <45539777+ysthakur@users.noreply.github.com>
Date: Fri, 20 Jan 2023 18:47:16 -0500
Subject: [PATCH 017/657] Use ctx.implicits.eligible directly

---
 .../src/dotty/tools/dotc/reporting/messages.scala     |  8 ++++----
 compiler/src/dotty/tools/dotc/typer/Implicits.scala   |  5 +++--
 compiler/test/dotty/tools/dotc/CompilationTests.scala |  1 +
 tests/neg/i16453.check                                |  7 +++++++
 tests/neg/i16453.scala                                | 11 +++++++++++
 5 files changed, 26 insertions(+), 6 deletions(-)
 create mode 100644 tests/neg/i16453.check
 create mode 100644 tests/neg/i16453.scala

diff --git a/compiler/src/dotty/tools/dotc/reporting/messages.scala b/compiler/src/dotty/tools/dotc/reporting/messages.scala
index 692e72d504ad..cca5dae293e2 100644
--- a/compiler/src/dotty/tools/dotc/reporting/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/messages.scala
@@ -2555,7 +2555,7 @@ class MissingImplicitArgument(
     where: String,
     paramSymWithMethodCallTree: Option[(Symbol, tpd.Tree)] = None,
     ignoredInstanceNormalImport: => Option[SearchSuccess],
-    ignoredConversions: => Set[SearchSuccess]
+    ignoredConversions: => Iterable[TermRef]
   )(using Context) extends TypeMsg(MissingImplicitArgumentID), ShowMatchTrace(pt):
 
   arg.tpe match
@@ -2744,9 +2744,9 @@ class MissingImplicitArgument(
         // 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`."
-        def noChainConversionsNote(s: Set[SearchSuccess]): Option[String] =
-          Option.when(s.isEmpty)(
-              i"\n\nNote: Chaining implicit conversions is no longer allowed in Scala. The following conversions were ignored: ${s.map(_.ref.symbol.showLocated).mkString("\n")}"
+        def noChainConversionsNote(s: Iterable[TermRef]): Option[String] =
+          Option.when(s.nonEmpty)(
+              i"\n\nNote: Chaining implicit conversions is no longer allowed in Scala. The following conversions were ignored:${s.map(g => "\n  - " + g.symbol.showLocated).mkString}"
           )
         super.msgPostscript
         ++ ignoredInstanceNormalImport.map(hiddenImplicitNote)
diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
index f373e0563154..f723a18eb241 100644
--- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -926,9 +926,10 @@ trait Implicits:
     def ignoredConversions = arg.tpe match
       case fail: SearchFailureType =>
         if (fail.expectedType eq pt) || isFullyDefined(fail.expectedType, ForceDegree.none) then
-          ImplicitSearch(fail.expectedType, dummyTreeOfType(WildcardType), arg.span).allImplicits
+          ctx.implicits.eligible(ViewProto(WildcardType, wildApprox(fail.expectedType)))
+            .collect { case c if c.isConversion => c.ref }
         else
-          Set.empty
+          Nil
 
     MissingImplicitArgument(arg, pt, where, paramSymWithMethodCallTree, ignoredInstanceNormalImport, ignoredConversions)
   }
diff --git a/compiler/test/dotty/tools/dotc/CompilationTests.scala b/compiler/test/dotty/tools/dotc/CompilationTests.scala
index b8b38cce92e4..0346662b5434 100644
--- a/compiler/test/dotty/tools/dotc/CompilationTests.scala
+++ b/compiler/test/dotty/tools/dotc/CompilationTests.scala
@@ -188,6 +188,7 @@ class CompilationTests {
       compileFile("tests/neg-custom-args/i13026.scala", defaultOptions.and("-print-lines")),
       compileFile("tests/neg-custom-args/i13838.scala", defaultOptions.and("-Ximplicit-search-limit", "1000")),
       compileFile("tests/neg-custom-args/jdk-9-app.scala", defaultOptions.and("-release:8")),
+      compileFile("tests/neg/i16453.scala", defaultOptions),
     ).checkExpectedErrors()
   }
 
diff --git a/tests/neg/i16453.check b/tests/neg/i16453.check
new file mode 100644
index 000000000000..76fe7330e3b9
--- /dev/null
+++ b/tests/neg/i16453.check
@@ -0,0 +1,7 @@
+-- [E172] Type Error: tests/neg/i16453.scala:10:43 ---------------------------------------------------------------------
+10 |  val fails = summon[String => Option[Int]] // error
+   |                                           ^
+   |     No given instance of type String => Option[Int] was found for parameter x of method summon in object Predef
+   |
+   |     Note: Chaining implicit conversions is no longer allowed in Scala. The following conversions were ignored:
+   |       - given instance given_Conversion_Function_Function
diff --git a/tests/neg/i16453.scala b/tests/neg/i16453.scala
new file mode 100644
index 000000000000..b60c174e4077
--- /dev/null
+++ b/tests/neg/i16453.scala
@@ -0,0 +1,11 @@
+import scala.language.implicitConversions
+
+given [T]: Conversion[String => T, String => Option[T]] = ???
+// This one is irrelevant, shouldn't be included in error message
+given irrelevant[T]: Conversion[String => T, String => Byte] = ???
+
+def test() = {
+  given foo: (String => Int) = _ => 42
+
+  val fails = summon[String => Option[Int]] // error
+}

From 393dab4f93c64766149abfa822c8a8947d3eb766 Mon Sep 17 00:00:00 2001
From: ysthakur <45539777+ysthakur@users.noreply.github.com>
Date: Fri, 20 Jan 2023 19:23:12 -0500
Subject: [PATCH 018/657] Use symbol.showDcl, add sentence on explicitly
 passing arg

---
 compiler/src/dotty/tools/dotc/reporting/messages.scala | 4 +++-
 tests/neg/i16453.check                                 | 7 ++++---
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/reporting/messages.scala b/compiler/src/dotty/tools/dotc/reporting/messages.scala
index cca5dae293e2..be5b4c16d170 100644
--- a/compiler/src/dotty/tools/dotc/reporting/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/messages.scala
@@ -2746,7 +2746,9 @@ class MissingImplicitArgument(
           i"\n\nNote: ${s.ref.symbol.showLocated} was not considered because it was not imported with `import given`."
         def noChainConversionsNote(s: Iterable[TermRef]): Option[String] =
           Option.when(s.nonEmpty)(
-              i"\n\nNote: Chaining implicit conversions is no longer allowed in Scala. The following conversions were ignored:${s.map(g => "\n  - " + g.symbol.showLocated).mkString}"
+              i"\n\nNote: Chaining implicit conversions is no longer allowed in Scala. " +
+              i"The following conversions were ignored:${s.map(g => s"\n  - ${g.symbol.showDcl}").mkString}" +
+              i"\nIf there is an implicit `Conversion[A, ${pt.show}]` and an implicit `A` in scope, you need to explicitly pass the argument, e.g. `(using summon[A])`"
           )
         super.msgPostscript
         ++ ignoredInstanceNormalImport.map(hiddenImplicitNote)
diff --git a/tests/neg/i16453.check b/tests/neg/i16453.check
index 76fe7330e3b9..871df3b6d7d2 100644
--- a/tests/neg/i16453.check
+++ b/tests/neg/i16453.check
@@ -1,7 +1,8 @@
 -- [E172] Type Error: tests/neg/i16453.scala:10:43 ---------------------------------------------------------------------
 10 |  val fails = summon[String => Option[Int]] // error
    |                                           ^
-   |     No given instance of type String => Option[Int] was found for parameter x of method summon in object Predef
+   |No given instance of type String => Option[Int] was found for parameter x of method summon in object Predef
    |
-   |     Note: Chaining implicit conversions is no longer allowed in Scala. The following conversions were ignored:
-   |       - given instance given_Conversion_Function_Function
+   |Note: Chaining implicit conversions is no longer allowed in Scala. The following conversions were ignored:
+   |  - final given def given_Conversion_Function_Function[T]: Conversion[String => T, String => Option[T]]
+   |If there is an implicit `Conversion[A, String => Option[Int]]` and an implicit `A` in scope, you need to explicitly pass the argument, e.g. `(using summon[A])`

From c73c47aabc7130098fc1712a7c7732f2d5392718 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Sun, 22 Jan 2023 18:21:23 +0000
Subject: [PATCH 019/657] Fix upper bound constraints, that are higher-kinded

When recording an upper bound, when it's a some higher-kinded type
variable applied to some type arguments, TypeComparer was re-applying
the type arguments to the type parameter (the type variable's origin).
Meaning that the instantiation of the type variable won't reflect in the
upper bound.

See the error message: `F$1[Int]` correctly appears as the lower bound,
but `F$1[Int]` isn't the upper bound, `F[Int]` is, which is the original
type parameter, in `Foo.Bar.apply[F](..)`.

    -- [E007] Type Mismatch Error: i12478.scala:8:13 -------------------------------
    8 |      Foo.Bar(fu1)
      |      ^^^^^^^^^^^^
      |Found:    Foo.Bar[F$1]
      |Required: Foo[T1]
      |
      |where:    F$1 is a type in method id1 with bounds <: [_] =>> Any
      |          T1  is a type in method id1 with bounds >: F$1[Int] and <: F[Int]
      |
      | longer explanation available when compiling with `-explain`
    -- [E007] Type Mismatch Error: i12478.scala:18:13 ------------------------------
    18 |      Foo.Bar(fu3)
       |      ^^^^^^^^^^^^
       |Found:    Foo.Bar[F$2]
       |Required: Foo[T3]
       |
       |where:    F$2 is a type in method id3 with bounds <: [_] =>> Any
       |          T3  is a type in method id3 with bounds >: F$2[Int] and <: F[Int]
       |
       | longer explanation available when compiling with `-explain`
---
 .../dotty/tools/dotc/core/TypeComparer.scala  |  7 +++++--
 tests/pos/i12478.scala                        | 19 +++++++++++++++++++
 2 files changed, 24 insertions(+), 2 deletions(-)
 create mode 100644 tests/pos/i12478.scala

diff --git a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
index a0eb5139eb07..cf2507aa1724 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
@@ -1338,8 +1338,11 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
             }
           } || tryLiftedToThis2
 
-        case _: TypeVar =>
-          recur(tp1, tp2.superType)
+        case tv: TypeVar =>
+          if tv.isInstantiated then
+            recur(tp1, tp2.superType)
+          else
+            compareAppliedType2(tp2, tv.origin, args2)
         case tycon2: AnnotatedType if !tycon2.isRefining =>
           recur(tp1, tp2.superType)
         case tycon2: AppliedType =>
diff --git a/tests/pos/i12478.scala b/tests/pos/i12478.scala
new file mode 100644
index 000000000000..d1e247ae4e68
--- /dev/null
+++ b/tests/pos/i12478.scala
@@ -0,0 +1,19 @@
+sealed trait Foo[T]
+
+object Foo:
+  case class Bar[F[_]](fu: List[F[Unit]]) extends Foo[F[Unit]]
+
+class Test:
+  def id1[T1](foo1: Foo[T1]): Foo[T1] = foo1 match
+    case Foo.Bar(fu) =>
+      Foo.Bar(fu)
+
+  def id2[T2](foo2: Foo[T2]): Foo[T2] = foo2 match
+    case bar2 @ (_: Foo.Bar[f]) =>
+      val fu2 = bar2.fu
+      Foo.Bar(fu2)
+
+  def id3[T3](foo3: Foo[T3]): Foo[T3] = foo3 match
+    case bar3 @ Foo.Bar(_) =>
+      val fu3 = bar3.fu
+      Foo.Bar(fu3)

From 3e9bb9f2361c52e8cc56254d9af6f6051dfcba15 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 23 Jan 2023 09:22:22 +0100
Subject: [PATCH 020/657] Improve `New`/`Select` -Ycheck message

We mention that the constructor must be selected. This should be all the
information needed in case someone writes a buggy macro that does not
include the `Select` around the `New`.

Closed #16357
---
 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 4573c40df78b..2daac7cdd604 100644
--- a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
@@ -141,7 +141,7 @@ class TreeChecker extends Phase with SymTransformer {
       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}")
+            assert(assertion = false, i"`New` node must be wrapped in a `Select` of the constructor:\n  parent = ${parent.show}\n  child = ${tree.show}")
           case _: Annotated =>
             // Don't check inside annotations, since they're allowed to contain
             // somewhat invalid trees.

From ad4abbafe5e05901df49518f3f99c8dba9a079b3 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 23 Jan 2023 11:15:53 +0100
Subject: [PATCH 021/657] Improve error message for CyclicReference in macros

Closes #16582
---
 .../dotty/tools/dotc/quoted/Interpreter.scala |  9 +++++-
 tests/neg-macros/i16582.check                 | 15 ++++++++++
 tests/neg-macros/i16582/Macro_1.scala         | 29 +++++++++++++++++++
 tests/neg-macros/i16582/Test_2.scala          |  6 ++++
 4 files changed, 58 insertions(+), 1 deletion(-)
 create mode 100644 tests/neg-macros/i16582.check
 create mode 100644 tests/neg-macros/i16582/Macro_1.scala
 create mode 100644 tests/neg-macros/i16582/Test_2.scala

diff --git a/compiler/src/dotty/tools/dotc/quoted/Interpreter.scala b/compiler/src/dotty/tools/dotc/quoted/Interpreter.scala
index 38cecb7953b8..8920b99b902c 100644
--- a/compiler/src/dotty/tools/dotc/quoted/Interpreter.scala
+++ b/compiler/src/dotty/tools/dotc/quoted/Interpreter.scala
@@ -30,6 +30,7 @@ import dotty.tools.dotc.typer.ImportInfo.withRootImports
 import dotty.tools.dotc.util.SrcPos
 import dotty.tools.dotc.reporting.Message
 import dotty.tools.repl.AbstractFileClassLoader
+import dotty.tools.dotc.core.CyclicReference
 
 /** Tree interpreter for metaprogramming constructs */
 class Interpreter(pos: SrcPos, classLoader: ClassLoader)(using Context):
@@ -253,8 +254,14 @@ class Interpreter(pos: SrcPos, classLoader: ClassLoader)(using Context):
               }
               val shortStackTrace = targetException.getStackTrace.take(end + 1)
               targetException.setStackTrace(shortStackTrace)
+              targetException.printStackTrace(new PrintWriter(sw))
+
+              targetException match
+                case _: CyclicReference => sw.write("\nSee full stack trace using -Ydebug")
+                case _ =>
+            } else {
+              targetException.printStackTrace(new PrintWriter(sw))
             }
-            targetException.printStackTrace(new PrintWriter(sw))
             sw.write("\n")
             throw new StopInterpretation(sw.toString.toMessage, pos)
         }
diff --git a/tests/neg-macros/i16582.check b/tests/neg-macros/i16582.check
new file mode 100644
index 000000000000..c06fe0d9829f
--- /dev/null
+++ b/tests/neg-macros/i16582.check
@@ -0,0 +1,15 @@
+
+-- Error: tests/neg-macros/i16582/Test_2.scala:5:27 --------------------------------------------------------------------
+5 |  val o2 = ownerDoesNotWork(2) // error
+  |           ^^^^^^^^^^^^^^^^^^^
+  |           Exception occurred while executing macro expansion.
+  |           dotty.tools.dotc.core.CyclicReference: Recursive value o2 needs type
+  |
+  |           See full stack trace using -Ydebug
+  |---------------------------------------------------------------------------------------------------------------------
+  |Inline stack trace
+  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  |This location contains code that was inlined from Macro_1.scala:7
+7 |    ${ownerWorksImpl('in)}
+  |    ^^^^^^^^^^^^^^^^^^^^^^
+   ---------------------------------------------------------------------------------------------------------------------
diff --git a/tests/neg-macros/i16582/Macro_1.scala b/tests/neg-macros/i16582/Macro_1.scala
new file mode 100644
index 000000000000..dea58b89f017
--- /dev/null
+++ b/tests/neg-macros/i16582/Macro_1.scala
@@ -0,0 +1,29 @@
+import scala.quoted.*
+
+inline def ownerWorks(in: Int): Any =
+    ${ownerWorksImpl('in)}
+
+transparent inline def ownerDoesNotWork(in: Int): Any =
+    ${ownerWorksImpl('in)}
+
+def ownerWorksImpl(in: Expr[Int])(using Quotes): Expr[String] =
+  import quotes.reflect.*
+  val position = Position.ofMacroExpansion
+  val file = position.sourceFile
+  val owner0 = Symbol.spliceOwner.maybeOwner
+  println("owner0 = " + owner0)
+  val ownerName = owner0.tree match {
+    case ValDef(name, _, _) =>
+      name
+    case DefDef(name, _, _, _) =>
+      name
+    case t => report.errorAndAbort(s"unexpected tree shape: ${t.show}")
+  }
+  val path = file.path
+  val line = position.startLine
+  val column = position.startColumn
+  val v = in.valueOrAbort
+  val out = Expr(s"val $ownerName $v: $file @ ${position.startLine}")
+  out
+
+
diff --git a/tests/neg-macros/i16582/Test_2.scala b/tests/neg-macros/i16582/Test_2.scala
new file mode 100644
index 000000000000..7cfd65febd00
--- /dev/null
+++ b/tests/neg-macros/i16582/Test_2.scala
@@ -0,0 +1,6 @@
+def test=
+  val o1 = ownerWorks(1)
+  println(o1)
+
+  val o2 = ownerDoesNotWork(2) // error
+  println(o2)

From 94ff3c8a0d81de3ced9b60c4e50b63970f309094 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Mon, 23 Jan 2023 11:35:50 +0000
Subject: [PATCH 022/657] Fix & reuse printing of dummyTreeOfType

The main fix is the unsplice, which was making the pattern not match for
FunProto.  But also, when the tree is applied to the dummy, print the
dummy in the Apply node.  And print null as a constant literal.

Also, given AnyFunctionProto and AnyTypeConstructorProto shorter
toStrings.
---
 .../dotty/tools/dotc/printing/RefinedPrinter.scala  | 13 +++++++------
 .../src/dotty/tools/dotc/typer/ProtoTypes.scala     | 10 ++++++----
 2 files changed, 13 insertions(+), 10 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index 9a4b53d4112c..f94ff68d0698 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -3,6 +3,7 @@ package dotc
 package printing
 
 import core._
+import Constants.*
 import Texts._
 import Types._
 import Flags._
@@ -286,14 +287,10 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       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
+        ~ argsTreeText(args)
         ~ ") returning "
         ~ toText(resultType)
         ~ "]"
@@ -309,6 +306,10 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   protected def exprToText(tp: ExprType): Text =
     "=> " ~ toText(tp.resType)
 
+  protected def argsTreeText(args: List[untpd.Tree]): Text = args match
+    case dummyTreeOfType(tp) :: Nil if !tp.isRef(defn.NullClass) && !homogenizedView => toText(Constant(null)) ~ ": " ~ toText(tp)
+    case _                                                                           => toTextGlobal(args, ", ")
+
   protected def blockToText[T <: Untyped](block: Block[T]): Text =
     blockText(block.stats :+ block.expr)
 
@@ -442,7 +443,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           toTextLocal(fun)
           ~ "("
           ~ Str("using ").provided(app.applyKind == ApplyKind.Using && !homogenizedView)
-          ~ toTextGlobal(args, ", ")
+          ~ argsTreeText(args)
           ~ ")"
       case tree: TypeApply =>
         typeApplyText(tree)
diff --git a/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala b/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
index 8ba842ad695f..15da3c2ccc22 100644
--- a/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
+++ b/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
@@ -671,10 +671,12 @@ object ProtoTypes {
    *
    *    [] _
    */
-  @sharable object AnyFunctionProto extends UncachedGroundType with MatchAlways
+  @sharable object AnyFunctionProto extends UncachedGroundType with MatchAlways:
+    override def toString = "AnyFunctionProto"
 
   /** A prototype for type constructors that are followed by a type application */
-  @sharable object AnyTypeConstructorProto extends UncachedGroundType with MatchAlways
+  @sharable object AnyTypeConstructorProto extends UncachedGroundType with MatchAlways:
+    override def toString = "AnyTypeConstructorProto"
 
   extension (pt: Type)
     def isExtensionApplyProto: Boolean = pt match
@@ -946,8 +948,8 @@ object ProtoTypes {
   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)
+    def unapply(tree: untpd.Tree): Option[Type] = untpd.unsplice(tree) match {
+      case tree @ Literal(Constant(null)) => Some(tree.typeOpt)
       case _ => None
     }
   }

From ee44db864654d85bedbb380aa9ee62d74483a59e Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Mon, 23 Jan 2023 11:47:29 +0000
Subject: [PATCH 023/657] Fix early returns nested in trace

Found by enabling the tracing config.
---
 .../src/dotty/tools/dotc/transform/patmat/Space.scala |  5 +++--
 compiler/src/dotty/tools/dotc/typer/Implicits.scala   | 11 +++++------
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index 90310a385d0c..f4c4863d073d 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -489,9 +489,10 @@ class SpaceEngine(using Context) extends SpaceLogic {
   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
+      case tp @ AppliedType(tycon, args) if tycon.typeSymbol.isPatternBound =>
+        WildcardType
 
+      case tp @ AppliedType(tycon, args) =>
         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))
diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
index 3e0e7dd5879d..c04f9b990bc7 100644
--- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -1002,11 +1002,10 @@ trait Implicits:
         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 usableForInference = !pt.unusableForInference
+        && (argument.isEmpty || !argument.tpe.unusableForInference)
 
-      val result0 =
+      val result0 = if usableForInference then
         // 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
@@ -1023,7 +1022,7 @@ trait Implicits:
         catch case ce: CyclicReference =>
           ce.inImplicitSearch = true
           throw ce
-      end result0
+      else NoMatchingImplicitsFailure
 
       val result =
         result0 match {
@@ -1052,7 +1051,7 @@ trait Implicits:
                   result
               }
             else result
-          case NoMatchingImplicitsFailure =>
+          case NoMatchingImplicitsFailure if usableForInference =>
             SearchFailure(new NoMatchingImplicits(pt, argument, ctx.typerState.constraint), span)
           case _ =>
             result0

From 4e4bf207fd521f16d743d4bbe64d11f7cf076c9e Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 23 Jan 2023 17:18:16 +0100
Subject: [PATCH 024/657] Update
 compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala

Co-authored-by: Guillaume Martres <smarter@ubuntu.com>
---
 compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala b/compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala
index 4669dc86982d..e2e494a95074 100644
--- a/compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala
@@ -179,7 +179,7 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
    *  - 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 higher level, then it is inconsistent.
-   *    It can not be healed because the term will not exists in the any future stage.
+   *    It cannot be healed because the term will not exist in any future stage.
    *
    *  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]`.

From 29dc069a5cbf1b7ffadba03f1766e5205f795735 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Mon, 23 Jan 2023 16:31:28 +0000
Subject: [PATCH 025/657] Redefine hasCaptureConversionArg

---
 .../src/dotty/tools/dotc/core/Types.scala     |  2 --
 .../dotty/tools/dotc/typer/Inferencing.scala  |  4 +++
 .../dotty/tools/dotc/typer/ProtoTypes.scala   | 28 +++++++++++--------
 .../src/dotty/tools/dotc/typer/Typer.scala    |  2 +-
 4 files changed, 21 insertions(+), 15 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index 403fe7021152..0c5614e29a60 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -4470,8 +4470,6 @@ object Types {
 
     def hasWildcardArg(using Context): Boolean = args.exists(isBounds)
 
-    def hasCaptureConversionArg(using Context): Boolean = args.exists(_.typeSymbol == defn.TypeBox_CAP)
-
     def derivedAppliedType(tycon: Type, args: List[Type])(using Context): Type =
       if ((tycon eq this.tycon) && (args eq this.args)) this
       else tycon.appliedTo(args)
diff --git a/compiler/src/dotty/tools/dotc/typer/Inferencing.scala b/compiler/src/dotty/tools/dotc/typer/Inferencing.scala
index 656a1266d5ab..434e1c01849d 100644
--- a/compiler/src/dotty/tools/dotc/typer/Inferencing.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Inferencing.scala
@@ -546,6 +546,10 @@ object Inferencing {
     case tp: AnnotatedType => tp.derivedAnnotatedType(captureWildcards(tp.parent), tp.annot)
     case _ => tp
   }
+
+  def hasCaptureConversionArg(tp: Type)(using Context): Boolean = tp match
+    case tp: AppliedType => tp.args.exists(_.typeSymbol == defn.TypeBox_CAP)
+    case _ => false
 }
 
 trait Inferencing { this: Typer =>
diff --git a/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala b/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
index 170d12b998de..31e862ecd569 100644
--- a/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
+++ b/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
@@ -13,6 +13,7 @@ import Decorators._
 import Uniques._
 import inlines.Inlines
 import config.Printers.typr
+import Inferencing.*
 import ErrorReporting.*
 import util.SourceFile
 import TypeComparer.necessarySubType
@@ -495,18 +496,21 @@ object ProtoTypes {
         force = true)
       val targ1 = typer.adapt(targ, wideFormal, locked)
       if wideFormal eq formal then targ1
-      else targ1.tpe match
-        case tp: AppliedType if tp.hasCaptureConversionArg =>
-          stripCast(targ1).tpe match
-            case tp: AppliedType if tp.hasWildcardArg =>
-              errorTree(targ1,
-                em"""argument for by-name parameter is not a value
-                    |and contains wildcard arguments: $tp
-                    |
-                    |Assign it to a val and pass that instead.
-                    |""")
-            case _ => targ1
-        case _ => targ1
+      else checkNoWildcardCaptureForCBN(targ1)
+    }
+
+    def checkNoWildcardCaptureForCBN(targ1: Tree)(using Context): Tree = {
+      if hasCaptureConversionArg(targ1.tpe) then
+        stripCast(targ1).tpe match
+          case tp: AppliedType if tp.hasWildcardArg =>
+            errorTree(targ1,
+              em"""argument for by-name parameter is not a value
+                  |and contains wildcard arguments: $tp
+                  |
+                  |Assign it to a val and pass that instead.
+                  |""")
+          case _ => targ1
+      else targ1
     }
 
     /** The type of the argument `arg`, or `NoType` if `arg` has not been typed before
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 54eb8bc2ab1e..40e488dc7336 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -1568,7 +1568,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
                 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 if mt.resType.match { case tp: AppliedType => tp.hasCaptureConversionArg case _ => false } then
+                else if hasCaptureConversionArg(mt.resType) then
                   errorTree(tree,
                     em"""cannot turn method type $mt into closure
                         |because it has capture conversion skolem types""")

From d91f66ff783682e473909299f3775db07b784101 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Mon, 23 Jan 2023 14:51:54 +0100
Subject: [PATCH 026/657] Don't generate a Select for a TermRef with NoPrefix

In TreeTypeMap, don't generate a Select node if the new type of
the tree is a TermRef with NoPrefix. Generate an Ident node instead.

Fixes #16740
---
 .../dotty/tools/dotc/ast/TreeTypeMap.scala    | 40 ++++++++++++-------
 compiler/src/dotty/tools/dotc/ast/tpd.scala   |  4 ++
 .../dotty/tools/dotc/transform/Erasure.scala  |  2 +-
 tests/pos/i16740.scala                        |  8 ++++
 4 files changed, 38 insertions(+), 16 deletions(-)
 create mode 100644 tests/pos/i16740.scala

diff --git a/compiler/src/dotty/tools/dotc/ast/TreeTypeMap.scala b/compiler/src/dotty/tools/dotc/ast/TreeTypeMap.scala
index f5bf55802adf..faeafae97f5e 100644
--- a/compiler/src/dotty/tools/dotc/ast/TreeTypeMap.scala
+++ b/compiler/src/dotty/tools/dotc/ast/TreeTypeMap.scala
@@ -43,7 +43,7 @@ class TreeTypeMap(
 
   def copy(
       typeMap: Type => Type,
-      treeMap: tpd.Tree => tpd.Tree,
+      treeMap: Tree => Tree,
       oldOwners: List[Symbol],
       newOwners: List[Symbol],
       substFrom: List[Symbol],
@@ -85,13 +85,13 @@ class TreeTypeMap(
       updateDecls(prevStats.tail, newStats.tail)
     }
 
-  def transformInlined(tree: tpd.Inlined)(using Context): tpd.Tree =
+  def transformInlined(tree: Inlined)(using Context): 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 {
+  override def transform(tree: Tree)(using Context): Tree = treeMap(tree) match {
     case impl @ Template(constr, _, self, _) =>
       val tmap = withMappedSyms(localSyms(impl :: self :: Nil))
       cpy.Template(impl)(
@@ -103,8 +103,24 @@ class TreeTypeMap(
         ).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 id: Ident =>
+          if needsSelect(id.tpe) then
+            ref(id.tpe.asInstanceOf[TermRef]).withSpan(id.span)
+          else
+            super.transform(id)
+        case sel: Select =>
+          if needsIdent(sel.tpe) then
+            ref(sel.tpe.asInstanceOf[TermRef]).withSpan(sel.span)
+          else
+            super.transform(sel)
+        case app: Apply =>
+          super.transform(app)
+        case blk @ Block(stats, expr) =>
+          val (tmap1, stats1) = transformDefs(stats)
+          val expr1 = tmap1.transform(expr)
+          cpy.Block(blk)(stats1, expr1)
+        case lit @ Literal(Constant(tpe: Type)) =>
+          cpy.Literal(lit)(Constant(mapType(tpe)))
         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))
@@ -117,10 +133,6 @@ class TreeTypeMap(
         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) =>
@@ -139,18 +151,16 @@ class TreeTypeMap(
           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] =
+  override def transformStats(trees: List[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))
+  def transformDefs[TT <: Tree](trees: List[TT])(using Context): (TreeTypeMap, List[TT]) = {
+    val tmap = withMappedSyms(localSyms(trees))
     (tmap, tmap.transformSub(trees))
   }
 
@@ -165,7 +175,7 @@ class TreeTypeMap(
     case nil =>
       (this, paramss)
 
-  def apply[ThisTree <: tpd.Tree](tree: ThisTree): ThisTree = transform(tree).asInstanceOf[ThisTree]
+  def apply[ThisTree <: Tree](tree: ThisTree): ThisTree = transform(tree).asInstanceOf[ThisTree]
 
   def apply(annot: Annotation): Annotation = annot.derivedAnnotation(apply(annot.tree))
 
diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
index dd1e46c62223..1a202ece1e66 100644
--- a/compiler/src/dotty/tools/dotc/ast/tpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -414,6 +414,10 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     case _ => false
   }
 
+  def needsIdent(tp: Type)(using Context): Boolean = tp match
+    case tp: TermRef => tp.prefix eq NoPrefix
+    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)
diff --git a/compiler/src/dotty/tools/dotc/transform/Erasure.scala b/compiler/src/dotty/tools/dotc/transform/Erasure.scala
index 129964557995..60affae38ad5 100644
--- a/compiler/src/dotty/tools/dotc/transform/Erasure.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Erasure.scala
@@ -774,7 +774,7 @@ object Erasure {
             select(qual1, sym)
           else
             val castTarget = // Avoid inaccessible cast targets, see i8661
-              if isJvmAccessible(sym.owner)
+              if isJvmAccessible(sym.owner) && sym.owner.isType
               then
                 sym.owner.typeRef
               else
diff --git a/tests/pos/i16740.scala b/tests/pos/i16740.scala
new file mode 100644
index 000000000000..398518ee77ef
--- /dev/null
+++ b/tests/pos/i16740.scala
@@ -0,0 +1,8 @@
+class Enclosing:
+  object Tags:
+    opaque type Ref[T, S <: String & Singleton] = S
+    inline def require[T, S <: String & Singleton]: Ref[T, S] = ???
+  import Tags.*
+
+  val t1 = require[Int, "t1"]
+  val t2 = require[Double, "t2"]

From 1d7f8dc06706d2d53a1f16088c1fda79d558ee53 Mon Sep 17 00:00:00 2001
From: ysthakur <45539777+ysthakur@users.noreply.github.com>
Date: Tue, 24 Jan 2023 04:15:20 -0500
Subject: [PATCH 027/657] Remove test from negAll
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Michał Pałka <prolativus@gmail.com>
---
 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 0346662b5434..b8b38cce92e4 100644
--- a/compiler/test/dotty/tools/dotc/CompilationTests.scala
+++ b/compiler/test/dotty/tools/dotc/CompilationTests.scala
@@ -188,7 +188,6 @@ class CompilationTests {
       compileFile("tests/neg-custom-args/i13026.scala", defaultOptions.and("-print-lines")),
       compileFile("tests/neg-custom-args/i13838.scala", defaultOptions.and("-Ximplicit-search-limit", "1000")),
       compileFile("tests/neg-custom-args/jdk-9-app.scala", defaultOptions.and("-release:8")),
-      compileFile("tests/neg/i16453.scala", defaultOptions),
     ).checkExpectedErrors()
   }
 

From 8d1e5dfa35f2e61c369e5105625f73913219cfab Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Fri, 30 Dec 2022 17:58:05 +0000
Subject: [PATCH 028/657] Split out immutable GadtConstraint

---
 .../dotty/tools/dotc/core/Constraint.scala    |   3 +
 .../tools/dotc/core/ConstraintHandling.scala  |  11 +-
 .../src/dotty/tools/dotc/core/Contexts.scala  |  10 +-
 .../tools/dotc/core/GadtConstraint.scala      | 351 +++++++++---------
 .../tools/dotc/core/OrderingConstraint.scala  |  11 +
 .../dotc/core/PatternTypeConstrainer.scala    |   2 +-
 .../dotty/tools/dotc/core/TypeComparer.scala  |  26 +-
 .../tools/dotc/transform/PostTyper.scala      |   2 +-
 .../dotty/tools/dotc/typer/Implicits.scala    |   8 +-
 .../src/dotty/tools/dotc/typer/Typer.scala    |   4 +-
 10 files changed, 213 insertions(+), 215 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/Constraint.scala b/compiler/src/dotty/tools/dotc/core/Constraint.scala
index b849c7aa7093..c634f847e510 100644
--- a/compiler/src/dotty/tools/dotc/core/Constraint.scala
+++ b/compiler/src/dotty/tools/dotc/core/Constraint.scala
@@ -71,6 +71,9 @@ abstract class Constraint extends Showable {
    */
   def nonParamBounds(param: TypeParamRef)(using Context): TypeBounds
 
+  /** The current bounds of type parameter `param` */
+  def bounds(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,
diff --git a/compiler/src/dotty/tools/dotc/core/ConstraintHandling.scala b/compiler/src/dotty/tools/dotc/core/ConstraintHandling.scala
index 6207e0a3d728..9ffe2bda73cb 100644
--- a/compiler/src/dotty/tools/dotc/core/ConstraintHandling.scala
+++ b/compiler/src/dotty/tools/dotc/core/ConstraintHandling.scala
@@ -749,16 +749,7 @@ trait ConstraintHandling {
     }
 
   /** 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
-    }
-  }
+  def bounds(param: TypeParamRef)(using Context): TypeBounds = constraint.bounds(param)
 
   /** Add type lambda `tl`, possibly with type variables `tvars`, to current constraint
    *  and propagate all bounds.
diff --git a/compiler/src/dotty/tools/dotc/core/Contexts.scala b/compiler/src/dotty/tools/dotc/core/Contexts.scala
index 5f82e8c8b6ce..398af92e494d 100644
--- a/compiler/src/dotty/tools/dotc/core/Contexts.scala
+++ b/compiler/src/dotty/tools/dotc/core/Contexts.scala
@@ -141,7 +141,7 @@ object Contexts {
     def tree: Tree[?]
     def scope: Scope
     def typerState: TyperState
-    def gadt: GadtConstraint
+    def gadt: GadtConstraintHandling
     def searchHistory: SearchHistory
     def source: SourceFile
 
@@ -541,8 +541,8 @@ object Contexts {
     private var _typerState: TyperState = uninitialized
     final def typerState: TyperState = _typerState
 
-    private var _gadt: GadtConstraint = uninitialized
-    final def gadt: GadtConstraint = _gadt
+    private var _gadt: GadtConstraintHandling = uninitialized
+    final def gadt: GadtConstraintHandling = _gadt
 
     private var _searchHistory: SearchHistory = uninitialized
     final def searchHistory: SearchHistory = _searchHistory
@@ -624,7 +624,7 @@ object Contexts {
       this._scope = typer.scope
       setTypeAssigner(typer)
 
-    def setGadt(gadt: GadtConstraint): this.type =
+    def setGadt(gadt: GadtConstraintHandling): this.type =
       util.Stats.record("Context.setGadt")
       this._gadt = gadt
       this
@@ -721,7 +721,7 @@ object Contexts {
           .updated(notNullInfosLoc, Nil)
           .updated(compilationUnitLoc, NoCompilationUnit)
       c._searchHistory = new SearchRoot
-      c._gadt = GadtConstraint.empty
+      c._gadt = GadtConstraintHandling(GadtConstraint.empty)
       c
   end FreshContext
 
diff --git a/compiler/src/dotty/tools/dotc/core/GadtConstraint.scala b/compiler/src/dotty/tools/dotc/core/GadtConstraint.scala
index 7515898a36df..d683c15a9241 100644
--- a/compiler/src/dotty/tools/dotc/core/GadtConstraint.scala
+++ b/compiler/src/dotty/tools/dotc/core/GadtConstraint.scala
@@ -2,34 +2,145 @@ package dotty.tools
 package dotc
 package core
 
-import Decorators._
-import Contexts._
-import Types._
-import Symbols._
+import Contexts.*, Decorators.*, Symbols.*, Types.*
+import config.Printers.{gadts, gadtsConstr}
 import util.{SimpleIdentitySet, SimpleIdentityMap}
-import collection.mutable
 import printing._
 
+import scala.annotation.tailrec
+import scala.annotation.internal.sharable
+import scala.collection.mutable
+
 object GadtConstraint:
-  def apply(): GadtConstraint = empty
-  def empty: GadtConstraint =
-    new ProperGadtConstraint(OrderingConstraint.empty, SimpleIdentityMap.empty, SimpleIdentityMap.empty, false)
+  @sharable val empty: GadtConstraint =
+    GadtConstraint(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 =>
+class GadtConstraint private (
+  private val myConstraint: Constraint,
+  private val mapping: SimpleIdentityMap[Symbol, TypeVar],
+  private val reverseMapping: SimpleIdentityMap[TypeParamRef, Symbol],
+  private val wasConstrained: Boolean,
+) extends Showable:
+  def constraint: Constraint        = myConstraint
+  def symbols: List[Symbol]         = mapping.keys
+  def withConstraint(c: Constraint) = copy(myConstraint = c)
+  def withWasConstrained            = copy(wasConstrained = true)
+
+  def add(sym: Symbol, tv: TypeVar): GadtConstraint = copy(
+    mapping        = mapping.updated(sym, tv),
+    reverseMapping = reverseMapping.updated(tv.origin, sym),
+  )
+
+  /** 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
+    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
+      case tv: TypeVar =>
+        def retrieveBounds: TypeBounds = externalize(constraint.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
+
+  def fullBounds(param: TypeParamRef)(using Context): TypeBounds =
+    nonParamBounds(param).derivedTypeBounds(fullLowerBound(param), fullUpperBound(param))
+
+  def nonParamBounds(param: TypeParamRef)(using Context): TypeBounds =
+    externalize(constraint.nonParamBounds(param)).bounds
+
+  def fullLowerBound(param: TypeParamRef)(using Context): Type =
+    constraint.minLower(param).foldLeft(nonParamBounds(param).lo) {
+      (t, u) => t | externalize(u)
+    }
+
+  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
+    }
+
+  def externalize(tp: Type, theMap: TypeMap | Null = null)(using Context): Type = tp match
+    case param: TypeParamRef => reverseMapping(param) match
+      case sym: Symbol => sym.typeRef
+      case null        => param
+    case tp: TypeAlias       => tp.derivedAlias(externalize(tp.alias, theMap))
+    case tp                  => (if theMap == null then ExternalizeMap() else theMap).mapOver(tp)
+
+  private class ExternalizeMap(using Context) extends TypeMap:
+    def apply(tp: Type): Type = externalize(tp, this)(using mapCtx)
+
+  def tvarOrError(sym: Symbol)(using Context): TypeVar =
+    mapping(sym).ensuring(_ != null, i"not a constrainable symbol: $sym").uncheckedNN
+
+  @tailrec final def stripInternalTypeVar(tp: Type): Type = tp match
+    case tv: TypeVar =>
+      val inst = constraint.instType(tv)
+      if inst.exists then stripInternalTypeVar(inst) else tv
+    case _ => tp
+
+  def internalize(tp: Type)(using Context): Type = tp match
+    case nt: NamedType =>
+      val ntTvar = mapping(nt.symbol)
+      if ntTvar == null then tp
+      else ntTvar
+    case _ => tp
+
+  private def containsNoInternalTypes(tp: Type, theAcc: TypeAccumulator[Boolean] | Null = null)(using Context): Boolean = tp match {
+    case tpr: TypeParamRef => !reverseMapping.contains(tpr)
+    case tv: TypeVar => !reverseMapping.contains(tv.origin)
+    case tp =>
+      (if (theAcc != null) theAcc else new ContainsNoInternalTypesAccumulator()).foldOver(true, tp)
+  }
 
-  import dotty.tools.dotc.config.Printers.{gadts, gadtsConstr}
+  private class ContainsNoInternalTypesAccumulator(using Context) extends TypeAccumulator[Boolean] {
+    override def apply(x: Boolean, tp: Type): Boolean = x && containsNoInternalTypes(tp, this)
+  }
 
-  private[core] def getConstraint: Constraint = constraint
-  private[core] def getMapping: SimpleIdentityMap[Symbol, TypeVar] = mapping
-  private[core] def getReverseMapping: SimpleIdentityMap[TypeParamRef, Symbol] = reverseMapping
-  private[core] def getWasConstrained: Boolean = wasConstrained
+  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 def copy(
+    myConstraint: Constraint = myConstraint,
+    mapping: SimpleIdentityMap[Symbol, TypeVar] = mapping,
+    reverseMapping: SimpleIdentityMap[TypeParamRef, Symbol] = reverseMapping,
+    wasConstrained: Boolean = wasConstrained,
+  ): GadtConstraint = GadtConstraint(myConstraint, mapping, reverseMapping, wasConstrained)
+end GadtConstraint
+
+object GadtConstraintHandling:
+  def apply(gadt: GadtConstraint): GadtConstraintHandling = new ProperGadtConstraintHandling(gadt)
+
+sealed trait GadtConstraintHandling(private var myGadt: GadtConstraint) {
+  this: ConstraintHandling =>
+
+  def gadt: GadtConstraint              = myGadt
+  private def gadt_=(g: GadtConstraint) = myGadt = g
 
   /** Exposes ConstraintHandling.subsumes */
   def subsumes(left: GadtConstraint, right: GadtConstraint, pre: GadtConstraint)(using Context): Boolean = {
@@ -57,22 +168,19 @@ sealed trait GadtConstraint (
         // and used as orderings.
         def substDependentSyms(tp: Type, isUpper: Boolean)(using Context): Type = {
           def loop(tp: Type) = substDependentSyms(tp, isUpper)
-          tp match {
+          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 {
+              params.indexOf(tp.symbol) match
                 case -1 =>
-                  mapping(tp.symbol) match {
+                  gadt.internalize(tp) match
                     case tv: TypeVar => tv.origin
-                    case null => tp
-                  }
+                    case _ => tp
                 case i => pt.paramRefs(i)
-              }
             case tp => tp
-          }
         }
 
         val tb = param.info.bounds
@@ -86,205 +194,92 @@ sealed trait GadtConstraint (
 
     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)
+      gadt = gadt.add(sym, tv)
       tv
     }
 
     // The replaced symbols are picked up here.
     addToConstraint(poly1, tvars)
-      .showing(i"added to constraint: [$poly1] $params%, % gadt = $this", gadts)
+      .showing(i"added to constraint: [$poly1] $params%, % gadt = $gadt", gadts)
   }
 
   /** Further constrain a symbol already present in the constraint. */
   def addBound(sym: Symbol, bound: Type, isUpper: Boolean)(using Context): Boolean = {
-    @annotation.tailrec def stripInternalTypeVar(tp: Type): Type = tp match {
-      case tv: TypeVar =>
-        val inst = constraint.instType(tv)
-        if (inst.exists) stripInternalTypeVar(inst) else tv
-      case _ => tp
-    }
-
-    val symTvar: TypeVar = stripInternalTypeVar(tvarOrError(sym)) match {
+    val symTvar: TypeVar = gadt.stripInternalTypeVar(gadt.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)
-    }
+        return if isUpper then 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 internalizedBound = gadt.stripInternalTypeVar(gadt.internalize(bound))
 
     val saved = constraint
     val result = internalizedBound match
       case boundTvar: TypeVar =>
-        if (boundTvar eq symTvar) true
-        else if (isUpper) addLess(symTvar.origin, boundTvar.origin)
+        if boundTvar eq symTvar then true
+        else if isUpper
+        then 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 ">:"
+      val descr = if isUpper then "upper" else "lower"
+      val op = if isUpper then "<:" else ">:"
       i"adding $descr bound $sym $op $bound = $result"
     }
 
-    if constraint ne saved then wasConstrained = true
+    if constraint ne saved then gadt = gadt.withWasConstrained
     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
+  def isLess(sym1: Symbol, sym2: Symbol)(using Context): Boolean = gadt.isLess(sym1, sym2)
+  def fullBounds(sym: Symbol)(using Context): TypeBounds | Null = gadt.fullBounds(sym)
+  def bounds(sym: Symbol)(using Context): TypeBounds | Null = gadt.bounds(sym)
+  def contains(sym: Symbol)(using Context): Boolean = gadt.contains(sym)
+  def isNarrowing: Boolean = gadt.isNarrowing
+  def symbols: List[Symbol] = gadt.symbols
 
   /** 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
+    approximation(gadt.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.
+        gadt.externalize(tpr)
+      case tp => tp
+      .showing(i"approximating $sym ~> $result", gadts)
   }
 
-  def symbols: List[Symbol] = mapping.keys
+  def fresh: GadtConstraintHandling = GadtConstraintHandling(gadt)
 
-  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
-
-  def restore(constr: Constraint, mapping: SimpleIdentityMap[Symbol, TypeVar], revMapping: SimpleIdentityMap[TypeParamRef, Symbol], wasConstrained: Boolean): Unit =
-    this.myConstraint = constr
-    this.mapping = mapping
-    this.reverseMapping = revMapping
-    this.wasConstrained = wasConstrained
+  /** Restore the GadtConstraint state. */
+  def restore(gadt: GadtConstraint): Unit = this.gadt = gadt
 
   inline def rollbackGadtUnless(inline op: Boolean): Boolean =
-    val savedConstr = myConstraint
-    val savedMapping = mapping
-    val savedReverseMapping = reverseMapping
-    val savedWasConstrained = wasConstrained
+    val saved = gadt
     var result = false
-    try
-      result = op
-    finally
-      if !result then
-        restore(savedConstr, savedMapping, savedReverseMapping, savedWasConstrained)
+    try result = op
+    finally if !result then restore(saved)
     result
 
   // ---- Protected/internal -----------------------------------------------
 
-  override protected def constraint = myConstraint
-  override protected def constraint_=(c: Constraint) = myConstraint = c
+  override protected def constraint = gadt.constraint
+  override protected def constraint_=(c: Constraint) = gadt = gadt.withConstraint(c)
 
   override protected def isSub(tp1: Type, tp2: Type)(using Context): Boolean = TypeComparer.isSubType(tp1, tp2)
   override protected def isSame(tp1: Type, tp2: Type)(using Context): Boolean = TypeComparer.isSameType(tp1, tp2)
 
-  override def nonParamBounds(param: TypeParamRef)(using Context): TypeBounds =
-    externalize(constraint.nonParamBounds(param)).bounds
-
-  override def fullLowerBound(param: TypeParamRef)(using Context): Type =
-    constraint.minLower(param).foldLeft(nonParamBounds(param).lo) {
-      (t, u) => t | externalize(u)
-    }
-
-  override def fullUpperBound(param: TypeParamRef)(using Context): Type =
-    constraint.minUpper(param).foldLeft(nonParamBounds(param).hi) { (t, u) =>
-      val eu = externalize(u)
-      // Any as the upper bound means "no bound", but if F is higher-kinded,
-      // Any & F = F[_]; this is wrong for us so we need to short-circuit
-      if t.isAny then eu else t & eu
-    }
-
-  // ---- Private ----------------------------------------------------------
-
-  private def externalize(tp: Type, theMap: TypeMap | Null = null)(using Context): Type = tp match
-    case param: TypeParamRef => reverseMapping(param) match
-      case sym: Symbol => sym.typeRef
-      case null        => param
-    case tp: TypeAlias       => tp.derivedAlias(externalize(tp.alias, theMap))
-    case tp                  => (if theMap == null then ExternalizeMap() else theMap).mapOver(tp)
-
-  private class ExternalizeMap(using Context) extends TypeMap:
-    def apply(tp: Type): Type = externalize(tp, this)(using mapCtx)
-
-  private def tvarOrError(sym: Symbol)(using Context): TypeVar =
-    mapping(sym).ensuring(_ != null, i"not a constrainable symbol: $sym").uncheckedNN
-
-  private def containsNoInternalTypes(tp: Type, theAcc: TypeAccumulator[Boolean] | Null = null)(using Context): Boolean = tp match {
-    case tpr: TypeParamRef => !reverseMapping.contains(tpr)
-    case tv: TypeVar => !reverseMapping.contains(tv.origin)
-    case tp =>
-      (if (theAcc != null) theAcc else new ContainsNoInternalTypesAccumulator()).foldOver(true, tp)
-  }
-
-  private class ContainsNoInternalTypesAccumulator(using Context) extends TypeAccumulator[Boolean] {
-    override def apply(x: Boolean, tp: Type): Boolean = x && containsNoInternalTypes(tp, this)
-  }
+  override def nonParamBounds(param: TypeParamRef)(using Context): TypeBounds = gadt.nonParamBounds(param)
+  override def fullLowerBound(param: TypeParamRef)(using Context): Type = gadt.fullLowerBound(param)
+  override def fullUpperBound(param: TypeParamRef)(using Context): Type = gadt.fullUpperBound(param)
 
   // ---- 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)
+// Hide ConstraintHandling within GadtConstraintHandling
+private class ProperGadtConstraintHandling(gadt: GadtConstraint) extends ConstraintHandling with GadtConstraintHandling(gadt)
diff --git a/compiler/src/dotty/tools/dotc/core/OrderingConstraint.scala b/compiler/src/dotty/tools/dotc/core/OrderingConstraint.scala
index 212b70336f4b..faea30390d2b 100644
--- a/compiler/src/dotty/tools/dotc/core/OrderingConstraint.scala
+++ b/compiler/src/dotty/tools/dotc/core/OrderingConstraint.scala
@@ -224,6 +224,17 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
   def exclusiveUpper(param: TypeParamRef, butNot: TypeParamRef): List[TypeParamRef] =
     upper(param).filterNot(isLess(butNot, _))
 
+  def bounds(param: TypeParamRef)(using Context): TypeBounds = {
+    val e = 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
+    }
+  }
+
 // ---------- Info related to TypeParamRefs -------------------------------------------
 
   def isLess(param1: TypeParamRef, param2: TypeParamRef): Boolean =
diff --git a/compiler/src/dotty/tools/dotc/core/PatternTypeConstrainer.scala b/compiler/src/dotty/tools/dotc/core/PatternTypeConstrainer.scala
index e7f54d088c09..9fff257ee963 100644
--- a/compiler/src/dotty/tools/dotc/core/PatternTypeConstrainer.scala
+++ b/compiler/src/dotty/tools/dotc/core/PatternTypeConstrainer.scala
@@ -261,7 +261,7 @@ trait PatternTypeConstrainer { self: TypeComparer =>
     val assumeInvariantRefinement =
       migrateTo3 || forceInvariantRefinement || refinementIsInvariant(patternTp)
 
-    trace(i"constraining simple pattern type $tp >:< $pt", gadts, (res: Boolean) => i"$res gadt = ${ctx.gadt}") {
+    trace(i"constraining simple pattern type $tp >:< $pt", gadts, (res: Boolean) => i"$res gadt = ${ctx.gadt.gadt}") {
       (tp, pt) match {
         case (AppliedType(tyconS, argsS), AppliedType(tyconP, argsP)) =>
           val saved = state.nn.constraint
diff --git a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
index cf2507aa1724..32b41ed9c63b 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
@@ -1445,14 +1445,11 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
     if tp2 eq NoType then false
     else if tp1 eq tp2 then true
     else
-      val saved = constraint
-      val savedGadtConstr = ctx.gadt.getConstraint
-      val savedMapping = ctx.gadt.getMapping
-      val savedReverseMapping = ctx.gadt.getReverseMapping
-      val savedWasConstrained = ctx.gadt.getWasConstrained
+      val savedCstr = constraint
+      val savedGadt = ctx.gadt.gadt
       inline def restore() =
-        state.constraint = saved
-        ctx.gadt.restore(savedGadtConstr, savedMapping, savedReverseMapping, savedWasConstrained)
+        state.constraint = savedCstr
+        ctx.gadt.restore(savedGadt)
       val savedSuccessCount = successCount
       try
         recCount += 1
@@ -1858,22 +1855,23 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
    */
   private def necessaryEither(op1: => Boolean, op2: => Boolean): Boolean =
     val preConstraint = constraint
-    val preGadt = ctx.gadt.fresh
+    val preGadtHandling = ctx.gadt.fresh
+    val preGadt = preGadtHandling.gadt
 
     def allSubsumes(leftGadt: GadtConstraint, rightGadt: GadtConstraint, left: Constraint, right: Constraint): Boolean =
-      subsumes(left, right, preConstraint) && preGadt.subsumes(leftGadt, rightGadt, preGadt)
+      subsumes(left, right, preConstraint) && preGadtHandling.subsumes(leftGadt, rightGadt, preGadt)
 
     if op1 then
       val op1Constraint = constraint
-      val op1Gadt = ctx.gadt.fresh
+      val op1Gadt = ctx.gadt.gadt
       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")
+        if allSubsumes(op1Gadt, ctx.gadt.gadt, op1Constraint, constraint) then
+          gadts.println(i"GADT CUT - prefer ${ctx.gadt.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}")
+        else if allSubsumes(ctx.gadt.gadt, op1Gadt, constraint, op1Constraint) then
+          gadts.println(i"GADT CUT - prefer $op1Gadt over ${ctx.gadt.gadt}")
           constr.println(i"CUT - prefer $op1Constraint over $constraint")
           constraint = op1Constraint
           ctx.gadt.restore(op1Gadt)
diff --git a/compiler/src/dotty/tools/dotc/transform/PostTyper.scala b/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
index 5abb32b15d57..19a18305ee65 100644
--- a/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
@@ -269,7 +269,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
         case CaseDef(pat, _, _) =>
           val gadtCtx =
            pat.removeAttachment(typer.Typer.InferredGadtConstraints) match
-             case Some(gadt) => ctx.fresh.setGadt(gadt)
+             case Some(gadt) => ctx.fresh.setGadt(GadtConstraintHandling(gadt))
              case None =>
                ctx
           super.transform(tree)(using gadtCtx)
diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
index 3e0e7dd5879d..596ad01bb888 100644
--- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -1030,7 +1030,7 @@ trait Implicits:
           case result: SearchSuccess =>
             if result.tstate ne ctx.typerState then
               result.tstate.commit()
-            if result.gstate ne ctx.gadt then
+            if result.gstate ne ctx.gadt.gadt then
               ctx.gadt.restore(result.gstate)
             if hasSkolem(false, result.tree) then
               report.error(SkolemInInferred(result.tree, pt, argument), ctx.source.atSpan(span))
@@ -1145,7 +1145,7 @@ trait Implicits:
               SearchFailure(adapted.withType(new MismatchedImplicit(ref, pt, argument)))
         }
       else
-        SearchSuccess(adapted, ref, cand.level, cand.isExtension)(ctx.typerState, ctx.gadt)
+        SearchSuccess(adapted, ref, cand.level, cand.isExtension)(ctx.typerState, ctx.gadt.gadt)
     }
 
   /** An implicit search; parameters as in `inferImplicit` */
@@ -1343,7 +1343,7 @@ trait Implicits:
             case _: SearchFailure =>
               SearchSuccess(ref(defn.NotGiven_value), defn.NotGiven_value.termRef, 0)(
                 ctx.typerState.fresh().setCommittable(true),
-                ctx.gadt
+                ctx.gadt.gadt
               )
             case _: SearchSuccess =>
               NoMatchingImplicitsFailure
@@ -1526,7 +1526,7 @@ trait Implicits:
       // other candidates need to be considered.
       recursiveRef match
         case ref: TermRef =>
-          SearchSuccess(tpd.ref(ref).withSpan(span.startPos), ref, 0)(ctx.typerState, ctx.gadt)
+          SearchSuccess(tpd.ref(ref).withSpan(span.startPos), ref, 0)(ctx.typerState, ctx.gadt.gadt)
         case _ =>
           searchImplicit(contextual = true)
     end bestImplicit
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 1a24a94e527e..1cb723b85c27 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -1782,7 +1782,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         // 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)
+        pat1.putAttachment(InferredGadtConstraints, ctx.gadt.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)
@@ -3835,7 +3835,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
                 adaptToSubType(wtp)
           case CompareResult.OKwithGADTUsed
           if pt.isValueType
-             && !inContext(ctx.fresh.setGadt(GadtConstraint.empty)) {
+             && !inContext(ctx.fresh.setGadt(GadtConstraintHandling(GadtConstraint.empty))) {
                val res = (tree.tpe.widenExpr frozen_<:< pt)
                if res then
                  // we overshot; a cast is not needed, after all.

From a12e92434a49fa7fd79894c3e66a77acd5230aa1 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Tue, 24 Jan 2023 15:46:55 +0100
Subject: [PATCH 029/657] Check outer class prefixes in type projections when
 pattern matching

A type pattern of the form A#B should be checked if the prefix A
is not already the owner of B or a superclass.

Fixes #16728
---
 .../tools/dotc/transform/PatternMatcher.scala | 73 +++++++++++--------
 .../fatal-warnings/i16728.check               |  4 +
 .../fatal-warnings/i16728.scala               | 32 ++++++++
 tests/run/i16728.check                        |  3 +
 tests/run/i16728.scala                        | 52 +++++++++++++
 5 files changed, 132 insertions(+), 32 deletions(-)
 create mode 100644 tests/neg-custom-args/fatal-warnings/i16728.check
 create mode 100644 tests/neg-custom-args/fatal-warnings/i16728.scala
 create mode 100644 tests/run/i16728.check
 create mode 100644 tests/run/i16728.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala b/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala
index 63ffdffbddef..6a38c40f6916 100644
--- a/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala
@@ -11,6 +11,7 @@ import util.Spans._
 import typer.Applications.*
 import SymUtils._
 import TypeUtils.*
+import Annotations.*
 import Flags._, Constants._
 import Decorators._
 import NameKinds.{PatMatStdBinderName, PatMatAltsName, PatMatResultName}
@@ -707,9 +708,9 @@ object PatternMatcher {
     // ----- Generating trees from plans ---------------
 
     /** The condition a test plan rewrites to */
-    private def emitCondition(plan: TestPlan): Tree = {
+    private def emitCondition(plan: TestPlan): Tree =
       val scrutinee = plan.scrutinee
-      (plan.test: @unchecked) match {
+      (plan.test: @unchecked) match
         case NonEmptyTest =>
           constToLiteral(
             scrutinee
@@ -737,41 +738,49 @@ object PatternMatcher {
         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 typeTest(scrut: Tree, expected: Type): Tree =
+            val ttest = scrut.select(defn.Any_typeTest).appliedToType(expected)
+            if trusted then ttest.pushAttachment(TrustedTypeTestKey, ())
+            ttest
 
-          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)
-          }
+          /** An outer test is needed in a situation like  `case x: y.Inner => ...
+           *  or like  case x: O#Inner  if the owner of Inner is not a subclass of O.
+           *  Outer tests are added here instead of in TypeTestsCasts since they
+           *  might cause outer accessors to be added to inner classes (via ensureOuterAccessors)
+           *  and therefore have to run before ExplicitOuter.
+           */
+          def addOuterTest(tree: Tree, expected: Type): Tree = expected.dealias match
+            case tref @ TypeRef(pre, _) =>
+              tref.symbol match
+                case expectedCls: ClassSymbol if ExplicitOuter.needsOuterIfReferenced(expectedCls) =>
+                  def selectOuter =
+                    ExplicitOuter.ensureOuterAccessors(expectedCls)
+                    scrutinee.ensureConforms(expected).outerSelect(1, expectedCls.owner.typeRef)
+                  if pre.isSingleton then
+                    val expectedOuter = singleton(pre)
+                    tree.and(selectOuter.select(defn.Object_eq).appliedTo(expectedOuter))
+                  else if !expectedCls.isStatic
+                    && expectedCls.owner.isType
+                    && !expectedCls.owner.derivesFrom(pre.classSymbol)
+                  then
+                    val testPre =
+                      if expected.hasAnnotation(defn.UncheckedAnnot) then
+                        AnnotatedType(pre, Annotation(defn.UncheckedAnnot, tree.span))
+                      else pre
+                    tree.and(typeTest(selectOuter, testPre))
+                  else tree
+                case _ => tree
+            case AppliedType(tycon, _) =>
+              addOuterTest(tree, tycon)
+            case _ =>
+              tree
 
-          expectedTp.dealias match {
+          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
-          }
-      }
-    }
+              addOuterTest(typeTest(scrutinee, expectedTp), expectedTp)
+    end emitCondition
 
     @tailrec
     private def canFallThrough(plan: Plan): Boolean = plan match {
diff --git a/tests/neg-custom-args/fatal-warnings/i16728.check b/tests/neg-custom-args/fatal-warnings/i16728.check
new file mode 100644
index 000000000000..a797baf19be0
--- /dev/null
+++ b/tests/neg-custom-args/fatal-warnings/i16728.check
@@ -0,0 +1,4 @@
+-- Error: tests/neg-custom-args/fatal-warnings/i16728.scala:16:11 ------------------------------------------------------
+16 |      case tx : C[Int]#X => // error
+   |           ^
+   |     the type test for C[Int] cannot be checked at runtime because its type arguments can't be determined from A
diff --git a/tests/neg-custom-args/fatal-warnings/i16728.scala b/tests/neg-custom-args/fatal-warnings/i16728.scala
new file mode 100644
index 000000000000..42c860cc40b2
--- /dev/null
+++ b/tests/neg-custom-args/fatal-warnings/i16728.scala
@@ -0,0 +1,32 @@
+class A[T] {
+  class X {
+      def outer : A.this.type = A.this
+  }
+}
+
+class B extends A[Int]
+class C[T] extends A[T]
+
+object Test {
+  def main(args: Array[String]) : Unit = {
+    val b0 = new B
+    val b0x : A[?]#X = new b0.X
+
+    def test = b0x match {
+      case tx : C[Int]#X => // error
+        val c : C[Int] = tx.outer
+        c
+      case _ =>
+        "no match"
+    }
+
+    def test2 = b0x match {
+      case tx : C[Int]#X @unchecked => // ok
+        val c : C[Int] = tx.outer
+        c
+      case _ =>
+        "no match"
+    }
+
+  }
+}
\ No newline at end of file
diff --git a/tests/run/i16728.check b/tests/run/i16728.check
new file mode 100644
index 000000000000..06995cd05e9a
--- /dev/null
+++ b/tests/run/i16728.check
@@ -0,0 +1,3 @@
+b1.X
+B#X
+ELSE
diff --git a/tests/run/i16728.scala b/tests/run/i16728.scala
new file mode 100644
index 000000000000..a1ada09e6d29
--- /dev/null
+++ b/tests/run/i16728.scala
@@ -0,0 +1,52 @@
+class A {
+  class X {
+      def outer : A.this.type = A.this
+  }
+}
+
+class B extends A
+class C extends A
+
+object Test {
+  def main(args: Array[String]) : Unit = {
+    val b0 = new B
+    val b1 = b0
+    val b2 = new B
+
+    val c0 = new C
+    val c1 = c0
+    val c2 = new C
+
+    val b0x : A#X = new b0.X
+
+    val pathTypeMatch = b0x match {
+      case _ : c2.X => "c2.X"
+      case _ : c1.X => "c1.x"
+      case _ : c0.X => "c0.X"
+      case _ : b2.X => "b2.X"
+      case _ : b1.X => "b1.X"
+      case _ : b0.X => "b0.X"
+      case _        => "ELSE"
+    }
+
+    println(pathTypeMatch)
+
+    val projectionTypeMatch = b0x match {
+      case _ : C#X => "C#X"
+      case _ : B#X => "B#X"
+      case _ : A#X => "A#X"
+      case _       => "ELSE"
+    }
+
+    println(projectionTypeMatch)
+
+    val failingTypeMatch = b0x match {
+      case cx : C#X =>
+        val c : C = cx.outer
+        c
+      case _ => "ELSE"
+    }
+
+    println(failingTypeMatch)
+  }
+}
\ No newline at end of file

From b1a035acad2deb74daaa8433e8ded1256bff3a81 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Tue, 24 Jan 2023 12:16:05 +0000
Subject: [PATCH 030/657] Rename GadtConstraintHandling to GadtState

---
 .../src/dotty/tools/dotc/core/Contexts.scala  | 21 ++++++------
 .../tools/dotc/core/GadtConstraint.scala      | 33 +++++++------------
 .../src/dotty/tools/dotc/core/NamerOps.scala  |  6 ++--
 .../dotc/core/PatternTypeConstrainer.scala    |  4 +--
 .../src/dotty/tools/dotc/core/Symbols.scala   |  2 +-
 .../dotty/tools/dotc/core/TypeComparer.scala  | 32 +++++++++---------
 .../src/dotty/tools/dotc/core/TypeOps.scala   |  6 ++--
 .../tools/dotc/inlines/InlineReducer.scala    |  4 +--
 .../tools/dotc/transform/PostTyper.scala      |  2 +-
 .../dotty/tools/dotc/typer/Implicits.scala    | 10 +++---
 .../dotty/tools/dotc/typer/Inferencing.scala  |  4 +--
 .../src/dotty/tools/dotc/typer/Namer.scala    |  2 +-
 .../src/dotty/tools/dotc/typer/Typer.scala    |  8 ++---
 .../quoted/runtime/impl/QuotesImpl.scala      |  2 +-
 14 files changed, 63 insertions(+), 73 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/Contexts.scala b/compiler/src/dotty/tools/dotc/core/Contexts.scala
index 398af92e494d..2f28975dd066 100644
--- a/compiler/src/dotty/tools/dotc/core/Contexts.scala
+++ b/compiler/src/dotty/tools/dotc/core/Contexts.scala
@@ -141,7 +141,8 @@ object Contexts {
     def tree: Tree[?]
     def scope: Scope
     def typerState: TyperState
-    def gadt: GadtConstraintHandling
+    def gadt: GadtConstraint = gadtState.gadt
+    def gadtState: GadtState
     def searchHistory: SearchHistory
     def source: SourceFile
 
@@ -410,7 +411,7 @@ object Contexts {
       val constrCtx = outersIterator.dropWhile(_.outer.owner == owner).next()
       superOrThisCallContext(owner, constrCtx.scope)
         .setTyperState(typerState)
-        .setGadt(gadt)
+        .setGadtState(gadtState)
         .fresh
         .setScope(this.scope)
     }
@@ -541,8 +542,8 @@ object Contexts {
     private var _typerState: TyperState = uninitialized
     final def typerState: TyperState = _typerState
 
-    private var _gadt: GadtConstraintHandling = uninitialized
-    final def gadt: GadtConstraintHandling = _gadt
+    private var _gadtState: GadtState = uninitialized
+    final def gadtState: GadtState = _gadtState
 
     private var _searchHistory: SearchHistory = uninitialized
     final def searchHistory: SearchHistory = _searchHistory
@@ -567,7 +568,7 @@ object Contexts {
       _owner = origin.owner
       _tree = origin.tree
       _scope = origin.scope
-      _gadt = origin.gadt
+      _gadtState = origin.gadtState
       _searchHistory = origin.searchHistory
       _source = origin.source
       _moreProperties = origin.moreProperties
@@ -624,12 +625,12 @@ object Contexts {
       this._scope = typer.scope
       setTypeAssigner(typer)
 
-    def setGadt(gadt: GadtConstraintHandling): this.type =
-      util.Stats.record("Context.setGadt")
-      this._gadt = gadt
+    def setGadtState(gadtState: GadtState): this.type =
+      util.Stats.record("Context.setGadtState")
+      this._gadtState = gadtState
       this
     def setFreshGADTBounds: this.type =
-      setGadt(gadt.fresh)
+      setGadtState(gadtState.fresh)
 
     def setSearchHistory(searchHistory: SearchHistory): this.type =
       util.Stats.record("Context.setSearchHistory")
@@ -721,7 +722,7 @@ object Contexts {
           .updated(notNullInfosLoc, Nil)
           .updated(compilationUnitLoc, NoCompilationUnit)
       c._searchHistory = new SearchRoot
-      c._gadt = GadtConstraintHandling(GadtConstraint.empty)
+      c._gadtState = GadtState(GadtConstraint.empty)
       c
   end FreshContext
 
diff --git a/compiler/src/dotty/tools/dotc/core/GadtConstraint.scala b/compiler/src/dotty/tools/dotc/core/GadtConstraint.scala
index d683c15a9241..a863a982a44d 100644
--- a/compiler/src/dotty/tools/dotc/core/GadtConstraint.scala
+++ b/compiler/src/dotty/tools/dotc/core/GadtConstraint.scala
@@ -133,20 +133,14 @@ class GadtConstraint private (
   ): GadtConstraint = GadtConstraint(myConstraint, mapping, reverseMapping, wasConstrained)
 end GadtConstraint
 
-object GadtConstraintHandling:
-  def apply(gadt: GadtConstraint): GadtConstraintHandling = new ProperGadtConstraintHandling(gadt)
+object GadtState:
+  def apply(gadt: GadtConstraint): GadtState = ProperGadtState(gadt)
 
-sealed trait GadtConstraintHandling(private var myGadt: GadtConstraint) {
-  this: ConstraintHandling =>
+sealed trait GadtState {
+  this: ConstraintHandling => // Hide ConstraintHandling within GadtConstraintHandling
 
-  def gadt: GadtConstraint              = myGadt
-  private def gadt_=(g: GadtConstraint) = myGadt = g
-
-  /** 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))
-  }
+  def gadt: GadtConstraint
+  def gadt_=(g: GadtConstraint): Unit
 
   override protected def legalBound(param: TypeParamRef, rawBound: Type, isUpper: Boolean)(using Context): Type =
     // GADT constraints never involve wildcards and are not propagated outside
@@ -233,13 +227,6 @@ sealed trait GadtConstraintHandling(private var myGadt: GadtConstraint) {
     result
   }
 
-  def isLess(sym1: Symbol, sym2: Symbol)(using Context): Boolean = gadt.isLess(sym1, sym2)
-  def fullBounds(sym: Symbol)(using Context): TypeBounds | Null = gadt.fullBounds(sym)
-  def bounds(sym: Symbol)(using Context): TypeBounds | Null = gadt.bounds(sym)
-  def contains(sym: Symbol)(using Context): Boolean = gadt.contains(sym)
-  def isNarrowing: Boolean = gadt.isNarrowing
-  def symbols: List[Symbol] = gadt.symbols
-
   /** See [[ConstraintHandling.approximation]] */
   def approximation(sym: Symbol, fromBelow: Boolean, maxLevel: Int = Int.MaxValue)(using Context): Type = {
     approximation(gadt.tvarOrError(sym).origin, fromBelow, maxLevel).match
@@ -252,7 +239,7 @@ sealed trait GadtConstraintHandling(private var myGadt: GadtConstraint) {
       .showing(i"approximating $sym ~> $result", gadts)
   }
 
-  def fresh: GadtConstraintHandling = GadtConstraintHandling(gadt)
+  def fresh: GadtState = GadtState(gadt)
 
   /** Restore the GadtConstraint state. */
   def restore(gadt: GadtConstraint): Unit = this.gadt = gadt
@@ -281,5 +268,7 @@ sealed trait GadtConstraintHandling(private var myGadt: GadtConstraint) {
   override def constr = gadtsConstr
 }
 
-// Hide ConstraintHandling within GadtConstraintHandling
-private class ProperGadtConstraintHandling(gadt: GadtConstraint) extends ConstraintHandling with GadtConstraintHandling(gadt)
+// Hide ConstraintHandling within GadtState
+private class ProperGadtState(private var myGadt: GadtConstraint) extends ConstraintHandling with GadtState:
+  def gadt: GadtConstraint               = myGadt
+  def gadt_=(gadt: GadtConstraint): Unit = myGadt = gadt
diff --git a/compiler/src/dotty/tools/dotc/core/NamerOps.scala b/compiler/src/dotty/tools/dotc/core/NamerOps.scala
index 66912537dbce..db6f72590818 100644
--- a/compiler/src/dotty/tools/dotc/core/NamerOps.scala
+++ b/compiler/src/dotty/tools/dotc/core/NamerOps.scala
@@ -212,11 +212,11 @@ object NamerOps:
    *  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)
+    rhsCtx.gadtState.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)
+      rhsCtx.gadtState.addBound(psym, tr, isUpper = false)
+      rhsCtx.gadtState.addBound(psym, tr, isUpper = true)
     }
 
 end NamerOps
diff --git a/compiler/src/dotty/tools/dotc/core/PatternTypeConstrainer.scala b/compiler/src/dotty/tools/dotc/core/PatternTypeConstrainer.scala
index 9fff257ee963..5e8a960608e6 100644
--- a/compiler/src/dotty/tools/dotc/core/PatternTypeConstrainer.scala
+++ b/compiler/src/dotty/tools/dotc/core/PatternTypeConstrainer.scala
@@ -261,12 +261,12 @@ trait PatternTypeConstrainer { self: TypeComparer =>
     val assumeInvariantRefinement =
       migrateTo3 || forceInvariantRefinement || refinementIsInvariant(patternTp)
 
-    trace(i"constraining simple pattern type $tp >:< $pt", gadts, (res: Boolean) => i"$res gadt = ${ctx.gadt.gadt}") {
+    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 result =
-            ctx.gadt.rollbackGadtUnless {
+            ctx.gadtState.rollbackGadtUnless {
               tyconS.typeParams.lazyZip(argsS).lazyZip(argsP).forall { (param, argS, argP) =>
                 val variance = param.paramVarianceSign
                 if variance == 0 || assumeInvariantRefinement ||
diff --git a/compiler/src/dotty/tools/dotc/core/Symbols.scala b/compiler/src/dotty/tools/dotc/core/Symbols.scala
index d14be2b0dfb9..aa3ae0c3c513 100644
--- a/compiler/src/dotty/tools/dotc/core/Symbols.scala
+++ b/compiler/src/dotty/tools/dotc/core/Symbols.scala
@@ -686,7 +686,7 @@ object Symbols {
       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)
+    if (addToGadt && name.isTypeName) ctx.gadtState.addToConstraint(sym)
     sym
   }
 
diff --git a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
index 32b41ed9c63b..2a0072590550 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
@@ -116,7 +116,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
   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 gadtAddBound(sym: Symbol, b: Type, isUpper: Boolean): Boolean = ctx.gadtState.addBound(sym, b, isUpper)
 
   protected def typeVarInstance(tvar: TypeVar)(using Context): Type = tvar.underlying
 
@@ -1446,10 +1446,10 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
     else if tp1 eq tp2 then true
     else
       val savedCstr = constraint
-      val savedGadt = ctx.gadt.gadt
+      val savedGadt = ctx.gadt
       inline def restore() =
         state.constraint = savedCstr
-        ctx.gadt.restore(savedGadt)
+        ctx.gadtState.restore(savedGadt)
       val savedSuccessCount = successCount
       try
         recCount += 1
@@ -1855,34 +1855,34 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
    */
   private def necessaryEither(op1: => Boolean, op2: => Boolean): Boolean =
     val preConstraint = constraint
-    val preGadtHandling = ctx.gadt.fresh
-    val preGadt = preGadtHandling.gadt
+    val preGadt = ctx.gadt
 
     def allSubsumes(leftGadt: GadtConstraint, rightGadt: GadtConstraint, left: Constraint, right: Constraint): Boolean =
-      subsumes(left, right, preConstraint) && preGadtHandling.subsumes(leftGadt, rightGadt, preGadt)
+      subsumes(left, right, preConstraint)
+      && subsumes(leftGadt.constraint, rightGadt.constraint, preGadt.constraint)
 
     if op1 then
       val op1Constraint = constraint
-      val op1Gadt = ctx.gadt.gadt
+      val op1Gadt = ctx.gadt
       constraint = preConstraint
-      ctx.gadt.restore(preGadt)
+      ctx.gadtState.restore(preGadt)
       if op2 then
-        if allSubsumes(op1Gadt, ctx.gadt.gadt, op1Constraint, constraint) then
-          gadts.println(i"GADT CUT - prefer ${ctx.gadt.gadt} over $op1Gadt")
+        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.gadt, op1Gadt, constraint, op1Constraint) then
-          gadts.println(i"GADT CUT - prefer $op1Gadt over ${ctx.gadt.gadt}")
+        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)
+          ctx.gadtState.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)
+          ctx.gadtState.restore(preGadt)
       else
         constraint = op1Constraint
-        ctx.gadt.restore(op1Gadt)
+        ctx.gadtState.restore(op1Gadt)
       true
     else op2
   end necessaryEither
@@ -2054,7 +2054,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
       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
-        ctx.gadt.rollbackGadtUnless(gadtAddBound(tparam, bound, isUpper))
+        ctx.gadtState.rollbackGadtUnless(gadtAddBound(tparam, bound, isUpper))
     }
   }
 
diff --git a/compiler/src/dotty/tools/dotc/core/TypeOps.scala b/compiler/src/dotty/tools/dotc/core/TypeOps.scala
index ea8dcee5fca5..d9da11c561e8 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeOps.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeOps.scala
@@ -687,8 +687,8 @@ object TypeOps:
             val bound1 = massage(bound)
             if (bound1 ne bound) {
               if (checkCtx eq ctx) checkCtx = ctx.fresh.setFreshGADTBounds
-              if (!checkCtx.gadt.contains(sym)) checkCtx.gadt.addToConstraint(sym)
-              checkCtx.gadt.addBound(sym, bound1, fromBelow)
+              if (!checkCtx.gadt.contains(sym)) checkCtx.gadtState.addToConstraint(sym)
+              checkCtx.gadtState.addBound(sym, bound1, fromBelow)
               typr.println("install GADT bound $bound1 for when checking F-bounded $sym")
             }
           }
@@ -872,7 +872,7 @@ object TypeOps:
         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 syms2.nonEmpty then ctx.gadtState.addToConstraint(syms2)
 
     // If parent contains a reference to an abstract type, then we should
     // refine subtype checking to eliminate abstract types according to
diff --git a/compiler/src/dotty/tools/dotc/inlines/InlineReducer.scala b/compiler/src/dotty/tools/dotc/inlines/InlineReducer.scala
index 42e86b71eff8..e1b2aaa02866 100644
--- a/compiler/src/dotty/tools/dotc/inlines/InlineReducer.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/InlineReducer.scala
@@ -311,11 +311,11 @@ class InlineReducer(inliner: Inliner)(using Context):
       def addTypeBindings(typeBinds: TypeBindsMap)(using Context): Unit =
         typeBinds.foreachBinding { case (sym, shouldBeMinimized) =>
           newTypeBinding(sym,
-            ctx.gadt.approximation(sym, fromBelow = shouldBeMinimized, maxLevel = Int.MaxValue))
+            ctx.gadtState.approximation(sym, fromBelow = shouldBeMinimized, maxLevel = Int.MaxValue))
         }
 
       def registerAsGadtSyms(typeBinds: TypeBindsMap)(using Context): Unit =
-        if (typeBinds.size > 0) ctx.gadt.addToConstraint(typeBinds.keys)
+        if (typeBinds.size > 0) ctx.gadtState.addToConstraint(typeBinds.keys)
 
       pat match {
         case Typed(pat1, tpt) =>
diff --git a/compiler/src/dotty/tools/dotc/transform/PostTyper.scala b/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
index 19a18305ee65..2039a8f19558 100644
--- a/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
@@ -269,7 +269,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
         case CaseDef(pat, _, _) =>
           val gadtCtx =
            pat.removeAttachment(typer.Typer.InferredGadtConstraints) match
-             case Some(gadt) => ctx.fresh.setGadt(GadtConstraintHandling(gadt))
+             case Some(gadt) => ctx.fresh.setGadtState(GadtState(gadt))
              case None =>
                ctx
           super.transform(tree)(using gadtCtx)
diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
index 596ad01bb888..03d3011b4bcd 100644
--- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -1030,8 +1030,8 @@ trait Implicits:
           case result: SearchSuccess =>
             if result.tstate ne ctx.typerState then
               result.tstate.commit()
-            if result.gstate ne ctx.gadt.gadt then
-              ctx.gadt.restore(result.gstate)
+            if result.gstate ne ctx.gadt then
+              ctx.gadtState.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")
@@ -1145,7 +1145,7 @@ trait Implicits:
               SearchFailure(adapted.withType(new MismatchedImplicit(ref, pt, argument)))
         }
       else
-        SearchSuccess(adapted, ref, cand.level, cand.isExtension)(ctx.typerState, ctx.gadt.gadt)
+        SearchSuccess(adapted, ref, cand.level, cand.isExtension)(ctx.typerState, ctx.gadt)
     }
 
   /** An implicit search; parameters as in `inferImplicit` */
@@ -1343,7 +1343,7 @@ trait Implicits:
             case _: SearchFailure =>
               SearchSuccess(ref(defn.NotGiven_value), defn.NotGiven_value.termRef, 0)(
                 ctx.typerState.fresh().setCommittable(true),
-                ctx.gadt.gadt
+                ctx.gadt
               )
             case _: SearchSuccess =>
               NoMatchingImplicitsFailure
@@ -1526,7 +1526,7 @@ trait Implicits:
       // other candidates need to be considered.
       recursiveRef match
         case ref: TermRef =>
-          SearchSuccess(tpd.ref(ref).withSpan(span.startPos), ref, 0)(ctx.typerState, ctx.gadt.gadt)
+          SearchSuccess(tpd.ref(ref).withSpan(span.startPos), ref, 0)(ctx.typerState, ctx.gadt)
         case _ =>
           searchImplicit(contextual = true)
     end bestImplicit
diff --git a/compiler/src/dotty/tools/dotc/typer/Inferencing.scala b/compiler/src/dotty/tools/dotc/typer/Inferencing.scala
index 2aef3433228b..3442207653d4 100644
--- a/compiler/src/dotty/tools/dotc/typer/Inferencing.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Inferencing.scala
@@ -262,7 +262,7 @@ object Inferencing {
                                    && ctx.gadt.contains(tp.symbol)
                                    =>
         val sym = tp.symbol
-        val res = ctx.gadt.approximation(sym, fromBelow = variance < 0)
+        val res = ctx.gadtState.approximation(sym, fromBelow = variance < 0)
         gadts.println(i"approximated $tp  ~~  $res")
         res
 
@@ -432,7 +432,7 @@ object Inferencing {
     }
 
     // We add the created symbols to GADT constraint here.
-    if (res.nonEmpty) ctx.gadt.addToConstraint(res)
+    if (res.nonEmpty) ctx.gadtState.addToConstraint(res)
     res
   }
 
diff --git a/compiler/src/dotty/tools/dotc/typer/Namer.scala b/compiler/src/dotty/tools/dotc/typer/Namer.scala
index 6cdd0150518b..6f85efb0fc8a 100644
--- a/compiler/src/dotty/tools/dotc/typer/Namer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Namer.scala
@@ -1864,7 +1864,7 @@ class Namer { typer: Typer =>
       // so we must allow constraining its type parameters
       // compare with typedDefDef, see tests/pos/gadt-inference.scala
       rhsCtx.setFreshGADTBounds
-      rhsCtx.gadt.addToConstraint(typeParams)
+      rhsCtx.gadtState.addToConstraint(typeParams)
     }
 
     def typedAheadRhs(pt: Type) =
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 1cb723b85c27..eb09d30e60f3 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -1782,7 +1782,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         // 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.gadt)
+        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)
@@ -2362,7 +2362,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       ctx.outer.outersIterator.takeWhile(!_.owner.is(Method))
         .filter(ctx => ctx.owner.isClass && ctx.owner.typeParams.nonEmpty)
         .toList.reverse
-        .foreach(ctx => rhsCtx.gadt.addToConstraint(ctx.owner.typeParams))
+        .foreach(ctx => rhsCtx.gadtState.addToConstraint(ctx.owner.typeParams))
 
     if tparamss.nonEmpty then
       rhsCtx.setFreshGADTBounds
@@ -2371,7 +2371,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         // 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)
+        rhsCtx.gadtState.addToConstraint(tparamSyms)
       else if !sym.isPrimaryConstructor then
         linkConstructorParams(sym, tparamSyms, rhsCtx)
 
@@ -3835,7 +3835,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
                 adaptToSubType(wtp)
           case CompareResult.OKwithGADTUsed
           if pt.isValueType
-             && !inContext(ctx.fresh.setGadt(GadtConstraintHandling(GadtConstraint.empty))) {
+             && !inContext(ctx.fresh.setGadtState(GadtState(GadtConstraint.empty))) {
                val res = (tree.tpe.widenExpr frozen_<:< pt)
                if res then
                  // we overshot; a cast is not needed, after all.
diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
index dd6471a882bd..4d08e0582d1d 100644
--- a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
+++ b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
@@ -3130,7 +3130,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
       if typeHoles.isEmpty then ctx
       else
         val ctx1 = ctx.fresh.setFreshGADTBounds.addMode(dotc.core.Mode.GadtConstraintInference)
-        ctx1.gadt.addToConstraint(typeHoles)
+        ctx1.gadtState.addToConstraint(typeHoles)
         ctx1
 
     val matchings = QuoteMatcher.treeMatch(scrutinee, pat1)(using ctx1)

From 1978bcb55859fbd4373767282e323abaf8526640 Mon Sep 17 00:00:00 2001
From: Mohammad Yousuf Minhaj Zia <yzia2000@gmail.com>
Date: Wed, 25 Jan 2023 00:48:25 +0800
Subject: [PATCH 031/657] Added jpath check to `ClassLikeSupport`
 getParentsAsTreeSymbolTuples

Fixes #15927

Check for whether the non-scala3 parent exists before checking the start
and end of the span to confirm whether the span exists in
getParentsAsTreeSymbolTuples.
---
 scaladoc-testcases/src/tests/nonScala3Parent.scala  | 13 +++++++++++++
 .../tools/scaladoc/tasty/ClassLikeSupport.scala     |  3 ++-
 .../TranslatableSignaturesTestCases.scala           |  2 ++
 3 files changed, 17 insertions(+), 1 deletion(-)
 create mode 100644 scaladoc-testcases/src/tests/nonScala3Parent.scala

diff --git a/scaladoc-testcases/src/tests/nonScala3Parent.scala b/scaladoc-testcases/src/tests/nonScala3Parent.scala
new file mode 100644
index 000000000000..91183d25b583
--- /dev/null
+++ b/scaladoc-testcases/src/tests/nonScala3Parent.scala
@@ -0,0 +1,13 @@
+package tests
+package nonScala3Parent
+
+import javax.swing.JPanel
+import javax.swing.JFrame
+
+// https://github.com/lampepfl/dotty/issues/15927
+
+trait Foo1 extends Numeric[Any]
+trait Foo2 extends JPanel
+trait Foo3 extends JFrame
+trait Foo4 extends Ordering[Any]
+trait Foo5 extends Enumeration
diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala
index 920621b8577c..38cc90330265 100644
--- a/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala
@@ -266,7 +266,8 @@ trait ClassLikeSupport:
     def getParentsAsTreeSymbolTuples: List[(Tree, Symbol)] =
       if noPosClassDefs.contains(c.symbol) then Nil
       else for
-        parentTree <- c.parents if parentTree.pos.start != parentTree.pos.end // We assume here that order is correct
+        // TODO: add exists function to position methods in Quotes and replace the condition here for checking the JPath
+        parentTree <- c.parents if parentTree.pos.sourceFile.getJPath.isDefined && parentTree.pos.start != parentTree.pos.end // We assume here that order is correct
         parentSymbol = parentTree match
           case t: TypeTree => t.tpe.typeSymbol
           case tree if tree.symbol.isClassConstructor => tree.symbol.owner
diff --git a/scaladoc/test/dotty/tools/scaladoc/signatures/TranslatableSignaturesTestCases.scala b/scaladoc/test/dotty/tools/scaladoc/signatures/TranslatableSignaturesTestCases.scala
index ab7c2189e5d5..49316b08dbc0 100644
--- a/scaladoc/test/dotty/tools/scaladoc/signatures/TranslatableSignaturesTestCases.scala
+++ b/scaladoc/test/dotty/tools/scaladoc/signatures/TranslatableSignaturesTestCases.scala
@@ -106,3 +106,5 @@ class ImplicitMembers extends SignatureTest(
   Seq("def"),
   filterFunc = _.toString.endsWith("OuterClass$ImplicitMemberTarget.html")
 )
+
+class NonScala3Parent extends SignatureTest("nonScala3Parent", SignatureTest.all)

From 208071a5b333541d2e2db6cefc91c41ef1c55138 Mon Sep 17 00:00:00 2001
From: ysthakur <45539777+ysthakur@users.noreply.github.com>
Date: Tue, 24 Jan 2023 22:12:23 -0500
Subject: [PATCH 032/657] Test implicitly() too; change err msg

---
 .../dotty/tools/dotc/reporting/messages.scala |  6 ++---
 tests/neg/i16453.check                        | 24 +++++++++++++------
 tests/neg/i16453.scala                        | 13 ++++++----
 3 files changed, 29 insertions(+), 14 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/reporting/messages.scala b/compiler/src/dotty/tools/dotc/reporting/messages.scala
index be5b4c16d170..743a50a33700 100644
--- a/compiler/src/dotty/tools/dotc/reporting/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/messages.scala
@@ -2746,9 +2746,9 @@ class MissingImplicitArgument(
           i"\n\nNote: ${s.ref.symbol.showLocated} was not considered because it was not imported with `import given`."
         def noChainConversionsNote(s: Iterable[TermRef]): Option[String] =
           Option.when(s.nonEmpty)(
-              i"\n\nNote: Chaining implicit conversions is no longer allowed in Scala. " +
-              i"The following conversions were ignored:${s.map(g => s"\n  - ${g.symbol.showDcl}").mkString}" +
-              i"\nIf there is an implicit `Conversion[A, ${pt.show}]` and an implicit `A` in scope, you need to explicitly pass the argument, e.g. `(using summon[A])`"
+              i"\n\nNote: Chaining implicit conversions are not allowed in Scala. " +
+              i"The following conversions are in scope:${s.map(g => s"\n  - ${g.symbol.showDcl}").mkString}" +
+              i"\nIf there is an implicit `Conversion[A, ${pt.show}]` and an implicit `A` in scope, you can explicitly pass the argument, e.g. `(using summon[A])`"
           )
         super.msgPostscript
         ++ ignoredInstanceNormalImport.map(hiddenImplicitNote)
diff --git a/tests/neg/i16453.check b/tests/neg/i16453.check
index 871df3b6d7d2..d112266a44c6 100644
--- a/tests/neg/i16453.check
+++ b/tests/neg/i16453.check
@@ -1,8 +1,18 @@
--- [E172] Type Error: tests/neg/i16453.scala:10:43 ---------------------------------------------------------------------
-10 |  val fails = summon[String => Option[Int]] // error
-   |                                           ^
-   |No given instance of type String => Option[Int] was found for parameter x of method summon in object Predef
+-- [E172] Type Error: tests/neg/i16453.scala:14:21 ---------------------------------------------------------------------
+14 |  summon[Option[Int]] // error
+   |                     ^
+   |No given instance of type Option[Int] was found for parameter x of method summon in object Predef
    |
-   |Note: Chaining implicit conversions is no longer allowed in Scala. The following conversions were ignored:
-   |  - final given def given_Conversion_Function_Function[T]: Conversion[String => T, String => Option[T]]
-   |If there is an implicit `Conversion[A, String => Option[Int]]` and an implicit `A` in scope, you need to explicitly pass the argument, e.g. `(using summon[A])`
+   |Note: Chaining implicit conversions are not allowed in Scala. The following conversions are in scope:
+   |  - final given def given_Conversion_T_Option[T]: Conversion[T, Option[T]]
+   |  - implicit def toOption[T](t: T): Option[T]
+   |If there is an implicit `Conversion[A, Option[Int]]` and an implicit `A` in scope, you can explicitly pass the argument, e.g. `(using summon[A])`
+-- [E172] Type Error: tests/neg/i16453.scala:15:25 ---------------------------------------------------------------------
+15 |  implicitly[Option[Int]] // error
+   |                         ^
+   |No given instance of type Option[Int] was found for parameter e of method implicitly in object Predef
+   |
+   |Note: Chaining implicit conversions are not allowed in Scala. The following conversions are in scope:
+   |  - final given def given_Conversion_T_Option[T]: Conversion[T, Option[T]]
+   |  - implicit def toOption[T](t: T): Option[T]
+   |If there is an implicit `Conversion[A, Option[Int]]` and an implicit `A` in scope, you can explicitly pass the argument, e.g. `(using summon[A])`
diff --git a/tests/neg/i16453.scala b/tests/neg/i16453.scala
index b60c174e4077..a143237711d9 100644
--- a/tests/neg/i16453.scala
+++ b/tests/neg/i16453.scala
@@ -1,11 +1,16 @@
 import scala.language.implicitConversions
 
-given [T]: Conversion[String => T, String => Option[T]] = ???
+// Scala 3 style conversion
+given [T]: Conversion[T, Option[T]] = ???
+// Scala 2 style conversion
+implicit def toOption[T](t: T): Option[T] = Option(t)
+
 // This one is irrelevant, shouldn't be included in error message
-given irrelevant[T]: Conversion[String => T, String => Byte] = ???
+given irrelevant: Conversion[Int, Option[Long]] = ???
 
 def test() = {
-  given foo: (String => Int) = _ => 42
+  given foo: Int = 0
 
-  val fails = summon[String => Option[Int]] // error
+  summon[Option[Int]] // error
+  implicitly[Option[Int]] // error
 }

From a527b10706fbced4158caeb58cca7bdf9e11c8ee Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Mon, 23 Jan 2023 09:26:12 +0000
Subject: [PATCH 033/657] Fix isFullyDefined trace

First, switch to the "i" interpolator and replace "IFT" with
"isFullyDefined".  Then apply it to the whole apply, and make the
dealias appear in the trace.  Requires fixing an early return usage.
Also expose the ForceDegree specified.

Found this in the course of enabling tracing and the typr printer and
seeing lots of verbose type case classes printed.
---
 .../tools/dotc/printing/Formatting.scala      |  1 +
 .../dotty/tools/dotc/typer/Inferencing.scala  | 32 +++++++++++--------
 2 files changed, 19 insertions(+), 14 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/printing/Formatting.scala b/compiler/src/dotty/tools/dotc/printing/Formatting.scala
index f4bbd74842c8..0acfd06de433 100644
--- a/compiler/src/dotty/tools/dotc/printing/Formatting.scala
+++ b/compiler/src/dotty/tools/dotc/printing/Formatting.scala
@@ -90,6 +90,7 @@ object Formatting {
       given Show[util.SourceFile]                     = ShowAny
       given Show[util.Spans.Span]                     = ShowAny
       given Show[tasty.TreeUnpickler#OwnerTree]       = ShowAny
+      given Show[typer.ForceDegree.Value]             = 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
diff --git a/compiler/src/dotty/tools/dotc/typer/Inferencing.scala b/compiler/src/dotty/tools/dotc/typer/Inferencing.scala
index 656a1266d5ab..dc83b49a8aa3 100644
--- a/compiler/src/dotty/tools/dotc/typer/Inferencing.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Inferencing.scala
@@ -170,14 +170,18 @@ object Inferencing {
 
     private var toMaximize: List[TypeVar] = Nil
 
-    def apply(x: Boolean, tp: Type): Boolean =
-      try tp.dealias match
+    def apply(x: Boolean, tp: Type): Boolean = trace(i"isFullyDefined($tp, $force)", typr) {
+      try {
+      val tpd = tp.dealias
+      if tpd ne tp then apply(x, tpd)
+      else tp match
         case _: WildcardType | _: ProtoType =>
           false
         case tvar: TypeVar if !tvar.isInstantiated =>
           force.appliesTo(tvar)
           && ctx.typerState.constraint.contains(tvar)
           && {
+            var fail = false
             val direction = instDirection(tvar.origin)
             if minimizeSelected then
               if direction <= 0 && tvar.hasLowerBound then
@@ -190,17 +194,16 @@ object Inferencing {
             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
+              fail = true
             else
               toMaximize = tvar :: toMaximize
-            foldOver(x, tvar)
-          }
-        case tp =>
-          reporting.trace(s"IFT $tp") {
-            foldOver(x, tp)
+            !fail && foldOver(x, tvar)
           }
+        case 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 */
@@ -767,13 +770,14 @@ trait Inferencing { this: Typer =>
   end constrainIfDependentParamRef
 }
 
-/** An enumeration controlling the degree of forcing in "is-dully-defined" checks. */
+/** An enumeration controlling the degree of forcing in "is-fully-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)
+  class Value(val appliesTo: TypeVar => Boolean, val ifBottom: IfBottom):
+    override def toString = s"ForceDegree.Value(.., $ifBottom)"
+  val none: Value       = new Value(_ => false, IfBottom.ok)  { override def toString = "ForceDegree.none" }
+  val all: Value        = new Value(_ => true, IfBottom.ok)   { override def toString = "ForceDegree.all" }
+  val failBottom: Value = new Value(_ => true, IfBottom.fail) { override def toString = "ForceDegree.failBottom" }
+  val flipBottom: Value = new Value(_ => true, IfBottom.flip) { override def toString = "ForceDegree.flipBottom" }
 }
 
 enum IfBottom:

From 1978b8b0ef35eb04debe9623904369d40cc49180 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Wed, 25 Jan 2023 16:00:13 +0100
Subject: [PATCH 034/657] Simplifications (2)

---
 .../src/dotty/tools/dotc/typer/Typer.scala    | 71 +++++++++----------
 1 file changed, 33 insertions(+), 38 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 44ae2ac7a46c..b03a4962cf61 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -1197,9 +1197,9 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     )
   end typedIf
 
-  /** Decompose function prototype into a list of parameter prototypes, an optional list 
-   *  describing whether the parameter prototypes come from WildcardTypes, and a result prototype
-   *  tree, using WildcardTypes where a type is not known.
+  /** Decompose function prototype into a list of parameter prototypes and a result
+   *  prototype tree, using WildcardTypes where a type is not known.
+   *  Note: parameter prototypes may be TypeBounds.
    *  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).
@@ -1207,7 +1207,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
    *     def double(x: Char): String = s"$x$x"
    *     "abc" flatMap double
    */
-  private def decomposeProtoFunction(pt: Type, defaultArity: Int, pos: SrcPos)(using Context): (List[Type], Option[List[Boolean]], untpd.Tree) = {
+  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)
@@ -1235,26 +1235,19 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           // 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.
-          // However, we still keep the information on whether expected parameter types were 
-          // wildcards, in case of types inferred from target being more specific
 
-          val fromWildcards = pt1.argInfos.init.map{
-            case bounds @ TypeBounds(nt, at) if nt == defn.NothingType && at == defn.AnyType => true
-            case bounds => false
-          }
-
-          (pt1.argTypesLo.init, Some(fromWildcards), typeTree(interpolateWildcards(pt1.argTypesHi.last)))
+          (pt1.argInfos.init, typeTree(interpolateWildcards(pt1.argInfos.last.hiBound)))
         case RefinedType(parent, nme.apply, mt @ MethodTpe(_, formals, restpe))
         if defn.isNonRefinedFunction(parent) && formals.length == defaultArity =>
-          (formals, None, untpd.DependentTypeTree(syms => restpe.substParams(mt, syms.map(_.termRef))))
+          (formals, untpd.DependentTypeTree(syms => restpe.substParams(mt, syms.map(_.termRef))))
         case SAMType(mt @ MethodTpe(_, formals, restpe)) =>
-          (formals, None, 
+          (formals,
            if (mt.isResultDependent)
              untpd.DependentTypeTree(syms => restpe.substParams(mt, syms.map(_.termRef)))
            else
              typeTree(restpe))
         case _ =>
-          (List.tabulate(defaultArity)(alwaysWildcardType), None, untpd.TypeTree())
+          (List.tabulate(defaultArity)(alwaysWildcardType), untpd.TypeTree())
       }
     }
   }
@@ -1276,7 +1269,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
    *  If both attempts fail, return `NoType`.
    */
   def inferredFromTarget(
-      param: untpd.ValDef, formal: Type, calleeType: Type, paramIndex: Name => Int, isWildcardParam: Boolean)(using Context): Type =
+      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)
@@ -1289,7 +1282,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         else NoType
       case _ => NoType
     if target.exists then formal <:< target
-    if !isWildcardParam && isFullyDefined(formal, ForceDegree.flipBottom) then formal
+    if !formal.isExactlyNothing && isFullyDefined(formal, ForceDegree.flipBottom) then formal
     else if target.exists && isFullyDefined(target, ForceDegree.flipBottom) then target
     else NoType
 
@@ -1466,7 +1459,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       case _ =>
     }
 
-    val (protoFormals, areWildcardParams, resultTpt) = decomposeProtoFunction(pt, params.length, tree.srcPos)
+    val (protoFormals, resultTpt) = decomposeProtoFunction(pt, params.length, tree.srcPos)
 
     def protoFormal(i: Int): Type =
       if (protoFormals.length == params.length) protoFormals(i)
@@ -1482,11 +1475,13 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       }
 
     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)
+    if protoFormals.length == 1 && params.length != 1 then
+      val firstFormal = protoFormals.head.loBound
+      if ptIsCorrectProduct(firstFormal) then
+        val isGenericTuple =
+          firstFormal.derivesFrom(defn.TupleClass)
+          && !defn.isTupleClass(firstFormal.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)
@@ -1508,22 +1503,22 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         for ((param, i) <- params.zipWithIndex) yield
           if (!param.tpt.isEmpty) param
           else
-            val formal = protoFormal(i)
-            val isWildcardParam = areWildcardParams.map(list => if i < list.length then list(i) else false).getOrElse(false)
+            val formalBounds = protoFormal(i)
+            val formal = formalBounds.loBound
+            val isBottomFromWildcard = (formalBounds ne formal) && formal.isExactlyNothing
             val knownFormal = isFullyDefined(formal, ForceDegree.failBottom)
-            // Since decomposeProtoFunction eagerly approximates function arguments
-            // from below, then in the case that the argument was also identified as
-            // a wildcard type we try to prioritize inferring from target, if possible.
-            // See issue 16405 (tests/run/16405.scala)
-            val (usingFormal, paramType) =
-              if !isWildcardParam && knownFormal then (true, formal)
-              else 
-                val fromTarget = inferredFromTarget(param, formal, calleeType, paramIndex, isWildcardParam)
-                if fromTarget.exists then (false, fromTarget)
-                else if knownFormal then (true, formal)
-                else (false, errorType(AnonymousFunctionMissingParamType(param, tree, formal), param.srcPos))
+            // If the expected formal is a TypeBounds wildcard argument with Nothing as lower bound,
+            // try to prioritize inferring from target. See issue 16405 (tests/run/16405.scala)
+            val paramType =
+              if knownFormal && !isBottomFromWildcard then
+                formal
+              else
+                inferredFromTarget(param, formal, calleeType, paramIndex).orElse(
+                  if knownFormal then formal
+                  else errorType(AnonymousFunctionMissingParamType(param, tree, formal), param.srcPos)
+                )
             val paramTpt = untpd.TypedSplice(
-                (if usingFormal then InferredTypeTree() else untpd.TypeTree())
+                (if knownFormal then InferredTypeTree() else untpd.TypeTree())
                   .withType(paramType.translateFromRepeated(toArray = false))
                   .withSpan(param.span.endPos)
               )
@@ -1594,7 +1589,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           typedMatchFinish(tree, tpd.EmptyTree, defn.ImplicitScrutineeTypeRef, cases1, pt)
         }
         else {
-          val (protoFormals, _, _) = decomposeProtoFunction(pt, 1, tree.srcPos)
+          val (protoFormals, _) = decomposeProtoFunction(pt, 1, tree.srcPos)
           val checkMode =
             if (pt.isRef(defn.PartialFunctionClass)) desugar.MatchCheck.None
             else desugar.MatchCheck.Exhaustive

From 6bded27149b83c508d795bd5772bad43a8b334e6 Mon Sep 17 00:00:00 2001
From: ysthakur <45539777+ysthakur@users.noreply.github.com>
Date: Wed, 25 Jan 2023 11:01:38 -0500
Subject: [PATCH 035/657] Use clearer name
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Michał Pałka <prolativus@gmail.com>
---
 compiler/src/dotty/tools/dotc/reporting/messages.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/reporting/messages.scala b/compiler/src/dotty/tools/dotc/reporting/messages.scala
index 743a50a33700..8b52544922ec 100644
--- a/compiler/src/dotty/tools/dotc/reporting/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/messages.scala
@@ -2744,7 +2744,7 @@ class MissingImplicitArgument(
         // 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`."
-        def noChainConversionsNote(s: Iterable[TermRef]): Option[String] =
+        def noChainConversionsNote(ignoredConversions: Iterable[TermRef]): Option[String] =
           Option.when(s.nonEmpty)(
               i"\n\nNote: Chaining implicit conversions are not allowed in Scala. " +
               i"The following conversions are in scope:${s.map(g => s"\n  - ${g.symbol.showDcl}").mkString}" +

From 76c826d2ec81f1475521bf09569e0dffbbfdd85e Mon Sep 17 00:00:00 2001
From: ysthakur <45539777+ysthakur@users.noreply.github.com>
Date: Wed, 25 Jan 2023 12:04:38 -0500
Subject: [PATCH 036/657] Update message to be more generic

---
 compiler/src/dotty/tools/dotc/reporting/messages.scala | 8 ++++----
 tests/neg/i16453.check                                 | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/reporting/messages.scala b/compiler/src/dotty/tools/dotc/reporting/messages.scala
index 8b52544922ec..9816ac25023b 100644
--- a/compiler/src/dotty/tools/dotc/reporting/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/messages.scala
@@ -2745,10 +2745,10 @@ class MissingImplicitArgument(
         def hiddenImplicitNote(s: SearchSuccess) =
           i"\n\nNote: ${s.ref.symbol.showLocated} was not considered because it was not imported with `import given`."
         def noChainConversionsNote(ignoredConversions: Iterable[TermRef]): Option[String] =
-          Option.when(s.nonEmpty)(
-              i"\n\nNote: Chaining implicit conversions are not allowed in Scala. " +
-              i"The following conversions are in scope:${s.map(g => s"\n  - ${g.symbol.showDcl}").mkString}" +
-              i"\nIf there is an implicit `Conversion[A, ${pt.show}]` and an implicit `A` in scope, you can explicitly pass the argument, e.g. `(using summon[A])`"
+          Option.when(ignoredConversions.nonEmpty)(
+              i"\n\nNote: implicit conversions are not automatically applied to implicit arguments. " +
+              i"You will have to pass the argument explicitly.\n" +
+              i"The following conversions in scope result in ${pt.show}: ${ignoredConversions.map(g => s"\n  - ${g.symbol.showDcl}").mkString}"
           )
         super.msgPostscript
         ++ ignoredInstanceNormalImport.map(hiddenImplicitNote)
diff --git a/tests/neg/i16453.check b/tests/neg/i16453.check
index d112266a44c6..e9fb0443311e 100644
--- a/tests/neg/i16453.check
+++ b/tests/neg/i16453.check
@@ -3,16 +3,16 @@
    |                     ^
    |No given instance of type Option[Int] was found for parameter x of method summon in object Predef
    |
-   |Note: Chaining implicit conversions are not allowed in Scala. The following conversions are in scope:
+   |Note: implicit conversions are not automatically applied to implicit arguments. You will have to pass the argument explicitly.
+   |The following conversions in scope result in Option[Int]: 
    |  - final given def given_Conversion_T_Option[T]: Conversion[T, Option[T]]
    |  - implicit def toOption[T](t: T): Option[T]
-   |If there is an implicit `Conversion[A, Option[Int]]` and an implicit `A` in scope, you can explicitly pass the argument, e.g. `(using summon[A])`
 -- [E172] Type Error: tests/neg/i16453.scala:15:25 ---------------------------------------------------------------------
 15 |  implicitly[Option[Int]] // error
    |                         ^
    |No given instance of type Option[Int] was found for parameter e of method implicitly in object Predef
    |
-   |Note: Chaining implicit conversions are not allowed in Scala. The following conversions are in scope:
+   |Note: implicit conversions are not automatically applied to implicit arguments. You will have to pass the argument explicitly.
+   |The following conversions in scope result in Option[Int]: 
    |  - final given def given_Conversion_T_Option[T]: Conversion[T, Option[T]]
    |  - implicit def toOption[T](t: T): Option[T]
-   |If there is an implicit `Conversion[A, Option[Int]]` and an implicit `A` in scope, you can explicitly pass the argument, e.g. `(using summon[A])`

From adc1995e1313a35eabf4b9fbf56210ee13982316 Mon Sep 17 00:00:00 2001
From: ysthakur <45539777+ysthakur@users.noreply.github.com>
Date: Wed, 25 Jan 2023 12:07:19 -0500
Subject: [PATCH 037/657] Edit message according to suggestion

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

diff --git a/compiler/src/dotty/tools/dotc/reporting/messages.scala b/compiler/src/dotty/tools/dotc/reporting/messages.scala
index 9816ac25023b..def04818255a 100644
--- a/compiler/src/dotty/tools/dotc/reporting/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/messages.scala
@@ -2746,7 +2746,7 @@ class MissingImplicitArgument(
           i"\n\nNote: ${s.ref.symbol.showLocated} was not considered because it was not imported with `import given`."
         def noChainConversionsNote(ignoredConversions: Iterable[TermRef]): Option[String] =
           Option.when(ignoredConversions.nonEmpty)(
-              i"\n\nNote: implicit conversions are not automatically applied to implicit arguments. " +
+              i"\n\nNote: implicit conversions are not automatically applied to arguments of using clauses. " +
               i"You will have to pass the argument explicitly.\n" +
               i"The following conversions in scope result in ${pt.show}: ${ignoredConversions.map(g => s"\n  - ${g.symbol.showDcl}").mkString}"
           )

From 90abf995c4c02a5de48fafba054e82dd91dcb222 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Wed, 25 Jan 2023 17:18:13 +0000
Subject: [PATCH 038/657] Fix tuple member selection so it works with GADT
 healing

---
 .../src/dotty/tools/dotc/core/Definitions.scala |  9 +++++++++
 compiler/src/dotty/tools/dotc/typer/Typer.scala | 17 ++++++++---------
 tests/pos/i16590.scala                          | 13 +++++++++++++
 3 files changed, 30 insertions(+), 9 deletions(-)
 create mode 100644 tests/pos/i16590.scala

diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
index ed86050436e8..854608143df9 100644
--- a/compiler/src/dotty/tools/dotc/core/Definitions.scala
+++ b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -1675,6 +1675,15 @@ class Definitions {
     rec(tp.stripTypeVar, Nil, bound)
   }
 
+  def isSmallGenericTuple(tp: Type)(using Context): Boolean =
+    if tp.derivesFrom(defn.PairClass) && !defn.isTupleNType(tp.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(tp.widenTermRefExpr) match
+        case Some(elems) if elems.length <= Definitions.MaxTupleArity => true
+        case _ => false
+    else false
+
   def isProductSubType(tp: Type)(using Context): Boolean = tp.derivesFrom(ProductClass)
 
   /** Is `tp` (an alias) of either a scala.FunctionN or a scala.ContextFunctionN
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 3c4146f7ca2d..67b5736b2c22 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -635,6 +635,9 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
        // 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 if defn.isSmallGenericTuple(qual.tpe) then
+      val elems = defn.tupleTypes(qual.tpe.widenTermRefExpr).getOrElse(Nil)
+      typedSelect(tree, pt, qual.cast(defn.tupleType(elems)))
     else
       val tree1 = tryExtensionOrConversion(
           tree, pt, IgnoredProto(pt), qual, ctx.typerState.ownedVars, this, inSelect = true)
@@ -654,6 +657,9 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
             if checkedType1.exists then
               gadts.println(i"Member selection healed by GADT approximation")
               finish(tree1, qual1, checkedType1)
+            else if defn.isSmallGenericTuple(qual1.tpe) then
+              gadts.println(i"Tuple member selection healed by GADT approximation")
+              typedSelect(tree, pt, qual1)
             else
               tryExtensionOrConversion(tree1, pt, IgnoredProto(pt), qual1, ctx.typerState.ownedVars, this, inSelect = true)
           else EmptyTree
@@ -3998,15 +4004,8 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         else err.typeMismatch(tree, pt, failure)
 
       pt match
-        case pt: SelectionProto =>
-          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 _: SelectionProto =>
+          tree // 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)
diff --git a/tests/pos/i16590.scala b/tests/pos/i16590.scala
new file mode 100644
index 000000000000..d70054fd52b4
--- /dev/null
+++ b/tests/pos/i16590.scala
@@ -0,0 +1,13 @@
+enum Tag[A]:
+  case MyTuple extends Tag[(String, String)]
+
+def printIt[A](t: Tag[A], a: A): Unit =
+  t match
+    case Tag.MyTuple => println(a._1)
+
+enum Tag2[A]:
+  case MyTuple extends Tag2[String *: String *: EmptyTuple]
+
+def printIt2[A](t: Tag2[A], a: A): Unit =
+  t match
+    case Tag2.MyTuple => println(a._1)

From d13062aa301a29caa57c45e4892978154d7238f5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Marks?= <pmarks@virtuslab.com>
Date: Wed, 25 Jan 2023 19:37:26 +0100
Subject: [PATCH 039/657] Update base version to 3.3.1-RC1

Also fix incorrect tasty version
---
 project/Build.scala                           |  4 +--
 project/MiMaFilters.scala                     | 25 ++++++++++++++++---
 tasty/src/dotty/tools/tasty/TastyFormat.scala |  4 +--
 3 files changed, 26 insertions(+), 7 deletions(-)

diff --git a/project/Build.scala b/project/Build.scala
index 9babd3c9c679..4b347db088a9 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -80,9 +80,9 @@ object DottyJSPlugin extends AutoPlugin {
 object Build {
   import ScaladocConfigs._
 
-  val referenceVersion = "3.2.2"
+  val referenceVersion = "3.3.0-RC1"
 
-  val baseVersion = "3.3.0-RC1"
+  val baseVersion = "3.3.1-RC1"
 
   // Versions used by the vscode extension to create a new project
   // This should be the latest published releases.
diff --git a/project/MiMaFilters.scala b/project/MiMaFilters.scala
index 689a4b8f1614..63ce926355bb 100644
--- a/project/MiMaFilters.scala
+++ b/project/MiMaFilters.scala
@@ -5,10 +5,29 @@ object MiMaFilters {
   val Library: Seq[ProblemFilter] = Seq(
     ProblemFilters.exclude[DirectMissingMethodProblem]("scala.caps.unsafeBox"),
     ProblemFilters.exclude[DirectMissingMethodProblem]("scala.caps.unsafeUnbox"),
+    ProblemFilters.exclude[DirectMissingMethodProblem]("scala.CanEqual.canEqualMap"),
+    ProblemFilters.exclude[MissingClassProblem]("scala.caps$Pure"),
+    ProblemFilters.exclude[MissingClassProblem]("scala.caps$unsafe$"),
+    ProblemFilters.exclude[MissingFieldProblem]("scala.runtime.stdLibPatches.language.3.3-migration"),
+    ProblemFilters.exclude[MissingFieldProblem]("scala.runtime.stdLibPatches.language.3.3"),
+    ProblemFilters.exclude[MissingClassProblem]("scala.runtime.stdLibPatches.language$3$u002E3$"),
+    ProblemFilters.exclude[MissingClassProblem]("scala.runtime.stdLibPatches.language$3$u002E3$minusmigration$"),
+    ProblemFilters.exclude[MissingFieldProblem]("scala.runtime.stdLibPatches.language#experimental.into"),
+    ProblemFilters.exclude[MissingClassProblem]("scala.runtime.stdLibPatches.language$experimental$into$"),
+    ProblemFilters.exclude[MissingClassProblem]("scala.util.boundary"),
+    ProblemFilters.exclude[MissingClassProblem]("scala.util.boundary$"),
+    ProblemFilters.exclude[MissingClassProblem]("scala.util.boundary$Break"),
+    ProblemFilters.exclude[MissingClassProblem]("scala.util.boundary$Label")
+  )
+  val TastyCore: Seq[ProblemFilter] = Seq(
+    ProblemFilters.exclude[DirectMissingMethodProblem]("dotty.tools.tasty.TastyBuffer.reset"),
+    ProblemFilters.exclude[DirectMissingMethodProblem]("dotty.tools.tasty.TastyFormat.APPLYsigpoly"),
+    ProblemFilters.exclude[DirectMissingMethodProblem]("dotty.tools.tasty.TastyHash.pjwHash64"),
+    ProblemFilters.exclude[DirectMissingMethodProblem]("dotty.tools.tasty.util.Util.dble")
   )
-  val TastyCore: Seq[ProblemFilter] = Seq()
   val Interfaces: Seq[ProblemFilter] = Seq(
-    ProblemFilters.exclude[MissingClassProblem]("dotty.tools.dotc.interfaces.DiagnosticRelatedInformation"),
-    ProblemFilters.exclude[ReversedMissingMethodProblem]("dotty.tools.dotc.interfaces.Diagnostic.diagnosticRelatedInformation")
+    ProblemFilters.exclude[ReversedMissingMethodProblem]("dotty.tools.dotc.interfaces.Diagnostic.diagnosticRelatedInformation"),
+    ProblemFilters.exclude[DirectMissingMethodProblem]("dotty.tools.dotc.interfaces.Diagnostic.diagnosticRelatedInformation"),
+    ProblemFilters.exclude[MissingClassProblem]("dotty.tools.dotc.interfaces.DiagnosticRelatedInformation")
   )
 }
diff --git a/tasty/src/dotty/tools/tasty/TastyFormat.scala b/tasty/src/dotty/tools/tasty/TastyFormat.scala
index ded313fb171c..23b74ed1d7c7 100644
--- a/tasty/src/dotty/tools/tasty/TastyFormat.scala
+++ b/tasty/src/dotty/tools/tasty/TastyFormat.scala
@@ -289,7 +289,7 @@ object TastyFormat {
    *  compatibility, but remains backwards compatible, with all
    *  preceeding `MinorVersion`.
    */
-  final val MinorVersion: Int = 2
+  final val MinorVersion: Int = 4
 
   /** Natural Number. The `ExperimentalVersion` allows for
    *  experimentation with changes to TASTy without committing
@@ -305,7 +305,7 @@ object TastyFormat {
    *  is able to read final TASTy documents if the file's
    *  `MinorVersion` is strictly less than the current value.
    */
-  final val ExperimentalVersion: Int = 0
+  final val ExperimentalVersion: Int = 1
 
   /**This method implements a binary relation (`<:<`) between two TASTy versions.
    *

From 82d69a761d9912705f45613c0aaeff9ca90c54d2 Mon Sep 17 00:00:00 2001
From: ysthakur <45539777+ysthakur@users.noreply.github.com>
Date: Wed, 25 Jan 2023 15:10:21 -0500
Subject: [PATCH 040/657] Update check

---
 tests/neg/i16453.check | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/neg/i16453.check b/tests/neg/i16453.check
index e9fb0443311e..46fea0f7c8c0 100644
--- a/tests/neg/i16453.check
+++ b/tests/neg/i16453.check
@@ -3,7 +3,7 @@
    |                     ^
    |No given instance of type Option[Int] was found for parameter x of method summon in object Predef
    |
-   |Note: implicit conversions are not automatically applied to implicit arguments. You will have to pass the argument explicitly.
+   |Note: implicit conversions are not automatically applied to arguments of using clauses. You will have to pass the argument explicitly.
    |The following conversions in scope result in Option[Int]: 
    |  - final given def given_Conversion_T_Option[T]: Conversion[T, Option[T]]
    |  - implicit def toOption[T](t: T): Option[T]
@@ -12,7 +12,7 @@
    |                         ^
    |No given instance of type Option[Int] was found for parameter e of method implicitly in object Predef
    |
-   |Note: implicit conversions are not automatically applied to implicit arguments. You will have to pass the argument explicitly.
+   |Note: implicit conversions are not automatically applied to arguments of using clauses. You will have to pass the argument explicitly.
    |The following conversions in scope result in Option[Int]: 
    |  - final given def given_Conversion_T_Option[T]: Conversion[T, Option[T]]
    |  - implicit def toOption[T](t: T): Option[T]

From 381242e2e73735bd3ac5e7e7c89303c819b2c527 Mon Sep 17 00:00:00 2001
From: Fengyun Liu <fengyun.liu.cs@gmail.com>
Date: Mon, 16 Jan 2023 06:56:59 +0100
Subject: [PATCH 041/657] Extract reusable code

---
 .../tools/dotc/transform/init/Cache.scala     | 132 +++++++
 .../tools/dotc/transform/init/Errors.scala    |  71 +---
 .../tools/dotc/transform/init/Semantic.scala  | 336 ++++--------------
 .../tools/dotc/transform/init/Trace.scala     |  76 ++++
 .../tools/dotc/transform/init/Util.scala      | 102 ++++++
 5 files changed, 394 insertions(+), 323 deletions(-)
 create mode 100644 compiler/src/dotty/tools/dotc/transform/init/Cache.scala
 create mode 100644 compiler/src/dotty/tools/dotc/transform/init/Trace.scala
 create mode 100644 compiler/src/dotty/tools/dotc/transform/init/Util.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/init/Cache.scala b/compiler/src/dotty/tools/dotc/transform/init/Cache.scala
new file mode 100644
index 000000000000..5ee651c2ed02
--- /dev/null
+++ b/compiler/src/dotty/tools/dotc/transform/init/Cache.scala
@@ -0,0 +1,132 @@
+package dotty.tools.dotc
+package transform
+package init
+
+import core.*
+import Contexts.*
+
+import ast.tpd
+import tpd.Tree
+
+class Cache[Config, Res]:
+  import Cache.*
+
+  /** The cache for expression values from last iteration */
+  protected var last: ExprValueCache[Config, Res] =  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.
+   */
+  protected var current: ExprValueCache[Config, Res] = Map.empty
+
+  /** Whether the current heap is different from the last heap?
+   *
+   *  `changed == false` implies that the fixed point has been reached.
+   */
+  protected var changed: Boolean = false
+
+  /** Used to avoid allocation, its state does not matter */
+  protected given MutableTreeWrapper = new MutableTreeWrapper
+
+  def get(config: Config, expr: Tree): Option[Res] =
+    current.get(config, expr)
+
+  /** Copy the value (config, expr)` from the last cache to the current cache
+   *
+   *  It assumes `default` 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 cachedEval(config: Config, expr: Tree, cacheResult: Boolean, default: Res)(eval: => Res): Res =
+    this.get(config, expr) match
+    case Some(value) => value
+    case None =>
+      val assumeValue: Res =
+        last.get(config, expr) match
+        case Some(value) => value
+        case None =>
+          this.last = last.updatedNested(config, expr, default)
+          default
+
+      this.current = current.updatedNested(config, expr, assumeValue)
+
+      val actual = eval
+      if actual != assumeValue then
+        // println("Changed! from = " + assumeValue + ", to = " + actual)
+        this.changed = true
+        // TODO: respect cacheResult to reduce cache size
+        this.current = this.current.updatedNested(config, expr, actual)
+        // this.current = this.current.removed(config, expr)
+      end if
+
+      actual
+  end cachedEval
+
+  def hasChanged = changed
+
+  /** Prepare cache for the next iteration
+   *
+   *  1. Reset changed flag.
+   *
+   *  2. Use current cache as last cache and set current cache to be empty.
+   */
+  def prepareForNextIteration()(using Context) =
+    this.changed = false
+    this.last = this.current
+    this.current = Map.empty
+end Cache
+
+object Cache:
+  type ExprValueCache[Config, Res] = Map[Config, Map[TreeWrapper, Res]]
+
+  /** A wrapper for trees for storage in maps based on referential equality of trees. */
+  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. */
+  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.
+   */
+  class MutableTreeWrapper extends TreeWrapper:
+    var queryTree: Tree | Null = null
+    def tree: Tree = queryTree match
+      case tree: Tree => tree
+      case null => ???
+
+  extension [Config, Res](cache: ExprValueCache[Config, Res])
+    def get(config: Config, expr: Tree)(using queryWrapper: MutableTreeWrapper): Option[Res] =
+      queryWrapper.queryTree = expr
+      cache.get(config).flatMap(_.get(queryWrapper))
+
+    def removed(config: Config, expr: Tree)(using queryWrapper: MutableTreeWrapper) =
+      queryWrapper.queryTree = expr
+      val innerMap2 = cache(config).removed(queryWrapper)
+      cache.updated(config, innerMap2)
+
+    def updatedNested(config: Config, expr: Tree, result: Res): ExprValueCache[Config, Res] =
+      val wrapper = new ImmutableTreeWrapper(expr)
+      updatedNestedWrapper(config, wrapper, result)
+
+    def updatedNestedWrapper(config: Config, wrapper: ImmutableTreeWrapper, result: Res): ExprValueCache[Config, Res] =
+      val innerMap = cache.getOrElse(config, Map.empty[TreeWrapper, Res])
+      val innerMap2 = innerMap.updated(wrapper, result)
+      cache.updated(config, innerMap2)
+  end extension
diff --git a/compiler/src/dotty/tools/dotc/transform/init/Errors.scala b/compiler/src/dotty/tools/dotc/transform/init/Errors.scala
index 7d92d2b2a921..762e029ba36f 100644
--- a/compiler/src/dotty/tools/dotc/transform/init/Errors.scala
+++ b/compiler/src/dotty/tools/dotc/transform/init/Errors.scala
@@ -5,106 +5,61 @@ package init
 
 import ast.tpd._
 import core._
-import util.SourcePosition
 import util.Property
-import Decorators._, printing.SyntaxHighlighting
+import util.SourcePosition
 import Types._, Symbols._, Contexts._
 
-import scala.collection.mutable
+import Trace.Trace
 
 object Errors:
   private val IsFromPromotion = new Property.Key[Boolean]
 
   sealed trait Error:
-    def trace: Seq[Tree]
+    def trace: Trace
     def show(using Context): String
 
-    def pos(using Context): SourcePosition = trace.last.sourcePos
+    def pos(using Context): SourcePosition = Trace.position(using trace).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)
+      Trace.buildStacktrace(trace, preamble)
 
     def issue(using Context): Unit =
       report.warning(show, this.pos)
   end Error
 
-  def buildStacktrace(trace: Seq[Tree], preamble: String)(using Context): String = if trace.isEmpty then "" else preamble + {
-    var lastLineNum = -1
-    var lines: mutable.ArrayBuffer[String] = new mutable.ArrayBuffer
-    trace.foreach { tree =>
-      val pos = tree.sourcePos
-      val prefix = "-> "
-      val line =
-        if pos.source.exists then
-          val loc = "[ " + pos.source.file.name + ":" + (pos.line + 1) + " ]"
-          val code = SyntaxHighlighting.highlight(pos.lineContent.trim.nn)
-          i"$code\t$loc"
-        else
-          tree.show
-      val positionMarkerLine =
-        if pos.exists && pos.source.exists then
-          positionMarker(pos)
-        else ""
-
-      // always use the more precise trace location
-      if lastLineNum == pos.line then
-        lines.dropRightInPlace(1)
-
-      lines += (prefix + line + "\n" + positionMarkerLine)
-
-      lastLineNum = pos.line
-    }
-    val sb = new StringBuilder
-    for line <- lines do sb.append(line)
-    sb.toString
-  }
-
-  /** Used to underline source positions in the stack trace
-   *  pos.source must exist
-   */
-  private def positionMarker(pos: SourcePosition): String =
-    val trimmed = pos.lineContent.takeWhile(c => c.isWhitespace).length
-    val padding = pos.startColumnPadding.substring(trimmed).nn + "   "
-    val carets =
-      if (pos.startLine == pos.endLine)
-        "^" * math.max(1, pos.endColumn - pos.startColumn)
-      else "^"
-
-    s"$padding$carets\n"
-
   override def toString() = this.getClass.getName.nn
 
   /** Access non-initialized field */
-  case class AccessNonInit(field: Symbol)(val trace: Seq[Tree]) extends Error:
-    def source: Tree = trace.last
+  case class AccessNonInit(field: Symbol)(val trace: Trace) extends Error:
+    def source: Tree = Trace.position(using trace)
     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:
+  case class PromoteError(msg: String)(val trace: Trace) extends Error:
     def show(using Context): String = msg + stacktrace
 
-  case class AccessCold(field: Symbol)(val trace: Seq[Tree]) extends Error:
+  case class AccessCold(field: Symbol)(val trace: Trace) 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:
+  case class CallCold(meth: Symbol)(val trace: Trace) 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:
+  case class CallUnknown(meth: Symbol)(val trace: Trace) 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:
+  case class UnsafePromotion(msg: String, error: Error)(val trace: Trace) extends Error:
     def show(using Context): String =
       msg + stacktrace + "\n" +
         "Promoting the value to hot (transitively initialized) failed due to the following problem:\n" + {
@@ -116,7 +71,7 @@ object Errors:
    *
    *  Invariant: argsIndices.nonEmpty
    */
-  case class UnsafeLeaking(error: Error, nonHotOuterClass: Symbol, argsIndices: List[Int])(val trace: Seq[Tree]) extends Error:
+  case class UnsafeLeaking(error: Error, nonHotOuterClass: Symbol, argsIndices: List[Int])(val trace: Trace) extends Error:
     def show(using Context): String =
       "Problematic object instantiation: " + argumentInfo() + stacktrace + "\n" +
         "It leads to the following error during object initialization:\n" +
diff --git a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
index eb1692e00a12..4aaf0fa9ba72 100644
--- a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
+++ b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
@@ -15,10 +15,19 @@ import config.Printers.init as printer
 import reporting.trace as log
 
 import Errors.*
+import Trace.*
+import Util.*
+import Cache.*
 
 import scala.collection.mutable
 import scala.annotation.tailrec
 
+/**
+ * Checks safe initialization of objects
+ *
+ * This algorithm cannot handle safe access of global object names. That part
+ * is handled by the check in `Objects` (@see Objects).
+ */
 object Semantic:
 
 // ----- Domain definitions --------------------------------
@@ -117,7 +126,7 @@ object Semantic:
       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))) }
+      extendTrace(klass.defTree) { this.callConstructor(ctor, args.map(arg => new ArgInfo(arg, trace))) }
       populatingParams = false
       this
     }
@@ -207,7 +216,7 @@ object Semantic:
   object Cache:
     /** Cache for expressions
      *
-     *  Ref -> Tree -> Value
+     *  Value -> Tree -> Value
      *
      *  The first key is the value of `this` for the expression.
      *
@@ -233,66 +242,29 @@ object Semantic:
      *  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]]
+    private type Config = Value
+    private type Res = 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.
+     *  The heap objects are immutable and its values are essentially derived
+     *  from the cache, thus they are not part of the configuration.
      *
-     *  A `MutableTreeWrapper` is only ever used temporarily for querying a map,
-     *  and is never inserted to the map.
+     *  The only exception is the object correspond to `ThisRef`, where the
+     *  object remembers the set of initialized fields. That information is reset
+     *  in each iteration thus is harmless.
      */
-    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
+    private type Heap = Map[Ref, Objekt]
 
-      /** 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
 
+    class Data extends Cache[Config, Res]:
       /** 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
+      private var stable: ExprValueCache[Config, Res] = Map.empty
 
       /** Abstract heap stores abstract objects
        *
@@ -320,77 +292,38 @@ object Semantic:
       /** 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)
+      override def get(value: Value, expr: Tree): Option[Value] =
+        stable.get(value, expr) match
+        case None => super.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
+      def backup(): Data =
+        val cache = new Data
         cache.stable = this.stable
         cache.heap = this.heap
         cache.heapStable = this.heapStable
         cache.changed = this.changed
+        cache.last = this.last
+        cache.current = this.current
         cache
 
       /** Restore state from a backup */
-      def restore(cache: Cache) =
+      def restore(cache: Data) =
+        this.changed = cache.changed
         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
+          (v, m) <- this.current
           if v.isWarm          // It's useless to cache value for ThisRef.
           (wrapper, res) <- m
         do
@@ -404,10 +337,8 @@ object Semantic:
        *
        *  3. Revert heap to stable.
        */
-      def prepareForNextIteration()(using Context) =
-        this.changed = false
-        this.last = this.current
-        this.current = Map.empty
+      override def prepareForNextIteration()(using Context) =
+        super.prepareForNextIteration()
         this.heap = this.heapStable
 
       /** Prepare for checking next class
@@ -421,15 +352,15 @@ object Semantic:
        *  4. Reset last cache.
        */
       def prepareForNextClass()(using Context) =
-        if this.changed then
-          this.changed = false
+        if this.hasChanged then
           this.heap = this.heapStable
         else
           this.commitToStableCache()
           this.heapStable = this.heap
 
-        this.last = Map.empty
-        this.current = Map.empty
+        // reset changed and cache
+        super.prepareForNextIteration()
+
 
       def updateObject(ref: Ref, obj: Objekt) =
         assert(!this.heapStable.contains(ref))
@@ -438,59 +369,19 @@ object Semantic:
       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
+    end Data
 
-  import Cache.*
+  end Cache
 
-  inline def cache(using c: Cache): Cache = c
+  inline def cache(using c: Cache.Data): Cache.Data = c
 
 // ----- Checker State -----------------------------------
 
   /** The state that threads through the interpreter */
-  type Contextual[T] = (Context, Trace, Promoted, Cache, Reporter) ?=> T
+  type Contextual[T] = (Context, Trace, Promoted, Cache.Data, 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
@@ -508,7 +399,7 @@ object Semantic:
     /**
      * Revert the cache to previous state.
      */
-    def abort()(using Cache): Unit
+    def abort()(using Cache.Data): Unit
     def errors: List[Error]
 
   object Reporter:
@@ -517,8 +408,8 @@ object Semantic:
       def errors = buf.toList
       def report(err: Error) = buf += err
 
-    class TryBufferedReporter(backup: Cache) extends BufferedReporter with TryReporter:
-      def abort()(using Cache): Unit = cache.restore(backup)
+    class TryBufferedReporter(backup: Cache.Data) extends BufferedReporter with TryReporter:
+      def abort()(using Cache.Data): Unit = cache.restore(backup)
 
     class ErrorFound(val error: Error) extends Exception
     class StopEarlyReporter extends Reporter:
@@ -529,7 +420,7 @@ object Semantic:
      *  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 =
+    def errorsIn(fn: Reporter ?=> Unit)(using Cache.Data): TryReporter =
       val reporter = new TryBufferedReporter(cache.backup())
       fn(using reporter)
       reporter
@@ -544,7 +435,7 @@ object Semantic:
       catch case ex: ErrorFound =>
         ex.error :: Nil
 
-    def hasErrors(fn: Reporter ?=> Unit)(using Cache): Boolean =
+    def hasErrors(fn: Reporter ?=> Unit)(using Cache.Data): Boolean =
       val backup = cache.backup()
       val errors = stopEarly(fn)
       cache.restore(backup)
@@ -606,14 +497,14 @@ object Semantic:
         case _ =>
       cache.getObject(ref)
 
-    def ensureObjectExists()(using Cache): ref.type =
+    def ensureObjectExists()(using Cache.Data): ref.type =
       if cache.containsObject(ref) then
         printer.println("object " + ref + " already exists")
         ref
       else
         ensureFresh()
 
-    def ensureFresh()(using Cache): ref.type =
+    def ensureFresh()(using Cache.Data): 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)
@@ -664,7 +555,7 @@ object Semantic:
           Hot
 
         case Cold =>
-          val error = AccessCold(field)(trace.toVector)
+          val error = AccessCold(field)(trace)
           reporter.report(error)
           Hot
 
@@ -689,11 +580,11 @@ object Semantic:
                 val rhs = target.defTree.asInstanceOf[ValOrDefDef].rhs
                 eval(rhs, ref, target.owner.asClass, cacheResult = true)
               else
-                val error = CallUnknown(field)(trace.toVector)
+                val error = CallUnknown(field)(trace)
                 reporter.report(error)
                 Hot
             else
-              val error = AccessNonInit(target)(trace.toVector)
+              val error = AccessNonInit(target)(trace)
               reporter.report(error)
               Hot
           else
@@ -779,7 +670,7 @@ object Semantic:
 
         case Cold =>
           promoteArgs()
-          val error = CallCold(meth)(trace.toVector)
+          val error = CallCold(meth)(trace)
           reporter.report(error)
           Hot
 
@@ -820,7 +711,7 @@ object Semantic:
               // 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)
+                val error = CallUnknown(target)(trace)
                 reporter.report(error)
               Hot
           else if target.exists then
@@ -899,7 +790,7 @@ object Semantic:
             Hot
           else
             // no source code available
-            val error = CallUnknown(ctor)(trace.toVector)
+            val error = CallUnknown(ctor)(trace)
             reporter.report(error)
             Hot
       }
@@ -922,7 +813,7 @@ object Semantic:
             yield
               i + 1
 
-          val error = UnsafeLeaking(errors.head, nonHotOuterClass, indices)(trace.toVector)
+          val error = UnsafeLeaking(errors.head, nonHotOuterClass, indices)(trace)
           reporter.report(error)
           Hot
         else
@@ -947,7 +838,7 @@ object Semantic:
             tryLeak(warm, NoSymbol, args2)
 
         case Cold =>
-          val error = CallCold(ctor)(trace.toVector)
+          val error = CallCold(ctor)(trace)
           reporter.report(error)
           Hot
 
@@ -1078,7 +969,7 @@ object Semantic:
         case Hot   =>
 
         case Cold  =>
-          reporter.report(PromoteError(msg)(trace.toVector))
+          reporter.report(PromoteError(msg)(trace))
 
         case thisRef: ThisRef =>
           val emptyFields = thisRef.nonInitFields()
@@ -1086,7 +977,7 @@ object Semantic:
             promoted.promoteCurrent(thisRef)
           else
             val fields = "Non initialized field(s): " + emptyFields.map(_.show).mkString(", ") + "."
-            reporter.report(PromoteError(msg + "\n" + fields)(trace.toVector))
+            reporter.report(PromoteError(msg + "\n" + fields)(trace))
 
         case warm: Warm =>
           if !promoted.contains(warm) then
@@ -1106,7 +997,7 @@ object Semantic:
               res.promote("The function return value is not hot. Found = " + res.show + ".")
             }
             if errors.nonEmpty then
-              reporter.report(UnsafePromotion(msg, errors.head)(trace.toVector))
+              reporter.report(UnsafePromotion(msg, errors.head)(trace))
             else
               promoted.add(fun)
 
@@ -1156,12 +1047,12 @@ object Semantic:
         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)
+              val error = PromoteError("Promotion cancelled as the value contains inner " + member.show + ".")(Trace.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 args = member.info.paramInfoss.flatten.map(_ => new ArgInfo(Hot: Value, 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 + ".")
@@ -1189,7 +1080,7 @@ object Semantic:
       }
 
       if errors.isEmpty then Nil
-      else UnsafePromotion(msg, errors.head)(trace.toVector) :: Nil
+      else UnsafePromotion(msg, errors.head)(trace) :: Nil
     }
 
   end extension
@@ -1212,7 +1103,7 @@ object Semantic:
    *
    *  The class to be checked must be an instantiable concrete class.
    */
-  private def checkClass(classSym: ClassSymbol)(using Cache, Context): Unit =
+  private def checkClass(classSym: ClassSymbol)(using Cache.Data, Context): Unit =
     val thisRef = ThisRef(classSym)
     val tpl = classSym.defTree.asInstanceOf[TypeDef].rhs.asInstanceOf[Template]
 
@@ -1246,16 +1137,16 @@ object Semantic:
    * Check the specified concrete classes
    */
   def checkClasses(classes: List[ClassSymbol])(using Context): Unit =
-    given Cache()
+    given Cache.Data()
     for classSym <- classes if isConcreteClass(classSym) do
       checkClass(classSym)
 
 // ----- Semantic definition --------------------------------
+  type ArgInfo = TraceValue[Value]
 
-  /** 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 + ".")
+  extension (arg: ArgInfo)
+    def promote: Contextual[Unit] = withTrace(arg.trace) {
+      arg.value.promote("Cannot prove the method argument is hot. Only hot values are safe to leak.\nFound = " + arg.value.show + ".")
     }
 
   /** Evaluate an expression with the given value for `this` in a given class `klass`
@@ -1279,10 +1170,7 @@ object Semantic:
    * @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) }
+    cache.cachedEval(thisV, expr, cacheResult, default = Hot) { cases(expr, thisV, klass) }
   }
 
   /** Evaluate a list of expressions */
@@ -1299,7 +1187,7 @@ object Semantic:
         else
           eval(arg.tree, thisV, klass)
 
-      argInfos += ArgInfo(res, trace.add(arg.tree))
+      argInfos += new ArgInfo(res, trace.add(arg.tree))
     }
     argInfos.toList
 
@@ -1667,7 +1555,7 @@ object Semantic:
             // The parameter check of traits comes late in the mixin phase.
             // To avoid crash we supply hot values for erroneous parent calls.
             // See tests/neg/i16438.scala.
-            val args: List[ArgInfo] = ctor.info.paramInfoss.flatten.map(_ => ArgInfo(Hot, Trace.empty))
+            val args: List[ArgInfo] = ctor.info.paramInfoss.flatten.map(_ => new ArgInfo(Hot, Trace.empty))
             extendTrace(superParent) {
               superCall(tref, ctor, args, tasks)
             }
@@ -1726,85 +1614,3 @@ object Semantic:
           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/compiler/src/dotty/tools/dotc/transform/init/Trace.scala b/compiler/src/dotty/tools/dotc/transform/init/Trace.scala
new file mode 100644
index 000000000000..048a3d318646
--- /dev/null
+++ b/compiler/src/dotty/tools/dotc/transform/init/Trace.scala
@@ -0,0 +1,76 @@
+package dotty.tools.dotc
+package transform
+package init
+
+import core.*
+import Contexts.*
+import ast.tpd.*
+import util.SourcePosition
+
+import Decorators._, printing.SyntaxHighlighting
+
+import scala.collection.mutable
+
+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 ++(trace2: Trace): Trace = trace ++ trace2
+
+  def show(using trace: Trace, ctx: Context): String = buildStacktrace(trace, "\n")
+
+  def position(using trace: Trace): Tree = trace.last
+
+  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))
+
+  def buildStacktrace(trace: Trace, 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"
diff --git a/compiler/src/dotty/tools/dotc/transform/init/Util.scala b/compiler/src/dotty/tools/dotc/transform/init/Util.scala
new file mode 100644
index 000000000000..4e60c1325b09
--- /dev/null
+++ b/compiler/src/dotty/tools/dotc/transform/init/Util.scala
@@ -0,0 +1,102 @@
+package dotty.tools.dotc
+package transform
+package init
+
+import core.*
+import Contexts.*
+import Types.*
+import Symbols.*
+import StdNames.*
+import ast.tpd.*
+
+import reporting.trace as log
+import config.Printers.init as printer
+
+import Trace.*
+
+object Util:
+  /** Utility definition used for better error-reporting of argument errors */
+  case class TraceValue[T](value: T, trace: Trace)
+
+  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
+
+  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)
+  }
+
+
+  extension (sym: Symbol)
+    def hasSource(using Context): Boolean = !sym.defTree.isEmpty
+
+    def isStaticObject(using Context) =
+      sym.is(Flags.Module, butNot = Flags.Package) && sym.isStatic
+
+  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

From 1864f4f8b1cd1f5cc39138781a66ad2f50b33ddd Mon Sep 17 00:00:00 2001
From: Fengyun Liu <fengyun.liu.cs@gmail.com>
Date: Mon, 16 Jan 2023 23:58:42 +0100
Subject: [PATCH 042/657] Fix pickling test

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

diff --git a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
index 4aaf0fa9ba72..4b7de601c053 100644
--- a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
+++ b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
@@ -242,8 +242,6 @@ object Semantic:
      *  that could be reused to check other classes. We employ this trick to
      *  improve performance of the analysis.
      */
-    private type Config = Value
-    private type Res = Value
 
     /** The heap for abstract objects
      *
@@ -257,14 +255,14 @@ object Semantic:
     private type Heap = Map[Ref, Objekt]
 
 
-    class Data extends Cache[Config, Res]:
+    class Data extends Cache[Value, Value]:
       /** 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[Config, Res] = Map.empty
+      private var stable: ExprValueCache[Value, Value] = Map.empty
 
       /** Abstract heap stores abstract objects
        *

From fcc87911c1dc85b01547b832c5f2b451c9348eb0 Mon Sep 17 00:00:00 2001
From: Fengyun Liu <fengyun.liu.cs@gmail.com>
Date: Wed, 25 Jan 2023 08:52:14 +0100
Subject: [PATCH 043/657] Address review

---
 .../tools/dotc/transform/init/Cache.scala     | 71 ++++++++++++++++---
 .../tools/dotc/transform/init/Semantic.scala  |  2 +-
 .../tools/dotc/transform/init/Trace.scala     |  6 ++
 3 files changed, 69 insertions(+), 10 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/init/Cache.scala b/compiler/src/dotty/tools/dotc/transform/init/Cache.scala
index 5ee651c2ed02..b4d378aed4ec 100644
--- a/compiler/src/dotty/tools/dotc/transform/init/Cache.scala
+++ b/compiler/src/dotty/tools/dotc/transform/init/Cache.scala
@@ -8,6 +8,51 @@ import Contexts.*
 import ast.tpd
 import tpd.Tree
 
+/** The co-inductive cache used for analysis
+ *
+ *  The cache contains two maps from `(Config, Tree)` to `Res`:
+ *
+ *  - input cache (`this.last`)
+ *  - output cache (`this.current`)
+ *
+ *  The two caches are required because we want to make sure in a new iteration,
+ *  an expression is evaluated exactly once. The monotonicity of the analysis
+ *  ensures that the cache state goes up the lattice of the abstract domain,
+ *  consequently the algorithm terminates.
+ *
+ *  The general skeleton for usage of the cache is as follows
+ *
+ *      def analysis() = {
+ *        def iterate(entryExp: Expr)(using Cache) =
+ *           eval(entryExp, initConfig)
+ *           if cache.hasChanged && noErrors then
+ *             cache.last = cache.current
+ *             cache.current = Empty
+ *             cache.changed = false
+ *             iterate(outputCache, emptyCache)
+ *           else
+ *             reportErrors
+ *
+ *
+ *        def eval(exp: Exp, config: Config)(using Cache) =
+ *          cache.cachedEval(config, expr) {
+ *            // Actual recursive evaluation of expression.
+ *            //
+ *            // Only executed if the entry `(exp, config)` is not in the output cache.
+ *          }
+ *
+ *        iterate(entryExp)(using new Cache)
+ *      }
+ *
+ *  See the documentation for the method `Cache.cachedEval` for more information.
+ *
+ *  What goes to the configuration (`Config`) and what goes to the result (`Res`)
+ *  need to be decided by the specific analysis and justified by reasoning about
+ *  soundness.
+ *
+ *  @param Config The analysis state that matters for evaluating an expression.
+ *  @param Res The result from the evaluation the given expression.
+ */
 class Cache[Config, Res]:
   import Cache.*
 
@@ -36,28 +81,36 @@ class Cache[Config, Res]:
   def get(config: Config, expr: Tree): Option[Res] =
     current.get(config, expr)
 
-  /** Copy the value (config, expr)` from the last cache to the current cache
+  /** Evaluate an expression with cache
    *
-   *  It assumes `default` if it doesn't exist in the last cache.
+   *  The algorithmic skeleton is as follows:
    *
-   *  It updates the current caches if the values change.
+   *      if this.current.contains(config, expr) then
+   *        return cached value
+   *      else
+   *        val assumed = this.last(config, expr) or bottom value if absent
+   *        this.current(config, expr) = assumed
+   *        val actual = eval(exp)
+   *
+   *        if assumed != actual then
+   *          this.changed = true
+   *          this.current(config, expr) = actual
    *
-   *  The two caches are required because we want to make sure in a new iteration, an expression is evaluated once.
    */
-  def cachedEval(config: Config, expr: Tree, cacheResult: Boolean, default: Res)(eval: => Res): Res =
+  def cachedEval(config: Config, expr: Tree, cacheResult: Boolean, default: Res)(eval: Tree => Res): Res =
     this.get(config, expr) match
     case Some(value) => value
     case None =>
       val assumeValue: Res =
-        last.get(config, expr) match
+        this.last.get(config, expr) match
         case Some(value) => value
         case None =>
-          this.last = last.updatedNested(config, expr, default)
+          this.last = this.last.updatedNested(config, expr, default)
           default
 
-      this.current = current.updatedNested(config, expr, assumeValue)
+      this.current = this.current.updatedNested(config, expr, assumeValue)
 
-      val actual = eval
+      val actual = eval(expr)
       if actual != assumeValue then
         // println("Changed! from = " + assumeValue + ", to = " + actual)
         this.changed = true
diff --git a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
index 4b7de601c053..286e3a124d12 100644
--- a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
+++ b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
@@ -1168,7 +1168,7 @@ object Semantic:
    * @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.cachedEval(thisV, expr, cacheResult, default = Hot) { cases(expr, thisV, klass) }
+    cache.cachedEval(thisV, expr, cacheResult, default = Hot) { expr => cases(expr, thisV, klass) }
   }
 
   /** Evaluate a list of expressions */
diff --git a/compiler/src/dotty/tools/dotc/transform/init/Trace.scala b/compiler/src/dotty/tools/dotc/transform/init/Trace.scala
index 048a3d318646..7dfbc0b6cfa5 100644
--- a/compiler/src/dotty/tools/dotc/transform/init/Trace.scala
+++ b/compiler/src/dotty/tools/dotc/transform/init/Trace.scala
@@ -11,6 +11,12 @@ import Decorators._, printing.SyntaxHighlighting
 
 import scala.collection.mutable
 
+/** Logic related to evaluation trace for showing friendly error messages
+ *
+ *  A trace is a sequence of program positions which tells the evaluation order
+ *  that leads to an error. It is usually more informative than the stack trace
+ *  by tracking the exact sub-expression in the trace instead of only methods.
+ */
 object Trace:
   opaque type Trace = Vector[Tree]
 

From 464fa5d56933d6875302653e738435a125b6fcc4 Mon Sep 17 00:00:00 2001
From: Fengyun Liu <fengyun.liu.cs@gmail.com>
Date: Wed, 25 Jan 2023 09:23:41 +0100
Subject: [PATCH 044/657] Fix typo in comment

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

diff --git a/compiler/src/dotty/tools/dotc/transform/init/Cache.scala b/compiler/src/dotty/tools/dotc/transform/init/Cache.scala
index b4d378aed4ec..14a52d995131 100644
--- a/compiler/src/dotty/tools/dotc/transform/init/Cache.scala
+++ b/compiler/src/dotty/tools/dotc/transform/init/Cache.scala
@@ -22,19 +22,19 @@ import tpd.Tree
  *
  *  The general skeleton for usage of the cache is as follows
  *
- *      def analysis() = {
+ *      def analysis(entryExp: Expr) = {
  *        def iterate(entryExp: Expr)(using Cache) =
  *           eval(entryExp, initConfig)
  *           if cache.hasChanged && noErrors then
  *             cache.last = cache.current
  *             cache.current = Empty
  *             cache.changed = false
- *             iterate(outputCache, emptyCache)
+ *             iterate(entryExp)
  *           else
  *             reportErrors
  *
  *
- *        def eval(exp: Exp, config: Config)(using Cache) =
+ *        def eval(expr: Expr, config: Config)(using Cache) =
  *          cache.cachedEval(config, expr) {
  *            // Actual recursive evaluation of expression.
  *            //

From e3ed95e90bd9a3144ad0ed54a8e306a25c0fb506 Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Tue, 24 Jan 2023 23:22:54 +0100
Subject: [PATCH 045/657] Add default scaladoc settings to scaladoc artifact
 publishing

---
 project/Build.scala              | 9 +++++++--
 project/ScaladocGeneration.scala | 4 ++++
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/project/Build.scala b/project/Build.scala
index 4b347db088a9..473624df0fa2 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -843,6 +843,7 @@ object Build {
       "-sourcepath", (Compile / sourceDirectories).value.map(_.getAbsolutePath).distinct.mkString(File.pathSeparator),
       "-Yexplicit-nulls",
     ),
+    (Compile / doc / scalacOptions) ++= ScaladocConfigs.DefaultGenerationSettings.value.settings
   )
 
   lazy val `scala3-library` = project.in(file("library")).asDottyLibrary(NonBootstrapped)
@@ -1892,8 +1893,7 @@ object ScaladocConfigs {
     )
   }
 
-  lazy val DefaultGenerationConfig = Def.task {
-    def distLocation = (dist / pack).value
+  lazy val DefaultGenerationSettings = Def.task {
     def projectVersion = version.value
     def socialLinks = SocialLinks(List(
       "github::https://github.com/lampepfl/dotty",
@@ -1934,6 +1934,11 @@ object ScaladocConfigs {
     )
   }
 
+  lazy val DefaultGenerationConfig = Def.task {
+    def distLocation = (dist / pack).value
+    DefaultGenerationSettings.value
+  }
+
   lazy val Scaladoc = Def.task {
     DefaultGenerationConfig.value
       .add(UseJavacp(true))
diff --git a/project/ScaladocGeneration.scala b/project/ScaladocGeneration.scala
index c6c4393c071f..fd972311da1d 100644
--- a/project/ScaladocGeneration.scala
+++ b/project/ScaladocGeneration.scala
@@ -141,6 +141,7 @@ object ScaladocGeneration {
     def remove[T <: Arg[_]: ClassTag]: GenerationConfig
     def withTargets(targets: Seq[String]): GenerationConfig
     def serialize: String
+    def settings: Seq[String]
   }
 
   object GenerationConfig {
@@ -173,6 +174,9 @@ object ScaladocGeneration {
          ++ targets
       ).mkString(" ")
 
+      override def settings: Seq[String] =
+        args.map(_.serialize) ++ targets
+
       private def argsWithout[T <: Arg[_]](
         implicit tag: ClassTag[T]
       ): (Option[T], Seq[Arg[_]]) = args.foldLeft[(Option[T], Seq[Arg[_]])]((None, Seq.empty)) {

From 031bae6b9918f90f33ca0ec12827fc819015302d Mon Sep 17 00:00:00 2001
From: Yadu Krishnan <yadavan88@gmail.com>
Date: Thu, 26 Jan 2023 20:39:40 +0100
Subject: [PATCH 046/657] Small correction in documentation

I believe that the current doc is confusing a bit. Readers might get confused with the usage `single quote` in the doc with the `'` symbol.
I also added an additional message to avoid confusion between that and the triple quote interpolation.
---
 docs/_docs/reference/changed-features/interpolation-escapes.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/_docs/reference/changed-features/interpolation-escapes.md b/docs/_docs/reference/changed-features/interpolation-escapes.md
index 594e7671c5ab..ed1cb89cce7a 100644
--- a/docs/_docs/reference/changed-features/interpolation-escapes.md
+++ b/docs/_docs/reference/changed-features/interpolation-escapes.md
@@ -4,7 +4,7 @@ title: "Escapes in interpolations"
 nightlyOf: https://docs.scala-lang.org/scala3/reference/changed-features/interpolation-escapes.html
 ---
 
-In Scala 2 there is no straightforward way to represent a single quote character `"` in a single quoted interpolation. A `\` character can't be used for that because interpolators themselves decide how to handle escaping, so the parser doesn't know whether the `"` character should be escaped or used as a terminator.
+In Scala 2 there is no straightforward way to represent a double-quote character `"` in a quoted interpolation(except in triple-quote interpolation). A `\` character can't be used for that because interpolators themselves decide how to handle escaping, so the parser doesn't know whether the `"` character should be escaped or used as a terminator.
 
 In Scala 3, we can use the `$` meta character of interpolations to escape a `"` character. Example:
 

From 113c5735925a1cc243cdd163654faff96ce0a367 Mon Sep 17 00:00:00 2001
From: Yadu Krishnan <yadavan88@gmail.com>
Date: Thu, 26 Jan 2023 20:47:19 +0100
Subject: [PATCH 047/657] update documentation message

---
 docs/_docs/reference/changed-features/interpolation-escapes.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/_docs/reference/changed-features/interpolation-escapes.md b/docs/_docs/reference/changed-features/interpolation-escapes.md
index ed1cb89cce7a..4abeabdce3ac 100644
--- a/docs/_docs/reference/changed-features/interpolation-escapes.md
+++ b/docs/_docs/reference/changed-features/interpolation-escapes.md
@@ -4,7 +4,7 @@ title: "Escapes in interpolations"
 nightlyOf: https://docs.scala-lang.org/scala3/reference/changed-features/interpolation-escapes.html
 ---
 
-In Scala 2 there is no straightforward way to represent a double-quote character `"` in a quoted interpolation(except in triple-quote interpolation). A `\` character can't be used for that because interpolators themselves decide how to handle escaping, so the parser doesn't know whether the `"` character should be escaped or used as a terminator.
+In Scala 2 there is no straightforward way to represent a double-quote character `"` in a quoted interpolation (except in triple-quote interpolation). A `\` character can't be used for that because interpolators themselves decide how to handle escaping, so the parser doesn't know whether the `"` character should be escaped or used as a terminator.
 
 In Scala 3, we can use the `$` meta character of interpolations to escape a `"` character. Example:
 

From 859d30b0cd8a2de2510cab0d315ca731174b3fe6 Mon Sep 17 00:00:00 2001
From: ysthakur <45539777+ysthakur@users.noreply.github.com>
Date: Thu, 26 Jan 2023 23:41:46 -0500
Subject: [PATCH 048/657] Find all implicits first

---
 .../src/dotty/tools/dotc/reporting/messages.scala  | 12 +++++++++---
 .../src/dotty/tools/dotc/typer/Implicits.scala     | 14 ++++++++++++--
 tests/neg/i16453.scala                             |  9 +++++++--
 3 files changed, 28 insertions(+), 7 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/reporting/messages.scala b/compiler/src/dotty/tools/dotc/reporting/messages.scala
index def04818255a..83209fb63c13 100644
--- a/compiler/src/dotty/tools/dotc/reporting/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/messages.scala
@@ -2555,7 +2555,7 @@ class MissingImplicitArgument(
     where: String,
     paramSymWithMethodCallTree: Option[(Symbol, tpd.Tree)] = None,
     ignoredInstanceNormalImport: => Option[SearchSuccess],
-    ignoredConversions: => Iterable[TermRef]
+    ignoredConversions: => Iterable[(TermRef, Iterable[TermRef])]
   )(using Context) extends TypeMsg(MissingImplicitArgumentID), ShowMatchTrace(pt):
 
   arg.tpe match
@@ -2744,12 +2744,18 @@ class MissingImplicitArgument(
         // 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`."
-        def noChainConversionsNote(ignoredConversions: Iterable[TermRef]): Option[String] =
+        def showImplicitAndConversions(imp: TermRef, convs: Iterable[TermRef]) =
+          i"\n- ${imp.symbol.showDcl}${convs.map(c => "\n    - " + c.symbol.showDcl).mkString}"
+        def noChainConversionsNote(ignoredConversions: Iterable[(TermRef, Iterable[TermRef])]): Option[String] = {
+          val convsFormatted = ignoredConversions.map{ (imp, convs) =>
+            i"\n- ${imp.symbol.showDcl}${convs.map(c => "\n    - " + c.symbol.showDcl).mkString}"
+          }.mkString
           Option.when(ignoredConversions.nonEmpty)(
               i"\n\nNote: implicit conversions are not automatically applied to arguments of using clauses. " +
               i"You will have to pass the argument explicitly.\n" +
-              i"The following conversions in scope result in ${pt.show}: ${ignoredConversions.map(g => s"\n  - ${g.symbol.showDcl}").mkString}"
+              i"The following conversions in scope result in ${pt.show}: $convsFormatted"
           )
+        }
         super.msgPostscript
         ++ ignoredInstanceNormalImport.map(hiddenImplicitNote)
             .orElse(noChainConversionsNote(ignoredConversions))
diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
index f723a18eb241..928ac2ec999b 100644
--- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -923,11 +923,21 @@ trait Implicits:
           // example where searching for a nested type causes an infinite loop.
           None
 
+    def allImplicits(currImplicits: ContextualImplicits): List[ImplicitRef] =
+      if currImplicits.outerImplicits == null then currImplicits.refs
+      else currImplicits.refs ::: allImplicits(currImplicits.outerImplicits)
+
     def ignoredConversions = arg.tpe match
       case fail: SearchFailureType =>
+        // Get every implicit in scope and find Conversions for each
         if (fail.expectedType eq pt) || isFullyDefined(fail.expectedType, ForceDegree.none) then
-          ctx.implicits.eligible(ViewProto(WildcardType, wildApprox(fail.expectedType)))
-            .collect { case c if c.isConversion => c.ref }
+          // todo filter out implicit conversions
+          allImplicits(ctx.implicits).map { imp =>
+            // todo imp.underlyingRef.underlying does not work for implicit functions or givens
+            // with type or implicit parameters
+            val convs = ctx.implicits.eligible(ViewProto(imp.underlyingRef.underlying, wildApprox(fail.expectedType)))
+            (imp.underlyingRef, convs.map(_.ref))
+          }.filter(_._2.nonEmpty)
         else
           Nil
 
diff --git a/tests/neg/i16453.scala b/tests/neg/i16453.scala
index a143237711d9..0288c05938b7 100644
--- a/tests/neg/i16453.scala
+++ b/tests/neg/i16453.scala
@@ -1,7 +1,10 @@
 import scala.language.implicitConversions
 
+trait Foo { type T }
+
 // Scala 3 style conversion
-given [T]: Conversion[T, Option[T]] = ???
+// given [T]: Conversion[T, Option[T]] = ???
+given [F <: Foo](using f: F): Conversion[f.T, Option[f.T]] = ???
 // Scala 2 style conversion
 implicit def toOption[T](t: T): Option[T] = Option(t)
 
@@ -9,7 +12,9 @@ implicit def toOption[T](t: T): Option[T] = Option(t)
 given irrelevant: Conversion[Int, Option[Long]] = ???
 
 def test() = {
-  given foo: Int = 0
+  given foo: Foo with
+    type T = Int
+  given bar: Int = 0
 
   summon[Option[Int]] // error
   implicitly[Option[Int]] // error

From b5755deba79f04db5d846fcc24004e15973f04b0 Mon Sep 17 00:00:00 2001
From: ysthakur <45539777+ysthakur@users.noreply.github.com>
Date: Fri, 27 Jan 2023 00:28:41 -0500
Subject: [PATCH 049/657] Use finalResultType

---
 .../src/dotty/tools/dotc/reporting/messages.scala   |  2 +-
 compiler/src/dotty/tools/dotc/typer/Implicits.scala | 13 +++++++++++--
 2 files changed, 12 insertions(+), 3 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/reporting/messages.scala b/compiler/src/dotty/tools/dotc/reporting/messages.scala
index 83209fb63c13..69965ab4a10a 100644
--- a/compiler/src/dotty/tools/dotc/reporting/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/messages.scala
@@ -2748,7 +2748,7 @@ class MissingImplicitArgument(
           i"\n- ${imp.symbol.showDcl}${convs.map(c => "\n    - " + c.symbol.showDcl).mkString}"
         def noChainConversionsNote(ignoredConversions: Iterable[(TermRef, Iterable[TermRef])]): Option[String] = {
           val convsFormatted = ignoredConversions.map{ (imp, convs) =>
-            i"\n- ${imp.symbol.showDcl}${convs.map(c => "\n    - " + c.symbol.showDcl).mkString}"
+            s"\n- ${imp.symbol.showDcl}${convs.map(c => "\n    - " + c.symbol.showDcl).mkString}"
           }.mkString
           Option.when(ignoredConversions.nonEmpty)(
               i"\n\nNote: implicit conversions are not automatically applied to arguments of using clauses. " +
diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
index 928ac2ec999b..c7d9a7c9ef89 100644
--- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -935,8 +935,17 @@ trait Implicits:
           allImplicits(ctx.implicits).map { imp =>
             // todo imp.underlyingRef.underlying does not work for implicit functions or givens
             // with type or implicit parameters
-            val convs = ctx.implicits.eligible(ViewProto(imp.underlyingRef.underlying, wildApprox(fail.expectedType)))
-            (imp.underlyingRef, convs.map(_.ref))
+            val impRef = imp.underlyingRef
+            val impResultType = wildApprox(impRef.underlying.finalResultType)
+            val convs = ctx.implicits.eligible(ViewProto(impResultType, fail.expectedType))
+              .filter { conv =>
+                if !conv.isConversion then false
+                else
+                  // Actually feed the summoned implicit into the Conversion to
+                  // check if it works
+                  true
+              }
+            (impRef, convs.map(_.ref))
           }.filter(_._2.nonEmpty)
         else
           Nil

From a3e87e7cbf433ee106aaa5adf40e453e10956a8c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Marks?= <pmarks@virtuslab.com>
Date: Fri, 27 Jan 2023 11:38:55 +0100
Subject: [PATCH 050/657] Set reference version to 3.3.0-RC2

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

diff --git a/project/Build.scala b/project/Build.scala
index 4b347db088a9..3c37f83347af 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -80,7 +80,7 @@ object DottyJSPlugin extends AutoPlugin {
 object Build {
   import ScaladocConfigs._
 
-  val referenceVersion = "3.3.0-RC1"
+  val referenceVersion = "3.3.0-RC2"
 
   val baseVersion = "3.3.1-RC1"
 

From fd64c6a99087e9bba5ac9732f5780459c9650ca4 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Fri, 27 Jan 2023 13:11:25 +0100
Subject: [PATCH 051/657] Run macro tests only on bootstrapped test

---
 .../dotty/tools/dotc/BootstrappedOnlyCompilationTests.scala     | 2 ++
 compiler/test/dotty/tools/dotc/CompilationTests.scala           | 2 --
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/test/dotty/tools/dotc/BootstrappedOnlyCompilationTests.scala b/compiler/test/dotty/tools/dotc/BootstrappedOnlyCompilationTests.scala
index e9d0e26f33b0..8c8f0079e868 100644
--- a/compiler/test/dotty/tools/dotc/BootstrappedOnlyCompilationTests.scala
+++ b/compiler/test/dotty/tools/dotc/BootstrappedOnlyCompilationTests.scala
@@ -130,6 +130,8 @@ class BootstrappedOnlyCompilationTests {
       compileFilesInDir("tests/run-custom-args/Yretain-trees", defaultOptions and "-Yretain-trees"),
       compileFilesInDir("tests/run-custom-args/Yread-comments", defaultOptions and "-Yread-docs"),
       compileFilesInDir("tests/run-custom-args/run-macros-erased", defaultOptions.and("-language:experimental.erasedDefinitions").and("-Xcheck-macros")),
+      compileDir("tests/run-custom-args/Xmacro-settings/simple", defaultOptions.and("-Xmacro-settings:one,two,three")),
+      compileDir("tests/run-custom-args/Xmacro-settings/compileTimeEnv", defaultOptions.and("-Xmacro-settings:a,b=1,c.b.a=x.y.z=1,myLogger.level=INFO")),
     )
   }.checkRuns()
 
diff --git a/compiler/test/dotty/tools/dotc/CompilationTests.scala b/compiler/test/dotty/tools/dotc/CompilationTests.scala
index b8b38cce92e4..2fdebef3f5db 100644
--- a/compiler/test/dotty/tools/dotc/CompilationTests.scala
+++ b/compiler/test/dotty/tools/dotc/CompilationTests.scala
@@ -208,8 +208,6 @@ class CompilationTests {
       compileFile("tests/run-custom-args/defaults-serizaliable-no-forwarders.scala", defaultOptions and "-Xmixin-force-forwarders:false"),
       compileFilesInDir("tests/run-custom-args/erased", defaultOptions.and("-language:experimental.erasedDefinitions")),
       compileFilesInDir("tests/run-custom-args/fatal-warnings", defaultOptions.and("-Xfatal-warnings")),
-      compileDir("tests/run-custom-args/Xmacro-settings/simple", defaultOptions.and("-Xmacro-settings:one,two,three")),
-      compileDir("tests/run-custom-args/Xmacro-settings/compileTimeEnv", defaultOptions.and("-Xmacro-settings:a,b=1,c.b.a=x.y.z=1,myLogger.level=INFO")),
       compileFilesInDir("tests/run-custom-args/captures", allowDeepSubtypes.and("-language:experimental.captureChecking")),
       compileFilesInDir("tests/run-deep-subtype", allowDeepSubtypes),
       compileFilesInDir("tests/run", defaultOptions.and("-Ysafe-init")),

From 9579aa56bd04704d63ee727be79634ff71313c4f Mon Sep 17 00:00:00 2001
From: ysthakur <45539777+ysthakur@users.noreply.github.com>
Date: Fri, 27 Jan 2023 23:38:55 -0500
Subject: [PATCH 052/657] Filter out Scala 2-style implicit conversions

---
 .../dotty/tools/dotc/typer/Implicits.scala    | 37 +++++++++++--------
 1 file changed, 22 insertions(+), 15 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
index c7d9a7c9ef89..32ab6518bce9 100644
--- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -927,26 +927,33 @@ trait Implicits:
       if currImplicits.outerImplicits == null then currImplicits.refs
       else currImplicits.refs ::: allImplicits(currImplicits.outerImplicits)
 
+    /** Ensure an implicit is not a Scala 2-style implicit conversion, based on its type */
+    def notImplicitConv(typ: Type): Boolean = typ match {
+      case PolyType(_, resType) => notImplicitConv(resType)
+      case mt: MethodType => mt.isImplicitMethod || mt.isContextualMethod
+      case _ => true
+    }
+
     def ignoredConversions = arg.tpe match
       case fail: SearchFailureType =>
         // Get every implicit in scope and find Conversions for each
         if (fail.expectedType eq pt) || isFullyDefined(fail.expectedType, ForceDegree.none) then
           // todo filter out implicit conversions
-          allImplicits(ctx.implicits).map { imp =>
-            // todo imp.underlyingRef.underlying does not work for implicit functions or givens
-            // with type or implicit parameters
-            val impRef = imp.underlyingRef
-            val impResultType = wildApprox(impRef.underlying.finalResultType)
-            val convs = ctx.implicits.eligible(ViewProto(impResultType, fail.expectedType))
-              .filter { conv =>
-                if !conv.isConversion then false
-                else
-                  // Actually feed the summoned implicit into the Conversion to
-                  // check if it works
-                  true
-              }
-            (impRef, convs.map(_.ref))
-          }.filter(_._2.nonEmpty)
+          allImplicits(ctx.implicits)
+            .filter(imp => notImplicitConv(imp.underlyingRef.underlying))
+            .map { imp =>
+              val impRef = imp.underlyingRef
+              val impResultType = wildApprox(impRef.underlying.finalResultType)
+              val convs = ctx.implicits.eligible(ViewProto(impResultType, fail.expectedType))
+                .filter { conv =>
+                  if !conv.isConversion then false
+                  else
+                    // TODO Actually feed the summoned implicit into the Conversion to
+                    // check if it works
+                    true
+                }
+              (impRef, convs.map(_.ref))
+            }.filter(_._2.nonEmpty)
         else
           Nil
 

From ebb616c0e15b75c752badb855e9bb65176fd3125 Mon Sep 17 00:00:00 2001
From: ysthakur <45539777+ysthakur@users.noreply.github.com>
Date: Sat, 28 Jan 2023 21:17:55 -0500
Subject: [PATCH 053/657] Use typed directly instead of finding conversions

---
 .../dotty/tools/dotc/reporting/messages.scala | 19 ++++------
 .../dotty/tools/dotc/typer/Implicits.scala    | 38 +++++++++++--------
 tests/neg/i16453.check                        | 20 ++++------
 tests/neg/i16453.scala                        |  2 +-
 4 files changed, 39 insertions(+), 40 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/reporting/messages.scala b/compiler/src/dotty/tools/dotc/reporting/messages.scala
index 69965ab4a10a..785f502a0f9c 100644
--- a/compiler/src/dotty/tools/dotc/reporting/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/messages.scala
@@ -2555,7 +2555,7 @@ class MissingImplicitArgument(
     where: String,
     paramSymWithMethodCallTree: Option[(Symbol, tpd.Tree)] = None,
     ignoredInstanceNormalImport: => Option[SearchSuccess],
-    ignoredConversions: => Iterable[(TermRef, Iterable[TermRef])]
+    ignoredConvertibleImplicits: => Iterable[TermRef]
   )(using Context) extends TypeMsg(MissingImplicitArgumentID), ShowMatchTrace(pt):
 
   arg.tpe match
@@ -2746,19 +2746,16 @@ class MissingImplicitArgument(
           i"\n\nNote: ${s.ref.symbol.showLocated} was not considered because it was not imported with `import given`."
         def showImplicitAndConversions(imp: TermRef, convs: Iterable[TermRef]) =
           i"\n- ${imp.symbol.showDcl}${convs.map(c => "\n    - " + c.symbol.showDcl).mkString}"
-        def noChainConversionsNote(ignoredConversions: Iterable[(TermRef, Iterable[TermRef])]): Option[String] = {
-          val convsFormatted = ignoredConversions.map{ (imp, convs) =>
-            s"\n- ${imp.symbol.showDcl}${convs.map(c => "\n    - " + c.symbol.showDcl).mkString}"
-          }.mkString
-          Option.when(ignoredConversions.nonEmpty)(
-              i"\n\nNote: implicit conversions are not automatically applied to arguments of using clauses. " +
-              i"You will have to pass the argument explicitly.\n" +
-              i"The following conversions in scope result in ${pt.show}: $convsFormatted"
+        def noChainConversionsNote(ignoredConvertibleImplicits: Iterable[TermRef]): Option[String] =
+          Option.when(ignoredConvertibleImplicits.nonEmpty)(
+            i"\n\nNote: implicit conversions are not automatically applied to arguments of using clauses. " +
+            i"You will have to pass the argument explicitly.\n" +
+            i"The following implicits in scope can be converted to ${pt.show}:" +
+            ignoredConvertibleImplicits.map { imp => s"\n- ${imp.symbol.showDcl}"}.mkString
           )
-        }
         super.msgPostscript
         ++ ignoredInstanceNormalImport.map(hiddenImplicitNote)
-            .orElse(noChainConversionsNote(ignoredConversions))
+            .orElse(noChainConversionsNote(ignoredConvertibleImplicits))
             .getOrElse(ctx.typer.importSuggestionAddendum(pt))
 
   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 32ab6518bce9..c016d469f5ac 100644
--- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -934,26 +934,34 @@ trait Implicits:
       case _ => true
     }
 
+    def isScala2Conv(typ: Type): Boolean = typ match {
+      case PolyType(_, resType) => isScala2Conv(resType)
+      case mt: MethodType =>
+        (!mt.resultType.isImplicitMethod && !mt.resultType.isContextualMethod)
+          || isScala2Conv(mt.resultType)
+      case _ => false
+    }
+
     def ignoredConversions = arg.tpe match
       case fail: SearchFailureType =>
         // Get every implicit in scope and find Conversions for each
         if (fail.expectedType eq pt) || isFullyDefined(fail.expectedType, ForceDegree.none) then
-          // todo filter out implicit conversions
           allImplicits(ctx.implicits)
-            .filter(imp => notImplicitConv(imp.underlyingRef.underlying))
-            .map { imp =>
-              val impRef = imp.underlyingRef
-              val impResultType = wildApprox(impRef.underlying.finalResultType)
-              val convs = ctx.implicits.eligible(ViewProto(impResultType, fail.expectedType))
-                .filter { conv =>
-                  if !conv.isConversion then false
-                  else
-                    // TODO Actually feed the summoned implicit into the Conversion to
-                    // check if it works
-                    true
-                }
-              (impRef, convs.map(_.ref))
-            }.filter(_._2.nonEmpty)
+            .map(_.underlyingRef)
+            .filter { imp =>
+              if notImplicitConv(imp.underlying) then false
+              else
+                val locked = ctx.typerState.ownedVars
+                val tryCtx = ctx.fresh
+                val tried = Contexts.withMode(Mode.Printing) {
+                    typed(
+                      tpd.ref(imp).withSpan(arg.span),
+                      fail.expectedType,
+                      locked
+                    )
+                  }(using tryCtx)
+                !tryCtx.reporter.hasErrors && fail.expectedType =:= tried.tpe
+            }
         else
           Nil
 
diff --git a/tests/neg/i16453.check b/tests/neg/i16453.check
index 46fea0f7c8c0..5ccd9b491a1e 100644
--- a/tests/neg/i16453.check
+++ b/tests/neg/i16453.check
@@ -1,18 +1,12 @@
--- [E172] Type Error: tests/neg/i16453.scala:14:21 ---------------------------------------------------------------------
-14 |  summon[Option[Int]] // error
+-- [E172] Type Error: tests/neg/i16453.scala:19:21 ---------------------------------------------------------------------
+19 |  summon[Option[Int]] // error
    |                     ^
    |No given instance of type Option[Int] was found for parameter x of method summon in object Predef
    |
    |Note: implicit conversions are not automatically applied to arguments of using clauses. You will have to pass the argument explicitly.
-   |The following conversions in scope result in Option[Int]: 
-   |  - final given def given_Conversion_T_Option[T]: Conversion[T, Option[T]]
-   |  - implicit def toOption[T](t: T): Option[T]
--- [E172] Type Error: tests/neg/i16453.scala:15:25 ---------------------------------------------------------------------
-15 |  implicitly[Option[Int]] // error
+   |The following conversions in scope can be converted to Option[Int]:
+   |- given bar: Int
+-- [E172] Type Error: tests/neg/i16453.scala:20:25 ---------------------------------------------------------------------
+20 |  implicitly[Option[Int]] // error
    |                         ^
-   |No given instance of type Option[Int] was found for parameter e of method implicitly in object Predef
-   |
-   |Note: implicit conversions are not automatically applied to arguments of using clauses. You will have to pass the argument explicitly.
-   |The following conversions in scope result in Option[Int]: 
-   |  - final given def given_Conversion_T_Option[T]: Conversion[T, Option[T]]
-   |  - implicit def toOption[T](t: T): Option[T]
+   |           No given instance of type Option[Int] was found for parameter e of method implicitly in object Predef
diff --git a/tests/neg/i16453.scala b/tests/neg/i16453.scala
index 0288c05938b7..517a22cc1270 100644
--- a/tests/neg/i16453.scala
+++ b/tests/neg/i16453.scala
@@ -3,7 +3,7 @@ import scala.language.implicitConversions
 trait Foo { type T }
 
 // Scala 3 style conversion
-// given [T]: Conversion[T, Option[T]] = ???
+given [T]: Conversion[T, Option[T]] = ???
 given [F <: Foo](using f: F): Conversion[f.T, Option[f.T]] = ???
 // Scala 2 style conversion
 implicit def toOption[T](t: T): Option[T] = Option(t)

From 98bf4b2b5f7dd634e3fa54b676b1171dd1969a1a Mon Sep 17 00:00:00 2001
From: ysthakur <45539777+ysthakur@users.noreply.github.com>
Date: Sun, 29 Jan 2023 06:39:45 +0000
Subject: [PATCH 054/657] Fix inversion of if, check for errors properly

---
 .../dotty/tools/dotc/reporting/messages.scala |  2 +-
 .../dotty/tools/dotc/typer/Implicits.scala    | 38 ++++++++-------
 tests/neg/i16453.check                        | 47 ++++++++++++++++---
 tests/neg/i16453.scala                        | 34 ++++++++++----
 4 files changed, 86 insertions(+), 35 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/reporting/messages.scala b/compiler/src/dotty/tools/dotc/reporting/messages.scala
index 785f502a0f9c..f41d34b8c17c 100644
--- a/compiler/src/dotty/tools/dotc/reporting/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/messages.scala
@@ -2750,7 +2750,7 @@ class MissingImplicitArgument(
           Option.when(ignoredConvertibleImplicits.nonEmpty)(
             i"\n\nNote: implicit conversions are not automatically applied to arguments of using clauses. " +
             i"You will have to pass the argument explicitly.\n" +
-            i"The following implicits in scope can be converted to ${pt.show}:" +
+            i"The following implicits in scope can be implicitly converted to ${pt.show}:" +
             ignoredConvertibleImplicits.map { imp => s"\n- ${imp.symbol.showDcl}"}.mkString
           )
         super.msgPostscript
diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
index c016d469f5ac..1553053e9d2e 100644
--- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -928,44 +928,46 @@ trait Implicits:
       else currImplicits.refs ::: allImplicits(currImplicits.outerImplicits)
 
     /** Ensure an implicit is not a Scala 2-style implicit conversion, based on its type */
-    def notImplicitConv(typ: Type): Boolean = typ match {
-      case PolyType(_, resType) => notImplicitConv(resType)
-      case mt: MethodType => mt.isImplicitMethod || mt.isContextualMethod
-      case _ => true
-    }
-
     def isScala2Conv(typ: Type): Boolean = typ match {
       case PolyType(_, resType) => isScala2Conv(resType)
-      case mt: MethodType =>
-        (!mt.resultType.isImplicitMethod && !mt.resultType.isContextualMethod)
-          || isScala2Conv(mt.resultType)
+      case mt: MethodType => !mt.isImplicitMethod && !mt.isContextualMethod
       case _ => false
     }
 
-    def ignoredConversions = arg.tpe match
+    def hasErrors(tree: Tree): Boolean =
+      if tree.tpe.isInstanceOf[ErrorType] then true
+      else
+        tree match {
+          case Apply(_, List(arg)) => arg.tpe.isInstanceOf[ErrorType]
+          case _ => false
+        }
+
+    def ignoredConvertibleImplicits = arg.tpe match
       case fail: SearchFailureType =>
-        // Get every implicit in scope and find Conversions for each
         if (fail.expectedType eq pt) || isFullyDefined(fail.expectedType, ForceDegree.none) then
+          // Get every implicit in scope and try to convert each
           allImplicits(ctx.implicits)
+            .distinctBy(_.underlyingRef.denot)
+            .view
             .map(_.underlyingRef)
             .filter { imp =>
-              if notImplicitConv(imp.underlying) then false
+              if isScala2Conv(imp.underlying) || imp.symbol == defn.Predef_conforms then
+                false
               else
-                val locked = ctx.typerState.ownedVars
-                val tryCtx = ctx.fresh
+                // Using Mode.Printing will stop it from printing errors
                 val tried = Contexts.withMode(Mode.Printing) {
                     typed(
                       tpd.ref(imp).withSpan(arg.span),
                       fail.expectedType,
-                      locked
+                      ctx.typerState.ownedVars
                     )
-                  }(using tryCtx)
-                !tryCtx.reporter.hasErrors && fail.expectedType =:= tried.tpe
+                  }
+                !hasErrors(tried) && fail.expectedType =:= tried.tpe
             }
         else
           Nil
 
-    MissingImplicitArgument(arg, pt, where, paramSymWithMethodCallTree, ignoredInstanceNormalImport, ignoredConversions)
+    MissingImplicitArgument(arg, pt, where, paramSymWithMethodCallTree, ignoredInstanceNormalImport, ignoredConvertibleImplicits)
   }
 
   /** A string indicating the formal parameter corresponding to a  missing argument */
diff --git a/tests/neg/i16453.check b/tests/neg/i16453.check
index 5ccd9b491a1e..e01ddf5cab7a 100644
--- a/tests/neg/i16453.check
+++ b/tests/neg/i16453.check
@@ -1,12 +1,45 @@
--- [E172] Type Error: tests/neg/i16453.scala:19:21 ---------------------------------------------------------------------
-19 |  summon[Option[Int]] // error
+-- [E172] Type Error: tests/neg/i16453.scala:21:19 ---------------------------------------------------------------------
+21 |  summon[List[Int]] // error
+   |                   ^
+   |                 No given instance of type List[Int] was found for parameter x of method summon in object Predef
+-- [E172] Type Error: tests/neg/i16453.scala:23:21 ---------------------------------------------------------------------
+23 |  summon[Option[Int]] // error
    |                     ^
    |No given instance of type Option[Int] was found for parameter x of method summon in object Predef
    |
    |Note: implicit conversions are not automatically applied to arguments of using clauses. You will have to pass the argument explicitly.
-   |The following conversions in scope can be converted to Option[Int]:
-   |- given bar: Int
--- [E172] Type Error: tests/neg/i16453.scala:20:25 ---------------------------------------------------------------------
-20 |  implicitly[Option[Int]] // error
+   |The following implicits in scope can be implicitly converted to Option[Int]:
+   |- final lazy given val baz3: Char
+   |- final lazy given val bar3: Int
+-- [E172] Type Error: tests/neg/i16453.scala:24:26 ---------------------------------------------------------------------
+24 |  implicitly[Option[Char]] // error
+   |                          ^
+   |No given instance of type Option[Char] was found for parameter e of method implicitly in object Predef
+   |
+   |Note: implicit conversions are not automatically applied to arguments of using clauses. You will have to pass the argument explicitly.
+   |The following implicits in scope can be implicitly converted to Option[Char]:
+   |- final lazy given val baz3: Char
+-- [E172] Type Error: tests/neg/i16453.scala:25:20 ---------------------------------------------------------------------
+25 |  implicitly[String] // error
+   |                    ^
+   |No given instance of type String was found for parameter e of method implicitly in object Predef
+   |
+   |Note: implicit conversions are not automatically applied to arguments of using clauses. You will have to pass the argument explicitly.
+   |The following implicits in scope can be implicitly converted to String:
+   |- final lazy given val baz3: Char
+-- [E172] Type Error: tests/neg/i16453.scala:35:16 ---------------------------------------------------------------------
+35 |  summon[String] // error
+   |                ^
+   |No given instance of type String was found for parameter x of method summon in object Predef
+   |
+   |Note: implicit conversions are not automatically applied to arguments of using clauses. You will have to pass the argument explicitly.
+   |The following implicits in scope can be implicitly converted to String:
+   |- implicit val baz2: Char
+-- [E172] Type Error: tests/neg/i16453.scala:36:25 ---------------------------------------------------------------------
+36 |  implicitly[Option[Int]] // error
    |                         ^
-   |           No given instance of type Option[Int] was found for parameter e of method implicitly in object Predef
+   |No given instance of type Option[Int] was found for parameter e of method implicitly in object Predef
+   |
+   |Note: implicit conversions are not automatically applied to arguments of using clauses. You will have to pass the argument explicitly.
+   |The following implicits in scope can be implicitly converted to Option[Int]:
+   |- implicit val bar2: Int
diff --git a/tests/neg/i16453.scala b/tests/neg/i16453.scala
index 517a22cc1270..00495c39e21a 100644
--- a/tests/neg/i16453.scala
+++ b/tests/neg/i16453.scala
@@ -2,20 +2,36 @@ import scala.language.implicitConversions
 
 trait Foo { type T }
 
-// Scala 3 style conversion
-given [T]: Conversion[T, Option[T]] = ???
-given [F <: Foo](using f: F): Conversion[f.T, Option[f.T]] = ???
-// Scala 2 style conversion
-implicit def toOption[T](t: T): Option[T] = Option(t)
-
 // This one is irrelevant, shouldn't be included in error message
-given irrelevant: Conversion[Int, Option[Long]] = ???
+given irrelevant: Long = ???
+
+/** Use Scala 3 givens/conversions */
+def testScala3() = {
+  given c1[T]: Conversion[T, Option[T]] = ???
+  given c2[F <: Foo](using f: F): Conversion[f.T, Option[f.T]] = ???
+  given Conversion[Char, String] = ???
+  given Conversion[Char, Option[Int]] = ???
 
-def test() = {
   given foo: Foo with
     type T = Int
-  given bar: Int = 0
+  given bar3: Int = 0
+  given baz3: Char = 'a'
+
+  // This should get the usual error
+  summon[List[Int]] // error
 
   summon[Option[Int]] // error
+  implicitly[Option[Char]] // error
+  implicitly[String] // error
+}
+
+/** Use Scala 2 implicits */
+def testScala2() = {
+  implicit def toOpt[T](t: T): Option[T] = ???
+  implicit def char2Str(c: Char): String = ???
+  implicit val bar2: Int = 1
+  implicit val baz2: Char = 'b'
+
+  summon[String] // error
   implicitly[Option[Int]] // error
 }

From 12a8051b7712327fe81c9bc062cb78c60e4e7ce2 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Sun, 29 Jan 2023 19:24:18 +0000
Subject: [PATCH 055/657] Infer: Don't minimise to Nothing if there's an upper
 bound

---
 .../src/dotty/tools/dotc/core/Types.scala     |  2 +-
 .../dotty/tools/dotc/typer/Inferencing.scala  |  2 +-
 .../tools/dotc/typer/InstantiateModel.scala   | 57 +++++++++++++++++++
 tests/neg/i15525.scala                        |  2 +-
 tests/pos/i14218.http4s.scala                 | 22 +++++++
 tests/pos/i14218.scala                        | 15 +++++
 6 files changed, 97 insertions(+), 3 deletions(-)
 create mode 100644 compiler/test/dotty/tools/dotc/typer/InstantiateModel.scala
 create mode 100644 tests/pos/i14218.http4s.scala
 create mode 100644 tests/pos/i14218.scala

diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index 15b0b00ed0f3..d2fc225ff19d 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -4781,7 +4781,7 @@ object Types {
     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)
+    def hasUpperBound(using Context): Boolean = !currentEntry.hiBound.finalResultType.isExactlyAny
 
     /** Unwrap to instance (if instantiated) or origin (if not), until result
      *  is no longer a TypeVar
diff --git a/compiler/src/dotty/tools/dotc/typer/Inferencing.scala b/compiler/src/dotty/tools/dotc/typer/Inferencing.scala
index be74cb0fa2ec..af4174423cbc 100644
--- a/compiler/src/dotty/tools/dotc/typer/Inferencing.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Inferencing.scala
@@ -183,7 +183,7 @@ object Inferencing {
               // 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
+            else if variance >= 0 && (force.ifBottom == IfBottom.ok && !tvar.hasUpperBound || tvar.hasLowerBound) then
               instantiate(tvar, fromBelow = true)
             else if variance >= 0 && force.ifBottom == IfBottom.fail then
               return false
diff --git a/compiler/test/dotty/tools/dotc/typer/InstantiateModel.scala b/compiler/test/dotty/tools/dotc/typer/InstantiateModel.scala
new file mode 100644
index 000000000000..b08062913dac
--- /dev/null
+++ b/compiler/test/dotty/tools/dotc/typer/InstantiateModel.scala
@@ -0,0 +1,57 @@
+package dotty.tools
+package dotc
+package typer
+
+// Modelling the decision in IsFullyDefined
+object InstantiateModel:
+  enum LB  { case NN; case LL; case L1                             }; import LB.*
+  enum UB  { case AA; case UU; case U1                             }; import UB.*
+  enum Var { case V; case NotV                                     }; import Var.*
+  enum MSe { case M; case NotM                                     }; import MSe.*
+  enum Bot { case Fail; case Ok; case Flip                         }; import Bot.*
+  enum Act { case Min; case Max; case ToMax; case Skip; case False }; import Act.*
+
+  // NN/AA = Nothing/Any
+  // LL/UU = the original bounds, on the type parameter
+  // L1/U1 = the constrained bounds, on the type variable
+  // V     = variance >= 0 ("non-contravariant")
+  // MSe   = minimisedSelected
+  // Bot   = IfBottom
+  // ToMax = delayed maximisation, via addition to toMaximize
+  // Skip  = minimisedSelected "hold off instantiating"
+  // False = return false
+
+  // there are 9 combinations:
+  // # | LB | UB | d | // d = direction
+  // --+----+----+---+
+  // 1 | L1 | AA | - |       L1 <: T
+  // 2 | L1 | UU | - |       L1 <: T       <: UU
+  // 3 | LL | U1 | + | LL <:       T <: U1
+  // 4 | NN | U1 | + |             T <: U1
+  // 5 | L1 | U1 | 0 |       L1 <: T <: U1
+  // 6 | LL | UU | 0 | LL <:       T       <: UU
+  // 7 | LL | AA | 0 | LL <:       T
+  // 8 | NN | UU | 0 |             T       <: UU
+  // 9 | NN | AA | 0 |             T
+
+  def decide(lb: LB, ub: UB, v: Var, bot: Bot, m: MSe): Act = (lb, ub) match
+    case (L1, AA) => Min
+    case (L1, UU) => Min
+    case (LL, U1) => Max
+    case (NN, U1) => Max
+
+    case (L1, U1) => if m==M || v==V then Min else ToMax
+    case (LL, UU) => if m==M || v==V then Min else ToMax
+    case (LL, AA) => if m==M || v==V then Min else ToMax
+
+    case (NN, UU) => bot match
+      case _    if m==M => Max
+    //case Ok   if v==V => Min   // removed, i14218 fix
+      case Fail if v==V => False
+      case _            => ToMax
+
+    case (NN, AA) => bot match
+      case _    if m==M => Skip
+      case Ok   if v==V => Min
+      case Fail if v==V => False
+      case _            => ToMax
diff --git a/tests/neg/i15525.scala b/tests/neg/i15525.scala
index 0813d7c82435..b14c244b43c8 100644
--- a/tests/neg/i15525.scala
+++ b/tests/neg/i15525.scala
@@ -37,7 +37,7 @@ def element22(
       transmittable20.Type / transmittable21.Type
   } = ???
 
-def test22 =
+def test22 = // error
   Resolution(
     element22(
       Resolution(element0), Resolution(element0), // error // error
diff --git a/tests/pos/i14218.http4s.scala b/tests/pos/i14218.http4s.scala
new file mode 100644
index 000000000000..774a5432177e
--- /dev/null
+++ b/tests/pos/i14218.http4s.scala
@@ -0,0 +1,22 @@
+// A minimisation from http4s,
+// which broke while implementing the fix for i14218.
+
+final class Bar[+F[_]]
+object Bar:
+  def empty[F[_]]: Bar[F] = new Bar[Nothing]
+
+final class Foo[+F[_]]
+
+object Foo:
+  def apply[F[_]](bar: Bar[F] = Bar.empty): Foo[F]    = new Foo
+
+class Test:
+  def test[F[_]]: Foo[F] = Foo[F]()
+
+//-- [E007] Type Mismatch Error
+//12 |  def test[F[_]]: Foo[F] = Foo[F]()
+//   |                           ^^^^^^
+//   |              Found:    Bar[[_] =>> Any]
+//   |              Required: Bar[F]
+//   |
+//   |              where:    F is a type in method t1 with bounds <: [_] =>> Any
diff --git a/tests/pos/i14218.scala b/tests/pos/i14218.scala
new file mode 100644
index 000000000000..e35aec94b3bd
--- /dev/null
+++ b/tests/pos/i14218.scala
@@ -0,0 +1,15 @@
+class Pet
+class Cat extends Pet
+
+class Z1[ S1 <: Pet](val fn: S1 => Unit)
+class Z2[ S2       ](val fn: S2 => Unit)
+class Z3[-S3 <: Pet](val fn: S3 => Unit)
+
+abstract class Test:
+  def test =
+    val r1 = new Z1((_: Pet) => ()); eat[Z1[Pet]](r1) // the case: using the parameter bound in situ infers Z[Nothing]
+    val r2 = new Z2((_: Pet) => ()); eat[Z2[Pet]](r2) // counter-example: infers as desired without an upper bound
+    val r3 = new Z3((_: Pet) => ()); eat[Z3[Pet]](r3) // workaround: declare it contravariant
+    val r4 = new Z1((_: Cat) => ()); eat[Z1[Cat]](r4) // counter-example: infers as desired with a subtype
+
+  def eat[T](x: T): Unit

From 942e184e72066093e768185bc9b5f3aa9c5f3805 Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wojciech.mazur95@gmail.com>
Date: Mon, 30 Jan 2023 17:54:44 +0100
Subject: [PATCH 056/657] Don't allow SemanticDB write to output directory JAR.

Writing to outputDirectory when it is a JAR can lead to producing malformed file, it is using FileOutputStream which works somehow correct, but if we would open the same JAR again in later phase (eg. genBCode) header of the file would be malformed: the result file grows in size respectively to provided input, but we can read only files written by SemanticDB phase.
---
 .../dotc/semanticdb/ExtractSemanticDB.scala   | 20 +++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala
index 071efb1fb91c..84bc1e77a1ef 100644
--- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala
+++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala
@@ -24,6 +24,7 @@ import scala.annotation.{ threadUnsafe => tu, tailrec }
 import scala.PartialFunction.condOpt
 
 import dotty.tools.dotc.{semanticdb => s}
+import dotty.tools.io.{AbstractFile, JarArchive}
 
 /** Extract symbol references and uses to semanticdb files.
  *  See https://scalameta.org/docs/semanticdb/specification.html#symbol-1
@@ -38,7 +39,9 @@ class ExtractSemanticDB extends Phase:
   override val description: String = ExtractSemanticDB.description
 
   override def isRunnable(using Context) =
-    super.isRunnable && ctx.settings.Xsemanticdb.value
+    import ExtractSemanticDB.{semanticdbTarget, outputDirectory}
+    def writesToOutputJar = semanticdbTarget.isEmpty && outputDirectory.isInstanceOf[JarArchive]
+    super.isRunnable && ctx.settings.Xsemanticdb.value && !writesToOutputJar
 
   // Check not needed since it does not transform trees
   override def isCheckable: Boolean = false
@@ -475,6 +478,13 @@ object ExtractSemanticDB:
   val name: String = "extractSemanticDB"
   val description: String = "extract info into .semanticdb files"
 
+  private def semanticdbTarget(using Context): Option[Path] =
+    Option(ctx.settings.semanticdbTarget.value)
+      .filterNot(_.isEmpty)
+      .map(Paths.get(_))
+
+  private def outputDirectory(using Context): AbstractFile = ctx.settings.outputDir.value
+
   def write(
     source: SourceFile,
     occurrences: List[SymbolOccurrence],
@@ -482,14 +492,8 @@ object ExtractSemanticDB:
     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
+    val outpath = absolutePath(semanticdbTarget.getOrElse(outputDirectory.jpath))
       .resolve("META-INF")
       .resolve("semanticdb")
       .resolve(relPath)

From 2fafeaa7a5dbeb5f65bbbe9efb02d6b85f1e798b Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wmazur@virtuslab.com>
Date: Mon, 30 Jan 2023 18:43:41 +0100
Subject: [PATCH 057/657] Remove not used integration with Open Community Build
 (#16751)

This change removes integration with Open Community Build, triggering
builds after publishing a new nightly version. This feature was not
really used previously - nightly builds we're testing only 100 - 200
projects, and we relied on weekly builds (with over 1k projects) anyway.

This change makes project secret `BUILD_TOKEN` obsolete.
---
 .github/workflows/ci.yaml                     | 39 -------------------
 .../scripts/triggerUnmanagedCommunityBuild.sh | 37 ------------------
 2 files changed, 76 deletions(-)
 delete mode 100755 .github/workflows/scripts/triggerUnmanagedCommunityBuild.sh

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 72e7149fa762..46a4e6064d07 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -585,45 +585,6 @@ jobs:
           external_repository: lampepfl/dotty-website
           publish_branch: gh-pages
 
-  nightly_unmanaged_community_build:
-    # Self-hosted runner is used only for getting current build version
-    runs-on: [self-hosted, Linux]
-    container:
-      image: lampepfl/dotty:2021-03-22
-      options: --cpu-shares 4096
-      volumes:
-        - ${{ github.workspace }}/../../cache/sbt:/root/.sbt
-        - ${{ github.workspace }}/../../cache/ivy:/root/.ivy2/cache
-        - ${{ github.workspace }}/../../cache/general:/root/.cache
-    needs: [publish_nightly]
-    if: "(github.event_name == 'schedule' || github.event_name == 'workflow_dispatch') && github.repository == 'lampepfl/dotty'"
-    env:
-      NIGHTLYBUILD: yes
-    steps:
-      - name: Reset existing repo
-        run: git -c "http.https://github.com/.extraheader=" fetch --recurse-submodules=no "https://github.com/lampepfl/dotty" && git reset --hard FETCH_HEAD || true
-
-      - name: Checkout cleanup script
-        uses: actions/checkout@v3
-
-      - name: Cleanup
-        run: .github/workflows/cleanup.sh
-
-      - name: Git Checkout
-        uses: actions/checkout@v3
-
-      - name: Add SBT proxy repositories
-        run: cp -vf .github/workflows/repositories /root/.sbt/ ; true
-
-      - name: Get version string for this build
-        run: |
-          ver=$(./project/scripts/sbt "print scala3-compiler-bootstrapped/version" | tail -n1)
-          echo "This build version: $ver"
-          echo "THISBUILD_VERSION=$ver" >> $GITHUB_ENV
-      # Steps above are copy-pasted from publish_nightly, needed only to resolve THISBUILD_VERSION
-      - name: Trigger unmanaged community build
-        run: .github/workflows/scripts/triggerUnmanagedCommunityBuild.sh "${{ secrets.BUILD_TOKEN }}" "$THISBUILD_VERSION"
-
   publish_release:
     permissions:
       contents: write  # for actions/create-release to create a release
diff --git a/.github/workflows/scripts/triggerUnmanagedCommunityBuild.sh b/.github/workflows/scripts/triggerUnmanagedCommunityBuild.sh
deleted file mode 100755
index 694428e29bb5..000000000000
--- a/.github/workflows/scripts/triggerUnmanagedCommunityBuild.sh
+++ /dev/null
@@ -1,37 +0,0 @@
-#!/usr/bin/env bash
-
-# This is script for triggering unamanged community build upon releasing nightly version.
-# Script sends request to CB Jenkins instance to start the build for given released Scala version
-# Prints url of created job to stdout
-#
-# Requirement:
-#   - the latest (nightly) version of scala should be published
-
-set -u
-
-if [ $# -ne 2 ]; then
-  echo "Wrong number of script arguments, expected <token> <scala-version>, got $#: $@"
-  exit 1
-fi
-
-CB_ENDPOINT=https://scala3.westeurope.cloudapp.azure.com
-CB_BUILD_TOKEN="$1"
-SCALA_VERSION="$2"
-
-startRunResponse=$(curl "${CB_ENDPOINT}/job/runBuild/buildWithParameters?token=${CB_BUILD_TOKEN}&publishedScalaVersion=${SCALA_VERSION}" -v 2>&1)
-echo "${startRunResponse}"
-queueItem=$(echo "${startRunResponse}" | grep -oP "< Location: \K[\w\d:/.//]+")
-# Wait until Jenkins does acknowledge the build (max 1 min )
-for i in {1..12}; do
-  buildUrl=$(curl -s "${queueItem}/api/json?tree=executable[url]" | jq .executable.url)
-  if [[ "null" == "${buildUrl}" ]]; then
-    echo "Waiting for build start..."
-    sleep 5
-  else
-    echo "Created build url: ${buildUrl}"
-    exit 0
-  fi
-done
-
-# Set error if failed to resolve build url
-exit 1

From 18a8a096e4f123e9375e779e487f4ac672dfbf87 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C5=81ukasz=20Wro=C5=84ski?= <lukaszwronski98@gmail.com>
Date: Sat, 28 Jan 2023 12:47:07 +0100
Subject: [PATCH 058/657] Attach explanation message to diagnostic message

---
 sbt-bridge/src/dotty/tools/xsbt/DelegatingReporter.java | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/sbt-bridge/src/dotty/tools/xsbt/DelegatingReporter.java b/sbt-bridge/src/dotty/tools/xsbt/DelegatingReporter.java
index 3e1e291ab7d1..25b934000144 100644
--- a/sbt-bridge/src/dotty/tools/xsbt/DelegatingReporter.java
+++ b/sbt-bridge/src/dotty/tools/xsbt/DelegatingReporter.java
@@ -39,13 +39,16 @@ public void doReport(Diagnostic dia, Context ctx) {
     StringBuilder rendered = new StringBuilder();
     rendered.append(messageAndPos(dia, ctx));
     Message message = dia.msg();
+    StringBuilder messageBuilder = new StringBuilder();
+    messageBuilder.append(message.message());
     String diagnosticCode = String.valueOf(message.errorId().errorNumber());
     boolean shouldExplain = Diagnostic.shouldExplain(dia, ctx);
     if (shouldExplain && !message.explanation().isEmpty()) {
       rendered.append(explanation(message, ctx));
+      messageBuilder.append(System.lineSeparator()).append(explanation(message, ctx));
     }
 
-    delegate.log(new Problem(position, message.message(), severity, rendered.toString(), diagnosticCode));
+    delegate.log(new Problem(position, messageBuilder.toString(), severity, rendered.toString(), diagnosticCode));
   }
 
   private static Severity severityOf(int level) {

From dda91bba3387155bd40677c238722fe72ec597eb Mon Sep 17 00:00:00 2001
From: ysthakur <45539777+ysthakur@users.noreply.github.com>
Date: Mon, 30 Jan 2023 21:11:46 -0500
Subject: [PATCH 059/657] Make code more readable

---
 .../dotty/tools/dotc/typer/Implicits.scala    | 42 ++++++++++---------
 1 file changed, 22 insertions(+), 20 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
index 1553053e9d2e..3ebe60e327ea 100644
--- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -927,42 +927,44 @@ trait Implicits:
       if currImplicits.outerImplicits == null then currImplicits.refs
       else currImplicits.refs ::: allImplicits(currImplicits.outerImplicits)
 
-    /** Ensure an implicit is not a Scala 2-style implicit conversion, based on its type */
-    def isScala2Conv(typ: Type): Boolean = typ match {
-      case PolyType(_, resType) => isScala2Conv(resType)
+    /** Whether the given type is for an implicit def that's a Scala 2 implicit conversion */
+    def isImplicitDefConversion(typ: Type): Boolean = typ match {
+      case PolyType(_, resType) => isImplicitDefConversion(resType)
       case mt: MethodType => !mt.isImplicitMethod && !mt.isContextualMethod
       case _ => false
     }
 
-    def hasErrors(tree: Tree): Boolean =
-      if tree.tpe.isInstanceOf[ErrorType] then true
-      else
-        tree match {
+    /** Whether a found implicit be converted to the desired type */
+    def canBeConverted(ref: TermRef, expected: Type): Boolean = {
+      // Using Mode.Printing will stop it from printing errors
+      val tried = Contexts.withMode(Mode.Printing) {
+          typed(
+            tpd.ref(ref).withSpan(arg.span),
+            expected,
+            ctx.typerState.ownedVars
+          )
+        }
+      val hasErrors =
+        if tried.tpe.isInstanceOf[ErrorType] then true
+        else tried match {
           case Apply(_, List(arg)) => arg.tpe.isInstanceOf[ErrorType]
           case _ => false
         }
+      !hasErrors && expected =:= tried.tpe
+    }
 
     def ignoredConvertibleImplicits = arg.tpe match
       case fail: SearchFailureType =>
         if (fail.expectedType eq pt) || isFullyDefined(fail.expectedType, ForceDegree.none) then
           // Get every implicit in scope and try to convert each
           allImplicits(ctx.implicits)
-            .distinctBy(_.underlyingRef.denot)
             .view
             .map(_.underlyingRef)
+            .distinctBy(_.denot)
             .filter { imp =>
-              if isScala2Conv(imp.underlying) || imp.symbol == defn.Predef_conforms then
-                false
-              else
-                // Using Mode.Printing will stop it from printing errors
-                val tried = Contexts.withMode(Mode.Printing) {
-                    typed(
-                      tpd.ref(imp).withSpan(arg.span),
-                      fail.expectedType,
-                      ctx.typerState.ownedVars
-                    )
-                  }
-                !hasErrors(tried) && fail.expectedType =:= tried.tpe
+              !isImplicitDefConversion(imp.underlying)
+                && imp.symbol != defn.Predef_conforms
+                && canBeConverted(imp, fail.expectedType)
             }
         else
           Nil

From 2584cf6aee10970a51c00f371980ff87e3aa204b Mon Sep 17 00:00:00 2001
From: ysthakur <45539777+ysthakur@users.noreply.github.com>
Date: Mon, 30 Jan 2023 21:12:53 -0500
Subject: [PATCH 060/657] Remove unnecessary check for Predef.conforms

---
 compiler/src/dotty/tools/dotc/typer/Implicits.scala | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
index 3ebe60e327ea..5d97adea514e 100644
--- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -962,9 +962,7 @@ trait Implicits:
             .map(_.underlyingRef)
             .distinctBy(_.denot)
             .filter { imp =>
-              !isImplicitDefConversion(imp.underlying)
-                && imp.symbol != defn.Predef_conforms
-                && canBeConverted(imp, fail.expectedType)
+              !isImplicitDefConversion(imp.underlying) && canBeConverted(imp, fail.expectedType)
             }
         else
           Nil

From 95c9dfba8f8efbf578a1baad1740179cdfb14354 Mon Sep 17 00:00:00 2001
From: ysthakur <45539777+ysthakur@users.noreply.github.com>
Date: Mon, 30 Jan 2023 22:48:48 -0500
Subject: [PATCH 061/657] Put check for Predef.conforms back

---
 compiler/src/dotty/tools/dotc/typer/Implicits.scala | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
index 5d97adea514e..3ebe60e327ea 100644
--- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -962,7 +962,9 @@ trait Implicits:
             .map(_.underlyingRef)
             .distinctBy(_.denot)
             .filter { imp =>
-              !isImplicitDefConversion(imp.underlying) && canBeConverted(imp, fail.expectedType)
+              !isImplicitDefConversion(imp.underlying)
+                && imp.symbol != defn.Predef_conforms
+                && canBeConverted(imp, fail.expectedType)
             }
         else
           Nil

From 1a84513dae20ffb04b5426c79acfe1c2d7486bed Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 24 Jan 2023 16:13:22 +0100
Subject: [PATCH 062/657] Prepare bodies of inline forwarders eagerly

Fixes #14131
Fixes #16469
---
 compiler/src/dotty/tools/dotc/typer/Namer.scala | 16 ++++++++++++----
 tests/pos-macros/i14131.scala                   | 11 +++++++++++
 tests/pos/i16469.scala                          | 15 +++++++++++++++
 3 files changed, 38 insertions(+), 4 deletions(-)
 create mode 100644 tests/pos-macros/i14131.scala
 create mode 100644 tests/pos/i16469.scala

diff --git a/compiler/src/dotty/tools/dotc/typer/Namer.scala b/compiler/src/dotty/tools/dotc/typer/Namer.scala
index 6cdd0150518b..d9c857279266 100644
--- a/compiler/src/dotty/tools/dotc/typer/Namer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Namer.scala
@@ -1227,13 +1227,21 @@ class Namer { typer: Typer =>
               case pt: MethodOrPoly => 1 + extensionParamsCount(pt.resType)
               case _ => 0
             val ddef = tpd.DefDef(forwarder.asTerm, prefss => {
+              val forwarderCtx = ctx.withOwner(forwarder)
               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))
+              val rhs = ref.appliedToArgss(adaptForwarderParams(Nil, sym.info, methRefss))
+                .etaExpandCFT(using forwarderCtx)
+              if forwarder.isInlineMethod then
+                // Eagerly make the body inlineable. `registerInlineInfo` does this lazily
+                // but it does not get evaluated during typer as the forwarder we are creating
+                // is already typed.
+                val inlinableRhs = PrepareInlineable.makeInlineable(rhs)(using forwarderCtx)
+                PrepareInlineable.registerInlineInfo(forwarder, inlinableRhs)(using forwarderCtx)
+                inlinableRhs
+              else
+                rhs
             })
-            if forwarder.isInlineMethod then
-              PrepareInlineable.registerInlineInfo(forwarder, ddef.rhs)
             buf += ddef.withSpan(span)
             if hasDefaults then
               foreachDefaultGetterOf(sym.asTerm,
diff --git a/tests/pos-macros/i14131.scala b/tests/pos-macros/i14131.scala
new file mode 100644
index 000000000000..76c01839a17f
--- /dev/null
+++ b/tests/pos-macros/i14131.scala
@@ -0,0 +1,11 @@
+class Dog:
+  inline given bark(using msg: String = "Woof!"): String = s"bark: $msg"
+
+class Wolf:
+  private val dog: Dog = Dog()
+  export dog.given
+
+def test =
+  val w = Wolf()
+  import w.given
+  summon[String]
diff --git a/tests/pos/i16469.scala b/tests/pos/i16469.scala
new file mode 100644
index 000000000000..1aaa381bb7e2
--- /dev/null
+++ b/tests/pos/i16469.scala
@@ -0,0 +1,15 @@
+class Context {
+  def normalMethod(): String = "normal"
+  inline def inlineMethod(): String = "inline"
+}
+
+class Script(ctx: Context) {
+  export ctx.*
+  normalMethod()
+  inlineMethod()
+}
+
+class MyScript(context: Context) extends Script(context) {
+  normalMethod()
+  inlineMethod()
+}

From 809f9fc91aade75b91c759aebe7d49335888f994 Mon Sep 17 00:00:00 2001
From: ysthakur <45539777+ysthakur@users.noreply.github.com>
Date: Tue, 31 Jan 2023 12:25:48 -0500
Subject: [PATCH 063/657] Use viewExists

---
 .../dotty/tools/dotc/typer/Implicits.scala    | 21 +------------------
 1 file changed, 1 insertion(+), 20 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
index 3ebe60e327ea..08ec108a6d9a 100644
--- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -934,25 +934,6 @@ trait Implicits:
       case _ => false
     }
 
-    /** Whether a found implicit be converted to the desired type */
-    def canBeConverted(ref: TermRef, expected: Type): Boolean = {
-      // Using Mode.Printing will stop it from printing errors
-      val tried = Contexts.withMode(Mode.Printing) {
-          typed(
-            tpd.ref(ref).withSpan(arg.span),
-            expected,
-            ctx.typerState.ownedVars
-          )
-        }
-      val hasErrors =
-        if tried.tpe.isInstanceOf[ErrorType] then true
-        else tried match {
-          case Apply(_, List(arg)) => arg.tpe.isInstanceOf[ErrorType]
-          case _ => false
-        }
-      !hasErrors && expected =:= tried.tpe
-    }
-
     def ignoredConvertibleImplicits = arg.tpe match
       case fail: SearchFailureType =>
         if (fail.expectedType eq pt) || isFullyDefined(fail.expectedType, ForceDegree.none) then
@@ -964,7 +945,7 @@ trait Implicits:
             .filter { imp =>
               !isImplicitDefConversion(imp.underlying)
                 && imp.symbol != defn.Predef_conforms
-                && canBeConverted(imp, fail.expectedType)
+                && viewExists(imp, fail.expectedType)
             }
         else
           Nil

From 2dd2595b90f36433aec5c4a59a5f9db33efef736 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Wed, 1 Feb 2023 09:28:00 +0100
Subject: [PATCH 064/657] Add regression test

Closes #16792
---
 tests/pos/i16792.scala | 2 ++
 1 file changed, 2 insertions(+)
 create mode 100644 tests/pos/i16792.scala

diff --git a/tests/pos/i16792.scala b/tests/pos/i16792.scala
new file mode 100644
index 000000000000..5a44d8c09458
--- /dev/null
+++ b/tests/pos/i16792.scala
@@ -0,0 +1,2 @@
+val x = (1, 1) match
+  case _: (_ *: _) => ()

From 67a0e2c56b82e2b78d2478d870be60c29772f68d Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Wed, 1 Feb 2023 17:39:54 +0100
Subject: [PATCH 065/657] Fix static lazy field holder for GraalVM

---
 .../lazyvals/InitializedAccessInt.scala       | 30 +++++++++++++++++++
 .../lazyvals/InitializedObject.scala          | 22 ++++++++++++++
 .../tools/benchmarks/lazyvals/LazyVals.scala  | 18 +++++++++++
 .../tools/backend/jvm/BCodeSkelBuilder.scala  |  2 +-
 .../backend/jvm/DottyBackendInterface.scala   |  7 +++--
 .../dotty/tools/dotc/transform/LazyVals.scala | 11 ++-----
 6 files changed, 77 insertions(+), 13 deletions(-)
 create mode 100644 bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/InitializedAccessInt.scala
 create mode 100644 bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/InitializedObject.scala

diff --git a/bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/InitializedAccessInt.scala b/bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/InitializedAccessInt.scala
new file mode 100644
index 000000000000..2a115ad63496
--- /dev/null
+++ b/bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/InitializedAccessInt.scala
@@ -0,0 +1,30 @@
+package dotty.tools.benchmarks.lazyvals
+
+import org.openjdk.jmh.annotations.*
+import org.openjdk.jmh.infra.Blackhole
+import LazyVals.LazyIntHolder
+import java.util.concurrent.TimeUnit
+
+@BenchmarkMode(Array(Mode.AverageTime))
+@Fork(2)
+@Threads(1)
+@Warmup(iterations = 5)
+@Measurement(iterations = 5)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@State(Scope.Benchmark)
+class InitializedAccessInt {
+
+  var holder: LazyIntHolder = _
+
+  @Setup
+  def prepare: Unit = {
+    holder = new LazyIntHolder
+    holder.value
+  }
+
+  @Benchmark
+  def measureInitialized(bh: Blackhole) = {
+    bh.consume(holder)
+    bh.consume(holder.value)
+  }
+}
diff --git a/bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/InitializedObject.scala b/bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/InitializedObject.scala
new file mode 100644
index 000000000000..672cc4bf6544
--- /dev/null
+++ b/bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/InitializedObject.scala
@@ -0,0 +1,22 @@
+package dotty.tools.benchmarks.lazyvals
+
+import org.openjdk.jmh.annotations.*
+import org.openjdk.jmh.infra.Blackhole
+import LazyVals.ObjectHolder
+import java.util.concurrent.TimeUnit
+
+@BenchmarkMode(Array(Mode.AverageTime))
+@Fork(2)
+@Threads(1)
+@Warmup(iterations = 5)
+@Measurement(iterations = 5)
+@OutputTimeUnit(TimeUnit.NANOSECONDS)
+@State(Scope.Benchmark)
+class InitializedObject {
+
+  @Benchmark
+  def measureInitialized(bh: Blackhole) = {
+    bh.consume(ObjectHolder)
+    bh.consume(ObjectHolder.value)
+  }
+}
diff --git a/bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/LazyVals.scala b/bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/LazyVals.scala
index 0afd93d086be..68379f9e142c 100644
--- a/bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/LazyVals.scala
+++ b/bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/LazyVals.scala
@@ -50,4 +50,22 @@ object LazyVals {
             }
         }
     }
+
+    class LazyIntHolder {
+        lazy val value: Int = {
+            (System.nanoTime() % 1000).toInt
+        }
+    }
+
+    object ObjectHolder {
+        lazy val value: String = {
+            System.nanoTime() % 5 match {
+                case 0 => "abc"
+                case 1 => "def"
+                case 2 => "ghi"
+                case 3 => "jkl"
+                case 4 => "mno"
+            }
+        }
+    }
 }
diff --git a/compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala b/compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala
index 1885210a6687..9c1ff1f26763 100644
--- a/compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala
+++ b/compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala
@@ -151,7 +151,7 @@ trait BCodeSkelBuilder extends BCodeHelpers {
 
         // !!! Part of this logic is duplicated in JSCodeGen.genCompilationUnit
         claszSymbol.info.decls.foreach { f =>
-          if f.isField && !f.name.is(LazyBitMapName) then
+          if f.isField && !f.name.is(LazyBitMapName) && !f.name.is(LazyLocalName) then
             f.setFlag(JavaStatic)
         }
 
diff --git a/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala b/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
index ecdd0ae98803..f8f683a429f6 100644
--- a/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
+++ b/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
@@ -22,7 +22,7 @@ import dotty.tools.dotc.report
 import tpd._
 
 import StdNames.nme
-import NameKinds.LazyBitMapName
+import NameKinds.{LazyBitMapName, LazyLocalName}
 import Names.Name
 
 class DottyBackendInterface(val outputDirectory: AbstractFile, val superCallsMap: ReadOnlyMap[Symbol, Set[ClassSymbol]])(using val ctx: Context) {
@@ -129,10 +129,11 @@ object DottyBackendInterface {
        *        the new lazy val encoding: https://github.com/lampepfl/dotty/issues/7140
        */
       def isStaticModuleField(using Context): Boolean =
-        sym.owner.isStaticModuleClass && sym.isField && !sym.name.is(LazyBitMapName)
+        sym.owner.isStaticModuleClass && sym.isField && !sym.name.is(LazyBitMapName) && !sym.name.is(LazyLocalName)
 
       def isStaticMember(using Context): Boolean = (sym ne NoSymbol) &&
-        (sym.is(JavaStatic) || sym.isScalaStatic || sym.isStaticModuleField)
+          (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
 
       /**
diff --git a/compiler/src/dotty/tools/dotc/transform/LazyVals.scala b/compiler/src/dotty/tools/dotc/transform/LazyVals.scala
index 0a9a2b1214b2..0861350c30a9 100644
--- a/compiler/src/dotty/tools/dotc/transform/LazyVals.scala
+++ b/compiler/src/dotty/tools/dotc/transform/LazyVals.scala
@@ -466,13 +466,9 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
     val containerSymbol = newSymbol(claz, containerName, x.symbol.flags &~ containerFlagsMask | containerFlags | Private, defn.ObjectType, coord = x.symbol.coord).enteredAfter(this)
     containerSymbol.addAnnotation(Annotation(defn.VolatileAnnot, containerSymbol.span)) // 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)
+    containerSymbol.removeAnnotation(defn.ScalaStaticAnnot)
+    containerSymbol.resetFlag(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)
 
@@ -490,9 +486,6 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
     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)

From 7bdfa4fa4242761c2ea5de888b0f49255d56c569 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Wed, 1 Feb 2023 18:19:19 +0100
Subject: [PATCH 066/657] No need to reset JavaStatic as its removed with the
 amsk

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

diff --git a/compiler/src/dotty/tools/dotc/transform/LazyVals.scala b/compiler/src/dotty/tools/dotc/transform/LazyVals.scala
index 0861350c30a9..8d3702190763 100644
--- a/compiler/src/dotty/tools/dotc/transform/LazyVals.scala
+++ b/compiler/src/dotty/tools/dotc/transform/LazyVals.scala
@@ -467,7 +467,6 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
     containerSymbol.addAnnotation(Annotation(defn.VolatileAnnot, containerSymbol.span)) // private @volatile var _x: AnyRef
     containerSymbol.addAnnotations(x.symbol.annotations) // pass annotations from original definition
     containerSymbol.removeAnnotation(defn.ScalaStaticAnnot)
-    containerSymbol.resetFlag(JavaStatic)
     val getOffset =
         Select(ref(defn.LazyValsModule), lazyNme.RLazyVals.getOffsetStatic)
     val containerTree = ValDef(containerSymbol, nullLiteral)

From bd17ec592991eb8d2c7b5935b7deba21d3d0ee3a Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Wed, 1 Feb 2023 18:25:07 +0100
Subject: [PATCH 067/657] Removing getStaticFieldOffset as it's not used
 anymore

---
 compiler/src/dotty/tools/dotc/transform/LazyVals.scala | 1 -
 library/src/scala/runtime/LazyVals.scala               | 8 --------
 2 files changed, 9 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/LazyVals.scala b/compiler/src/dotty/tools/dotc/transform/LazyVals.scala
index 8d3702190763..e4cb21a279d6 100644
--- a/compiler/src/dotty/tools/dotc/transform/LazyVals.scala
+++ b/compiler/src/dotty/tools/dotc/transform/LazyVals.scala
@@ -674,7 +674,6 @@ object LazyVals {
       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
diff --git a/library/src/scala/runtime/LazyVals.scala b/library/src/scala/runtime/LazyVals.scala
index 5d1e8e74b89d..a75042671efa 100644
--- a/library/src/scala/runtime/LazyVals.scala
+++ b/library/src/scala/runtime/LazyVals.scala
@@ -142,14 +142,6 @@ object LazyVals {
     r
   }
 
-  def getStaticFieldOffset(field: java.lang.reflect.Field): Long = {
-    @nowarn
-    val r = unsafe.staticFieldOffset(field)
-    if (debug)
-      println(s"getStaticFieldOffset(${field.getDeclaringClass}, ${field.getName}) = $r")
-    r
-  }
-
   def getOffsetStatic(field: java.lang.reflect.Field) =
     @nowarn
     val r = unsafe.objectFieldOffset(field)

From 26567e7ce75347401e818f578523f77d56256998 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Thu, 2 Feb 2023 09:07:32 +0000
Subject: [PATCH 068/657] Close test: GADT constraint drives picking the right
 implicit

---
 tests/run/i16785.check |  1 +
 tests/run/i16785.scala | 14 ++++++++++++++
 2 files changed, 15 insertions(+)
 create mode 100644 tests/run/i16785.check
 create mode 100644 tests/run/i16785.scala

diff --git a/tests/run/i16785.check b/tests/run/i16785.check
new file mode 100644
index 000000000000..917d993cb822
--- /dev/null
+++ b/tests/run/i16785.check
@@ -0,0 +1 @@
+specific: 1
diff --git a/tests/run/i16785.scala b/tests/run/i16785.scala
new file mode 100644
index 000000000000..a2217c99f6a4
--- /dev/null
+++ b/tests/run/i16785.scala
@@ -0,0 +1,14 @@
+object Test {
+  sealed trait Box[T] { def value: T }
+  final case class IntBox(value: Int) extends Box[Int]
+
+  implicit def s1[T](implicit box: Box[T]): String = "generic: " + box.value
+  implicit def s2(implicit box: Box[Int]): String = "specific: " + box.value
+
+  def test[T](implicit box: Box[T]): String = box match {
+    case IntBox(_) => implicitly[String]
+  }
+
+  def main(args: Array[String]): Unit =
+    println(test(IntBox(1)))
+}

From 85e2844f8fce4a4b53d938e7fce5e0247cf66797 Mon Sep 17 00:00:00 2001
From: Vasil Vasilev <vasil.vasilev@jetbrains.com>
Date: Thu, 2 Feb 2023 14:13:09 +0100
Subject: [PATCH 069/657] Add support for disabling redirected output in the
 REPL driver for usage in worksheets in the Scala Plugin for IntelliJ IDEA

- Calling `setOut/setErr` in a concurrent environment without any synchronization (such as the Scala compile server in the Scala Plugin for IntelliJ IDEA, which is used to execute Scala 3 worksheets) can lead to unpredictable outcomes where the out/err streams are not restored properly after changing.
- This change adds a new default method `redirectOutput` which can be overriden by others to control the redirecting behavior of the REPL driver.
---
 .../src/dotty/tools/repl/ReplDriver.scala     | 26 +++++++++++--------
 1 file changed, 15 insertions(+), 11 deletions(-)

diff --git a/compiler/src/dotty/tools/repl/ReplDriver.scala b/compiler/src/dotty/tools/repl/ReplDriver.scala
index b072d58f6bb7..0f29591e2121 100644
--- a/compiler/src/dotty/tools/repl/ReplDriver.scala
+++ b/compiler/src/dotty/tools/repl/ReplDriver.scala
@@ -187,19 +187,23 @@ class ReplDriver(settings: Array[String],
   // TODO: i5069
   final def bind(name: String, value: Any)(using state: State): State = state
 
+  protected def redirectOutput: Boolean = true
+
   // redirecting the output allows us to test `println` in scripted tests
   private def withRedirectedOutput(op: => State): State = {
-    val savedOut = System.out
-    val savedErr = System.err
-    try {
-      System.setOut(out)
-      System.setErr(out)
-      op
-    }
-    finally {
-      System.setOut(savedOut)
-      System.setErr(savedErr)
-    }
+    if redirectOutput then
+      val savedOut = System.out
+      val savedErr = System.err
+      try {
+        System.setOut(out)
+        System.setErr(out)
+        op
+      }
+      finally {
+        System.setOut(savedOut)
+        System.setErr(savedErr)
+      }
+    else op
   }
 
   private def newRun(state: State, reporter: StoreReporter = newStoreReporter) = {

From b9a02cdceb432b92eb9ba2082fec5b03c10f6cf2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Doeraene?= <sjrdoeraene@gmail.com>
Date: Thu, 2 Feb 2023 15:02:50 +0100
Subject: [PATCH 070/657] Fix #12621: Scala.js: Better error message for JS
 trait ctor param.

JS traits cannot have constructor params any more than they can
have concrete term members. This improves the error message in
that case.
---
 .../dotty/tools/dotc/transform/sjs/PrepJSInterop.scala   | 3 +++
 tests/neg-scalajs/js-trait-ctor-param.check              | 4 ++++
 tests/neg-scalajs/js-trait-ctor-param.scala              | 9 +++++++++
 3 files changed, 16 insertions(+)
 create mode 100644 tests/neg-scalajs/js-trait-ctor-param.check
 create mode 100644 tests/neg-scalajs/js-trait-ctor-param.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/sjs/PrepJSInterop.scala b/compiler/src/dotty/tools/dotc/transform/sjs/PrepJSInterop.scala
index d934dc179989..8a430991e378 100644
--- a/compiler/src/dotty/tools/dotc/transform/sjs/PrepJSInterop.scala
+++ b/compiler/src/dotty/tools/dotc/transform/sjs/PrepJSInterop.scala
@@ -888,6 +888,9 @@ class PrepJSInterop extends MacroTransform with IdentityDenotTransformer { thisP
             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(ParamAccessor)) {
+            // #12621
+            report.error("A non-native JS trait cannot have constructor parameters", 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.
diff --git a/tests/neg-scalajs/js-trait-ctor-param.check b/tests/neg-scalajs/js-trait-ctor-param.check
new file mode 100644
index 000000000000..bc5296b3c76f
--- /dev/null
+++ b/tests/neg-scalajs/js-trait-ctor-param.check
@@ -0,0 +1,4 @@
+-- Error: tests/neg-scalajs/js-trait-ctor-param.scala:9:34 -------------------------------------------------------------
+9 |trait NonNativeBagHolderTrait(val bag: Bag) extends js.Any // error
+  |                              ^^^^^^^^^^^^
+  |                              A non-native JS trait cannot have constructor parameters
diff --git a/tests/neg-scalajs/js-trait-ctor-param.scala b/tests/neg-scalajs/js-trait-ctor-param.scala
new file mode 100644
index 000000000000..c907b0d9b606
--- /dev/null
+++ b/tests/neg-scalajs/js-trait-ctor-param.scala
@@ -0,0 +1,9 @@
+import scala.scalajs.js
+import scala.scalajs.js.annotation.*
+
+@js.native
+trait Bag extends js.Any {
+  val str: String
+}
+
+trait NonNativeBagHolderTrait(val bag: Bag) extends js.Any // error

From 4c223479d0561c70ea08035ee962b2c1e4f99ef9 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Thu, 2 Feb 2023 16:45:19 +0100
Subject: [PATCH 071/657] Revert deletion of getStaticFieldOffset for now

---
 library/src/scala/runtime/LazyVals.scala | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/library/src/scala/runtime/LazyVals.scala b/library/src/scala/runtime/LazyVals.scala
index a75042671efa..5d1e8e74b89d 100644
--- a/library/src/scala/runtime/LazyVals.scala
+++ b/library/src/scala/runtime/LazyVals.scala
@@ -142,6 +142,14 @@ object LazyVals {
     r
   }
 
+  def getStaticFieldOffset(field: java.lang.reflect.Field): Long = {
+    @nowarn
+    val r = unsafe.staticFieldOffset(field)
+    if (debug)
+      println(s"getStaticFieldOffset(${field.getDeclaringClass}, ${field.getName}) = $r")
+    r
+  }
+
   def getOffsetStatic(field: java.lang.reflect.Field) =
     @nowarn
     val r = unsafe.objectFieldOffset(field)

From df88c0f6cb2f07fa77fbdd8514312f2bdc7e81b4 Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@bluewin.ch>
Date: Sat, 5 Feb 2022 16:44:09 +0100
Subject: [PATCH 072/657] Document new changes The new syntax allows arbitrary
 interleaving of type and term clauses for methods TypelessClause{|s} is added
 for class constructors since they still don't allow interleaving of type
 parameters

Also unifies the affected grammar variable names so that <x>s means
"one or more <x>"

Implicit clauses are moved apart from term clause to make it more
obvious they can only be the last clause
---
 docs/_docs/internals/syntax.md                |  36 +++---
 .../reference/contextual/using-clauses.md     |   4 +-
 .../generalized-method-syntax.md              | 105 ++++++++++++++++++
 docs/_docs/reference/syntax.md                |  36 +++---
 4 files changed, 151 insertions(+), 30 deletions(-)
 create mode 100644 docs/_docs/reference/other-new-features/generalized-method-syntax.md

diff --git a/docs/_docs/internals/syntax.md b/docs/_docs/internals/syntax.md
index 76664569bb17..dfdad496d446 100644
--- a/docs/_docs/internals/syntax.md
+++ b/docs/_docs/internals/syntax.md
@@ -347,9 +347,6 @@ ClsTypeParamClause::=  ‘[’ ClsTypeParam {‘,’ ClsTypeParam} ‘]’
 ClsTypeParam      ::=  {Annotation} [‘+’ | ‘-’]                                 TypeDef(Modifiers, name, tparams, bounds)
                        id [HkTypeParamClause] TypeParamBounds                   Bound(below, above, context)
 
-DefTypeParamClause::=  ‘[’ DefTypeParam {‘,’ DefTypeParam} ‘]’
-DefTypeParam      ::=  {Annotation} id [HkTypeParamClause] TypeParamBounds
-
 TypTypeParamClause::=  ‘[’ TypTypeParam {‘,’ TypTypeParam} ‘]’
 TypTypeParam      ::=  {Annotation} id [HkTypeParamClause] TypeBounds
 
@@ -363,13 +360,24 @@ ClsParamClause    ::=  [nl] ‘(’ ClsParams ‘)’
 ClsParams         ::=  ClsParam {‘,’ ClsParam}
 ClsParam          ::=  {Annotation}                                             ValDef(mods, id, tpe, expr) -- point of mods on val/var
                        [{Modifier} (‘val’ | ‘var’) | ‘inline’] Param
-Param             ::=  id ‘:’ ParamType [‘=’ Expr]
 
-DefParamClauses   ::=  {DefParamClause} [[nl] ‘(’ [‘implicit’] DefParams ‘)’]
-DefParamClause    ::=  [nl] ‘(’ DefParams ‘)’ | UsingParamClause
-UsingParamClause  ::=  [nl] ‘(’ ‘using’ (DefParams | FunArgTypes) ‘)’
-DefParams         ::=  DefParam {‘,’ DefParam}
-DefParam          ::=  {Annotation} [‘inline’] Param                            ValDef(mods, id, tpe, expr) -- point of mods at id.
+DefParamClauses   ::=  DefParamClause { DefParamClause }
+DefParamClause    ::=  DefTypeParamClause 
+                    |  DefTermParamClause 
+                    |  UsingParamClause
+TypelessClauses   ::=  TypelessClause {TypelessClause}
+TypelessClause    ::=  DefTermParamClause
+                    |  UsingParamClause
+
+DefTypeParamClause::=  [nl] ‘[’ DefTypeParam {‘,’ DefTypeParam} ‘]’
+DefTypeParam      ::=  {Annotation} id [HkTypeParamClause] TypeParamBounds
+DefTermParamClause::=  [nl] ‘(’ [DefTermParams] ‘)’
+UsingParamClause  ::=  [nl] ‘(’ ‘using’ (DefTermParams | FunArgTypes) ‘)’
+DefImplicitClause ::=  [nl] ‘(’ ‘implicit’ DefTermParams ‘)’
+
+DefTermParams     ::= DefTermParam {‘,’ DefTermParam}
+DefTermParam      ::= {Annotation} [‘inline’] Param                         ValDef(mods, id, tpe, expr) -- point of mods at id.
+Param             ::=  id ‘:’ ParamType [‘=’ Expr]
 ```
 
 ### Bindings and Imports
@@ -420,7 +428,7 @@ Dcl               ::=  RefineDcl
 ValDcl            ::=  ids ‘:’ Type                                             PatDef(_, ids, tpe, EmptyTree)
 VarDcl            ::=  ids ‘:’ Type                                             PatDef(_, ids, tpe, EmptyTree)
 DefDcl            ::=  DefSig ‘:’ Type                                          DefDef(_, name, tparams, vparamss, tpe, EmptyTree)
-DefSig            ::=  id [DefTypeParamClause] DefParamClauses
+DefSig            ::=  id [DefParamClauses] [DefImplicitClause]
 TypeDcl           ::=  id [TypeParamClause] {FunParamClause} TypeBounds         TypeDefTree(_, name, tparams, bound
                        [‘=’ Type]
 
@@ -431,8 +439,8 @@ Def               ::=  ‘val’ PatDef
                     |  TmplDef
 PatDef            ::=  ids [‘:’ Type] ‘=’ Expr
                     |  Pattern2 [‘:’ Type] ‘=’ Expr                             PatDef(_, pats, tpe?, expr)
-DefDef            ::=  DefSig [‘:’ Type] ‘=’ Expr                               DefDef(_, name, tparams, vparamss, tpe, expr)
-                    |  ‘this’ DefParamClause DefParamClauses ‘=’ ConstrExpr     DefDef(_, <init>, Nil, vparamss, EmptyTree, expr | Block)
+DefDef            ::=  DefSig [‘:’ Type] ‘=’ Expr                               DefDef(_, name, paramss, tpe, expr)
+                    |  ‘this’ TypelessClauses [DefImplicitClause] ‘=’ ConstrExpr     DefDef(_, <init>, vparamss, EmptyTree, expr | Block)
 
 TmplDef           ::=  ([‘case’] ‘class’ | ‘trait’) ClassDef
                     |  [‘case’] ‘object’ ObjectDef
@@ -444,10 +452,10 @@ ConstrMods        ::=  {Annotation} [AccessModifier]
 ObjectDef         ::=  id [Template]                                            ModuleDef(mods, name, template)  // no constructor
 EnumDef           ::=  id ClassConstr InheritClauses EnumBody
 GivenDef          ::=  [GivenSig] (AnnotType [‘=’ Expr] | StructuralInstance)
-GivenSig          ::=  [id] [DefTypeParamClause] {UsingParamClause} ‘:’         -- one of `id`, `DefParamClause`, `UsingParamClause` must be present
+GivenSig          ::=  [id] [DefTypeParamClause] {UsingParamClause} ‘:’         -- one of `id`, `DefTypeParamClause`, `UsingParamClause` must be present
 StructuralInstance ::=  ConstrApp {‘with’ ConstrApp} [‘with’ WithTemplateBody]
 Extension         ::=  ‘extension’ [DefTypeParamClause] {UsingParamClause}
-                       ‘(’ DefParam ‘)’ {UsingParamClause} ExtMethods
+                       ‘(’ DefTermParam ‘)’ {UsingParamClause} ExtMethods
 ExtMethods        ::=  ExtMethod | [nl] <<< ExtMethod {semi ExtMethod} >>>
 ExtMethod         ::=  {Annotation [nl]} {Modifier} ‘def’ DefDef
                     |  Export
diff --git a/docs/_docs/reference/contextual/using-clauses.md b/docs/_docs/reference/contextual/using-clauses.md
index 8f410ebc026e..61b80ee27d91 100644
--- a/docs/_docs/reference/contextual/using-clauses.md
+++ b/docs/_docs/reference/contextual/using-clauses.md
@@ -153,8 +153,8 @@ Here is the new syntax of parameters and arguments seen as a delta from the [sta
 
 ```
 ClsParamClause      ::=  ... | UsingClsParamClause
-DefParamClauses     ::=  ... | UsingParamClause
+DefParamClause      ::=  ... | UsingParamClause
 UsingClsParamClause ::=  ‘(’ ‘using’ (ClsParams | Types) ‘)’
-UsingParamClause    ::=  ‘(’ ‘using’ (DefParams | Types) ‘)’
+UsingParamClause    ::=  ‘(’ ‘using’ (DefTermParams | Types) ‘)’
 ParArgumentExprs    ::=  ... | ‘(’ ‘using’ ExprsInParens ‘)’
 ```
diff --git a/docs/_docs/reference/other-new-features/generalized-method-syntax.md b/docs/_docs/reference/other-new-features/generalized-method-syntax.md
new file mode 100644
index 000000000000..dbe9c6eb0a61
--- /dev/null
+++ b/docs/_docs/reference/other-new-features/generalized-method-syntax.md
@@ -0,0 +1,105 @@
+---
+layout: doc-page
+title: "Generalized Method Syntax"
+movedTo: https://docs.scala-lang.org/scala3/reference/other-new-features/generalized-method-syntax.html
+---
+
+The inclusion of using clauses is not the only way in which methods have been updated, type parameter clauses are now allowed in any number and at any position.
+
+## Syntax Changes
+
+### In Scala 2
+
+The old syntax only allowed zero or one type parameter clause, followed by any number of term clauses, optionnally followed by an implicit clause:
+
+```scala
+def foo[T, U](x: T)(y: U)(z: Int, s: String)(a: Array[T])(implicit ordInt: Ord[Int], l: List[U])
+```
+
+### In Scala 3
+
+The new syntax allows any number of type, term and using clause, in any order, optionnaly followed by an implicit clause:
+(do note however that [implicit clause are discouraged, in favor of using clauses](https://docs.scala-lang.org/scala3/reference/contextual/relationship-implicits.html))
+
+```scala
+def foo[T, U](x: T)(y: U)[V](z: V, s: String)[A](a: Array[A])(implicit List[U])
+```
+
+### Unchanged
+
+Class definitions and type declarations are unaffected, there can only be up to one type clause, in leading posion.
+
+## Motivation
+
+The new syntax is a powerful but natural extension of the old one, it allows new design patterns while staying intuitive and legible.
+
+### Dependent Type Clauses
+
+As type clauses can come after term clauses, it is now possible to have type parameters that depend on term parameters:
+
+```scala
+trait Key { type Value }
+trait DB {
+  def get(k: Key): Option[k.Value] // dependent result type
+  def getOrElse(k: Key)[V >: k.Value](default: V): V // dependent type parameter
+}
+```
+
+Note that simply replacing `V` by `k.Value` would not be equivalent. For example, if `k.Value` is `Some[Int]`, only the above allows: 
+`getOrElse(k)[Option[Int]](None)`, which returns a `Number`.
+
+### Partial Inference
+
+It is now possible to only infer some of the type parameters, this reduces boilerplate at the use site:
+```scala
+trait StaticSizeList[S <: Int & Singleton, T]
+def filled[S <: Int & Singleton][T](x: T): StaticSizeList[S,T] = ???
+val helloes = filled[4]("Hello!") // S=4, and T is inferred
+```
+
+## Details
+
+### Application
+
+Method application is unchanged.
+When multiple type clauses are expected but not all are passed, the rightmost ones are inferred.
+
+In particular, the following does not type check, even though the argument `Char` is only valid for `C`:
+```scala
+def triple[I <: Int](using Ordering[I])[C <: Char](a: I, b: C) = ???
+triple[Char](0, 'c') // error: Char does not conform to upperbound Int
+```
+
+### Extension Methods
+
+Extension methods follow the same syntax, for example the following is valid:
+```scala
+extension [T](l1: List[T])
+  def zipWith[U](l2: List[U])[V](l3: List[V]): List[(T,U,V)]
+```
+
+### When to use
+
+We recommand to always put a unique type clause at the beginning, unless it is not possible to do so.
+For example, the extension method `zipWith` above should be written `zipWith[U, V](l2: List[U], l3: List[V]): List[(T,U,V)]` instead.
+On the other hand, the `getOrElse` method is recommended as-is, as it cannot be written with a leading type clause.
+
+### Formal syntax
+
+```
+DefDcl            ::=  DefSig ‘:’ Type
+DefDef            ::=  DefSig [‘:’ Type] ‘=’ Expr
+DefSig            ::=  id [DefParamClauses] [DefImplicitClause]
+DefParamClauses   ::=  DefParamClause { DefParamClause }
+DefParamClause    ::=  DefTypeParamClause 
+                    |  DefTermParamClause 
+                    |  UsingParamClause
+DefTypeParamClause::=  [nl] ‘[’ DefTypeParam {‘,’ DefTypeParam} ‘]’
+DefTypeParam      ::=  {Annotation} id [HkTypeParamClause] TypeParamBounds
+DefTermParamClause::=  [nl] ‘(’ [DefTermParams] ‘)’
+UsingParamClause  ::=  [nl] ‘(’ ‘using’ (DefTermParams | FunArgTypes) ‘)’
+DefImplicitClause ::=  [nl] ‘(’ ‘implicit’ DefTermParams ‘)’
+DefTermParams     ::=  DefTermParam {‘,’ DefTermParam}
+DefTermParam      ::=  {Annotation} [‘inline’] Param
+Param             ::=  id ‘:’ ParamType [‘=’ Expr]
+```
diff --git a/docs/_docs/reference/syntax.md b/docs/_docs/reference/syntax.md
index 7e4b81b1ef5a..1d0c45030d2c 100644
--- a/docs/_docs/reference/syntax.md
+++ b/docs/_docs/reference/syntax.md
@@ -338,9 +338,6 @@ ArgumentPatterns  ::=  ‘(’ [Patterns] ‘)’
 ClsTypeParamClause::=  ‘[’ ClsTypeParam {‘,’ ClsTypeParam} ‘]’
 ClsTypeParam      ::=  {Annotation} [‘+’ | ‘-’] id [HkTypeParamClause] TypeParamBounds
 
-DefTypeParamClause::=  ‘[’ DefTypeParam {‘,’ DefTypeParam} ‘]’
-DefTypeParam      ::=  {Annotation} id [HkTypeParamClause] TypeParamBounds
-
 TypTypeParamClause::=  ‘[’ TypTypeParam {‘,’ TypTypeParam} ‘]’
 TypTypeParam      ::=  {Annotation} id [HkTypeParamClause] TypeBounds
 
@@ -352,13 +349,24 @@ ClsParamClause    ::=  [nl] ‘(’ ClsParams ‘)’
                     |  [nl] ‘(’ ‘using’ (ClsParams | FunArgTypes) ‘)’
 ClsParams         ::=  ClsParam {‘,’ ClsParam}
 ClsParam          ::=  {Annotation} [{Modifier} (‘val’ | ‘var’) | ‘inline’] Param
-Param             ::=  id ‘:’ ParamType [‘=’ Expr]
 
-DefParamClauses   ::=  {DefParamClause} [[nl] ‘(’ [‘implicit’] DefParams ‘)’]
-DefParamClause    ::=  [nl] ‘(’ DefParams ‘)’ | UsingParamClause
-UsingParamClause  ::=  [nl] ‘(’ ‘using’ (DefParams | FunArgTypes) ‘)’
-DefParams         ::=  DefParam {‘,’ DefParam}
-DefParam          ::=  {Annotation} [‘inline’] Param
+DefParamClauses   ::=  DefParamClause { DefParamClause }
+DefParamClause    ::=  DefTypeParamClause 
+                    |  DefTermParamClause 
+                    |  UsingParamClause
+TypelessClauses   ::=  TypelessClause {TypelessClause}
+TypelessClause    ::=  DefTermParamClause
+                    |  UsingParamClause
+
+DefTypeParamClause::=  [nl] ‘[’ DefTypeParam {‘,’ DefTypeParam} ‘]’
+DefTypeParam      ::=  {Annotation} id [HkTypeParamClause] TypeParamBounds
+DefTermParamClause::=  [nl] ‘(’ [DefTermParams] ‘)’
+UsingParamClause  ::=  [nl] ‘(’ ‘using’ (DefTermParams | FunArgTypes) ‘)’
+DefImplicitClause ::=  [nl] ‘(’ ‘implicit’ DefTermParams ‘)’
+
+DefTermParams     ::= DefTermParam {‘,’ DefTermParam}
+DefTermParam      ::= {Annotation} [‘inline’] Param
+Param             ::=  id ‘:’ ParamType [‘=’ Expr]
 ```
 
 ### Bindings and Imports
@@ -409,8 +417,8 @@ Dcl               ::=  RefineDcl
 ValDcl            ::=  ids ‘:’ Type
 VarDcl            ::=  ids ‘:’ Type
 DefDcl            ::=  DefSig ‘:’ Type
-DefSig            ::=  id [DefTypeParamClause] DefParamClauses
-TypeDcl           ::=  id [TypeParamClause] {FunParamClause} TypeBounds [‘=’ Type]
+DefSig            ::=  id [DefParamClauses] [DefImplicitClause]
+TypeDcl           ::=  id [TypeParamClause] {FunParamClause} TypeBounds
 
 Def               ::=  ‘val’ PatDef
                     |  ‘var’ PatDef
@@ -420,7 +428,7 @@ Def               ::=  ‘val’ PatDef
 PatDef            ::=  ids [‘:’ Type] ‘=’ Expr
                     |  Pattern2 [‘:’ Type] ‘=’ Expr
 DefDef            ::=  DefSig [‘:’ Type] ‘=’ Expr
-                    |  ‘this’ DefParamClause DefParamClauses ‘=’ ConstrExpr
+                    |  ‘this’ TypelessClauses [DefImplicitClause] ‘=’ ConstrExpr
 
 TmplDef           ::=  ([‘case’] ‘class’ | ‘trait’) ClassDef
                     |  [‘case’] ‘object’ ObjectDef
@@ -432,10 +440,10 @@ ConstrMods        ::=  {Annotation} [AccessModifier]
 ObjectDef         ::=  id [Template]
 EnumDef           ::=  id ClassConstr InheritClauses EnumBody
 GivenDef          ::=  [GivenSig] (AnnotType [‘=’ Expr] | StructuralInstance)
-GivenSig          ::=  [id] [DefTypeParamClause] {UsingParamClause} ‘:’         -- one of `id`, `DefParamClause`, `UsingParamClause` must be present
+GivenSig          ::=  [id] [DefTypeParamClause] {UsingParamClause} ‘:’         -- one of `id`, `DefTypeParamClause`, `UsingParamClause` must be present
 StructuralInstance ::=  ConstrApp {‘with’ ConstrApp} [‘with’ WithTemplateBody]
 Extension         ::=  ‘extension’ [DefTypeParamClause] {UsingParamClause}
-                       ‘(’ DefParam ‘)’ {UsingParamClause} ExtMethods
+                       ‘(’ DefTermParam ‘)’ {UsingParamClause} ExtMethods
 ExtMethods        ::=  ExtMethod | [nl] <<< ExtMethod {semi ExtMethod} >>>
 ExtMethod         ::=  {Annotation [nl]} {Modifier} ‘def’ DefDef
                     |  Export

From 897deaf35f4509b5acebd7a3a1ac87e8122f491c Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@bluewin.ch>
Date: Wed, 26 Jan 2022 10:08:17 +0100
Subject: [PATCH 073/657] Update Parsers.scala to accomodate new syntax

Interweaved methods still fail at use-cite, see next commit
---
 .../dotty/tools/dotc/parsing/Parsers.scala    | 80 ++++++++++++++++---
 1 file changed, 69 insertions(+), 11 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index ff5e95f3aa03..99359ac06a37 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -3079,6 +3079,61 @@ object Parsers {
 
  /* -------- PARAMETERS ------------------------------------------- */
 
+    /** DefParamClause ::= DefTypeParamClause 
+     *                   | DefTermParamClause 
+     *                   | UsingParamClause
+     */
+    def typeOrTermParamClause(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
+                    ownerKind: ParamOwner
+                   ): List[TypeDef] | List[ValDef] =
+      if (in.token == LPAREN)
+        paramClause(nparams, ofClass, ofCaseClass, prefix, givenOnly, firstClause)
+      else if (in.token == LBRACKET)
+        typeParamClause(ownerKind)
+      else
+        Nil
+      
+    end typeOrTermParamClause
+    
+    /** DefParamClauses       ::= DefParamClause { DefParamClause }
+     */
+    def typeOrTermParamClauses(
+                    ownerKind: ParamOwner,
+                    ofClass: Boolean = false,
+                    ofCaseClass: Boolean = false,
+                    givenOnly: Boolean = false,
+                    numLeadParams: Int = 0
+                   ): List[List[TypeDef] | List[ValDef]] =
+
+      def recur(firstClause: Boolean, nparams: Int): List[List[TypeDef] | List[ValDef]] =
+        newLineOptWhenFollowedBy(LPAREN)
+        newLineOptWhenFollowedBy(LBRACKET)
+        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 if in.token == LBRACKET then
+          typeParamClause(ownerKind) :: recur(firstClause, nparams)
+        else Nil
+      end recur
+
+      recur(firstClause = true, nparams = numLeadParams)
+    end typeOrTermParamClauses
+
+
     /** ClsTypeParamClause::=  ‘[’ ClsTypeParam {‘,’ ClsTypeParam} ‘]’
      *  ClsTypeParam      ::=  {Annotation} [‘+’ | ‘-’]
      *                         id [HkTypeParamClause] TypeParamBounds
@@ -3143,11 +3198,15 @@ object Parsers {
      *  UsingClsParamClause::= ‘(’ ‘using’ [‘erased’] (ClsParams | ContextTypes) ‘)’
      *  ClsParams         ::=  ClsParam {‘,’ ClsParam}
      *  ClsParam          ::=  {Annotation}
+     * 
+     *  TypelessClause    ::= DefTermParamClause
+     *                      | UsingParamClause
      *
-     *  DefParamClause    ::=  ‘(’ [‘erased’] DefParams ‘)’ | UsingParamClause
-     *  UsingParamClause  ::=  ‘(’ ‘using’ [‘erased’] (DefParams | ContextTypes) ‘)’
-     *  DefParams         ::=  DefParam {‘,’ DefParam}
-     *  DefParam          ::=  {Annotation} [‘inline’] Param
+     *  DefTermParamClause::= [nl] ‘(’ [DefTermParams] ‘)’
+     *  UsingParamClause  ::=  ‘(’ ‘using’ [‘erased’] (DefTermParams | ContextTypes) ‘)’
+     *  DefImplicitClause ::=  [nl] ‘(’ ‘implicit’ DefTermParams ‘)’
+     *  DefTermParams     ::=  DefTermParam {‘,’ DefTermParam}
+     *  DefTermParam      ::=  {Annotation} [‘inline’] Param
      *
      *  Param             ::=  id `:' ParamType [`=' Expr]
      *
@@ -3246,7 +3305,7 @@ object Parsers {
     }
 
     /** ClsParamClauses   ::=  {ClsParamClause} [[nl] ‘(’ [‘implicit’] ClsParams ‘)’]
-     *  DefParamClauses   ::=  {DefParamClause} [[nl] ‘(’ [‘implicit’] DefParams ‘)’]
+     *  TypelessClauses   ::= TypelessClause {TypelessClause}
      *
      *  @return  The parameter definitions
      */
@@ -3515,9 +3574,9 @@ object Parsers {
     }
 
     /** DefDef  ::=  DefSig [‘:’ Type] ‘=’ Expr
-     *            |  this ParamClause ParamClauses `=' ConstrExpr
+     *            |  this TypelessClauses [DefImplicitClause] `=' ConstrExpr
      *  DefDcl  ::=  DefSig `:' Type
-     *  DefSig  ::=  id [DefTypeParamClause] DefParamClauses
+     *  DefSig  ::=  id [DefParamClauses] [DefImplicitClause]
      *            |  ExtParamClause [nl] [‘.’] id DefParamClauses
      */
     def defDefOrDcl(start: Offset, mods: Modifiers, numLeadParams: Int = 0): DefDef = atSpan(start, nameStart) {
@@ -3555,8 +3614,7 @@ object Parsers {
         val mods1 = addFlag(mods, Method)
         val ident = termIdent()
         var name = ident.name.asTermName
-        val tparams = typeParamClauseOpt(ParamOwner.Def)
-        val vparamss = paramClauses(numLeadParams = numLeadParams)
+        val paramss = typeOrTermParamClauses(ParamOwner.Def, numLeadParams = numLeadParams)
         var tpt = fromWithinReturnType { typedOpt() }
         if (migrateTo3) newLineOptWhenFollowedBy(LBRACE)
         val rhs =
@@ -3574,7 +3632,7 @@ object Parsers {
             accept(EQUALS)
             expr()
 
-        val ddef = DefDef(name, joinParams(tparams, vparamss), tpt, rhs)
+        val ddef = DefDef(name, paramss, tpt, rhs)
         if (isBackquoted(ident)) ddef.pushAttachment(Backquoted, ())
         finalizeDef(ddef, mods1, start)
       }
@@ -3837,7 +3895,7 @@ object Parsers {
       finalizeDef(gdef, mods1, start)
     }
 
-    /** Extension  ::=  ‘extension’ [DefTypeParamClause] {UsingParamClause} ‘(’ DefParam ‘)’
+    /** Extension  ::=  ‘extension’ [DefTypeParamClause] {UsingParamClause} ‘(’ DefTermParam ‘)’
      *                  {UsingParamClause} ExtMethods
      */
     def extension(): ExtMethods =

From f1c5855d3e3c0af25f1323d10bea474b6e8d0c7a Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@bluewin.ch>
Date: Wed, 26 Jan 2022 10:17:53 +0100
Subject: [PATCH 074/657] Fix assumptions in Applications.scala A check is
 removed that forbids interleaved methods at use-site This however breaks
 named type parameters, some tests are thus removed

methType implicitly assumed there could only be one leading term
parameter clause, this has been changed
---
 .../dotty/tools/dotc/typer/Applications.scala   | 17 +++++++++++------
 tests/neg/namedTypeParams.scala                 |  2 ++
 2 files changed, 13 insertions(+), 6 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/typer/Applications.scala b/compiler/src/dotty/tools/dotc/typer/Applications.scala
index cd33fe9cef24..19b96f00d365 100644
--- a/compiler/src/dotty/tools/dotc/typer/Applications.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Applications.scala
@@ -444,10 +444,17 @@ trait Applications extends Compatibility {
     /** 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 methType: Type = {
+      def rec(t: Type): Type = {
+        t.widen match{
+          case funType: MethodType => funType
+          case funType: PolyType => 
+            rec(instantiateWithTypeVars(funType))
+          case tp => tp
+        }
+      }
+
+      rec(liftedFunType)
     }
 
     @threadUnsafe lazy val liftedFunType: Type =
@@ -1144,8 +1151,6 @@ trait Applications extends Compatibility {
     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 =>
diff --git a/tests/neg/namedTypeParams.scala b/tests/neg/namedTypeParams.scala
index 8ed7c92241ea..197fc6a9a790 100644
--- a/tests/neg/namedTypeParams.scala
+++ b/tests/neg/namedTypeParams.scala
@@ -17,6 +17,7 @@ object Test {
   def f[X, Y](x: X, y: Y): Int = ???
 
   f[X = Int, String](1, "") // error // error
+  /* Conflicts with Clause Interweaving, stems from named type parameters assuming one type clause
   f[X = Int][X = Int][Y = String](1, "") // error: illegal repeated type application
 
   f[X = Int][Y = String](1, "") // error: illegal repeated type application
@@ -24,4 +25,5 @@ object Test {
 
   f[Y = String][X = Int](1, "") // error: illegal repeated type application
   f[Y = String][Int](1, "") // error: illegal repeated type application
+  */
 }

From b45d44dfd0ffe649cd51ef6d307e5f32c6e6d6b2 Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@bluewin.ch>
Date: Wed, 26 Jan 2022 10:19:36 +0100
Subject: [PATCH 075/657] Add interleaving tests

---
 tests/neg/interleaving-ab.scala               |  8 +++++++
 tests/neg/interleaving-nameCollision.scala    |  3 +++
 tests/neg/interleaving-params.scala           |  7 ++++++
 tests/neg/interleaving-typeApply.scala        | 12 ++++++++++
 tests/neg/interleaving-unmatched.scala        |  3 +++
 tests/neg/overrides.scala                     | 12 ++++++++++
 tests/pos/interleaving-ba.scala               | 11 ++++++++++
 tests/pos/interleaving-chainedParams.scala    | 18 +++++++++++++++
 tests/pos/interleaving-classless.scala        |  4 ++++
 tests/pos/interleaving-functorCurrying.scala  | 17 ++++++++++++++
 .../interleaving-functorInterleaving.scala    | 17 ++++++++++++++
 tests/pos/interleaving-nameCollision.scala    |  5 +++++
 tests/pos/interleaving-newline.scala          |  9 ++++++++
 tests/pos/interleaving-overload.scala         | 19 ++++++++++++++++
 tests/pos/interleaving-params.scala           |  6 +++++
 tests/pos/interleaving-typeApply.scala        | 22 +++++++++++++++++++
 tests/pos/overrides.scala                     |  3 +++
 17 files changed, 176 insertions(+)
 create mode 100644 tests/neg/interleaving-ab.scala
 create mode 100644 tests/neg/interleaving-nameCollision.scala
 create mode 100644 tests/neg/interleaving-params.scala
 create mode 100644 tests/neg/interleaving-typeApply.scala
 create mode 100644 tests/neg/interleaving-unmatched.scala
 create mode 100644 tests/pos/interleaving-ba.scala
 create mode 100644 tests/pos/interleaving-chainedParams.scala
 create mode 100644 tests/pos/interleaving-classless.scala
 create mode 100644 tests/pos/interleaving-functorCurrying.scala
 create mode 100644 tests/pos/interleaving-functorInterleaving.scala
 create mode 100644 tests/pos/interleaving-nameCollision.scala
 create mode 100644 tests/pos/interleaving-newline.scala
 create mode 100644 tests/pos/interleaving-overload.scala
 create mode 100644 tests/pos/interleaving-params.scala
 create mode 100644 tests/pos/interleaving-typeApply.scala

diff --git a/tests/neg/interleaving-ab.scala b/tests/neg/interleaving-ab.scala
new file mode 100644
index 000000000000..0d6649bbb3be
--- /dev/null
+++ b/tests/neg/interleaving-ab.scala
@@ -0,0 +1,8 @@
+object Ab:
+    given String = ""
+    given Double = 0
+
+    def ab[A][B](x: A)(using B): B = summon[B]
+
+    def test =
+        ab[Int](0: Int) // error
\ No newline at end of file
diff --git a/tests/neg/interleaving-nameCollision.scala b/tests/neg/interleaving-nameCollision.scala
new file mode 100644
index 000000000000..44aa1e169db4
--- /dev/null
+++ b/tests/neg/interleaving-nameCollision.scala
@@ -0,0 +1,3 @@
+object nameCollision:
+    def f[T](x: T)[U](y: U) = (x,y)
+    def f[T](x: T, y: T) = (x,y) // error
\ No newline at end of file
diff --git a/tests/neg/interleaving-params.scala b/tests/neg/interleaving-params.scala
new file mode 100644
index 000000000000..e8fa5361a9ab
--- /dev/null
+++ b/tests/neg/interleaving-params.scala
@@ -0,0 +1,7 @@
+class Params{
+    def bar[T](x: T)[T]: String = ??? // error
+    def zoo(x: Int)[T, U](x: U): T = ??? // error
+    def bbb[T <: U](x: U)[U]: U = ??? // error // error
+    def f0[T](implicit x: T)[U](y: U) = (x,y) // error
+    def f1[T](implicit x: T)[U] = (x,y) // error
+}
\ No newline at end of file
diff --git a/tests/neg/interleaving-typeApply.scala b/tests/neg/interleaving-typeApply.scala
new file mode 100644
index 000000000000..2e5f652dc21a
--- /dev/null
+++ b/tests/neg/interleaving-typeApply.scala
@@ -0,0 +1,12 @@
+object typeApply:
+    
+    def f3[T <: Int][U <: String](): T => T = ???
+    def f5[T <: Int][U <: String]: [X <: Unit] => X => X = ???
+    def f7[T <: Int][U <: String]()[X <: Unit]: X => X = ???
+
+    @main def test = {
+        f3[String]() // error
+        f5[Int][Unit] // error
+        f5[String][Unit] // error // error
+        f7[String]()[Unit] // error
+    }
\ No newline at end of file
diff --git a/tests/neg/interleaving-unmatched.scala b/tests/neg/interleaving-unmatched.scala
new file mode 100644
index 000000000000..b2afcf5b5d45
--- /dev/null
+++ b/tests/neg/interleaving-unmatched.scala
@@ -0,0 +1,3 @@
+object unmatched:
+    def f1[T (x: T)] = ??? // error
+    def f2(x: Any[)T] = ??? // error // error
\ No newline at end of file
diff --git a/tests/neg/overrides.scala b/tests/neg/overrides.scala
index 48f3260721e9..ee7a8b73ba0d 100644
--- a/tests/neg/overrides.scala
+++ b/tests/neg/overrides.scala
@@ -39,6 +39,7 @@ package p2 { // all being in the same package compiles fine
 class A[T] {
 
   def f(x: T)(y: T = x) = y
+  def b[U <: T](x: Int)[V >: T](y: String) = false
 
   def next: T = ???
 
@@ -49,11 +50,22 @@ class B extends A[Int] {
   def f(x: Int)(y: Int) = y // error: needs `override' modifier
 
   f(2)()
+  override def b[T <: Int](x: Int)(y: String) = true // error
 
   override def next(): Int = ???    // error: incompatible type
 
 }
 
+class C extends A[String] {
+
+  override def f(x: String) = x // error
+
+  override def b[T <: String](x: Int)[U >: Int](y: String) = true // error: incompatible type
+
+  override def next: Int = ???    // error: incompatible type
+
+}
+
 class X {
   def f: A[Int] = ???
 }
diff --git a/tests/pos/interleaving-ba.scala b/tests/pos/interleaving-ba.scala
new file mode 100644
index 000000000000..74c15d4e87e9
--- /dev/null
+++ b/tests/pos/interleaving-ba.scala
@@ -0,0 +1,11 @@
+
+
+object BA {
+    given String = ""
+    given Double = 0
+
+    def ba[B][A](x: A)(using B): B = summon[B]
+
+    def test = ba[String](0)
+
+}
\ No newline at end of file
diff --git a/tests/pos/interleaving-chainedParams.scala b/tests/pos/interleaving-chainedParams.scala
new file mode 100644
index 000000000000..6ed970a69458
--- /dev/null
+++ b/tests/pos/interleaving-chainedParams.scala
@@ -0,0 +1,18 @@
+object chainedParams{
+
+    trait Chain{
+        type Tail <: Chain
+    }
+
+    def f[C1 <: Chain](c1: C1)[C2 <: c1.Tail](c2: C2)[C3 <: c2.Tail](c3: C3): c3.Tail = ???
+
+    val self = new Chain{ type Tail = this.type }
+    val res: self.type = f(self)(self)(self)
+
+    type C <: Chain
+
+    val c3 = new Chain{ type Tail = C }
+    val c2 = new Chain{ type Tail = c3.type }
+    val c1 = new Chain{ type Tail = c2.type }
+    val u: C = f(c1)(c2)(c3)
+}
diff --git a/tests/pos/interleaving-classless.scala b/tests/pos/interleaving-classless.scala
new file mode 100644
index 000000000000..4308030f66a6
--- /dev/null
+++ b/tests/pos/interleaving-classless.scala
@@ -0,0 +1,4 @@
+def f1[T][U](x: T, y: U): (T, U) = (x, y)
+def f2[T](x: T)[U](y: U): (T, U) = (x, y)
+def f3[T, U][V](x: T): U = ???
+def f4[T](x: T)[U <: x.type](y: U): (T, U) = (x, y)
\ No newline at end of file
diff --git a/tests/pos/interleaving-functorCurrying.scala b/tests/pos/interleaving-functorCurrying.scala
new file mode 100644
index 000000000000..078d65233997
--- /dev/null
+++ b/tests/pos/interleaving-functorCurrying.scala
@@ -0,0 +1,17 @@
+object functorCurrying:
+  //taken from https://dotty.epfl.ch/docs/reference/contextual/type-classes.html
+  //at version 3.1.1-RC1-bin-20210930-01f040b-NIGHTLY
+  //modified to have type currying
+  trait Functor[F[_]]:
+    def map[A][B](x: F[A], f: A => B): F[B]
+
+
+  given Functor[List] with
+    def map[A][B](x: List[A], f: A => B): List[B] =
+      x.map(f)
+
+  def assertTransformation[F[_]: Functor][A][B](expected: F[B], original: F[A], mapping: A => B): Unit =
+    assert(expected == summon[Functor[F]].map(original, mapping))
+
+  @main def testCurrying =
+    assertTransformation(List("a1", "b1"), List("a", "b"), elt => s"${elt}1")
diff --git a/tests/pos/interleaving-functorInterleaving.scala b/tests/pos/interleaving-functorInterleaving.scala
new file mode 100644
index 000000000000..fb14c151387c
--- /dev/null
+++ b/tests/pos/interleaving-functorInterleaving.scala
@@ -0,0 +1,17 @@
+object functorInterweaving:
+  //taken from https://dotty.epfl.ch/docs/reference/contextual/type-classes.html
+  //at version 3.1.1-RC1-bin-20210930-01f040b-NIGHTLY
+  //modified to have type interveawing
+  trait Functor[F[_]]:
+    def map[A](x: F[A])[B](f: A => B): F[B]
+
+
+  given Functor[List] with
+    def map[A](x: List[A])[B](f: A => B): List[B] =
+      x.map(f)
+
+  def assertTransformation[F[_]: Functor][A](original: F[A])[B](expected: F[B])(mapping: A => B): Unit =
+    assert(expected == summon[Functor[F]].map(original)(mapping))
+
+  @main def testInterweaving =
+    assertTransformation(List("a", "b"))(List("a1", "b1")){elt => s"${elt}1"}
diff --git a/tests/pos/interleaving-nameCollision.scala b/tests/pos/interleaving-nameCollision.scala
new file mode 100644
index 000000000000..b66f63b9f92c
--- /dev/null
+++ b/tests/pos/interleaving-nameCollision.scala
@@ -0,0 +1,5 @@
+import scala.annotation.targetName
+
+object nameCollision:
+    def f[T](x: T)[U](y: U) = (x,y)
+    @targetName("g") def f[T](x: T, y: T) = (x,y)
\ No newline at end of file
diff --git a/tests/pos/interleaving-newline.scala b/tests/pos/interleaving-newline.scala
new file mode 100644
index 000000000000..dbd30bca4ef7
--- /dev/null
+++ b/tests/pos/interleaving-newline.scala
@@ -0,0 +1,9 @@
+object newline {
+  def multipleLines
+        [T]
+        (x: T)
+        [U]
+        (using (T,U))
+        (y: U)
+        = ???
+}
diff --git a/tests/pos/interleaving-overload.scala b/tests/pos/interleaving-overload.scala
new file mode 100644
index 000000000000..3dcb0a911704
--- /dev/null
+++ b/tests/pos/interleaving-overload.scala
@@ -0,0 +1,19 @@
+
+class A{
+
+    def f1[T][U](x: Any) = ???
+    def f1[T][U](x: Int) = ???
+
+    f1(1)
+    f1("hello")
+
+    case class B[U](x: Int)
+    def b[U](x: Int) = B[U](x)
+
+    def f2[T]: [U] => Int => B[U] = [U] => (x: Int) => b[U](x)
+
+    f2(1)
+    f2[Any](1)
+    f2[Any][Any](1)
+
+}
\ No newline at end of file
diff --git a/tests/pos/interleaving-params.scala b/tests/pos/interleaving-params.scala
new file mode 100644
index 000000000000..fb55d451b2bd
--- /dev/null
+++ b/tests/pos/interleaving-params.scala
@@ -0,0 +1,6 @@
+class Params{
+    type U
+    def foo[T](x: T)[U >: x.type <: T][L <: List[U]](l: L): L = ???
+    def aaa(x: U): U = ???
+    def bbb[T <: U](x: U)[U]: U = ???
+}
\ No newline at end of file
diff --git a/tests/pos/interleaving-typeApply.scala b/tests/pos/interleaving-typeApply.scala
new file mode 100644
index 000000000000..b637d59e2239
--- /dev/null
+++ b/tests/pos/interleaving-typeApply.scala
@@ -0,0 +1,22 @@
+object typeApply:
+
+    def f0[T]: [U] => T => T = ???
+    def f1[T][U]: T => T = ???
+    def f2[T][U](): T => T = ???
+    def f3[T <: Int][U <: String](): T => T = ???
+    def f4[T <: Int][U <: String]: T => T = ???
+    def f5[T <: Int][U <: String]: [X <: Unit] => X => X = ???
+    def f6[T <: Int][U <: String](): [X <: Unit] => X => X = ???
+    def f7[T <: Int][U <: String]()[X <: Unit]: X => X = ???
+
+    @main def test = {
+        f0[Int][String]
+        f1[Int][String]
+        f2[Int][String]()
+        f3[Int][String]()
+        f4[Int][String]
+        f5[Int][String]
+        f5[Int][String][Unit]
+        f6[Int]()[Unit]
+        f7[Int]()[Unit]
+    }
\ No newline at end of file
diff --git a/tests/pos/overrides.scala b/tests/pos/overrides.scala
index 97402f773082..0f5d12367ca2 100644
--- a/tests/pos/overrides.scala
+++ b/tests/pos/overrides.scala
@@ -1,6 +1,7 @@
 class A[T] {
 
   def f(x: T)(y: T = x) = y
+  def b[U <: T](x: Int)[V >: T](y: String) = false
 
 }
 
@@ -10,4 +11,6 @@ class B extends A[Int] {
 
   f(2)()
 
+  override def b[T <: Int](x: Int)[U >: Int](y: String) = true
+
 }

From 61fef6697ce97864d5fc07e16c3a4851ba8a2306 Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Tue, 23 Aug 2022 15:51:04 +0200
Subject: [PATCH 076/657] Generalise SymOps to more than one def type clause

---
 library/src/scala/quoted/Quotes.scala         |  2 +-
 .../dotty/tools/scaladoc/tasty/SymOps.scala   | 51 +++++++++----------
 2 files changed, 25 insertions(+), 28 deletions(-)

diff --git a/library/src/scala/quoted/Quotes.scala b/library/src/scala/quoted/Quotes.scala
index 48a387e64169..22ec107aeae8 100644
--- a/library/src/scala/quoted/Quotes.scala
+++ b/library/src/scala/quoted/Quotes.scala
@@ -3143,7 +3143,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
     /** Extension methods of `MethodType` */
     trait MethodTypeMethods:
       extension (self: MethodType)
-        /** Is this the type of given parameter clause `(implicit X1, ..., Xn)`, `(given X1, ..., Xn)` or `(given x1: X1, ..., xn: Xn)` */
+        /** Is this the type of using parameter clause `(implicit X1, ..., Xn)`, `(using X1, ..., Xn)` or `(using x1: X1, ..., xn: Xn)` */
         def isImplicit: Boolean
         def isErased: Boolean
         def param(idx: Int): TypeRepr
diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/SymOps.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/SymOps.scala
index b4a1fc197d9a..584ef1f54267 100644
--- a/scaladoc/src/dotty/tools/scaladoc/tasty/SymOps.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/tasty/SymOps.scala
@@ -143,7 +143,9 @@ object SymOps:
       import reflect._
       sym.flags.is(Flags.Artifact)
 
-    def isLeftAssoc: Boolean = !sym.name.endsWith(":")
+    def isRightAssoc: Boolean = sym.name.endsWith(":")
+
+    def isLeftAssoc: Boolean = !sym.isRightAssoc
 
     def extendedSymbol: Option[reflect.ValDef] =
       import reflect.*
@@ -172,41 +174,36 @@ object SymOps:
           )
         case _ => Nil -> Nil
 
+    def extendedParamLists: List[reflect.ParamClause] = sym.splitExtensionParamList._1
+
+    def extendedTypeParamLists: List[reflect.TypeParamClause] =
+      sym.extendedParamLists.collect {
+        case typeClause: reflect.TypeParamClause => typeClause
+      }
+
     def extendedTypeParams: List[reflect.TypeDef] =
-      import reflect.*
-      sym.tree match
-        case tree: DefDef =>
-          tree.leadingTypeParams
-        case _ => Nil
+      sym.extendedTypeParamLists.headOption.map(_.params).getOrElse(List())
 
     def extendedTermParamLists: List[reflect.TermParamClause] =
-      import reflect.*
-      sym.splitExtensionParamList._1.collect {
-        case tpc: TermParamClause => tpc
+      sym.extendedParamLists.collect {
+        case tpc: reflect.TermParamClause => tpc
       }
 
-    def nonExtensionTermParamLists: List[reflect.TermParamClause] =
-      import reflect.*
-      if sym.nonExtensionLeadingTypeParams.nonEmpty then
-        sym.nonExtensionParamLists.dropWhile {
-          case _: TypeParamClause => false
-          case _ => true
-        }.drop(1).collect {
-          case tpc: TermParamClause => tpc
-        }
-      else
-        sym.nonExtensionParamLists.collect {
-          case tpc: TermParamClause => tpc
-        }
-
     def nonExtensionParamLists: List[reflect.ParamClause] =
       sym.splitExtensionParamList._2
 
+    def nonExtensionTermParamLists: List[reflect.TermParamClause] =
+      sym.nonExtensionParamLists.collect {
+        case tpc: reflect.TermParamClause => tpc
+      }
+
+    def nonExtensionTypeParamLists: List[reflect.TypeParamClause] =
+      sym.nonExtensionParamLists.collect {
+        case typeClause: reflect.TypeParamClause => typeClause
+      }
+
     def nonExtensionLeadingTypeParams: List[reflect.TypeDef] =
-      import reflect.*
-      sym.nonExtensionParamLists.collectFirst {
-        case TypeParamClause(params) => params
-      }.toList.flatten
+      sym.nonExtensionTypeParamLists.headOption.map(_.params).getOrElse(List())
 
   end extension
 

From 77c53c853ea5fa860dde0e74b18fa00454b6a9f7 Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Tue, 23 Aug 2022 16:06:39 +0200
Subject: [PATCH 077/657] Uniformize api's Parameter case classes

---
 scaladoc/src/dotty/tools/scaladoc/api.scala   | 20 ++++++++++---------
 .../scaladoc/tasty/ClassLikeSupport.scala     |  8 ++++----
 .../translators/ScalaSignatureUtils.scala     |  4 ++--
 3 files changed, 17 insertions(+), 15 deletions(-)

diff --git a/scaladoc/src/dotty/tools/scaladoc/api.scala b/scaladoc/src/dotty/tools/scaladoc/api.scala
index 90a03658c90e..9c8f17f7a074 100644
--- a/scaladoc/src/dotty/tools/scaladoc/api.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/api.scala
@@ -44,24 +44,24 @@ enum Modifier(val name: String, val prefix: Boolean):
   case Transparent extends Modifier("transparent", true)
   case Infix extends Modifier("infix", true)
 
-case class ExtensionTarget(name: String, typeParams: Seq[TypeParameter], argsLists: Seq[ParametersList], signature: Signature, dri: DRI, position: Long)
+case class ExtensionTarget(name: String, typeParams: Seq[TypeParameter], argsLists: Seq[TermParameterList], signature: Signature, dri: DRI, position: Long)
 case class ImplicitConversion(from: DRI, to: DRI)
 trait ImplicitConversionProvider { def conversion: Option[ImplicitConversion] }
 trait Classlike:
   def typeParams: Seq[TypeParameter] = Seq.empty
-  def argsLists: Seq[ParametersList] = Seq.empty
+  def argsLists: Seq[TermParameterList] = Seq.empty
 
 enum Kind(val name: String):
   case RootPackage extends Kind("")
   case Package extends Kind("package")
-  case Class(override val typeParams: Seq[TypeParameter], override val argsLists: Seq[ParametersList])
+  case Class(override val typeParams: Seq[TypeParameter], override val argsLists: Seq[TermParameterList])
     extends Kind("class") with Classlike
   case Object extends Kind("object") with Classlike
-  case Trait(override val typeParams: Seq[TypeParameter], override val argsLists: Seq[ParametersList])
+  case Trait(override val typeParams: Seq[TypeParameter], override val argsLists: Seq[TermParameterList])
     extends Kind("trait") with Classlike
-  case Enum(override val typeParams: Seq[TypeParameter], override val argsLists: Seq[ParametersList]) extends Kind("enum") with Classlike
+  case Enum(override val typeParams: Seq[TypeParameter], override val argsLists: Seq[TermParameterList]) extends Kind("enum") with Classlike
   case EnumCase(kind: Object.type | Kind.Type | Val.type | Class) extends Kind("case")
-  case Def(typeParams: Seq[TypeParameter], argsLists: Seq[ParametersList])
+  case Def(typeParams: Seq[TypeParameter], argsLists: Seq[TermParameterList])
     extends Kind("def")
   case Extension(on: ExtensionTarget, m: Kind.Def) extends Kind("def")
   case Constructor(base: Kind.Def) extends Kind("def")
@@ -97,12 +97,12 @@ object Annotation:
   case class LinkParameter(name: Option[String] = None, dri: DRI, value: String) extends AnnotationParameter
   case class UnresolvedParameter(name: Option[String] = None, unresolvedText: String) extends AnnotationParameter
 
-case class ParametersList(
-  parameters: Seq[Parameter],
+case class TermParameterList(
+  parameters: Seq[TermParameter],
   modifiers: String
 )
 
-case class Parameter(
+case class TermParameter(
   annotations: Seq[Annotation],
   modifiers: String,
   name: Option[String],
@@ -112,6 +112,8 @@ case class Parameter(
   isGrouped: Boolean = false
 )
 
+type TypeParameterList = Seq[TypeParameter]
+
 case class TypeParameter(
   annotations: Seq[Annotation],
   variance: "" | "+" | "-",
diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala
index 38cc90330265..8419e0275fa8 100644
--- a/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala
@@ -45,7 +45,7 @@ trait ClassLikeSupport:
           .filter(s => s.exists && !s.isHiddenByVisibility)
           .map( _.tree.asInstanceOf[DefDef])
       constr.fold(Nil)(
-        _.termParamss.map(pList => ParametersList(pList.params.map(p => mkParameter(p, parameterModifier)), paramListModifier(pList.params)))
+        _.termParamss.map(pList => TermParameterList(pList.params.map(p => mkParameter(p, parameterModifier)), paramListModifier(pList.params)))
         )
 
     if classDef.symbol.flags.is(Flags.Module) then Kind.Object
@@ -146,7 +146,7 @@ trait ClassLikeSupport:
             memberInfo.paramLists(index) match
               case EvidenceOnlyParameterList => Nil
               case info: RegularParameterList =>
-                Seq(ParametersList(paramList.params.map(mkParameter(_, memberInfo = info)), paramListModifier(paramList.params)))
+                Seq(TermParameterList(paramList.params.map(mkParameter(_, memberInfo = info)), paramListModifier(paramList.params)))
           }
           val target = ExtensionTarget(
             extSym.symbol.normalizedName,
@@ -351,7 +351,7 @@ trait ClassLikeSupport:
         memberInfo.paramLists(index) match
           case EvidenceOnlyParameterList => Nil
           case info: RegularParameterList =>
-            Seq(ParametersList(pList.params.map(
+            Seq(TermParameterList(pList.params.map(
               mkParameter(_, paramPrefix, memberInfo = info)), paramListModifier(pList.params)
             ))
       }
@@ -404,7 +404,7 @@ trait ClassLikeSupport:
       val inlinePrefix = if argument.symbol.flags.is(Flags.Inline) then "inline " else ""
       val nameIfNotSynthetic = Option.when(!argument.symbol.flags.is(Flags.Synthetic))(argument.symbol.normalizedName)
       val name = argument.symbol.normalizedName
-      Parameter(
+      TermParameter(
         argument.symbol.getAnnotations(),
         inlinePrefix + prefix(argument.symbol),
         nameIfNotSynthetic,
diff --git a/scaladoc/src/dotty/tools/scaladoc/translators/ScalaSignatureUtils.scala b/scaladoc/src/dotty/tools/scaladoc/translators/ScalaSignatureUtils.scala
index acbfe87b5d25..4303cf6422b0 100644
--- a/scaladoc/src/dotty/tools/scaladoc/translators/ScalaSignatureUtils.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/translators/ScalaSignatureUtils.scala
@@ -26,7 +26,7 @@ case class SignatureBuilder(content: Signature = Nil) extends ScalaSignatureUtil
   def annotationsBlock(d: Member): SignatureBuilder =
     d.annotations.foldLeft(this){ (bdr, annotation) => bdr.buildAnnotation(annotation)}
 
-  def annotationsInline(d: Parameter): SignatureBuilder =
+  def annotationsInline(d: TermParameter): SignatureBuilder =
     d.annotations.foldLeft(this){ (bdr, annotation) => bdr.buildAnnotation(annotation) }
 
   def annotationsInline(t: TypeParameter): SignatureBuilder =
@@ -78,7 +78,7 @@ case class SignatureBuilder(content: Signature = Nil) extends ScalaSignatureUtil
     bdr.annotationsInline(e).keyword(e.variance).tpe(e.name, Some(e.dri)).signature(e.signature)
   }
 
-  def functionParameters(params: Seq[ParametersList]) =
+  def functionParameters(params: Seq[TermParameterList]) =
     if params.isEmpty then this.plain("")
     else if params.size == 1 && params(0).parameters == Nil then this.plain("()")
     else this.list(params, separator = List(Plain(""))) { (bld, pList) =>

From 908e5c8a656ae399f313d557c0ef6594d5647348 Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Tue, 23 Aug 2022 16:21:29 +0200
Subject: [PATCH 078/657] Uniformize ScalaSignatureUtils param methods

---
 .../scaladoc/renderers/MemberRenderer.scala   |  4 +--
 .../tools/scaladoc/renderers/Resources.scala  |  4 +--
 .../translators/ScalaSignatureProvider.scala  | 10 +++----
 .../translators/ScalaSignatureUtils.scala     | 30 +++++++++++--------
 4 files changed, 27 insertions(+), 21 deletions(-)

diff --git a/scaladoc/src/dotty/tools/scaladoc/renderers/MemberRenderer.scala b/scaladoc/src/dotty/tools/scaladoc/renderers/MemberRenderer.scala
index 5d5f3e9b20d5..f2501378bf72 100644
--- a/scaladoc/src/dotty/tools/scaladoc/renderers/MemberRenderer.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/renderers/MemberRenderer.scala
@@ -409,10 +409,10 @@ class MemberRenderer(signatureRenderer: SignatureRenderer)(using DocContext) ext
         case (Some(on), members) =>
           val typeSig = SignatureBuilder()
             .keyword("extension ")
-            .generics(on.typeParams)
+            .typeParamList(on.typeParams)
             .content
           val argsSig = SignatureBuilder()
-            .functionParameters(on.argsLists)
+            .functionTermParameters(on.argsLists)
             .content
           val sig = typeSig ++ Signature(Plain(s"(${on.name}: ")) ++ on.signature ++ Signature(Plain(")")) ++ argsSig
           MGroup(span(cls := "groupHeader")(sig.map(renderElement(_))), members.sortBy(_.name).toSeq, on.name) -> on.position
diff --git a/scaladoc/src/dotty/tools/scaladoc/renderers/Resources.scala b/scaladoc/src/dotty/tools/scaladoc/renderers/Resources.scala
index bae43980a11d..43b4440bce2c 100644
--- a/scaladoc/src/dotty/tools/scaladoc/renderers/Resources.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/renderers/Resources.scala
@@ -180,10 +180,10 @@ trait Resources(using ctx: DocContext) extends Locations, Writer:
         case Kind.Extension(on, _) =>
           val typeSig = SignatureBuilder()
             .keyword("extension ")
-            .generics(on.typeParams)
+            .typeParamList(on.typeParams)
             .content
           val argsSig = SignatureBuilder()
-            .functionParameters(on.argsLists)
+            .functionTermParameters(on.argsLists)
             .content
           flattenToText(typeSig ++ argsSig)
         case _ => ""
diff --git a/scaladoc/src/dotty/tools/scaladoc/translators/ScalaSignatureProvider.scala b/scaladoc/src/dotty/tools/scaladoc/translators/ScalaSignatureProvider.scala
index 88561282afb0..02de12666666 100644
--- a/scaladoc/src/dotty/tools/scaladoc/translators/ScalaSignatureProvider.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/translators/ScalaSignatureProvider.scala
@@ -58,8 +58,8 @@ class ScalaSignatureProvider:
       builder.kind(showKind),
       builder.name(member.name, member.dri),
       builder
-        .generics(kind.typeParams)
-        .functionParameters(kind.argsLists)
+        .typeParamList(kind.typeParams)
+        .functionTermParameters(kind.argsLists)
         .parentsSignature(member)
     )
 
@@ -106,8 +106,8 @@ class ScalaSignatureProvider:
       builder.kind(showKind),
       builder.name(method.name, method.dri),
       builder
-        .generics(kind.typeParams)
-        .functionParameters(kind.argsLists)
+        .typeParamList(kind.typeParams)
+        .functionTermParameters(kind.argsLists)
         .pipe { builder =>
           instance.fold(builder)(i => builder.plain(": ").signature(i))
         }
@@ -151,7 +151,7 @@ class ScalaSignatureProvider:
       builder.modifiersAndVisibility(typeDef),
       builder.kind(tpe),
       builder.name(typeDef.name, typeDef.dri),
-      builder.generics(tpe.typeParams).pipe { bdr =>
+      builder.typeParamList(tpe.typeParams).pipe { bdr =>
         if (!tpe.opaque) {
           (if tpe.concreate then bdr.plain(" = ") else bdr)
             .signature(typeDef.signature)
diff --git a/scaladoc/src/dotty/tools/scaladoc/translators/ScalaSignatureUtils.scala b/scaladoc/src/dotty/tools/scaladoc/translators/ScalaSignatureUtils.scala
index 4303cf6422b0..d28dd6ca18fe 100644
--- a/scaladoc/src/dotty/tools/scaladoc/translators/ScalaSignatureUtils.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/translators/ScalaSignatureUtils.scala
@@ -74,21 +74,27 @@ case class SignatureBuilder(content: Signature = Nil) extends ScalaSignatureUtil
   def kind(k: Kind) =
     keyword(k.name + " ")
 
-  def generics(on: Seq[TypeParameter]) = list(on.toList, List(Plain("[")), List(Plain("]"))){ (bdr, e) =>
+
+  def functionParameters(paramss: Seq[ Either[TermParameterList,TypeParameterList] ]) =
+    this.list(paramss, separator = List(Plain(""))) {
+      case (bld, Left(params: TermParameterList))  => bld.termParamList(params)
+      case (bld, Right(params: TypeParameterList)) => bld.typeParamList(params)
+    }
+
+  def termParamList(params: TermParameterList) =
+    this.list(params.parameters, prefix = List(Plain("("), Keyword(params.modifiers)), suffix = List(Plain(")")), forcePrefixAndSuffix = true) { (bld, p) =>
+      val annotationsAndModifiers = bld.annotationsInline(p)
+        .keyword(p.modifiers)
+      val name = p.name.fold(annotationsAndModifiers)(annotationsAndModifiers.name(_, p.dri).plain(": "))
+      name.signature(p.signature)
+    }
+
+  def typeParamList(on: TypeParameterList) = list(on.toList, List(Plain("[")), List(Plain("]"))){ (bdr, e) =>
     bdr.annotationsInline(e).keyword(e.variance).tpe(e.name, Some(e.dri)).signature(e.signature)
   }
 
-  def functionParameters(params: Seq[TermParameterList]) =
-    if params.isEmpty then this.plain("")
-    else if params.size == 1 && params(0).parameters == Nil then this.plain("()")
-    else this.list(params, separator = List(Plain(""))) { (bld, pList) =>
-      bld.list(pList.parameters, prefix = List(Plain("("), Keyword(pList.modifiers)), suffix = List(Plain(")")), forcePrefixAndSuffix = true) { (bld, p) =>
-        val annotationsAndModifiers = bld.annotationsInline(p)
-          .keyword(p.modifiers)
-        val name = p.name.fold(annotationsAndModifiers)(annotationsAndModifiers.name(_, p.dri).plain(": "))
-        name.signature(p.signature)
-      }
-    }
+  def functionTermParameters(paramss: Seq[TermParameterList]) =
+    this.list(paramss, separator = List(Plain(""))) { (bld, pList) => bld.termParamList(pList) }
 
 trait ScalaSignatureUtils:
   extension (tokens: Seq[String]) def toSignatureString(): String =

From a617c483fa7e0f8e100bd3b8f94faec2db9d62e4 Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Tue, 23 Aug 2022 16:33:31 +0200
Subject: [PATCH 079/657] Refactor Kind.Def to use one paramLists

---
 scaladoc/src/dotty/tools/scaladoc/api.scala               | 2 +-
 .../src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala | 8 ++++----
 .../ImplicitMembersExtensionTransformer.scala             | 2 +-
 .../scaladoc/translators/ScalaSignatureProvider.scala     | 3 +--
 4 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/scaladoc/src/dotty/tools/scaladoc/api.scala b/scaladoc/src/dotty/tools/scaladoc/api.scala
index 9c8f17f7a074..5af55f76a211 100644
--- a/scaladoc/src/dotty/tools/scaladoc/api.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/api.scala
@@ -61,7 +61,7 @@ enum Kind(val name: String):
     extends Kind("trait") with Classlike
   case Enum(override val typeParams: Seq[TypeParameter], override val argsLists: Seq[TermParameterList]) extends Kind("enum") with Classlike
   case EnumCase(kind: Object.type | Kind.Type | Val.type | Class) extends Kind("case")
-  case Def(typeParams: Seq[TypeParameter], argsLists: Seq[TermParameterList])
+  case Def(paramLists: Seq[Either[TermParameterList,TypeParameterList]])
     extends Kind("def")
   case Extension(on: ExtensionTarget, m: Kind.Def) extends Kind("def")
   case Constructor(base: Kind.Def) extends Kind("def")
diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala
index 8419e0275fa8..a95d5f3e10f2 100644
--- a/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala
@@ -346,14 +346,14 @@ trait ClassLikeSupport:
     val memberInfo = unwrapMemberInfo(c, methodSymbol)
 
     val basicKind: Kind.Def = Kind.Def(
-      genericTypes.map(mkTypeArgument(_, memberInfo.genericTypes, memberInfo.contextBounds)),
+      Right(genericTypes.map(mkTypeArgument(_, memberInfo.genericTypes, memberInfo.contextBounds))) +:
       paramLists.zipWithIndex.flatMap { (pList, index) =>
         memberInfo.paramLists(index) match
-          case EvidenceOnlyParameterList => Nil
+          case EvidenceOnlyParameterList => None
           case info: RegularParameterList =>
-            Seq(TermParameterList(pList.params.map(
+            Some(Left(TermParameterList(pList.params.map(
               mkParameter(_, paramPrefix, memberInfo = info)), paramListModifier(pList.params)
-            ))
+            )))
       }
     )
 
diff --git a/scaladoc/src/dotty/tools/scaladoc/transformers/ImplicitMembersExtensionTransformer.scala b/scaladoc/src/dotty/tools/scaladoc/transformers/ImplicitMembersExtensionTransformer.scala
index 44eba3a39807..8ed7436bb11d 100644
--- a/scaladoc/src/dotty/tools/scaladoc/transformers/ImplicitMembersExtensionTransformer.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/transformers/ImplicitMembersExtensionTransformer.scala
@@ -29,7 +29,7 @@ class ImplicitMembersExtensionTransformer(using DocContext) extends(Module => Mo
         case m @ Member(_, _, _, Kind.Extension(ExtensionTarget(_, _, _, _, MyDri, _), _), Origin.RegularlyDefined) =>
           val kind = m.kind match
             case Kind.Extension(_, d) => d
-            case _ => Kind.Def(Nil, Nil)
+            case _ => Kind.Def(Nil)
 
           Seq(m.withOrigin(Origin.ExtensionFrom(source.name, source.dri)).withKind(kind))
         case m @ Member(_, _, _, conversionProvider: ImplicitConversionProvider, Origin.RegularlyDefined) =>
diff --git a/scaladoc/src/dotty/tools/scaladoc/translators/ScalaSignatureProvider.scala b/scaladoc/src/dotty/tools/scaladoc/translators/ScalaSignatureProvider.scala
index 02de12666666..fd8dfc4f5b6c 100644
--- a/scaladoc/src/dotty/tools/scaladoc/translators/ScalaSignatureProvider.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/translators/ScalaSignatureProvider.scala
@@ -106,8 +106,7 @@ class ScalaSignatureProvider:
       builder.kind(showKind),
       builder.name(method.name, method.dri),
       builder
-        .typeParamList(kind.typeParams)
-        .functionTermParameters(kind.argsLists)
+        .functionParameters(kind.paramLists)
         .pipe { builder =>
           instance.fold(builder)(i => builder.plain(": ").signature(i))
         }

From 2126c4645304b97f5a28896db21f3f3754b5e761 Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Tue, 23 Aug 2022 16:46:24 +0200
Subject: [PATCH 080/657] Refactor MemberInfo (breaks tests) This commit is
 only here for the sake of legibility, it breaks tests If you want to come
 back in the history, go to either the previous commit or the next

---
 .../scaladoc/tasty/ClassLikeSupport.scala     | 62 ++++++++++++-------
 1 file changed, 40 insertions(+), 22 deletions(-)

diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala
index a95d5f3e10f2..6a0201f5fb0b 100644
--- a/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala
@@ -12,6 +12,9 @@ import NameNormalizer._
 import SyntheticsSupport._
 import dotty.tools.dotc.core.NameKinds
 
+// Please use this only for things defined in the api.scala file
+import dotty.tools.{scaladoc => api}
+
 trait ClassLikeSupport:
   self: TastyParser =>
   import qctx.reflect._
@@ -45,7 +48,7 @@ trait ClassLikeSupport:
           .filter(s => s.exists && !s.isHiddenByVisibility)
           .map( _.tree.asInstanceOf[DefDef])
       constr.fold(Nil)(
-        _.termParamss.map(pList => TermParameterList(pList.params.map(p => mkParameter(p, parameterModifier)), paramListModifier(pList.params)))
+        _.termParamss.map(pList => api.TermParameterList(pList.params.map(p => mkParameter(p, parameterModifier)), paramListModifier(pList.params)))
         )
 
     if classDef.symbol.flags.is(Flags.Module) then Kind.Object
@@ -142,11 +145,12 @@ trait ClassLikeSupport:
         dd.symbol.extendedSymbol.map { extSym =>
           val memberInfo = unwrapMemberInfo(c, dd.symbol)
           val typeParams = dd.symbol.extendedTypeParams.map(mkTypeArgument(_, memberInfo.genericTypes))
-          val termParams = dd.symbol.extendedTermParamLists.zipWithIndex.flatMap { case (paramList, index) =>
-            memberInfo.paramLists(index) match
-              case EvidenceOnlyParameterList => Nil
-              case info: RegularParameterList =>
-                Seq(TermParameterList(paramList.params.map(mkParameter(_, memberInfo = info)), paramListModifier(paramList.params)))
+          val termParams = dd.symbol.extendedTermParamLists.zipWithIndex.flatMap { case (termParamList, index) =>
+            memberInfo.termParamLists(index) match
+              case MemberInfo.EvidenceOnlyParameterList => None
+              case MemberInfo.RegularParameterList(info) =>
+                Some(api.TermParameterList(termParamList.params.map(mkParameter(_, memberInfo = info)), paramListModifier(termParamList.params)))
+              case _ => assert(false, "memberInfo.termParamLists contains a type parameter list !")
           }
           val target = ExtensionTarget(
             extSym.symbol.normalizedName,
@@ -349,11 +353,12 @@ trait ClassLikeSupport:
       Right(genericTypes.map(mkTypeArgument(_, memberInfo.genericTypes, memberInfo.contextBounds))) +:
       paramLists.zipWithIndex.flatMap { (pList, index) =>
         memberInfo.paramLists(index) match
-          case EvidenceOnlyParameterList => None
-          case info: RegularParameterList =>
+          case MemberInfo.EvidenceOnlyParameterList => None
+          case MemberInfo.RegularParameterList(info) =>
             Some(Left(TermParameterList(pList.params.map(
               mkParameter(_, paramPrefix, memberInfo = info)), paramListModifier(pList.params)
             )))
+          case _ => assert(false, "memberInfo.termParamLists contains a type parameter list !")
       }
     )
 
@@ -404,7 +409,7 @@ trait ClassLikeSupport:
       val inlinePrefix = if argument.symbol.flags.is(Flags.Inline) then "inline " else ""
       val nameIfNotSynthetic = Option.when(!argument.symbol.flags.is(Flags.Synthetic))(argument.symbol.normalizedName)
       val name = argument.symbol.normalizedName
-      TermParameter(
+      api.TermParameter(
         argument.symbol.getAnnotations(),
         inlinePrefix + prefix(argument.symbol),
         nameIfNotSynthetic,
@@ -514,16 +519,26 @@ trait ClassLikeSupport:
     experimental = experimental
   )
 
-  object EvidenceOnlyParameterList
-  type RegularParameterList = Map[String, TypeRepr]
-  type ParameterList = RegularParameterList | EvidenceOnlyParameterList.type
 
   case class MemberInfo(
-    genericTypes: Map[String, TypeBounds],
-    paramLists: List[ParameterList],
+    paramLists: List[MemberInfo.ParameterList],
     res: TypeRepr,
     contextBounds: Map[String, DSignature] = Map.empty,
-  )
+  ){
+    val genericTypes: Map[String, TypeBounds] = paramLists.collect{ case MemberInfo.TypeParameterList(types) => types }.headOption.getOrElse(Map())
+    
+    val termParamLists: List[MemberInfo.ParameterList] = paramLists.filter(_.isTerm)
+  }
+
+  object MemberInfo:
+    enum ParameterList(val isTerm: Boolean, val isUsing: Boolean):
+      inline def isType = !isTerm
+      case EvidenceOnlyParameterList                                         extends ParameterList(isTerm = true, isUsing = false)
+      case RegularParameterList(m: Map[String, TypeRepr])(isUsing: Boolean)  extends ParameterList(isTerm = true, isUsing)
+      case TypeParameterList(m: Map[String, TypeBounds])                     extends ParameterList(isTerm = false, isUsing = false)
+    
+    export ParameterList.{RegularParameterList, EvidenceOnlyParameterList, TypeParameterList}
+
 
 
   def unwrapMemberInfo(c: ClassDef, symbol: Symbol): MemberInfo =
@@ -541,10 +556,12 @@ trait ClassLikeSupport:
         symbol.paramSymss.flatten.find(_.name == name).exists(_.flags.is(Flags.Implicit))
 
     def handlePolyType(memberInfo: MemberInfo, polyType: PolyType): MemberInfo =
-      MemberInfo(polyType.paramNames.zip(polyType.paramBounds).toMap, memberInfo.paramLists, polyType.resType)
+      val typeParamList = MemberInfo.TypeParameterList(polyType.paramNames.zip(polyType.paramBounds).toMap)
+      MemberInfo(memberInfo.paramLists :+ typeParamList, polyType.resType)
 
     def handleMethodType(memberInfo: MemberInfo, methodType: MethodType): MemberInfo =
       val rawParams = methodType.paramNames.zip(methodType.paramTypes).toMap
+      val isUsing = methodType.isImplicit
       val (evidences, notEvidences) = rawParams.partition(e => isSyntheticEvidence(e._1))
 
       def findParamRefs(t: TypeRepr): Seq[ParamRef] = t match
@@ -573,14 +590,15 @@ trait ClassLikeSupport:
 
       val newParams = notEvidences ++ paramsThatLookLikeContextBounds
 
-      val newLists: List[ParameterList] = if newParams.isEmpty   && contextBounds.nonEmpty
-        then memberInfo.paramLists ++  Seq(EvidenceOnlyParameterList)
-        else memberInfo.paramLists ++ Seq(newParams)
+      val termParamList = if newParams.isEmpty && contextBounds.nonEmpty
+        then MemberInfo.EvidenceOnlyParameterList
+        else MemberInfo.RegularParameterList(newParams)(isUsing)
+        
 
-      MemberInfo(memberInfo.genericTypes, newLists , methodType.resType, contextBounds.toMap)
+      MemberInfo(memberInfo.paramLists :+ termParamList, methodType.resType, contextBounds.toMap)
 
     def handleByNameType(memberInfo: MemberInfo, byNameType: ByNameType): MemberInfo =
-      MemberInfo(memberInfo.genericTypes, memberInfo.paramLists, byNameType.underlying)
+      MemberInfo(memberInfo.paramLists, byNameType.underlying)
 
     def recursivelyCalculateMemberInfo(memberInfo: MemberInfo): MemberInfo = memberInfo.res match
       case p: PolyType => recursivelyCalculateMemberInfo(handlePolyType(memberInfo, p))
@@ -588,7 +606,7 @@ trait ClassLikeSupport:
       case b: ByNameType => handleByNameType(memberInfo, b)
       case _ => memberInfo
 
-    recursivelyCalculateMemberInfo(MemberInfo(Map.empty, List.empty, baseTypeRepr))
+    recursivelyCalculateMemberInfo(MemberInfo(List.empty, baseTypeRepr))
 
   private def paramListModifier(parameters: Seq[ValDef]): String =
     if parameters.size > 0 then

From 9e8f91d28ebfc9c0589a468446c63b2e887f43de Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Tue, 23 Aug 2022 16:49:58 +0200
Subject: [PATCH 081/657] Add scaladoc support for interleaved clauses

---
 .../src/tests/extensionParams.scala           |  5 ++
 .../src/tests/methodsAndConstructors.scala    |  3 +
 .../scaladoc/tasty/ClassLikeSupport.scala     | 73 ++++++++++++-------
 3 files changed, 55 insertions(+), 26 deletions(-)

diff --git a/scaladoc-testcases/src/tests/extensionParams.scala b/scaladoc-testcases/src/tests/extensionParams.scala
index 7892676af2c4..58b95c5dac1f 100644
--- a/scaladoc-testcases/src/tests/extensionParams.scala
+++ b/scaladoc-testcases/src/tests/extensionParams.scala
@@ -52,3 +52,8 @@ extension [A <: List[Char]](using String)(using Unit)(a: A)(using Int)(using Num
 extension (using String)(using Unit)(a: Animal)(using Int)(using Number)
   def f11(b: Any)(c: Any): Any
   = ???
+  def f13(b: Any)[T](c: T): T
+  = ???
+  def f14[D](b: D)[T](c: T): T
+  = ???
+
diff --git a/scaladoc-testcases/src/tests/methodsAndConstructors.scala b/scaladoc-testcases/src/tests/methodsAndConstructors.scala
index b8925c593b4c..b4c354d174c4 100644
--- a/scaladoc-testcases/src/tests/methodsAndConstructors.scala
+++ b/scaladoc-testcases/src/tests/methodsAndConstructors.scala
@@ -60,3 +60,6 @@ class Methods:
  def withImplicitParam2(v: String)(implicit ab: Double, a: Int, b: String): String
  = ???
 
+ def clauseInterleaving[T](x: T)[U](y: U)(using (T, U)): (T, U)
+ = ???
+
diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala
index 6a0201f5fb0b..c7178acac312 100644
--- a/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala
@@ -339,45 +339,66 @@ trait ClassLikeSupport:
   def parseMethod(
       c: ClassDef,
       methodSymbol: Symbol,
-      emptyParamsList: Boolean = false,
       paramPrefix: Symbol => String = _ => "",
       specificKind: (Kind.Def => Kind) = identity
     ): Member =
     val method = methodSymbol.tree.asInstanceOf[DefDef]
-    val paramLists: List[TermParamClause] = methodSymbol.nonExtensionTermParamLists
-    val genericTypes: List[TypeDef] = if (methodSymbol.isClassConstructor) Nil else methodSymbol.nonExtensionLeadingTypeParams
+    val paramLists = methodSymbol.nonExtensionParamLists
 
     val memberInfo = unwrapMemberInfo(c, methodSymbol)
 
-    val basicKind: Kind.Def = Kind.Def(
-      Right(genericTypes.map(mkTypeArgument(_, memberInfo.genericTypes, memberInfo.contextBounds))) +:
-      paramLists.zipWithIndex.flatMap { (pList, index) =>
-        memberInfo.paramLists(index) match
-          case MemberInfo.EvidenceOnlyParameterList => None
-          case MemberInfo.RegularParameterList(info) =>
-            Some(Left(TermParameterList(pList.params.map(
+    val unshuffledMemberInfoParamLists = 
+      if methodSymbol.isExtensionMethod && methodSymbol.isRightAssoc then
+        // Taken from RefinedPrinter.scala
+        val (leadingTyParamss, rest1) = memberInfo.paramLists.span(_.isType)
+        val (leadingUsing, rest2) = rest1.span(_.isUsing)
+        val (rightTyParamss, rest3) = rest2.span(_.isType)
+        val (rightParamss, rest4) = rest3.splitAt(1)
+        val (leftParamss, rest5) = rest4.splitAt(1)
+        val (trailingUsing, rest6) = rest5.span(_.isUsing)
+        if leftParamss.nonEmpty then
+          // leadingTyParamss ::: leadingUsing ::: leftParamss ::: trailingUsing ::: rightTyParamss ::: rightParamss ::: rest6
+          // because of takeRight after, this is equivalent to the following:
+          rightTyParamss ::: rightParamss ::: rest6
+        else
+          memberInfo.paramLists // it wasn't a binary operator, after all.
+      else 
+        memberInfo.paramLists
+
+    val croppedUnshuffledMemberInfoParamLists = unshuffledMemberInfoParamLists.takeRight(paramLists.length)
+
+    val basicDefKind: Kind.Def = Kind.Def(
+      paramLists.zip(croppedUnshuffledMemberInfoParamLists).flatMap{
+        case (_: TermParamClause, MemberInfo.EvidenceOnlyParameterList) => Nil
+        case (pList: TermParamClause, MemberInfo.RegularParameterList(info)) =>
+            Some(Left(api.TermParameterList(pList.params.map(
               mkParameter(_, paramPrefix, memberInfo = info)), paramListModifier(pList.params)
             )))
-          case _ => assert(false, "memberInfo.termParamLists contains a type parameter list !")
+        case (TypeParamClause(genericTypeList), MemberInfo.TypeParameterList(memInfoTypes)) =>
+          Some(Right(genericTypeList.map(mkTypeArgument(_, memInfoTypes, memberInfo.contextBounds))))
+        case (_,_) =>
+          assert(false, s"croppedUnshuffledMemberInfoParamLists and SymOps.nonExtensionParamLists disagree on whether this clause is a type or term one")
       }
     )
 
     val methodKind =
-      if methodSymbol.isClassConstructor then Kind.Constructor(basicKind)
-      else if methodSymbol.flags.is(Flags.Implicit) then extractImplicitConversion(method.returnTpt.tpe) match
-        case Some(conversion) if paramLists.size == 0 || (paramLists.size == 1 && paramLists.head.params.size == 0) =>
-          Kind.Implicit(basicKind, Some(conversion))
-        case None if paramLists.size == 1 && paramLists(0).params.size == 1 =>
-          Kind.Implicit(basicKind, Some(
-            ImplicitConversion(
-              paramLists(0).params(0).tpt.tpe.typeSymbol.dri,
-              method.returnTpt.tpe.typeSymbol.dri
-            )
-          ))
-        case _ =>
-          Kind.Implicit(basicKind, None)
-      else if methodSymbol.flags.is(Flags.Given) then Kind.Given(basicKind, Some(method.returnTpt.tpe.asSignature), extractImplicitConversion(method.returnTpt.tpe))
-      else specificKind(basicKind)
+      if methodSymbol.isClassConstructor then Kind.Constructor(basicDefKind)
+      else if methodSymbol.flags.is(Flags.Implicit) then 
+        val termParamLists: List[TermParamClause] = methodSymbol.nonExtensionTermParamLists
+        extractImplicitConversion(method.returnTpt.tpe) match
+          case Some(conversion) if termParamLists.size == 0 || (termParamLists.size == 1 && termParamLists.head.params.size == 0) =>
+            Kind.Implicit(basicDefKind, Some(conversion))
+          case None if termParamLists.size == 1 && termParamLists(0).params.size == 1 =>
+            Kind.Implicit(basicDefKind, Some(
+              ImplicitConversion(
+                termParamLists(0).params(0).tpt.tpe.typeSymbol.dri,
+                method.returnTpt.tpe.typeSymbol.dri
+              )
+            ))
+          case _ =>
+            Kind.Implicit(basicDefKind, None)
+      else if methodSymbol.flags.is(Flags.Given) then Kind.Given(basicDefKind, Some(method.returnTpt.tpe.asSignature), extractImplicitConversion(method.returnTpt.tpe))
+      else specificKind(basicDefKind)
 
     val origin = if !methodSymbol.isOverridden then Origin.RegularlyDefined else
       val overriddenSyms = methodSymbol.allOverriddenSymbols.map(_.owner)

From b7de2b20519fca6b7a73207755cec1b0a6fbbbda Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Thu, 25 Aug 2022 15:03:34 +0200
Subject: [PATCH 082/657] Uniformize Parsers ParamClause methods

---
 .../dotty/tools/dotc/parsing/Parsers.scala    | 118 ++++++++++--------
 1 file changed, 63 insertions(+), 55 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 99359ac06a37..a56c5175be02 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -3083,16 +3083,17 @@ object Parsers {
      *                   | DefTermParamClause 
      *                   | UsingParamClause
      */
-    def typeOrTermParamClause(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
-                    ownerKind: ParamOwner
+    def typeOrTermParamClause(
+                    ownerKind: ParamOwner,
+                    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[TypeDef] | List[ValDef] =
       if (in.token == LPAREN)
-        paramClause(nparams, ofClass, ofCaseClass, prefix, givenOnly, firstClause)
+        termParamClause(nparams, ofClass, ofCaseClass, prefix, givenOnly, firstClause)
       else if (in.token == LBRACKET)
         typeParamClause(ownerKind)
       else
@@ -3103,20 +3104,20 @@ object Parsers {
     /** DefParamClauses       ::= DefParamClause { DefParamClause }
      */
     def typeOrTermParamClauses(
-                    ownerKind: ParamOwner,
-                    ofClass: Boolean = false,
-                    ofCaseClass: Boolean = false,
-                    givenOnly: Boolean = false,
-                    numLeadParams: Int = 0
-                   ): List[List[TypeDef] | List[ValDef]] =
-
-      def recur(firstClause: Boolean, nparams: Int): List[List[TypeDef] | List[ValDef]] =
+      ownerKind: ParamOwner,
+      ofClass: Boolean = false,
+      ofCaseClass: Boolean = false,
+      givenOnly: Boolean = false,
+      numLeadParams: Int = 0
+    ): List[List[TypeDef] | List[ValDef]] =
+
+      def recur(firstClause: Boolean, numLeadParams: Int): List[List[TypeDef] | List[ValDef]] =
         newLineOptWhenFollowedBy(LPAREN)
         newLineOptWhenFollowedBy(LBRACKET)
         if in.token == LPAREN then
           val paramsStart = in.offset
-          val params = paramClause(
-              nparams,
+          val params = termParamClause(
+              numLeadParams,
               ofClass = ofClass,
               ofCaseClass = ofCaseClass,
               givenOnly = givenOnly,
@@ -3124,13 +3125,13 @@ object Parsers {
           val lastClause = params.nonEmpty && params.head.mods.flags.is(Implicit)
           params :: (
             if lastClause then Nil
-            else recur(firstClause = false, nparams + params.length))
+            else recur(firstClause = false, numLeadParams + params.length))
         else if in.token == LBRACKET then
-          typeParamClause(ownerKind) :: recur(firstClause, nparams)
+          typeParamClause(ownerKind) :: recur(firstClause, numLeadParams)
         else Nil
       end recur
 
-      recur(firstClause = true, nparams = numLeadParams)
+      recur(firstClause = true, numLeadParams = numLeadParams)
     end typeOrTermParamClauses
 
 
@@ -3187,15 +3188,15 @@ object Parsers {
 
     /** ContextTypes   ::=  FunArgType {‘,’ FunArgType}
      */
-    def contextTypes(ofClass: Boolean, nparams: Int, impliedMods: Modifiers): List[ValDef] =
+    def contextTypes(ofClass: Boolean, numLeadParams: Int, impliedMods: Modifiers): List[ValDef] =
       val tps = commaSeparated(funArgType)
-      var counter = nparams
+      var counter = numLeadParams
       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) ‘)’
+    /** ClsTermParamClause    ::=  ‘(’ [‘erased’] ClsParams ‘)’ | UsingClsTermParamClause
+     *  UsingClsTermParamClause::= ‘(’ ‘using’ [‘erased’] (ClsParams | ContextTypes) ‘)’
      *  ClsParams         ::=  ClsParam {‘,’ ClsParam}
      *  ClsParam          ::=  {Annotation}
      * 
@@ -3212,13 +3213,14 @@ object Parsers {
      *
      *  @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] = {
+    def termParamClause(
+      numLeadParams: 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() })
@@ -3283,7 +3285,7 @@ object Parsers {
           checkVarArgsRules(rest)
       }
 
-      // begin paramClause
+      // begin termParamClause
       inParens {
         if in.token == RPAREN && !prefix && !impliedMods.is(Given) then Nil
         else
@@ -3298,28 +3300,30 @@ object Parsers {
                 || startParamTokens.contains(in.token)
                 || isIdent && (in.name == nme.inline || in.lookahead.isColon)
               if isParams then commaSeparated(() => param())
-              else contextTypes(ofClass, nparams, impliedMods)
+              else contextTypes(ofClass, numLeadParams, impliedMods)
           checkVarArgsRules(clause)
           clause
       }
     }
 
-    /** ClsParamClauses   ::=  {ClsParamClause} [[nl] ‘(’ [‘implicit’] ClsParams ‘)’]
-     *  TypelessClauses   ::= TypelessClause {TypelessClause}
+    /** ClsTermParamClauses   ::=  {ClsTermParamClause} [[nl] ‘(’ [‘implicit’] ClsParams ‘)’]
+     *  TypelessClauses       ::=  TypelessClause {TypelessClause}
      *
      *  @return  The parameter definitions
      */
-    def paramClauses(ofClass: Boolean = false,
-                     ofCaseClass: Boolean = false,
-                     givenOnly: Boolean = false,
-                     numLeadParams: Int = 0): List[List[ValDef]] =
+    def termParamClauses(
+      ofClass: Boolean = false,
+      ofCaseClass: Boolean = false,
+      givenOnly: Boolean = false,
+      numLeadParams: Int = 0
+    ): List[List[ValDef]] =
 
-      def recur(firstClause: Boolean, nparams: Int): List[List[ValDef]] =
+      def recur(firstClause: Boolean, numLeadParams: Int): List[List[ValDef]] =
         newLineOptWhenFollowedBy(LPAREN)
         if in.token == LPAREN then
           val paramsStart = in.offset
-          val params = paramClause(
-              nparams,
+          val params = termParamClause(
+              numLeadParams,
               ofClass = ofClass,
               ofCaseClass = ofCaseClass,
               givenOnly = givenOnly,
@@ -3327,12 +3331,12 @@ object Parsers {
           val lastClause = params.nonEmpty && params.head.mods.flags.is(Implicit)
           params :: (
             if lastClause then Nil
-            else recur(firstClause = false, nparams + params.length))
+            else recur(firstClause = false, numLeadParams + params.length))
         else Nil
       end recur
 
       recur(firstClause = true, numLeadParams)
-    end paramClauses
+    end termParamClauses
 
 /* -------- DEFS ------------------------------------------- */
 
@@ -3573,11 +3577,15 @@ object Parsers {
       }
     }
 
+    
+
     /** DefDef  ::=  DefSig [‘:’ Type] ‘=’ Expr
      *            |  this TypelessClauses [DefImplicitClause] `=' ConstrExpr
      *  DefDcl  ::=  DefSig `:' Type
+     *  DefSig  ::=  id [DefTypeParamClause] DefTermParamClauses
+     * 
+     * if clauseInterleaving is enabled:
      *  DefSig  ::=  id [DefParamClauses] [DefImplicitClause]
-     *            |  ExtParamClause [nl] [‘.’] id DefParamClauses
      */
     def defDefOrDcl(start: Offset, mods: Modifiers, numLeadParams: Int = 0): DefDef = atSpan(start, nameStart) {
 
@@ -3596,7 +3604,7 @@ object Parsers {
 
       if (in.token == THIS) {
         in.nextToken()
-        val vparamss = paramClauses(numLeadParams = numLeadParams)
+        val vparamss = termParamClauses(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")
@@ -3753,12 +3761,12 @@ object Parsers {
       val templ = templateOpt(constr)
       finalizeDef(TypeDef(name, templ), mods, start)
 
-    /** ClassConstr ::= [ClsTypeParamClause] [ConstrMods] ClsParamClauses
+    /** ClassConstr ::= [ClsTypeParamClause] [ConstrMods] ClsTermParamClauses
      */
     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)
+      val vparamss = termParamClauses(ofClass = true, ofCaseClass = isCaseClass)
       makeConstructor(tparams, vparamss).withMods(cmods)
     }
 
@@ -3860,7 +3868,7 @@ object Parsers {
         newLineOpt()
         val vparamss =
           if in.token == LPAREN && in.lookahead.isIdent(nme.using)
-          then paramClauses(givenOnly = true)
+          then termParamClauses(givenOnly = true)
           else Nil
         newLinesOpt()
         val noParams = tparams.isEmpty && vparamss.isEmpty
@@ -3902,13 +3910,13 @@ object Parsers {
       val start = in.skipToken()
       val tparams = typeParamClauseOpt(ParamOwner.Def)
       val leadParamss = ListBuffer[List[ValDef]]()
-      def nparams = leadParamss.map(_.length).sum
+      def numLeadParams = leadParamss.map(_.length).sum
       while
-        val extParams = paramClause(nparams, prefix = true)
+        val extParams = termParamClause(numLeadParams, prefix = true)
         leadParamss += extParams
         isUsingClause(extParams)
       do ()
-      leadParamss ++= paramClauses(givenOnly = true, numLeadParams = nparams)
+      leadParamss ++= termParamClauses(givenOnly = true, numLeadParams = numLeadParams)
       if in.isColon then
         syntaxError(em"no `:` expected here")
         in.nextToken()
@@ -3916,11 +3924,11 @@ object Parsers {
         if in.token == EXPORT then
           exportClause()
         else if isDefIntro(modifierTokens) then
-          extMethod(nparams) :: Nil
+          extMethod(numLeadParams) :: Nil
         else
           in.observeIndented()
           newLineOptWhenFollowedBy(LBRACE)
-          if in.isNestedStart then inDefScopeBraces(extMethods(nparams))
+          if in.isNestedStart then inDefScopeBraces(extMethods(numLeadParams))
           else { syntaxErrorOrIncomplete(em"Extension without extension methods") ; Nil }
       val result = atSpan(start)(ExtMethods(joinParams(tparams, leadParamss.toList), methods))
       val comment = in.getDocComment(start)

From cd27721adbf3b425dc150bffc3e97274e77d5ac1 Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Tue, 29 Nov 2022 13:18:29 +0100
Subject: [PATCH 083/657] Remove type currying

This adds back the TypeApply case that was present in Applications.scala.
With it is an improved error message that shows a potential fix.
---
 .../dotty/tools/dotc/parsing/Parsers.scala    | 15 ++++++++++-----
 .../dotty/tools/dotc/typer/Applications.scala |  6 ++++++
 docs/_docs/internals/syntax.md                |  4 ++--
 .../generalized-method-syntax.md              | 19 +++++--------------
 docs/_docs/reference/syntax.md                |  2 +-
 5 files changed, 24 insertions(+), 22 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index a56c5175be02..bac5d4e94d99 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -3101,7 +3101,7 @@ object Parsers {
       
     end typeOrTermParamClause
     
-    /** DefParamClauses       ::= DefParamClause { DefParamClause }
+    /** DefParamClauses       ::= DefParamClause { DefParamClause }  -- and two DefTypeParamClause cannot be adjacent
      */
     def typeOrTermParamClauses(
       ownerKind: ParamOwner,
@@ -3111,7 +3111,7 @@ object Parsers {
       numLeadParams: Int = 0
     ): List[List[TypeDef] | List[ValDef]] =
 
-      def recur(firstClause: Boolean, numLeadParams: Int): List[List[TypeDef] | List[ValDef]] =
+      def recur(firstClause: Boolean, numLeadParams: Int, prevIsTypeClause: Boolean): List[List[TypeDef] | List[ValDef]] =
         newLineOptWhenFollowedBy(LPAREN)
         newLineOptWhenFollowedBy(LBRACKET)
         if in.token == LPAREN then
@@ -3125,13 +3125,18 @@ object Parsers {
           val lastClause = params.nonEmpty && params.head.mods.flags.is(Implicit)
           params :: (
             if lastClause then Nil
-            else recur(firstClause = false, numLeadParams + params.length))
+            else recur(firstClause = false, numLeadParams + params.length, prevIsTypeClause = false))
         else if in.token == LBRACKET then
-          typeParamClause(ownerKind) :: recur(firstClause, numLeadParams)
+          if prevIsTypeClause then
+            syntaxError(
+              em"Type parameter lists must be separated by a term or using parameter list",
+              in.offset
+            )
+          typeParamClause(ownerKind) :: recur(firstClause, numLeadParams, prevIsTypeClause = true)
         else Nil
       end recur
 
-      recur(firstClause = true, numLeadParams = numLeadParams)
+      recur(firstClause = true, numLeadParams = numLeadParams, prevIsTypeClause = false)
     end typeOrTermParamClauses
 
 
diff --git a/compiler/src/dotty/tools/dotc/typer/Applications.scala b/compiler/src/dotty/tools/dotc/typer/Applications.scala
index 19b96f00d365..e15121ff1636 100644
--- a/compiler/src/dotty/tools/dotc/typer/Applications.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Applications.scala
@@ -1151,6 +1151,12 @@ trait Applications extends Compatibility {
     val typedArgs = if (isNamed) typedNamedArgs(tree.args) else tree.args.mapconserve(typedType(_))
     record("typedTypeApply")
     typedExpr(tree.fun, PolyProto(typedArgs, pt)) match {
+      case fun: TypeApply if !ctx.isAfterTyper =>
+        val function = fun.fun
+        val args = (fun.args ++ tree.args).map(_.show).mkString(", ")
+        errorTree(tree, em"""illegal repeated type application
+                            |You might have meant something like:
+                            |${function}[${args}]""")
       case typedFn =>
         typedFn.tpe.widen match {
           case pt: PolyType =>
diff --git a/docs/_docs/internals/syntax.md b/docs/_docs/internals/syntax.md
index dfdad496d446..1fbb7a34b078 100644
--- a/docs/_docs/internals/syntax.md
+++ b/docs/_docs/internals/syntax.md
@@ -361,7 +361,7 @@ ClsParams         ::=  ClsParam {‘,’ ClsParam}
 ClsParam          ::=  {Annotation}                                             ValDef(mods, id, tpe, expr) -- point of mods on val/var
                        [{Modifier} (‘val’ | ‘var’) | ‘inline’] Param
 
-DefParamClauses   ::=  DefParamClause { DefParamClause }
+DefParamClauses   ::=  DefParamClause { DefParamClause } -- and two DefTypeParamClause cannot be adjacent
 DefParamClause    ::=  DefTypeParamClause 
                     |  DefTermParamClause 
                     |  UsingParamClause
@@ -427,7 +427,7 @@ Dcl               ::=  RefineDcl
                     |  ‘var’ VarDcl
 ValDcl            ::=  ids ‘:’ Type                                             PatDef(_, ids, tpe, EmptyTree)
 VarDcl            ::=  ids ‘:’ Type                                             PatDef(_, ids, tpe, EmptyTree)
-DefDcl            ::=  DefSig ‘:’ Type                                          DefDef(_, name, tparams, vparamss, tpe, EmptyTree)
+DefDcl            ::=  DefSig ‘:’ Type                                          DefDef(_, name, paramss, tpe, EmptyTree)
 DefSig            ::=  id [DefParamClauses] [DefImplicitClause]
 TypeDcl           ::=  id [TypeParamClause] {FunParamClause} TypeBounds         TypeDefTree(_, name, tparams, bound
                        [‘=’ Type]
diff --git a/docs/_docs/reference/other-new-features/generalized-method-syntax.md b/docs/_docs/reference/other-new-features/generalized-method-syntax.md
index dbe9c6eb0a61..c78a5df8a3f4 100644
--- a/docs/_docs/reference/other-new-features/generalized-method-syntax.md
+++ b/docs/_docs/reference/other-new-features/generalized-method-syntax.md
@@ -18,11 +18,11 @@ def foo[T, U](x: T)(y: U)(z: Int, s: String)(a: Array[T])(implicit ordInt: Ord[I
 
 ### In Scala 3
 
-The new syntax allows any number of type, term and using clause, in any order, optionnaly followed by an implicit clause:
+The new syntax allows any number of type clauses, as long as they are not adjacent:
 (do note however that [implicit clause are discouraged, in favor of using clauses](https://docs.scala-lang.org/scala3/reference/contextual/relationship-implicits.html))
 
 ```scala
-def foo[T, U](x: T)(y: U)[V](z: V, s: String)[A](a: Array[A])(implicit List[U])
+def foo[T, U](x: T)(y: U)[V](z: V, s: String)(using Ord[Int])[A](a: Array[A])(implicit List[U])
 ```
 
 ### Unchanged
@@ -48,15 +48,6 @@ trait DB {
 Note that simply replacing `V` by `k.Value` would not be equivalent. For example, if `k.Value` is `Some[Int]`, only the above allows: 
 `getOrElse(k)[Option[Int]](None)`, which returns a `Number`.
 
-### Partial Inference
-
-It is now possible to only infer some of the type parameters, this reduces boilerplate at the use site:
-```scala
-trait StaticSizeList[S <: Int & Singleton, T]
-def filled[S <: Int & Singleton][T](x: T): StaticSizeList[S,T] = ???
-val helloes = filled[4]("Hello!") // S=4, and T is inferred
-```
-
 ## Details
 
 ### Application
@@ -90,9 +81,9 @@ On the other hand, the `getOrElse` method is recommended as-is, as it cannot be
 DefDcl            ::=  DefSig ‘:’ Type
 DefDef            ::=  DefSig [‘:’ Type] ‘=’ Expr
 DefSig            ::=  id [DefParamClauses] [DefImplicitClause]
-DefParamClauses   ::=  DefParamClause { DefParamClause }
-DefParamClause    ::=  DefTypeParamClause 
-                    |  DefTermParamClause 
+DefParamClauses   ::=  DefParamClause { DefParamClause } -- and two DefTypeParamClause cannot be adjacent
+DefParamClause    ::=  DefTypeParamClause
+                    |  DefTermParamClause
                     |  UsingParamClause
 DefTypeParamClause::=  [nl] ‘[’ DefTypeParam {‘,’ DefTypeParam} ‘]’
 DefTypeParam      ::=  {Annotation} id [HkTypeParamClause] TypeParamBounds
diff --git a/docs/_docs/reference/syntax.md b/docs/_docs/reference/syntax.md
index 1d0c45030d2c..dde70d2131ad 100644
--- a/docs/_docs/reference/syntax.md
+++ b/docs/_docs/reference/syntax.md
@@ -350,7 +350,7 @@ ClsParamClause    ::=  [nl] ‘(’ ClsParams ‘)’
 ClsParams         ::=  ClsParam {‘,’ ClsParam}
 ClsParam          ::=  {Annotation} [{Modifier} (‘val’ | ‘var’) | ‘inline’] Param
 
-DefParamClauses   ::=  DefParamClause { DefParamClause }
+DefParamClauses   ::=  DefParamClause { DefParamClause } -- and two DefTypeParamClause cannot be adjacent
 DefParamClause    ::=  DefTypeParamClause 
                     |  DefTermParamClause 
                     |  UsingParamClause

From d59a3e61d78a1a5ddc5248d4929b9a3111879335 Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Tue, 6 Dec 2022 16:41:53 +0100
Subject: [PATCH 084/657] Update tests

---
 tests/neg/interleaving-ab.scala                 |  5 +++--
 tests/neg/interleaving-typeApply.scala          |  6 +++---
 tests/neg/namedTypeParams.scala                 |  7 +++++--
 tests/pos/interleaving-ba.scala                 |  4 ++--
 tests/pos/interleaving-classless.scala          |  6 +++---
 ...leaving.scala => interleaving-functor.scala} |  2 +-
 tests/pos/interleaving-functorCurrying.scala    | 17 -----------------
 tests/pos/interleaving-overload.scala           |  4 ++--
 tests/pos/interleaving-params.scala             |  2 +-
 tests/pos/interleaving-typeApply.scala          | 14 +++++++-------
 tests/pos/namedTypeParams.scala                 |  6 ++++++
 11 files changed, 33 insertions(+), 40 deletions(-)
 rename tests/pos/{interleaving-functorInterleaving.scala => interleaving-functor.scala} (90%)
 delete mode 100644 tests/pos/interleaving-functorCurrying.scala

diff --git a/tests/neg/interleaving-ab.scala b/tests/neg/interleaving-ab.scala
index 0d6649bbb3be..281002ba37fc 100644
--- a/tests/neg/interleaving-ab.scala
+++ b/tests/neg/interleaving-ab.scala
@@ -2,7 +2,8 @@ object Ab:
     given String = ""
     given Double = 0
 
-    def ab[A][B](x: A)(using B): B = summon[B]
-
+    def illegal[A][B](x: A)(using B): B = summon[B] // error: Type parameter lists must be separated by a term or using parameter list
+    
+    def ab[A](x: A)[B](using B): B = summon[B]
     def test =
         ab[Int](0: Int) // error
\ No newline at end of file
diff --git a/tests/neg/interleaving-typeApply.scala b/tests/neg/interleaving-typeApply.scala
index 2e5f652dc21a..498873abae91 100644
--- a/tests/neg/interleaving-typeApply.scala
+++ b/tests/neg/interleaving-typeApply.scala
@@ -1,8 +1,8 @@
 object typeApply:
     
-    def f3[T <: Int][U <: String](): T => T = ???
-    def f5[T <: Int][U <: String]: [X <: Unit] => X => X = ???
-    def f7[T <: Int][U <: String]()[X <: Unit]: X => X = ???
+    def f3[T <: Int](using DummyImplicit)[U <: String](): T => T = ???
+    def f5[T <: Int](using DummyImplicit)[U <: String]: [X <: Unit] => X => X = ???
+    def f7[T <: Int](using DummyImplicit)[U <: String]()[X <: Unit]: X => X = ???
 
     @main def test = {
         f3[String]() // error
diff --git a/tests/neg/namedTypeParams.scala b/tests/neg/namedTypeParams.scala
index 197fc6a9a790..1b85ee6349f4 100644
--- a/tests/neg/namedTypeParams.scala
+++ b/tests/neg/namedTypeParams.scala
@@ -17,7 +17,6 @@ object Test {
   def f[X, Y](x: X, y: Y): Int = ???
 
   f[X = Int, String](1, "") // error // error
-  /* Conflicts with Clause Interweaving, stems from named type parameters assuming one type clause
   f[X = Int][X = Int][Y = String](1, "") // error: illegal repeated type application
 
   f[X = Int][Y = String](1, "") // error: illegal repeated type application
@@ -25,5 +24,9 @@ object Test {
 
   f[Y = String][X = Int](1, "") // error: illegal repeated type application
   f[Y = String][Int](1, "") // error: illegal repeated type application
-  */
+
+  def f2[X](using DummyImplicit)[Y](x: X, y: Y): Int = ???
+
+  f2[Y = String][X = Int](1, "") // error: Y is undefined
+  f2[Y = String](1, "") // error: Y is undefined
 }
diff --git a/tests/pos/interleaving-ba.scala b/tests/pos/interleaving-ba.scala
index 74c15d4e87e9..dc2b36202891 100644
--- a/tests/pos/interleaving-ba.scala
+++ b/tests/pos/interleaving-ba.scala
@@ -4,8 +4,8 @@ object BA {
     given String = ""
     given Double = 0
 
-    def ba[B][A](x: A)(using B): B = summon[B]
+    def ba[A](x: A)[B](using B): B = summon[B]
 
-    def test = ba[String](0)
+    def test = ba(0)[String]
 
 }
\ No newline at end of file
diff --git a/tests/pos/interleaving-classless.scala b/tests/pos/interleaving-classless.scala
index 4308030f66a6..924202673029 100644
--- a/tests/pos/interleaving-classless.scala
+++ b/tests/pos/interleaving-classless.scala
@@ -1,4 +1,4 @@
-def f1[T][U](x: T, y: U): (T, U) = (x, y)
+def f1[T]()[U](x: T, y: U): (T, U) = (x, y)
 def f2[T](x: T)[U](y: U): (T, U) = (x, y)
-def f3[T, U][V](x: T): U = ???
-def f4[T](x: T)[U <: x.type](y: U): (T, U) = (x, y)
\ No newline at end of file
+def f3[T, U](using DummyImplicit)[V](x: T): U = ???
+def f4[T](x: T)[U <: x.type](y: U): (T, U) = (x, y)
diff --git a/tests/pos/interleaving-functorInterleaving.scala b/tests/pos/interleaving-functor.scala
similarity index 90%
rename from tests/pos/interleaving-functorInterleaving.scala
rename to tests/pos/interleaving-functor.scala
index fb14c151387c..00c26151f5cb 100644
--- a/tests/pos/interleaving-functorInterleaving.scala
+++ b/tests/pos/interleaving-functor.scala
@@ -10,7 +10,7 @@ object functorInterweaving:
     def map[A](x: List[A])[B](f: A => B): List[B] =
       x.map(f)
 
-  def assertTransformation[F[_]: Functor][A](original: F[A])[B](expected: F[B])(mapping: A => B): Unit =
+  def assertTransformation[F[_]: Functor, A](original: F[A])[B](expected: F[B])(mapping: A => B): Unit =
     assert(expected == summon[Functor[F]].map(original)(mapping))
 
   @main def testInterweaving =
diff --git a/tests/pos/interleaving-functorCurrying.scala b/tests/pos/interleaving-functorCurrying.scala
deleted file mode 100644
index 078d65233997..000000000000
--- a/tests/pos/interleaving-functorCurrying.scala
+++ /dev/null
@@ -1,17 +0,0 @@
-object functorCurrying:
-  //taken from https://dotty.epfl.ch/docs/reference/contextual/type-classes.html
-  //at version 3.1.1-RC1-bin-20210930-01f040b-NIGHTLY
-  //modified to have type currying
-  trait Functor[F[_]]:
-    def map[A][B](x: F[A], f: A => B): F[B]
-
-
-  given Functor[List] with
-    def map[A][B](x: List[A], f: A => B): List[B] =
-      x.map(f)
-
-  def assertTransformation[F[_]: Functor][A][B](expected: F[B], original: F[A], mapping: A => B): Unit =
-    assert(expected == summon[Functor[F]].map(original, mapping))
-
-  @main def testCurrying =
-    assertTransformation(List("a1", "b1"), List("a", "b"), elt => s"${elt}1")
diff --git a/tests/pos/interleaving-overload.scala b/tests/pos/interleaving-overload.scala
index 3dcb0a911704..02074fd82914 100644
--- a/tests/pos/interleaving-overload.scala
+++ b/tests/pos/interleaving-overload.scala
@@ -1,8 +1,8 @@
 
 class A{
 
-    def f1[T][U](x: Any) = ???
-    def f1[T][U](x: Int) = ???
+    def f1[T](x: Any)[U] = ???
+    def f1[T](x: Int)[U] = ???
 
     f1(1)
     f1("hello")
diff --git a/tests/pos/interleaving-params.scala b/tests/pos/interleaving-params.scala
index fb55d451b2bd..dec9f6780370 100644
--- a/tests/pos/interleaving-params.scala
+++ b/tests/pos/interleaving-params.scala
@@ -1,6 +1,6 @@
 class Params{
     type U
-    def foo[T](x: T)[U >: x.type <: T][L <: List[U]](l: L): L = ???
+    def foo[T](x: T)[U >: x.type <: T](using U)[L <: List[U]](l: L): L = ???
     def aaa(x: U): U = ???
     def bbb[T <: U](x: U)[U]: U = ???
 }
\ No newline at end of file
diff --git a/tests/pos/interleaving-typeApply.scala b/tests/pos/interleaving-typeApply.scala
index b637d59e2239..5b0be806bf33 100644
--- a/tests/pos/interleaving-typeApply.scala
+++ b/tests/pos/interleaving-typeApply.scala
@@ -1,13 +1,13 @@
 object typeApply:
 
     def f0[T]: [U] => T => T = ???
-    def f1[T][U]: T => T = ???
-    def f2[T][U](): T => T = ???
-    def f3[T <: Int][U <: String](): T => T = ???
-    def f4[T <: Int][U <: String]: T => T = ???
-    def f5[T <: Int][U <: String]: [X <: Unit] => X => X = ???
-    def f6[T <: Int][U <: String](): [X <: Unit] => X => X = ???
-    def f7[T <: Int][U <: String]()[X <: Unit]: X => X = ???
+    def f1[T](using DummyImplicit)[U]: T => T = ???
+    def f2[T](using DummyImplicit)[U](): T => T = ???
+    def f3[T <: Int](using DummyImplicit)[U <: String](): T => T = ???
+    def f4[T <: Int](using DummyImplicit)[U <: String]: T => T = ???
+    def f5[T <: Int](using DummyImplicit)[U <: String]: [X <: Unit] => X => X = ???
+    def f6[T <: Int](using DummyImplicit)[U <: String](): [X <: Unit] => X => X = ???
+    def f7[T <: Int](using DummyImplicit)[U <: String]()[X <: Unit]: X => X = ???
 
     @main def test = {
         f0[Int][String]
diff --git a/tests/pos/namedTypeParams.scala b/tests/pos/namedTypeParams.scala
index a8c38972838c..86f35bf3c596 100644
--- a/tests/pos/namedTypeParams.scala
+++ b/tests/pos/namedTypeParams.scala
@@ -9,4 +9,10 @@ object Test {
   f[Y = String](1, "")
 
 
+  def f2[X](using DummyImplicit)[Y](x: X, y: Y): Int = ???
+
+  f2[X = Int][Y = String](1, "")
+  f2[X = Int](1, "")
+
+
 }

From b9b3ed5a12a13f1852fd32ca5e3dce7995870e22 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Doeraene?= <sjrdoeraene@gmail.com>
Date: Thu, 2 Feb 2023 16:47:59 +0100
Subject: [PATCH 085/657] Fix #15107: Avoid re-emitting a LineNumber after only
 LabelNodes.

There was already some deduplication code to avoid consecutive
`LineNumber` nodes. However, it can happen that `LabelNode`s
appear in-between. In that case, we also want to deduplicate the
`LineNumber`s, since labels do not actually contribute to the
final bytecode.
---
 .../tools/backend/jvm/BCodeSkelBuilder.scala  |  8 +++-
 .../backend/jvm/DottyBytecodeTests.scala      |  2 -
 .../backend/jvm/InlineBytecodeTests.scala     | 48 +++++++++----------
 3 files changed, 29 insertions(+), 29 deletions(-)

diff --git a/compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala b/compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala
index 1885210a6687..b9f0d4ee302d 100644
--- a/compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala
+++ b/compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala
@@ -556,11 +556,17 @@ trait BCodeSkelBuilder extends BCodeHelpers {
         case _ => false } )
     }
     def lineNumber(tree: Tree): Unit = {
+      @tailrec
+      def getNonLabelNode(a: asm.tree.AbstractInsnNode): asm.tree.AbstractInsnNode = a match {
+        case a: asm.tree.LabelNode => getNonLabelNode(a.getPrevious)
+        case _                     => a
+      }
+
       if (!emitLines || !tree.span.exists) return;
       val nr = ctx.source.offsetToLine(tree.span.point) + 1
       if (nr != lastEmittedLineNr) {
         lastEmittedLineNr = nr
-        lastInsn match {
+        getNonLabelNode(lastInsn) match {
           case lnn: asm.tree.LineNumberNode =>
             // overwrite previous landmark as no instructions have been emitted for it
             lnn.line = nr
diff --git a/compiler/test/dotty/tools/backend/jvm/DottyBytecodeTests.scala b/compiler/test/dotty/tools/backend/jvm/DottyBytecodeTests.scala
index 71bf530fcda5..ac4ba3ee0e75 100644
--- a/compiler/test/dotty/tools/backend/jvm/DottyBytecodeTests.scala
+++ b/compiler/test/dotty/tools/backend/jvm/DottyBytecodeTests.scala
@@ -1622,7 +1622,6 @@ class DottyBytecodeTests extends DottyBytecodeTest {
       val instructions = instructionsFromMethod(method).filter(_.isInstanceOf[LineNumber])
 
       val expected = List(
-        LineNumber(2, Label(0)),
         LineNumber(3, Label(0)),
         LineNumber(4, Label(5)), // case y =>
         LineNumber(5, Label(9)),
@@ -1664,7 +1663,6 @@ class DottyBytecodeTests extends DottyBytecodeTest {
       val instructions = instructionsFromMethod(method).filter(_.isInstanceOf[LineNumber])
 
       val expected = List(
-        LineNumber(2, Label(0)),
         LineNumber(3, Label(0)),
         LineNumber(4, Label(5)), // case a if a == 3 =>
         LineNumber(5, Label(15)),
diff --git a/compiler/test/dotty/tools/backend/jvm/InlineBytecodeTests.scala b/compiler/test/dotty/tools/backend/jvm/InlineBytecodeTests.scala
index 33e898718b33..d55d1343ea7e 100644
--- a/compiler/test/dotty/tools/backend/jvm/InlineBytecodeTests.scala
+++ b/compiler/test/dotty/tools/backend/jvm/InlineBytecodeTests.scala
@@ -163,28 +163,27 @@ class InlineBytecodeTests extends DottyBytecodeTest {
       val expected =
         List(
           Label(0),
-          LineNumber(6, Label(0)),
           LineNumber(3, Label(0)),
           VarOp(ALOAD, 0),
           Ldc(LDC, "tracking"),
           Invoke(INVOKEVIRTUAL, "Foo", "foo", "(Ljava/lang/String;)V", false),
-          Label(6),
-          LineNumber(8, Label(6)),
+          Label(5),
+          LineNumber(8, Label(5)),
           VarOp(ALOAD, 0),
           Ldc(LDC, "abc"),
           Invoke(INVOKEVIRTUAL, "Foo", "foo", "(Ljava/lang/String;)V", false),
-          Label(11),
-          LineNumber(3, Label(11)),
+          Label(10),
+          LineNumber(3, Label(10)),
           VarOp(ALOAD, 0),
           Ldc(LDC, "tracking"),
           Invoke(INVOKEVIRTUAL, "Foo", "foo", "(Ljava/lang/String;)V", false),
-          Label(16),
-          LineNumber(10, Label(16)),
+          Label(15),
+          LineNumber(10, Label(15)),
           VarOp(ALOAD, 0),
           Ldc(LDC, "inner"),
           Invoke(INVOKEVIRTUAL, "Foo", "foo", "(Ljava/lang/String;)V", false),
           Op(RETURN),
-          Label(22)
+          Label(21)
         )
       assert(instructions == expected,
         "`track` was not properly inlined in `main`\n" + diffInstructions(instructions, expected))
@@ -228,23 +227,22 @@ class InlineBytecodeTests extends DottyBytecodeTest {
       val expected =
         List(
           Label(0),
-          LineNumber(12, Label(0)),
           LineNumber(7, Label(0)),
           VarOp(ALOAD, 0),
           Ldc(LDC, "tracking"),
           Invoke(INVOKEVIRTUAL, "Foo", "foo", "(Ljava/lang/String;)V", false),
-          Label(6),
-          LineNumber(3, Label(6)),
+          Label(5),
+          LineNumber(3, Label(5)),
           VarOp(ALOAD, 0),
           Ldc(LDC, "tracking2"),
           Invoke(INVOKEVIRTUAL, "Foo", "foo", "(Ljava/lang/String;)V", false),
-          Label(11),
-          LineNumber(14, Label(11)),
+          Label(10),
+          LineNumber(14, Label(10)),
           VarOp(ALOAD, 0),
           Ldc(LDC, "abc"),
           Invoke(INVOKEVIRTUAL, "Foo", "foo", "(Ljava/lang/String;)V", false),
           Op(RETURN),
-          Label(17)
+          Label(16)
         )
       assert(instructions == expected,
         "`track` was not properly inlined in `main`\n" + diffInstructions(instructions, expected))
@@ -288,23 +286,22 @@ class InlineBytecodeTests extends DottyBytecodeTest {
       val expected =
         List(
           Label(0),
-          LineNumber(12, Label(0)),
           LineNumber(3, Label(0)),
           VarOp(ALOAD, 0),
           Ldc(LDC, "tracking2"),
           Invoke(INVOKEVIRTUAL, "Foo", "foo", "(Ljava/lang/String;)V", false),
-          Label(6),
-          LineNumber(8, Label(6)),
+          Label(5),
+          LineNumber(8, Label(5)),
           VarOp(ALOAD, 0),
           Ldc(LDC, "fgh"),
           Invoke(INVOKEVIRTUAL, "Foo", "foo", "(Ljava/lang/String;)V", false),
-          Label(11),
-          LineNumber(14, Label(11)),
+          Label(10),
+          LineNumber(14, Label(10)),
           VarOp(ALOAD, 0),
           Ldc(LDC, "abc"),
           Invoke(INVOKEVIRTUAL, "Foo", "foo", "(Ljava/lang/String;)V", false),
           Op(RETURN),
-          Label(17)
+          Label(16)
         )
       assert(instructions == expected,
         "`track` was not properly inlined in `main`\n" + diffInstructions(instructions, expected))
@@ -349,23 +346,22 @@ class InlineBytecodeTests extends DottyBytecodeTest {
       val expected =
         List(
           Label(0),
-          LineNumber(13, Label(0)),
           LineNumber(3, Label(0)),
           VarOp(ALOAD, 0),
           Ldc(LDC, "tracking2"),
           Invoke(INVOKEVIRTUAL, "Foo", "foo", "(Ljava/lang/String;)V", false),
-          Label(6),
-          LineNumber(3, Label(6)),
+          Label(5),
+          LineNumber(3, Label(5)),
           VarOp(ALOAD, 0),
           Ldc(LDC, "tracking2"),
           Invoke(INVOKEVIRTUAL, "Foo", "foo", "(Ljava/lang/String;)V", false),
-          Label(11),
-          LineNumber(15, Label(11)),
+          Label(10),
+          LineNumber(15, Label(10)),
           VarOp(ALOAD, 0),
           Ldc(LDC, "abc"),
           Invoke(INVOKEVIRTUAL, "Foo", "foo", "(Ljava/lang/String;)V", false),
           Op(RETURN),
-          Label(17)
+          Label(16)
         )
       assert(instructions == expected,
         "`track` was not properly inlined in `main`\n" + diffInstructions(instructions, expected))

From 1a6c5c5552a15458c617cdbe09d4f8ce09c7462b Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Fri, 13 Jan 2023 14:45:17 +0100
Subject: [PATCH 086/657] Add and Fix tests

---
 .../src/tests/extensionParams.scala           |   1 -
 .../src/tests/methodsAndConstructors.scala    |   1 -
 tests/neg/extension-methods.scala             |   2 +-
 tests/neg/interleaving-ab.scala               |  14 +--
 tests/neg/interleaving-nameCollision.scala    |   3 -
 tests/neg/interleaving-params.scala           |   2 +-
 .../neg/interleaving-signatureCollision.scala |   3 +
 tests/neg/interleaving-typeApply.check        |  30 ++++++
 tests/neg/interleaving-typeApply.scala        |   2 +-
 tests/neg/interleaving-unmatched.scala        |   2 +-
 tests/neg/namedTypeParams.check               | 102 ++++++++++++++++++
 tests/neg/namedTypeParams.scala               |   5 +-
 tests/neg/overrides.scala                     |   2 -
 tests/pos/interleaving-ba.scala               |   3 +-
 tests/pos/interleaving-chainedParams.scala    |  24 ++---
 tests/pos/interleaving-functor.scala          |   4 +-
 tests/pos/interleaving-nameCollision.scala    |   5 -
 tests/pos/interleaving-overload.scala         |   2 +-
 tests/pos/interleaving-params.scala           |   2 +-
 .../pos/interleaving-signatureCollision.scala |   5 +
 tests/pos/interleaving-typeApply.scala        |   2 +-
 tests/pos/namedTypeParams.scala               |   1 -
 tests/run/interleaving.scala                  | 101 +++++++++++++++++
 23 files changed, 273 insertions(+), 45 deletions(-)
 delete mode 100644 tests/neg/interleaving-nameCollision.scala
 create mode 100644 tests/neg/interleaving-signatureCollision.scala
 create mode 100644 tests/neg/interleaving-typeApply.check
 create mode 100644 tests/neg/namedTypeParams.check
 delete mode 100644 tests/pos/interleaving-nameCollision.scala
 create mode 100644 tests/pos/interleaving-signatureCollision.scala
 create mode 100644 tests/run/interleaving.scala

diff --git a/scaladoc-testcases/src/tests/extensionParams.scala b/scaladoc-testcases/src/tests/extensionParams.scala
index 58b95c5dac1f..e064ff6d56d7 100644
--- a/scaladoc-testcases/src/tests/extensionParams.scala
+++ b/scaladoc-testcases/src/tests/extensionParams.scala
@@ -56,4 +56,3 @@ extension (using String)(using Unit)(a: Animal)(using Int)(using Number)
   = ???
   def f14[D](b: D)[T](c: T): T
   = ???
-
diff --git a/scaladoc-testcases/src/tests/methodsAndConstructors.scala b/scaladoc-testcases/src/tests/methodsAndConstructors.scala
index b4c354d174c4..5fc6af38888b 100644
--- a/scaladoc-testcases/src/tests/methodsAndConstructors.scala
+++ b/scaladoc-testcases/src/tests/methodsAndConstructors.scala
@@ -62,4 +62,3 @@ class Methods:
 
  def clauseInterleaving[T](x: T)[U](y: U)(using (T, U)): (T, U)
  = ???
-
diff --git a/tests/neg/extension-methods.scala b/tests/neg/extension-methods.scala
index e075105762f9..a11b2cca5add 100644
--- a/tests/neg/extension-methods.scala
+++ b/tests/neg/extension-methods.scala
@@ -15,4 +15,4 @@ object Test {
     def f2[T]: T = ???        // error: T is already defined as type T
     def f3(xs: List[T]) = ??? // error: xs is already defined as value xs
   }
-}
\ No newline at end of file
+}
diff --git a/tests/neg/interleaving-ab.scala b/tests/neg/interleaving-ab.scala
index 281002ba37fc..5516d9b9dd51 100644
--- a/tests/neg/interleaving-ab.scala
+++ b/tests/neg/interleaving-ab.scala
@@ -1,9 +1,9 @@
 object Ab:
-    given String = ""
-    given Double = 0
+  given String = ""
+  given Double = 0
 
-    def illegal[A][B](x: A)(using B): B = summon[B] // error: Type parameter lists must be separated by a term or using parameter list
-    
-    def ab[A](x: A)[B](using B): B = summon[B]
-    def test =
-        ab[Int](0: Int) // error
\ No newline at end of file
+  def illegal[A][B](x: A)(using B): B = summon[B] // error: Type parameter lists must be separated by a term or using parameter list
+  
+  def ab[A](x: A)[B](using B): B = summon[B]
+  def test =
+    ab[Int](0: Int) // error
diff --git a/tests/neg/interleaving-nameCollision.scala b/tests/neg/interleaving-nameCollision.scala
deleted file mode 100644
index 44aa1e169db4..000000000000
--- a/tests/neg/interleaving-nameCollision.scala
+++ /dev/null
@@ -1,3 +0,0 @@
-object nameCollision:
-    def f[T](x: T)[U](y: U) = (x,y)
-    def f[T](x: T, y: T) = (x,y) // error
\ No newline at end of file
diff --git a/tests/neg/interleaving-params.scala b/tests/neg/interleaving-params.scala
index e8fa5361a9ab..97de1e6e2948 100644
--- a/tests/neg/interleaving-params.scala
+++ b/tests/neg/interleaving-params.scala
@@ -4,4 +4,4 @@ class Params{
     def bbb[T <: U](x: U)[U]: U = ??? // error // error
     def f0[T](implicit x: T)[U](y: U) = (x,y) // error
     def f1[T](implicit x: T)[U] = (x,y) // error
-}
\ No newline at end of file
+}
diff --git a/tests/neg/interleaving-signatureCollision.scala b/tests/neg/interleaving-signatureCollision.scala
new file mode 100644
index 000000000000..d2df384dc1e7
--- /dev/null
+++ b/tests/neg/interleaving-signatureCollision.scala
@@ -0,0 +1,3 @@
+object signatureCollision:
+    def f[T](x: T)[U](y: U) = (x,y)
+    def f[T](x: T, y: T) = (x,y) // error
diff --git a/tests/neg/interleaving-typeApply.check b/tests/neg/interleaving-typeApply.check
new file mode 100644
index 000000000000..c932a899dfe6
--- /dev/null
+++ b/tests/neg/interleaving-typeApply.check
@@ -0,0 +1,30 @@
+-- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:8:11 ---------------------------------------------
+8 |        f3[String]() // error
+  |           ^
+  |           Type argument String does not conform to upper bound Int
+  |
+  | longer explanation available when compiling with `-explain`
+-- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:9:16 ---------------------------------------------
+9 |        f5[Int][Unit] // error
+  |                ^
+  |                Type argument Unit does not conform to upper bound String
+  |
+  | longer explanation available when compiling with `-explain`
+-- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:10:19 --------------------------------------------
+10 |        f5[String][Unit] // error // error
+   |                   ^
+   |                   Type argument Unit does not conform to upper bound String
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:10:11 --------------------------------------------
+10 |        f5[String][Unit] // error // error
+   |           ^
+   |           Type argument String does not conform to upper bound Int
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:11:11 --------------------------------------------
+11 |        f7[String]()[Unit] // error
+   |           ^
+   |           Type argument String does not conform to upper bound Int
+   |
+   | longer explanation available when compiling with `-explain`
diff --git a/tests/neg/interleaving-typeApply.scala b/tests/neg/interleaving-typeApply.scala
index 498873abae91..18a21b4984e1 100644
--- a/tests/neg/interleaving-typeApply.scala
+++ b/tests/neg/interleaving-typeApply.scala
@@ -9,4 +9,4 @@ object typeApply:
         f5[Int][Unit] // error
         f5[String][Unit] // error // error
         f7[String]()[Unit] // error
-    }
\ No newline at end of file
+    }
diff --git a/tests/neg/interleaving-unmatched.scala b/tests/neg/interleaving-unmatched.scala
index b2afcf5b5d45..c433c0a7210a 100644
--- a/tests/neg/interleaving-unmatched.scala
+++ b/tests/neg/interleaving-unmatched.scala
@@ -1,3 +1,3 @@
 object unmatched:
     def f1[T (x: T)] = ??? // error
-    def f2(x: Any[)T] = ??? // error // error
\ No newline at end of file
+    def f2(x: Any[)T] = ??? // error // error
diff --git a/tests/neg/namedTypeParams.check b/tests/neg/namedTypeParams.check
new file mode 100644
index 000000000000..1252f29c4e9e
--- /dev/null
+++ b/tests/neg/namedTypeParams.check
@@ -0,0 +1,102 @@
+-- [E040] Syntax Error: tests/neg/namedTypeParams.scala:2:8 ------------------------------------------------------------
+2 |class D[type T] // error: identifier expected, but `type` found
+  |        ^^^^
+  |        an identifier expected, but 'type' found
+  |
+  | longer explanation available when compiling with `-explain`
+-- [E040] Syntax Error: tests/neg/namedTypeParams.scala:11:13 ----------------------------------------------------------
+11 |  val x: C[T = Int] = // error:  ']' expected, but `=` found // error
+   |             ^
+   |             ']' expected, but '=' found
+-- [E040] Syntax Error: tests/neg/namedTypeParams.scala:12:12 ----------------------------------------------------------
+12 |    new C[T = Int] // error:  ']' expected, but `=` found // error
+   |            ^
+   |            ']' expected, but '=' found
+-- [E040] Syntax Error: tests/neg/namedTypeParams.scala:14:22 ----------------------------------------------------------
+14 |  class E extends C[T = Int] // error: ']' expected, but `=` found // error
+   |                      ^
+   |                      ']' expected, but '=' found
+-- [E040] Syntax Error: tests/neg/namedTypeParams.scala:15:22 ----------------------------------------------------------
+15 |  class F extends C[T = Int]() // error: ']' expected, but `=` found // error
+   |                      ^
+   |                      ']' expected, but '=' found
+-- [E040] Syntax Error: tests/neg/namedTypeParams.scala:19:19 ----------------------------------------------------------
+19 |  f[X = Int, String](1, "") // error // error
+   |                   ^
+   |                   '=' expected, but ']' found
+-- Error: tests/neg/namedTypeParams.scala:6:8 --------------------------------------------------------------------------
+6 |  f[X = Int, Y = Int](1, 2) // error: experimental // error: experimental
+  |        ^^^
+  |        Named type arguments are experimental,
+  |        they must be enabled with a `experimental.namedTypeArguments` language import or setting
+-- Error: tests/neg/namedTypeParams.scala:6:17 -------------------------------------------------------------------------
+6 |  f[X = Int, Y = Int](1, 2) // error: experimental // error: experimental
+  |                 ^^^
+  |                 Named type arguments are experimental,
+  |                 they must be enabled with a `experimental.namedTypeArguments` language import or setting
+-- [E006] Not Found Error: tests/neg/namedTypeParams.scala:11:11 -------------------------------------------------------
+11 |  val x: C[T = Int] = // error:  ']' expected, but `=` found // error
+   |           ^
+   |           Not found: type T
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E006] Not Found Error: tests/neg/namedTypeParams.scala:12:10 -------------------------------------------------------
+12 |    new C[T = Int] // error:  ']' expected, but `=` found // error
+   |          ^
+   |          Not found: type T
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E006] Not Found Error: tests/neg/namedTypeParams.scala:14:20 -------------------------------------------------------
+14 |  class E extends C[T = Int] // error: ']' expected, but `=` found // error
+   |                    ^
+   |                    Not found: type T
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E006] Not Found Error: tests/neg/namedTypeParams.scala:15:20 -------------------------------------------------------
+15 |  class F extends C[T = Int]() // error: ']' expected, but `=` found // error
+   |                    ^
+   |                    Not found: type T
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E102] Syntax Error: tests/neg/namedTypeParams.scala:19:18 ----------------------------------------------------------
+19 |  f[X = Int, String](1, "") // error // error
+   |                  ^
+   |                  Type parameter String is undefined. Expected one of X, Y.
+-- Error: tests/neg/namedTypeParams.scala:20:12 ------------------------------------------------------------------------
+20 |  f[X = Int][X = Int][Y = String](1, "") // error: illegal repeated type application
+   |  ^^^^^^^^^^^^^^^^^^^
+   |  illegal repeated type application
+   |  You might have meant something like:
+   |  Test.f[X = Int, X = Int]
+-- Error: tests/neg/namedTypeParams.scala:22:12 ------------------------------------------------------------------------
+22 |  f[X = Int][Y = String](1, "") // error: illegal repeated type application
+   |  ^^^^^^^^^^^^^^^^^^^^^^
+   |  illegal repeated type application
+   |  You might have meant something like:
+   |  Test.f[X = Int, Y = String]
+-- Error: tests/neg/namedTypeParams.scala:23:12 ------------------------------------------------------------------------
+23 |  f[X = Int][String](1, "") // error: illegal repeated type application
+   |  ^^^^^^^^^^^^^^^^^^
+   |  illegal repeated type application
+   |  You might have meant something like:
+   |  Test.f[X = Int, String]
+-- Error: tests/neg/namedTypeParams.scala:25:15 ------------------------------------------------------------------------
+25 |  f[Y = String][X = Int](1, "") // error: illegal repeated type application
+   |  ^^^^^^^^^^^^^^^^^^^^^^
+   |  illegal repeated type application
+   |  You might have meant something like:
+   |  Test.f[Y = String, X = Int]
+-- Error: tests/neg/namedTypeParams.scala:26:15 ------------------------------------------------------------------------
+26 |  f[Y = String][Int](1, "") // error: illegal repeated type application
+   |  ^^^^^^^^^^^^^^^^^^
+   |  illegal repeated type application
+   |  You might have meant something like:
+   |  Test.f[Y = String, Int]
+-- [E102] Syntax Error: tests/neg/namedTypeParams.scala:32:9 -----------------------------------------------------------
+32 |  f2[Y = String][X = Int](1, "") // error: Y is undefined
+   |         ^^^^^^
+   |         Type parameter Y is undefined. Expected one of X.
+-- [E102] Syntax Error: tests/neg/namedTypeParams.scala:33:9 -----------------------------------------------------------
+33 |  f2[Y = String](1, "") // error: Y is undefined
+   |         ^^^^^^
+   |         Type parameter Y is undefined. Expected one of X.
diff --git a/tests/neg/namedTypeParams.scala b/tests/neg/namedTypeParams.scala
index 1b85ee6349f4..489ac1e8cdb6 100644
--- a/tests/neg/namedTypeParams.scala
+++ b/tests/neg/namedTypeParams.scala
@@ -5,7 +5,7 @@ object Test0:
   def f[X, Y](x: X, y: Y): Int = ???
   f[X = Int, Y = Int](1, 2) // error: experimental // error: experimental
 
-object Test {
+object Test:
   import language.experimental.namedTypeArguments
 
   val x: C[T = Int] = // error:  ']' expected, but `=` found // error
@@ -25,8 +25,9 @@ object Test {
   f[Y = String][X = Int](1, "") // error: illegal repeated type application
   f[Y = String][Int](1, "") // error: illegal repeated type application
 
+object TestInterleaving:
+  import language.experimental.namedTypeArguments
   def f2[X](using DummyImplicit)[Y](x: X, y: Y): Int = ???
 
   f2[Y = String][X = Int](1, "") // error: Y is undefined
   f2[Y = String](1, "") // error: Y is undefined
-}
diff --git a/tests/neg/overrides.scala b/tests/neg/overrides.scala
index ee7a8b73ba0d..48dbd41ab839 100644
--- a/tests/neg/overrides.scala
+++ b/tests/neg/overrides.scala
@@ -53,7 +53,6 @@ class B extends A[Int] {
   override def b[T <: Int](x: Int)(y: String) = true // error
 
   override def next(): Int = ???    // error: incompatible type
-
 }
 
 class C extends A[String] {
@@ -115,4 +114,3 @@ class C extends A {
   override def m: Int = 42 // error: has incompatible type
 }
 }
-
diff --git a/tests/pos/interleaving-ba.scala b/tests/pos/interleaving-ba.scala
index dc2b36202891..4a7d721c804e 100644
--- a/tests/pos/interleaving-ba.scala
+++ b/tests/pos/interleaving-ba.scala
@@ -1,5 +1,4 @@
 
-
 object BA {
     given String = ""
     given Double = 0
@@ -8,4 +7,4 @@ object BA {
 
     def test = ba(0)[String]
 
-}
\ No newline at end of file
+}
diff --git a/tests/pos/interleaving-chainedParams.scala b/tests/pos/interleaving-chainedParams.scala
index 6ed970a69458..8613120f581a 100644
--- a/tests/pos/interleaving-chainedParams.scala
+++ b/tests/pos/interleaving-chainedParams.scala
@@ -1,18 +1,18 @@
 object chainedParams{
 
-    trait Chain{
-        type Tail <: Chain
-    }
+  trait Chain{
+      type Tail <: Chain
+  }
+  
+  def f[C1 <: Chain](c1: C1)[C2 <: c1.Tail](c2: C2)[C3 <: c2.Tail](c3: C3): c3.Tail = ???
 
-    def f[C1 <: Chain](c1: C1)[C2 <: c1.Tail](c2: C2)[C3 <: c2.Tail](c3: C3): c3.Tail = ???
+  val self = new Chain{ type Tail = this.type }
+  val res: self.type = f(self)(self)(self)
 
-    val self = new Chain{ type Tail = this.type }
-    val res: self.type = f(self)(self)(self)
+  type C <: Chain
 
-    type C <: Chain
-
-    val c3 = new Chain{ type Tail = C }
-    val c2 = new Chain{ type Tail = c3.type }
-    val c1 = new Chain{ type Tail = c2.type }
-    val u: C = f(c1)(c2)(c3)
+  val c3 = new Chain{ type Tail = C }
+  val c2 = new Chain{ type Tail = c3.type }
+  val c1 = new Chain{ type Tail = c2.type }
+  val u: C = f(c1)(c2)(c3)
 }
diff --git a/tests/pos/interleaving-functor.scala b/tests/pos/interleaving-functor.scala
index 00c26151f5cb..c3df1f869850 100644
--- a/tests/pos/interleaving-functor.scala
+++ b/tests/pos/interleaving-functor.scala
@@ -1,7 +1,7 @@
-object functorInterweaving:
+object functorInterleaving:
   //taken from https://dotty.epfl.ch/docs/reference/contextual/type-classes.html
   //at version 3.1.1-RC1-bin-20210930-01f040b-NIGHTLY
-  //modified to have type interveawing
+  //modified to have type interleaving
   trait Functor[F[_]]:
     def map[A](x: F[A])[B](f: A => B): F[B]
 
diff --git a/tests/pos/interleaving-nameCollision.scala b/tests/pos/interleaving-nameCollision.scala
deleted file mode 100644
index b66f63b9f92c..000000000000
--- a/tests/pos/interleaving-nameCollision.scala
+++ /dev/null
@@ -1,5 +0,0 @@
-import scala.annotation.targetName
-
-object nameCollision:
-    def f[T](x: T)[U](y: U) = (x,y)
-    @targetName("g") def f[T](x: T, y: T) = (x,y)
\ No newline at end of file
diff --git a/tests/pos/interleaving-overload.scala b/tests/pos/interleaving-overload.scala
index 02074fd82914..e1c3db1abe37 100644
--- a/tests/pos/interleaving-overload.scala
+++ b/tests/pos/interleaving-overload.scala
@@ -16,4 +16,4 @@ class A{
     f2[Any](1)
     f2[Any][Any](1)
 
-}
\ No newline at end of file
+}
diff --git a/tests/pos/interleaving-params.scala b/tests/pos/interleaving-params.scala
index dec9f6780370..e86f856a728d 100644
--- a/tests/pos/interleaving-params.scala
+++ b/tests/pos/interleaving-params.scala
@@ -3,4 +3,4 @@ class Params{
     def foo[T](x: T)[U >: x.type <: T](using U)[L <: List[U]](l: L): L = ???
     def aaa(x: U): U = ???
     def bbb[T <: U](x: U)[U]: U = ???
-}
\ No newline at end of file
+}
diff --git a/tests/pos/interleaving-signatureCollision.scala b/tests/pos/interleaving-signatureCollision.scala
new file mode 100644
index 000000000000..be016e7bdbfe
--- /dev/null
+++ b/tests/pos/interleaving-signatureCollision.scala
@@ -0,0 +1,5 @@
+import scala.annotation.targetName
+
+object signatureCollision:
+  def f[T](x: T)[U](y: U) = (x,y)
+  @targetName("g") def f[T](x: T, y: T) = (x,y)
diff --git a/tests/pos/interleaving-typeApply.scala b/tests/pos/interleaving-typeApply.scala
index 5b0be806bf33..ba9486408adb 100644
--- a/tests/pos/interleaving-typeApply.scala
+++ b/tests/pos/interleaving-typeApply.scala
@@ -19,4 +19,4 @@ object typeApply:
         f5[Int][String][Unit]
         f6[Int]()[Unit]
         f7[Int]()[Unit]
-    }
\ No newline at end of file
+    }
diff --git a/tests/pos/namedTypeParams.scala b/tests/pos/namedTypeParams.scala
index 86f35bf3c596..160bfc11f079 100644
--- a/tests/pos/namedTypeParams.scala
+++ b/tests/pos/namedTypeParams.scala
@@ -8,7 +8,6 @@ object Test {
   f[X = Int](1, "")
   f[Y = String](1, "")
 
-
   def f2[X](using DummyImplicit)[Y](x: X, y: Y): Int = ???
 
   f2[X = Int][Y = String](1, "")
diff --git a/tests/run/interleaving.scala b/tests/run/interleaving.scala
new file mode 100644
index 000000000000..e84f2896e5af
--- /dev/null
+++ b/tests/run/interleaving.scala
@@ -0,0 +1,101 @@
+object Test extends App {
+  trait Key { type Value }
+  trait DB {
+    def getOrElse(k: Key)[V >: k.Value](default: V): V // dependent type parameter
+  }
+
+  val key1 = new Key{ type Value = Some[Int] }
+  val key2 = new Key{ type Value = Some[Int] }
+  val key3 = new Key{ type Value = Some[String] }
+
+  val db1: DB = new DB{
+    def getOrElse(k: Key)[V >: k.Value](default: V): V = if k == key1 then Some(4).asInstanceOf[k.Value] else default
+  }
+
+  // Interleaved method with dependent type bound
+  val default1: None.type = None
+  assert(db1.getOrElse(key1)[Option[Int]](default1) == Some(4))
+  assert(db1.getOrElse(key2)[Option[Int]](default1) == default1)
+  assert(db1.getOrElse(key3)[Option[String]](default1) == default1)
+  assert(db1.getOrElse(key1)(default1) == Some(4))
+  assert(db1.getOrElse(key2)(default1) == default1)
+  assert(db1.getOrElse(key3)(default1) == default1)
+
+  val default2: Any = 3
+  assert(db1.getOrElse(key1)[Any](default2) == Some(4))
+  assert(db1.getOrElse(key2)[Any](default2) == default2)
+  assert(db1.getOrElse(key3)[Any](default2) == default2)
+  assert(db1.getOrElse(key1)(default2) == Some(4))
+  assert(db1.getOrElse(key2)(default2) == default2)
+  assert(db1.getOrElse(key3)(default2) == default2)
+
+  // Extension method and using parameter
+  extension (k: Key)
+    def lookupOrElse(using db: DB)[V >: k.Value](default: V): V = db.getOrElse(k)(default)
+
+  object Block1:
+    given DB = db1
+
+    assert(key1.lookupOrElse[Option[Int]](default1) == Some(4))
+    assert(key2.lookupOrElse[Option[Int]](default1) == default1)
+    assert(key3.lookupOrElse[Option[String]](default1) == default1)
+    assert(key1.lookupOrElse(default1) == Some(4))
+    assert(key2.lookupOrElse(default1) == default1)
+    assert(key3.lookupOrElse(default1) == default1)
+
+    assert(key1.lookupOrElse[Any](default2) == Some(4))
+    assert(key2.lookupOrElse[Any](default2) == default2)
+    assert(key3.lookupOrElse[Any](default2) == default2)
+    assert(key1.lookupOrElse(default2) == Some(4))
+    assert(key2.lookupOrElse(default2) == default2)
+    assert(key3.lookupOrElse(default2) == default2)
+  end Block1
+
+  // Right associative extension method
+  extension (db: DB)
+    def ?:(k: Key)[V >: k.Value](default: V): V = db.getOrElse(k)(default)
+
+  assert((db1 ?: (key1))[Option[Int]](default1) == Some(4))
+  assert((db1 ?: (key2))[Option[Int]](default1) == default1)
+  assert((db1 ?: (key3))[Option[String]](default1) == default1)
+  assert((db1 ?: (key1))(default1) == Some(4))
+  assert((db1 ?: (key2))(default1) == default1)
+  assert((db1 ?: (key3))(default1) == default1)
+
+  assert((db1 ?: (key1))[Any](default2) == Some(4))
+  assert((db1 ?: (key2))[Any](default2) == default2)
+  assert((db1 ?: (key3))[Any](default2) == default2)
+  assert((db1 ?: (key1))(default2) == Some(4))
+  assert((db1 ?: (key2))(default2) == default2)
+  assert((db1 ?: (key3))(default2) == default2)
+
+
+  assert(key1.?:(db1)[Option[Int]](default1) == Some(4))
+  assert(key2.?:(db1)[Option[Int]](default1) == default1)
+  assert(key3.?:(db1)[Option[String]](default1) == default1)
+  assert(key1.?:(db1)(default1) == Some(4))
+  assert(key2.?:(db1)(default1) == default1)
+  assert(key3.?:(db1)(default1) == default1)
+
+  assert(key1.?:(db1)[Any](default2) == Some(4))
+  assert(key2.?:(db1)[Any](default2) == default2)
+  assert(key3.?:(db1)[Any](default2) == default2)
+  assert(key1.?:(db1)(default2) == Some(4))
+  assert(key2.?:(db1)(default2) == default2)
+  assert(key3.?:(db1)(default2) == default2)
+
+
+  assert(?:(key1)(db1)[Option[Int]](default1) == Some(4))
+  assert(?:(key2)(db1)[Option[Int]](default1) == default1)
+  assert(?:(key3)(db1)[Option[String]](default1) == default1)
+  assert(?:(key1)(db1)(default1) == Some(4))
+  assert(?:(key2)(db1)(default1) == default1)
+  assert(?:(key3)(db1)(default1) == default1)
+
+  assert(?:(key1)(db1)[Any](default2) == Some(4))
+  assert(?:(key2)(db1)[Any](default2) == default2)
+  assert(?:(key3)(db1)[Any](default2) == default2)
+  assert(?:(key1)(db1)(default2) == Some(4))
+  assert(?:(key2)(db1)(default2) == default2)
+  assert(?:(key3)(db1)(default2) == default2)
+}

From 35ed4295b2bcf3afca6e7f7bc4163aac6a44f742 Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Thu, 2 Feb 2023 15:35:57 +0100
Subject: [PATCH 087/657] Fix right-associative-extension-methods.md

---
 .../right-associative-extension-methods.md    | 40 +++++++++++--------
 1 file changed, 24 insertions(+), 16 deletions(-)

diff --git a/docs/_docs/reference/contextual/right-associative-extension-methods.md b/docs/_docs/reference/contextual/right-associative-extension-methods.md
index 068123df8cd2..9d711c42ad3d 100644
--- a/docs/_docs/reference/contextual/right-associative-extension-methods.md
+++ b/docs/_docs/reference/contextual/right-associative-extension-methods.md
@@ -4,46 +4,54 @@ title: "Right-Associative Extension Methods: Details"
 nightlyOf: https://docs.scala-lang.org/scala3/reference/contextual/right-associative-extension-methods.html
 ---
 
-The most general form of leading parameters of an extension method is as follows:
-
+The most general signature an extension method can have is as follows:
+  - An optional type clause `leadingTyParamss`
   - A possibly empty list of using clauses `leadingUsing`
-  - A single parameter `extensionParam`
+  - A single parameter `leftParamss`
   - A possibly empty list of using clauses `trailingUsing`
+  - A name (preceded by the `def` keyword)
+  - An optional type clause `rightTyParamss`
+  - An optional explicit term clause `rightParamss`
+  - Any number of any clauses `rest`
 
-This is then followed by `def`, the method name, and possibly further parameters
-`otherParams`. An example is:
+For example:
 
 ```scala
-  extension (using a: A, b: B)(using c: C)    // <-- leadingUsing
-            (x: X)                            // <-- extensionParam
+  extension [T]                               // <-- leadingTyParamss
+            (using a: A, b: B)(using c: C)    // <-- leadingUsing
+            (x: X)                            // <-- leftParamss
             (using d: D)                      // <-- trailingUsing
-    def +:: (y: Y)(using e: E)(z: Z)          // <-- otherParams
+    def +:: [U]                               // <-- rightTyParamss
+            (y: Y)                            // <-- rightParamss
+            [V](using e: E)[W](z: Z)          // <-- rest
 ```
 
+
 An extension method is treated as a right-associative operator
 (as in [SLS §6.12.3](https://www.scala-lang.org/files/archive/spec/2.13/06-expressions.html#infix-operations))
-if it has a name ending in `:` and is immediately followed by a
-single parameter. In the example above, that parameter is `(y: Y)`.
+if it has a name ending in `:`, and is immediately followed by a
+single explicit term parameter (in other words, `rightParamss` is present). In the example above, that parameter is `(y: Y)`.
 
 The Scala compiler pre-processes a right-associative infix operation such as `x +: xs`
 to `xs.+:(x)` if `x` is a pure expression or a call-by-name parameter and to `val y = x; xs.+:(y)` otherwise. This is necessary since a regular right-associative infix method
 is defined in the class of its right operand. To make up for this swap,
-the expansion of right-associative extension methods performs an analogous parameter swap. More precisely, if `otherParams` consists of a single parameter
-`rightParam` followed by `remaining`, the total parameter sequence
+the expansion of right-associative extension methods performs the inverse parameter swap. More precisely, if `rightParamss` is present, the total parameter sequence
 of the extension method's expansion is:
 
 ```
-    leadingUsing  rightParam  trailingUsing  extensionParam  remaining
+    leadingTyParamss  leadingUsing  rightTyParamss  rightParamss  leftParamss  trailingUsing  rest
 ```
 
 For instance, the `+::` method above would become
 
 ```scala
-  <extension> def +:: (using a: A, b: B)(using c: C)
+  <extension> def +:: [T]
+                      (using a: A, b: B)(using c: C)
+                      [U]
                       (y: Y)
-                      (using d: D)
                       (x: X)
-                      (using e: E)(z: Z)
+                      (using d: D)
+                      [V](using e: E)[W](z: Z)
 ```
 
 This expansion has to be kept in mind when writing right-associative extension

From 4ffe1dad952b7615f00e7457e4e1f0b87e035159 Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Thu, 2 Feb 2023 16:18:16 +0100
Subject: [PATCH 088/657] Uniformise naming of clauses in right associative
 extension methods

---
 .../src/dotty/tools/dotc/ast/Desugar.scala    | 12 ++++----
 .../tools/dotc/printing/RefinedPrinter.scala  | 29 ++++++++++---------
 .../right-associative-extension-methods.md    | 26 ++++++++++-------
 .../scaladoc/tasty/ClassLikeSupport.scala     | 15 +++++-----
 4 files changed, 45 insertions(+), 37 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index 5326361ada98..2cfd292fd6dd 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -915,16 +915,16 @@ object desugar {
       name = normalizeName(mdef, mdef.tpt).asTermName,
       paramss =
         if mdef.name.isRightAssocOperatorName then
-          val (typaramss, paramss) = mdef.paramss.span(isTypeParamClause) // first extract type parameters
+          val (rightTyParams, paramss) = mdef.paramss.span(isTypeParamClause) // first extract type parameters
 
           paramss match
-            case params :: paramss1 => // `params` must have a single parameter and without `given` flag
+            case rightParam :: paramss1 => // `rightParam` 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
+              rightParam match
                 case ValDefs(vparam :: Nil) =>
                   if !vparam.mods.is(Given) then
                     // we merge the extension parameters with the method parameters,
@@ -934,8 +934,10 @@ object desugar {
                     //     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
+                    //
+                    // If you change the names of the clauses below, also change them in right-associative-extension-methods.md
+                    val (leftTyParamsAndLeadingUsing, leftParamAndTrailingUsing) = extParamss.span(isUsingOrTypeParamClause)
+                    leftTyParamsAndLeadingUsing ::: rightTyParams ::: rightParam :: leftParamAndTrailingUsing ::: paramss1
                   else
                     badRightAssoc("cannot start with using clause")
                 case _ =>
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index f94ff68d0698..6f258fdddbe9 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -896,30 +896,31 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           if isExtension then
             val paramss =
               if tree.name.isRightAssocOperatorName then
+                // If you change the names of the clauses below, also change them in right-associative-extension-methods.md
                 // we have the following encoding of tree.paramss:
-                //   (leadingTyParamss ++ leadingUsing
-                //      ++ rightTyParamss ++ rightParamss
-                //      ++ leftParamss ++ trailingUsing ++ rest)
+                //   (leftTyParams ++ leadingUsing
+                //      ++ rightTyParams ++ rightParam
+                //      ++ leftParam ++ 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]`)
+                //   - leftTyParams = List(`[A]`)
                 //   - leadingUsing = List(`(using B)`)
-                //   - rightTyParamss = List(`[E]`)
-                //   - rightParamss = List(`(f: F)`)
-                //   - leftParamss = List(`(c: C)`)
+                //   - rightTyParams = List(`[E]`)
+                //   - rightParam = List(`(f: F)`)
+                //   - leftParam = 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)
+                // we need to swap (rightTyParams ++ rightParam) with (leftParam ++ trailingUsing)
+                val (leftTyParams, 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 (rightTyParams, rest3) = rest2.span(isTypeParamClause)
+                val (rightParam, rest4) = rest3.splitAt(1)
+                val (leftParam, rest5) = rest4.splitAt(1)
                 val (trailingUsing, rest6) = rest5.span(isUsingClause)
-                if leftParamss.nonEmpty then
-                  leadingTyParamss ::: leadingUsing ::: leftParamss ::: trailingUsing ::: rightTyParamss ::: rightParamss ::: rest6
+                if leftParam.nonEmpty then
+                  leftTyParams ::: leadingUsing ::: leftParam ::: trailingUsing ::: rightTyParams ::: rightParam ::: rest6
                 else
                   tree.paramss // it wasn't a binary operator, after all.
               else
diff --git a/docs/_docs/reference/contextual/right-associative-extension-methods.md b/docs/_docs/reference/contextual/right-associative-extension-methods.md
index 9d711c42ad3d..1b878ca2db22 100644
--- a/docs/_docs/reference/contextual/right-associative-extension-methods.md
+++ b/docs/_docs/reference/contextual/right-associative-extension-methods.md
@@ -4,25 +4,27 @@ title: "Right-Associative Extension Methods: Details"
 nightlyOf: https://docs.scala-lang.org/scala3/reference/contextual/right-associative-extension-methods.html
 ---
 
+<!-- In case the names of the clauses are modified, also modify them in ClassLikeSupport, Desugar, and RefinedPrinter -->
+
 The most general signature an extension method can have is as follows:
-  - An optional type clause `leadingTyParamss`
+  - An optional type clause `leftTyParams`
   - A possibly empty list of using clauses `leadingUsing`
-  - A single parameter `leftParamss`
+  - A single parameter `leftParam` (in an explicit term clause)
   - A possibly empty list of using clauses `trailingUsing`
   - A name (preceded by the `def` keyword)
-  - An optional type clause `rightTyParamss`
-  - An optional explicit term clause `rightParamss`
+  - An optional type clause `rightTyParams`
+  - An optional single parameter `rightParam` (in an explicit term clause)
   - Any number of any clauses `rest`
 
 For example:
 
 ```scala
-  extension [T]                               // <-- leadingTyParamss
+  extension [T]                               // <-- leftTyParams
             (using a: A, b: B)(using c: C)    // <-- leadingUsing
-            (x: X)                            // <-- leftParamss
+            (x: X)                            // <-- leftParam
             (using d: D)                      // <-- trailingUsing
-    def +:: [U]                               // <-- rightTyParamss
-            (y: Y)                            // <-- rightParamss
+    def +:: [U]                               // <-- rightTyParams
+            (y: Y)                            // <-- rightParam
             [V](using e: E)[W](z: Z)          // <-- rest
 ```
 
@@ -30,18 +32,20 @@ For example:
 An extension method is treated as a right-associative operator
 (as in [SLS §6.12.3](https://www.scala-lang.org/files/archive/spec/2.13/06-expressions.html#infix-operations))
 if it has a name ending in `:`, and is immediately followed by a
-single explicit term parameter (in other words, `rightParamss` is present). In the example above, that parameter is `(y: Y)`.
+single explicit term parameter (in other words, `rightParam` is present). In the example above, that parameter is `(y: Y)`.
 
 The Scala compiler pre-processes a right-associative infix operation such as `x +: xs`
 to `xs.+:(x)` if `x` is a pure expression or a call-by-name parameter and to `val y = x; xs.+:(y)` otherwise. This is necessary since a regular right-associative infix method
 is defined in the class of its right operand. To make up for this swap,
-the expansion of right-associative extension methods performs the inverse parameter swap. More precisely, if `rightParamss` is present, the total parameter sequence
+the expansion of right-associative extension methods performs the inverse parameter swap. More precisely, if `rightParam` is present, the total parameter sequence
 of the extension method's expansion is:
 
 ```
-    leadingTyParamss  leadingUsing  rightTyParamss  rightParamss  leftParamss  trailingUsing  rest
+    leftTyParams  leadingUsing  rightTyParams  rightParam  leftParam  trailingUsing  rest
 ```
 
+In other words, we swap `leftParams  trailingUsing` with `rightTyParam  rightParam`.
+
 For instance, the `+::` method above would become
 
 ```scala
diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala
index c7178acac312..0c85dff0879f 100644
--- a/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala
@@ -350,16 +350,17 @@ trait ClassLikeSupport:
     val unshuffledMemberInfoParamLists = 
       if methodSymbol.isExtensionMethod && methodSymbol.isRightAssoc then
         // Taken from RefinedPrinter.scala
-        val (leadingTyParamss, rest1) = memberInfo.paramLists.span(_.isType)
+        // If you change the names of the clauses below, also change them in right-associative-extension-methods.md
+        val (leftTyParams, rest1) = memberInfo.paramLists.span(_.isType)
         val (leadingUsing, rest2) = rest1.span(_.isUsing)
-        val (rightTyParamss, rest3) = rest2.span(_.isType)
-        val (rightParamss, rest4) = rest3.splitAt(1)
-        val (leftParamss, rest5) = rest4.splitAt(1)
+        val (rightTyParams, rest3) = rest2.span(_.isType)
+        val (rightParam, rest4) = rest3.splitAt(1)
+        val (leftParam, rest5) = rest4.splitAt(1)
         val (trailingUsing, rest6) = rest5.span(_.isUsing)
-        if leftParamss.nonEmpty then
-          // leadingTyParamss ::: leadingUsing ::: leftParamss ::: trailingUsing ::: rightTyParamss ::: rightParamss ::: rest6
+        if leftParam.nonEmpty then
+          // leftTyParams ::: leadingUsing ::: leftParam ::: trailingUsing ::: rightTyParams ::: rightParam ::: rest6
           // because of takeRight after, this is equivalent to the following:
-          rightTyParamss ::: rightParamss ::: rest6
+          rightTyParams ::: rightParam ::: rest6
         else
           memberInfo.paramLists // it wasn't a binary operator, after all.
       else 

From 6ace5b816a1845993b0f002067e65d98882667ee Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Thu, 25 Aug 2022 15:04:36 +0200
Subject: [PATCH 089/657] Make clause interleaving experimental

---
 compiler/src/dotty/tools/dotc/config/Feature.scala   |  3 +++
 compiler/src/dotty/tools/dotc/parsing/Parsers.scala  | 12 +++++++++++-
 .../right-associative-extension-methods.md           |  4 ++--
 .../generalized-method-syntax.md                     |  8 +++++++-
 docs/_docs/reference/syntax.md                       |  6 +-----
 .../src/scala/runtime/stdLibPatches/language.scala   |  8 ++++++++
 project/MiMaFilters.scala                            | 11 ++++++++---
 7 files changed, 40 insertions(+), 12 deletions(-)
 rename docs/_docs/reference/{other-new-features => experimental}/generalized-method-syntax.md (92%)

diff --git a/compiler/src/dotty/tools/dotc/config/Feature.scala b/compiler/src/dotty/tools/dotc/config/Feature.scala
index 188526bb094f..419ed5868cbf 100644
--- a/compiler/src/dotty/tools/dotc/config/Feature.scala
+++ b/compiler/src/dotty/tools/dotc/config/Feature.scala
@@ -28,6 +28,7 @@ object Feature:
   val symbolLiterals = deprecated("symbolLiterals")
   val fewerBraces = experimental("fewerBraces")
   val saferExceptions = experimental("saferExceptions")
+  val clauseInterleaving = experimental("clauseInterleaving")
   val pureFunctions = experimental("pureFunctions")
   val captureChecking = experimental("captureChecking")
   val into = experimental("into")
@@ -76,6 +77,8 @@ object Feature:
 
   def namedTypeArgsEnabled(using Context) = enabled(namedTypeArguments)
 
+  def clauseInterleavingEnabled(using Context) = enabled(clauseInterleaving)
+
   def genericNumberLiteralsEnabled(using Context) = enabled(genericNumberLiterals)
 
   def scala2ExperimentalMacroEnabled(using Context) = enabled(scala2macros)
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index bac5d4e94d99..af4d0220162b 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -3627,8 +3627,18 @@ object Parsers {
         val mods1 = addFlag(mods, Method)
         val ident = termIdent()
         var name = ident.name.asTermName
-        val paramss = typeOrTermParamClauses(ParamOwner.Def, numLeadParams = numLeadParams)
+        val paramss = 
+          if in.featureEnabled(Feature.clauseInterleaving) then 
+            // If you are making interleaving stable manually, please refer to the PR introducing it instead, section "How to make non-experimental"
+            typeOrTermParamClauses(ParamOwner.Def, numLeadParams = numLeadParams)
+          else
+            val tparams = typeParamClauseOpt(ParamOwner.Def)
+            val vparamss = termParamClauses(numLeadParams = numLeadParams)
+
+            joinParams(tparams, vparamss)
+
         var tpt = fromWithinReturnType { typedOpt() }
+        
         if (migrateTo3) newLineOptWhenFollowedBy(LBRACE)
         val rhs =
           if in.token == EQUALS then
diff --git a/docs/_docs/reference/contextual/right-associative-extension-methods.md b/docs/_docs/reference/contextual/right-associative-extension-methods.md
index 1b878ca2db22..61f0beece6ed 100644
--- a/docs/_docs/reference/contextual/right-associative-extension-methods.md
+++ b/docs/_docs/reference/contextual/right-associative-extension-methods.md
@@ -25,7 +25,7 @@ For example:
             (using d: D)                      // <-- trailingUsing
     def +:: [U]                               // <-- rightTyParams
             (y: Y)                            // <-- rightParam
-            [V](using e: E)[W](z: Z)          // <-- rest
+            (using e: E)(z: Z)                // <-- rest
 ```
 
 
@@ -55,7 +55,7 @@ For instance, the `+::` method above would become
                       (y: Y)
                       (x: X)
                       (using d: D)
-                      [V](using e: E)[W](z: Z)
+                      (using e: E)(z: Z)
 ```
 
 This expansion has to be kept in mind when writing right-associative extension
diff --git a/docs/_docs/reference/other-new-features/generalized-method-syntax.md b/docs/_docs/reference/experimental/generalized-method-syntax.md
similarity index 92%
rename from docs/_docs/reference/other-new-features/generalized-method-syntax.md
rename to docs/_docs/reference/experimental/generalized-method-syntax.md
index c78a5df8a3f4..072052c1ae10 100644
--- a/docs/_docs/reference/other-new-features/generalized-method-syntax.md
+++ b/docs/_docs/reference/experimental/generalized-method-syntax.md
@@ -1,9 +1,15 @@
 ---
 layout: doc-page
 title: "Generalized Method Syntax"
-movedTo: https://docs.scala-lang.org/scala3/reference/other-new-features/generalized-method-syntax.html
+nightlyOf: https://docs.scala-lang.org/scala3/reference/experimental/generalized-method-syntax.html
 ---
 
+This feature is not yet part of the Scala 3 language definition. It can be made available by a language import:
+
+```scala
+import scala.language.experimental.clauseInterleaving
+```
+
 The inclusion of using clauses is not the only way in which methods have been updated, type parameter clauses are now allowed in any number and at any position.
 
 ## Syntax Changes
diff --git a/docs/_docs/reference/syntax.md b/docs/_docs/reference/syntax.md
index dde70d2131ad..8da41c7e6d0c 100644
--- a/docs/_docs/reference/syntax.md
+++ b/docs/_docs/reference/syntax.md
@@ -350,10 +350,6 @@ ClsParamClause    ::=  [nl] ‘(’ ClsParams ‘)’
 ClsParams         ::=  ClsParam {‘,’ ClsParam}
 ClsParam          ::=  {Annotation} [{Modifier} (‘val’ | ‘var’) | ‘inline’] Param
 
-DefParamClauses   ::=  DefParamClause { DefParamClause } -- and two DefTypeParamClause cannot be adjacent
-DefParamClause    ::=  DefTypeParamClause 
-                    |  DefTermParamClause 
-                    |  UsingParamClause
 TypelessClauses   ::=  TypelessClause {TypelessClause}
 TypelessClause    ::=  DefTermParamClause
                     |  UsingParamClause
@@ -417,7 +413,7 @@ Dcl               ::=  RefineDcl
 ValDcl            ::=  ids ‘:’ Type
 VarDcl            ::=  ids ‘:’ Type
 DefDcl            ::=  DefSig ‘:’ Type
-DefSig            ::=  id [DefParamClauses] [DefImplicitClause]
+DefSig            ::=  id [DefTypeParamClause] [TypelessClauses] [DefImplicitClause]
 TypeDcl           ::=  id [TypeParamClause] {FunParamClause} TypeBounds
 
 Def               ::=  ‘val’ PatDef
diff --git a/library/src/scala/runtime/stdLibPatches/language.scala b/library/src/scala/runtime/stdLibPatches/language.scala
index 401926dbab4d..d92495c6f5aa 100644
--- a/library/src/scala/runtime/stdLibPatches/language.scala
+++ b/library/src/scala/runtime/stdLibPatches/language.scala
@@ -61,6 +61,14 @@ object language:
     @compileTimeOnly("`saferExceptions` can only be used at compile time in import statements")
     object saferExceptions
 
+    /** Adds support for clause interleaving:
+      * Methods can now have as many type clauses as they like, this allows to have type bounds depend on terms: `def f(x: Int)[A <: x.type]: A`
+      *
+      * @see [[http://dotty.epfl.ch/docs/reference/other-new-features/explicit-nulls.html]]
+      */
+    @compileTimeOnly("`clauseInterleaving` can only be used at compile time in import statements")
+    object clauseInterleaving
+
     /** Experimental support for pure function type syntax
      *
      *  @see [[https://dotty.epfl.ch/docs/reference/experimental/purefuns]]
diff --git a/project/MiMaFilters.scala b/project/MiMaFilters.scala
index 63ce926355bb..0937777595ca 100644
--- a/project/MiMaFilters.scala
+++ b/project/MiMaFilters.scala
@@ -12,12 +12,17 @@ object MiMaFilters {
     ProblemFilters.exclude[MissingFieldProblem]("scala.runtime.stdLibPatches.language.3.3"),
     ProblemFilters.exclude[MissingClassProblem]("scala.runtime.stdLibPatches.language$3$u002E3$"),
     ProblemFilters.exclude[MissingClassProblem]("scala.runtime.stdLibPatches.language$3$u002E3$minusmigration$"),
-    ProblemFilters.exclude[MissingFieldProblem]("scala.runtime.stdLibPatches.language#experimental.into"),
-    ProblemFilters.exclude[MissingClassProblem]("scala.runtime.stdLibPatches.language$experimental$into$"),
     ProblemFilters.exclude[MissingClassProblem]("scala.util.boundary"),
     ProblemFilters.exclude[MissingClassProblem]("scala.util.boundary$"),
     ProblemFilters.exclude[MissingClassProblem]("scala.util.boundary$Break"),
-    ProblemFilters.exclude[MissingClassProblem]("scala.util.boundary$Label")
+    ProblemFilters.exclude[MissingClassProblem]("scala.util.boundary$Label"),
+
+    //  New experimental features in 3.3.X
+    ProblemFilters.exclude[MissingFieldProblem]("scala.runtime.stdLibPatches.language#experimental.clauseInterleaving"),
+    ProblemFilters.exclude[MissingClassProblem]("scala.runtime.stdLibPatches.language$experimental$clauseInterleaving$"),
+    ProblemFilters.exclude[MissingFieldProblem]("scala.runtime.stdLibPatches.language#experimental.into"),
+    ProblemFilters.exclude[MissingClassProblem]("scala.runtime.stdLibPatches.language$experimental$into$"),
+    // end of New experimental features in 3.3.X
   )
   val TastyCore: Seq[ProblemFilter] = Seq(
     ProblemFilters.exclude[DirectMissingMethodProblem]("dotty.tools.tasty.TastyBuffer.reset"),

From 1e402f3e44310dab4699fcbacbf6afc1eefb261c Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Thu, 25 Aug 2022 15:05:32 +0200
Subject: [PATCH 090/657] Add import to tests

---
 .../src/tests/extensionParams.scala           |  5 +++
 .../src/tests/methodsAndConstructors.scala    |  3 ++
 tests/neg/interleaving-ab.scala               |  2 ++
 tests/neg/interleaving-params.scala           |  2 ++
 .../neg/interleaving-signatureCollision.scala |  2 ++
 tests/neg/interleaving-typeApply.check        | 36 +++++++++----------
 tests/neg/interleaving-typeApply.scala        |  2 ++
 tests/neg/interleaving-unmatched.scala        |  2 ++
 tests/neg/namedTypeParams.check               |  8 ++---
 tests/neg/namedTypeParams.scala               |  1 +
 tests/neg/overrides.scala                     | 14 +++++---
 tests/pos/interleaving-ba.scala               |  1 +
 tests/pos/interleaving-chainedParams.scala    |  2 ++
 tests/pos/interleaving-classless.scala        |  2 ++
 tests/pos/interleaving-functor.scala          |  2 ++
 tests/pos/interleaving-newline.scala          |  2 ++
 tests/pos/interleaving-overload.scala         |  1 +
 tests/pos/interleaving-params.scala           |  2 ++
 .../pos/interleaving-signatureCollision.scala |  1 +
 tests/pos/interleaving-typeApply.scala        |  3 ++
 tests/pos/namedTypeParams.scala               |  4 +++
 tests/pos/overrides.scala                     |  7 +++-
 tests/run/interleaving.scala                  |  1 +
 23 files changed, 78 insertions(+), 27 deletions(-)

diff --git a/scaladoc-testcases/src/tests/extensionParams.scala b/scaladoc-testcases/src/tests/extensionParams.scala
index e064ff6d56d7..9276bf41f067 100644
--- a/scaladoc-testcases/src/tests/extensionParams.scala
+++ b/scaladoc-testcases/src/tests/extensionParams.scala
@@ -52,7 +52,12 @@ extension [A <: List[Char]](using String)(using Unit)(a: A)(using Int)(using Num
 extension (using String)(using Unit)(a: Animal)(using Int)(using Number)
   def f11(b: Any)(c: Any): Any
   = ???
+
+import scala.language.experimental.clauseInterleaving
+
+extension (using String)(using Unit)(a: Animal)(using Int)(using Number)
   def f13(b: Any)[T](c: T): T
   = ???
   def f14[D](b: D)[T](c: T): T
   = ???
+
diff --git a/scaladoc-testcases/src/tests/methodsAndConstructors.scala b/scaladoc-testcases/src/tests/methodsAndConstructors.scala
index 5fc6af38888b..132d35035b30 100644
--- a/scaladoc-testcases/src/tests/methodsAndConstructors.scala
+++ b/scaladoc-testcases/src/tests/methodsAndConstructors.scala
@@ -60,5 +60,8 @@ class Methods:
  def withImplicitParam2(v: String)(implicit ab: Double, a: Int, b: String): String
  = ???
 
+ import scala.language.experimental.clauseInterleaving
+
  def clauseInterleaving[T](x: T)[U](y: U)(using (T, U)): (T, U)
  = ???
+
diff --git a/tests/neg/interleaving-ab.scala b/tests/neg/interleaving-ab.scala
index 5516d9b9dd51..e446626a2982 100644
--- a/tests/neg/interleaving-ab.scala
+++ b/tests/neg/interleaving-ab.scala
@@ -1,3 +1,5 @@
+import scala.language.experimental.clauseInterleaving
+
 object Ab:
   given String = ""
   given Double = 0
diff --git a/tests/neg/interleaving-params.scala b/tests/neg/interleaving-params.scala
index 97de1e6e2948..dc6762cf0214 100644
--- a/tests/neg/interleaving-params.scala
+++ b/tests/neg/interleaving-params.scala
@@ -1,3 +1,5 @@
+import scala.language.experimental.clauseInterleaving
+
 class Params{
     def bar[T](x: T)[T]: String = ??? // error
     def zoo(x: Int)[T, U](x: U): T = ??? // error
diff --git a/tests/neg/interleaving-signatureCollision.scala b/tests/neg/interleaving-signatureCollision.scala
index d2df384dc1e7..a6a729ed3b62 100644
--- a/tests/neg/interleaving-signatureCollision.scala
+++ b/tests/neg/interleaving-signatureCollision.scala
@@ -1,3 +1,5 @@
+import scala.language.experimental.clauseInterleaving
+
 object signatureCollision:
     def f[T](x: T)[U](y: U) = (x,y)
     def f[T](x: T, y: T) = (x,y) // error
diff --git a/tests/neg/interleaving-typeApply.check b/tests/neg/interleaving-typeApply.check
index c932a899dfe6..a50c1455bfbb 100644
--- a/tests/neg/interleaving-typeApply.check
+++ b/tests/neg/interleaving-typeApply.check
@@ -1,29 +1,29 @@
--- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:8:11 ---------------------------------------------
-8 |        f3[String]() // error
-  |           ^
-  |           Type argument String does not conform to upper bound Int
-  |
-  | longer explanation available when compiling with `-explain`
--- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:9:16 ---------------------------------------------
-9 |        f5[Int][Unit] // error
-  |                ^
-  |                Type argument Unit does not conform to upper bound String
-  |
-  | longer explanation available when compiling with `-explain`
--- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:10:19 --------------------------------------------
-10 |        f5[String][Unit] // error // error
+-- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:10:11 --------------------------------------------
+10 |        f3[String]() // error
+   |           ^
+   |           Type argument String does not conform to upper bound Int
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:11:16 --------------------------------------------
+11 |        f5[Int][Unit] // error
+   |                ^
+   |                Type argument Unit does not conform to upper bound String
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:12:19 --------------------------------------------
+12 |        f5[String][Unit] // error // error
    |                   ^
    |                   Type argument Unit does not conform to upper bound String
    |
    | longer explanation available when compiling with `-explain`
--- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:10:11 --------------------------------------------
-10 |        f5[String][Unit] // error // error
+-- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:12:11 --------------------------------------------
+12 |        f5[String][Unit] // error // error
    |           ^
    |           Type argument String does not conform to upper bound Int
    |
    | longer explanation available when compiling with `-explain`
--- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:11:11 --------------------------------------------
-11 |        f7[String]()[Unit] // error
+-- [E057] Type Mismatch Error: tests/neg/interleaving-typeApply.scala:13:11 --------------------------------------------
+13 |        f7[String]()[Unit] // error
    |           ^
    |           Type argument String does not conform to upper bound Int
    |
diff --git a/tests/neg/interleaving-typeApply.scala b/tests/neg/interleaving-typeApply.scala
index 18a21b4984e1..ad21fe2f0329 100644
--- a/tests/neg/interleaving-typeApply.scala
+++ b/tests/neg/interleaving-typeApply.scala
@@ -1,3 +1,5 @@
+import scala.language.experimental.clauseInterleaving
+
 object typeApply:
     
     def f3[T <: Int](using DummyImplicit)[U <: String](): T => T = ???
diff --git a/tests/neg/interleaving-unmatched.scala b/tests/neg/interleaving-unmatched.scala
index c433c0a7210a..2ce3074d07fa 100644
--- a/tests/neg/interleaving-unmatched.scala
+++ b/tests/neg/interleaving-unmatched.scala
@@ -1,3 +1,5 @@
+import scala.language.experimental.clauseInterleaving
+
 object unmatched:
     def f1[T (x: T)] = ??? // error
     def f2(x: Any[)T] = ??? // error // error
diff --git a/tests/neg/namedTypeParams.check b/tests/neg/namedTypeParams.check
index 1252f29c4e9e..3f6f9f7913e8 100644
--- a/tests/neg/namedTypeParams.check
+++ b/tests/neg/namedTypeParams.check
@@ -92,11 +92,11 @@
    |  illegal repeated type application
    |  You might have meant something like:
    |  Test.f[Y = String, Int]
--- [E102] Syntax Error: tests/neg/namedTypeParams.scala:32:9 -----------------------------------------------------------
-32 |  f2[Y = String][X = Int](1, "") // error: Y is undefined
+-- [E102] Syntax Error: tests/neg/namedTypeParams.scala:33:9 -----------------------------------------------------------
+33 |  f2[Y = String][X = Int](1, "") // error: Y is undefined
    |         ^^^^^^
    |         Type parameter Y is undefined. Expected one of X.
--- [E102] Syntax Error: tests/neg/namedTypeParams.scala:33:9 -----------------------------------------------------------
-33 |  f2[Y = String](1, "") // error: Y is undefined
+-- [E102] Syntax Error: tests/neg/namedTypeParams.scala:34:9 -----------------------------------------------------------
+34 |  f2[Y = String](1, "") // error: Y is undefined
    |         ^^^^^^
    |         Type parameter Y is undefined. Expected one of X.
diff --git a/tests/neg/namedTypeParams.scala b/tests/neg/namedTypeParams.scala
index 489ac1e8cdb6..53ef14188e12 100644
--- a/tests/neg/namedTypeParams.scala
+++ b/tests/neg/namedTypeParams.scala
@@ -27,6 +27,7 @@ object Test:
 
 object TestInterleaving:
   import language.experimental.namedTypeArguments
+  import language.experimental.clauseInterleaving
   def f2[X](using DummyImplicit)[Y](x: X, y: Y): Int = ???
 
   f2[Y = String][X = Int](1, "") // error: Y is undefined
diff --git a/tests/neg/overrides.scala b/tests/neg/overrides.scala
index 48dbd41ab839..c8fc8de97f7c 100644
--- a/tests/neg/overrides.scala
+++ b/tests/neg/overrides.scala
@@ -39,10 +39,12 @@ package p2 { // all being in the same package compiles fine
 class A[T] {
 
   def f(x: T)(y: T = x) = y
-  def b[U <: T](x: Int)[V >: T](y: String) = false
 
   def next: T = ???
 
+  import scala.language.experimental.clauseInterleaving
+
+  def b[U <: T](x: Int)[V >: T](y: String) = false
 }
 
 class B extends A[Int] {
@@ -50,19 +52,23 @@ class B extends A[Int] {
   def f(x: Int)(y: Int) = y // error: needs `override' modifier
 
   f(2)()
-  override def b[T <: Int](x: Int)(y: String) = true // error
 
   override def next(): Int = ???    // error: incompatible type
+
+  import scala.language.experimental.clauseInterleaving
+
+  override def b[T <: Int](x: Int)(y: String) = true // error
 }
 
 class C extends A[String] {
 
   override def f(x: String) = x // error
 
-  override def b[T <: String](x: Int)[U >: Int](y: String) = true // error: incompatible type
-
   override def next: Int = ???    // error: incompatible type
 
+  import scala.language.experimental.clauseInterleaving
+
+  override def b[T <: String](x: Int)[U >: Int](y: String) = true // error: incompatible type
 }
 
 class X {
diff --git a/tests/pos/interleaving-ba.scala b/tests/pos/interleaving-ba.scala
index 4a7d721c804e..69fe2d9537a0 100644
--- a/tests/pos/interleaving-ba.scala
+++ b/tests/pos/interleaving-ba.scala
@@ -1,3 +1,4 @@
+import scala.language.experimental.clauseInterleaving
 
 object BA {
     given String = ""
diff --git a/tests/pos/interleaving-chainedParams.scala b/tests/pos/interleaving-chainedParams.scala
index 8613120f581a..e502888d97c8 100644
--- a/tests/pos/interleaving-chainedParams.scala
+++ b/tests/pos/interleaving-chainedParams.scala
@@ -1,3 +1,5 @@
+import scala.language.experimental.clauseInterleaving
+
 object chainedParams{
 
   trait Chain{
diff --git a/tests/pos/interleaving-classless.scala b/tests/pos/interleaving-classless.scala
index 924202673029..5aec92db3409 100644
--- a/tests/pos/interleaving-classless.scala
+++ b/tests/pos/interleaving-classless.scala
@@ -1,3 +1,5 @@
+import scala.language.experimental.clauseInterleaving
+
 def f1[T]()[U](x: T, y: U): (T, U) = (x, y)
 def f2[T](x: T)[U](y: U): (T, U) = (x, y)
 def f3[T, U](using DummyImplicit)[V](x: T): U = ???
diff --git a/tests/pos/interleaving-functor.scala b/tests/pos/interleaving-functor.scala
index c3df1f869850..35bed59f77f0 100644
--- a/tests/pos/interleaving-functor.scala
+++ b/tests/pos/interleaving-functor.scala
@@ -1,3 +1,5 @@
+import scala.language.experimental.clauseInterleaving
+
 object functorInterleaving:
   //taken from https://dotty.epfl.ch/docs/reference/contextual/type-classes.html
   //at version 3.1.1-RC1-bin-20210930-01f040b-NIGHTLY
diff --git a/tests/pos/interleaving-newline.scala b/tests/pos/interleaving-newline.scala
index dbd30bca4ef7..de8fb98a2f81 100644
--- a/tests/pos/interleaving-newline.scala
+++ b/tests/pos/interleaving-newline.scala
@@ -1,3 +1,5 @@
+import scala.language.experimental.clauseInterleaving
+
 object newline {
   def multipleLines
         [T]
diff --git a/tests/pos/interleaving-overload.scala b/tests/pos/interleaving-overload.scala
index e1c3db1abe37..1902551f9036 100644
--- a/tests/pos/interleaving-overload.scala
+++ b/tests/pos/interleaving-overload.scala
@@ -1,3 +1,4 @@
+import scala.language.experimental.clauseInterleaving
 
 class A{
 
diff --git a/tests/pos/interleaving-params.scala b/tests/pos/interleaving-params.scala
index e86f856a728d..36963ff2e123 100644
--- a/tests/pos/interleaving-params.scala
+++ b/tests/pos/interleaving-params.scala
@@ -1,3 +1,5 @@
+import scala.language.experimental.clauseInterleaving
+
 class Params{
     type U
     def foo[T](x: T)[U >: x.type <: T](using U)[L <: List[U]](l: L): L = ???
diff --git a/tests/pos/interleaving-signatureCollision.scala b/tests/pos/interleaving-signatureCollision.scala
index be016e7bdbfe..77190284ae6d 100644
--- a/tests/pos/interleaving-signatureCollision.scala
+++ b/tests/pos/interleaving-signatureCollision.scala
@@ -1,3 +1,4 @@
+import scala.language.experimental.clauseInterleaving
 import scala.annotation.targetName
 
 object signatureCollision:
diff --git a/tests/pos/interleaving-typeApply.scala b/tests/pos/interleaving-typeApply.scala
index ba9486408adb..3c669cc76bfc 100644
--- a/tests/pos/interleaving-typeApply.scala
+++ b/tests/pos/interleaving-typeApply.scala
@@ -1,3 +1,5 @@
+import scala.language.experimental.clauseInterleaving
+
 object typeApply:
 
     def f0[T]: [U] => T => T = ???
@@ -10,6 +12,7 @@ object typeApply:
     def f7[T <: Int](using DummyImplicit)[U <: String]()[X <: Unit]: X => X = ???
 
     @main def test = {
+        import scala.language.experimental.namedTypeArguments
         f0[Int][String]
         f1[Int][String]
         f2[Int][String]()
diff --git a/tests/pos/namedTypeParams.scala b/tests/pos/namedTypeParams.scala
index 160bfc11f079..388bcfa98bef 100644
--- a/tests/pos/namedTypeParams.scala
+++ b/tests/pos/namedTypeParams.scala
@@ -1,4 +1,5 @@
 import language.experimental.namedTypeArguments
+
 object Test {
 
   def f[X, Y](x: X, y: Y): Int = ???
@@ -7,7 +8,10 @@ object Test {
   f[X = Int, Y = String](1, "")
   f[X = Int](1, "")
   f[Y = String](1, "")
+}
 
+object TestInterleaving{
+  import language.experimental.clauseInterleaving
   def f2[X](using DummyImplicit)[Y](x: X, y: Y): Int = ???
 
   f2[X = Int][Y = String](1, "")
diff --git a/tests/pos/overrides.scala b/tests/pos/overrides.scala
index 0f5d12367ca2..146dc06c76a9 100644
--- a/tests/pos/overrides.scala
+++ b/tests/pos/overrides.scala
@@ -1,16 +1,21 @@
 class A[T] {
 
   def f(x: T)(y: T = x) = y
+  
+  import scala.language.experimental.clauseInterleaving
+
   def b[U <: T](x: Int)[V >: T](y: String) = false
 
 }
-
 class B extends A[Int] {
 
   override def f(x: Int)(y: Int) = y
 
   f(2)()
 
+
+  import scala.language.experimental.clauseInterleaving
+
   override def b[T <: Int](x: Int)[U >: Int](y: String) = true
 
 }
diff --git a/tests/run/interleaving.scala b/tests/run/interleaving.scala
index e84f2896e5af..557741032e8a 100644
--- a/tests/run/interleaving.scala
+++ b/tests/run/interleaving.scala
@@ -1,4 +1,5 @@
 object Test extends App {
+  import scala.language.experimental.clauseInterleaving
   trait Key { type Value }
   trait DB {
     def getOrElse(k: Key)[V >: k.Value](default: V): V // dependent type parameter

From 65091c31a625d9abb1d12942e2f870be8a8ae094 Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Tue, 3 Jan 2023 14:21:44 +0100
Subject: [PATCH 091/657] Remove unused methods

Not fixup'ed with another commit to keep a trace of the original version of these methods.
---
 .../dotty/tools/dotc/parsing/Parsers.scala    | 31 ++-----------------
 1 file changed, 3 insertions(+), 28 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index af4d0220162b..479ae1fa9095 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -3079,35 +3079,13 @@ object Parsers {
 
  /* -------- PARAMETERS ------------------------------------------- */
 
-    /** DefParamClause ::= DefTypeParamClause 
-     *                   | DefTermParamClause 
-     *                   | UsingParamClause
-     */
-    def typeOrTermParamClause(
-                    ownerKind: ParamOwner,
-                    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[TypeDef] | List[ValDef] =
-      if (in.token == LPAREN)
-        termParamClause(nparams, ofClass, ofCaseClass, prefix, givenOnly, firstClause)
-      else if (in.token == LBRACKET)
-        typeParamClause(ownerKind)
-      else
-        Nil
-      
-    end typeOrTermParamClause
-    
     /** DefParamClauses       ::= DefParamClause { DefParamClause }  -- and two DefTypeParamClause cannot be adjacent
+     *  DefParamClause        ::= DefTypeParamClause 
+     *                          | DefTermParamClause 
+     *                          | UsingParamClause
      */
     def typeOrTermParamClauses(
       ownerKind: ParamOwner,
-      ofClass: Boolean = false,
-      ofCaseClass: Boolean = false,
-      givenOnly: Boolean = false,
       numLeadParams: Int = 0
     ): List[List[TypeDef] | List[ValDef]] =
 
@@ -3118,9 +3096,6 @@ object Parsers {
           val paramsStart = in.offset
           val params = termParamClause(
               numLeadParams,
-              ofClass = ofClass,
-              ofCaseClass = ofCaseClass,
-              givenOnly = givenOnly,
               firstClause = firstClause)
           val lastClause = params.nonEmpty && params.head.mods.flags.is(Implicit)
           params :: (

From ff3fab2929fbe20e52df790be18aaa2dcc2a4310 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Fri, 3 Feb 2023 12:34:32 +0100
Subject: [PATCH 092/657] Perform Matchable check only if type test is needed

Fixes #16808
---
 .../src/dotty/tools/dotc/typer/Applications.scala     | 11 +++++------
 compiler/src/dotty/tools/dotc/typer/Checking.scala    |  1 -
 compiler/test/dotty/tools/dotc/CompilationTests.scala |  4 +---
 .../strict}/adhoc-extension/A.scala                   |  0
 .../strict}/adhoc-extension/B.scala                   |  0
 tests/pos-custom-args/{ => strict}/i10383.scala       |  0
 tests/pos-custom-args/strict/i16808.scala             |  2 ++
 .../strict}/i7296.scala                               |  0
 8 files changed, 8 insertions(+), 10 deletions(-)
 rename tests/{pos-special => pos-custom-args/strict}/adhoc-extension/A.scala (100%)
 rename tests/{pos-special => pos-custom-args/strict}/adhoc-extension/B.scala (100%)
 rename tests/pos-custom-args/{ => strict}/i10383.scala (100%)
 create mode 100644 tests/pos-custom-args/strict/i16808.scala
 rename tests/{pos-special => pos-custom-args/strict}/i7296.scala (100%)

diff --git a/compiler/src/dotty/tools/dotc/typer/Applications.scala b/compiler/src/dotty/tools/dotc/typer/Applications.scala
index cd33fe9cef24..d1ca562a5aba 100644
--- a/compiler/src/dotty/tools/dotc/typer/Applications.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Applications.scala
@@ -1258,8 +1258,6 @@ trait Applications extends Compatibility {
   def typedUnApply(tree: untpd.Apply, selType: Type)(using Context): Tree = {
     record("typedUnApply")
     val Apply(qual, args) = tree
-    if !ctx.mode.is(Mode.InTypeTest) then
-      checkMatchable(selType, tree.srcPos, pattern = true)
 
     def notAnExtractor(tree: Tree): Tree =
       // prefer inner errors
@@ -1398,12 +1396,13 @@ trait Applications extends Compatibility {
         val unapplyArgType = mt.paramInfos.head
         unapp.println(i"unapp arg tpe = $unapplyArgType, pt = $selType")
         val ownType =
-          if (selType <:< unapplyArgType) {
+          if selType <:< unapplyArgType then
             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 {
+          else
+            if !ctx.mode.is(Mode.InTypeTest) then
+              checkMatchable(selType, tree.srcPos, pattern = true)
             // 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.
@@ -1412,7 +1411,7 @@ trait Applications extends Compatibility {
             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] = {
diff --git a/compiler/src/dotty/tools/dotc/typer/Checking.scala b/compiler/src/dotty/tools/dotc/typer/Checking.scala
index 817fe6f21d24..bff9310dee88 100644
--- a/compiler/src/dotty/tools/dotc/typer/Checking.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Checking.scala
@@ -1461,7 +1461,6 @@ trait Checking {
 
   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
diff --git a/compiler/test/dotty/tools/dotc/CompilationTests.scala b/compiler/test/dotty/tools/dotc/CompilationTests.scala
index 2fdebef3f5db..dee65e404da9 100644
--- a/compiler/test/dotty/tools/dotc/CompilationTests.scala
+++ b/compiler/test/dotty/tools/dotc/CompilationTests.scala
@@ -48,6 +48,7 @@ class CompilationTests {
       compileFilesInDir("tests/pos", defaultOptions.and("-Ysafe-init", "-Ylegacy-lazy-vals", "-Ycheck-constraint-deps"), FileFilter.include(TestSources.posLazyValsAllowlist)),
       compileFilesInDir("tests/pos-deep-subtype", allowDeepSubtypes),
       compileFilesInDir("tests/pos-custom-args/no-experimental", defaultOptions.and("-Yno-experimental")),
+      compileFilesInDir("tests/pos-custom-args/strict", defaultOptions.and("-source", "future", "-deprecation", "-Xfatal-warnings")),
       compileDir("tests/pos-special/java-param-names", defaultOptions.withJavacOnlyOptions("-parameters")),
       compileFile(
         // succeeds despite -Xfatal-warnings because of -nowarn
@@ -55,8 +56,6 @@ class CompilationTests {
         defaultOptions.and("-nowarn", "-Xfatal-warnings")
       ),
       compileFile("tests/pos-special/typeclass-scaling.scala", defaultOptions.and("-Xmax-inlines", "40")),
-      compileFile("tests/pos-special/i7296.scala", defaultOptions.and("-source", "future", "-deprecation", "-Xfatal-warnings")),
-      compileDir("tests/pos-special/adhoc-extension", defaultOptions.and("-source", "future", "-feature", "-Xfatal-warnings")),
       compileFile("tests/pos-special/i7575.scala", defaultOptions.andLanguageFeature("dynamics")),
       compileFile("tests/pos-special/kind-projector.scala", defaultOptions.and("-Ykind-projector")),
       compileFile("tests/pos-special/kind-projector-underscores.scala", defaultOptions.and("-Ykind-projector:underscores")),
@@ -65,7 +64,6 @@ class CompilationTests {
       compileFile("tests/pos-custom-args/i9267.scala", defaultOptions.and("-Ystop-after:erasure")),
       compileFile("tests/pos-special/extend-java-enum.scala", defaultOptions.and("-source", "3.0-migration")),
       compileFile("tests/pos-custom-args/help.scala", defaultOptions.and("-help", "-V", "-W", "-X", "-Y")),
-      compileFile("tests/pos-custom-args/i10383.scala", defaultOptions.and("-source", "future", "-deprecation", "-Xfatal-warnings")),
       compileFile("tests/pos-custom-args/i13044.scala", defaultOptions.and("-Xmax-inlines:33")),
       compileFile("tests/pos-custom-args/jdk-8-app.scala", defaultOptions.and("-release:8")),
     ).checkCompile()
diff --git a/tests/pos-special/adhoc-extension/A.scala b/tests/pos-custom-args/strict/adhoc-extension/A.scala
similarity index 100%
rename from tests/pos-special/adhoc-extension/A.scala
rename to tests/pos-custom-args/strict/adhoc-extension/A.scala
diff --git a/tests/pos-special/adhoc-extension/B.scala b/tests/pos-custom-args/strict/adhoc-extension/B.scala
similarity index 100%
rename from tests/pos-special/adhoc-extension/B.scala
rename to tests/pos-custom-args/strict/adhoc-extension/B.scala
diff --git a/tests/pos-custom-args/i10383.scala b/tests/pos-custom-args/strict/i10383.scala
similarity index 100%
rename from tests/pos-custom-args/i10383.scala
rename to tests/pos-custom-args/strict/i10383.scala
diff --git a/tests/pos-custom-args/strict/i16808.scala b/tests/pos-custom-args/strict/i16808.scala
new file mode 100644
index 000000000000..602ceed94161
--- /dev/null
+++ b/tests/pos-custom-args/strict/i16808.scala
@@ -0,0 +1,2 @@
+def collectKeys[A, B, C](xs: Map[A, B])(f: PartialFunction[A, C]): Map[C, B] =
+	xs.collect{ case (f(c) , b) => (c, b) }
\ No newline at end of file
diff --git a/tests/pos-special/i7296.scala b/tests/pos-custom-args/strict/i7296.scala
similarity index 100%
rename from tests/pos-special/i7296.scala
rename to tests/pos-custom-args/strict/i7296.scala

From d28641c19e52ca4059fb2ec00f89e2fc71b9937e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Doeraene?= <sjrdoeraene@gmail.com>
Date: Thu, 2 Feb 2023 12:07:40 +0100
Subject: [PATCH 093/657] Fix #16801: Scala.js: Handle Closure's of
 s.r.FunctionXXL.

---
 compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala   |  7 +++++--
 .../src/scala/scalajs/runtime/AnonFunctionXXL.scala    |  8 ++++++++
 project/MiMaFilters.scala                              |  3 +++
 tests/run/functionXXL.scala                            |  2 --
 tests/run/i2004.scala                                  |  2 --
 tests/run/implicitFunctionXXL.scala                    |  2 --
 tests/run/tupled-function-andThen.scala                |  2 --
 tests/run/tupled-function-apply.scala                  |  4 +---
 tests/run/tupled-function-compose.scala                |  2 --
 tests/run/tupled-function-extension-method.scala       | 10 ++++++----
 tests/run/tupled-function-tupled.scala                 |  2 --
 11 files changed, 23 insertions(+), 21 deletions(-)
 create mode 100644 library-js/src/scala/scalajs/runtime/AnonFunctionXXL.scala

diff --git a/compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala b/compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala
index 4caf1f6b5fa2..eee791852fde 100644
--- a/compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala
+++ b/compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala
@@ -3532,13 +3532,16 @@ class JSCodeGen()(using genCtx: Context) {
       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 if (funInterfaceSym.name == tpnme.FunctionXXL && funInterfaceSym.owner == defn.ScalaRuntimePackageClass) {
+        val cls = ClassName("scala.scalajs.runtime.AnonFunctionXXL")
+        val ctorName = MethodName.constructor(
+            jstpe.ClassRef(ClassName("scala.scalajs.js.Function1")) :: Nil)
+        js.New(cls, js.MethodIdent(ctorName), List(closure))
       } else {
         assert(funInterfaceSym.isJSType,
             s"Invalid functional interface $funInterfaceSym reached the back-end")
diff --git a/library-js/src/scala/scalajs/runtime/AnonFunctionXXL.scala b/library-js/src/scala/scalajs/runtime/AnonFunctionXXL.scala
new file mode 100644
index 000000000000..87208573eff9
--- /dev/null
+++ b/library-js/src/scala/scalajs/runtime/AnonFunctionXXL.scala
@@ -0,0 +1,8 @@
+package scala.scalajs.runtime
+
+import scala.scalajs.js
+
+@inline
+final class AnonFunctionXXL(f: js.Function1[IArray[Object], Object]) extends scala.runtime.FunctionXXL {
+  override def apply(xs: IArray[Object]): Object = f(xs)
+}
diff --git a/project/MiMaFilters.scala b/project/MiMaFilters.scala
index 0937777595ca..8af2de7058ee 100644
--- a/project/MiMaFilters.scala
+++ b/project/MiMaFilters.scala
@@ -17,6 +17,9 @@ object MiMaFilters {
     ProblemFilters.exclude[MissingClassProblem]("scala.util.boundary$Break"),
     ProblemFilters.exclude[MissingClassProblem]("scala.util.boundary$Label"),
 
+    // Scala.js only: new runtime support class in 3.2.3; not available to users
+    ProblemFilters.exclude[MissingClassProblem]("scala.scalajs.runtime.AnonFunctionXXL"),
+
     //  New experimental features in 3.3.X
     ProblemFilters.exclude[MissingFieldProblem]("scala.runtime.stdLibPatches.language#experimental.clauseInterleaving"),
     ProblemFilters.exclude[MissingClassProblem]("scala.runtime.stdLibPatches.language$experimental$clauseInterleaving$"),
diff --git a/tests/run/functionXXL.scala b/tests/run/functionXXL.scala
index 885e7bce8be9..de8c8e3faedd 100644
--- a/tests/run/functionXXL.scala
+++ b/tests/run/functionXXL.scala
@@ -1,5 +1,3 @@
-// scalajs: --skip --pending
-
 object Test {
 
   val f = (x1: Int,
diff --git a/tests/run/i2004.scala b/tests/run/i2004.scala
index dd829ef24b5b..8682423ef2f0 100644
--- a/tests/run/i2004.scala
+++ b/tests/run/i2004.scala
@@ -1,5 +1,3 @@
-// scalajs: --skip --pending
-
 object Test {
   def main(args: Array[String]) = {
 
diff --git a/tests/run/implicitFunctionXXL.scala b/tests/run/implicitFunctionXXL.scala
index fcae9c135cda..b4131080577d 100644
--- a/tests/run/implicitFunctionXXL.scala
+++ b/tests/run/implicitFunctionXXL.scala
@@ -1,5 +1,3 @@
-// scalajs: --skip --pending
-
 object Test {
 
   def main(args: Array[String]): Unit = {
diff --git a/tests/run/tupled-function-andThen.scala b/tests/run/tupled-function-andThen.scala
index a57c3613bb32..94236e9267e1 100644
--- a/tests/run/tupled-function-andThen.scala
+++ b/tests/run/tupled-function-andThen.scala
@@ -1,5 +1,3 @@
-// scalajs: --skip --pending
-
 import scala.util.TupledFunction
 
 object Test {
diff --git a/tests/run/tupled-function-apply.scala b/tests/run/tupled-function-apply.scala
index 76f6b823df76..7d2162a565ac 100644
--- a/tests/run/tupled-function-apply.scala
+++ b/tests/run/tupled-function-apply.scala
@@ -1,5 +1,3 @@
-// scalajs: --skip --pending
-
 import scala.util.TupledFunction
 
 object Test {
@@ -119,4 +117,4 @@ object Test {
     */
   extension [F, Args <: Tuple, R](f: F) def apply (args: Args)(using tf: TupledFunction[F, Args => R]): R =
     tf.tupled(f)(args)
-}
\ No newline at end of file
+}
diff --git a/tests/run/tupled-function-compose.scala b/tests/run/tupled-function-compose.scala
index a2ca5c56771a..4cf83563274d 100644
--- a/tests/run/tupled-function-compose.scala
+++ b/tests/run/tupled-function-compose.scala
@@ -1,5 +1,3 @@
-// scalajs: --skip --pending
-
 import scala.util.TupledFunction
 object Test {
   def main(args: Array[String]): Unit = {
diff --git a/tests/run/tupled-function-extension-method.scala b/tests/run/tupled-function-extension-method.scala
index 0185fc4eb06c..be5ccbd5ca17 100644
--- a/tests/run/tupled-function-extension-method.scala
+++ b/tests/run/tupled-function-extension-method.scala
@@ -1,5 +1,3 @@
-// scalajs: --skip --pending
-
 import scala.util.TupledFunction
 object Test {
   def main(args: Array[String]): Unit = {
@@ -13,7 +11,7 @@ object Test {
         (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25)
     )
 
-    println(f0())
+    portablePrintln(f0())
     println(f1(1))
     println(f2(1, 2))
     println(f3(1, 2, 3))
@@ -34,6 +32,10 @@ object Test {
 
   }
 
+  def portablePrintln(x: Any): Unit =
+    if x == () then println("()")
+    else println(x)
+
   class Expr[T](val x: T)
 
   // Specialized only for arity 0 and one as auto tupling will not provide the disired effect
@@ -50,4 +52,4 @@ object Test {
   extension [F, Args <: Tuple, R](e: Expr[F]) def applyGiven (args: Args)(using tf: TupledFunction[F, Args ?=> R]): R =
     tf.tupled(e.x)(using args)
 
-}
\ No newline at end of file
+}
diff --git a/tests/run/tupled-function-tupled.scala b/tests/run/tupled-function-tupled.scala
index 360e3e299770..6e7d94b3ac3d 100644
--- a/tests/run/tupled-function-tupled.scala
+++ b/tests/run/tupled-function-tupled.scala
@@ -1,5 +1,3 @@
-// scalajs: --skip --pending
-
 import scala.util.TupledFunction
 
 object Test {

From 917534b5588a33401ae1937416319697163c2980 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Fri, 3 Feb 2023 15:21:56 +0100
Subject: [PATCH 094/657] Update printing tests to have matching AST

---
 .../printing/transformed/lazy-vals-new.check  | 24 +++++++++----------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/tests/printing/transformed/lazy-vals-new.check b/tests/printing/transformed/lazy-vals-new.check
index 406417845c20..4b81cd457a38 100644
--- a/tests/printing/transformed/lazy-vals-new.check
+++ b/tests/printing/transformed/lazy-vals-new.check
@@ -10,19 +10,19 @@ package <empty> {
     @static private def <clinit>(): Unit =
       {
         A.OFFSET$_m_0 =
-          scala.runtime.LazyVals.getStaticFieldOffset(
+          scala.runtime.LazyVals.getOffsetStatic(
             classOf[Object {...}].getDeclaredField("x$lzy1"))
         ()
       }
     @static @static val OFFSET$_m_0: Long =
-      scala.runtime.LazyVals.getStaticFieldOffset(
+      scala.runtime.LazyVals.getOffsetStatic(
         classOf[Object {...}].getDeclaredField("x$lzy1"))
     private def writeReplace(): Object =
       new scala.runtime.ModuleSerializationProxy(classOf[A])
-    @volatile private lazy <static> var x$lzy1: Object = null
+    @volatile private lazy var x$lzy1: Object = null
     lazy def x(): Int =
       {
-        val result: Object = A#x$lzy1
+        val result: Object = A.x$lzy1
         if result.isInstanceOf[Int] then scala.Int.unbox(result) else
           if result.eq(scala.runtime.LazyVals.NullValue) then
             scala.Int.unbox(null) else scala.Int.unbox(A.x$lzyINIT1())
@@ -30,10 +30,10 @@ package <empty> {
     private def x$lzyINIT1(): Object =
       while <empty> do
         {
-          val current: Object = A#x$lzy1
+          val current: Object = A.x$lzy1
           if current.eq(null) then
             if
-              scala.runtime.LazyVals.objCAS(classOf[A], A.OFFSET$_m_0, null,
+              scala.runtime.LazyVals.objCAS(this, A.OFFSET$_m_0, null,
                 scala.runtime.LazyVals.Evaluating)
              then
               {
@@ -49,15 +49,15 @@ package <empty> {
                   }
                  finally
                   if
-                    scala.runtime.LazyVals.objCAS(classOf[A], A.OFFSET$_m_0,
+                    scala.runtime.LazyVals.objCAS(this, A.OFFSET$_m_0,
                       scala.runtime.LazyVals.Evaluating, result).unary_!()
                    then
                     {
                       val lock: scala.runtime.LazyVals.LazyVals$Waiting =
-                        A#x$lzy1.asInstanceOf[
+                        A.x$lzy1.asInstanceOf[
                           scala.runtime.LazyVals.LazyVals$Waiting]
-                      scala.runtime.LazyVals.objCAS(classOf[A], A.OFFSET$_m_0,
-                        lock, result)
+                      scala.runtime.LazyVals.objCAS(this, A.OFFSET$_m_0, lock,
+                        result)
                       lock.countDown()
                     }
                    else ()
@@ -71,8 +71,8 @@ package <empty> {
              then
               if current.eq(scala.runtime.LazyVals.Evaluating) then
                 {
-                  scala.runtime.LazyVals.objCAS(classOf[A], A.OFFSET$_m_0,
-                    current, new scala.runtime.LazyVals.LazyVals$Waiting())
+                  scala.runtime.LazyVals.objCAS(this, A.OFFSET$_m_0, current,
+                    new scala.runtime.LazyVals.LazyVals$Waiting())
                   ()
                 }
                else

From 11854bbf20d92b74fef82f19c4dcb7dd38f45f70 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Wed, 1 Feb 2023 14:48:29 +0000
Subject: [PATCH 095/657] Restrict captureWildcards to only be used if needed

Rather than blindly using the newly wildcard-captured type, check that
it's compatible with the proto/formal type.  That way values that have
wildcard types can be passed, uncast, to extension methods that don't
require the capture.

For instance in specs2, a value of type `Class[? <: Foo]` needn't become
`Class[?1.CAP]` just so it can be applied to `def theValue[T](t: => T)`.

For the zio-http case, despite knowing that JFuture is morally
covariant, we don't have any way to knowing that - so we must be safe
and error.
---
 .../dotty/tools/dotc/typer/Applications.scala  |  9 +++++++--
 .../dotty/tools/dotc/typer/ProtoTypes.scala    | 16 +++++++---------
 .../src/dotty/tools/dotc/typer/Typer.scala     |  2 +-
 tests/neg/t9419.zio-http.scala                 | 18 ++++++++++++++++++
 tests/pos/t9419.specs2.scala                   | 13 +++++++++++++
 5 files changed, 46 insertions(+), 12 deletions(-)
 create mode 100644 tests/neg/t9419.zio-http.scala
 create mode 100644 tests/pos/t9419.specs2.scala

diff --git a/compiler/src/dotty/tools/dotc/typer/Applications.scala b/compiler/src/dotty/tools/dotc/typer/Applications.scala
index cd33fe9cef24..224359faaf3b 100644
--- a/compiler/src/dotty/tools/dotc/typer/Applications.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Applications.scala
@@ -714,8 +714,8 @@ trait Applications extends Compatibility {
         || argMatch == ArgMatch.CompatibleCAP
             && {
               val argtpe1 = argtpe.widen
-              val captured = captureWildcards(argtpe1)
-              (captured ne argtpe1) && isCompatible(captured, formal.widenExpr)
+              val captured = captureWildcardsCompat(argtpe1, formal.widenExpr)
+              captured ne argtpe1
             }
 
     /** The type of the given argument */
@@ -2412,4 +2412,9 @@ trait Applications extends Compatibility {
   def isApplicableExtensionMethod(methodRef: TermRef, receiverType: Type)(using Context): Boolean =
     methodRef.symbol.is(ExtensionMethod) && !receiverType.isBottomType &&
       tryApplyingExtensionMethod(methodRef, nullLiteral.asInstance(receiverType)).nonEmpty
+
+  def captureWildcardsCompat(tp: Type, pt: Type)(using Context): Type =
+    val captured = captureWildcards(tp)
+    if (captured ne tp) && isCompatible(captured, pt) then captured
+    else tp
 }
diff --git a/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala b/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
index d724ad1708b1..da785e32865a 100644
--- a/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
+++ b/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
@@ -501,15 +501,13 @@ object ProtoTypes {
 
     def checkNoWildcardCaptureForCBN(targ1: Tree)(using Context): Tree = {
       if hasCaptureConversionArg(targ1.tpe) then
-        stripCast(targ1).tpe match
-          case tp: AppliedType if tp.hasWildcardArg =>
-            errorTree(targ1,
-              em"""argument for by-name parameter is not a value
-                  |and contains wildcard arguments: $tp
-                  |
-                  |Assign it to a val and pass that instead.
-                  |""")
-          case _ => targ1
+        val tp = stripCast(targ1).tpe
+        errorTree(targ1,
+          em"""argument for by-name parameter is not a value
+              |and contains wildcard arguments: $tp
+              |
+              |Assign it to a val and pass that instead.
+              |""")
       else targ1
     }
 
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index e7f75eafed94..a87d6dd7e703 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -3962,7 +3962,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
             return adaptConstant(tree, ConstantType(converted))
         case _ =>
 
-      val captured = captureWildcards(wtp)
+      val captured = captureWildcardsCompat(wtp, pt)
       if (captured `ne` wtp)
         return readapt(tree.cast(captured))
 
diff --git a/tests/neg/t9419.zio-http.scala b/tests/neg/t9419.zio-http.scala
new file mode 100644
index 000000000000..cff9ec51e6f9
--- /dev/null
+++ b/tests/neg/t9419.zio-http.scala
@@ -0,0 +1,18 @@
+// Minimisation of how the fix for t9419 affected zio-http
+import java.util.concurrent.Future as JFuture
+
+trait Test:
+  def shutdownGracefully(): JFuture[_]
+
+  def executedWildcard(jFuture: => JFuture[_]): Unit
+  def executedGeneric[A](jFuture: => JFuture[A]): Unit
+  def executedWildGen[A](jFuture: => JFuture[? <: A]): Unit
+
+  // Even though JFuture is morally covariant, at least currently,
+  // there's no definition-side variance, so it's treated as invariant.
+  // So we have to be concerned that two different values of `JFuture[A]`
+  // with different types, blowing up together.  So error in `fails`.
+  def works = executedWildcard(shutdownGracefully())
+  def fails = executedGeneric(shutdownGracefully()) // error
+  def fixed = executedGeneric(shutdownGracefully().asInstanceOf[JFuture[Any]]) // fix
+  def best2 = executedWildGen(shutdownGracefully()) // even better, use use-site variance in the method
diff --git a/tests/pos/t9419.specs2.scala b/tests/pos/t9419.specs2.scala
new file mode 100644
index 000000000000..fe4a44312594
--- /dev/null
+++ b/tests/pos/t9419.specs2.scala
@@ -0,0 +1,13 @@
+// Minimisation of how the fix for t9419 affected specs2
+class MustExpectable[T](tm: () => T):
+  def must_==(other: => Any) = tm() == other
+
+class Foo
+
+object Main:
+  implicit def theValue[T](t: => T): MustExpectable[T] = new MustExpectable(() => t)
+  def main(args: Array[String]): Unit =
+    val cls = classOf[Foo]
+    val instance = new Foo()
+    val works = cls must_== cls
+    val fails = instance.getClass must_== cls

From 22b49e9365f9a8e045feca1b373af2a4285129d8 Mon Sep 17 00:00:00 2001
From: Michael Pilquist <mpilquist@gmail.com>
Date: Fri, 3 Feb 2023 20:43:05 -0500
Subject: [PATCH 096/657] Remove experimental from Mirror#fromProductTyped

---
 library/src/scala/deriving/Mirror.scala | 1 -
 1 file changed, 1 deletion(-)

diff --git a/library/src/scala/deriving/Mirror.scala b/library/src/scala/deriving/Mirror.scala
index 5de219dfe5c4..57453a516567 100644
--- a/library/src/scala/deriving/Mirror.scala
+++ b/library/src/scala/deriving/Mirror.scala
@@ -52,7 +52,6 @@ object Mirror {
 
   extension [T](p: ProductOf[T])
     /** Create a new instance of type `T` with elements taken from product `a`. */
-    @annotation.experimental
     def fromProductTyped[A <: scala.Product, Elems <: p.MirroredElemTypes](a: A)(using m: ProductOf[A] { type MirroredElemTypes = Elems }): T =
       p.fromProduct(a)
 

From cac782a3bd47640cf1ff435f3c6df51d05dc3eba Mon Sep 17 00:00:00 2001
From: Michael Pilquist <mpilquist@gmail.com>
Date: Sat, 4 Feb 2023 08:42:54 -0500
Subject: [PATCH 097/657] Update experimental definitions list

---
 .../tasty-inspector/stdlibExperimentalDefinitions.scala       | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/tests/run-custom-args/tasty-inspector/stdlibExperimentalDefinitions.scala b/tests/run-custom-args/tasty-inspector/stdlibExperimentalDefinitions.scala
index 30e7c5af6c2a..062fa25e0ca5 100644
--- a/tests/run-custom-args/tasty-inspector/stdlibExperimentalDefinitions.scala
+++ b/tests/run-custom-args/tasty-inspector/stdlibExperimentalDefinitions.scala
@@ -58,10 +58,6 @@ val experimentalDefinitionInLibrary = Set(
   //// New feature: into
   "scala.annotation.allowConversions",
 
-  //// New APIs: Mirror
-  // Can be stabilized in 3.3.0 or later.
-  "scala.deriving.Mirror$.fromProductTyped", // This API is a bit convoluted. We may need some more feedback before we can stabilize it.
-
   //// New feature: Macro annotations
   "scala.annotation.MacroAnnotation",
 

From 11ef198e6d9c50bb31a01480b3877f6dbba545a5 Mon Sep 17 00:00:00 2001
From: Vasil Vasilev <vasil.vasilev@jetbrains.com>
Date: Mon, 6 Feb 2023 12:08:05 +0100
Subject: [PATCH 098/657] Add scaladoc documentation for
 `ReplDriver#redirectOutput`

---
 compiler/src/dotty/tools/repl/ReplDriver.scala | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/compiler/src/dotty/tools/repl/ReplDriver.scala b/compiler/src/dotty/tools/repl/ReplDriver.scala
index 0f29591e2121..905f4f06de08 100644
--- a/compiler/src/dotty/tools/repl/ReplDriver.scala
+++ b/compiler/src/dotty/tools/repl/ReplDriver.scala
@@ -187,6 +187,17 @@ class ReplDriver(settings: Array[String],
   // TODO: i5069
   final def bind(name: String, value: Any)(using state: State): State = state
 
+  /**
+   * Controls whether the `System.out` and `System.err` streams are set to the provided constructor parameter instance
+   * of [[java.io.PrintStream]] during the execution of the repl. On by default.
+   *
+   * Disabling this can be beneficial when executing a repl instance inside a concurrent environment, for example a
+   * thread pool (such as the Scala compile server in the Scala Plugin for IntelliJ IDEA).
+   *
+   * In such environments, indepently executing `System.setOut` and `System.setErr` without any synchronization can
+   * lead to unpredictable results when restoring the original streams (dependent on the order of execution), leaving
+   * the Java process in an inconsistent state.
+   */
   protected def redirectOutput: Boolean = true
 
   // redirecting the output allows us to test `println` in scripted tests

From 35320eb288a625a8504e6d01020e4ea64d61c904 Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Mon, 6 Feb 2023 14:12:24 +0100
Subject: [PATCH 099/657] fix: ensure syntax blocks for ebnf are marked as such

I see that this was done in the past in
https://github.com/lampepfl/dotty/pull/14958/files, but then reverted in
https://github.com/lampepfl/dotty/pull/14958. Like many commits, there
really isn't an explanation of the revert, but from reading between the
lines I assume the `;` was the actual issue, not the syntax
highlighting. As it was pointed out, syntax.js doesn't actually support
`ebnf`. They do say they support `bnf`, but that didn't really work when I
was testing. Either way, this pr makes sure that we _do_ mark the
snippets as `ebnf`. The reason for this isn't necessarily so that we
_get_ syntax highlighting for these, but so that syntax.js doesn't infer
the wrong type of syntax and provide odd highlighting like we currently
have. This also helps to ensure screen readers know what type of
codeblock this is.

fixes #14697
---
 docs/_docs/reference/changed-features/imports.md          | 2 +-
 docs/_docs/reference/changed-features/match-syntax.md     | 2 +-
 docs/_docs/reference/changed-features/pattern-bindings.md | 2 +-
 .../reference/changed-features/structural-types-spec.md   | 2 +-
 docs/_docs/reference/changed-features/vararg-splices.md   | 2 +-
 docs/_docs/reference/contextual/context-bounds.md         | 2 +-
 docs/_docs/reference/contextual/context-functions-spec.md | 2 +-
 docs/_docs/reference/contextual/derivation.md             | 2 +-
 docs/_docs/reference/contextual/extension-methods.md      | 2 +-
 docs/_docs/reference/contextual/given-imports.md          | 2 +-
 docs/_docs/reference/contextual/givens.md                 | 4 ++--
 docs/_docs/reference/contextual/using-clauses.md          | 2 +-
 docs/_docs/reference/enums/adts.md                        | 4 ++--
 docs/_docs/reference/experimental/named-typeargs-spec.md  | 4 ++--
 docs/_docs/reference/metaprogramming/macros-spec.md       | 6 +++---
 docs/_docs/reference/metaprogramming/simple-smp.md        | 2 +-
 .../reference/new-types/dependent-function-types-spec.md  | 2 +-
 docs/_docs/reference/new-types/intersection-types-spec.md | 2 +-
 docs/_docs/reference/new-types/type-lambdas-spec.md       | 2 +-
 docs/_docs/reference/other-new-features/export.md         | 2 +-
 docs/_docs/reference/other-new-features/indentation.md    | 8 ++++----
 .../_docs/reference/other-new-features/opaques-details.md | 2 +-
 22 files changed, 30 insertions(+), 30 deletions(-)

diff --git a/docs/_docs/reference/changed-features/imports.md b/docs/_docs/reference/changed-features/imports.md
index 2058ef08b7db..b322a6a58393 100644
--- a/docs/_docs/reference/changed-features/imports.md
+++ b/docs/_docs/reference/changed-features/imports.md
@@ -46,7 +46,7 @@ are offered under settings `-source 3.1-migration -rewrite`.
 
 ## Syntax
 
-```
+```ebnf
 Import            ::=  ‘import’ ImportExpr {‘,’ ImportExpr}
 ImportExpr        ::= SimpleRef {‘.’ id} ‘.’ ImportSpec
                     | SimpleRef `as` id
diff --git a/docs/_docs/reference/changed-features/match-syntax.md b/docs/_docs/reference/changed-features/match-syntax.md
index dba50e9beb6a..3f4d608e261f 100644
--- a/docs/_docs/reference/changed-features/match-syntax.md
+++ b/docs/_docs/reference/changed-features/match-syntax.md
@@ -47,7 +47,7 @@ The syntactical precedence of match expressions has been changed.
 
 The new syntax of match expressions is as follows.
 
-```
+```ebnf
 InfixExpr    ::=  ...
                |  InfixExpr MatchClause
 SimpleExpr   ::=  ...
diff --git a/docs/_docs/reference/changed-features/pattern-bindings.md b/docs/_docs/reference/changed-features/pattern-bindings.md
index 2de338fc1dde..a75d64e7cd2d 100644
--- a/docs/_docs/reference/changed-features/pattern-bindings.md
+++ b/docs/_docs/reference/changed-features/pattern-bindings.md
@@ -50,7 +50,7 @@ for case (x, y) <- elems yield (y, x)  // returns List((2, 1), (4, 3))
 ## Syntax Changes
 
 Generators in for expressions may be prefixed with `case`.
-```
+```ebnf
 Generator      ::=  [‘case’] Pattern1 ‘<-’ Expr
 ```
 
diff --git a/docs/_docs/reference/changed-features/structural-types-spec.md b/docs/_docs/reference/changed-features/structural-types-spec.md
index d456932649fb..18d0f31ee6fe 100644
--- a/docs/_docs/reference/changed-features/structural-types-spec.md
+++ b/docs/_docs/reference/changed-features/structural-types-spec.md
@@ -6,7 +6,7 @@ nightlyOf: https://docs.scala-lang.org/scala3/reference/changed-features/structu
 
 ## Syntax
 
-```
+```ebnf
 SimpleType    ::= ... | Refinement
 Refinement    ::= ‘{’ RefineStatSeq ‘}’
 RefineStatSeq ::=  RefineStat {semi RefineStat}
diff --git a/docs/_docs/reference/changed-features/vararg-splices.md b/docs/_docs/reference/changed-features/vararg-splices.md
index 43c4acc5f880..8f23af771216 100644
--- a/docs/_docs/reference/changed-features/vararg-splices.md
+++ b/docs/_docs/reference/changed-features/vararg-splices.md
@@ -24,7 +24,7 @@ The old syntax for splice arguments will be phased out.
 
 ## Syntax
 
-```
+```ebnf
 ArgumentPatterns  ::=  ‘(’ [Patterns] ‘)’
                     |  ‘(’ [Patterns ‘,’] Pattern2 ‘*’ ‘)’
 
diff --git a/docs/_docs/reference/contextual/context-bounds.md b/docs/_docs/reference/contextual/context-bounds.md
index 42479d6802b3..11d57c8cbd52 100644
--- a/docs/_docs/reference/contextual/context-bounds.md
+++ b/docs/_docs/reference/contextual/context-bounds.md
@@ -47,7 +47,7 @@ done automatically under `-rewrite`.
 
 ## Syntax
 
-```
+```ebnf
 TypeParamBounds   ::=  [SubtypeBounds] {ContextBound}
 ContextBound      ::=  ‘:’ Type
 ```
diff --git a/docs/_docs/reference/contextual/context-functions-spec.md b/docs/_docs/reference/contextual/context-functions-spec.md
index 109513e9da86..385ee3901fd8 100644
--- a/docs/_docs/reference/contextual/context-functions-spec.md
+++ b/docs/_docs/reference/contextual/context-functions-spec.md
@@ -6,7 +6,7 @@ nightlyOf: https://docs.scala-lang.org/scala3/reference/contextual/context-funct
 
 ## Syntax
 
-```
+```ebnf
 Type              ::=  ...
                     |  FunArgTypes ‘?=>’ Type
 Expr              ::=  ...
diff --git a/docs/_docs/reference/contextual/derivation.md b/docs/_docs/reference/contextual/derivation.md
index 31040615d38c..fb8acd0fad93 100644
--- a/docs/_docs/reference/contextual/derivation.md
+++ b/docs/_docs/reference/contextual/derivation.md
@@ -486,7 +486,7 @@ method please read more at [How to write a type class `derived` method using mac
 
 ## Syntax
 
-```
+```ebnf
 Template          ::=  InheritClauses [TemplateBody]
 EnumDef           ::=  id ClassConstr InheritClauses EnumBody
 InheritClauses    ::=  [‘extends’ ConstrApps] [‘derives’ QualId {‘,’ QualId}]
diff --git a/docs/_docs/reference/contextual/extension-methods.md b/docs/_docs/reference/contextual/extension-methods.md
index d23cadf513d7..6a1504c25048 100644
--- a/docs/_docs/reference/contextual/extension-methods.md
+++ b/docs/_docs/reference/contextual/extension-methods.md
@@ -285,7 +285,7 @@ def position(s: String)(ch: Char, n: Int): Int =
 Here are the syntax changes for extension methods and collective extensions relative
 to the [current syntax](../syntax.md).
 
-```
+```ebnf
 BlockStat         ::=  ... | Extension
 TemplateStat      ::=  ... | Extension
 TopStat           ::=  ... | Extension
diff --git a/docs/_docs/reference/contextual/given-imports.md b/docs/_docs/reference/contextual/given-imports.md
index 6a55368979b1..28442581e408 100644
--- a/docs/_docs/reference/contextual/given-imports.md
+++ b/docs/_docs/reference/contextual/given-imports.md
@@ -103,7 +103,7 @@ given instances once their user base has migrated.
 
 ## Syntax
 
-```
+```ebnf
 Import            ::=  ‘import’ ImportExpr {‘,’ ImportExpr}
 Export            ::=  ‘export’ ImportExpr {‘,’ ImportExpr}
 ImportExpr        ::=  SimpleRef {‘.’ id} ‘.’ ImportSpec
diff --git a/docs/_docs/reference/contextual/givens.md b/docs/_docs/reference/contextual/givens.md
index 1bfffbc5bf6f..f1333bf8811f 100644
--- a/docs/_docs/reference/contextual/givens.md
+++ b/docs/_docs/reference/contextual/givens.md
@@ -10,7 +10,7 @@ that serve for synthesizing arguments to [context parameters](./using-clauses.md
 ```scala
 trait Ord[T]:
   def compare(x: T, y: T): Int
-  extension (x: T) 
+  extension (x: T)
     def < (y: T) = compare(x, y) < 0
     def > (y: T) = compare(x, y) > 0
 
@@ -174,7 +174,7 @@ is created for each reference.
 
 Here is the syntax for given instances:
 
-```
+```ebnf
 TmplDef             ::=  ...
                      |   ‘given’ GivenDef
 GivenDef            ::=  [GivenSig] StructuralInstance
diff --git a/docs/_docs/reference/contextual/using-clauses.md b/docs/_docs/reference/contextual/using-clauses.md
index 61b80ee27d91..48da98a3ccb5 100644
--- a/docs/_docs/reference/contextual/using-clauses.md
+++ b/docs/_docs/reference/contextual/using-clauses.md
@@ -151,7 +151,7 @@ def summon[T](using x: T): x.type = x
 
 Here is the new syntax of parameters and arguments seen as a delta from the [standard context free syntax of Scala 3](../syntax.md). `using` is a soft keyword, recognized only at the start of a parameter or argument list. It can be used as a normal identifier everywhere else.
 
-```
+```ebnf
 ClsParamClause      ::=  ... | UsingClsParamClause
 DefParamClause      ::=  ... | UsingParamClause
 UsingClsParamClause ::=  ‘(’ ‘using’ (ClsParams | Types) ‘)’
diff --git a/docs/_docs/reference/enums/adts.md b/docs/_docs/reference/enums/adts.md
index 3ab8c9f3b45b..5219e062a633 100644
--- a/docs/_docs/reference/enums/adts.md
+++ b/docs/_docs/reference/enums/adts.md
@@ -154,7 +154,7 @@ The changes are specified below as deltas with respect to the Scala syntax given
 
  1. Enum definitions are defined as follows:
 
-    ```
+    ```ebnf
     TmplDef   ::=  `enum' EnumDef
     EnumDef   ::=  id ClassConstr [`extends' [ConstrApps]] EnumBody
     EnumBody  ::=  [nl] ‘{’ [SelfType] EnumStat {semi EnumStat} ‘}’
@@ -164,7 +164,7 @@ The changes are specified below as deltas with respect to the Scala syntax given
 
  2. Cases of enums are defined as follows:
 
-    ```
+    ```ebnf
     EnumCase  ::=  `case' (id ClassConstr [`extends' ConstrApps]] | ids)
     ```
 
diff --git a/docs/_docs/reference/experimental/named-typeargs-spec.md b/docs/_docs/reference/experimental/named-typeargs-spec.md
index 9e1113bbac86..741836a481f2 100644
--- a/docs/_docs/reference/experimental/named-typeargs-spec.md
+++ b/docs/_docs/reference/experimental/named-typeargs-spec.md
@@ -10,7 +10,7 @@ In this section we give more details about the [named type arguments](named-type
 
 The addition to the grammar is:
 
-```
+```ebnf
 SimpleExpr1       ::=  ...
                     |  SimpleExpr (TypeArgs | NamedTypeArgs)
 NamedTypeArgs     ::=  ‘[’ NamedTypeArg {‘,’ NamedTypeArg} ‘]’
@@ -19,7 +19,7 @@ NamedTypeArg      ::=  id ‘=’ Type
 
 Note in particular that named arguments cannot be passed to type constructors:
 
-``` scala
+```scala
 class C[T]
 
 val x: C[T = Int] = // error
diff --git a/docs/_docs/reference/metaprogramming/macros-spec.md b/docs/_docs/reference/metaprogramming/macros-spec.md
index aa8f94a9a1f7..d4221365454d 100644
--- a/docs/_docs/reference/metaprogramming/macros-spec.md
+++ b/docs/_docs/reference/metaprogramming/macros-spec.md
@@ -57,7 +57,7 @@ extends simply-typed lambda calculus with quotes and splices.
 ### Syntax
 
 The syntax of terms, values, and types is given as follows:
-```
+```ebnf
 Terms         t  ::=  x                 variable
                       (x: T) => t       lambda
                       t t               application
@@ -77,7 +77,7 @@ Typing rules are formulated using a stack of environments
 `Es`. Individual environments `E` consist as usual of variable
 bindings `x: T`. Environments can be combined using the two
 combinators `'` and `$`.
-```
+```ebnf
 Environment   E  ::=  ()                empty
                       E, x: T
 
@@ -108,7 +108,7 @@ rule says that splice and quotes cancel each other out. The third rule
 is a context rule; it says that reduction is allowed in the hole `[ ]`
 position of an evaluation context.  Evaluation contexts `e` and
 splice evaluation context `e_s` are defined syntactically as follows:
-```
+```ebnf
 Eval context    e    ::=  [ ]  |  e t  |  v e  |  'e_s[${e}]
 Splice context  e_s  ::=  [ ]  |  (x: T) => e_s  |  e_s t  |  u e_s
 ```
diff --git a/docs/_docs/reference/metaprogramming/simple-smp.md b/docs/_docs/reference/metaprogramming/simple-smp.md
index 2ba0155ad329..61b062f55b87 100644
--- a/docs/_docs/reference/metaprogramming/simple-smp.md
+++ b/docs/_docs/reference/metaprogramming/simple-smp.md
@@ -23,7 +23,7 @@ replace evaluation contexts with contextual typing rules. While this
 is more verbose, it makes it easier to set up the meta theory.
 
 ## Syntax
-```
+```ebnf
 Terms         t  ::=  x                 variable
                       (x: T) => t       lambda
                       t t               application
diff --git a/docs/_docs/reference/new-types/dependent-function-types-spec.md b/docs/_docs/reference/new-types/dependent-function-types-spec.md
index f3237ddf7b9a..f603200b1ae0 100644
--- a/docs/_docs/reference/new-types/dependent-function-types-spec.md
+++ b/docs/_docs/reference/new-types/dependent-function-types-spec.md
@@ -8,7 +8,7 @@ Initial implementation in [PR #3464](https://github.com/lampepfl/dotty/pull/3464
 
 ## Syntax
 
-```
+```ebnf
 FunArgTypes       ::=  InfixType
                     |  ‘(’ [ FunArgType {',' FunArgType } ] ‘)’
                     |  ‘(’ TypedFunParam {',' TypedFunParam } ‘)’
diff --git a/docs/_docs/reference/new-types/intersection-types-spec.md b/docs/_docs/reference/new-types/intersection-types-spec.md
index 346c57c004f0..8d332fc6ed29 100644
--- a/docs/_docs/reference/new-types/intersection-types-spec.md
+++ b/docs/_docs/reference/new-types/intersection-types-spec.md
@@ -12,7 +12,7 @@ with the usual precedence and subject to usual resolving rules.
 Unless shadowed by another definition, it resolves to the type `scala.&`,
 which acts as a type alias to an internal representation of intersection types.
 
-```
+```ebnf
 Type              ::=  ...| InfixType
 InfixType         ::=  RefinedType {id [nl] RefinedType}
 ```
diff --git a/docs/_docs/reference/new-types/type-lambdas-spec.md b/docs/_docs/reference/new-types/type-lambdas-spec.md
index 76937e5160f7..7f7053a13ddd 100644
--- a/docs/_docs/reference/new-types/type-lambdas-spec.md
+++ b/docs/_docs/reference/new-types/type-lambdas-spec.md
@@ -6,7 +6,7 @@ nightlyOf: https://docs.scala-lang.org/scala3/reference/new-types/type-lambdas-s
 
 ## Syntax
 
-```
+```ebnf
 Type            ::=  ... |  TypeParamClause ‘=>>’ Type
 TypeParamClause ::=  ‘[’ TypeParam {‘,’ TypeParam} ‘]’
 TypeParam       ::=  {Annotation} (id [HkTypeParamClause] | ‘_’) TypeBounds
diff --git a/docs/_docs/reference/other-new-features/export.md b/docs/_docs/reference/other-new-features/export.md
index 41104a54e4a6..e8482cb343d9 100644
--- a/docs/_docs/reference/other-new-features/export.md
+++ b/docs/_docs/reference/other-new-features/export.md
@@ -176,7 +176,7 @@ extension (x: String)
 
 ## Syntax changes:
 
-```
+```ebnf
 TemplateStat      ::=  ...
                     |  Export
 TopStat           ::=  ...
diff --git a/docs/_docs/reference/other-new-features/indentation.md b/docs/_docs/reference/other-new-features/indentation.md
index 40e2fc6fb38c..f53bf0995727 100644
--- a/docs/_docs/reference/other-new-features/indentation.md
+++ b/docs/_docs/reference/other-new-features/indentation.md
@@ -174,12 +174,12 @@ The syntax changes allowing this are as follows:
 
 Define for an arbitrary sequence of tokens or non-terminals `TS`:
 
-```
+```ebnf
 :<<< TS >>>   ::=   ‘{’ TS ‘}’
                 |   <colon> <indent" TS <outdent>
 ```
 Then the grammar changes as follows:
-```
+```ebnf
 TemplateBody      ::=  :<<< [SelfType] TemplateStat {semi TemplateStat} >>>
 EnumBody          ::=  :<<< [SelfType] EnumStat {semi EnumStat} >>>
 Refinement        ::=  :<<< [RefineDcl] {semi [RefineDcl]} >>>
@@ -229,7 +229,7 @@ xs.foldLeft(0): (x, y) =>
 
 The grammar changes for optional braces around arguments are as follows.
 
-```
+```ebnf
 SimpleExpr       ::=  ...
                    |  SimpleExpr ColonArgument
 InfixExpr        ::=  ...
@@ -430,7 +430,7 @@ If none of these criteria apply, it's often better to not use an end marker sinc
 
 ### Syntax
 
-```
+```ebnf
 EndMarker         ::=  ‘end’ EndMarkerTag    -- when followed by EOL
 EndMarkerTag      ::=  id | ‘if’ | ‘while’ | ‘for’ | ‘match’ | ‘try’
                     |  ‘new’ | ‘this’ | ‘given’ | ‘extension’ | ‘val’
diff --git a/docs/_docs/reference/other-new-features/opaques-details.md b/docs/_docs/reference/other-new-features/opaques-details.md
index 87e56e240481..d285ec8e8325 100644
--- a/docs/_docs/reference/other-new-features/opaques-details.md
+++ b/docs/_docs/reference/other-new-features/opaques-details.md
@@ -6,7 +6,7 @@ nightlyOf: https://docs.scala-lang.org/scala3/reference/other-new-features/opaqu
 
 ## Syntax
 
-```
+```ebnf
 Modifier          ::=  ...
                     |  ‘opaque’
 ```

From 87f1e82d414e3a16fdc4f8623e25c31fa363e531 Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Wed, 12 Oct 2022 09:46:55 +0200
Subject: [PATCH 100/657] Copy Scala 2's Spec

Scala 2 Spec taken from https://github.com/scala/scala/commit/f15171599298d57618a53e6f4a9a8c26e2d139a3
---
 docs/_spec/01-lexical-syntax.md               |  652 ++++++
 docs/_spec/02-identifiers-names-and-scopes.md |  183 ++
 docs/_spec/03-types.md                        | 1078 ++++++++++
 .../04-basic-declarations-and-definitions.md  |  945 +++++++++
 docs/_spec/05-classes-and-objects.md          | 1160 +++++++++++
 docs/_spec/06-expressions.md                  | 1828 +++++++++++++++++
 docs/_spec/07-implicits.md                    |  525 +++++
 docs/_spec/08-pattern-matching.md             |  817 ++++++++
 docs/_spec/09-top-level-definitions.md        |  210 ++
 docs/_spec/10-xml-expressions-and-patterns.md |  145 ++
 docs/_spec/11-annotations.md                  |  176 ++
 docs/_spec/12-the-scala-standard-library.md   |  816 ++++++++
 docs/_spec/13-syntax-summary.md               |  330 +++
 docs/_spec/14-references.md                   |  207 ++
 docs/_spec/15-changelog.md                    |  847 ++++++++
 docs/_spec/README.md                          |   45 +
 docs/_spec/_config.yml                        |   11 +
 docs/_spec/_includes/numbering.css            |   60 +
 docs/_spec/_includes/table-of-contents.yml    |   23 +
 docs/_spec/_includes/version-notice.yml       |    3 +
 docs/_spec/_layouts/default.yml               |   51 +
 docs/_spec/_layouts/toc.yml                   |   34 +
 docs/_spec/id_dsa_travis.enc                  |   68 +
 docs/_spec/index.md                           |   55 +
 docs/_spec/public/favicon.ico                 |  Bin 0 -> 6518 bytes
 docs/_spec/public/fonts/Heuristica-Bold.woff  |  Bin 0 -> 106188 bytes
 .../public/fonts/Heuristica-BoldItalic.woff   |  Bin 0 -> 104316 bytes
 .../public/fonts/Heuristica-Regular.woff      |  Bin 0 -> 141416 bytes
 .../fonts/Heuristica-RegularItalic.woff       |  Bin 0 -> 104700 bytes
 docs/_spec/public/fonts/LuxiMono-Bold.woff    |  Bin 0 -> 26560 bytes
 .../public/fonts/LuxiMono-BoldOblique.woff    |  Bin 0 -> 29480 bytes
 docs/_spec/public/fonts/LuxiMono-Regular.woff |  Bin 0 -> 26432 bytes
 .../public/fonts/LuxiMono-RegularOblique.woff |  Bin 0 -> 29300 bytes
 docs/_spec/public/fonts/LuxiSans-Bold.woff    |  Bin 0 -> 13592 bytes
 docs/_spec/public/fonts/LuxiSans-Regular.woff |  Bin 0 -> 13568 bytes
 docs/_spec/public/images/classhierarchy.pdf   |  Bin 0 -> 84078 bytes
 docs/_spec/public/images/classhierarchy.png   |  Bin 0 -> 117555 bytes
 docs/_spec/public/images/github-logo@2x.png   |  Bin 0 -> 1753 bytes
 .../public/images/scala-spiral-white.png      |  Bin 0 -> 1442 bytes
 docs/_spec/public/octicons/LICENSE.txt        |    9 +
 docs/_spec/public/octicons/octicons.css       |  235 +++
 docs/_spec/public/octicons/octicons.eot       |  Bin 0 -> 31440 bytes
 docs/_spec/public/octicons/octicons.svg       |  198 ++
 docs/_spec/public/octicons/octicons.ttf       |  Bin 0 -> 31272 bytes
 docs/_spec/public/octicons/octicons.woff      |  Bin 0 -> 17492 bytes
 docs/_spec/public/scripts/LICENSE-highlight   |   24 +
 docs/_spec/public/scripts/LICENSE-toc         |   18 +
 docs/_spec/public/scripts/highlight.pack.js   |    1 +
 docs/_spec/public/scripts/main.js             |   71 +
 docs/_spec/public/scripts/toc.js              |  128 ++
 docs/_spec/public/stylesheets/fonts.css       |   73 +
 docs/_spec/public/stylesheets/print.css       |   42 +
 .../_spec/public/stylesheets/screen-small.css |   57 +
 docs/_spec/public/stylesheets/screen-toc.css  |   37 +
 docs/_spec/public/stylesheets/screen.css      |  521 +++++
 docs/_spec/spec-toc.xslt                      |   64 +
 56 files changed, 11747 insertions(+)
 create mode 100644 docs/_spec/01-lexical-syntax.md
 create mode 100644 docs/_spec/02-identifiers-names-and-scopes.md
 create mode 100644 docs/_spec/03-types.md
 create mode 100644 docs/_spec/04-basic-declarations-and-definitions.md
 create mode 100644 docs/_spec/05-classes-and-objects.md
 create mode 100644 docs/_spec/06-expressions.md
 create mode 100644 docs/_spec/07-implicits.md
 create mode 100644 docs/_spec/08-pattern-matching.md
 create mode 100644 docs/_spec/09-top-level-definitions.md
 create mode 100644 docs/_spec/10-xml-expressions-and-patterns.md
 create mode 100644 docs/_spec/11-annotations.md
 create mode 100644 docs/_spec/12-the-scala-standard-library.md
 create mode 100644 docs/_spec/13-syntax-summary.md
 create mode 100644 docs/_spec/14-references.md
 create mode 100644 docs/_spec/15-changelog.md
 create mode 100644 docs/_spec/README.md
 create mode 100644 docs/_spec/_config.yml
 create mode 100644 docs/_spec/_includes/numbering.css
 create mode 100644 docs/_spec/_includes/table-of-contents.yml
 create mode 100644 docs/_spec/_includes/version-notice.yml
 create mode 100644 docs/_spec/_layouts/default.yml
 create mode 100644 docs/_spec/_layouts/toc.yml
 create mode 100644 docs/_spec/id_dsa_travis.enc
 create mode 100644 docs/_spec/index.md
 create mode 100644 docs/_spec/public/favicon.ico
 create mode 100644 docs/_spec/public/fonts/Heuristica-Bold.woff
 create mode 100644 docs/_spec/public/fonts/Heuristica-BoldItalic.woff
 create mode 100644 docs/_spec/public/fonts/Heuristica-Regular.woff
 create mode 100644 docs/_spec/public/fonts/Heuristica-RegularItalic.woff
 create mode 100644 docs/_spec/public/fonts/LuxiMono-Bold.woff
 create mode 100644 docs/_spec/public/fonts/LuxiMono-BoldOblique.woff
 create mode 100644 docs/_spec/public/fonts/LuxiMono-Regular.woff
 create mode 100644 docs/_spec/public/fonts/LuxiMono-RegularOblique.woff
 create mode 100644 docs/_spec/public/fonts/LuxiSans-Bold.woff
 create mode 100644 docs/_spec/public/fonts/LuxiSans-Regular.woff
 create mode 100644 docs/_spec/public/images/classhierarchy.pdf
 create mode 100644 docs/_spec/public/images/classhierarchy.png
 create mode 100644 docs/_spec/public/images/github-logo@2x.png
 create mode 100644 docs/_spec/public/images/scala-spiral-white.png
 create mode 100644 docs/_spec/public/octicons/LICENSE.txt
 create mode 100644 docs/_spec/public/octicons/octicons.css
 create mode 100644 docs/_spec/public/octicons/octicons.eot
 create mode 100644 docs/_spec/public/octicons/octicons.svg
 create mode 100644 docs/_spec/public/octicons/octicons.ttf
 create mode 100644 docs/_spec/public/octicons/octicons.woff
 create mode 100644 docs/_spec/public/scripts/LICENSE-highlight
 create mode 100644 docs/_spec/public/scripts/LICENSE-toc
 create mode 100644 docs/_spec/public/scripts/highlight.pack.js
 create mode 100644 docs/_spec/public/scripts/main.js
 create mode 100644 docs/_spec/public/scripts/toc.js
 create mode 100644 docs/_spec/public/stylesheets/fonts.css
 create mode 100644 docs/_spec/public/stylesheets/print.css
 create mode 100644 docs/_spec/public/stylesheets/screen-small.css
 create mode 100644 docs/_spec/public/stylesheets/screen-toc.css
 create mode 100644 docs/_spec/public/stylesheets/screen.css
 create mode 100644 docs/_spec/spec-toc.xslt

diff --git a/docs/_spec/01-lexical-syntax.md b/docs/_spec/01-lexical-syntax.md
new file mode 100644
index 000000000000..921384b40e20
--- /dev/null
+++ b/docs/_spec/01-lexical-syntax.md
@@ -0,0 +1,652 @@
+---
+title: Lexical Syntax
+layout: default
+chapter: 1
+---
+
+# Lexical Syntax
+
+Scala source code consists of Unicode text.
+
+The program text is tokenized as described in this chapter.
+See the last section for special support for XML literals,
+which are parsed in _XML mode_.
+
+To construct tokens, characters are distinguished according to the following
+classes (Unicode general category given in parentheses):
+
+1. Whitespace characters. `\u0020 | \u0009 | \u000D | \u000A`.
+1. Letters, which include lower case letters (`Ll`), upper case letters (`Lu`),
+   title case letters (`Lt`), other letters (`Lo`), modifier letters (`Lm`), 
+   letter numerals (`Nl`) and the two characters `\u0024 ‘$’` and `\u005F ‘_’`.
+1. Digits `‘0’ | … | ‘9’`.
+1. Parentheses `‘(’ | ‘)’ | ‘[’ | ‘]’ | ‘{’ | ‘}’ `.
+1. Delimiter characters ``‘`’ | ‘'’ | ‘"’ | ‘.’ | ‘;’ | ‘,’ ``.
+1. Operator characters. These consist of all printable ASCII characters
+   (`\u0020` - `\u007E`) that are in none of the sets above, mathematical
+   symbols (`Sm`) and other symbols (`So`).
+
+## Identifiers
+
+```ebnf
+op       ::=  opchar {opchar}
+varid    ::=  lower idrest
+boundvarid ::=  varid
+             | ‘`’ varid ‘`’
+plainid  ::=  upper idrest
+           |  varid
+           |  op
+id       ::=  plainid
+           |  ‘`’ { charNoBackQuoteOrNewline | escapeSeq } ‘`’
+idrest   ::=  {letter | digit} [‘_’ op]
+escapeSeq     ::= UnicodeEscape | charEscapeSeq
+UnicodeEscape ::= ‘\’ ‘u’ {‘u’} hexDigit hexDigit hexDigit hexDigit
+hexDigit      ::= ‘0’ | … | ‘9’ | ‘A’ | … | ‘F’ | ‘a’ | … | ‘f’
+```
+
+There are three ways to form an identifier. First, an identifier can
+start with a letter, followed by an arbitrary sequence of
+letters and digits. This may be followed by underscore `‘_‘`
+characters and another string composed of either letters and digits or
+of operator characters.  Second, an identifier can start with an operator
+character followed by an arbitrary sequence of operator characters.
+The preceding two forms are called _plain_ identifiers.  Finally,
+an identifier may also be formed by an arbitrary string between
+backquotes (host systems may impose some restrictions on which
+strings are legal for identifiers).  The identifier then is composed
+of all characters excluding the backquotes themselves.
+
+As usual, the longest match rule applies. For instance, the string
+
+```scala
+big_bob++=`def`
+```
+
+decomposes into the three identifiers `big_bob`, `++=`, and
+`def`.
+
+The rules for pattern matching further distinguish between
+_variable identifiers_, which start with a lower case letter
+or `_`, and _constant identifiers_, which do not.
+
+For this purpose, lower case letters include not only a-z,
+but also all characters in Unicode category Ll (lowercase letter),
+as well as all letters that have contributory property
+Other_Lowercase, except characters in category Nl (letter numerals),
+which are never taken as lower case.
+
+The following are examples of variable identifiers:
+
+> ```scala
+>     x         maxIndex   p2p   empty_?
+>     `yield`   αρετη      _y    dot_product_*
+>     __system  _MAX_LEN_
+>     ªpple     ʰelper
+> ```
+
+Some examples of constant identifiers are
+
+> ```scala
+>     +    Object  $reserved  Džul    ǂnûm
+>     ⅰ_ⅲ  Ⅰ_Ⅲ     ↁelerious  ǃqhàà  ʹthatsaletter
+> ```
+
+The ‘$’ character is reserved for compiler-synthesized identifiers.
+User programs should not define identifiers that contain ‘$’ characters.
+
+The following names are reserved words instead of being members of the
+syntactic class `id` of lexical identifiers.
+
+```scala
+abstract    case        catch       class       def
+do          else        extends     false       final
+finally     for         forSome     if          implicit
+import      lazy        macro       match       new
+null        object      override    package     private
+protected   return      sealed      super       this
+throw       trait       try         true        type
+val         var         while       with        yield
+_    :    =    =>    <-    <:    <%     >:    #    @
+```
+
+The Unicode operators `\u21D2` ‘´\Rightarrow´’ and `\u2190` ‘´\leftarrow´’, which have the ASCII
+equivalents `=>` and `<-`, are also reserved.
+
+> Here are examples of identifiers:
+> ```scala
+>     x         Object        maxIndex   p2p      empty_?
+>     +         `yield`       αρετη     _y       dot_product_*
+>     __system  _MAX_LEN_
+> ```
+
+<!-- -->
+
+> When one needs to access Java identifiers that are reserved words in Scala, use backquote-enclosed strings.
+> For instance, the statement `Thread.yield()` is illegal, since `yield` is a reserved word in Scala.
+> However, here's a work-around: `` Thread.`yield`() ``
+
+## Newline Characters
+
+```ebnf
+semi ::= ‘;’ |  nl {nl}
+```
+
+Scala is a line-oriented language where statements may be terminated by
+semi-colons or newlines. A newline in a Scala source text is treated
+as the special token “nl” if the three following criteria are satisfied:
+
+1. The token immediately preceding the newline can terminate a statement.
+1. The token immediately following the newline can begin a statement.
+1. The token appears in a region where newlines are enabled.
+
+The tokens that can terminate a statement are: literals, identifiers
+and the following delimiters and reserved words:
+
+```scala
+this    null    true    false    return    type    <xml-start>
+_       )       ]       }
+```
+
+The tokens that can begin a statement are all Scala tokens _except_
+the following delimiters and reserved words:
+
+```scala
+catch    else    extends    finally    forSome    match
+with    yield    ,    .    ;    :    =    =>    <-    <:    <%
+>:    #    [    )    ]    }
+```
+
+A `case` token can begin a statement only if followed by a
+`class` or `object` token.
+
+Newlines are enabled in:
+
+1. all of a Scala source file, except for nested regions where newlines
+   are disabled, and
+1. the interval between matching `{` and `}` brace tokens,
+   except for nested regions where newlines are disabled.
+
+Newlines are disabled in:
+
+1. the interval between matching `(` and `)` parenthesis tokens, except for
+   nested regions where newlines are enabled, and
+1. the interval between matching `[` and `]` bracket tokens, except for nested
+   regions where newlines are enabled.
+1. The interval between a `case` token and its matching
+   `=>` token, except for nested regions where newlines are
+   enabled.
+1. Any regions analyzed in [XML mode](#xml-mode).
+
+Note that the brace characters of `{...}` escapes in XML and
+string literals are not tokens,
+and therefore do not enclose a region where newlines
+are enabled.
+
+Normally, only a single `nl` token is inserted between two
+consecutive non-newline tokens which are on different lines, even if there are multiple lines
+between the two tokens. However, if two tokens are separated by at
+least one completely blank line (i.e a line which contains no
+printable characters), then two `nl` tokens are inserted.
+
+The Scala grammar (given in full [here](13-syntax-summary.html))
+contains productions where optional `nl` tokens, but not
+semicolons, are accepted. This has the effect that a new line in one of these
+positions does not terminate an expression or statement. These positions can
+be summarized as follows:
+
+Multiple newline tokens are accepted in the following places (note
+that a semicolon in place of the newline would be illegal in every one
+of these cases):
+
+- between the condition of a
+  [conditional expression](06-expressions.html#conditional-expressions)
+  or [while loop](06-expressions.html#while-loop-expressions) and the next
+  following expression,
+- between the enumerators of a
+  [for-comprehension](06-expressions.html#for-comprehensions-and-for-loops)
+  and the next following expression, and
+- after the initial `type` keyword in a
+  [type definition or declaration](04-basic-declarations-and-definitions.html#type-declarations-and-type-aliases).
+
+A single new line token is accepted
+
+- in front of an opening brace ‘{’, if that brace is a legal
+  continuation of the current statement or expression,
+- after an [infix operator](06-expressions.html#prefix,-infix,-and-postfix-operations),
+  if the first token on the next line can start an expression,
+- in front of a [parameter clause](04-basic-declarations-and-definitions.html#function-declarations-and-definitions), and
+- after an [annotation](11-annotations.html#user-defined-annotations).
+
+> The newline tokens between the two lines are not
+> treated as statement separators.
+>
+> ```scala
+> if (x > 0)
+>   x = x - 1
+>
+> while (x > 0)
+>   x = x / 2
+>
+> for (x <- 1 to 10)
+>   println(x)
+>
+> type
+>   IntList = List[Int]
+> ```
+
+<!-- -->
+
+> ```scala
+> new Iterator[Int]
+> {
+>   private var x = 0
+>   def hasNext = true
+>   def next = { x += 1; x }
+> }
+> ```
+>
+> With an additional newline character, the same code is interpreted as
+> an object creation followed by a local block:
+>
+> ```scala
+> new Iterator[Int]
+>
+> {
+>   private var x = 0
+>   def hasNext = true
+>   def next = { x += 1; x }
+> }
+> ```
+
+<!-- -->
+
+> ```scala
+>   x < 0 ||
+>   x > 10
+> ```
+>
+> With an additional newline character, the same code is interpreted as
+> two expressions:
+>
+> ```scala
+>   x < 0 ||
+>
+>   x > 10
+> ```
+
+<!-- -->
+
+> ```scala
+> def func(x: Int)
+>         (y: Int) = x + y
+> ```
+>
+> With an additional newline character, the same code is interpreted as
+> an abstract function definition and a syntactically illegal statement:
+>
+> ```scala
+> def func(x: Int)
+>
+>         (y: Int) = x + y
+> ```
+
+<!-- -->
+
+> ```scala
+> @serializable
+> protected class Data { ... }
+> ```
+>
+> With an additional newline character, the same code is interpreted as
+> an attribute and a separate statement (which is syntactically illegal).
+>
+> ```scala
+> @serializable
+>
+> protected class Data { ... }
+> ```
+
+## Literals
+
+There are literals for integer numbers, floating point numbers,
+characters, booleans, symbols, strings.  The syntax of these literals is in
+each case as in Java.
+
+<!-- TODO
+  say that we take values from Java, give examples of some lits in
+  particular float and double.
+-->
+
+```ebnf
+Literal  ::=  [‘-’] integerLiteral
+           |  [‘-’] floatingPointLiteral
+           |  booleanLiteral
+           |  characterLiteral
+           |  stringLiteral
+           |  interpolatedString
+           |  symbolLiteral
+           |  ‘null’
+```
+
+### Integer Literals
+
+```ebnf
+integerLiteral  ::=  (decimalNumeral | hexNumeral)
+                       [‘L’ | ‘l’]
+decimalNumeral  ::=  digit {digit}
+hexNumeral      ::=  ‘0’ (‘x’ | ‘X’) hexDigit {hexDigit}
+```
+
+Values of type `Int` are all integer
+numbers between $-2\^{31}$ and $2\^{31}-1$, inclusive.  Values of
+type `Long` are all integer numbers between $-2\^{63}$ and
+$2\^{63}-1$, inclusive. A compile-time error occurs if an integer literal
+denotes a number outside these ranges.
+
+Integer literals are usually of type `Int`, or of type
+`Long` when followed by a `L` or `l` suffix.
+(Lowercase `l` is deprecated for reasons of legibility.)
+
+However, if the expected type [_pt_](06-expressions.html#expression-typing) of a literal
+in an expression is either `Byte`, `Short`, or `Char`
+and the integer number fits in the numeric range defined by the type,
+then the number is converted to type _pt_ and the literal's type
+is _pt_. The numeric ranges given by these types are:
+
+|                |                          |
+|----------------|--------------------------|
+|`Byte`          | ´-2\^7´ to ´2\^7-1´      |
+|`Short`         | ´-2\^{15}´ to ´2\^{15}-1´|
+|`Char`          | ´0´ to ´2\^{16}-1´       |
+
+The digits of a numeric literal may be separated by
+arbitrarily many underscores for purposes of legibility.
+
+> ```scala
+> 0           21_000      0x7F        -42L        0xFFFF_FFFF
+> ```
+
+### Floating Point Literals
+
+```ebnf
+floatingPointLiteral  ::=  digit {digit} ‘.’ digit {digit} [exponentPart] [floatType]
+                        |  ‘.’ digit {digit} [exponentPart] [floatType]
+                        |  digit {digit} exponentPart [floatType]
+                        |  digit {digit} [exponentPart] floatType
+exponentPart          ::=  (‘E’ | ‘e’) [‘+’ | ‘-’] digit {digit}
+floatType             ::=  ‘F’ | ‘f’ | ‘D’ | ‘d’
+```
+
+Floating point literals are of type `Float` when followed by
+a floating point type suffix `F` or `f`, and are
+of type `Double` otherwise.  The type `Float`
+consists of all IEEE 754 32-bit single-precision binary floating point
+values, whereas the type `Double` consists of all IEEE 754
+64-bit double-precision binary floating point values.
+
+If a floating point literal in a program is followed by a token
+starting with a letter, there must be at least one intervening
+whitespace character between the two tokens.
+
+> ```scala
+> 0.0        1e30f      3.14159f      1.0e-100      .1
+> ```
+
+<!-- -->
+
+> The phrase `1.toString` parses as three different tokens:
+> the integer literal `1`, a `.`, and the identifier `toString`.
+
+<!-- -->
+
+> `1.` is not a valid floating point literal because the mandatory digit after the `.` is missing.
+
+### Boolean Literals
+
+```ebnf
+booleanLiteral  ::=  ‘true’ | ‘false’
+```
+
+The boolean literals `true` and `false` are
+members of type `Boolean`.
+
+### Character Literals
+
+```ebnf
+characterLiteral  ::=  ‘'’ (charNoQuoteOrNewline | escapeSeq) ‘'’
+```
+
+A character literal is a single character enclosed in quotes.
+The character can be any Unicode character except the single quote
+delimiter or `\u000A` (LF) or `\u000D` (CR);
+or any Unicode character represented by an
+[escape sequence](#escape-sequences).
+
+> ```scala
+> 'a'    '\u0041'    '\n'    '\t'
+> ```
+
+### String Literals
+
+```ebnf
+stringLiteral  ::=  ‘"’ {stringElement} ‘"’
+stringElement  ::=  charNoDoubleQuoteOrNewline | escapeSeq
+```
+
+A string literal is a sequence of characters in double quotes.
+The characters can be any Unicode character except the double quote
+delimiter or `\u000A` (LF) or `\u000D` (CR);
+or any Unicode character represented by an [escape sequence](#escape-sequences).
+
+If the string literal contains a double quote character, it must be escaped using
+`"\""`.
+
+The value of a string literal is an instance of class `String`.
+
+> ```scala
+> "Hello, world!\n"
+> "\"Hello,\" replied the world."
+> ```
+
+#### Multi-Line String Literals
+
+```ebnf
+stringLiteral   ::=  ‘"""’ multiLineChars ‘"""’
+multiLineChars  ::=  {[‘"’] [‘"’] charNoDoubleQuote} {‘"’}
+```
+
+A multi-line string literal is a sequence of characters enclosed in
+triple quotes `""" ... """`. The sequence of characters is
+arbitrary, except that it may contain three or more consecutive quote characters
+only at the very end. Characters
+must not necessarily be printable; newlines or other
+control characters are also permitted. [Escape sequences](#escape-sequences) are
+not processed, except for Unicode escapes (this is deprecated since 2.13.2).
+
+> ```scala
+>   """the present string
+>      spans three
+>      lines."""
+> ```
+>
+> This would produce the string:
+>
+> ```scala
+> the present string
+>      spans three
+>      lines.
+> ```
+>
+> The Scala library contains a utility method `stripMargin`
+> which can be used to strip leading whitespace from multi-line strings.
+> The expression
+>
+> ```scala
+>  """the present string
+>    |spans three
+>    |lines.""".stripMargin
+> ```
+>
+> evaluates to
+>
+> ```scala
+> the present string
+> spans three
+> lines.
+> ```
+>
+> Method `stripMargin` is defined in class
+> [scala.collection.StringOps](https://www.scala-lang.org/api/current/scala/collection/StringOps.html#stripMargin:String).
+
+#### Interpolated string
+
+```ebnf
+interpolatedString     ::= alphaid ‘"’ {[‘\’] interpolatedStringPart | ‘\\’ | ‘\"’} ‘"’
+                         | alphaid ‘"""’ {[‘"’] [‘"’] char \ (‘"’ | ‘$’) | escape} {‘"’} ‘"""’
+interpolatedStringPart ::= printableChar \ (‘"’ | ‘$’ | ‘\’) | escape
+escape                 ::= ‘$$’
+                         | ‘$"’
+                         | ‘$’ alphaid
+                         | ‘$’ BlockExpr
+alphaid                ::= upper idrest
+                         |  varid
+
+```
+
+An interpolated string consists of an identifier starting with a letter immediately
+followed by a string literal. There may be no whitespace characters or comments 
+between the leading identifier and the opening quote `"` of the string.
+The string literal in an interpolated string can be standard (single quote)
+or multi-line (triple quote).
+
+Inside an interpolated string none of the usual escape characters are interpreted
+no matter whether the string literal is normal (enclosed in single quotes) or
+multi-line (enclosed in triple quotes). Note that the sequence `\"` does not
+close a normal string literal (enclosed in single quotes).
+
+There are three forms of dollar sign escape.
+The most general form encloses an expression in `${` and `}`, i.e. `${expr}`. 
+The expression enclosed in the braces that follow the leading `$` character is of 
+syntactical category BlockExpr. Hence, it can contain multiple statements, 
+and newlines are significant. Single ‘$’-signs are not permitted in isolation 
+in an interpolated string. A single ‘$’-sign can still be obtained by doubling the ‘$’
+character: ‘$$’. A single ‘"’-sign can be obtained by the sequence ‘\$"’.
+
+The simpler form consists of a ‘$’-sign followed by an identifier starting with 
+a letter and followed only by letters, digits, and underscore characters, e.g., `$id`.
+The simpler form is expanded by putting braces around the identifier,
+e.g., `$id` is equivalent to `${id}`. In the following, unless we explicitly state otherwise,
+we assume that this expansion has already been performed.
+
+The expanded expression is type checked normally. Usually, `StringContext` will resolve to 
+the default implementation in the scala package, 
+but it could also be user-defined. Note that new interpolators can also be added through 
+implicit conversion of the built-in `scala.StringContext`.
+
+One could write an extension
+```scala
+implicit class StringInterpolation(s: StringContext) {
+  def id(args: Any*) = ???
+}
+```
+
+### Escape Sequences
+
+The following character escape sequences are recognized in character and string literals.
+
+| charEscapeSeq | unicode  | name            | char   |
+|---------------|----------|-----------------|--------|
+| `‘\‘ ‘b‘`     | `\u0008` | backspace       |  `BS`  |
+| `‘\‘ ‘t‘`     | `\u0009` | horizontal tab  |  `HT`  |
+| `‘\‘ ‘n‘`     | `\u000a` | linefeed        |  `LF`  |
+| `‘\‘ ‘f‘`     | `\u000c` | form feed       |  `FF`  |
+| `‘\‘ ‘r‘`     | `\u000d` | carriage return |  `CR`  |
+| `‘\‘ ‘"‘`     | `\u0022` | double quote    |  `"`   |
+| `‘\‘ ‘'‘`     | `\u0027` | single quote    |  `'`   |
+| `‘\‘ ‘\‘`     | `\u005c` | backslash       |  `\`   |
+
+In addition, Unicode escape sequences of the form `\uxxxx`, where each `x` is a hex digit are
+recognized in character and string literals.
+
+It is a compile time error if a backslash character in a character or
+string literal does not start a valid escape sequence.
+
+### Symbol literals
+
+```ebnf
+symbolLiteral  ::=  ‘'’ plainid
+```
+
+A symbol literal `'x` is deprecated shorthand for the expression `scala.Symbol("x")`.
+
+The `apply` method of `Symbol`'s companion object
+caches weak references to `Symbol`s, thus ensuring that
+identical symbol literals are equivalent with respect to reference
+equality.
+
+## Whitespace and Comments
+
+Tokens may be separated by whitespace characters
+and/or comments. Comments come in two forms:
+
+A single-line comment is a sequence of characters which starts with
+`//` and extends to the end of the line.
+
+A multi-line comment is a sequence of characters between
+`/*` and `*/`. Multi-line comments may be nested,
+but are required to be properly nested.  Therefore, a comment like
+`/* /* */` will be rejected as having an unterminated
+comment.
+
+## Trailing Commas in Multi-line Expressions
+
+If a comma (`,`) is followed immediately, ignoring whitespace, by a newline and
+a closing parenthesis (`)`), bracket (`]`), or brace (`}`), then the comma is
+treated as a "trailing comma" and is ignored. For example:
+
+```scala
+foo(
+  23,
+  "bar",
+  true,
+)
+```
+
+## XML mode
+
+In order to allow literal inclusion of XML fragments, lexical analysis
+switches from Scala mode to XML mode when encountering an opening
+angle bracket ‘<’ in the following circumstance: The ‘<’ must be
+preceded either by whitespace, an opening parenthesis or an opening
+brace and immediately followed by a character starting an XML name.
+
+```ebnf
+ ( whitespace | ‘(’ | ‘{’ ) ‘<’ (XNameStart | ‘!’ | ‘?’)
+
+  XNameStart ::= ‘_’ | BaseChar | Ideographic // as in W3C XML, but without ‘:’
+```
+
+The scanner switches from XML mode to Scala mode if either
+
+- the XML expression or the XML pattern started by the initial ‘<’ has been
+  successfully parsed, or if
+- the parser encounters an embedded Scala expression or pattern and
+  forces the Scanner
+  back to normal mode, until the Scala expression or pattern is
+  successfully parsed. In this case, since code and XML fragments can be
+  nested, the parser has to maintain a stack that reflects the nesting
+  of XML and Scala expressions adequately.
+
+Note that no Scala tokens are constructed in XML mode, and that comments are interpreted
+as text.
+
+> The following value definition uses an XML literal with two embedded
+> Scala expressions:
+>
+> ```scala
+> val b = <book>
+>           <title>The Scala Language Specification</title>
+>           <version>{scalaBook.version}</version>
+>           <authors>{scalaBook.authors.mkList("", ", ", "")}</authors>
+>         </book>
+> ```
diff --git a/docs/_spec/02-identifiers-names-and-scopes.md b/docs/_spec/02-identifiers-names-and-scopes.md
new file mode 100644
index 000000000000..b8bde8cfd1a9
--- /dev/null
+++ b/docs/_spec/02-identifiers-names-and-scopes.md
@@ -0,0 +1,183 @@
+---
+title: Identifiers, Names & Scopes
+layout: default
+chapter: 2
+---
+
+# Identifiers, Names and Scopes
+
+Names in Scala identify types, values, methods, and classes which are
+collectively called _entities_. Names are introduced by local
+[definitions and declarations](04-basic-declarations-and-definitions.html#basic-declarations-and-definitions),
+[inheritance](05-classes-and-objects.html#class-members),
+[import clauses](04-basic-declarations-and-definitions.html#import-clauses), or
+[package clauses](09-top-level-definitions.html#packagings)
+which are collectively called _bindings_.
+
+Bindings of different kinds have precedence defined on them:
+
+1. Definitions and declarations that are local, inherited, or made
+   available by a package clause and also defined in the same compilation unit
+   as the reference to them, have the highest precedence.
+1. Explicit imports have the next highest precedence.
+1. Wildcard imports have the next highest precedence.
+1. Definitions made available by a package clause, but not also defined in the
+   same compilation unit as the reference to them, as well as imports which
+   are supplied by the compiler but not explicitly written in source code,
+   have the lowest precedence.
+
+There are two different name spaces, one for [types](03-types.html#types)
+and one for [terms](06-expressions.html#expressions). The same name may designate a
+type and a term, depending on the context where the name is used.
+
+A binding has a _scope_ in which the entity defined by a single
+name can be accessed using a simple name. Scopes are nested.  A binding
+in some inner scope _shadows_ bindings of lower precedence in the
+same scope as well as bindings of the same or lower precedence in outer
+scopes.
+
+Note that shadowing is only a partial order. In the following example,
+neither binding of `x` shadows the other. Consequently, the
+reference to `x` in the last line of the block is ambiguous.
+
+```scala
+val x = 1
+locally {
+  import p.X.x
+  x
+}
+```
+
+A reference to an unqualified (type- or term-) identifier ´x´ is bound
+by the unique binding, which
+
+- defines an entity with name ´x´ in the same namespace as the identifier, and
+- shadows all other bindings that define entities with name ´x´ in that
+  namespace.
+
+It is an error if no such binding exists.  If ´x´ is bound by an
+import clause, then the simple name ´x´ is taken to be equivalent to
+the qualified name to which ´x´ is mapped by the import clause. If ´x´
+is bound by a definition or declaration, then ´x´ refers to the entity
+introduced by that binding. In that case, the type of ´x´ is the type
+of the referenced entity.
+
+A reference to a qualified (type- or term-) identifier ´e.x´ refers to
+the member of the type ´T´ of ´e´ which has the name ´x´ in the same
+namespace as the identifier. It is an error if ´T´ is not a [value type](03-types.html#value-types).
+The type of ´e.x´ is the member type of the referenced entity in ´T´.
+
+Binding precedence implies that the way source is bundled in files affects name resolution.
+In particular, imported names have higher precedence than names, defined in other files,
+that might otherwise be visible because they are defined in
+either the current package or an enclosing package.
+
+Note that a package definition is taken as lowest precedence, since packages
+are open and can be defined across arbitrary compilation units.
+
+```scala
+package util {
+  import scala.util
+  class Random
+  object Test extends App {
+    println(new util.Random)  // scala.util.Random
+  }
+}
+```
+
+The compiler supplies imports in a preamble to every source file. This preamble
+conceptually has the following form, where braces indicate nested scopes:
+
+```scala
+import java.lang._
+{
+  import scala._
+  {
+    import Predef._
+    { /* source */ }
+  }
+}
+```
+
+These imports are taken as lowest precedence, so that they are always shadowed
+by user code, which may contain competing imports and definitions.
+They also increase the nesting depth as shown, so that later imports
+shadow earlier ones.
+
+As a convenience, multiple bindings of a type identifier to the same
+underlying type is permitted. This is possible when import clauses introduce
+a binding of a member type alias with the same binding precedence, typically
+through wildcard imports. This allows redundant type aliases to be imported
+without introducing an ambiguity.
+
+```scala
+object X { type T = annotation.tailrec }
+object Y { type T = annotation.tailrec }
+object Z {
+  import X._, Y._, annotation.{tailrec => T}  // OK, all T mean tailrec
+  @T def f: Int = { f ; 42 }                  // error, f is not tail recursive
+}
+```
+
+Similarly, imported aliases of names introduced by package statements are
+allowed, even though the names are strictly ambiguous:
+
+```scala
+// c.scala
+package p { class C }
+
+// xy.scala
+import p._
+package p { class X extends C }
+package q { class Y extends C }
+```
+
+The reference to `C` in the definition of `X` is strictly ambiguous
+because `C` is available by virtue of the package clause in
+a different file, and can't shadow the imported name. But because
+the references are the same, the definition is taken as though it
+did shadow the import.
+
+###### Example
+
+Assume the following two definitions of objects named `X` in packages `p` and `q`
+in separate compilation units.
+
+```scala
+package p {
+  object X { val x = 1; val y = 2 }
+}
+
+package q {
+  object X { val x = true; val y = false }
+}
+```
+
+The following program illustrates different kinds of bindings and
+precedences between them.
+
+```scala
+package p {                   // `X' bound by package clause
+import Console._              // `println' bound by wildcard import
+object Y {
+  println(s"L4: $X")          // `X' refers to `p.X' here
+  locally {
+    import q._                // `X' bound by wildcard import
+    println(s"L7: $X")        // `X' refers to `q.X' here
+    import X._                // `x' and `y' bound by wildcard import
+    println(s"L9: $x")        // `x' refers to `q.X.x' here
+    locally {
+      val x = 3               // `x' bound by local definition
+      println(s"L12: $x")     // `x' refers to constant `3' here
+      locally {
+        import q.X._          // `x' and `y' bound by wildcard import
+//      println(s"L15: $x")   // reference to `x' is ambiguous here
+        import X.y            // `y' bound by explicit import
+        println(s"L17: $y")   // `y' refers to `q.X.y' here
+        locally {
+          val x = "abc"       // `x' bound by local definition
+          import p.X._        // `x' and `y' bound by wildcard import
+//        println(s"L21: $y") // reference to `y' is ambiguous here
+          println(s"L22: $x") // `x' refers to string "abc" here
+}}}}}}
+```
diff --git a/docs/_spec/03-types.md b/docs/_spec/03-types.md
new file mode 100644
index 000000000000..3c78b33e571c
--- /dev/null
+++ b/docs/_spec/03-types.md
@@ -0,0 +1,1078 @@
+---
+title: Types
+layout: default
+chapter: 3
+---
+
+# Types
+
+```ebnf
+  Type              ::=  FunctionArgTypes ‘=>’ Type
+                      |  InfixType [ExistentialClause]
+  FunctionArgTypes  ::=  InfixType
+                      |  ‘(’ [ ParamType {‘,’ ParamType } ] ‘)’
+  ExistentialClause ::=  ‘forSome’ ‘{’ ExistentialDcl
+                             {semi ExistentialDcl} ‘}’
+  ExistentialDcl    ::=  ‘type’ TypeDcl
+                      |  ‘val’ ValDcl
+  InfixType         ::=  CompoundType {id [nl] CompoundType}
+  CompoundType      ::=  AnnotType {‘with’ AnnotType} [Refinement]
+                      |  Refinement
+  AnnotType         ::=  SimpleType {Annotation}
+  SimpleType        ::=  SimpleType TypeArgs
+                      |  SimpleType ‘#’ id
+                      |  StableId
+                      |  Path ‘.’ ‘type’
+                      |  Literal
+                      |  ‘(’ Types ‘)’
+  TypeArgs          ::=  ‘[’ Types ‘]’
+  Types             ::=  Type {‘,’ Type}
+```
+
+We distinguish between proper types and type constructors, which
+take type parameters and yield types. A subset of proper types
+called _value types_ represents sets of (first-class) values.
+Value types are either _concrete_ or _abstract_.
+
+Every concrete value type can be represented as a _class type_, i.e. a
+[type designator](#type-designators) that refers to a
+[class or a trait](05-classes-and-objects.html#class-definitions) [^1], or as a
+[compound type](#compound-types) representing an
+intersection of types, possibly with a [refinement](#compound-types)
+that further constrains the types of its members.
+<!--
+A shorthand exists for denoting [function types](#function-types)
+-->
+Abstract value types are introduced by [type parameters](04-basic-declarations-and-definitions.html#type-parameters)
+and [abstract type bindings](04-basic-declarations-and-definitions.html#type-declarations-and-type-aliases).
+Parentheses in types can be used for grouping.
+
+[^1]: We assume that objects and packages also implicitly
+      define a class (of the same name as the object or package, but
+      inaccessible to user programs).
+
+Non-value types capture properties of identifiers that
+[are not values](#non-value-types). For example, a
+[type constructor](#type-constructors) does not directly specify a type of
+values. However, when a type constructor is applied to the correct type
+arguments, it yields a proper type, which may be a value type.
+
+Non-value types are expressed indirectly in Scala. E.g., a method type is
+described by writing down a method signature, which in itself is not a real
+type, although it  gives rise to a corresponding [method type](#method-types).
+Type constructors are another example, as one can write
+`type Swap[m[_, _], a,b] = m[b, a]`, but there is no syntax to write
+the corresponding anonymous type function directly.
+
+## Paths
+
+```ebnf
+Path            ::=  StableId
+                  |  [id ‘.’] this
+StableId        ::=  id
+                  |  Path ‘.’ id
+                  |  [id ‘.’] ‘super’ [ClassQualifier] ‘.’ id
+ClassQualifier  ::= ‘[’ id ‘]’
+```
+
+Paths are not types themselves, but they can be a part of named types
+and in that function form a central role in Scala's type system.
+
+A path is one of the following.
+
+- The empty path ε (which cannot be written explicitly in user programs).
+- ´C.´`this`, where ´C´ references a class.
+  The path `this` is taken as a shorthand for ´C.´`this` where
+  ´C´ is the name of the class directly enclosing the reference.
+- ´p.x´ where ´p´ is a path and ´x´ is a stable member of ´p´.
+  _Stable members_ are packages or members introduced by object definitions or
+  by value definitions of [non-volatile types](#volatile-types).
+- ´C.´`super`´.x´ or ´C.´`super`´[M].x´
+  where ´C´ references a class and ´x´ references a
+  stable member of the super class or designated parent class ´M´ of ´C´.
+  The prefix `super` is taken as a shorthand for ´C.´`super` where
+  ´C´ is the name of the class directly enclosing the reference.
+
+A _stable identifier_ is a path which ends in an identifier.
+
+## Value Types
+
+Every value in Scala has a type which is of one of the following
+forms.
+
+### Singleton Types
+
+```ebnf
+SimpleType  ::=  Path ‘.’ ‘type’
+```
+
+A _singleton type_ is of the form ´p.´`type`. Where ´p´ is a path pointing to a
+value which [conforms](06-expressions.html#expression-typing) to
+`scala.AnyRef`, the type denotes the set of values consisting of `null` and the
+value denoted by ´p´ (i.e., the value ´v´ for which `v eq p`). Where the path
+does not conform to `scala.AnyRef` the type denotes the set consisting of only
+the value denoted by ´p´.
+
+<!-- a pattern match/type test against a singleton type `p.type` desugars to `_ eq p` -->
+
+### Literal Types
+
+```ebnf
+SimpleType  ::=  Literal
+```
+
+A literal type `lit` is a special kind of singleton type which denotes the
+single literal value `lit`.  Thus, the type ascription `1: 1` gives the most
+precise type to the literal value `1`:  the literal type `1`.
+
+At run time, an expression `e` is considered to have literal type `lit` if `e == lit`.
+Concretely, the result of `e.isInstanceOf[lit]` and `e match { case _ : lit => }` is
+determined by evaluating `e == lit`.
+
+Literal types are available for all types for which there is dedicated syntax
+except `Unit`. This includes the numeric types (other than `Byte` and `Short`
+which don't currently have syntax), `Boolean`, `Char` and `String`.
+
+### Stable Types
+A _stable type_ is a singleton type, a literal type,
+or a type that is declared to be a subtype of trait `scala.Singleton`.
+
+### Type Projection
+
+```ebnf
+SimpleType  ::=  SimpleType ‘#’ id
+```
+
+A _type projection_ ´T´#´x´ references the type member named
+´x´ of type ´T´.
+
+<!--
+The following is no longer necessary:
+If ´x´ references an abstract type member, then ´T´ must be a
+[stable type](#singleton-types)
+-->
+
+### Type Designators
+
+```ebnf
+SimpleType  ::=  StableId
+```
+
+A _type designator_ refers to a named value type. It can be simple or
+qualified. All such type designators are shorthands for type projections.
+
+Specifically, the unqualified type name ´t´ where ´t´ is bound in some
+class, object, or package ´C´ is taken as a shorthand for
+´C.´`this.type#`´t´. If ´t´ is
+not bound in a class, object, or package, then ´t´ is taken as a
+shorthand for ε`.type#`´t´.
+
+A qualified type designator has the form `p.t` where `p` is
+a [path](#paths) and _t_ is a type name. Such a type designator is
+equivalent to the type projection `p.type#t`.
+
+###### Example
+
+Some type designators and their expansions are listed below. We assume
+a local type parameter ´t´, a value `maintable`
+with a type member `Node` and the standard class `scala.Int`,
+
+| Designator          | Expansion                 |
+|-------------------- | --------------------------|
+|t                    | ε.type#t                  |
+|Int                  | scala.type#Int            |
+|scala.Int            | scala.type#Int            |
+|data.maintable.Node  | data.maintable.type#Node  |
+
+### Parameterized Types
+
+```ebnf
+SimpleType      ::=  SimpleType TypeArgs
+TypeArgs        ::=  ‘[’ Types ‘]’
+```
+
+A _parameterized type_ ´T[ T_1 , \ldots , T_n ]´ consists of a type
+designator ´T´ and type parameters ´T_1 , \ldots , T_n´ where
+´n \geq 1´. ´T´ must refer to a type constructor which takes ´n´ type
+parameters ´a_1 , \ldots , a_n´.
+
+Say the type parameters have lower bounds ´L_1 , \ldots , L_n´ and
+upper bounds ´U_1, \ldots, U_n´.  The parameterized type is
+well-formed if each actual type parameter
+_conforms to its bounds_, i.e. ´\sigma L_i <: T_i <: \sigma U_i´ where ´\sigma´ is the
+substitution ´[ a_1 := T_1 , \ldots , a_n := T_n ]´.
+
+###### Example Parameterized Types
+
+Given the partial type definitions:
+
+```scala
+class TreeMap[A <: Comparable[A], B] { … }
+class List[A] { … }
+class I extends Comparable[I] { … }
+
+class F[M[_], X] { … }
+class S[K <: String] { … }
+class G[M[ Z <: I ], I] { … }
+```
+
+the following parameterized types are well-formed:
+
+```scala
+TreeMap[I, String]
+List[I]
+List[List[Boolean]]
+
+F[List, Int]
+G[S, String]
+```
+
+###### Example
+
+Given the [above type definitions](#example-parameterized-types),
+the following types are ill-formed:
+
+```scala
+TreeMap[I]            // illegal: wrong number of parameters
+TreeMap[List[I], Int] // illegal: type parameter not within bound
+
+F[Int, Boolean]       // illegal: Int is not a type constructor
+F[TreeMap, Int]       // illegal: TreeMap takes two parameters,
+                      //   F expects a constructor taking one
+G[S, Int]             // illegal: S constrains its parameter to
+                      //   conform to String,
+                      // G expects type constructor with a parameter
+                      //   that conforms to Int
+```
+
+### Tuple Types
+
+```ebnf
+SimpleType    ::=   ‘(’ Types ‘)’
+```
+
+A _tuple type_ ´(T_1 , \ldots , T_n)´ is an alias for the
+class `scala.Tuple´n´[´T_1´, … , ´T_n´]`, where ´n \geq 2´.
+
+Tuple classes are case classes whose fields can be accessed using
+selectors `_1` , … , `_n`. Their functionality is
+abstracted in a corresponding `Product` trait. The _n_-ary tuple
+class and product trait are defined at least as follows in the
+standard Scala library (they might also add other methods and
+implement other traits).
+
+```scala
+case class Tuple´_n´[+´T_1´, … , +´T_n´](_1: ´T_1´, … , _n: ´T_n´)
+extends Product´_n´[´T_1´, … , ´T_n´]
+
+trait Product´_n´[+´T_1´, … , +´T_n´] {
+  override def productArity = ´n´
+  def _1: ´T_1´
+  …
+  def _n: ´T_n´
+}
+```
+
+### Annotated Types
+
+```ebnf
+AnnotType  ::=  SimpleType {Annotation}
+```
+
+An _annotated type_ ´T´ ´a_1, \ldots, a_n´
+attaches [annotations](11-annotations.html#user-defined-annotations)
+´a_1 , \ldots , a_n´ to the type ´T´.
+
+###### Example
+
+The following type adds the `@suspendable` annotation to the type `String`:
+
+```scala
+String @suspendable
+```
+
+### Compound Types
+
+```ebnf
+CompoundType    ::=  AnnotType {‘with’ AnnotType} [Refinement]
+                  |  Refinement
+Refinement      ::=  [nl] ‘{’ RefineStat {semi RefineStat} ‘}’
+RefineStat      ::=  Dcl
+                  |  ‘type’ TypeDef
+                  |
+```
+
+A _compound type_ ´T_1´ `with` … `with` ´T_n \\{ R \\}´
+represents objects with members as given in the component types
+´T_1 , \ldots , T_n´ and the refinement ´\\{ R \\}´. A refinement
+´\\{ R \\}´ contains declarations and type definitions.
+If a declaration or definition overrides a declaration or definition in
+one of the component types ´T_1 , \ldots , T_n´, the usual rules for
+[overriding](05-classes-and-objects.html#overriding) apply; otherwise the declaration
+or definition is said to be “structural” [^2].
+
+[^2]: A reference to a structurally defined member (method call or access
+      to a value or variable) may generate binary code that is significantly
+      slower than an equivalent code to a non-structural member.
+
+Within a method declaration in a structural refinement, the type of
+any value parameter may only refer to type parameters or abstract
+types that are contained inside the refinement. That is, it must refer
+either to a type parameter of the method itself, or to a type
+definition within the refinement. This restriction does not apply to
+the method's result type.
+
+If no refinement is given, the empty refinement is implicitly added,
+i.e. ´T_1´ `with` … `with` ´T_n´ is a shorthand for ´T_1´ `with` … `with` ´T_n \\{\\}´.
+
+A compound type may also consist of just a refinement
+´\\{ R \\}´ with no preceding component types. Such a type is
+equivalent to `AnyRef` ´\\{ R \\}´.
+
+###### Example
+
+The following example shows how to declare and use a method which has
+a parameter type that contains a refinement with structural declarations.
+
+```scala
+case class Bird (val name: String) extends Object {
+        def fly(height: Int) = …
+…
+}
+case class Plane (val callsign: String) extends Object {
+        def fly(height: Int) = …
+…
+}
+def takeoff(
+            runway: Int,
+      r: { val callsign: String; def fly(height: Int) }) = {
+  tower.print(r.callsign + " requests take-off on runway " + runway)
+  tower.read(r.callsign + " is clear for take-off")
+  r.fly(1000)
+}
+val bird = new Bird("Polly the parrot"){ val callsign = name }
+val a380 = new Plane("TZ-987")
+takeoff(42, bird)
+takeoff(89, a380)
+```
+
+Although `Bird` and `Plane` do not share any parent class other than
+`Object`, the parameter _r_ of method `takeoff` is defined using a
+refinement with structural declarations to accept any object that declares
+a value `callsign` and a `fly` method.
+
+### Infix Types
+
+```ebnf
+InfixType     ::=  CompoundType {id [nl] CompoundType}
+```
+
+An _infix type_ ´T_1´ `op` ´T_2´ consists of an infix
+operator `op` which gets applied to two type operands ´T_1´ and
+´T_2´.  The type is equivalent to the type application
+`op`´[T_1, T_2]´.  The infix operator `op` may be an
+arbitrary identifier.
+
+All type infix operators have the same precedence; parentheses have to
+be used for grouping. The [associativity](06-expressions.html#prefix,-infix,-and-postfix-operations)
+of a type operator is determined as for term operators: type operators
+ending in a colon ‘:’ are right-associative; all other
+operators are left-associative.
+
+In a sequence of consecutive type infix operations
+´t_0 \, \mathit{op} \, t_1 \, \mathit{op_2} \, \ldots \, \mathit{op_n} \, t_n´,
+all operators ´\mathit{op}\_1 , \ldots , \mathit{op}\_n´ must have the same
+associativity. If they are all left-associative, the sequence is
+interpreted as
+´(\ldots (t_0 \mathit{op_1} t_1) \mathit{op_2} \ldots) \mathit{op_n} t_n´,
+otherwise it is interpreted as
+´t_0 \mathit{op_1} (t_1 \mathit{op_2} ( \ldots \mathit{op_n} t_n) \ldots)´.
+
+### Function Types
+
+```ebnf
+Type              ::=  FunctionArgs ‘=>’ Type
+FunctionArgs      ::=  InfixType
+                    |  ‘(’ [ ParamType {‘,’ ParamType } ] ‘)’
+```
+
+The type ´(T_1 , \ldots , T_n) \Rightarrow U´ represents the set of function
+values that take arguments of types ´T_1 , \ldots , Tn´ and yield
+results of type ´U´.  In the case of exactly one argument type
+´T \Rightarrow U´ is a shorthand for ´(T) \Rightarrow U´.
+An argument type of the form ´\Rightarrow T´
+represents a [call-by-name parameter](04-basic-declarations-and-definitions.html#by-name-parameters) of type ´T´.
+
+Function types associate to the right, e.g.
+´S \Rightarrow T \Rightarrow U´ is the same as
+´S \Rightarrow (T \Rightarrow U)´.
+
+Function types are shorthands for class types that define `apply`
+functions.  Specifically, the ´n´-ary function type
+´(T_1 , \ldots , T_n) \Rightarrow U´ is a shorthand for the class type
+`Function´_n´[´T_1´ , … , ´T_n´, ´U´]`. Such class
+types are defined in the Scala library for ´n´ between 0 and 22 as follows.
+
+```scala
+package scala
+trait Function´_n´[-´T_1´ , … , -´T_n´, +´U´] {
+  def apply(´x_1´: ´T_1´ , … , ´x_n´: ´T_n´): ´U´
+  override def toString = "<function>"
+}
+```
+
+Hence, function types are [covariant](04-basic-declarations-and-definitions.html#variance-annotations) in their
+result type and contravariant in their argument types.
+
+### Existential Types
+
+```ebnf
+Type               ::= InfixType ExistentialClauses
+ExistentialClauses ::= ‘forSome’ ‘{’ ExistentialDcl
+                       {semi ExistentialDcl} ‘}’
+ExistentialDcl     ::= ‘type’ TypeDcl
+                    |  ‘val’ ValDcl
+```
+
+An _existential type_ has the form `´T´ forSome { ´Q´ }`
+where ´Q´ is a sequence of
+[type declarations](04-basic-declarations-and-definitions.html#type-declarations-and-type-aliases).
+
+Let
+´t_1[\mathit{tps}\_1] >: L_1 <: U_1 , \ldots , t_n[\mathit{tps}\_n] >: L_n <: U_n´
+be the types declared in ´Q´ (any of the
+type parameter sections `[ ´\mathit{tps}_i´ ]` might be missing).
+The scope of each type ´t_i´ includes the type ´T´ and the existential clause
+´Q´.
+The type variables ´t_i´ are said to be _bound_ in the type
+`´T´ forSome { ´Q´ }`.
+Type variables which occur in a type ´T´ but which are not bound in ´T´ are said
+to be _free_ in ´T´.
+
+A _type instance_ of `´T´ forSome { ´Q´ }`
+is a type ´\sigma T´ where ´\sigma´ is a substitution over ´t_1 , \ldots , t_n´
+such that, for each ´i´, ´\sigma L_i <: \sigma t_i <: \sigma U_i´.
+The set of values denoted by the existential type `´T´ forSome {´\,Q\,´}`
+is the union of the set of values of all its type instances.
+
+A _skolemization_ of `´T´ forSome { ´Q´ }` is
+a type instance ´\sigma T´, where ´\sigma´ is the substitution
+´[t_1'/t_1 , \ldots , t_n'/t_n]´ and each ´t_i'´ is a fresh abstract type
+with lower bound ´\sigma L_i´ and upper bound ´\sigma U_i´.
+
+#### Simplification Rules
+
+Existential types obey the following four equivalences:
+
+1. Multiple for-clauses in an existential type can be merged. E.g.,
+`´T´ forSome { ´Q´ } forSome { ´Q'´ }`
+is equivalent to
+`´T´ forSome { ´Q´ ; ´Q'´}`.
+1. Unused quantifications can be dropped. E.g.,
+`´T´ forSome { ´Q´ ; ´Q'´}`
+where none of the types defined in ´Q'´ are referred to by ´T´ or ´Q´,
+is equivalent to
+`´T´ forSome {´ Q ´}`.
+1. An empty quantification can be dropped. E.g.,
+`´T´ forSome { }` is equivalent to ´T´.
+1. An existential type `´T´ forSome { ´Q´ }` where ´Q´ contains
+a clause `type ´t[\mathit{tps}] >: L <: U´` is equivalent
+to the type `´T'´ forSome { ´Q´ }` where ´T'´ results from ´T´ by replacing
+every [covariant occurrence](04-basic-declarations-and-definitions.html#variance-annotations) of ´t´ in ´T´ by ´U´ and by
+replacing every contravariant occurrence of ´t´ in ´T´ by ´L´.
+
+#### Existential Quantification over Values
+
+As a syntactic convenience, the bindings clause
+in an existential type may also contain
+value declarations `val ´x´: ´T´`.
+An existential type `´T´ forSome { ´Q´; val ´x´: ´S\,´;´\,Q'´ }`
+is treated as a shorthand for the type
+`´T'´ forSome { ´Q´; type ´t´ <: ´S´ with Singleton; ´Q'´ }`, where ´t´ is a
+fresh type name and ´T'´ results from ´T´ by replacing every occurrence of
+`´x´.type` with ´t´.
+
+#### Placeholder Syntax for Existential Types
+
+```ebnf
+WildcardType   ::=  ‘_’ TypeBounds
+```
+
+Scala supports a placeholder syntax for existential types.
+A _wildcard type_ is of the form `_´\;´>:´\,L\,´<:´\,U´`. Both bound
+clauses may be omitted. If a lower bound clause `>:´\,L´` is missing,
+`>:´\,´scala.Nothing`
+is assumed. If an upper bound clause `<:´\,U´` is missing,
+`<:´\,´scala.Any` is assumed. A wildcard type is a shorthand for an
+existentially quantified type variable, where the existential quantification is
+implicit.
+
+A wildcard type must appear as a type argument of a parameterized type.
+Let ´T = p.c[\mathit{targs},T,\mathit{targs}']´ be a parameterized type where
+´\mathit{targs}, \mathit{targs}'´ may be empty and
+´T´ is a wildcard type `_´\;´>:´\,L\,´<:´\,U´`. Then ´T´ is equivalent to the
+existential
+type
+
+```scala
+´p.c[\mathit{targs},t,\mathit{targs}']´ forSome { type ´t´ >: ´L´ <: ´U´ }
+```
+
+where ´t´ is some fresh type variable.
+Wildcard types may also appear as parts of [infix types](#infix-types)
+, [function types](#function-types),
+or [tuple types](#tuple-types).
+Their expansion is then the expansion in the equivalent parameterized
+type.
+
+###### Example
+
+Assume the class definitions
+
+```scala
+class Ref[T]
+abstract class Outer { type T }
+```
+
+Here are some examples of existential types:
+
+```scala
+Ref[T] forSome { type T <: java.lang.Number }
+Ref[x.T] forSome { val x: Outer }
+Ref[x_type # T] forSome { type x_type <: Outer with Singleton }
+```
+
+The last two types in this list are equivalent.
+An alternative formulation of the first type above using wildcard syntax is:
+
+```scala
+Ref[_ <: java.lang.Number]
+```
+
+###### Example
+
+The type `List[List[_]]` is equivalent to the existential type
+
+```scala
+List[List[t] forSome { type t }]
+```
+
+###### Example
+
+Assume a covariant type
+
+```scala
+class List[+T]
+```
+
+The type
+
+```scala
+List[T] forSome { type T <: java.lang.Number }
+```
+
+is equivalent (by simplification rule 4 above) to
+
+```scala
+List[java.lang.Number] forSome { type T <: java.lang.Number }
+```
+
+which is in turn equivalent (by simplification rules 2 and 3 above) to
+`List[java.lang.Number]`.
+
+## Non-Value Types
+
+The types explained in the following do not denote sets of values, nor
+do they appear explicitly in programs. They are introduced in this
+report as the internal types of defined identifiers.
+
+### Method Types
+
+A _method type_ is denoted internally as ´(\mathit{Ps})U´, where ´(\mathit{Ps})´
+is a sequence of parameter names and types ´(p_1:T_1 , \ldots , p_n:T_n)´
+for some ´n \geq 0´ and ´U´ is a (value or method) type.  This type
+represents named methods that take arguments named ´p_1 , \ldots , p_n´
+of types ´T_1 , \ldots , T_n´
+and that return a result of type ´U´.
+
+Method types associate to the right: ´(\mathit{Ps}\_1)(\mathit{Ps}\_2)U´ is
+treated as ´(\mathit{Ps}\_1)((\mathit{Ps}\_2)U)´.
+
+A special case are types of methods without any parameters. They are
+written here `=> T`. Parameterless methods name expressions
+that are re-evaluated each time the parameterless method name is
+referenced.
+
+Method types do not exist as types of values. If a method name is used
+as a value, its type is [implicitly converted](06-expressions.html#implicit-conversions) to a
+corresponding function type.
+
+###### Example
+
+The declarations
+
+```scala
+def a: Int
+def b (x: Int): Boolean
+def c (x: Int) (y: String, z: String): String
+```
+
+produce the typings
+
+```scala
+a: => Int
+b: (Int) Boolean
+c: (Int) (String, String) String
+```
+
+### Polymorphic Method Types
+
+A polymorphic method type is denoted internally as `[´\mathit{tps}\,´]´T´` where
+`[´\mathit{tps}\,´]` is a type parameter section
+`[´a_1´ >: ´L_1´ <: ´U_1 , \ldots , a_n´ >: ´L_n´ <: ´U_n´]`
+for some ´n \geq 0´ and ´T´ is a
+(value or method) type.  This type represents named methods that
+take type arguments `´S_1 , \ldots , S_n´` which
+[conform](#parameterized-types) to the lower bounds
+`´L_1 , \ldots , L_n´` and the upper bounds
+`´U_1 , \ldots , U_n´` and that yield results of type ´T´.
+
+###### Example
+
+The declarations
+
+```scala
+def empty[A]: List[A]
+def union[A <: Comparable[A]] (x: Set[A], xs: Set[A]): Set[A]
+```
+
+produce the typings
+
+```scala
+empty : [A >: Nothing <: Any] List[A]
+union : [A >: Nothing <: Comparable[A]] (x: Set[A], xs: Set[A]) Set[A]
+```
+
+### Type Constructors
+
+A _type constructor_ is represented internally much like a polymorphic method type.
+`[´\pm´ ´a_1´ >: ´L_1´ <: ´U_1 , \ldots , \pm a_n´ >: ´L_n´ <: ´U_n´] ´T´`
+represents a type that is expected by a
+[type constructor parameter](04-basic-declarations-and-definitions.html#type-parameters) or an
+[abstract type constructor binding](04-basic-declarations-and-definitions.html#type-declarations-and-type-aliases) with
+the corresponding type parameter clause.
+
+###### Example
+
+Consider this fragment of the `Iterable[+X]` class:
+
+```scala
+trait Iterable[+X] {
+  def flatMap[newType[+X] <: Iterable[X], S](f: X => newType[S]): newType[S]
+}
+```
+
+Conceptually, the type constructor `Iterable` is a name for the
+anonymous type `[+X] Iterable[X]`, which may be passed to the
+`newType` type constructor parameter in `flatMap`.
+
+<!-- ### Overloaded Types
+
+More than one values or methods are defined in the same scope with the
+same name, we model
+
+An overloaded type consisting of type alternatives ´T_1 \commadots T_n (n \geq 2)´ is denoted internally ´T_1 \overload \ldots \overload T_n´.
+
+###### Example
+```scala
+def println(): Unit
+def println(s: String): Unit = ´\ldots´
+def println(x: Float): Unit = ´\ldots´
+def println(x: Float, width: Int): Unit = ´\ldots´
+def println[A](x: A)(tostring: A => String): Unit = ´\ldots´
+```
+define a single function `println` which has an overloaded
+type.
+```
+println:  () Unit ´\overload´
+          (String) Unit ´\overload´
+          (Float) Unit ´\overload´
+          (Float, Int) Unit ´\overload´
+          [A] (A) (A => String) Unit
+```
+
+###### Example
+```scala
+def f(x: T): T = ´\ldots´
+val f = 0
+```
+define a function `f} which has type `(x: T)T ´\overload´ Int`.
+-->
+
+## Base Types and Member Definitions
+
+Types of class members depend on the way the members are referenced.
+Central here are three notions, namely:
+1. the notion of the set of base types of a type ´T´,
+1. the notion of a type ´T´ in some class ´C´ seen from some
+   prefix type ´S´,
+1. the notion of the set of member bindings of some type ´T´.
+
+These notions are defined mutually recursively as follows.
+
+1. The set of _base types_ of a type is a set of class types,
+   given as follows.
+  - The base types of a class type ´C´ with parents ´T_1 , \ldots , T_n´ are
+    ´C´ itself, as well as the base types of the compound type
+    `´T_1´ with … with ´T_n´ { ´R´ }`.
+  - The base types of an aliased type are the base types of its alias.
+  - The base types of an abstract type are the base types of its upper bound.
+  - The base types of a parameterized type
+    `´C´[´T_1 , \ldots , T_n´]` are the base types
+    of type ´C´, where every occurrence of a type parameter ´a_i´
+    of ´C´ has been replaced by the corresponding parameter type ´T_i´.
+  - The base types of a singleton type `´p´.type` are the base types of
+    the type of ´p´.
+  - The base types of a compound type
+    `´T_1´ with ´\ldots´ with ´T_n´ { ´R´ }`
+    are the _reduced union_ of the base
+    classes of all ´T_i´'s. This means:
+    Let the multi-set ´\mathscr{S}´ be the multi-set-union of the
+    base types of all ´T_i´'s.
+    If ´\mathscr{S}´ contains several type instances of the same class, say
+    `´S^i´#´C´[´T^i_1 , \ldots , T^i_n´]` ´(i \in I)´, then
+    all those instances
+    are replaced by one of them which conforms to all
+    others. It is an error if no such instance exists. It follows that the
+    reduced union, if it exists,
+    produces a set of class types, where different types are instances of
+    different classes.
+  - The base types of a type selection `´S´#´T´` are
+    determined as follows. If ´T´ is an alias or abstract type, the
+    previous clauses apply. Otherwise, ´T´ must be a (possibly
+    parameterized) class type, which is defined in some class ´B´.  Then
+    the base types of `´S´#´T´` are the base types of ´T´
+    in ´B´ seen from the prefix type ´S´.
+  - The base types of an existential type `´T´ forSome { ´Q´ }` are
+    all types `´S´ forSome { ´Q´ }` where ´S´ is a base type of ´T´.
+
+1. The notion of a type ´T´ _in class ´C´ seen from some prefix type ´S´_
+   makes sense only if the prefix type ´S´
+   has a type instance of class ´C´ as a base type, say
+   `´S'´#´C´[´T_1 , \ldots , T_n´]`. Then we define as follows.
+    - If `´S´ = ´\epsilon´.type`, then ´T´ in ´C´ seen from ´S´ is
+      ´T´ itself.
+    - Otherwise, if ´S´ is an existential type `´S'´ forSome { ´Q´ }`, and
+      ´T´ in ´C´ seen from ´S'´ is ´T'´,
+      then ´T´ in ´C´ seen from ´S´ is `´T'´ forSome {´\,Q\,´}`.
+    - Otherwise, if ´T´ is the ´i´'th type parameter of some class ´D´, then
+        - If ´S´ has a base type `´D´[´U_1 , \ldots , U_n´]`, for some type
+          parameters `[´U_1 , \ldots , U_n´]`, then ´T´ in ´C´ seen from ´S´
+          is ´U_i´.
+        - Otherwise, if ´C´ is defined in a class ´C'´, then
+          ´T´ in ´C´ seen from ´S´ is the same as ´T´ in ´C'´ seen from ´S'´.
+        - Otherwise, if ´C´ is not defined in another class, then
+          ´T´ in ´C´ seen from ´S´ is ´T´ itself.
+    - Otherwise, if ´T´ is the singleton type `´D´.this.type` for some class ´D´
+      then
+        - If ´D´ is a subclass of ´C´ and ´S´ has a type instance of class ´D´
+          among its base types, then ´T´ in ´C´ seen from ´S´ is ´S´.
+        - Otherwise, if ´C´ is defined in a class ´C'´, then
+          ´T´ in ´C´ seen from ´S´ is the same as ´T´ in ´C'´ seen from ´S'´.
+        - Otherwise, if ´C´ is not defined in another class, then
+          ´T´ in ´C´ seen from ´S´ is ´T´ itself.
+    - If ´T´ is some other type, then the described mapping is performed
+      to all its type components.
+
+    If ´T´ is a possibly parameterized class type, where ´T´'s class
+    is defined in some other class ´D´, and ´S´ is some prefix type,
+    then we use "´T´ seen from ´S´" as a shorthand for
+    "´T´ in ´D´ seen from ´S´".
+
+1. The _member bindings_ of a type ´T´ are
+   1. all bindings ´d´ such that there exists a type instance of some class ´C´ among the base types of ´T´
+     and there exists a definition or declaration ´d'´ in ´C´
+     such that ´d´ results from ´d'´ by replacing every
+     type ´T'´ in ´d'´ by ´T'´ in ´C´ seen from ´T´, and
+   2. all bindings of the type's [refinement](#compound-types), if it has one.
+
+   The _definition_ of a type projection `S#T` is the member
+   binding ´d_T´ of the type `T` in `S`. In that case, we also say
+   that `S#T` _is defined by_ ´d_T´.
+
+## Relations between types
+
+We define the following relations between types.
+
+| Name             | Symbolically   | Interpretation                                     |
+|------------------|----------------|----------------------------------------------------|
+| Equivalence      | ´T \equiv U´   | ´T´ and ´U´ are interchangeable in all contexts.   |
+| Conformance      | ´T <: U´       | Type ´T´ conforms to ("is a subtype of") type ´U´. |
+| Weak Conformance | ´T <:_w U´     | Augments conformance for primitive numeric types.  |
+| Compatibility    |                | Type ´T´ conforms to type ´U´ after conversions.   |
+
+### Equivalence
+
+Equivalence ´(\equiv)´ between types is the smallest congruence [^congruence] such that the following holds:
+
+- If ´t´ is defined by a type alias `type ´t´ = ´T´`, then ´t´ is equivalent to ´T´.
+- If a path ´p´ has a singleton type `´q´.type`, then `´p´.type ´\equiv q´.type`.
+- If ´O´ is defined by an object definition, and ´p´ is a path consisting only of package or object selectors and ending in ´O´, then `´O´.this.type ´\equiv p´.type`.
+- Two [compound types](#compound-types) are equivalent if the sequences
+  of their component are pairwise equivalent, and occur in the same order, and
+  their refinements are equivalent. Two refinements are equivalent if they
+  bind the same names and the modifiers, types and bounds of every
+  declared entity are equivalent in both refinements.
+- Two [method types](#method-types) are equivalent if:
+    - neither are implicit, or they both are [^implicit];
+    - they have equivalent result types;
+    - they have the same number of parameters; and
+    - corresponding parameters have equivalent types.
+      Note that the names of parameters do not matter for method type equivalence.
+- Two [polymorphic method types](#polymorphic-method-types) are equivalent if
+  they have the same number of type parameters, and, after renaming one set of
+  type parameters by another, the result types as well as lower and upper bounds
+  of corresponding type parameters are equivalent.
+- Two [existential types](#existential-types)
+  are equivalent if they have the same number of
+  quantifiers, and, after renaming one list of type quantifiers by
+  another, the quantified types as well as lower and upper bounds of
+  corresponding quantifiers are equivalent.
+- Two [type constructors](#type-constructors) are equivalent if they have the
+  same number of type parameters, and, after renaming one list of type
+  parameters by another, the result types as well as variances, lower and upper
+  bounds of corresponding type parameters are equivalent.
+
+[^congruence]: A congruence is an equivalence relation which is closed under formation of contexts.
+[^implicit]: A method type is implicit if the parameter section that defines it starts with the `implicit` keyword.
+
+### Conformance
+
+The conformance relation ´(<:)´ is the smallest transitive relation that satisfies the following conditions.
+
+
+- Conformance includes equivalence. If `T \equiv U` then `T <: U`.
+- For every value type `T`, `scala.Nothing <: ´T´ <: scala.Any`.
+- For every type constructor ´T´ (with any number of type parameters), `scala.Nothing <: ´T´ <: scala.Any`.
+- For every value type ´T´, `scala.Null <: ´T´` unless `´T´ <: scala.AnyVal`.
+- A type variable or abstract type ´t´ conforms to its upper bound and
+  its lower bound conforms to ´t´.
+- A class type or parameterized type conforms to any of its base-types.
+- A singleton type `´p´.type` conforms to the type of the path ´p´.
+- A singleton type `´p´.type` conforms to the type `scala.Singleton`.
+- A type projection `´T´#´t´` conforms to `´U´#´t´` if ´T´ conforms to ´U´.
+- A parameterized type `´T´[´T_1´ , … , ´T_n´]` conforms to
+  `´T´[´U_1´ , … , ´U_n´]` if
+  the following three conditions hold for ´i \in \{ 1 , \ldots , n \}´:
+ 1. If the ´i´'th type parameter of ´T´ is declared covariant, then
+       ´T_i <: U_i´.
+ 1. If the ´i´'th type parameter of ´T´ is declared contravariant, then
+       ´U_i <: T_i´.
+ 1. If the ´i´'th type parameter of ´T´ is declared neither covariant
+       nor contravariant, then ´U_i \equiv T_i´.
+- A compound type `´T_1´ with ´\ldots´ with ´T_n´ {´R\,´}` conforms to
+  each of its component types ´T_i´.
+- If ´T <: U_i´ for ´i \in \{ 1 , \ldots , n \}´ and for every
+  binding ´d´ of a type or value ´x´ in ´R´ there exists a member
+  binding of ´x´ in ´T´ which subsumes ´d´, then ´T´ conforms to the
+  compound type `´U_1´ with ´\ldots´ with ´U_n´ {´R\,´}`.
+- The existential type `´T´ forSome {´\,Q\,´}` conforms to
+  ´U´ if its [skolemization](#existential-types)
+  conforms to ´U´.
+- The type ´T´ conforms to the existential type `´U´ forSome {´\,Q\,´}`
+  if ´T´ conforms to one of the [type instances](#existential-types)
+  of `´U´ forSome {´\,Q\,´}`.
+- If
+  ´T_i \equiv T_i'´ for ´i \in \{ 1 , \ldots , n\}´ and ´U´ conforms to ´U'´
+  then the method type ´(p_1:T_1 , \ldots , p_n:T_n) U´ conforms to
+  ´(p_1':T_1' , \ldots , p_n':T_n') U'´.
+- The polymorphic type
+  ´[a_1 >: L_1 <: U_1 , \ldots , a_n >: L_n <: U_n] T´ conforms to the
+  polymorphic type
+  ´[a_1 >: L_1' <: U_1' , \ldots , a_n >: L_n' <: U_n'] T'´ if, assuming
+  ´L_1' <: a_1 <: U_1' , \ldots , L_n' <: a_n <: U_n'´
+  one has ´T <: T'´ and ´L_i <: L_i'´ and ´U_i' <: U_i´
+  for ´i \in \{ 1 , \ldots , n \}´.
+- Type constructors ´T´ and ´T'´ follow a similar discipline. We characterize
+  ´T´ and ´T'´ by their type parameter clauses
+  ´[a_1 , \ldots , a_n]´ and
+  ´[a_1' , \ldots , a_n']´, where an ´a_i´ or ´a_i'´ may include a variance
+  annotation, a higher-order type parameter clause, and bounds. Then, ´T´
+  conforms to ´T'´ if any list ´[t_1 , \ldots , t_n]´ -- with declared
+  variances, bounds and higher-order type parameter clauses -- of valid type
+  arguments for ´T'´ is also a valid list of type arguments for ´T´ and
+  ´T[t_1 , \ldots , t_n] <: T'[t_1 , \ldots , t_n]´. Note that this entails
+  that:
+    - The bounds on ´a_i´ must be weaker than the corresponding bounds declared
+      for ´a'_i´.
+    - The variance of ´a_i´ must match the variance of ´a'_i´, where covariance
+      matches covariance, contravariance matches contravariance and any variance
+      matches invariance.
+    - Recursively, these restrictions apply to the corresponding higher-order
+      type parameter clauses of ´a_i´ and ´a'_i´.
+
+A declaration or definition in some compound type of class type ´C´
+_subsumes_ another declaration of the same name in some compound type or class
+type ´C'´, if one of the following holds.
+
+- A value declaration or definition that defines a name ´x´ with type ´T´
+  subsumes a value or method declaration that defines ´x´ with type ´T'´, provided
+  ´T <: T'´.
+- A method declaration or definition that defines a name ´x´ with type ´T´
+  subsumes a method declaration that defines ´x´ with type ´T'´, provided
+  ´T <: T'´.
+- A type alias
+  `type ´t´[´T_1´ , … , ´T_n´] = ´T´` subsumes a type alias
+  `type ´t´[´T_1´ , … , ´T_n´] = ´T'´` if ´T \equiv T'´.
+- A type declaration `type ´t´[´T_1´ , … , ´T_n´] >: ´L´ <: ´U´` subsumes
+  a type declaration `type ´t´[´T_1´ , … , ´T_n´] >: ´L'´ <: ´U'´` if
+  ´L' <: L´ and ´U <: U'´.
+- A type or class definition that binds a type name ´t´ subsumes an abstract
+  type declaration `type t[´T_1´ , … , ´T_n´] >: L <: U` if
+  ´L <: t <: U´.
+
+
+#### Least upper bounds and greatest lower bounds
+The ´(<:)´ relation forms pre-order between types, i.e. it is transitive and reflexive.
+This allows us to define _least upper bounds_ and _greatest lower bounds_ of a set of types in terms of that order.
+The least upper bound or greatest lower bound of a set of types does not always exist.
+For instance, consider the class definitions:
+
+```scala
+class A[+T] {}
+class B extends A[B]
+class C extends A[C]
+```
+
+Then the types `A[Any], A[A[Any]], A[A[A[Any]]], ...` form
+a descending sequence of upper bounds for `B` and `C`. The
+least upper bound would be the infinite limit of that sequence, which
+does not exist as a Scala type. Since cases like this are in general
+impossible to detect, a Scala compiler is free to reject a term
+which has a type specified as a least upper or greatest lower bound,
+and that bound would be more complex than some compiler-set
+limit [^4].
+
+The least upper bound or greatest lower bound might also not be
+unique. For instance `A with B` and `B with A` are both
+greatest lower bounds of `A` and `B`. If there are several
+least upper bounds or greatest lower bounds, the Scala compiler is
+free to pick any one of them.
+
+[^4]: The current Scala compiler limits the nesting level
+      of parameterization in such bounds to be at most two deeper than the
+      maximum nesting level of the operand types
+
+### Weak Conformance
+
+In some situations Scala uses a more general conformance relation.
+A type ´S´ _weakly conforms_ to a type ´T´, written ´S <:_w T´,
+if ´S <: T´ or both ´S´ and ´T´ are primitive number types and ´S´ precedes ´T´ in the following ordering.
+
+```scala
+Byte  ´<:_w´ Short
+Short ´<:_w´ Int
+Char  ´<:_w´ Int
+Int   ´<:_w´ Long
+Long  ´<:_w´ Float
+Float ´<:_w´ Double
+```
+
+A _weak least upper bound_ is a least upper bound with respect to weak conformance.
+
+### Compatibility
+A type ´T´ is _compatible_ to a type ´U´ if ´T´ (or its corresponding function type) [weakly conforms](#weak-conformance) to ´U´
+after applying [eta-expansion](06-expressions.html#eta-expansion). If ´T´ is a method type, it's converted to the corresponding function type. If the types do not weakly conform, the following alternatives are checked in order:
+  - [view application](07-implicits.html#views): there's an implicit view from ´T´ to ´U´;
+  - dropping by-name modifiers: if ´U´ is of the shape `´=> U'´` (and ´T´ is not), `´T <:_w U'´`;
+  - SAM conversion: if ´T´ corresponds to a function type, and ´U´ declares a single abstract method whose type [corresponds](06-expressions.html#sam-conversion) to the function type ´U'´, `´T <:_w U'´`.
+
+<!--- TODO: include other implicit conversions in addition to view application?
+
+  trait Proc { def go(x: Any): Unit }
+
+  def foo(x: Any => Unit): Unit = ???
+  def foo(x: Proc): Unit = ???
+
+  foo((x: Any) => 1) // works when you drop either foo overload since value discarding is applied
+
+-->
+
+#### Examples
+
+##### Function compatibility via SAM conversion
+
+Given the definitions
+
+```scala
+def foo(x: Int => String): Unit
+def foo(x: ToString): Unit
+
+trait ToString { def convert(x: Int): String }
+```
+
+The application `foo((x: Int) => x.toString)` [resolves](06-expressions.html#overloading-resolution) to the first overload,
+as it's more specific:
+  - `Int => String` is compatible to `ToString` -- when expecting a value of type `ToString`, you may pass a function literal from `Int` to `String`, as it will be SAM-converted to said function;
+  - `ToString` is not compatible to `Int => String` -- when expecting a function from `Int` to `String`, you may not pass a `ToString`.
+
+## Volatile Types
+
+Type volatility approximates the possibility that a type parameter or
+abstract type instance of a type does not have any non-null values.
+A value member of a volatile type cannot appear in a [path](#paths).
+
+A type is _volatile_ if it falls into one of four categories:
+
+A compound type `´T_1´ with … with ´T_n´ {´R\,´}`
+is volatile if one of the following three conditions hold.
+
+1. One of ´T_2 , \ldots , T_n´ is a type parameter or abstract type, or
+1. ´T_1´ is an abstract type and either the refinement ´R´
+   or a type ´T_j´ for ´j > 1´ contributes an abstract member
+   to the compound type, or
+1. one of ´T_1 , \ldots , T_n´ is a singleton type.
+
+Here, a type ´S´ _contributes an abstract member_ to a type ´T´ if
+´S´ contains an abstract member that is also a member of ´T´.
+A refinement ´R´ contributes an abstract member to a type ´T´ if ´R´
+contains an abstract declaration which is also a member of ´T´.
+
+A type designator is volatile if it is an alias of a volatile type, or
+if it designates a type parameter or abstract type that has a volatile type as
+its upper bound.
+
+A singleton type `´p´.type` is volatile, if the underlying
+type of path ´p´ is volatile.
+
+An existential type `´T´ forSome {´\,Q\,´}` is volatile if
+´T´ is volatile.
+
+## Type Erasure
+
+A type is called _generic_ if it contains type arguments or type variables.
+_Type erasure_ is a mapping from (possibly generic) types to
+non-generic types. We write ´|T|´ for the erasure of type ´T´.
+The erasure mapping is defined as follows.
+
+- The erasure of an alias type is the erasure of its right-hand side.
+- The erasure of an abstract type is the erasure of its upper bound.
+- The erasure of the parameterized type `scala.Array´[T_1]´` is
+ `scala.Array´[|T_1|]´`.
+- The erasure of every other parameterized type ´T[T_1 , \ldots , T_n]´ is ´|T|´.
+- The erasure of a singleton type `´p´.type` is the
+  erasure of the type of ´p´.
+- The erasure of a type projection `´T´#´x´` is `|´T´|#´x´`.
+- The erasure of a compound type
+  `´T_1´ with ´\ldots´ with ´T_n´ {´R\,´}` is the erasure of the intersection
+  dominator of ´T_1 , \ldots , T_n´.
+- The erasure of an existential type `´T´ forSome {´\,Q\,´}` is ´|T|´.
+
+The _intersection dominator_ of a list of types ´T_1 , \ldots , T_n´ is computed
+as follows.
+Let ´T_{i_1} , \ldots , T_{i_m}´ be the subsequence of types ´T_i´
+which are not supertypes of some other type ´T_j´.
+If this subsequence contains a type designator ´T_c´ that refers to a class
+which is not a trait,
+the intersection dominator is ´T_c´. Otherwise, the intersection
+dominator is the first element of the subsequence, ´T_{i_1}´.
diff --git a/docs/_spec/04-basic-declarations-and-definitions.md b/docs/_spec/04-basic-declarations-and-definitions.md
new file mode 100644
index 000000000000..acaf2491d99b
--- /dev/null
+++ b/docs/_spec/04-basic-declarations-and-definitions.md
@@ -0,0 +1,945 @@
+---
+title: Basic Declarations & Definitions
+layout: default
+chapter: 4
+---
+
+# Basic Declarations and Definitions
+
+```ebnf
+Dcl         ::=  ‘val’ ValDcl
+              |  ‘var’ VarDcl
+              |  ‘def’ FunDcl
+              |  ‘type’ {nl} TypeDcl
+PatVarDef   ::=  ‘val’ PatDef
+              |  ‘var’ VarDef
+Def         ::=  PatVarDef
+              |  ‘def’ FunDef
+              |  ‘type’ {nl} TypeDef
+              |  TmplDef
+```
+
+A _declaration_ introduces names and assigns them types. It can
+form part of a [class definition](05-classes-and-objects.html#templates) or of a
+refinement in a [compound type](03-types.html#compound-types).
+
+A _definition_ introduces names that denote terms or types. It can
+form part of an object or class definition or it can be local to a
+block.  Both declarations and definitions produce _bindings_ that
+associate type names with type definitions or bounds, and that
+associate term names with types.
+
+The scope of a name introduced by a declaration or definition is the
+whole statement sequence containing the binding.  However, there is a
+restriction on forward references in blocks: In a statement sequence
+´s_1 \ldots s_n´ making up a block, if a simple name in ´s_i´ refers
+to an entity defined by ´s_j´ where ´j \geq i´, then for all ´s_k´
+between and including ´s_i´ and ´s_j´,
+
+- ´s_k´ cannot be a variable definition.
+- If ´s_k´ is a value definition, it must be lazy.
+
+<!--
+Every basic definition may introduce several defined names, separated
+by commas. These are expanded according to the following scheme:
+\bda{lcl}
+\VAL;x, y: T = e && \VAL; x: T = e \\
+                 && \VAL; y: T = x \\[0.5em]
+
+\LET;x, y: T = e && \LET; x: T = e \\
+                 && \VAL; y: T = x \\[0.5em]
+
+\DEF;x, y (ps): T = e &\tab\mbox{expands to}\tab& \DEF; x(ps): T = e \\
+                      && \DEF; y(ps): T = x(ps)\\[0.5em]
+
+\VAR;x, y: T := e && \VAR;x: T := e\\
+                  && \VAR;y: T := x\\[0.5em]
+
+\TYPE;t,u = T && \TYPE; t = T\\
+              && \TYPE; u = t\\[0.5em]
+\eda
+
+All definitions have a ``repeated form`` where the initial
+definition keyword is followed by several constituent definitions
+which are separated by commas.  A repeated definition is
+always interpreted as a sequence formed from the
+constituent definitions. E.g. the function definition
+`def f(x) = x, g(y) = y` expands to
+`def f(x) = x; def g(y) = y` and
+the type definition
+`type T, U <: B` expands to
+`type T; type U <: B`.
+}
+\comment{
+If an element in such a sequence introduces only the defined name,
+possibly with some type or value parameters, but leaves out any
+additional parts in the definition, then those parts are implicitly
+copied from the next subsequent sequence element which consists of
+more than just a defined name and parameters. Examples:
+
+- []
+The variable declaration `var x, y: Int`
+expands to `var x: Int; var y: Int`.
+- []
+The value definition `val x, y: Int = 1`
+expands to `val x: Int = 1; val y: Int = 1`.
+- []
+The class definition `case class X(), Y(n: Int) extends Z` expands to
+`case class X extends Z; case class Y(n: Int) extends Z`.
+- The object definition `case object Red, Green, Blue extends Color`~
+expands to
+```scala
+case object Red extends Color
+case object Green extends Color
+case object Blue extends Color
+```
+-->
+
+## Value Declarations and Definitions
+
+```ebnf
+Dcl          ::=  ‘val’ ValDcl
+ValDcl       ::=  ids ‘:’ Type
+PatVarDef    ::=  ‘val’ PatDef
+PatDef       ::=  Pattern2 {‘,’ Pattern2} [‘:’ Type] ‘=’ Expr
+ids          ::=  id {‘,’ id}
+```
+
+A value declaration `val ´x´: ´T´` introduces ´x´ as a name of a value of
+type ´T´.
+
+A value definition `val ´x´: ´T´ = ´e´` defines ´x´ as a
+name of the value that results from the evaluation of ´e´.
+If the value definition is not recursive, the type
+´T´ may be omitted, in which case the [packed type](06-expressions.html#expression-typing) of
+expression ´e´ is assumed.  If a type ´T´ is given, then ´e´ is expected to
+conform to it.
+
+Evaluation of the value definition implies evaluation of its
+right-hand side ´e´, unless it has the modifier `lazy`.  The
+effect of the value definition is to bind ´x´ to the value of ´e´
+converted to type ´T´. A `lazy` value definition evaluates
+its right hand side ´e´ the first time the value is accessed.
+
+A _constant value definition_ is of the form
+
+```scala
+final val x = e
+```
+
+where `e` is a [constant expression](06-expressions.html#constant-expressions).
+The `final` modifier must be
+present and no type annotation may be given. References to the
+constant value `x` are themselves treated as constant expressions; in the
+generated code they are replaced by the definition's right-hand side `e`.
+
+Value definitions can alternatively have a [pattern](08-pattern-matching.html#patterns)
+as left-hand side.  If ´p´ is some pattern other
+than a simple name or a name followed by a colon and a type, then the
+value definition `val ´p´ = ´e´` is expanded as follows:
+
+1. If the pattern ´p´ has bound variables ´x_1 , \ldots , x_n´, where ´n > 1´:
+
+```scala
+val ´\$x´ = ´e´ match {case ´p´ => (´x_1 , \ldots , x_n´)}
+val ´x_1´ = ´\$x´._1
+´\ldots´
+val ´x_n´ = ´\$x´._n
+```
+
+Here, ´\$x´ is a fresh name.
+
+2. If ´p´ has a unique bound variable ´x´:
+
+```scala
+val ´x´ = ´e´ match { case ´p´ => ´x´ }
+```
+
+3. If ´p´ has no bound variables:
+
+```scala
+´e´ match { case ´p´ => ()}
+```
+
+###### Example
+
+The following are examples of value definitions
+
+```scala
+val pi = 3.1415
+val pi: Double = 3.1415   // equivalent to first definition
+val Some(x) = f()         // a pattern definition
+val x :: xs = mylist      // an infix pattern definition
+```
+
+The last two definitions have the following expansions.
+
+```scala
+val x = f() match { case Some(x) => x }
+
+val x´\$´ = mylist match { case x :: xs => (x, xs) }
+val x = x´\$´._1
+val xs = x´\$´._2
+```
+
+The name of any declared or defined value may not end in `_=`.
+
+A value declaration `val ´x_1 , \ldots , x_n´: ´T´` is a shorthand for the
+sequence of value declarations `val ´x_1´: ´T´; ...; val ´x_n´: ´T´`.
+A value definition `val ´p_1 , \ldots , p_n´ = ´e´` is a shorthand for the
+sequence of value definitions `val ´p_1´ = ´e´; ...; val ´p_n´ = ´e´`.
+A value definition `val ´p_1 , \ldots , p_n: T´ = ´e´` is a shorthand for the
+sequence of value definitions `val ´p_1: T´ = ´e´; ...; val ´p_n: T´ = ´e´`.
+
+## Variable Declarations and Definitions
+
+```ebnf
+Dcl            ::=  ‘var’ VarDcl
+PatVarDef      ::=  ‘var’ VarDef
+VarDcl         ::=  ids ‘:’ Type
+VarDef         ::=  PatDef
+                 |  ids ‘:’ Type ‘=’ ‘_’
+```
+
+A variable declaration `var ´x´: ´T´` is equivalent to the declarations
+of both a _getter function_ ´x´ *and* a _setter function_ `´x´_=`:
+
+```scala
+def ´x´: ´T´
+def ´x´_= (´y´: ´T´): Unit
+```
+
+An implementation of a class may _define_ a declared variable
+using a variable definition, or by defining the corresponding setter and getter methods.
+
+A variable definition `var ´x´: ´T´ = ´e´` introduces a
+mutable variable with type ´T´ and initial value as given by the
+expression ´e´. The type ´T´ can be omitted, in which case the type of
+´e´ is assumed. If ´T´ is given, then ´e´ is expected to
+[conform to it](06-expressions.html#expression-typing).
+
+Variable definitions can alternatively have a [pattern](08-pattern-matching.html#patterns)
+as left-hand side.  A variable definition
+ `var ´p´ = ´e´` where ´p´ is a pattern other
+than a simple name or a name followed by a colon and a type is expanded in the same way
+as a [value definition](#value-declarations-and-definitions)
+`val ´p´ = ´e´`, except that
+the free names in ´p´ are introduced as mutable variables, not values.
+
+The name of any declared or defined variable may not end in `_=`.
+
+A variable definition `var ´x´: ´T´ = _` can appear only as a member of a template.
+It introduces a mutable field with type ´T´ and a default initial value.
+The default value depends on the type ´T´ as follows:
+
+| default  | type ´T´                           |
+|----------|------------------------------------|
+|`0`       | `Int` or one of its subrange types |
+|`0L`      | `Long`                             |
+|`0.0f`    | `Float`                            |
+|`0.0d`    | `Double`                           |
+|`false`   | `Boolean`                          |
+|`()`      | `Unit`                             |
+|`null`    | all other types                    |
+
+When they occur as members of a template, both forms of variable
+definition also introduce a getter function ´x´ which returns the
+value currently assigned to the variable, as well as a setter function
+`´x´_=` which changes the value currently assigned to the variable.
+The functions have the same signatures as for a variable declaration.
+The template then has these getter and setter functions as
+members, whereas the original variable cannot be accessed directly as
+a template member.
+
+###### Example
+
+The following example shows how _properties_ can be
+simulated in Scala. It defines a class `TimeOfDayVar` of time
+values with updatable integer fields representing hours, minutes, and
+seconds. Its implementation contains tests that allow only legal
+values to be assigned to these fields. The user code, on the other
+hand, accesses these fields just like normal variables.
+
+```scala
+class TimeOfDayVar {
+  private var h: Int = 0
+  private var m: Int = 0
+  private var s: Int = 0
+
+  def hours              =  h
+  def hours_= (h: Int)   =  if (0 <= h && h < 24) this.h = h
+                            else throw new DateError()
+
+  def minutes            =  m
+  def minutes_= (m: Int) =  if (0 <= m && m < 60) this.m = m
+                            else throw new DateError()
+
+  def seconds            =  s
+  def seconds_= (s: Int) =  if (0 <= s && s < 60) this.s = s
+                            else throw new DateError()
+}
+val d = new TimeOfDayVar
+d.hours = 8; d.minutes = 30; d.seconds = 0
+d.hours = 25                  // throws a DateError exception
+```
+
+A variable declaration `var ´x_1 , \ldots , x_n´: ´T´` is a shorthand for the
+sequence of variable declarations `var ´x_1´: ´T´; ...; var ´x_n´: ´T´`.
+A variable definition `var ´x_1 , \ldots , x_n´ = ´e´` is a shorthand for the
+sequence of variable definitions `var ´x_1´ = ´e´; ...; var ´x_n´ = ´e´`.
+A variable definition `var ´x_1 , \ldots , x_n: T´ = ´e´` is a shorthand for
+the sequence of variable definitions
+`var ´x_1: T´ = ´e´; ...; var ´x_n: T´ = ´e´`.
+
+## Type Declarations and Type Aliases
+
+<!-- TODO: Higher-kinded tdecls should have a separate section -->
+
+```ebnf
+Dcl        ::=  ‘type’ {nl} TypeDcl
+TypeDcl    ::=  id [TypeParamClause] [‘>:’ Type] [‘<:’ Type]
+Def        ::=  ‘type’ {nl} TypeDef
+TypeDef    ::=  id [TypeParamClause] ‘=’ Type
+```
+
+A _type declaration_ `type ´t´[´\mathit{tps}\,´] >: ´L´ <: ´U´` declares
+´t´ to be an abstract type with lower bound type ´L´ and upper bound
+type ´U´. If the type parameter clause `[´\mathit{tps}\,´]` is omitted, ´t´ abstracts over a proper type, otherwise ´t´ stands for a type constructor that accepts type arguments as described by the type parameter clause.
+
+If a type declaration appears as a member declaration of a
+type, implementations of the type may implement ´t´ with any type ´T´
+for which ´L <: T <: U´. It is a compile-time error if
+´L´ does not conform to ´U´.  Either or both bounds may be omitted.
+If the lower bound ´L´ is absent, the bottom type
+`scala.Nothing` is assumed.  If the upper bound ´U´ is absent,
+the top type `scala.Any` is assumed.
+
+A type constructor declaration imposes additional restrictions on the
+concrete types for which ´t´ may stand. Besides the bounds ´L´ and
+´U´, the type parameter clause may impose higher-order bounds and
+variances, as governed by the [conformance of type constructors](03-types.html#conformance).
+
+The scope of a type parameter extends over the bounds `>: ´L´ <: ´U´` and the type parameter clause ´\mathit{tps}´ itself. A
+higher-order type parameter clause (of an abstract type constructor
+´tc´) has the same kind of scope, restricted to the declaration of the
+type parameter ´tc´.
+
+To illustrate nested scoping, these declarations are all equivalent: `type t[m[x] <: Bound[x], Bound[x]]`, `type t[m[x] <: Bound[x], Bound[y]]` and `type t[m[x] <: Bound[x], Bound[_]]`, as the scope of, e.g., the type parameter of ´m´ is limited to the declaration of ´m´. In all of them, ´t´ is an abstract type member that abstracts over two type constructors: ´m´ stands for a type constructor that takes one type parameter and that must be a subtype of ´Bound´, ´t´'s second type constructor parameter. `t[MutableList, Iterable]` is a valid use of ´t´.
+
+A _type alias_ `type ´t´ = ´T´` defines ´t´ to be an alias
+name for the type ´T´.  The left hand side of a type alias may
+have a type parameter clause, e.g. `type ´t´[´\mathit{tps}\,´] = ´T´`.  The scope
+of a type parameter extends over the right hand side ´T´ and the
+type parameter clause ´\mathit{tps}´ itself.
+
+The scope rules for [definitions](#basic-declarations-and-definitions)
+and [type parameters](#function-declarations-and-definitions)
+make it possible that a type name appears in its
+own bound or in its right-hand side.  However, it is a static error if
+a type alias refers recursively to the defined type constructor itself.
+That is, the type ´T´ in a type alias `type ´t´[´\mathit{tps}\,´] = ´T´` may not
+refer directly or indirectly to the name ´t´.  It is also an error if
+an abstract type is directly or indirectly its own upper or lower bound.
+
+###### Example
+
+The following are legal type declarations and definitions:
+
+```scala
+type IntList = List[Integer]
+type T <: Comparable[T]
+type Two[A] = Tuple2[A, A]
+type MyCollection[+X] <: Iterable[X]
+```
+
+The following are illegal:
+
+```scala
+type Abs = Comparable[Abs]      // recursive type alias
+
+type S <: T                     // S, T are bounded by themselves.
+type T <: S
+
+type T >: Comparable[T.That]    // Cannot select from T.
+                                // T is a type, not a value
+type MyCollection <: Iterable   // Type constructor members must explicitly
+                                // state their type parameters.
+```
+
+If a type alias `type ´t´[´\mathit{tps}\,´] = ´S´` refers to a class type
+´S´, the name ´t´ can also be used as a constructor for
+objects of type ´S´.
+
+###### Example
+
+Suppose we make `Pair` an alias of the parameterized class `Tuple2`,
+as follows:
+
+```scala
+type Pair[+A, +B] = Tuple2[A, B]
+object Pair {
+  def apply[A, B](x: A, y: B) = Tuple2(x, y)
+  def unapply[A, B](x: Tuple2[A, B]): Option[Tuple2[A, B]] = Some(x)
+}
+```
+
+As a consequence, for any two types ´S´ and ´T´, the type
+`Pair[´S´, ´T\,´]` is equivalent to the type `Tuple2[´S´, ´T\,´]`.
+`Pair` can also be used as a constructor instead of `Tuple2`, as in:
+
+```scala
+val x: Pair[Int, String] = new Pair(1, "abc")
+```
+
+## Type Parameters
+
+```ebnf
+TypeParamClause  ::= ‘[’ VariantTypeParam {‘,’ VariantTypeParam} ‘]’
+VariantTypeParam ::= {Annotation} [‘+’ | ‘-’] TypeParam
+TypeParam        ::= (id | ‘_’) [TypeParamClause] [‘>:’ Type] [‘<:’ Type] [‘:’ Type]
+```
+
+Type parameters appear in type definitions, class definitions, and
+function definitions.  In this section we consider only type parameter
+definitions with lower bounds `>: ´L´` and upper bounds
+`<: ´U´` whereas a discussion of context bounds
+`: ´U´` and view bounds `<% ´U´`
+is deferred to [here](07-implicits.html#context-bounds-and-view-bounds).
+
+The most general form of a proper type parameter is
+`´@a_1 \ldots @a_n´ ´\pm´ ´t´ >: ´L´ <: ´U´`.
+Here, ´L´, and ´U´ are lower and upper bounds that
+constrain possible type arguments for the parameter.  It is a
+compile-time error if ´L´ does not conform to ´U´. ´\pm´ is a _variance_, i.e. an optional prefix of either `+`, or
+`-`. One or more annotations may precede the type parameter.
+
+<!--
+The upper bound ´U´ in a type parameter clauses may not be a final
+class. The lower bound may not denote a value type.
+
+TODO: Why
+-->
+
+<!--
+TODO: this is a pretty awkward description of scoping and distinctness of binders
+-->
+
+The names of all type parameters must be pairwise different in their enclosing type parameter clause.  The scope of a type parameter includes in each case the whole type parameter clause. Therefore it is possible that a type parameter appears as part of its own bounds or the bounds of other type parameters in the same clause.  However, a type parameter may not be bounded directly or indirectly by itself.
+
+A type constructor parameter adds a nested type parameter clause to the type parameter. The most general form of a type constructor parameter is `´@a_1 \ldots @a_n \pm t[\mathit{tps}\,]´ >: ´L´ <: ´U´`.
+
+The above scoping restrictions are generalized to the case of nested type parameter clauses, which declare higher-order type parameters. Higher-order type parameters (the type parameters of a type parameter ´t´) are only visible in their immediately surrounding parameter clause (possibly including clauses at a deeper nesting level) and in the bounds of ´t´. Therefore, their names must only be pairwise different from the names of other visible parameters. Since the names of higher-order type parameters are thus often irrelevant, they may be denoted with a `‘_’`, which is nowhere visible.
+
+###### Example
+Here are some well-formed type parameter clauses:
+
+```scala
+[S, T]
+[@specialized T, U]
+[Ex <: Throwable]
+[A <: Comparable[B], B <: A]
+[A, B >: A, C >: A <: B]
+[M[X], N[X]]
+[M[_], N[_]] // equivalent to previous clause
+[M[X <: Bound[X]], Bound[_]]
+[M[+X] <: Iterable[X]]
+```
+
+The following type parameter clauses are illegal:
+
+```scala
+[A >: A]                  // illegal, `A' has itself as bound
+[A <: B, B <: C, C <: A]  // illegal, `A' has itself as bound
+[A, B, C >: A <: B]       // illegal lower bound `A' of `C' does
+                          // not conform to upper bound `B'.
+```
+
+## Variance Annotations
+
+Variance annotations indicate how instances of parameterized types
+vary with respect to [subtyping](03-types.html#conformance).  A
+‘+’ variance indicates a covariant dependency, a
+‘-’ variance indicates a contravariant dependency, and a
+missing variance indication indicates an invariant dependency.
+
+A variance annotation constrains the way the annotated type variable
+may appear in the type or class which binds the type parameter.  In a
+type definition `type ´T´[´\mathit{tps}\,´] = ´S´`, or a type
+declaration `type ´T´[´\mathit{tps}\,´] >: ´L´ <: ´U´` type parameters labeled
+‘+’ must only appear in covariant position whereas
+type parameters labeled ‘-’ must only appear in contravariant
+position. Analogously, for a class definition
+`class ´C´[´\mathit{tps}\,´](´\mathit{ps}\,´) extends ´T´ { ´x´: ´S´ => ...}`,
+type parameters labeled
+‘+’ must only appear in covariant position in the
+self type ´S´ and the template ´T´, whereas type
+parameters labeled ‘-’ must only appear in contravariant
+position.
+
+The variance position of a type parameter in a type or template is
+defined as follows.  Let the opposite of covariance be contravariance,
+and the opposite of invariance be itself.  The top-level of the type
+or template is always in covariant position. The variance position
+changes at the following constructs.
+
+- The variance position of a method parameter is the opposite of the
+  variance position of the enclosing parameter clause.
+- The variance position of a type parameter is the opposite of the
+  variance position of the enclosing type parameter clause.
+- The variance position of the lower bound of a type declaration or type parameter
+  is the opposite of the variance position of the type declaration or parameter.
+- The type of a mutable variable is always in invariant position.
+- The right-hand side of a type alias is always in invariant position.
+- The prefix ´S´ of a type selection `´S´#´T´` is always in invariant position.
+- For a type argument ´T´ of a type `´S´[´\ldots T \ldots´ ]`: If the
+  corresponding type parameter is invariant, then ´T´ is in
+  invariant position.  If the corresponding type parameter is
+  contravariant, the variance position of ´T´ is the opposite of
+  the variance position of the enclosing type `´S´[´\ldots T \ldots´ ]`.
+
+<!-- TODO: handle type aliases -->
+
+References to the type parameters in
+[object-private or object-protected values, types, variables, or methods](05-classes-and-objects.html#modifiers) of the class are not
+checked for their variance position. In these members the type parameter may
+appear anywhere without restricting its legal variance annotations.
+
+###### Example
+The following variance annotation is legal.
+
+```scala
+abstract class P[+A, +B] {
+  def fst: A; def snd: B
+}
+```
+
+With this variance annotation, type instances
+of ´P´ subtype covariantly with respect to their arguments.
+For instance,
+
+```scala
+P[IOException, String] <: P[Throwable, AnyRef]
+```
+
+If the members of ´P´ are mutable variables,
+the same variance annotation becomes illegal.
+
+```scala
+abstract class Q[+A, +B](x: A, y: B) {
+  var fst: A = x           // **** error: illegal variance:
+  var snd: B = y           // `A', `B' occur in invariant position.
+}
+```
+
+If the mutable variables are object-private, the class definition
+becomes legal again:
+
+```scala
+abstract class R[+A, +B](x: A, y: B) {
+  private[this] var fst: A = x        // OK
+  private[this] var snd: B = y        // OK
+}
+```
+
+###### Example
+
+The following variance annotation is illegal, since ´a´ appears
+in contravariant position in the parameter of `append`:
+
+```scala
+abstract class Sequence[+A] {
+  def append(x: Sequence[A]): Sequence[A]
+                  // **** error: illegal variance:
+                  // `A' occurs in contravariant position.
+}
+```
+
+The problem can be avoided by generalizing the type of `append`
+by means of a lower bound:
+
+```scala
+abstract class Sequence[+A] {
+  def append[B >: A](x: Sequence[B]): Sequence[B]
+}
+```
+
+###### Example
+
+```scala
+abstract class OutputChannel[-A] {
+  def write(x: A): Unit
+}
+```
+
+With that annotation, we have that
+`OutputChannel[AnyRef]` conforms to `OutputChannel[String]`.
+That is, a
+channel on which one can write any object can substitute for a channel
+on which one can write only strings.
+
+## Function Declarations and Definitions
+
+```ebnf
+Dcl                ::=  ‘def’ FunDcl
+FunDcl             ::=  FunSig ‘:’ Type
+Def                ::=  ‘def’ FunDef
+FunDef             ::=  FunSig [‘:’ Type] ‘=’ Expr
+FunSig             ::=  id [FunTypeParamClause] ParamClauses
+FunTypeParamClause ::=  ‘[’ TypeParam {‘,’ TypeParam} ‘]’
+ParamClauses       ::=  {ParamClause} [[nl] ‘(’ ‘implicit’ Params ‘)’]
+ParamClause        ::=  [nl] ‘(’ [Params] ‘)’
+Params             ::=  Param {‘,’ Param}
+Param              ::=  {Annotation} id [‘:’ ParamType] [‘=’ Expr]
+ParamType          ::=  Type
+                     |  ‘=>’ Type
+                     |  Type ‘*’
+```
+
+A _function declaration_ has the form `def ´f\,\mathit{psig}´: ´T´`, where
+´f´ is the function's name, ´\mathit{psig}´ is its parameter
+signature and ´T´ is its result type. A _function definition_
+`def ´f\,\mathit{psig}´: ´T´ = ´e´` also includes a _function body_ ´e´,
+i.e. an expression which defines the function's result.  A parameter
+signature consists of an optional type parameter clause `[´\mathit{tps}\,´]`,
+followed by zero or more value parameter clauses
+`(´\mathit{ps}_1´)´\ldots´(´\mathit{ps}_n´)`.  Such a declaration or definition
+introduces a value with a (possibly polymorphic) method type whose
+parameter types and result type are as given.
+
+The type of the function body is expected to [conform](06-expressions.html#expression-typing)
+to the function's declared
+result type, if one is given. If the function definition is not
+recursive, the result type may be omitted, in which case it is
+determined from the packed type of the function body.
+
+A _type parameter clause_ ´\mathit{tps}´ consists of one or more
+[type declarations](#type-declarations-and-type-aliases), which introduce type
+parameters, possibly with bounds.  The scope of a type parameter includes
+the whole signature, including any of the type parameter bounds as
+well as the function body, if it is present.
+
+A _value parameter clause_ ´\mathit{ps}´ consists of zero or more formal
+parameter bindings such as `´x´: ´T´` or `´x: T = e´`, which bind value
+parameters and associate them with their types.
+
+### Default Arguments
+
+Each value parameter
+declaration may optionally define a default argument. The default argument
+expression ´e´ is type-checked with an expected type ´T'´ obtained
+by replacing all occurrences of the function's type parameters in ´T´ by
+the undefined type.
+
+For every parameter ´p_{i,j}´ with a default argument a method named
+`´f\$´default´\$´n` is generated which computes the default argument
+expression. Here, ´n´ denotes the parameter's position in the method
+declaration. These methods are parametrized by the type parameter clause
+`[´\mathit{tps}\,´]` and all value parameter clauses
+`(´\mathit{ps}_1´)´\ldots´(´\mathit{ps}_{i-1}´)` preceding ´p_{i,j}´.
+The `´f\$´default´\$´n` methods are inaccessible for user programs.
+
+###### Example
+In the method
+
+```scala
+def compare[T](a: T = 0)(b: T = a) = (a == b)
+```
+
+the default expression `0` is type-checked with an undefined expected
+type. When applying `compare()`, the default value `0` is inserted
+and `T` is instantiated to `Int`. The methods computing the default
+arguments have the form:
+
+```scala
+def compare´\$´default´\$´1[T]: Int = 0
+def compare´\$´default´\$´2[T](a: T): T = a
+```
+
+The scope of a formal value parameter name ´x´ comprises all subsequent
+parameter clauses, as well as the method return type and the function body, if
+they are given. Both type parameter names and value parameter names must
+be pairwise distinct.
+
+A default value which depends on earlier parameters uses the actual arguments
+if they are provided, not the default arguments.
+
+```scala
+def f(a: Int = 0)(b: Int = a + 1) = b // OK
+// def f(a: Int = 0, b: Int = a + 1)  // "error: not found: value a"
+f(10)()                               // returns 11 (not 1)
+```
+
+If an [implicit argument](07-implicits.html#implicit-parameters)
+is not found by implicit search, it may be supplied using a default argument.
+
+```scala
+implicit val i: Int = 2
+def f(implicit x: Int, s: String = "hi") = s * x
+f                                     // "hihi"
+```
+
+### By-Name Parameters
+
+```ebnf
+ParamType          ::=  ‘=>’ Type
+```
+
+The type of a value parameter may be prefixed by `=>`, e.g.
+`´x´: => ´T´`. The type of such a parameter is then the
+parameterless method type `=> ´T´`. This indicates that the
+corresponding argument is not evaluated at the point of function
+application, but instead is evaluated at each use within the
+function. That is, the argument is evaluated using _call-by-name_.
+
+The by-name modifier is disallowed for parameters of classes that
+carry a `val` or `var` prefix, including parameters of case
+classes for which a `val` prefix is implicitly generated.
+
+###### Example
+The declaration
+
+```scala
+def whileLoop (cond: => Boolean) (stat: => Unit): Unit
+```
+
+indicates that both parameters of `whileLoop` are evaluated using
+call-by-name.
+
+### Repeated Parameters
+
+```ebnf
+ParamType          ::=  Type ‘*’
+```
+
+The last value parameter of a parameter section may be suffixed by
+`'*'`, e.g. `(..., ´x´:´T´*)`.  The type of such a
+_repeated_ parameter inside the method is then the sequence type
+`scala.Seq[´T´]`.  Methods with repeated parameters
+`´T´*` take a variable number of arguments of type ´T´.
+That is, if a method ´m´ with type
+`(´p_1:T_1 , \ldots , p_n:T_n, p_s:S´*)´U´` is applied to arguments
+´(e_1 , \ldots , e_k)´ where ´k \geq n´, then ´m´ is taken in that application
+to have type ´(p_1:T_1 , \ldots , p_n:T_n, p_s:S , \ldots , p_{s'}:S)U´, with
+´k - n´ occurrences of type
+´S´ where any parameter names beyond ´p_s´ are fresh. The only exception to
+this rule is if the last argument is
+marked to be a _sequence argument_ via a `_*` type
+annotation. If ´m´ above is applied to arguments
+`(´e_1 , \ldots , e_n, e'´: _*)`, then the type of ´m´ in
+that application is taken to be
+`(´p_1:T_1, \ldots , p_n:T_n,p_{s}:´scala.Seq[´S´])`.
+
+It is not allowed to define any default arguments in a parameter section
+with a repeated parameter.
+
+###### Example
+The following method definition computes the sum of the squares of a
+variable number of integer arguments.
+
+```scala
+def sum(args: Int*) = {
+  var result = 0
+  for (arg <- args) result += arg
+  result
+}
+```
+
+The following applications of this method yield `0`, `1`,
+`6`, in that order.
+
+```scala
+sum()
+sum(1)
+sum(1, 2, 3)
+```
+
+Furthermore, assume the definition:
+
+```scala
+val xs = List(1, 2, 3)
+```
+
+The following application of method `sum` is ill-formed:
+
+```scala
+sum(xs)       // ***** error: expected: Int, found: List[Int]
+```
+
+By contrast, the following application is well formed and yields again
+the result `6`:
+
+```scala
+sum(xs: _*)
+```
+
+### Procedures
+
+```ebnf
+FunDcl   ::=  FunSig
+FunDef   ::=  FunSig [nl] ‘{’ Block ‘}’
+```
+
+Special syntax exists for procedures, i.e. functions that return the
+`Unit` value `()`.
+A _procedure declaration_ is a function declaration where the result type
+is omitted. The result type is then implicitly completed to the
+`Unit` type. E.g., `def ´f´(´\mathit{ps}´)` is equivalent to
+`def ´f´(´\mathit{ps}´): Unit`.
+
+A _procedure definition_ is a function definition where the result type
+and the equals sign are omitted; its defining expression must be a block.
+E.g., `def ´f´(´\mathit{ps}´) {´\mathit{stats}´}` is equivalent to
+`def ´f´(´\mathit{ps}´): Unit = {´\mathit{stats}´}`.
+
+###### Example
+Here is a declaration and a definition of a procedure named `write`:
+
+```scala
+trait Writer {
+  def write(str: String)
+}
+object Terminal extends Writer {
+  def write(str: String) { System.out.println(str) }
+}
+```
+
+The code above is implicitly completed to the following code:
+
+```scala
+trait Writer {
+  def write(str: String): Unit
+}
+object Terminal extends Writer {
+  def write(str: String): Unit = { System.out.println(str) }
+}
+```
+
+### Method Return Type Inference
+
+A class member definition ´m´ that overrides some other function ´m'´
+in a base class of ´C´ may leave out the return type, even if it is
+recursive. In this case, the return type ´R'´ of the overridden
+function ´m'´, seen as a member of ´C´, is taken as the return type of
+´m´ for each recursive invocation of ´m´. That way, a type ´R´ for the
+right-hand side of ´m´ can be determined, which is then taken as the
+return type of ´m´. Note that ´R´ may be different from ´R'´, as long
+as ´R´ conforms to ´R'´.
+
+###### Example
+Assume the following definitions:
+
+```scala
+trait I {
+  def factorial(x: Int): Int
+}
+class C extends I {
+  def factorial(x: Int) = if (x == 0) 1 else x * factorial(x - 1)
+}
+```
+
+Here, it is OK to leave out the result type of `factorial`
+in `C`, even though the method is recursive.
+
+<!-- ## Overloaded Definitions
+\label{sec:overloaded-defs}
+\todo{change}
+
+An overloaded definition is a set of ´n > 1´ value or function
+definitions in the same statement sequence that define the same name,
+binding it to types `´T_1 \commadots T_n´`, respectively.
+The individual definitions are called _alternatives_.  Overloaded
+definitions may only appear in the statement sequence of a template.
+Alternatives always need to specify the type of the defined entity
+completely.  It is an error if the types of two alternatives ´T_i´ and
+´T_j´ have the same erasure (\sref{sec:erasure}).
+
+\todo{Say something about bridge methods.}
+%This must be a well-formed
+%overloaded type -->
+
+## Import Clauses
+
+```ebnf
+Import          ::= ‘import’ ImportExpr {‘,’ ImportExpr}
+ImportExpr      ::= StableId ‘.’ (id | ‘_’ | ImportSelectors)
+ImportSelectors ::= ‘{’ {ImportSelector ‘,’}
+                    (ImportSelector | ‘_’) ‘}’
+ImportSelector  ::= id [‘=>’ id | ‘=>’ ‘_’]
+```
+
+An import clause has the form `import ´p´.´I´` where ´p´ is a
+[stable identifier](03-types.html#paths) and ´I´ is an import expression.
+The import expression determines a set of names of importable members of ´p´
+which are made available without qualification.  A member ´m´ of ´p´ is
+_importable_ if it is [accessible](05-classes-and-objects.html#modifiers).
+The most general form of an import expression is a list of _import selectors_
+
+```scala
+{ ´x_1´ => ´y_1 , \ldots , x_n´ => ´y_n´, _ }
+```
+
+for ´n \geq 0´, where the final wildcard `‘_’` may be absent.  It
+makes available each importable member `´p´.´x_i´` under the unqualified name
+´y_i´. I.e. every import selector `´x_i´ => ´y_i´` renames
+`´p´.´x_i´` to
+´y_i´.  If a final wildcard is present, all importable members ´z´ of
+´p´ other than `´x_1 , \ldots , x_n,y_1 , \ldots , y_n´` are also made available
+under their own unqualified names.
+
+Import selectors work in the same way for type and term members. For
+instance, an import clause `import ´p´.{´x´ => ´y\,´}` renames the term
+name `´p´.´x´` to the term name ´y´ and the type name `´p´.´x´`
+to the type name ´y´. At least one of these two names must
+reference an importable member of ´p´.
+
+If the target in an import selector is a wildcard, the import selector
+hides access to the source member. For instance, the import selector
+`´x´ => _` “renames” ´x´ to the wildcard symbol (which is
+unaccessible as a name in user programs), and thereby effectively
+prevents unqualified access to ´x´. This is useful if there is a
+final wildcard in the same import selector list, which imports all
+members not mentioned in previous import selectors.
+
+The scope of a binding introduced by an import-clause starts
+immediately after the import clause and extends to the end of the
+enclosing block, template, package clause, or compilation unit,
+whichever comes first.
+
+Several shorthands exist. An import selector may be just a simple name
+´x´. In this case, ´x´ is imported without renaming, so the
+import selector is equivalent to `´x´ => ´x´`. Furthermore, it is
+possible to replace the whole import selector list by a single
+identifier or wildcard. The import clause `import ´p´.´x´` is
+equivalent to `import ´p´.{´x\,´}`, i.e. it makes available without
+qualification the member ´x´ of ´p´. The import clause
+`import ´p´._` is equivalent to
+`import ´p´.{_}`,
+i.e. it makes available without qualification all members of ´p´
+(this is analogous to `import ´p´.*` in Java).
+
+An import clause with multiple import expressions
+`import ´p_1´.´I_1 , \ldots , p_n´.´I_n´` is interpreted as a
+sequence of import clauses
+`import ´p_1´.´I_1´; ´\ldots´; import ´p_n´.´I_n´`.
+
+###### Example
+Consider the object definition:
+
+```scala
+object M {
+  def z = 0, one = 1
+  def add(x: Int, y: Int): Int = x + y
+}
+```
+
+Then the block
+
+```scala
+{ import M.{one, z => zero, _}; add(zero, one) }
+```
+
+is equivalent to the block
+
+```scala
+{ M.add(M.z, M.one) }
+```
diff --git a/docs/_spec/05-classes-and-objects.md b/docs/_spec/05-classes-and-objects.md
new file mode 100644
index 000000000000..5c3a74e608a2
--- /dev/null
+++ b/docs/_spec/05-classes-and-objects.md
@@ -0,0 +1,1160 @@
+---
+title: Classes & Objects
+layout: default
+chapter: 5
+---
+
+# Classes and Objects
+
+```ebnf
+TmplDef          ::= [‘case’] ‘class’ ClassDef
+                  |  [‘case’] ‘object’ ObjectDef
+                  |  ‘trait’ TraitDef
+```
+
+[Classes](#class-definitions) and [objects](#object-definitions)
+are both defined in terms of _templates_.
+
+## Templates
+
+```ebnf
+ClassTemplate   ::=  [EarlyDefs] ClassParents [TemplateBody]
+TraitTemplate   ::=  [EarlyDefs] TraitParents [TemplateBody]
+ClassParents    ::=  Constr {‘with’ AnnotType}
+TraitParents    ::=  AnnotType {‘with’ AnnotType}
+TemplateBody    ::=  [nl] ‘{’ [SelfType] TemplateStat {semi TemplateStat} ‘}’
+SelfType        ::=  id [‘:’ Type] ‘=>’
+                 |   this ‘:’ Type ‘=>’
+```
+
+A _template_ defines the type signature, behavior and initial state of a
+trait or class of objects or of a single object. Templates form part of
+instance creation expressions, class definitions, and object
+definitions.  A template
+`´sc´ with ´mt_1´ with ´\ldots´ with ´mt_n´ { ´\mathit{stats}´ }`
+consists of a constructor invocation ´sc´
+which defines the template's _superclass_, trait references
+`´mt_1 , \ldots , mt_n´` ´(n \geq 0)´, which define the
+template's _traits_, and a statement sequence ´\mathit{stats}´ which
+contains initialization code and additional member definitions for the
+template.
+
+Each trait reference ´mt_i´ must denote a [trait](#traits).
+By contrast, the superclass constructor ´sc´ normally refers to a
+class which is not a trait. It is possible to write a list of
+parents that starts with a trait reference, e.g.
+`´mt_1´ with ´\ldots´ with ´mt_n´`. In that case the list
+of parents is implicitly extended to include the supertype of ´mt_1´
+as the first parent type. The new supertype must have at least one
+constructor that does not take parameters.  In the following, we will
+always assume that this implicit extension has been performed, so that
+the first parent class of a template is a regular superclass
+constructor, not a trait reference.
+
+The list of parents of a template must be well-formed. This means that
+the class denoted by the superclass constructor ´sc´ must be a
+subclass of the superclasses of all the traits ´mt_1 , \ldots , mt_n´.
+In other words, the non-trait classes inherited by a template form a
+chain in the inheritance hierarchy which starts with the template's
+superclass.
+
+The _least proper supertype_ of a template is the class type or
+[compound type](03-types.html#compound-types) consisting of all its parent
+class types.
+
+The statement sequence ´\mathit{stats}´ contains member definitions that
+define new members or overwrite members in the parent classes.  If the
+template forms part of an abstract class or trait definition, the
+statement part ´\mathit{stats}´ may also contain declarations of abstract
+members. If the template forms part of a concrete class definition,
+´\mathit{stats}´ may still contain declarations of abstract type members, but
+not of abstract term members.  Furthermore, ´\mathit{stats}´ may in any case
+also contain expressions; these are executed in the order they are
+given as part of the initialization of a template.
+
+The sequence of template statements may be prefixed with a formal
+parameter definition and an arrow, e.g. `´x´ =>`, or
+`´x´:´T´ =>`.  If a formal parameter is given, it can be
+used as an alias for the reference `this` throughout the
+body of the template.
+If the formal parameter comes with a type ´T´, this definition affects
+the _self type_ ´S´ of the underlying class or object as follows:  Let ´C´ be the type
+of the class or trait or object defining the template.
+If a type ´T´ is given for the formal self parameter, ´S´
+is the greatest lower bound of ´T´ and ´C´.
+If no type ´T´ is given, ´S´ is just ´C´.
+Inside the template, the type of `this` is assumed to be ´S´.
+
+The self type of a class or object must conform to the self types of
+all classes which are inherited by the template ´t´.
+
+A second form of self type annotation reads just
+`this: ´S´ =>`. It prescribes the type ´S´ for `this`
+without introducing an alias name for it.
+
+###### Example
+Consider the following class definitions:
+
+```scala
+class Base extends Object {}
+trait Mixin extends Base {}
+object O extends Mixin {}
+```
+
+In this case, the definition of `O` is expanded to:
+
+```scala
+object O extends Base with Mixin {}
+```
+
+<!-- TODO: Make all references to Java generic -->
+
+**Inheriting from Java Types**
+
+A template may have a Java class as its superclass and Java interfaces as its mixins.
+
+**Template Evaluation**
+
+Consider a template `´sc´ with ´mt_1´ with ´mt_n´ { ´\mathit{stats}´ }`.
+
+If this is the template of a [trait](#traits) then its _mixin-evaluation_
+consists of an evaluation of the statement sequence ´\mathit{stats}´.
+
+If this is not a template of a trait, then its _evaluation_
+consists of the following steps.
+
+- First, the superclass constructor ´sc´ is
+  [evaluated](#constructor-invocations).
+- Then, all base classes in the template's [linearization](#class-linearization)
+  up to the template's superclass denoted by ´sc´ are
+  mixin-evaluated. Mixin-evaluation happens in reverse order of
+  occurrence in the linearization.
+- Finally, the statement sequence ´\mathit{stats}\,´ is evaluated.
+
+###### Delayed Initialization
+This statement sequence constitutes the initialization code for an object
+or class after the superclass constructor invocation and the mixin-evaluation
+of the template's base classes as described above.
+Normally, this code is passed to a special hook, inaccessible to user code,
+which simply executes it.
+
+However, in objects and classes (but not traits) which extend `scala.DelayedInit`,
+the initialization code is passed to a `delayedInit` method which can be
+overridden to implement arbitrary semantics.
+
+```scala
+def delayedInit(body: => Unit): Unit
+```
+
+### Constructor Invocations
+
+```ebnf
+Constr  ::=  AnnotType {‘(’ [Exprs] ‘)’}
+```
+
+Constructor invocations define the type, members, and initial state of
+objects created by an instance creation expression, or of parts of an
+object's definition which are inherited by a class or object
+definition. A constructor invocation is a function application
+`´x´.´c´[´\mathit{targs}´](´\mathit{args}_1´)´\ldots´(´\mathit{args}_n´)`, where ´x´ is a
+[stable identifier](03-types.html#paths), ´c´ is a type name which either designates a
+class or defines an alias type for one, ´\mathit{targs}´ is a type argument
+list, ´\mathit{args}_1 , \ldots , \mathit{args}_n´ are argument lists, and there is a
+constructor of that class which is [applicable](06-expressions.html#function-applications)
+to the given arguments. If the constructor invocation uses named or
+default arguments, it is transformed into a block expression using the
+same transformation as described [here](sec:named-default).
+
+The prefix `´x´.` can be omitted.  A type argument list
+can be given only if the class ´c´ takes type parameters.  Even then
+it can be omitted, in which case a type argument list is synthesized
+using [local type inference](06-expressions.html#local-type-inference). If no explicit
+arguments are given, an empty list `()` is implicitly supplied.
+
+An evaluation of a constructor invocation
+`´x´.´c´[´\mathit{targs}´](´\mathit{args}_1´)´\ldots´(´\mathit{args}_n´)`
+consists of the following steps:
+
+- First, the prefix ´x´ is evaluated.
+- Then, the arguments ´\mathit{args}_1 , \ldots , \mathit{args}_n´ are evaluated from
+  left to right.
+- Finally, the class being constructed is initialized by evaluating the
+  template of the class referred to by ´c´.
+
+### Class Linearization
+
+The classes reachable through transitive closure of the direct
+inheritance relation from a class ´C´ are called the _base classes_ of ´C´.  Because of mixins, the inheritance relationship
+on base classes forms in general a directed acyclic graph. A
+linearization of this graph is defined as follows.
+
+###### Definition: linearization
+Let ´C´ be a class with template
+´C_1´ with ... with ´C_n´ { ´\mathit{stats}´ }`.
+The _linearization_ of ´C´, ´\mathcal{L}(C)´ is defined as follows:
+$$
+\mathcal{L}(C) = C, \mathcal{L}(C_n) \; \vec{+} \; \ldots \; \vec{+} \; \mathcal{L}(C_1)
+$$
+
+Here ´\vec{+}´ denotes concatenation where elements of the right operand
+replace identical elements of the left operand:
+
+$$
+\begin{array}{lcll}
+\{a, A\} \;\vec{+}\; B &=& a, (A \;\vec{+}\; B)  &{\bf if} \; a \not\in B \\\\
+                       &=& A \;\vec{+}\; B       &{\bf if} \; a \in B
+\end{array}
+$$
+
+###### Example
+Consider the following class definitions.
+
+```scala
+abstract class AbsIterator extends AnyRef { ... }
+trait RichIterator extends AbsIterator { ... }
+class StringIterator extends AbsIterator { ... }
+class Iter extends StringIterator with RichIterator { ... }
+```
+
+Then the linearization of class `Iter` is
+
+```scala
+{ Iter, RichIterator, StringIterator, AbsIterator, AnyRef, Any }
+```
+
+Note that the linearization of a class refines the inheritance
+relation: if ´C´ is a subclass of ´D´, then ´C´ precedes ´D´ in any
+linearization where both ´C´ and ´D´ occur.
+[Linearization](#definition:-linearization) also satisfies the property that
+a linearization of a class always contains the linearization of its direct superclass as a suffix.
+
+For instance, the linearization of `StringIterator` is
+
+```scala
+{ StringIterator, AbsIterator, AnyRef, Any }
+```
+
+which is a suffix of the linearization of its subclass `Iter`.
+The same is not true for the linearization of mixins.
+For instance, the linearization of `RichIterator` is
+
+```scala
+{ RichIterator, AbsIterator, AnyRef, Any }
+```
+
+which is not a suffix of the linearization of `Iter`.
+
+### Class Members
+
+A class ´C´ defined by a template `´C_1´ with ´\ldots´ with ´C_n´ { ´\mathit{stats}´ }`
+can define members in its statement sequence
+´\mathit{stats}´ and can inherit members from all parent classes.  Scala
+adopts Java and C\#'s conventions for static overloading of
+methods. It is thus possible that a class defines and/or inherits
+several methods with the same name.  To decide whether a defined
+member of a class ´C´ overrides a member of a parent class, or whether
+the two co-exist as overloaded variants in ´C´, Scala uses the
+following definition of _matching_ on members:
+
+###### Definition: matching
+A member definition ´M´ _matches_ a member definition ´M'´, if ´M´
+and ´M'´ bind the same name, and one of following holds.
+
+1. Neither ´M´ nor ´M'´ is a method definition.
+2. ´M´ and ´M'´ define both monomorphic methods with equivalent argument types.
+3. ´M´ defines a parameterless method and ´M'´ defines a method
+   with an empty parameter list `()` or _vice versa_.
+4. ´M´ and ´M'´ define both polymorphic methods with
+   equal number of argument types ´\overline T´, ´\overline T'´
+   and equal numbers of type parameters
+   ´\overline t´, ´\overline t'´, say, and  ´\overline T' = [\overline t'/\overline t]\overline T´.
+
+<!--
+every argument type
+´T_i´ of ´M´ is equal to the corresponding argument type ´T`_i´ of
+´M`´ where every occurrence of a type parameter ´t`´ of ´M`´ has been replaced by the corresponding type parameter ´t´ of ´M´.
+-->
+
+Member definitions fall into two categories: concrete and abstract.
+Members of class ´C´ are either _directly defined_ (i.e. they appear in
+´C´'s statement sequence ´\mathit{stats}´) or they are _inherited_.  There are two rules
+that determine the set of members of a class, one for each category:
+
+A _concrete member_ of a class ´C´ is any concrete definition ´M´ in
+some class ´C_i \in \mathcal{L}(C)´, except if there is a preceding class
+´C_j \in \mathcal{L}(C)´ where ´j < i´ which directly defines a concrete
+member ´M'´ matching ´M´.
+
+An _abstract member_ of a class ´C´ is any abstract definition ´M´
+in some class ´C_i \in \mathcal{L}(C)´, except if ´C´ contains already a
+concrete member ´M'´ matching ´M´, or if there is a preceding class
+´C_j \in \mathcal{L}(C)´ where ´j < i´ which directly defines an abstract
+member ´M'´ matching ´M´.
+
+This definition also determines the [overriding](#overriding) relationships
+between matching members of a class ´C´ and its parents.
+First, a concrete definition always overrides an abstract definition.
+Second, for definitions ´M´ and ´M´' which are both concrete or both abstract,
+´M´ overrides ´M'´ if ´M´ appears in a class that precedes (in the
+linearization of ´C´) the class in which ´M'´ is defined.
+
+It is an error if a template directly defines two matching members. It
+is also an error if a template contains two members (directly defined
+or inherited) with the same name and the same [erased type](03-types.html#type-erasure).
+Finally, a template is not allowed to contain two methods (directly
+defined or inherited) with the same name which both define default arguments.
+
+###### Example
+Consider the trait definitions:
+
+```scala
+trait A { def f: Int }
+trait B extends A { def f: Int = 1 ; def g: Int = 2 ; def h: Int = 3 }
+trait C extends A { override def f: Int = 4 ; def g: Int }
+trait D extends B with C { def h: Int }
+```
+
+Then trait `D` has a directly defined abstract member `h`. It
+inherits member `f` from trait `C` and member `g` from
+trait `B`.
+
+### Overriding
+
+<!-- TODO: Explain that classes cannot override each other -->
+
+A member ´M´ of class ´C´ that [matches](#class-members)
+a non-private member ´M'´ of a
+base class of ´C´ is said to _override_ that member.  In this case
+the binding of the overriding member ´M´ must [subsume](03-types.html#conformance)
+the binding of the overridden member ´M'´.
+Furthermore, the following restrictions on modifiers apply to ´M´ and
+´M'´:
+
+- ´M'´ must not be labeled `final`.
+- ´M´ must not be [`private`](#modifiers).
+- If ´M´ is labeled `private[´C´]` for some enclosing class or package ´C´,
+  then ´M'´ must be labeled `private[´C'´]` for some class or package ´C'´ where
+  ´C'´ equals ´C´ or ´C'´ is contained in ´C´.
+
+<!-- TODO: check whether this is accurate -->
+- If ´M´ is labeled `protected`, then ´M'´ must also be
+  labeled `protected`.
+- If ´M'´ is not an abstract member, then ´M´ must be labeled `override`.
+  Furthermore, one of two possibilities must hold:
+    - either ´M´ is defined in a subclass of the class where is ´M'´ is defined,
+    - or both ´M´ and ´M'´ override a third member ´M''´ which is defined
+      in a base class of both the classes containing ´M´ and ´M'´
+- If ´M'´ is [incomplete](#modifiers) in ´C´ then ´M´ must be
+  labeled `abstract override`.
+- If ´M´ and ´M'´ are both concrete value definitions, then either none
+  of them is marked `lazy` or both must be marked `lazy`.
+
+- A stable member can only be overridden by a stable member.
+  For example, this is not allowed:
+
+```scala
+class X { val stable = 1}
+class Y extends X { override var stable = 1 } // error
+```
+
+Another restriction applies to abstract type members: An abstract type
+member with a [volatile type](03-types.html#volatile-types) as its upper
+bound may not override an abstract type member which does not have a
+volatile upper bound.
+
+A special rule concerns parameterless methods. If a parameterless
+method defined as `def ´f´: ´T´ = ...` or `def ´f´ = ...` overrides a method of
+type ´()T'´ which has an empty parameter list, then ´f´ is also
+assumed to have an empty parameter list.
+
+An overriding method inherits all default arguments from the definition
+in the superclass. By specifying default arguments in the overriding method
+it is possible to add new defaults (if the corresponding parameter in the
+superclass does not have a default) or to override the defaults of the
+superclass (otherwise).
+
+###### Example
+
+Consider the definitions:
+
+```scala
+trait Root { type T <: Root }
+trait A extends Root { type T <: A }
+trait B extends Root { type T <: B }
+trait C extends A with B
+```
+
+Then the class definition `C` is not well-formed because the
+binding of `T` in `C` is
+`type T <: B`,
+which fails to subsume the binding `type T <: A` of `T`
+in type `A`. The problem can be solved by adding an overriding
+definition of type `T` in class `C`:
+
+```scala
+class C extends A with B { type T <: C }
+```
+
+### Inheritance Closure
+
+Let ´C´ be a class type. The _inheritance closure_ of ´C´ is the
+smallest set ´\mathscr{S}´ of types such that
+
+- ´C´ is in ´\mathscr{S}´.
+- If ´T´ is in ´\mathscr{S}´, then every type ´T'´ which forms syntactically
+  a part of ´T´ is also in ´\mathscr{S}´.
+- If ´T´ is a class type in ´\mathscr{S}´, then all [parents](#templates)
+  of ´T´ are also in ´\mathscr{S}´.
+
+It is a static error if the inheritance closure of a class type
+consists of an infinite number of types. (This restriction is
+necessary to make subtyping decidable[^kennedy]).
+
+[^kennedy]: Kennedy, Pierce. [On Decidability of Nominal Subtyping with Variance.]( https://research.microsoft.com/pubs/64041/fool2007.pdf) in FOOL 2007
+
+### Early Definitions
+
+```ebnf
+EarlyDefs         ::= ‘{’ [EarlyDef {semi EarlyDef}] ‘}’ ‘with’
+EarlyDef          ::=  {Annotation} {Modifier} PatVarDef
+```
+
+A template may start with an _early field definition_ clause,
+which serves to define certain field values before the supertype
+constructor is called. In a template
+
+```scala
+{ val ´p_1´: ´T_1´ = ´e_1´
+  ...
+  val ´p_n´: ´T_n´ = ´e_n´
+} with ´sc´ with ´mt_1´ with ´mt_n´ { ´\mathit{stats}´ }
+```
+
+The initial pattern definitions of ´p_1 , \ldots , p_n´ are called
+_early definitions_. They define fields
+which form part of the template. Every early definition must define
+at least one variable.
+
+An early definition is type-checked and evaluated in the scope which
+is in effect just before the template being defined, augmented by any
+type parameters of the enclosing class and by any early definitions
+preceding the one being defined. In particular, any reference to
+`this` in an early definition refers
+to the identity of `this` just outside the template. Consequently, it
+is impossible for an early definition to refer to the object being
+constructed by the template, or to refer to one of its fields and
+methods, except for any other preceding early definition in the same
+section. Furthermore, references to preceding early definitions
+always refer to the value that's defined there and do not take into account
+overriding definitions. In other words, a block of early definitions
+is evaluated exactly as if it were a local block containing a number of value
+definitions.
+
+Early definitions are evaluated
+before the superclass constructor of the template is called,
+in the order they are defined.
+
+###### Example
+Early definitions are particularly useful for
+traits, which do not have normal constructor parameters. Example:
+
+```scala
+trait Greeting {
+  val name: String
+  val msg = "How are you, "+name
+}
+class C extends {
+  val name = "Bob"
+} with Greeting {
+  println(msg)
+}
+```
+
+In the code above, the field `name` is initialized before the
+constructor of `Greeting` is called. Therefore, field `msg` in
+class `Greeting` is properly initialized to `"How are you, Bob"`.
+
+If `name` had been initialized instead in `C`'s normal class
+body, it would be initialized after the constructor of
+`Greeting`. In that case, `msg` would be initialized to
+`"How are you, <null>"`.
+
+## Modifiers
+
+```ebnf
+Modifier          ::=  LocalModifier
+                    |  AccessModifier
+                    |  ‘override’
+LocalModifier     ::=  ‘abstract’
+                    |  ‘final’
+                    |  ‘sealed’
+                    |  ‘implicit’
+                    |  ‘lazy’
+AccessModifier    ::=  (‘private’ | ‘protected’) [AccessQualifier]
+AccessQualifier   ::=  ‘[’ (id | ‘this’) ‘]’
+```
+
+Member definitions may be preceded by modifiers which affect the
+accessibility and usage of the identifiers bound by them.  If several
+modifiers are given, their order does not matter, but the same
+modifier may not occur more than once.  Modifiers preceding a repeated
+definition apply to all constituent definitions.  The rules governing
+the validity and meaning of a modifier are as follows.
+
+### `private`
+The `private` modifier can be used with any definition or declaration in a
+template. Private members of a template can be accessed only from within the
+directly enclosing template and its companion module or
+[companion class](#object-definitions).
+
+The `private` modifier is also valid for
+[top-level](09-top-level-definitions.html#packagings) templates.
+
+A `private` modifier can be _qualified_ with an identifier ´C´ (e.g.
+`private[´C´]`) that must denote a class or package enclosing the definition.
+Members labeled with such a modifier are accessible respectively only from code
+inside the package ´C´ or only from code inside the class ´C´ and its
+[companion module](#object-definitions).
+
+A different form of qualification is `private[this]`. A member
+´M´ marked with this modifier is called _object-protected_; it can be accessed only from within
+the object in which it is defined. That is, a selection ´p.M´ is only
+legal if the prefix is `this` or `´O´.this`, for some
+class ´O´ enclosing the reference. In addition, the restrictions for
+unqualified `private` apply.
+
+Members marked private without a qualifier are called _class-private_,
+whereas members labeled with `private[this]`
+are called _object-private_.  A member _is private_ if it is
+either class-private or object-private, but not if it is marked
+`private[´C´]` where ´C´ is an identifier; in the latter
+case the member is called _qualified private_.
+
+Class-private or object-private members may not be abstract, and may
+not have `protected` or `override` modifiers. They are not inherited
+by subclasses and they may not override definitions in parent classes.
+
+### `protected`
+The `protected` modifier applies to class member definitions.
+Protected members of a class can be accessed from within
+  - the template of the defining class,
+  - all templates that have the defining class as a base class,
+  - the companion module of any of those classes.
+
+A `protected` modifier can be qualified with an identifier ´C´ (e.g.
+`protected[´C´]`) that must denote a class or package enclosing the definition.
+Members labeled with such a modifier are also accessible respectively from all
+code inside the package ´C´ or from all code inside the class ´C´ and its
+[companion module](#object-definitions).
+
+A protected identifier ´x´ may be used as a member name in a selection
+`´r´.´x´` only if one of the following applies:
+  - The access is within the template defining the member, or, if
+    a qualification ´C´ is given, inside the package ´C´,
+    or the class ´C´, or its companion module, or
+  - ´r´ is one of the reserved words `this` and
+    `super`, or
+  - ´r´'s type conforms to a type-instance of the
+    class which contains the access.
+
+A different form of qualification is `protected[this]`. A member
+´M´ marked with this modifier is called _object-protected_; it can be accessed only from within
+the object in which it is defined. That is, a selection ´p.M´ is only
+legal if the prefix is `this` or `´O´.this`, for some
+class ´O´ enclosing the reference. In addition, the restrictions for
+unqualified `protected` apply.
+
+### `override`
+The `override` modifier applies to class member definitions or declarations.
+It is mandatory for member definitions or declarations that override some
+other concrete member definition in a parent class. If an `override`
+modifier is given, there must be at least one overridden member
+definition or declaration (either concrete or abstract).
+
+### `abstract override`
+The `override` modifier has an additional significance when
+combined with the `abstract` modifier.  That modifier combination
+is only allowed for value members of traits.
+
+We call a member ´M´ of a template _incomplete_ if it is either
+abstract (i.e. defined by a declaration), or it is labeled
+`abstract` and `override` and
+every member overridden by ´M´ is again incomplete.
+
+Note that the `abstract override` modifier combination does not
+influence the concept whether a member is concrete or abstract. A
+member is _abstract_ if only a declaration is given for it;
+it is _concrete_ if a full definition is given.
+
+### `abstract`
+The `abstract` modifier is used in class definitions. It is
+redundant for traits, and mandatory for all other classes which have
+incomplete members.  Abstract classes cannot be
+[instantiated](06-expressions.html#instance-creation-expressions) with a constructor invocation
+unless followed by mixins and/or a refinement which override all
+incomplete members of the class. Only abstract classes and traits can have
+abstract term members.
+
+The `abstract` modifier can also be used in conjunction with
+`override` for class member definitions. In that case the
+previous discussion applies.
+
+### `final`
+The `final` modifier applies to class member definitions and to
+class definitions. A `final` class member definition may not be
+overridden in subclasses. A `final` class may not be inherited by
+a template. `final` is redundant for object definitions.  Members
+of final classes or objects are implicitly also final, so the
+`final` modifier is generally redundant for them, too. Note, however, that
+[constant value definitions](04-basic-declarations-and-definitions.html#value-declarations-and-definitions)
+do require an explicit `final` modifier,
+even if they are defined in a final class or object.
+`final` is permitted for abstract classes
+but it may not be applied to traits or incomplete members,
+and it may not be combined in one modifier list with `sealed`.
+
+### `sealed`
+The `sealed` modifier applies to class definitions. A
+`sealed` class may not be directly inherited, except if the inheriting
+template is defined in the same source file as the inherited class.
+However, subclasses of a sealed class can be inherited anywhere.
+
+### `lazy`
+The `lazy` modifier applies to value definitions. A `lazy`
+value is initialized the first time it is accessed (which might never
+happen at all). Attempting to access a lazy value during its
+initialization might lead to looping behavior. If an exception is
+thrown during initialization, the value is considered uninitialized,
+and a later access will retry to evaluate its right hand side.
+
+###### Example
+The following code illustrates the use of qualified private:
+
+```scala
+package outerpkg.innerpkg
+class Outer {
+  class Inner {
+    private[Outer] def f()
+    private[innerpkg] def g()
+    private[outerpkg] def h()
+  }
+}
+```
+
+Here, accesses to the method `f` can appear anywhere within
+`Outer`, but not outside it. Accesses to method
+`g` can appear anywhere within the package
+`outerpkg.innerpkg`, as would be the case for
+package-private methods in Java. Finally, accesses to method
+`h` can appear anywhere within package `outerpkg`,
+including packages contained in it.
+
+###### Example
+A useful idiom to prevent clients of a class from
+constructing new instances of that class is to declare the class
+`abstract` and `sealed`:
+
+```scala
+object m {
+  abstract sealed class C (x: Int) {
+    def nextC = new C(x + 1) {}
+  }
+  val empty = new C(0) {}
+}
+```
+
+For instance, in the code above clients can create instances of class
+`m.C` only by calling the `nextC` method of an existing `m.C`
+object; it is not possible for clients to create objects of class
+`m.C` directly. Indeed the following two lines are both in error:
+
+```scala
+new m.C(0)    // **** error: C is abstract, so it cannot be instantiated.
+new m.C(0) {} // **** error: illegal inheritance from sealed class.
+```
+
+A similar access restriction can be achieved by marking the primary
+constructor `private` ([example](#example-private-constructor)).
+
+## Class Definitions
+
+```ebnf
+TmplDef           ::=  ‘class’ ClassDef
+ClassDef          ::=  id [TypeParamClause] {Annotation}
+                       [AccessModifier] ClassParamClauses ClassTemplateOpt
+ClassParamClauses ::=  {ClassParamClause}
+                       [[nl] ‘(’ implicit ClassParams ‘)’]
+ClassParamClause  ::=  [nl] ‘(’ [ClassParams] ‘)’
+ClassParams       ::=  ClassParam {‘,’ ClassParam}
+ClassParam        ::=  {Annotation} {Modifier} [(‘val’ | ‘var’)]
+                       id [‘:’ ParamType] [‘=’ Expr]
+ClassTemplateOpt  ::=  ‘extends’ ClassTemplate | [[‘extends’] TemplateBody]
+```
+
+The most general form of class definition is
+
+```scala
+class ´c´[´\mathit{tps}\,´] ´as´ ´m´(´\mathit{ps}_1´)´\ldots´(´\mathit{ps}_n´) extends ´t´    ´\quad(n \geq 0)´.
+```
+
+Here,
+
+  - ´c´ is the name of the class to be defined.
+  - ´\mathit{tps}´ is a non-empty list of type parameters of the class
+    being defined.  The scope of a type parameter is the whole class
+    definition including the type parameter section itself.  It is
+    illegal to define two type parameters with the same name.  The type
+    parameter section `[´\mathit{tps}\,´]` may be omitted. A class with a type
+    parameter section is called _polymorphic_, otherwise it is called
+    _monomorphic_.
+  - ´as´ is a possibly empty sequence of
+    [annotations](11-annotations.html#user-defined-annotations).
+    If any annotations are given, they apply to the primary constructor of the
+    class.
+  - ´m´ is an [access modifier](#modifiers) such as
+    `private` or `protected`, possibly with a qualification.
+    If such an access modifier is given it applies to the primary constructor of the class.
+  - ´(\mathit{ps}\_1)\ldots(\mathit{ps}\_n)´ are formal value parameter clauses for
+    the _primary constructor_ of the class. The scope of a formal value parameter includes
+    all subsequent parameter sections and the template ´t´. However, a formal
+    value parameter may not form part of the types of any of the parent classes or members of the class template ´t´.
+    It is illegal to define two formal value parameters with the same name.
+
+    If a class has no formal parameter section that is not implicit, an empty parameter section `()` is assumed.
+
+    If a formal parameter declaration ´x: T´ is preceded by a `val`
+    or `var` keyword, an accessor (getter) [definition](04-basic-declarations-and-definitions.html#variable-declarations-and-definitions)
+    for this parameter is implicitly added to the class.
+
+    The getter introduces a value member ´x´ of class ´c´ that is defined as an alias of the parameter.
+    If the introducing keyword is `var`, a setter accessor [`´x´_=`](04-basic-declarations-and-definitions.html#variable-declarations-and-definitions) is also implicitly added to the class.
+    In invocation of that setter  `´x´_=(´e´)` changes the value of the parameter to the result of evaluating ´e´.
+
+    The formal parameter declaration may contain modifiers, which then carry over to the accessor definition(s).
+    When access modifiers are given for a parameter, but no `val` or `var` keyword, `val` is assumed.
+    A formal parameter prefixed by `val` or `var` may not at the same time be a [call-by-name parameter](04-basic-declarations-and-definitions.html#by-name-parameters).
+
+  - ´t´ is a [template](#templates) of the form
+
+    ```scala
+    ´sc´ with ´mt_1´ with ´\ldots´ with ´mt_m´ { ´\mathit{stats}´ } // ´m \geq 0´
+    ```
+
+    which defines the base classes, behavior and initial state of objects of
+    the class. The extends clause
+    `extends ´sc´ with ´mt_1´ with ´\ldots´ with ´mt_m´`
+    can be omitted, in which case
+    `extends scala.AnyRef` is assumed.  The class body
+    `{ ´\mathit{stats}´ }` may also be omitted, in which case the empty body
+    `{}` is assumed.
+
+This class definition defines a type `´c´[´\mathit{tps}\,´]` and a constructor
+which when applied to parameters conforming to types ´\mathit{ps}´
+initializes instances of type `´c´[´\mathit{tps}\,´]` by evaluating the template
+´t´.
+
+###### Example – `val` and `var` parameters
+The following example illustrates `val` and `var` parameters of a class `C`:
+
+```scala
+class C(x: Int, val y: String, var z: List[String])
+val c = new C(1, "abc", List())
+c.z = c.y :: c.z
+```
+
+###### Example – Private Constructor
+The following class can be created only from its companion module.
+
+```scala
+object Sensitive {
+  def makeSensitive(credentials: Certificate): Sensitive =
+    if (credentials == Admin) new Sensitive()
+    else throw new SecurityViolationException
+}
+class Sensitive private () {
+  ...
+}
+```
+
+### Constructor Definitions
+
+```ebnf
+FunDef         ::= ‘this’ ParamClause ParamClauses
+                   (‘=’ ConstrExpr | [nl] ConstrBlock)
+ConstrExpr     ::= SelfInvocation
+                |  ConstrBlock
+ConstrBlock    ::= ‘{’ SelfInvocation {semi BlockStat} ‘}’
+SelfInvocation ::= ‘this’ ArgumentExprs {ArgumentExprs}
+```
+
+A class may have additional constructors besides the primary
+constructor.  These are defined by constructor definitions of the form
+`def this(´\mathit{ps}_1´)´\ldots´(´\mathit{ps}_n´) = ´e´`.  Such a
+definition introduces an additional constructor for the enclosing
+class, with parameters as given in the formal parameter lists ´\mathit{ps}_1
+, \ldots , \mathit{ps}_n´, and whose evaluation is defined by the constructor
+expression ´e´.  The scope of each formal parameter is the subsequent
+parameter sections and the constructor
+expression ´e´.  A constructor expression is either a self constructor
+invocation `this(´\mathit{args}_1´)´\ldots´(´\mathit{args}_n´)` or a block
+which begins with a self constructor invocation. The self constructor
+invocation must construct a generic instance of the class. I.e. if the
+class in question has name ´C´ and type parameters
+`[´\mathit{tps}\,´]`, then a self constructor invocation must
+generate an instance of `´C´[´\mathit{tps}\,´]`; it is not permitted
+to instantiate formal type parameters.
+
+The signature and the self constructor invocation of a constructor
+definition are type-checked and evaluated in the scope which is in
+effect at the point of the enclosing class definition, augmented by
+any type parameters of the enclosing class and by any
+[early definitions](#early-definitions) of the enclosing template.
+The rest of the
+constructor expression is type-checked and evaluated as a function
+body in the current class.
+
+If there are auxiliary constructors of a class ´C´, they form together
+with ´C´'s primary [constructor](#class-definitions)
+an overloaded constructor
+definition. The usual rules for
+[overloading resolution](06-expressions.html#overloading-resolution)
+apply for constructor invocations of ´C´,
+including for the self constructor invocations in the constructor
+expressions themselves. However, unlike other methods, constructors
+are never inherited.  To prevent infinite cycles of constructor
+invocations, there is the restriction that every self constructor
+invocation must refer to a constructor definition which precedes it
+(i.e. it must refer to either a preceding auxiliary constructor or the
+primary constructor of the class).
+
+###### Example
+Consider the class definition
+
+```scala
+class LinkedList[A]() {
+  var head: A = _
+  var tail: LinkedList[A] = null
+  def this(head: A) = { this(); this.head = head }
+  def this(head: A, tail: LinkedList[A]) = { this(head); this.tail = tail }
+}
+```
+
+This defines a class `LinkedList` with three constructors.  The
+second constructor constructs a singleton list, while the
+third one constructs a list with a given head and tail.
+
+### Case Classes
+
+```ebnf
+TmplDef  ::=  ‘case’ ‘class’ ClassDef
+```
+
+If a class definition is prefixed with `case`, the class is said
+to be a _case class_.
+
+A case class is required to have a parameter section that is not implicit.
+The formal parameters in the first parameter section 
+are called _elements_ and are treated specially.
+First, the value of such a parameter can be extracted as a
+field of a constructor pattern. Second, a `val` prefix is
+implicitly added to such a parameter, unless the parameter already carries
+a `val` or `var` modifier. Hence, an accessor
+definition for the parameter is [generated](#class-definitions).
+
+A case class definition of `´c´[´\mathit{tps}\,´](´\mathit{ps}_1\,´)´\ldots´(´\mathit{ps}_n´)` with type
+parameters ´\mathit{tps}´ and value parameters ´\mathit{ps}´ implies
+the definition of a companion object, which serves as an [extractor object](08-pattern-matching.html#extractor-patterns). It has the following shape:
+
+```scala
+object ´c´ {
+  def apply[´\mathit{tps}\,´](´\mathit{ps}_1\,´)´\ldots´(´\mathit{ps}_n´): ´c´[´\mathit{tps}\,´] = new ´c´[´\mathit{Ts}\,´](´\mathit{xs}_1\,´)´\ldots´(´\mathit{xs}_n´)
+  def unapply[´\mathit{tps}\,´](´x´: ´c´[´\mathit{tps}\,´]) =
+    if (x eq null) scala.None
+    else scala.Some(´x.\mathit{xs}_{11}, \ldots , x.\mathit{xs}_{1k}´)
+}
+```
+
+Here, ´\mathit{Ts}´ stands for the vector of types defined in the type
+parameter section ´\mathit{tps}´,
+each ´\mathit{xs}\_i´ denotes the parameter names of the parameter
+section ´\mathit{ps}\_i´, and
+´\mathit{xs}\_{11}, \ldots , \mathit{xs}\_{1k}´ denote the names of all parameters
+in the first parameter section ´\mathit{xs}\_1´.
+If a type parameter section is missing in the class, it is also missing in the `apply` and `unapply` methods.
+
+If the companion object ´c´ is already defined,
+the  `apply` and `unapply` methods are added to the existing object.
+If the object ´c´ already has a [matching](#definition-matching)
+`apply` (or `unapply`) member, no new definition is added.
+The definition of `apply` is omitted if class ´c´ is `abstract`.
+
+If the case class definition contains an empty value parameter list, the
+`unapply` method returns a `Boolean` instead of an `Option` type and
+is defined as follows:
+
+```scala
+def unapply[´\mathit{tps}\,´](´x´: ´c´[´\mathit{tps}\,´]) = x ne null
+```
+
+The name of the `unapply` method is changed to `unapplySeq` if the first
+parameter section ´\mathit{ps}_1´ of ´c´ ends in a
+[repeated parameter](04-basic-declarations-and-definitions.html#repeated-parameters).
+
+A method named `copy` is implicitly added to every case class unless the
+class already has a member (directly defined or inherited) with that name, or the
+class has a repeated parameter. The method is defined as follows:
+
+```scala
+def copy[´\mathit{tps}\,´](´\mathit{ps}'_1\,´)´\ldots´(´\mathit{ps}'_n´): ´c´[´\mathit{tps}\,´] = new ´c´[´\mathit{Ts}\,´](´\mathit{xs}_1\,´)´\ldots´(´\mathit{xs}_n´)
+```
+
+Again, `´\mathit{Ts}´` stands for the vector of types defined in the type parameter section `´\mathit{tps}´`
+and each `´xs_i´` denotes the parameter names of the parameter section `´ps'_i´`. The value
+parameters `´ps'_{1,j}´` of first parameter list have the form `´x_{1,j}´:´T_{1,j}´=this.´x_{1,j}´`,
+the other parameters `´ps'_{i,j}´` of the `copy` method are defined as `´x_{i,j}´:´T_{i,j}´`.
+In all cases `´x_{i,j}´` and `´T_{i,j}´` refer to the name and type of the corresponding class parameter
+`´\mathit{ps}_{i,j}´`.
+
+Every case class implicitly overrides some method definitions of class
+[`scala.AnyRef`](12-the-scala-standard-library.html#root-classes) unless a definition of the same
+method is already given in the case class itself or a concrete
+definition of the same method is given in some base class of the case
+class different from `AnyRef`. In particular:
+
+- Method `equals: (Any)Boolean` is structural equality, where two
+  instances are equal if they both belong to the case class in question and they
+  have equal (with respect to `equals`) constructor arguments (restricted to the class's _elements_, i.e., the first parameter section).
+- Method `hashCode: Int` computes a hash-code. If the hashCode methods
+  of the data structure members map equal (with respect to equals)
+  values to equal hash-codes, then the case class hashCode method does
+  too.
+- Method `toString: String` returns a string representation which
+  contains the name of the class and its elements.
+
+###### Example
+Here is the definition of abstract syntax for lambda calculus:
+
+```scala
+class Expr
+case class Var   (x: String)          extends Expr
+case class Apply (f: Expr, e: Expr)   extends Expr
+case class Lambda(x: String, e: Expr) extends Expr
+```
+
+This defines a class `Expr` with case classes
+`Var`, `Apply` and `Lambda`. A call-by-value evaluator
+for lambda expressions could then be written as follows.
+
+```scala
+type Env = String => Value
+case class Value(e: Expr, env: Env)
+
+def eval(e: Expr, env: Env): Value = e match {
+  case Var (x) =>
+    env(x)
+  case Apply(f, g) =>
+    val Value(Lambda (x, e1), env1) = eval(f, env)
+    val v = eval(g, env)
+    eval (e1, (y => if (y == x) v else env1(y)))
+  case Lambda(_, _) =>
+    Value(e, env)
+}
+```
+
+It is possible to define further case classes that extend type
+`Expr` in other parts of the program, for instance
+
+```scala
+case class Number(x: Int) extends Expr
+```
+
+This form of extensibility can be excluded by declaring the base class
+`Expr` `sealed`; in this case, all classes that
+directly extend `Expr` must be in the same source file as
+`Expr`.
+
+## Traits
+
+```ebnf
+TmplDef          ::=  ‘trait’ TraitDef
+TraitDef         ::=  id [TypeParamClause] TraitTemplateOpt
+TraitTemplateOpt ::=  ‘extends’ TraitTemplate | [[‘extends’] TemplateBody]
+```
+
+A _trait_ is a class that is meant to be added to some other class
+as a mixin. Unlike normal classes, traits cannot have
+constructor parameters. Furthermore, no constructor arguments are
+passed to the superclass of the trait. This is not necessary as traits are
+initialized after the superclass is initialized.
+
+Assume a trait ´D´ defines some aspect of an instance ´x´ of type ´C´ (i.e. ´D´ is a base class of ´C´).
+Then the _actual supertype_ of ´D´ in ´x´ is the compound type consisting of all the
+base classes in ´\mathcal{L}(C)´ that succeed ´D´.  The actual supertype gives
+the context for resolving a [`super` reference](06-expressions.html#this-and-super) in a trait.
+Note that the actual supertype depends on the type to which the trait is added in a mixin composition;
+it is not statically known at the time the trait is defined.
+
+If ´D´ is not a trait, then its actual supertype is simply its
+least proper supertype (which is statically known).
+
+###### Example
+The following trait defines the property
+of being comparable to objects of some type. It contains an abstract
+method `<` and default implementations of the other
+comparison operators `<=`, `>`, and
+`>=`.
+
+```scala
+trait Comparable[T <: Comparable[T]] { self: T =>
+  def < (that: T): Boolean
+  def <=(that: T): Boolean = this < that || this == that
+  def > (that: T): Boolean = that < this
+  def >=(that: T): Boolean = that <= this
+}
+```
+
+###### Example
+Consider an abstract class `Table` that implements maps
+from a type of keys `A` to a type of values `B`. The class
+has a method `set` to enter a new key / value pair into the table,
+and a method `get` that returns an optional value matching a
+given key. Finally, there is a method `apply` which is like
+`get`, except that it returns a given default value if the table
+is undefined for the given key. This class is implemented as follows.
+
+```scala
+abstract class Table[A, B](defaultValue: B) {
+  def get(key: A): Option[B]
+  def set(key: A, value: B): Unit
+  def apply(key: A) = get(key) match {
+    case Some(value) => value
+    case None => defaultValue
+  }
+}
+```
+
+Here is a concrete implementation of the `Table` class.
+
+```scala
+class ListTable[A, B](defaultValue: B) extends Table[A, B](defaultValue) {
+  private var elems: List[(A, B)] = Nil
+  def get(key: A) = elems.find(_._1 == key).map(_._2)
+  def set(key: A, value: B) = { elems = (key, value) :: elems }
+}
+```
+
+Here is a trait that prevents concurrent access to the
+`get` and `set` operations of its parent class:
+
+```scala
+trait SynchronizedTable[A, B] extends Table[A, B] {
+  abstract override def get(key: A): B =
+    synchronized { super.get(key) }
+  abstract override def set(key: A, value: B) =
+    synchronized { super.set(key, value) }
+}
+```
+
+Note that `SynchronizedTable` does not pass an argument to
+its superclass, `Table`, even  though `Table` is defined with a
+formal parameter. Note also that the `super` calls
+in `SynchronizedTable`'s `get` and `set` methods
+statically refer to abstract methods in class `Table`. This is
+legal, as long as the calling method is labeled
+[`abstract override`](#modifiers).
+
+Finally, the following mixin composition creates a synchronized list
+table with strings as keys and integers as values and with a default
+value `0`:
+
+```scala
+object MyTable extends ListTable[String, Int](0) with SynchronizedTable[String, Int]
+```
+
+The object `MyTable` inherits its `get` and `set`
+method from `SynchronizedTable`.  The `super` calls in these
+methods are re-bound to refer to the corresponding implementations in
+`ListTable`, which is the actual supertype of `SynchronizedTable`
+in `MyTable`.
+
+## Object Definitions
+
+```ebnf
+ObjectDef       ::=  id ClassTemplate
+```
+
+An _object definition_ defines a single object of a new class. Its
+most general form is
+`object ´m´ extends ´t´`. Here,
+´m´ is the name of the object to be defined, and
+´t´ is a [template](#templates) of the form
+
+```scala
+´sc´ with ´mt_1´ with ´\ldots´ with ´mt_n´ { ´\mathit{stats}´ }
+```
+
+which defines the base classes, behavior and initial state of ´m´.
+The extends clause `extends ´sc´ with ´mt_1´ with ´\ldots´ with ´mt_n´`
+can be omitted, in which case
+`extends scala.AnyRef` is assumed.  The class body
+`{ ´\mathit{stats}´ }` may also be omitted, in which case the empty body
+`{}` is assumed.
+
+The object definition defines a single object (or: _module_)
+conforming to the template ´t´.  It is roughly equivalent to the
+following definition of a lazy value:
+
+```scala
+lazy val ´m´ = new ´sc´ with ´mt_1´ with ´\ldots´ with ´mt_n´ { this: ´m.type´ => ´\mathit{stats}´ }
+```
+
+Note that the value defined by an object definition is instantiated
+lazily.  The `new ´m´$cls` constructor is evaluated
+not at the point of the object definition, but is instead evaluated
+the first time ´m´ is dereferenced during execution of the program
+(which might be never at all). An attempt to dereference ´m´ again
+during evaluation of the constructor will lead to an infinite loop
+or run-time error.
+Other threads trying to dereference ´m´ while the
+constructor is being evaluated block until evaluation is complete.
+
+The expansion given above is not accurate for top-level objects. It
+cannot be because variable and method definition cannot appear on the
+top-level outside of a [package object](09-top-level-definitions.html#package-objects). Instead,
+top-level objects are translated to static fields.
+
+###### Example
+Classes in Scala do not have static members; however, an equivalent
+effect can be achieved by an accompanying object definition
+E.g.
+
+```scala
+abstract class Point {
+  val x: Double
+  val y: Double
+  def isOrigin = (x == 0.0 && y == 0.0)
+}
+object Point {
+  val origin = new Point() { val x = 0.0; val y = 0.0 }
+}
+```
+
+This defines a class `Point` and an object `Point` which
+contains `origin` as a member.  Note that the double use of the
+name `Point` is legal, since the class definition defines the
+name `Point` in the type name space, whereas the object
+definition defines a name in the term namespace.
+
+This technique is applied by the Scala compiler when interpreting a
+Java class with static members. Such a class ´C´ is conceptually seen
+as a pair of a Scala class that contains all instance members of ´C´
+and a Scala object that contains all static members of ´C´.
+
+Generally, a _companion module_ of a class is an object which has
+the same name as the class and is defined in the same scope and
+compilation unit. Conversely, the class is called the _companion class_
+of the module.
+
+Very much like a concrete class definition, an object definition may
+still contain declarations of abstract type members, but not of
+abstract term members.
diff --git a/docs/_spec/06-expressions.md b/docs/_spec/06-expressions.md
new file mode 100644
index 000000000000..f574d7ad2469
--- /dev/null
+++ b/docs/_spec/06-expressions.md
@@ -0,0 +1,1828 @@
+---
+title: Expressions
+layout: default
+chapter: 6
+---
+
+# Expressions
+
+```ebnf
+Expr         ::=  (Bindings | id | ‘_’) ‘=>’ Expr
+               |  Expr1
+Expr1        ::=  ‘if’ ‘(’ Expr ‘)’ {nl} Expr [[semi] ‘else’ Expr]
+               |  ‘while’ ‘(’ Expr ‘)’ {nl} Expr
+               |  ‘try’ Expr [‘catch’ Expr] [‘finally’ Expr]
+               |  ‘do’ Expr [semi] ‘while’ ‘(’ Expr ‘)’
+               |  ‘for’ (‘(’ Enumerators ‘)’ | ‘{’ Enumerators ‘}’) {nl} [‘yield’] Expr
+               |  ‘throw’ Expr
+               |  ‘return’ [Expr]
+               |  [SimpleExpr ‘.’] id ‘=’ Expr
+               |  SimpleExpr1 ArgumentExprs ‘=’ Expr
+               |  PostfixExpr
+               |  PostfixExpr Ascription
+               |  PostfixExpr ‘match’ ‘{’ CaseClauses ‘}’
+PostfixExpr  ::=  InfixExpr [id [nl]]
+InfixExpr    ::=  PrefixExpr
+               |  InfixExpr id [nl] InfixExpr
+PrefixExpr   ::=  [‘-’ | ‘+’ | ‘~’ | ‘!’] SimpleExpr
+SimpleExpr   ::=  ‘new’ (ClassTemplate | TemplateBody)
+               |  BlockExpr
+               |  SimpleExpr1 [‘_’]
+SimpleExpr1  ::=  Literal
+               |  Path
+               |  ‘_’
+               |  ‘(’ [Exprs] ‘)’
+               |  SimpleExpr ‘.’ id
+               |  SimpleExpr TypeArgs
+               |  SimpleExpr1 ArgumentExprs
+               |  XmlExpr
+Exprs        ::=  Expr {‘,’ Expr}
+BlockExpr    ::=  ‘{’ CaseClauses ‘}’
+               |  ‘{’ Block ‘}’
+Block        ::=  BlockStat {semi BlockStat} [ResultExpr]
+ResultExpr   ::=  Expr1
+               |  (Bindings | ([‘implicit’] id | ‘_’) ‘:’ CompoundType) ‘=>’ Block
+Ascription   ::=  ‘:’ InfixType
+               |  ‘:’ Annotation {Annotation}
+               |  ‘:’ ‘_’ ‘*’
+```
+
+Expressions are composed of operators and operands. Expression forms are
+discussed subsequently in decreasing order of precedence.
+
+## Expression Typing
+
+The typing of expressions is often relative to some _expected type_  (which might be undefined). When we write "expression ´e´ is expected to conform to type ´T´", we mean:
+  1. the expected type of ´e´ is ´T´, and
+  2. the type of expression ´e´ must conform to ´T´.
+
+The following skolemization rule is applied universally for every
+expression: If the type of an expression would be an existential type
+´T´, then the type of the expression is assumed instead to be a
+[skolemization](03-types.html#existential-types) of ´T´.
+
+Skolemization is reversed by type packing. Assume an expression ´e´ of
+type ´T´ and let ´t_1[\mathit{tps}\_1] >: L_1 <: U_1 , \ldots , t_n[\mathit{tps}\_n] >: L_n <: U_n´ be
+all the type variables created by skolemization of some part of ´e´ which are free in ´T´.
+Then the _packed type_ of ´e´ is
+
+```scala
+´T´ forSome { type ´t_1[\mathit{tps}\_1] >: L_1 <: U_1´; ´\ldots´; type ´t_n[\mathit{tps}\_n] >: L_n <: U_n´ }.
+```
+
+## Literals
+
+```ebnf
+SimpleExpr    ::=  Literal
+```
+
+Typing of literals is described along with their [lexical syntax](01-lexical-syntax.html#literals);
+their evaluation is immediate.
+
+## The _Null_ Value
+
+The `null` value is of type `scala.Null`, and thus conforms to every reference type.
+It denotes a reference value which refers to a special `null` object.
+This object implements methods in class `scala.AnyRef` as follows:
+
+- `eq(´x\,´)` and `==(´x\,´)` return `true` iff the
+  argument ´x´ is also the "null" object.
+- `ne(´x\,´)` and `!=(´x\,´)` return true iff the
+  argument x is not also the "null" object.
+- `isInstanceOf[´T\,´]` always returns `false`.
+- `asInstanceOf[´T\,´]` returns the [default value](04-basic-declarations-and-definitions.html#value-declarations-and-definitions) of type ´T´.
+- `##` returns ``0``.
+
+A reference to any other member of the "null" object causes a
+`NullPointerException` to be thrown.
+
+## Designators
+
+```ebnf
+SimpleExpr  ::=  Path
+              |  SimpleExpr ‘.’ id
+```
+
+A designator refers to a named term. It can be a _simple name_ or
+a _selection_.
+
+A simple name ´x´ refers to a value as specified
+[here](02-identifiers-names-and-scopes.html#identifiers,-names-and-scopes).
+If ´x´ is bound by a definition or declaration in an enclosing class
+or object ´C´, it is taken to be equivalent to the selection
+`´C´.this.´x´` where ´C´ is taken to refer to the class containing ´x´
+even if the type name ´C´ is [shadowed](02-identifiers-names-and-scopes.html#identifiers,-names-and-scopes) at the
+occurrence of ´x´.
+
+If ´r´ is a [stable identifier](03-types.html#paths) of type ´T´, the selection ´r.x´ refers
+statically to a term member ´m´ of ´r´ that is identified in ´T´ by
+the name ´x´.
+
+<!-- There might be several such members, in which
+case overloading resolution (\sref{overloading-resolution}) is applied
+to pick a unique one.}  -->
+
+For other expressions ´e´, ´e.x´ is typed as
+if it was `{ val ´y´ = ´e´; ´y´.´x´ }`, for some fresh name
+´y´.
+
+The expected type of a designator's prefix is always undefined.  The
+type of a designator is the type ´T´ of the entity it refers to, with
+the following exception: The type of a [path](03-types.html#paths) ´p´
+which occurs in a context where a [stable type](03-types.html#singleton-types)
+is required is the singleton type `´p´.type`.
+
+The contexts where a stable type is required are those that satisfy
+one of the following conditions:
+
+1. The path ´p´ occurs as the prefix of a selection and it does not
+designate a constant, or
+1. The expected type ´\mathit{pt}´ is a stable type, or
+1. The expected type ´\mathit{pt}´ is an abstract type with a stable type as lower
+   bound, and the type ´T´ of the entity referred to by ´p´ does not
+   conform to ´\mathit{pt}´, or
+1. The path ´p´ designates a module.
+
+The selection ´e.x´ is evaluated by first evaluating the qualifier
+expression ´e´, which yields an object ´r´, say. The selection's
+result is then the member of ´r´ that is either defined by ´m´ or defined
+by a definition overriding ´m´.
+
+## This and Super
+
+```ebnf
+SimpleExpr  ::=  [id ‘.’] ‘this’
+              |  [id ‘.’] ‘super’ [ClassQualifier] ‘.’ id
+```
+
+The expression `this` can appear in the statement part of a
+template or compound type. It stands for the object being defined by
+the innermost template or compound type enclosing the reference. If
+this is a compound type, the type of `this` is that compound type.
+If it is a template of a
+class or object definition with simple name ´C´, the type of this
+is the same as the type of `´C´.this`.
+
+The expression `´C´.this` is legal in the statement part of an
+enclosing class or object definition with simple name ´C´. It
+stands for the object being defined by the innermost such definition.
+If the expression's expected type is a stable type, or
+`´C´.this` occurs as the prefix of a selection, its type is
+`´C´.this.type`, otherwise it is the self type of class ´C´.
+
+A reference `super.´m´` refers statically to a method or type ´m´
+in the least proper supertype of the innermost template containing the
+reference.  It evaluates to the member ´m'´ in the actual supertype of
+that template which is equal to ´m´ or which overrides ´m´.  The
+statically referenced member ´m´ must be a type or a
+method.
+
+<!-- explanation: so that we need not create several fields for overriding vals -->
+
+If it is
+a method, it must be concrete, or the template
+containing the reference must have a member ´m'´ which overrides ´m´
+and which is labeled `abstract override`.
+
+A reference `´C´.super.´m´` refers statically to a method
+or type ´m´ in the least proper supertype of the innermost enclosing class or
+object definition named ´C´ which encloses the reference. It evaluates
+to the member ´m'´ in the actual supertype of that class or object
+which is equal to ´m´ or which overrides ´m´. The
+statically referenced member ´m´ must be a type or a
+method.  If the statically
+referenced member ´m´ is a method, it must be concrete, or the innermost enclosing
+class or object definition named ´C´ must have a member ´m'´ which
+overrides ´m´ and which is labeled `abstract override`.
+
+The `super` prefix may be followed by a trait qualifier
+`[´T\,´]`, as in `´C´.super[´T\,´].´x´`. This is
+called a _static super reference_.  In this case, the reference is
+to the type or method of ´x´ in the parent trait of ´C´ whose simple
+name is ´T´. That member must be uniquely defined. If it is a method,
+it must be concrete.
+
+###### Example
+Consider the following class definitions
+
+```scala
+class Root { def x = "Root" }
+class A extends Root { override def x = "A" ; def superA = super.x }
+trait B extends Root { override def x = "B" ; def superB = super.x }
+class C extends Root with B {
+  override def x = "C" ; def superC = super.x
+}
+class D extends A with B {
+  override def x = "D" ; def superD = super.x
+}
+```
+
+The linearization of class `C` is `{C, B, Root}` and
+the linearization of class `D` is `{D, B, A, Root}`.
+Then we have:
+
+```scala
+(new A).superA == "Root"
+
+(new C).superB == "Root"
+(new C).superC == "B"
+
+(new D).superA == "Root"
+(new D).superB == "A"
+(new D).superD == "B"
+```
+
+Note that the `superB` method returns different results
+depending on whether `B` is mixed in with class `Root` or `A`.
+
+## Function Applications
+
+```ebnf
+SimpleExpr    ::=  SimpleExpr1 ArgumentExprs
+ArgumentExprs ::=  ‘(’ [Exprs] ‘)’
+                |  ‘(’ ‘using’ Exprs ‘)’
+                |  ‘(’ [Exprs ‘,’] PostfixExpr ‘:’ ‘_’ ‘*’ ‘)’
+                |  [nl] BlockExpr
+Exprs         ::=  Expr {‘,’ Expr}
+```
+
+An application `´f(e_1 , \ldots , e_m)´` applies the function `´f´` to the argument expressions `´e_1, \ldots , e_m´`. For this expression to be well-typed, the function must be *applicable* to its arguments, which is defined next by case analysis on ´f´'s type.
+
+If ´f´ has a method type `(´p_1´:´T_1 , \ldots , p_n´:´T_n´)´U´`, each argument expression ´e_i´ is typed with the corresponding parameter type ´T_i´ as expected type. Let ´S_i´ be the type of argument ´e_i´ ´(i = 1 , \ldots , m)´. The method ´f´ must be _applicable_ to its arguments ´e_1, \ldots , e_n´ of types ´S_1 , \ldots , S_n´. We say that an argument expression ´e_i´ is a _named_ argument if it has the form `´x_i=e'_i´` and `´x_i´` is one of the parameter names `´p_1, \ldots, p_n´`.
+
+Once the types ´S_i´ have been determined, the method ´f´ of the above method type is said to be applicable if all of the following conditions hold:
+  - for every named argument ´p_j=e_i'´ the type ´S_i´ is [compatible](03-types.html#compatibility) with the parameter type ´T_j´;
+  - for every positional argument ´e_i´ the type ´S_i´ is [compatible](03-types.html#compatibility) with ´T_i´;
+  - if the expected type is defined, the result type ´U´ is [compatible](03-types.html#compatibility) to it.
+
+If ´f´ is a polymorphic method, [local type inference](#local-type-inference) is used to instantiate ´f´'s type parameters.
+The polymorphic method is applicable if type inference can determine type arguments so that the instantiated method is applicable.
+
+If ´f´ has some value type, the application is taken to be equivalent to `´f´.apply(´e_1 , \ldots , e_m´)`,
+i.e. the application of an `apply` method defined by ´f´. The value `´f´` is applicable to the given arguments if `´f´.apply` is applicable.
+
+
+The application `´f´(´e_1 , \ldots , e_n´)` evaluates ´f´ and then each argument
+´e_1 , \ldots , e_n´ from left to right, except for arguments that correspond to
+a by-name parameter (see below).  Each argument expression is converted to the
+type of its corresponding formal parameter.  After that, the application is
+rewritten to the function's right hand side, with actual arguments substituted
+for formal parameters.  The result of evaluating the rewritten right-hand side
+is finally converted to the function's declared result type, if one is given.
+
+The case of a formal parameter with a parameterless
+method type `=> ´T´` is treated specially. In this case, the
+corresponding actual argument expression ´e´ is not evaluated before the
+application. Instead, every use of the formal parameter on the
+right-hand side of the rewrite rule entails a re-evaluation of ´e´.
+In other words, the evaluation order for
+`=>`-parameters is _call-by-name_ whereas the evaluation
+order for normal parameters is _call-by-value_.
+Furthermore, it is required that ´e´'s [packed type](#expression-typing)
+conforms to the parameter type ´T´.
+The behavior of by-name parameters is preserved if the application is
+transformed into a block due to named or default arguments. In this case,
+the local value for that parameter has the form `val ´y_i´ = () => ´e´`
+and the argument passed to the function is `´y_i´()`.
+
+The last argument in an application may be marked as a sequence
+argument, e.g. `´e´: _*`. Such an argument must correspond
+to a [repeated parameter](04-basic-declarations-and-definitions.html#repeated-parameters) of type
+`´S´*` and it must be the only argument matching this
+parameter (i.e. the number of formal parameters and actual arguments
+must be the same). Furthermore, the type of ´e´ must conform to
+`scala.Seq[´T´]`, for some type ´T´ which conforms to
+´S´. In this case, the argument list is transformed by replacing the
+sequence ´e´ with its elements. When the application uses named
+arguments, the vararg parameter has to be specified exactly once.
+
+If only a single argument is supplied, it may be supplied as a block expression
+and parentheses can be omitted, in the form `´f´ { block }`. This is valid when
+`f` has a single formal parameter or when all other formal parameters have
+default values.
+
+A function application usually allocates a new frame on the program's
+run-time stack. However, if a local method or a final method calls
+itself as its last action, the call is executed using the stack-frame
+of the caller.
+
+###### Example
+Assume the following method which computes the sum of a
+variable number of arguments:
+
+```scala
+def sum(xs: Int*) = xs.foldLeft(0)((x, y) => x + y)
+```
+
+Then
+
+```scala
+sum(1, 2, 3, 4)
+sum(List(1, 2, 3, 4): _*)
+```
+
+both yield `10` as result. On the other hand,
+
+```scala
+sum(List(1, 2, 3, 4))
+```
+
+would not typecheck.
+
+An argument list may begin with the soft keyword `using` to facilitate cross-compilation with Scala 3.
+The keyword is ignored.
+
+### Named and Default Arguments
+
+If an application is to use named arguments ´p = e´ or default
+arguments, the following conditions must hold.
+
+- For every named argument ´p_i = e_i´ which appears left of a positional argument
+  in the argument list ´e_1 \ldots e_m´, the argument position ´i´ coincides with
+  the position of parameter ´p_i´ in the parameter list of the applied method.
+- The names ´x_i´ of all named arguments are pairwise distinct and no named
+  argument defines a parameter which is already specified by a
+  positional argument.
+- Every formal parameter ´p_j:T_j´ which is not specified by either a positional
+  or named argument has a default argument.
+
+If the application uses named or default
+arguments the following transformation is applied to convert it into
+an application without named or default arguments.
+
+If the method ´f´
+has the form `´p.m´[´\mathit{targs}´]` it is transformed into the
+block
+
+```scala
+{ val q = ´p´
+  q.´m´[´\mathit{targs}´]
+}
+```
+
+If the method ´f´ is itself an application expression the transformation
+is applied recursively on ´f´. The result of transforming ´f´ is a block of
+the form
+
+```scala
+{ val q = ´p´
+  val ´x_1´ = expr´_1´
+  ´\ldots´
+  val ´x_k´ = expr´_k´
+  q.´m´[´\mathit{targs}´](´\mathit{args}_1´)´, \ldots ,´(´\mathit{args}_l´)
+}
+```
+
+where every argument in ´(\mathit{args}\_1) , \ldots , (\mathit{args}\_l)´ is a reference to
+one of the values ´x_1 , \ldots , x_k´. To integrate the current application
+into the block, first a value definition using a fresh name ´y_i´ is created
+for every argument in ´e_1 , \ldots , e_m´, which is initialised to ´e_i´ for
+positional arguments and to ´e'_i´ for named arguments of the form
+`´x_i=e'_i´`. Then, for every parameter which is not specified
+by the argument list, a value definition using a fresh name ´z_i´ is created,
+which is initialized using the method computing the
+[default argument](04-basic-declarations-and-definitions.html#function-declarations-and-definitions) of
+this parameter.
+
+Let ´\mathit{args}´ be a permutation of the generated names ´y_i´ and ´z_i´ such such
+that the position of each name matches the position of its corresponding
+parameter in the method type `(´p_1:T_1 , \ldots , p_n:T_n´)´U´`.
+The final result of the transformation is a block of the form
+
+```scala
+{ val q = ´p´
+  val ´x_1´ = expr´_1´
+  ´\ldots´
+  val ´x_l´ = expr´_k´
+  val ´y_1´ = ´e_1´
+  ´\ldots´
+  val ´y_m´ = ´e_m´
+  val ´z_1´ = ´q.m\$default\$i[\mathit{targs}](\mathit{args}_1), \ldots ,(\mathit{args}_l)´
+  ´\ldots´
+  val ´z_d´ = ´q.m\$default\$j[\mathit{targs}](\mathit{args}_1), \ldots ,(\mathit{args}_l)´
+  q.´m´[´\mathit{targs}´](´\mathit{args}_1´)´, \ldots ,´(´\mathit{args}_l´)(´\mathit{args}´)
+}
+```
+
+### Signature Polymorphic Methods
+
+For invocations of signature polymorphic methods of the target platform `´f´(´e_1 , \ldots , e_m´)`,
+the invoked method has a different method type `(´p_1´:´T_1 , \ldots , p_n´:´T_n´)´U´` at each call
+site. The parameter types `´T_ , \ldots , T_n´` are the types of the argument expressions
+`´e_1 , \ldots , e_m´`. If the declared return type `´R´` of the signature polymorphic method is
+any type other than `scala.AnyRef`, then the return type `´U´` is `´R´`.
+Otherwise, `´U´` is the expected type at the call site. If the expected type is undefined then
+`´U´` is `scala.AnyRef`. The parameter names `´p_1 , \ldots , p_n´` are fresh.
+
+###### Note
+
+On the Java platform version 11 and later, signature polymorphic methods are native,
+members of `java.lang.invoke.MethodHandle` or `java.lang.invoke.VarHandle`, and have a single
+repeated parameter of type `java.lang.Object*`.
+
+
+## Method Values
+
+```ebnf
+SimpleExpr    ::=  SimpleExpr1 ‘_’
+```
+
+The expression `´e´ _` is well-formed if ´e´ is of method
+type or if ´e´ is a call-by-name parameter.  If ´e´ is a method with
+parameters, `´e´ _` represents ´e´ converted to a function
+type by [eta expansion](#eta-expansion-section). If ´e´ is a
+parameterless method or call-by-name parameter of type
+`=> ´T´`, `´e´ _` represents the function of type
+`() => ´T´`, which evaluates ´e´ when it is applied to the empty
+parameter list `()`.
+
+###### Example
+The method values in the left column are each equivalent to the [eta-expanded expressions](#eta-expansion-section) on the right.
+
+| placeholder syntax            | eta-expansion                                                               |
+|------------------------------ | ----------------------------------------------------------------------------|
+|`math.sin _`                   | `x => math.sin(x)`                                                          |
+|`math.pow _`                   | `(x1, x2) => math.pow(x1, x2)`                                              |
+|`val vs = 1 to 9; vs.fold _`   | `(z) => (op) => vs.fold(z)(op)`                                             |
+|`(1 to 9).fold(z)_`            | `{ val eta1 = 1 to 9; val eta2 = z; op => eta1.fold(eta2)(op) }`            |
+|`Some(1).fold(??? : Int)_`     | `{ val eta1 = Some(1); val eta2 = () => ???; op => eta1.fold(eta2())(op) }` |
+
+Note that a space is necessary between a method name and the trailing underscore
+because otherwise the underscore would be considered part of the name.
+
+## Type Applications
+
+```ebnf
+SimpleExpr    ::=  SimpleExpr TypeArgs
+```
+
+A _type application_ `´e´[´T_1 , \ldots , T_n´]` instantiates
+a polymorphic value ´e´ of type
+`[´a_1´ >: ´L_1´ <: ´U_1, \ldots , a_n´ >: ´L_n´ <: ´U_n´]´S´`
+with argument types
+`´T_1 , \ldots , T_n´`.  Every argument type ´T_i´ must obey
+the corresponding bounds ´L_i´ and ´U_i´.  That is, for each ´i = 1
+, \ldots , n´, we must have ´\sigma L_i <: T_i <: \sigma
+U_i´, where ´\sigma´ is the substitution ´[a_1 := T_1 , \ldots , a_n
+:= T_n]´.  The type of the application is ´\sigma S´.
+
+If the function part ´e´ is of some value type, the type application
+is taken to be equivalent to
+`´e´.apply[´T_1 , \ldots ,´ T´_n´]`, i.e. the application of an `apply` method defined by
+´e´.
+
+Type applications can be omitted if
+[local type inference](#local-type-inference) can infer best type parameters
+for a polymorphic method from the types of the actual method arguments
+and the expected result type.
+
+## Tuples
+
+```ebnf
+SimpleExpr   ::=  ‘(’ [Exprs] ‘)’
+```
+
+A _tuple expression_ `(´e_1 , \ldots , e_n´)` is an alias
+for the class instance creation
+`scala.Tuple´n´(´e_1 , \ldots , e_n´)`, where ´n \geq 2´.
+The empty tuple
+`()` is the unique value of type `scala.Unit`.
+
+## Instance Creation Expressions
+
+```ebnf
+SimpleExpr     ::=  ‘new’ (ClassTemplate | TemplateBody)
+```
+
+A _simple instance creation expression_ is of the form
+`new ´c´`
+where ´c´ is a [constructor invocation](05-classes-and-objects.html#constructor-invocations). Let ´T´ be
+the type of ´c´. Then ´T´ must
+denote a (a type instance of) a non-abstract subclass of
+`scala.AnyRef`. Furthermore, the _concrete self type_ of the
+expression must conform to the [self type](05-classes-and-objects.html#templates) of the class denoted by
+´T´. The concrete self type is normally
+´T´, except if the expression `new ´c´` appears as the
+right hand side of a value definition
+
+```scala
+val ´x´: ´S´ = new ´c´
+```
+
+(where the type annotation `: ´S´` may be missing).
+In the latter case, the concrete self type of the expression is the
+compound type `´T´ with ´x´.type`.
+
+The expression is evaluated by creating a fresh
+object of type ´T´ which is initialized by evaluating ´c´. The
+type of the expression is ´T´.
+
+A _general instance creation expression_ is of the form
+`new ´t´` for some [class template](05-classes-and-objects.html#templates) ´t´.
+Such an expression is equivalent to the block
+
+```scala
+{ class ´a´ extends ´t´; new ´a´ }
+```
+
+where ´a´ is a fresh name of an _anonymous class_ which is
+inaccessible to user programs.
+
+There is also a shorthand form for creating values of structural
+types: If `{´D´}` is a class body, then
+`new {´D´}` is equivalent to the general instance creation expression
+`new AnyRef{´D´}`.
+
+###### Example
+Consider the following structural instance creation expression:
+
+```scala
+new { def getName() = "aaron" }
+```
+
+This is a shorthand for the general instance creation expression
+
+```scala
+new AnyRef{ def getName() = "aaron" }
+```
+
+The latter is in turn a shorthand for the block
+
+```scala
+{ class anon$X extends AnyRef{ def getName() = "aaron" }; new anon$X }
+```
+
+where `anon$X` is some freshly created name.
+
+## Blocks
+
+```ebnf
+BlockExpr  ::=  ‘{’ CaseClauses ‘}’
+             |  ‘{’ Block ‘}’
+Block      ::=  BlockStat {semi BlockStat} [ResultExpr]
+```
+
+A _block expression_ `{´s_1´; ´\ldots´; ´s_n´; ´e\,´}` is
+constructed from a sequence of block statements ´s_1 , \ldots , s_n´
+and a final expression ´e´.  The statement sequence may not contain
+two definitions or declarations that bind the same name in the same
+namespace.  The final expression can be omitted, in which
+case the unit value `()` is assumed.
+
+The expected type of the final expression ´e´ is the expected
+type of the block. The expected type of all preceding statements is
+undefined.
+
+The type of a block `´s_1´; ´\ldots´; ´s_n´; ´e´` is
+`´T´ forSome {´\,Q\,´}`, where ´T´ is the type of ´e´ and ´Q´
+contains [existential clauses](03-types.html#existential-types)
+for every value or type name which is free in ´T´
+and which is defined locally in one of the statements ´s_1 , \ldots , s_n´.
+We say the existential clause _binds_ the occurrence of the value or type name.
+Specifically,
+
+- A locally defined type definition  `type´\;t = T´`
+  is bound by the existential clause `type´\;t >: T <: T´`.
+  It is an error if ´t´ carries type parameters.
+- A locally defined value definition `val´\;x: T = e´` is
+  bound by the existential clause `val´\;x: T´`.
+- A locally defined class definition `class´\;c´ extends´\;t´`
+  is bound by the existential clause `type´\;c <: T´` where
+  ´T´ is the least class type or refinement type which is a proper
+  supertype of the type ´c´. It is an error if ´c´ carries type parameters.
+- A locally defined object definition `object´\;x\;´extends´\;t´`
+  is bound by the existential clause `val´\;x: T´` where
+  ´T´ is the least class type or refinement type which is a proper supertype of the type
+  `´x´.type`.
+
+Evaluation of the block entails evaluation of its
+statement sequence, followed by an evaluation of the final expression
+´e´, which defines the result of the block.
+
+A block expression `{´c_1´; ´\ldots´; ´c_n´}` where ´s_1 , \ldots , s_n´ are
+case clauses forms a [pattern matching anonymous function](08-pattern-matching.html#pattern-matching-anonymous-functions).
+
+###### Example
+Assuming a class `Ref[T](x: T)`, the block
+
+```scala
+{ class C extends B {´\ldots´} ; new Ref(new C) }
+```
+
+has the type `Ref[_1] forSome { type _1 <: B }`.
+The block
+
+```scala
+{ class C extends B {´\ldots´} ; new C }
+```
+
+simply has type `B`, because with the rules [here](03-types.html#simplification-rules)
+the existentially quantified type
+`_1 forSome { type _1 <: B }` can be simplified to `B`.
+
+## Prefix, Infix, and Postfix Operations
+
+```ebnf
+PostfixExpr     ::=  InfixExpr [id [nl]]
+InfixExpr       ::=  PrefixExpr
+                  |  InfixExpr id [nl] InfixExpr
+PrefixExpr      ::=  [‘-’ | ‘+’ | ‘!’ | ‘~’] SimpleExpr
+```
+
+Expressions can be constructed from operands and operators.
+
+### Prefix Operations
+
+A prefix operation ´\mathit{op};e´ consists of a prefix operator ´\mathit{op}´, which
+must be one of the identifiers ‘`+`’, ‘`-`’, ‘`!`’ or ‘`~`’,
+which must not be enclosed in backquotes.
+The expression ´\mathit{op};e´ is
+equivalent to the postfix method application
+`e.unary_´\mathit{op}´`.
+
+<!-- TODO: Generalize to arbitrary operators -->
+
+Prefix operators are different from normal method applications in
+that their operand expression need not be atomic. For instance, the
+input sequence `-sin(x)` is read as `-(sin(x))`, whereas the
+method application `negate sin(x)` would be parsed as the
+application of the infix operator `sin` to the operands
+`negate` and `(x)`.
+
+### Postfix Operations
+
+A postfix operator can be an arbitrary identifier. The postfix
+operation ´e;\mathit{op}´ is interpreted as ´e.\mathit{op}´.
+
+### Infix Operations
+
+An infix operator can be an arbitrary identifier. Infix operators have
+precedence and associativity defined as follows:
+
+The _precedence_ of an infix operator 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.
+
+```scala
+(all letters, as defined in [chapter 1](01-lexical-syntax.html), including `_` and `$`)
+|
+^
+&
+= !
+< >
+:
++ -
+* / %
+(other operator characters, as defined in [chapter 1](01-lexical-syntax.html), including Unicode categories `Sm` and `So`)
+```
+
+That is, operators starting with a letter have lowest precedence,
+followed by operators starting with ‘`|`’, etc.
+
+There's one exception to this rule, which concerns
+[_assignment operators_](#assignment-operators).
+The precedence of an assignment operator is the same as the one
+of simple assignment `(=)`. That is, it is lower than the
+precedence of any other operator.
+
+The _associativity_ of an operator is determined by the operator's
+last character.  Operators ending in a colon ‘`:`’ are
+right-associative. All other operators are left-associative.
+
+Precedence and associativity of operators determine the grouping of
+parts of an expression as follows.
+
+- If there are several infix operations in an
+  expression, then operators with higher precedence bind more closely
+  than operators with lower precedence.
+- If there are consecutive infix
+  operations ´e_0; \mathit{op}\_1; e_1; \mathit{op}\_2 \ldots \mathit{op}\_n; e_n´
+  with operators ´\mathit{op}\_1 , \ldots , \mathit{op}\_n´ of the same precedence,
+  then all these operators must
+  have the same associativity. If all operators are left-associative,
+  the sequence is interpreted as
+  ´(\ldots(e_0;\mathit{op}\_1;e_1);\mathit{op}\_2\ldots);\mathit{op}\_n;e_n´.
+  Otherwise, if all operators are right-associative, the
+  sequence is interpreted as
+  ´e_0;\mathit{op}\_1;(e_1;\mathit{op}\_2;(\ldots \mathit{op}\_n;e_n)\ldots)´.
+- Postfix operators always have lower precedence than infix
+  operators. E.g. ´e_1;\mathit{op}\_1;e_2;\mathit{op}\_2´ is always equivalent to
+  ´(e_1;\mathit{op}\_1;e_2);\mathit{op}\_2´.
+
+The right-hand operand of a left-associative operator may consist of
+several arguments enclosed in parentheses, e.g. ´e;\mathit{op};(e_1,\ldots,e_n)´.
+This expression is then interpreted as ´e.\mathit{op}(e_1,\ldots,e_n)´.
+
+A left-associative binary
+operation ´e_1;\mathit{op};e_2´ is interpreted as ´e_1.\mathit{op}(e_2)´. If ´\mathit{op}´ is
+right-associative and its parameter is passed by name, the same operation is interpreted as
+´e_2.\mathit{op}(e_1)´. If ´\mathit{op}´ is right-associative and its parameter is passed by value,
+it is interpreted as `{ val ´x´=´e_1´; ´e_2´.´\mathit{op}´(´x\,´) }`, where ´x´ is a fresh name.
+
+### Assignment Operators
+
+An _assignment operator_ is an operator symbol (syntax category
+`op` in [Identifiers](01-lexical-syntax.html#identifiers)) that ends in an equals character
+“`=`”, with the following exceptions:
+
+1. the operator also starts with an equals character, or
+1. the operator is one of `(<=)`, `(>=)`, `(!=)`.
+
+Assignment operators are treated specially in that they
+can be expanded to assignments if no other interpretation is valid.
+
+Let's consider an assignment operator such as `+=` in an infix
+operation `´l´ += ´r´`, where ´l´, ´r´ are expressions.
+This operation can be re-interpreted as an operation which corresponds
+to the assignment
+
+```scala
+´l´ = ´l´ + ´r´
+```
+
+except that the operation's left-hand-side ´l´ is evaluated only once.
+
+The re-interpretation occurs if the following two conditions are fulfilled.
+
+1. The left-hand-side ´l´ does not have a member named
+   `+=`, and also cannot be converted by an
+   [implicit conversion](#implicit-conversions)
+   to a value with a member named `+=`.
+1. The assignment `´l´ = ´l´ + ´r´` is type-correct.
+   In particular this implies that ´l´ refers to a variable or object
+   that can be assigned to, and that is convertible to a value with a member
+   named `+`.
+
+## Typed Expressions
+
+```ebnf
+Expr1              ::=  PostfixExpr ‘:’ CompoundType
+```
+
+The _typed expression_ ´e: T´ has type ´T´. The type of
+expression ´e´ is expected to conform to ´T´. The result of
+the expression is the value of ´e´ converted to type ´T´.
+
+###### Example
+Here are examples of well-typed and ill-typed expressions.
+
+```scala
+1: Int               // legal, of type Int
+1: Long              // legal, of type Long
+// 1: string         // ***** illegal
+```
+
+## Annotated Expressions
+
+```ebnf
+Expr1              ::=  PostfixExpr ‘:’ Annotation {Annotation}
+```
+
+An _annotated expression_ `´e´: @´a_1´ ´\ldots´ @´a_n´`
+attaches [annotations](11-annotations.html#user-defined-annotations) ´a_1 , \ldots , a_n´ to the
+expression ´e´.
+
+## Assignments
+
+```ebnf
+Expr1        ::=  [SimpleExpr ‘.’] id ‘=’ Expr
+               |  PrefixOperator SimpleExpr ‘=’ Expr
+               |  SimpleExpr1 ArgumentExprs ‘=’ Expr
+```
+
+The interpretation of an assignment to a simple variable `´x´ = ´e´`
+depends on the definition of ´x´. If ´x´ denotes a mutable
+variable, then the assignment changes the current value of ´x´ to be
+the result of evaluating the expression ´e´. The type of ´e´ is
+expected to conform to the type of ´x´. If ´x´ is a parameterless
+method defined in some template, and the same template contains a
+setter method `´x´_=` as member, then the assignment
+`´x´ = ´e´` is interpreted as the invocation
+`´x´_=(´e\,´)` of that setter method.  Analogously, an
+assignment `´f.x´ = ´e´` to a parameterless method ´x´
+is interpreted as the invocation `´f.x´_=(´e\,´)`.
+If ´x´ is an application of a unary operator, then the expression
+is interpreted as though it were written as the explicit application
+`´x´.unary_´\mathit{op}´`, namely, as `´x´.unary_´\mathit{op}´_=(´e\,´)`.
+
+An assignment `´f´(´\mathit{args}\,´) = ´e´` with a method application to the
+left of the ‘`=`’ operator is interpreted as
+`´f.´update(´\mathit{args}´, ´e\,´)`, i.e.
+the invocation of an `update` method defined by ´f´.
+
+###### Example
+Here are some assignment expressions and their equivalent expansions.
+
+| assignment               | expansion            |
+|--------------------------|----------------------|
+|`x.f = e`                 | `x.f_=(e)`           |
+|`x.f() = e`               | `x.f.update(e)`      |
+|`x.f(i) = e`              | `x.f.update(i, e)`   |
+|`x.f(i, j) = e`           | `x.f.update(i, j, e)`|
+
+###### Example Imperative Matrix Multiplication
+
+Here is the usual imperative code for matrix multiplication.
+
+```scala
+def matmul(xss: Array[Array[Double]], yss: Array[Array[Double]]) = {
+  val zss: Array[Array[Double]] = new Array(xss.length, yss(0).length)
+  var i = 0
+  while (i < xss.length) {
+    var j = 0
+    while (j < yss(0).length) {
+      var acc = 0.0
+      var k = 0
+      while (k < yss.length) {
+        acc = acc + xss(i)(k) * yss(k)(j)
+        k += 1
+      }
+      zss(i)(j) = acc
+      j += 1
+    }
+    i += 1
+  }
+  zss
+}
+```
+
+Desugaring the array accesses and assignments yields the following
+expanded version:
+
+```scala
+def matmul(xss: Array[Array[Double]], yss: Array[Array[Double]]) = {
+  val zss: Array[Array[Double]] = new Array(xss.length, yss.apply(0).length)
+  var i = 0
+  while (i < xss.length) {
+    var j = 0
+    while (j < yss.apply(0).length) {
+      var acc = 0.0
+      var k = 0
+      while (k < yss.length) {
+        acc = acc + xss.apply(i).apply(k) * yss.apply(k).apply(j)
+        k += 1
+      }
+      zss.apply(i).update(j, acc)
+      j += 1
+    }
+    i += 1
+  }
+  zss
+}
+```
+
+## Conditional Expressions
+
+```ebnf
+Expr1          ::=  ‘if’ ‘(’ Expr ‘)’ {nl} Expr [[semi] ‘else’ Expr]
+```
+
+The _conditional expression_ `if (´e_1´) ´e_2´ else ´e_3´` chooses
+one of the values of ´e_2´ and ´e_3´, depending on the
+value of ´e_1´. The condition ´e_1´ is expected to
+conform to type `Boolean`.  The then-part ´e_2´ and the
+else-part ´e_3´ are both expected to conform to the expected
+type of the conditional expression. The type of the conditional
+expression is the [weak least upper bound](03-types.html#weak-conformance)
+of the types of ´e_2´ and
+´e_3´.  A semicolon preceding the `else` symbol of a
+conditional expression is ignored.
+
+The conditional expression is evaluated by evaluating first
+´e_1´. If this evaluates to `true`, the result of
+evaluating ´e_2´ is returned, otherwise the result of
+evaluating ´e_3´ is returned.
+
+A short form of the conditional expression eliminates the
+else-part. The conditional expression `if (´e_1´) ´e_2´` is
+evaluated as if it was `if (´e_1´) ´e_2´ else ()`.
+
+## While Loop Expressions
+
+```ebnf
+Expr1          ::=  ‘while’ ‘(’ Expr ‘)’ {nl} Expr
+```
+
+The _while loop expression_ `while (´e_1´) ´e_2´` is typed and
+evaluated as if it was an application of `whileLoop (´e_1´) (´e_2´)` where
+the hypothetical method `whileLoop` is defined as follows.
+
+```scala
+def whileLoop(cond: => Boolean)(body: => Unit): Unit  =
+  if (cond) { body ; whileLoop(cond)(body) } else {}
+```
+
+## Do Loop Expressions
+
+```ebnf
+Expr1          ::=  ‘do’ Expr [semi] ‘while’ ‘(’ Expr ‘)’
+```
+
+The _do loop expression_ `do ´e_1´ while (´e_2´)` is typed and
+evaluated as if it was the expression `(´e_1´ ; while (´e_2´) ´e_1´)`.
+A semicolon preceding the `while` symbol of a do loop expression is ignored.
+
+## For Comprehensions and For Loops
+
+```ebnf
+Expr1          ::=  ‘for’ (‘(’ Enumerators ‘)’ | ‘{’ Enumerators ‘}’)
+                       {nl} [‘yield’] Expr
+Enumerators    ::=  Generator {semi Generator}
+Generator      ::=  [‘case’] Pattern1 ‘<-’ Expr {[semi] Guard | semi Pattern1 ‘=’ Expr}
+Guard          ::=  ‘if’ PostfixExpr
+```
+
+A _for loop_ `for (´\mathit{enums}\,´) ´e´` executes expression ´e´
+for each binding generated by the enumerators ´\mathit{enums}´. 
+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 _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. The precise meaning of generators and guards is
+defined by translation to invocations of four methods: `map`,
+`withFilter`, `flatMap`, and `foreach`. 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
+
+```scala
+´p´ <- ´e´.withFilter { case ´p´ => true; case _ => false }
+```
+
+Then, the following rules are applied repeatedly until all
+comprehensions have been eliminated.
+
+  - A for comprehension
+    `for (´p´ <- ´e\,´) yield ´e'´`
+    is translated to
+    `´e´.map { case ´p´ => ´e'´ }`.
+  - A for loop
+    `for (´p´ <- ´e\,´) ´e'´`
+    is translated to
+    `´e´.foreach { case ´p´ => ´e'´ }`.
+  - A for comprehension
+
+    ```scala
+    for (´p´ <- ´e´; ´p'´ <- ´e'; \ldots´) yield ´e''´
+    ```
+
+    where `´\ldots´` is a (possibly empty)
+    sequence of generators, definitions, or guards,
+    is translated to
+
+    ```scala
+    ´e´.flatMap { case ´p´ => for (´p'´ <- ´e'; \ldots´) yield ´e''´ }
+    ```
+
+  - A for loop
+
+    ```scala
+    for (´p´ <- ´e´; ´p'´ <- ´e'; \ldots´) ´e''´
+    ```
+
+    where `´\ldots´` is a (possibly empty)
+    sequence of generators, definitions, or guards,
+    is translated to
+
+    ```scala
+    ´e´.foreach { case ´p´ => for (´p'´ <- ´e'; \ldots´) ´e''´ }
+    ```
+
+  - A generator `´p´ <- ´e´` followed by a guard
+    `if ´g´` is translated to a single generator
+    `´p´ <- ´e´.withFilter((´x_1 , \ldots , x_n´) => ´g\,´)` where
+    ´x_1 , \ldots , x_n´ are the free variables of ´p´.
+
+  - 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:
+
+    ```scala
+    (´p´, ´p'´) <- for (´x @ p´ <- ´e´) yield { val ´x' @ p'´ = ´e'´; (´x´, ´x'´) }
+    ```
+
+###### Example
+The following code produces all pairs of numbers between ´1´ and ´n-1´
+whose sums are prime.
+
+```scala
+for  { i <- 1 until n
+       j <- 1 until i
+       if isPrime(i+j)
+} yield (i, j)
+```
+
+The for comprehension is translated to:
+
+```scala
+(1 until n)
+  .flatMap {
+     case i => (1 until i)
+       .withFilter { j => isPrime(i+j) }
+       .map { case j => (i, j) } }
+```
+
+###### Example
+For comprehensions can be used to express vector
+and matrix algorithms concisely.
+For instance, here is a method to compute the transpose of a given matrix:
+
+<!-- see test/files/run/t0421.scala -->
+
+```scala
+def transpose[A](xss: Array[Array[A]]) = {
+  for (i <- Array.range(0, xss(0).length)) yield
+    for (xs <- xss) yield xs(i)
+}
+```
+
+Here is a method to compute the scalar product of two vectors:
+
+```scala
+def scalprod(xs: Array[Double], ys: Array[Double]) = {
+  var acc = 0.0
+  for ((x, y) <- xs zip ys) acc = acc + x * y
+  acc
+}
+```
+
+Finally, here is a method to compute the product of two matrices.
+Compare with the [imperative version](#example-imperative-matrix-multiplication).
+
+```scala
+def matmul(xss: Array[Array[Double]], yss: Array[Array[Double]]) = {
+  val ysst = transpose(yss)
+  for (xs <- xss) yield
+    for (yst <- ysst) yield
+      scalprod(xs, yst)
+}
+```
+
+The code above makes use of the fact that `map`, `flatMap`,
+`withFilter`, and `foreach` are defined for instances of class
+`scala.Array`.
+
+## Return Expressions
+
+```ebnf
+Expr1      ::=  ‘return’ [Expr]
+```
+
+A _return expression_ `return ´e´` must occur inside the body of some
+enclosing user defined method. The innermost enclosing method in a
+source program, ´m´, must have an explicitly declared result type, and
+the type of ´e´ must conform to it.
+
+The return expression evaluates the expression ´e´ and returns its
+value as the result of ´m´. The evaluation of any statements or
+expressions following the return expression is omitted. The type of
+a return expression is `scala.Nothing`.
+
+The expression ´e´ may be omitted. The return expression
+`return` is type-checked and evaluated as if it were `return ()`.
+
+Returning from the method from within a nested function may be
+implemented by throwing and catching a
+`scala.runtime.NonLocalReturnControl`. Any exception catches
+between the point of return and the enclosing methods might see
+and catch that exception. A key comparison makes sure that this
+exception is only caught by the method instance which is terminated
+by the return.
+
+If the return expression is itself part of an anonymous function, it
+is possible that the enclosing method ´m´ has already returned
+before the return expression is executed. In that case, the thrown
+`scala.runtime.NonLocalReturnControl` will not be caught, and will
+propagate up the call stack.
+
+## Throw Expressions
+
+```ebnf
+Expr1      ::=  ‘throw’ Expr
+```
+
+A _throw expression_ `throw ´e´` evaluates the expression
+´e´. The type of this expression must conform to
+`Throwable`.  If ´e´ evaluates to an exception
+reference, evaluation is aborted with the thrown exception. If ´e´
+evaluates to `null`, evaluation is instead aborted with a
+`NullPointerException`. If there is an active
+[`try` expression](#try-expressions) which handles the thrown
+exception, evaluation resumes with the handler; otherwise the thread
+executing the `throw` is aborted.  The type of a throw expression
+is `scala.Nothing`.
+
+## Try Expressions
+
+```ebnf
+Expr1 ::=  ‘try’ Expr [‘catch’ Expr] [‘finally’ Expr]
+```
+
+A _try expression_ is of the form `try { ´b´ } catch ´h´`
+where the handler ´h´ is usually a
+[pattern matching anonymous function](08-pattern-matching.html#pattern-matching-anonymous-functions)
+
+```scala
+{ case ´p_1´ => ´b_1´ ´\ldots´ case ´p_n´ => ´b_n´ }
+```
+
+This expression is evaluated by evaluating the block
+´b´.  If evaluation of ´b´ does not cause an exception to be
+thrown, the result of ´b´ is returned. Otherwise the
+handler ´h´ is applied to the thrown exception.
+If the handler contains a case matching the thrown exception,
+the first such case is invoked. If the handler contains
+no case matching the thrown exception, the exception is
+re-thrown. More generally, if the handler is a `PartialFunction`,
+it is applied only if it is defined at the given exception.
+
+Let ´\mathit{pt}´ be the expected type of the try expression.  The block
+´b´ is expected to conform to ´\mathit{pt}´.  The handler ´h´
+is expected conform to type `scala.Function[scala.Throwable, ´\mathit{pt}\,´]`.
+The type of the try expression is the [weak least upper bound](03-types.html#weak-conformance)
+of the type of ´b´ and the result type of ´h´.
+
+A try expression `try { ´b´ } finally ´e´` evaluates the block
+´b´.  If evaluation of ´b´ does not cause an exception to be
+thrown, the expression ´e´ is evaluated. If an exception is thrown
+during evaluation of ´e´, the evaluation of the try expression is
+aborted with the thrown exception. If no exception is thrown during
+evaluation of ´e´, the result of ´b´ is returned as the
+result of the try expression.
+
+If an exception is thrown during evaluation of ´b´, the finally block
+´e´ is also evaluated. If another exception ´e´ is thrown
+during evaluation of ´e´, evaluation of the try expression is
+aborted with the thrown exception. If no exception is thrown during
+evaluation of ´e´, the original exception thrown in ´b´ is
+re-thrown once evaluation of ´e´ has completed.  The block
+´b´ is expected to conform to the expected type of the try
+expression. The finally expression ´e´ is expected to conform to
+type `Unit`.
+
+A try expression `try { ´b´ } catch ´e_1´ finally ´e_2´`
+is a shorthand
+for  `try { try { ´b´ } catch ´e_1´ } finally ´e_2´`.
+
+## Anonymous Functions
+
+```ebnf
+Expr            ::=  (Bindings | [‘implicit’] id | ‘_’) ‘=>’ Expr
+ResultExpr      ::=  (Bindings | ([‘implicit’] id | ‘_’) ‘:’ CompoundType) ‘=>’ Block
+Bindings        ::=  ‘(’ Binding {‘,’ Binding} ‘)’
+Binding         ::=  (id | ‘_’) [‘:’ Type]
+```
+
+The anonymous function of arity ´n´, `(´x_1´: ´T_1 , \ldots , x_n´: ´T_n´) => e` maps parameters ´x_i´ of types ´T_i´ to a result given by expression ´e´. The scope of each formal parameter ´x_i´ is ´e´. Formal parameters must have pairwise distinct names.
+
+In the case of a single untyped formal parameter, `(´x\,´) => ´e´` can be abbreviated to `´x´ => ´e´`. If an anonymous function `(´x´: ´T\,´) => ´e´` with a single typed parameter appears as the result expression of a block, it can be abbreviated to `´x´: ´T´ => e`.
+
+A formal parameter may also be a wildcard represented by an underscore `_`. In that case, a fresh name for the parameter is chosen arbitrarily.
+
+A named parameter of an anonymous function may be optionally preceded by an `implicit` modifier. In that case the parameter is labeled [`implicit`](07-implicits.html#implicit-parameters-and-views); however the parameter section itself does not count as an [implicit parameter section](07-implicits.html#implicit-parameters). Hence, arguments to anonymous functions always have to be given explicitly.
+
+### Translation
+If the expected type of the anonymous function is of the shape `scala.Function´n´[´S_1 , \ldots , S_n´, ´R\,´]`, or can be [SAM-converted](#sam-conversion) to such a function type, the type `´T_i´` of a parameter `´x_i´` can be omitted, as far as `´S_i´` is defined in the expected type, and `´T_i´ = ´S_i´` is assumed. Furthermore, the expected type when type checking ´e´ is ´R´.
+
+If there is no expected type for the function literal, all formal parameter types `´T_i´` must be specified explicitly, and the expected type of ´e´ is undefined. The type of the anonymous function is `scala.Function´n´[´T_1 , \ldots , T_n´, ´R\,´]`, where ´R´ is the [packed type](#expression-typing) of ´e´. ´R´ must be equivalent to a type which does not refer to any of the formal parameters ´x_i´.
+
+The eventual run-time value of an anonymous function is determined by the expected type:
+  - a subclass of one of the builtin function types, `scala.Function´n´[´S_1 , \ldots , S_n´, ´R\,´]` (with ´S_i´ and ´R´ fully defined),
+  - a [single-abstract-method (SAM) type](#sam-conversion);
+  - `PartialFunction[´T´, ´U´]`
+  - some other type.
+
+The standard anonymous function evaluates in the same way as the following instance creation expression:
+
+```scala
+new scala.Function´n´[´T_1 , \ldots , T_n´, ´T´] {
+  def apply(´x_1´: ´T_1 , \ldots , x_n´: ´T_n´): ´T´ = ´e´
+}
+```
+
+The same evaluation holds for a SAM type, except that the instantiated type is given by the SAM type, and the implemented method is the single abstract method member of this type.
+
+The underlying platform may provide more efficient ways of constructing these instances, such as Java 8's `invokedynamic` bytecode and `LambdaMetaFactory` class.
+
+When a `PartialFunction` is required, an additional member `isDefinedAt`
+is synthesized, which simply returns `true`.
+However, if the function literal has the shape `x => x match { $\ldots$ }`,
+then `isDefinedAt` is derived from the pattern match in the following way:
+each case from the match expression evaluates to `true`,
+and if there is no default case,
+a default case is added that evaluates to `false`.
+For more details on how that is implemented see
+["Pattern Matching Anonymous Functions"](08-pattern-matching.html#pattern-matching-anonymous-functions).
+
+###### Example
+Examples of anonymous functions:
+
+```scala
+x => x                             // The identity function
+
+f => g => x => f(g(x))             // Curried function composition
+
+(x: Int,y: Int) => x + y           // A summation function
+
+() => { count += 1; count }        // The function which takes an
+                                   // empty parameter list ´()´,
+                                   // increments a non-local variable
+                                   // `count' and returns the new value.
+
+_ => 5                             // The function that ignores its argument
+                                   // and always returns 5.
+```
+
+### Placeholder Syntax for Anonymous Functions
+
+```ebnf
+SimpleExpr1  ::=  ‘_’
+```
+
+An expression (of syntactic category `Expr`)
+may contain embedded underscore symbols `_` at places where identifiers
+are legal. Such an expression represents an anonymous function where subsequent
+occurrences of underscores denote successive parameters.
+
+Define an _underscore section_ to be an expression of the form
+`_:´T´` where ´T´ is a type, or else of the form `_`,
+provided the underscore does not appear as the expression part of a
+type ascription `_:´T´`.
+
+An expression ´e´ of syntactic category `Expr` _binds_ an underscore section
+´u´, if the following two conditions hold: (1) ´e´ properly contains ´u´, and
+(2) there is no other expression of syntactic category `Expr`
+which is properly contained in ´e´ and which itself properly contains ´u´.
+
+If an expression ´e´ binds underscore sections ´u_1 , \ldots , u_n´, in this order, it is equivalent to
+the anonymous function `(´u'_1´, ... ´u'_n´) => ´e'´`
+where each ´u_i'´ results from ´u_i´ by replacing the underscore with a fresh identifier and
+´e'´ results from ´e´ by replacing each underscore section ´u_i´ by ´u_i'´.
+
+###### Example
+The anonymous functions in the left column use placeholder
+syntax. Each of these is equivalent to the anonymous function on its right.
+
+| | |
+|---------------------------|----------------------------|
+|`_ + 1`                    | `x => x + 1`               |
+|`_ * _`                    | `(x1, x2) => x1 * x2`      |
+|`(_: Int) * 2`             | `(x: Int) => (x: Int) * 2` |
+|`if (_) x else y`          | `z => if (z) x else y`     |
+|`_.map(f)`                 | `x => x.map(f)`            |
+|`_.map(_ + 1)`             | `x => x.map(y => y + 1)`   |
+
+## Constant Expressions
+
+Constant expressions are expressions that the Scala compiler can evaluate to a constant.
+The definition of "constant expression" depends on the platform, but they
+include at least the expressions of the following forms:
+
+- A literal of a value class, such as an integer
+- A string literal
+- A class constructed with [`Predef.classOf`](12-the-scala-standard-library.html#the-predef-object)
+- An element of an enumeration from the underlying platform
+- A literal array, of the form `Array´(c_1 , \ldots , c_n)´`,
+  where all of the ´c_i´'s are themselves constant expressions
+- An identifier defined by a [constant value definition](04-basic-declarations-and-definitions.html#value-declarations-and-definitions).
+
+## Statements
+
+```ebnf
+BlockStat    ::=  Import
+               |  {Annotation} [‘implicit’] [‘lazy’] Def
+               |  {Annotation} {LocalModifier} TmplDef
+               |  Expr1
+               |
+TemplateStat ::=  Import
+               |  {Annotation} {Modifier} Def
+               |  {Annotation} {Modifier} Dcl
+               |  Expr
+               |
+```
+
+Statements occur as parts of blocks and templates.  A _statement_ can be
+an import, a definition or an expression, or it can be empty.
+Statements used in the template of a class definition can also be
+declarations.  An expression that is used as a statement can have an
+arbitrary value type. An expression statement ´e´ is evaluated by
+evaluating ´e´ and discarding the result of the evaluation.
+
+<!-- Generalize to implicit coercion? -->
+
+Block statements may be definitions which bind local names in the
+block. The only modifier allowed in all block-local definitions is
+`implicit`. When prefixing a class or object definition,
+modifiers `abstract`, `final`, and `sealed` are also
+permitted.
+
+Evaluation of a statement sequence entails evaluation of the
+statements in the order they are written.
+
+## Implicit Conversions
+
+Implicit conversions can be applied to expressions whose type does not
+match their expected type, to qualifiers in selections, and to unapplied methods. The
+available implicit conversions are given in the next two sub-sections.
+
+### Value Conversions
+
+The following seven implicit conversions can be applied to an
+expression ´e´ which has some value type ´T´ and which is type-checked with
+some expected type ´\mathit{pt}´.
+
+###### Static Overloading Resolution
+If an expression denotes several possible members of a class,
+[overloading resolution](#overloading-resolution)
+is applied to pick a unique member.
+
+###### Type Instantiation
+An expression ´e´ of polymorphic type
+
+```scala
+[´a_1´ >: ´L_1´ <: ´U_1 , \ldots , a_n´ >: ´L_n´ <: ´U_n´]´T´
+```
+
+which does not appear as the function part of
+a type application is converted to a type instance of ´T´
+by determining with [local type inference](#local-type-inference)
+instance types `´T_1 , \ldots , T_n´`
+for the type variables `´a_1 , \ldots , a_n´` and
+implicitly embedding ´e´ in the [type application](#type-applications)
+`´e´[´T_1 , \ldots , T_n´]`.
+
+###### Numeric Widening
+If ´e´ has a primitive number type which [weakly conforms](03-types.html#weak-conformance)
+to the expected type, it is widened to
+the expected type using one of the numeric conversion methods
+`toShort`, `toChar`, `toInt`, `toLong`,
+`toFloat`, `toDouble` defined [in the standard library](12-the-scala-standard-library.html#numeric-value-types).
+
+Since conversions from `Int` to `Float` and from `Long` to `Float` or `Double`
+may incur a loss of precision, those implicit conversions are deprecated.
+The conversion is permitted for literals if the original value can be recovered,
+that is, if conversion back to the original type produces the original value.
+
+###### Numeric Literal Narrowing
+If the expected type is `Byte`, `Short` or `Char`, and
+the expression ´e´ is an integer literal fitting in the range of that
+type, it is converted to the same literal in that type.
+
+###### Value Discarding
+If ´e´ has some value type and the expected type is `Unit`,
+´e´ is converted to the expected type by embedding it in the
+term `{ ´e´; () }`.
+
+###### SAM conversion
+An expression `(p1, ..., pN) => body` of function type `(T1, ..., TN) => T` is sam-convertible to the expected type `S` if the following holds:
+  - the class `C` of `S` declares an abstract method `m` with signature `(p1: A1, ..., pN: AN): R`;
+  - besides `m`, `C` must not declare or inherit any other deferred value members;
+  - the method `m` must have a single argument list;
+  - there must be a type `U` that is a subtype of `S`, so that the expression
+    `new U { final def m(p1: A1, ..., pN: AN): R = body }` is well-typed (conforming to the expected type `S`);
+  - for the purpose of scoping, `m` should be considered a static member (`U`'s members are not in scope in `body`);
+  - `(A1, ..., AN) => R` is a subtype of `(T1, ..., TN) => T` (satisfying this condition drives type inference of unknown type parameters in `S`);
+
+Note that a function literal that targets a SAM is not necessarily compiled to the above instance creation expression. This is platform-dependent.
+
+It follows that:
+  - if class `C` defines a constructor, it must be accessible and must define exactly one, empty, argument list;
+  - class `C` cannot be `final` or `sealed` (for simplicity we ignore the possibility of SAM conversion in the same compilation unit as the sealed class);
+  - `m` cannot be polymorphic;
+  - it must be possible to derive a fully-defined type `U` from `S` by inferring any unknown type parameters of `C`.
+
+Finally, we impose some implementation restrictions (these may be lifted in future releases):
+  - `C` must not be nested or local (it must not capture its environment, as that results in a nonzero-argument constructor)
+  - `C`'s constructor must not have an implicit argument list (this simplifies type inference);
+  - `C` must not declare a self type (this simplifies type inference);
+  - `C` must not be `@specialized`.
+
+###### View Application
+If none of the previous conversions applies, and ´e´'s type
+does not conform to the expected type ´\mathit{pt}´, it is attempted to convert
+´e´ to the expected type with a [view](07-implicits.html#views).
+
+###### Selection on `Dynamic`
+If none of the previous conversions applies, and ´e´ is a prefix
+of a selection ´e.x´, and ´e´'s type conforms to class `scala.Dynamic`,
+then the selection is rewritten according to the rules for
+[dynamic member selection](#dynamic-member-selection).
+
+### Method Conversions
+
+The following four implicit conversions can be applied to methods
+which are not applied to some argument list.
+
+###### Evaluation
+A parameterless method ´m´ of type `=> ´T´` is always converted to
+type ´T´ by evaluating the expression to which ´m´ is bound.
+
+###### Implicit Application
+If the method takes only implicit parameters, implicit
+arguments are passed following the rules [here](07-implicits.html#implicit-parameters).
+
+###### Eta Expansion
+Otherwise, if the method is not a constructor,
+and the expected type ´\mathit{pt}´ is a function type, or,
+for methods of non-zero arity, a type [sam-convertible](#sam-conversion) to a function type,
+´(\mathit{Ts}') \Rightarrow T'´, [eta-expansion](#eta-expansion-section)
+is performed on the expression ´e´.
+
+(The exception for zero-arity methods is to avoid surprises due to unexpected sam conversion.)
+
+###### Empty Application
+Otherwise, if ´e´ has method type ´()T´, it is implicitly applied to the empty
+argument list, yielding ´e()´.
+
+### Overloading Resolution
+
+If an identifier or selection ´e´ references several members of a
+class, the context of the reference is used to identify a unique
+member.  The way this is done depends on whether or not ´e´ is used as
+a function. Let ´\mathscr{A}´ be the set of members referenced by ´e´.
+
+Assume first that ´e´ appears as a function in an application, as in
+`´e´(´e_1 , \ldots , e_m´)`.
+
+One first determines the set of functions that is potentially [applicable](#function-applications)
+based on the _shape_ of the arguments.
+
+The *shape* of an argument expression ´e´, written  ´\mathit{shape}(e)´, is
+a type that is defined as follows:
+  - For a function expression `(´p_1´: ´T_1 , \ldots , p_n´: ´T_n´) => ´b´: (Any ´, \ldots ,´ Any) => ´\mathit{shape}(b)´`,
+    where `Any` occurs ´n´ times in the argument type.
+  - For a pattern-matching anonymous function definition `{ case ... }`: `PartialFunction[Any, Nothing]`.
+  - For a named argument `´n´ = ´e´`: ´\mathit{shape}(e)´.
+  - For all other expressions: `Nothing`.
+
+Let ´\mathscr{B}´ be the set of alternatives in ´\mathscr{A}´ that are [_applicable_](#function-applications)
+to expressions ´(e_1 , \ldots , e_n)´ of types ´(\mathit{shape}(e_1) , \ldots , \mathit{shape}(e_n))´.
+If there is precisely one alternative in ´\mathscr{B}´, that alternative is chosen.
+
+Otherwise, let ´S_1 , \ldots , S_m´ be the list of types obtained by typing each argument as follows.
+
+Normally, an argument is typed without an expected type, except when
+all alternatives explicitly specify the same parameter type for this argument (a missing parameter type,
+due to e.g. arity differences, is taken as `NoType`, thus resorting to no expected type),
+or when trying to propagate more type information to aid inference of higher-order function parameter types, as explained next.
+
+The intuition for higher-order function parameter type inference is that all arguments must be of a function-like type
+(`PartialFunction`, `FunctionN` or some equivalent [SAM type](#sam-conversion)),
+which in turn must define the same set of higher-order argument types, so that they can safely be used as
+the expected type of a given argument of the overloaded method, without unduly ruling out any alternatives.
+The intent is not to steer overloading resolution, but to preserve enough type information to steer type
+inference of the arguments (a function literal or eta-expanded method) to this overloaded method.
+
+Note that the expected type drives eta-expansion (not performed unless a function-like type is expected),
+as well as inference of omitted parameter types of function literals.
+
+More precisely, an argument `´e_i´` is typed with an expected type that is derived from the `´i´`th argument
+type found in each alternative (call these `´T_{ij}´` for alternative `´j´` and argument position `´i´`) when
+all `´T_{ij}´` are function types `´(A_{1j},..., A_{nj}) => ?´` (or the equivalent `PartialFunction`, or SAM)
+of some arity `´n´`, and their argument types `´A_{kj}´` are identical across all overloads `´j´` for a
+given `´k´`. Then, the expected type for `´e_i´` is derived as follows:
+   - we use `´PartialFunction[A_{1j},..., A_{nj}, ?]´` if for some overload `´j´`, `´T_{ij}´`'s type symbol is `PartialFunction`;
+   - else, if for some `´j´`, `´T_{ij}´` is `FunctionN`, the expected type is `´FunctionN[A_{1j},..., A_{nj}, ?]´`;
+   - else, if for all `´j´`, `´T_{ij}´` is a SAM type of the same class, defining argument types `´A_{1j},..., A_{nj}´`
+     (and a potentially varying result type), the expected type encodes these argument types and the SAM class.
+
+For every member ´m´ in ´\mathscr{B}´ one determines whether it is applicable
+to expressions (´e_1 , \ldots , e_m´) of types ´S_1, \ldots , S_m´.
+
+It is an error if none of the members in ´\mathscr{B}´ is applicable. If there is one
+single applicable alternative, that alternative is chosen. Otherwise, let ´\mathscr{CC}´
+be the set of applicable alternatives which don't employ any default argument
+in the application to ´e_1 , \ldots , e_m´.
+
+It is again an error if ´\mathscr{CC}´ is empty.
+Otherwise, one chooses the _most specific_ alternative among the alternatives
+in ´\mathscr{CC}´, according to the following definition of being "as specific as", and
+"more specific than":
+
+<!--
+question: given
+  def f(x: Int)
+  val f: { def apply(x: Int) }
+  f(1) // the value is chosen in our current implementation
+ why?
+  - method is as specific as value, because value is applicable to method`s argument types (item 1)
+  - value is as specific as method (item 3, any other type is always as specific..)
+ so the method is not more specific than the value.
+-->
+
+- A parameterized method ´m´ of type `(´p_1:T_1, \ldots , p_n:T_n´)´U´` is
+  _as specific as_ some other member ´m'´ of type ´S´ if ´m'´ is [applicable](#function-applications)
+  to arguments `(´p_1 , \ldots , p_n´)` of types ´T_1 , \ldots , T_n´.
+- A polymorphic method of type `[´a_1´ >: ´L_1´ <: ´U_1 , \ldots , a_n´ >: ´L_n´ <: ´U_n´]´T´` is
+  as specific as some other member of type ´S´ if ´T´ is as specific as ´S´
+  under the assumption that for ´i = 1 , \ldots , n´ each ´a_i´ is an abstract type name
+  bounded from below by ´L_i´ and from above by ´U_i´.
+- A member of any other type is always as specific as a parameterized method or a polymorphic method.
+- Given two members of types ´T´ and ´U´ which are neither parameterized nor polymorphic method types,
+  the member of type ´T´ is as specific as the member of type ´U´ if
+  the existential dual of ´T´ conforms to the existential dual of ´U´.
+  Here, the existential dual of a polymorphic type
+  `[´a_1´ >: ´L_1´ <: ´U_1 , \ldots , a_n´ >: ´L_n´ <: ´U_n´]´T´` is
+  `´T´ forSome { type ´a_1´ >: ´L_1´ <: ´U_1´ ´, \ldots ,´ type ´a_n´ >: ´L_n´ <: ´U_n´}`.
+  The existential dual of every other type is the type itself.
+
+The _relative weight_ of an alternative ´A´ over an alternative ´B´ is a
+number from 0 to 2, defined as the sum of
+
+- 1 if ´A´ is as specific as ´B´, 0 otherwise, and
+- 1 if ´A´ is defined in a class or object which is derived from the class or object defining ´B´, 0 otherwise.
+
+A class or object ´C´ is _derived_ from a class or object ´D´ if one of
+the following holds:
+
+- ´C´ is a subclass of ´D´, or
+- ´C´ is a companion object of a class derived from ´D´, or
+- ´D´ is a companion object of a class from which ´C´ is derived.
+
+An alternative ´A´ is _more specific_ than an alternative ´B´ if
+the relative weight of ´A´ over ´B´ is greater than the relative
+weight of ´B´ over ´A´.
+
+It is an error if there is no alternative in ´\mathscr{CC}´ which is more
+specific than all other alternatives in ´\mathscr{CC}´.
+
+Assume next that ´e´ appears as a function in a type application, as
+in `´e´[´\mathit{targs}\,´]`. Then all alternatives in
+´\mathscr{A}´ which take the same number of type parameters as there are type
+arguments in ´\mathit{targs}´ are chosen. It is an error if no such alternative exists.
+If there are several such alternatives, overloading resolution is
+applied again to the whole expression `´e´[´\mathit{targs}\,´]`.
+
+Assume finally that ´e´ does not appear as a function in either an application or a type application.
+If an expected type is given, let ´\mathscr{B}´ be the set of those alternatives
+in ´\mathscr{A}´ which are [compatible](03-types.html#compatibility) to it.
+Otherwise, let ´\mathscr{B}´ be the same as ´\mathscr{A}´.
+In this last case we choose the most specific alternative among all alternatives in ´\mathscr{B}´.
+It is an error if there is no alternative in ´\mathscr{B}´ which is
+more specific than all other alternatives in ´\mathscr{B}´.
+
+###### Example
+Consider the following definitions:
+
+```scala
+class A extends B {}
+def f(x: B, y: B) = ´\ldots´
+def f(x: A, y: B) = ´\ldots´
+val a: A
+val b: B
+```
+
+Then the application `f(b, b)` refers to the first
+definition of ´f´ whereas the application `f(a, a)`
+refers to the second.  Assume now we add a third overloaded definition
+
+```scala
+def f(x: B, y: A) = ´\ldots´
+```
+
+Then the application `f(a, a)` is rejected for being ambiguous, since
+no most specific applicable signature exists.
+
+### Local Type Inference
+
+Local type inference infers type arguments to be passed to expressions
+of polymorphic type. Say ´e´ is of type [´a_1´ >: ´L_1´ <: ´U_1, \ldots , a_n´ >: ´L_n´ <: ´U_n´]´T´
+and no explicit type parameters are given.
+
+Local type inference converts this expression to a type
+application `´e´[´T_1 , \ldots , T_n´]`. The choice of the
+type arguments ´T_1 , \ldots , T_n´ depends on the context in which
+the expression appears and on the expected type ´\mathit{pt}´.
+There are three cases.
+
+###### Case 1: Selections
+If the expression appears as the prefix of a selection with a name
+´x´, then type inference is _deferred_ to the whole expression
+´e.x´. That is, if ´e.x´ has type ´S´, it is now treated as having
+type [´a_1´ >: ´L_1´ <: ´U_1 , \ldots , a_n´ >: ´L_n´ <: ´U_n´]´S´,
+and local type inference is applied in turn to infer type arguments
+for ´a_1 , \ldots , a_n´, using the context in which ´e.x´ appears.
+
+###### Case 2: Values
+If the expression ´e´ appears as a value without being applied to
+value arguments, the type arguments are inferred by solving a
+constraint system which relates the expression's type ´T´ with the
+expected type ´\mathit{pt}´. Without loss of generality we can assume that
+´T´ is a value type; if it is a method type we apply
+[eta-expansion](#eta-expansion-section) to convert it to a function type. Solving
+means finding a substitution ´\sigma´ of types ´T_i´ for the type
+parameters ´a_i´ such that
+
+- None of the inferred types ´T_i´ is a [singleton type](03-types.html#singleton-types)
+  unless it is a singleton type corresponding to an object or a constant value
+  definition or the corresponding bound ´U_i´ is a subtype of `scala.Singleton`.
+- All type parameter bounds are respected, i.e.
+  ´\sigma L_i <: \sigma a_i´ and ´\sigma a_i <: \sigma U_i´ for ´i = 1 , \ldots , n´.
+- The expression's type conforms to the expected type, i.e.
+  ´\sigma T <: \sigma \mathit{pt}´.
+
+It is a compile time error if no such substitution exists.
+If several substitutions exist, local-type inference will choose for
+each type variable ´a_i´ a minimal or maximal type ´T_i´ of the
+solution space.  A _maximal_ type ´T_i´ will be chosen if the type
+parameter ´a_i´ appears [contravariantly](04-basic-declarations-and-definitions.html#variance-annotations) in the
+type ´T´ of the expression.  A _minimal_ type ´T_i´ will be chosen
+in all other situations, i.e. if the variable appears covariantly,
+non-variantly or not at all in the type ´T´. We call such a substitution
+an _optimal solution_ of the given constraint system for the type ´T´.
+
+###### Case 3: Methods
+The last case applies if the expression
+´e´ appears in an application ´e(d_1 , \ldots , d_m)´. In that case
+´T´ is a method type ´(p_1:R_1 , \ldots , p_m:R_m)T'´. Without loss of
+generality we can assume that the result type ´T'´ is a value type; if
+it is a method type we apply [eta-expansion](#eta-expansion-section) to
+convert it to a function type.  One computes first the types ´S_j´ of
+the argument expressions ´d_j´, using two alternative schemes.  Each
+argument expression ´d_j´ is typed first with the expected type ´R_j´,
+in which the type parameters ´a_1 , \ldots , a_n´ are taken as type
+constants.  If this fails, the argument ´d_j´ is typed instead with an
+expected type ´R_j'´ which results from ´R_j´ by replacing every type
+parameter in ´a_1 , \ldots , a_n´ with _undefined_.
+
+In a second step, type arguments are inferred by solving a constraint
+system which relates the method's type with the expected type
+´\mathit{pt}´ and the argument types ´S_1 , \ldots , S_m´. Solving the
+constraint system means
+finding a substitution ´\sigma´ of types ´T_i´ for the type parameters
+´a_i´ such that
+
+- None of the inferred types ´T_i´ is a [singleton type](03-types.html#singleton-types)
+  unless it is a singleton type corresponding to an object or a constant value
+  definition or the corresponding bound ´U_i´ is a subtype of `scala.Singleton`.
+- All type parameter bounds are respected, i.e. ´\sigma L_i <: \sigma a_i´ and
+  ´\sigma a_i <: \sigma U_i´ for ´i = 1 , \ldots , n´.
+- The method's result type ´T'´ conforms to the expected type, i.e. ´\sigma T' <: \sigma \mathit{pt}´.
+- Each argument type [weakly conforms](03-types.html#weak-conformance)
+  to the corresponding formal parameter
+  type, i.e. ´\sigma S_j <:_w \sigma R_j´ for ´j = 1 , \ldots , m´.
+
+It is a compile time error if no such substitution exists.  If several
+solutions exist, an optimal one for the type ´T'´ is chosen.
+
+All or parts of an expected type ´\mathit{pt}´ may be undefined. The rules for
+[conformance](03-types.html#conformance) are extended to this case by adding
+the rule that for any type ´T´ the following two statements are always
+true: ´\mathit{undefined} <: T´ and ´T <: \mathit{undefined}´
+
+It is possible that no minimal or maximal solution for a type variable
+exists, in which case a compile-time error results. Because ´<:´ is a
+pre-order, it is also possible that a solution set has several optimal
+solutions for a type. In that case, a Scala compiler is free to pick
+any one of them.
+
+###### Example
+Consider the two methods:
+
+```scala
+def cons[A](x: A, xs: List[A]): List[A] = x :: xs
+def nil[B]: List[B] = Nil
+```
+
+and the definition
+
+```scala
+val xs = cons(1, nil)
+```
+
+The application of `cons` is typed with an undefined expected
+type. This application is completed by local type inference to
+`cons[Int](1, nil)`.
+Here, one uses the following
+reasoning to infer the type argument `Int` for the type
+parameter `a`:
+
+First, the argument expressions are typed. The first argument `1`
+has type `Int` whereas the second argument `nil` is
+itself polymorphic. One tries to type-check `nil` with an
+expected type `List[a]`. This leads to the constraint system
+
+```scala
+List[b?] <: List[a]
+```
+
+where we have labeled `b?` with a question mark to indicate
+that it is a variable in the constraint system.
+Because class `List` is covariant, the optimal
+solution of this constraint is
+
+```scala
+b = scala.Nothing
+```
+
+In a second step, one solves the following constraint system for
+the type parameter `a` of `cons`:
+
+```scala
+Int <: a?
+List[scala.Nothing] <: List[a?]
+List[a?] <: ´\mathit{undefined}´
+```
+
+The optimal solution of this constraint system is
+
+```scala
+a = Int
+```
+
+so `Int` is the type inferred for `a`.
+
+###### Example
+
+Consider now the definition
+
+```scala
+val ys = cons("abc", xs)
+```
+
+where `xs` is defined of type `List[Int]` as before.
+In this case local type inference proceeds as follows.
+
+First, the argument expressions are typed. The first argument
+`"abc"` has type `String`. The second argument `xs` is
+first tried to be typed with expected type `List[a]`. This fails,
+as `List[Int]` is not a subtype of `List[a]`. Therefore,
+the second strategy is tried; `xs` is now typed with expected type
+`List[´\mathit{undefined}´]`. This succeeds and yields the argument type
+`List[Int]`.
+
+In a second step, one solves the following constraint system for
+the type parameter `a` of `cons`:
+
+```scala
+String <: a?
+List[Int] <: List[a?]
+List[a?] <: ´\mathit{undefined}´
+```
+
+The optimal solution of this constraint system is
+
+```scala
+a = scala.Any
+```
+
+so `scala.Any` is the type inferred for `a`.
+
+### <a name="eta-expansion-section">Eta Expansion</a>
+
+_Eta-expansion_ converts an expression of method type to an
+equivalent expression of function type. It proceeds in two steps.
+
+First, one identifies the maximal sub-expressions of ´e´; let's
+say these are ´e_1 , \ldots , e_m´. For each of these, one creates a
+fresh name ´x_i´. Let ´e'´ be the expression resulting from
+replacing every maximal subexpression ´e_i´ in ´e´ by the
+corresponding fresh name ´x_i´. Second, one creates a fresh name ´y_i´
+for every argument type ´T_i´ of the method (´i = 1 , \ldots ,
+n´). The result of eta-conversion is then:
+
+```scala
+{ val ´x_1´ = ´e_1´;
+  ´\ldots´
+  val ´x_m´ = ´e_m´;
+  (´y_1: T_1 , \ldots , y_n: T_n´) => ´e'´(´y_1 , \ldots , y_n´)
+}
+```
+
+The behavior of [call-by-name parameters](#function-applications)
+is preserved under eta-expansion: the corresponding actual argument expression,
+a sub-expression of parameterless method type, is not evaluated in the expanded block.
+
+### Dynamic Member Selection
+
+The standard Scala library defines a marker trait `scala.Dynamic`. Subclasses of this trait are able to intercept selections and applications on their instances by defining methods of the names `applyDynamic`, `applyDynamicNamed`, `selectDynamic`, and `updateDynamic`.
+
+The following rewrites are performed, assuming ´e´'s type conforms to `scala.Dynamic`, and the original expression does not type check under the normal rules, as specified fully in the relevant subsection of [implicit conversion](#dynamic-member-selection):
+
+ *  `e.m[Ti](xi)` becomes `e.applyDynamic[Ti]("m")(xi)`
+ *  `e.m[Ti]`     becomes `e.selectDynamic[Ti]("m")`
+ *  `e.m = x`     becomes `e.updateDynamic("m")(x)`
+
+If any arguments are named in the application (one of the `xi` is of the shape `arg = x`), their name is preserved as the first component of the pair passed to `applyDynamicNamed` (for missing names, `""` is used):
+
+ *  `e.m[Ti](argi = xi)` becomes `e.applyDynamicNamed[Ti]("m")(("argi", xi))`
+
+Finally:
+
+ *  `e.m(x) = y` becomes `e.selectDynamic("m").update(x, y)`
+
+None of these methods are actually defined in the `scala.Dynamic`, so that users are free to define them with or without type parameters, or implicit arguments.
diff --git a/docs/_spec/07-implicits.md b/docs/_spec/07-implicits.md
new file mode 100644
index 000000000000..6f38fdd48074
--- /dev/null
+++ b/docs/_spec/07-implicits.md
@@ -0,0 +1,525 @@
+---
+title: Implicits
+layout: default
+chapter: 7
+---
+
+# Implicits
+
+## The Implicit Modifier
+
+```ebnf
+LocalModifier  ::= ‘implicit’
+ParamClauses   ::= {ParamClause} [nl] ‘(’ ‘implicit’ Params ‘)’
+```
+
+Template members and parameters labeled with an `implicit`
+modifier can be passed to [implicit parameters](#implicit-parameters)
+and can be used as implicit conversions called [views](#views).
+The `implicit` modifier is illegal for all
+type members, as well as for [top-level objects](09-top-level-definitions.html#packagings).
+
+###### Example Monoid
+
+The following code defines an abstract class of monoids and
+two concrete implementations, `StringMonoid` and
+`IntMonoid`. The two implementations are marked implicit.
+
+```scala
+abstract class Monoid[A] extends SemiGroup[A] {
+  def unit: A
+  def add(x: A, y: A): A
+}
+object Monoids {
+  implicit object stringMonoid extends Monoid[String] {
+    def add(x: String, y: String): String = x.concat(y)
+    def unit: String = ""
+  }
+  implicit object intMonoid extends Monoid[Int] {
+    def add(x: Int, y: Int): Int = x + y
+    def unit: Int = 0
+  }
+}
+```
+
+## Implicit Parameters
+
+An _implicit parameter list_
+`(implicit ´p_1´,´\ldots´,´p_n´)` of a method marks the parameters ´p_1 , \ldots , p_n´ as
+implicit. A method or constructor can have only one implicit parameter
+list, and it must be the last parameter list given.
+
+A method with implicit parameters can be applied to arguments just
+like a normal method. In this case the `implicit` label has no
+effect. However, if such a method misses arguments for its implicit
+parameters, such arguments will be automatically provided.
+
+The actual arguments that are eligible to be passed to an implicit
+parameter of type ´T´ fall into two categories. First, eligible are
+all identifiers ´x´ that can be accessed at the point of the method
+call without a prefix and that denote an
+[implicit definition](#the-implicit-modifier)
+or an implicit parameter. To be accessible without a prefix, an identifier
+must be a local name, a member of an enclosing template or a name introduced by an
+[import clause](04-basic-declarations-and-definitions.html#import-clauses). If there are no eligible
+identifiers under this rule, then, second, eligible are also all
+`implicit` members of some object that belongs to the implicit
+scope of the implicit parameter's type, ´T´.
+
+The _implicit scope_ of a type ´T´ consists of all [companion modules](05-classes-and-objects.html#object-definitions) of classes that are associated with the implicit parameter's type.
+Here, we say a class ´C´ is _associated_ with a type ´T´ if it is a [base class](05-classes-and-objects.html#class-linearization) of some part of ´T´.
+
+The _parts_ of a type ´T´ are:
+
+- if ´T´ is a compound type `´T_1´ with ´\ldots´ with ´T_n´`,
+  the union of the parts of ´T_1 , \ldots , T_n´, as well as ´T´ itself;
+- if ´T´ is a parameterized type `´S´[´T_1 , \ldots , T_n´]`,
+  the union of the parts of ´S´ and ´T_1 , \ldots , T_n´;
+- if ´T´ is a singleton type `´p´.type`,
+  the parts of the type of ´p´;
+- if ´T´ is a type projection `´S´#´U´`,
+  the parts of ´S´ as well as ´T´ itself;
+- if ´T´ is a type alias, the parts of its expansion;
+- if ´T´ is an abstract type, the parts of its upper bound;
+- if ´T´ denotes an implicit conversion to a type with a method with argument types ´T_1 , \ldots , T_n´ and result type ´U´,
+  the union of the parts of ´T_1 , \ldots , T_n´ and ´U´;
+- the parts of quantified (existential or universal) and annotated types are defined as the parts of the underlying types (e.g., the parts of `T forSome { ... }` are the parts of `T`);
+- in all other cases, just ´T´ itself.
+
+Note that packages are internally represented as classes with companion modules to hold the package members.
+Thus, implicits defined in a package object are part of the implicit scope of a type prefixed by that package.
+
+If there are several eligible arguments which match the implicit
+parameter's type, a most specific one will be chosen using the rules
+of static [overloading resolution](06-expressions.html#overloading-resolution).
+If the parameter has a default argument and no implicit argument can
+be found the default argument is used.
+
+###### Example
+Assuming the classes from the [`Monoid` example](#example-monoid), here is a
+method which computes the sum of a list of elements using the
+monoid's `add` and `unit` operations.
+
+```scala
+def sum[A](xs: List[A])(implicit m: Monoid[A]): A =
+  if (xs.isEmpty) m.unit
+  else m.add(xs.head, sum(xs.tail))
+```
+
+The monoid in question is marked as an implicit parameter, and can therefore
+be inferred based on the type of the list.
+Consider for instance the call `sum(List(1, 2, 3))`
+in a context where `stringMonoid` and `intMonoid`
+are visible.  We know that the formal type parameter `a` of
+`sum` needs to be instantiated to `Int`. The only
+eligible object which matches the implicit formal parameter type
+`Monoid[Int]` is `intMonoid` so this object will
+be passed as implicit parameter.
+
+This discussion also shows that implicit parameters are inferred after
+any type arguments are [inferred](06-expressions.html#local-type-inference).
+
+Implicit methods can themselves have implicit parameters. An example
+is the following method from module `scala.List`, which injects
+lists into the `scala.Ordered` class, provided the element
+type of the list is also convertible to this type.
+
+```scala
+implicit def list2ordered[A](x: List[A])
+  (implicit elem2ordered: A => Ordered[A]): Ordered[List[A]] =
+  ...
+```
+
+Assume in addition a method
+
+```scala
+implicit def int2ordered(x: Int): Ordered[Int]
+```
+
+that injects integers into the `Ordered` class.  We can now
+define a `sort` method over ordered lists:
+
+```scala
+def sort[A](xs: List[A])(implicit a2ordered: A => Ordered[A]) = ...
+```
+
+We can apply `sort` to a list of lists of integers
+`yss: List[List[Int]]`
+as follows:
+
+```scala
+sort(yss)
+```
+
+The call above will be completed by passing two nested implicit arguments:
+
+```scala
+sort(yss)((xs: List[Int]) => list2ordered[Int](xs)(int2ordered))
+```
+
+The possibility of passing implicit arguments to implicit arguments
+raises the possibility of an infinite recursion.  For instance, one
+might try to define the following method, which injects _every_ type into the
+`Ordered` class:
+
+```scala
+implicit def magic[A](x: A)(implicit a2ordered: A => Ordered[A]): Ordered[A] =
+  a2ordered(x)
+```
+
+Now, if one tried to apply
+`sort` to an argument `arg` of a type that did not have
+another injection into the `Ordered` class, one would obtain an infinite
+expansion:
+
+```scala
+sort(arg)(x => magic(x)(x => magic(x)(x => ... )))
+```
+
+Such infinite expansions should be detected and reported as errors, however to support the deliberate
+implicit construction of recursive values we allow implicit arguments to be marked as by-name. At call
+sites recursive uses of implicit values are permitted if they occur in an implicit by-name argument.
+
+Consider the following example,
+
+```scala
+trait Foo {
+  def next: Foo
+}
+
+object Foo {
+  implicit def foo(implicit rec: Foo): Foo =
+    new Foo { def next = rec }
+}
+
+val foo = implicitly[Foo]
+assert(foo eq foo.next)
+```
+
+As with the `magic` case above this diverges due to the recursive implicit argument `rec` of method
+`foo`. If we mark the implicit argument as by-name,
+
+```scala
+trait Foo {
+  def next: Foo
+}
+
+object Foo {
+  implicit def foo(implicit rec: => Foo): Foo =
+    new Foo { def next = rec }
+}
+
+val foo = implicitly[Foo]
+assert(foo eq foo.next)
+```
+
+the example compiles with the assertion successful.
+
+When compiled, recursive by-name implicit arguments of this sort are extracted out as val members of a
+local synthetic object at call sites as follows,
+
+```scala
+val foo: Foo = scala.Predef.implicitly[Foo](
+  {
+    object LazyDefns$1 {
+      val rec$1: Foo = Foo.foo(rec$1)
+                       //      ^^^^^
+                       // recursive knot tied here
+    }
+    LazyDefns$1.rec$1
+  }
+)
+assert(foo eq foo.next)
+```
+
+Note that the recursive use of `rec$1` occurs within the by-name argument of `foo` and is consequently
+deferred. The desugaring matches what a programmer would do to construct such a recursive value
+explicitly.
+
+To prevent infinite expansions, such as the `magic` example above, the compiler keeps track of a stack
+of “open implicit types” for which implicit arguments are currently being searched. Whenever an
+implicit argument for type ´T´ is searched, ´T´ is added to the stack paired with the implicit
+definition which produces it, and whether it was required to satisfy a by-name implicit argument or
+not. The type is removed from the stack once the search for the implicit argument either definitely
+fails or succeeds. Everytime a type is about to be added to the stack, it is checked against
+existing entries which were produced by the same implicit definition and then,
+
++ if it is equivalent to some type which is already on the stack and there is a by-name argument between
+  that entry and the top of the stack. In this case the search for that type succeeds immediately and
+  the implicit argument is compiled as a recursive reference to the found argument.  That argument is
+  added as an entry in the synthesized implicit dictionary if it has not already been added.
++ otherwise if the _core_ of the type _dominates_ the core of a type already on the stack, then the
+  implicit expansion is said to _diverge_ and the search for that type fails immediately.
++ otherwise it is added to the stack paired with the implicit definition which produces it.
+  Implicit resolution continues with the implicit arguments of that definition (if any).
+
+Here, the _core type_ of ´T´ is ´T´ with aliases expanded,
+top-level type [annotations](11-annotations.html#user-defined-annotations) and
+[refinements](03-types.html#compound-types) removed, and occurrences of top-level existentially bound
+variables replaced by their upper bounds.
+
+A core type ´T´ _dominates_ a type ´U´ if ´T´ is [equivalent](03-types.html#equivalence) to ´U´,
+or if the top-level type constructors of ´T´ and ´U´ have a common element and ´T´ is more complex
+than ´U´ and the _covering sets_ of ´T´ and ´U´ are equal.
+
+The set of _top-level type constructors_ ´\mathit{ttcs}(T)´ of a type ´T´ depends on the form of
+the type:
+
+- For a type designator,  ´\mathit{ttcs}(p.c) ~=~ \{c\}´;
+- For a parameterized type,  ´\mathit{ttcs}(p.c[\mathit{targs}]) ~=~ \{c\}´;
+- For a singleton type,  ´\mathit{ttcs}(p.type) ~=~ \mathit{ttcs}(T)´, provided ´p´ has type ´T´;
+- For a compound type, `´\mathit{ttcs}(T_1´ with ´\ldots´ with ´T_n)´` ´~=~ \mathit{ttcs}(T_1) \cup \ldots \cup \mathit{ttcs}(T_n)´.
+
+The _complexity_ ´\operatorname{complexity}(T)´ of a core type is an integer which also depends on the form of
+the type:
+
+- For a type designator, ´\operatorname{complexity}(p.c) ~=~ 1 + \operatorname{complexity}(p)´
+- For a parameterized type, ´\operatorname{complexity}(p.c[\mathit{targs}]) ~=~ 1 + \Sigma \operatorname{complexity}(\mathit{targs})´
+- For a singleton type denoting a package ´p´, ´\operatorname{complexity}(p.type) ~=~ 0´
+- For any other singleton type, ´\operatorname{complexity}(p.type) ~=~ 1 + \operatorname{complexity}(T)´, provided ´p´ has type ´T´;
+- For a compound type, `´\operatorname{complexity}(T_1´ with ´\ldots´ with ´T_n)´` ´= \Sigma\operatorname{complexity}(T_i)´
+
+The _covering set_ ´\mathit{cs}(T)´ of a type ´T´ is the set of type designators mentioned in a type.
+For example, given the following,
+
+```scala
+type A = List[(Int, Int)]
+type B = List[(Int, (Int, Int))]
+type C = List[(Int, String)]
+```
+
+the corresponding covering sets are:
+
+- ´\mathit{cs}(A)´: List, Tuple2, Int
+- ´\mathit{cs}(B)´: List, Tuple2, Int
+- ´\mathit{cs}(C)´: List, Tuple2, Int, String
+
+###### Example
+When typing `sort(xs)` for some list `xs` of type `List[List[List[Int]]]`,
+the sequence of types for
+which implicit arguments are searched is
+
+```scala
+List[List[Int]] => Ordered[List[List[Int]]],
+List[Int] => Ordered[List[Int]],
+Int => Ordered[Int]
+```
+
+All types share the common type constructor `scala.Function1`,
+but the complexity of each new type is lower than the complexity of the previous types.
+Hence, the code typechecks.
+
+###### Example
+Let `ys` be a list of some type which cannot be converted
+to `Ordered`. For instance:
+
+```scala
+val ys = List(new IllegalArgumentException, new ClassCastException, new Error)
+```
+
+Assume that the definition of `magic` above is in scope. Then the sequence
+of types for which implicit arguments are searched is
+
+```scala
+Throwable => Ordered[Throwable],
+Throwable => Ordered[Throwable],
+...
+```
+
+Since the second type in the sequence is equal to the first, the compiler
+will issue an error signalling a divergent implicit expansion.
+
+## Views
+
+Implicit parameters and methods can also define implicit conversions
+called views. A _view_ from type ´S´ to type ´T´ is
+defined by an implicit value which has function type
+`´S´ => ´T´` or `(=> ´S´) => ´T´` or by a method convertible to a value of that
+type.
+
+Views are applied in three situations:
+
+1.  If an expression ´e´ is of type ´T´, and ´T´ does not conform to the
+    expression's expected type ´\mathit{pt}´. In this case an implicit ´v´ is
+    searched which is applicable to ´e´ and whose result type conforms to
+    ´\mathit{pt}´.  The search proceeds as in the case of implicit parameters,
+    where the implicit scope is the one of `´T´ => ´\mathit{pt}´`. If
+    such a view is found, the expression ´e´ is converted to
+    `´v´(´e´)`.
+1.  In a selection ´e.m´ with ´e´ of type ´T´, if the selector ´m´ does
+    not denote an accessible member of ´T´.  In this case, a view ´v´ is searched
+    which is applicable to ´e´ and whose result contains a member named
+    ´m´.  The search proceeds as in the case of implicit parameters, where
+    the implicit scope is the one of ´T´.  If such a view is found, the
+    selection ´e.m´ is converted to `´v´(´e´).´m´`.
+1.  In a selection ´e.m(\mathit{args})´ with ´e´ of type ´T´, if the selector
+    ´m´ denotes some member(s) of ´T´, but none of these members is applicable to the arguments
+    ´\mathit{args}´. In this case a view ´v´ is searched which is applicable to ´e´
+    and whose result contains a method ´m´ which is applicable to ´\mathit{args}´.
+    The search proceeds as in the case of implicit parameters, where
+    the implicit scope is the one of ´T´.  If such a view is found, the
+    selection ´e.m´ is converted to `´v´(´e´).´m(\mathit{args})´`.
+
+The implicit view, if it is found, can accept its argument ´e´ as a
+call-by-value or as a call-by-name parameter. However, call-by-value
+implicits take precedence over call-by-name implicits.
+
+As for implicit parameters, overloading resolution is applied
+if there are several possible candidates (of either the call-by-value
+or the call-by-name category).
+
+###### Example Ordered
+
+Class `scala.Ordered[A]` contains a method
+
+```scala
+  def <= [B >: A](that: B)(implicit b2ordered: B => Ordered[B]): Boolean
+```
+
+Assume two lists `xs` and `ys` of type `List[Int]`
+and assume that the `list2ordered` and `int2ordered`
+methods defined [here](#implicit-parameters) are in scope.
+Then the operation
+
+```scala
+  xs <= ys
+```
+
+is legal, and is expanded to:
+
+```scala
+  list2ordered(xs)(int2ordered).<=
+    (ys)
+    (xs => list2ordered(xs)(int2ordered))
+```
+
+The first application of `list2ordered` converts the list
+`xs` to an instance of class `Ordered`, whereas the second
+occurrence is part of an implicit parameter passed to the `<=`
+method.
+
+## Context Bounds and View Bounds
+
+```ebnf
+  TypeParam ::= (id | ‘_’) [TypeParamClause] [‘>:’ Type] [‘<:’ Type]
+                {‘<%’ Type} {‘:’ Type}
+```
+
+A type parameter ´A´ of a method or non-trait class may have one or more view
+bounds `´A´ <% ´T´`. In this case the type parameter may be
+instantiated to any type ´S´ which is convertible by application of a
+view to the bound ´T´.
+
+A type parameter ´A´ of a method or non-trait class may also have one
+or more context bounds `´A´ : ´T´`. In this case the type parameter may be
+instantiated to any type ´S´ for which _evidence_ exists at the
+instantiation point that ´S´ satisfies the bound ´T´. Such evidence
+consists of an implicit value with type ´T[S]´.
+
+A method or class containing type parameters with view or context bounds is treated as being
+equivalent to a method with implicit parameters. Consider first the case of a
+single parameter with view and/or context bounds such as:
+
+```scala
+def ´f´[´A´ <% ´T_1´ ... <% ´T_m´ : ´U_1´ : ´U_n´](´\mathit{ps}´): ´R´ = ...
+```
+
+Then the method definition above is expanded to
+
+```scala
+def ´f´[´A´](´\mathit{ps}´)(implicit ´v_1´: ´A´ => ´T_1´, ..., ´v_m´: ´A´ => ´T_m´,
+                       ´w_1´: ´U_1´[´A´], ..., ´w_n´: ´U_n´[´A´]): ´R´ = ...
+```
+
+where the ´v_i´ and ´w_j´ are fresh names for the newly introduced implicit parameters. These
+parameters are called _evidence parameters_.
+
+If a class or method has several view- or context-bounded type parameters, each
+such type parameter is expanded into evidence parameters in the order
+they appear and all the resulting evidence parameters are concatenated
+in one implicit parameter section.  Since traits do not take
+constructor parameters, this translation does not work for them.
+Consequently, type-parameters in traits may not be view- or context-bounded.
+
+Evidence parameters are prepended to the existing implicit parameter section, if one exists.
+
+For example:
+
+```scala
+def foo[A: M](implicit b: B): C
+// expands to:
+// def foo[A](implicit evidence´1: M[A], b: B): C
+```
+
+###### Example
+The `<=` method from the [`Ordered` example](#example-ordered) can be declared
+more concisely as follows:
+
+```scala
+def <= [B >: A <% Ordered[B]](that: B): Boolean
+```
+
+## Manifests
+
+Manifests are type descriptors that can be automatically generated by
+the Scala compiler as arguments to implicit parameters. The Scala
+standard library contains a hierarchy of four manifest classes,
+with `OptManifest`
+at the top. Their signatures follow the outline below.
+
+```scala
+trait OptManifest[+T]
+object NoManifest extends OptManifest[Nothing]
+trait ClassManifest[T] extends OptManifest[T]
+trait Manifest[T] extends ClassManifest[T]
+```
+
+If an implicit parameter of a method or constructor is of a subtype ´M[T]´ of
+class `OptManifest[T]`, _a manifest is determined for ´M[S]´_,
+according to the following rules.
+
+First if there is already an implicit argument that matches ´M[T]´, this
+argument is selected.
+
+Otherwise, let ´\mathit{Mobj}´ be the companion object `scala.reflect.Manifest`
+if ´M´ is trait `Manifest`, or be
+the companion object `scala.reflect.ClassManifest` otherwise. Let ´M'´ be the trait
+`Manifest` if ´M´ is trait `Manifest`, or be the trait `OptManifest` otherwise.
+Then the following rules apply.
+
+1.  If ´T´ is a value class or one of the classes `Any`, `AnyVal`, `Object`,
+    `Null`, or `Nothing`,
+    a manifest for it is generated by selecting
+    the corresponding manifest value `Manifest.´T´`, which exists in the
+    `Manifest` module.
+1.  If ´T´ is an instance of `Array[´S´]`, a manifest is generated
+    with the invocation `´\mathit{Mobj}´.arrayType[S](m)`, where ´m´ is the manifest
+    determined for ´M[S]´.
+1.  If ´T´ is some other class type ´S´#´C[U_1, \ldots, U_n]´ where the prefix
+    type ´S´ cannot be statically determined from the class ´C´,
+    a manifest is generated with the invocation `´\mathit{Mobj}´.classType[T](´m_0´, classOf[T], ´ms´)`
+    where ´m_0´ is the manifest determined for ´M'[S]´ and ´ms´ are the
+    manifests determined for ´M'[U_1], \ldots, M'[U_n]´.
+1.  If ´T´ is some other class type with type arguments ´U_1 , \ldots , U_n´,
+    a manifest is generated
+    with the invocation `´\mathit{Mobj}´.classType[T](classOf[T], ´ms´)`
+    where ´ms´ are the
+    manifests determined for ´M'[U_1] , \ldots , M'[U_n]´.
+1.  If ´T´ is a singleton type `´p´.type`, a manifest is generated with
+    the invocation `´\mathit{Mobj}´.singleType[T](´p´)`
+1.  If ´T´ is a refined type ´T' \{ R \}´, a manifest is generated for ´T'´.
+    (That is, refinements are never reflected in manifests).
+1.  If ´T´ is an intersection type
+    `´T_1´ with ´, \ldots ,´ with ´T_n´`
+    where ´n > 1´, the result depends on whether a full manifest is
+    to be determined or not.
+    If ´M´ is trait `Manifest`, then
+    a manifest is generated with the invocation
+    `Manifest.intersectionType[T](´ms´)` where ´ms´ are the manifests
+    determined for ´M[T_1] , \ldots , M[T_n]´.
+    Otherwise, if ´M´ is trait `ClassManifest`,
+    then a manifest is generated for the [intersection dominator](03-types.html#type-erasure)
+    of the types ´T_1 , \ldots , T_n´.
+1.  If ´T´ is some other type, then if ´M´ is trait `OptManifest`,
+    a manifest is generated from the designator `scala.reflect.NoManifest`.
+    If ´M´ is a type different from `OptManifest`, a static error results.
diff --git a/docs/_spec/08-pattern-matching.md b/docs/_spec/08-pattern-matching.md
new file mode 100644
index 000000000000..7607b0db85e0
--- /dev/null
+++ b/docs/_spec/08-pattern-matching.md
@@ -0,0 +1,817 @@
+---
+title: Pattern Matching
+layout: default
+chapter: 8
+---
+
+# Pattern Matching
+
+## Patterns
+
+```ebnf
+  Pattern         ::=  Pattern1 { ‘|’ Pattern1 }
+  Pattern1        ::=  boundvarid ‘:’ TypePat
+                    |  ‘_’ ‘:’ TypePat
+                    |  Pattern2
+  Pattern2        ::=  id [‘@’ Pattern3]
+                    |  Pattern3
+  Pattern3        ::=  SimplePattern
+                    |  SimplePattern {id [nl] SimplePattern}
+  SimplePattern   ::=  ‘_’
+                    |  varid
+                    |  Literal
+                    |  StableId
+                    |  StableId ‘(’ [Patterns] ‘)’
+                    |  StableId ‘(’ [Patterns ‘,’] [id ‘@’] ‘_’ ‘*’ ‘)’
+                    |  ‘(’ [Patterns] ‘)’
+                    |  XmlPattern
+  Patterns        ::=  Pattern {‘,’ Patterns}
+```
+
+A pattern is built from constants, constructors, variables and type
+tests. Pattern matching tests whether a given value (or sequence of values)
+has the shape defined by a pattern, and, if it does, binds the
+variables in the pattern to the corresponding components of the value
+(or sequence of values).  The same variable name may not be bound more
+than once in a pattern.
+
+###### Example
+Some examples of patterns are:
+ 1.  The pattern `ex: IOException` matches all instances of class
+        `IOException`, binding variable `ex` to the instance.
+ 1.  The pattern `Some(x)` matches values of the form `Some(´v´)`,
+        binding `x` to the argument value ´v´ of the `Some` constructor.
+ 1.  The pattern `(x, _)` matches pairs of values, binding `x` to
+        the first component of the pair. The second component is matched
+        with a wildcard pattern.
+ 1.  The pattern `x :: y :: xs` matches lists of length ´\geq 2´,
+        binding `x` to the list's first element, `y` to the list's
+        second element, and `xs` to the remainder.
+ 1.  The pattern `1 | 2 | 3` matches the integers between 1 and 3.
+
+Pattern matching is always done in a context which supplies an
+expected type of the pattern. We distinguish the following kinds of
+patterns.
+
+### Variable Patterns
+
+```ebnf
+  SimplePattern   ::=  ‘_’
+                    |  varid
+```
+
+A _variable pattern_ ´x´ is a simple identifier which starts with a
+lower case letter.  It matches any value, and binds the variable name
+to that value.  The type of ´x´ is the expected type of the pattern as
+given from outside.  A special case is the wild-card pattern `_`
+which is treated as if it was a fresh variable on each occurrence.
+
+### Typed Patterns
+
+```ebnf
+  Pattern1        ::=  varid ‘:’ TypePat
+                    |  ‘_’ ‘:’ TypePat
+```
+
+A _typed pattern_ ´x: T´ consists of a pattern variable ´x´ and a
+type pattern ´T´.  The type of ´x´ is the type pattern ´T´, where
+each type variable and wildcard is replaced by a fresh, unknown type.
+This pattern matches any value matched by the [type pattern](#type-patterns)
+´T´; it binds the variable name to
+that value.
+
+### Pattern Binders
+
+```ebnf
+  Pattern2        ::=  varid ‘@’ Pattern3
+```
+
+A _pattern binder_ `´x´@´p´` consists of a pattern variable ´x´ and a
+pattern ´p´. The type of the variable ´x´ is the static type ´T´ implied
+by the pattern ´p´.
+This pattern matches any value ´v´ matched by the pattern ´p´,
+and it binds the variable name to that value.
+
+A pattern ´p´ _implies_ a type ´T´ if the pattern matches only values of the type ´T´.
+
+### Literal Patterns
+
+```ebnf
+  SimplePattern   ::=  Literal
+```
+
+A _literal pattern_ ´L´ matches any value that is equal (in terms of
+`==`) to the literal ´L´. The type of ´L´ must conform to the
+expected type of the pattern.
+
+### Interpolated string patterns
+
+```ebnf
+  Literal  ::=  interpolatedString
+```
+
+The expansion of interpolated string literals in patterns is the same as 
+in expressions. If it occurs in a pattern, a interpolated string literal 
+of either of the forms
+```
+id"text0{ pat1 }text1 … { patn }textn"
+id"""text0{ pat1 }text1 … { patn }textn"""
+```
+is equivalent to:
+```
+StringContext("""text0""", …, """textn""").id(pat1, …, patn)
+```
+You could define your own `StringContext` to shadow the default one that's 
+in the `scala` package.
+
+This expansion is well-typed if the member `id` evaluates to an extractor 
+object. If the extractor object has `apply` as well as `unapply` or 
+`unapplySeq` methods, processed strings can be used as either expressions
+or patterns.
+
+Taking XML as an example
+```scala
+implicit class XMLinterpolation(s: StringContext) = {
+    object xml {
+        def apply(exprs: Any*) =
+            // parse ‘s’ and build an XML tree with ‘exprs’ 
+            //in the holes
+        def unapplySeq(xml: Node): Option[Seq[Node]] =
+          // match `s’ against `xml’ tree and produce 
+          //subtrees in holes
+    }
+}
+```
+Then, XML pattern matching could be expressed like this:
+```scala
+case xml"""
+      <body>
+        <a href = "some link"> $linktext </a>
+      </body>
+     """ => ...
+```
+where linktext is a variable bound by the pattern.
+
+### Stable Identifier Patterns
+
+```ebnf
+  SimplePattern   ::=  StableId
+```
+
+A _stable identifier pattern_ is a [stable identifier](03-types.html#paths) ´r´.
+The type of ´r´ must conform to the expected
+type of the pattern. The pattern matches any value ´v´ such that
+`´r´ == ´v´` (see [here](12-the-scala-standard-library.html#root-classes)).
+
+To resolve the syntactic overlap with a variable pattern, a
+stable identifier pattern may not be a simple name starting with a lower-case
+letter. However, it is possible to enclose such a variable name in
+backquotes; then it is treated as a stable identifier pattern.
+
+###### Example
+Consider the following class definition:
+
+```scala
+class C { c =>
+  val x = 42
+  val y = 27
+  val Z = 8
+  def f(x: Int) = x match {
+    case c.x => 1  // matches 42
+    case `y` => 2  // matches 27
+    case Z   => 3  // matches 8
+    case x   => 4  // matches any value
+  }
+}
+```
+
+Here, the first three patterns are stable identifier patterns, while the last
+one is a variable pattern.
+
+### Constructor Patterns
+
+```ebnf
+SimplePattern   ::=  StableId ‘(’ [Patterns] ‘)’
+```
+
+A _constructor pattern_ is of the form ´c(p_1 , \ldots , p_n)´ where ´n
+\geq 0´. It consists of a stable identifier ´c´, followed by element
+patterns ´p_1 , \ldots , p_n´. The constructor ´c´ is a simple or
+qualified name which denotes a [case class](05-classes-and-objects.html#case-classes).
+If the case class is monomorphic, then it
+must conform to the expected type of the pattern, and the formal
+parameter types of ´x´'s [primary constructor](05-classes-and-objects.html#class-definitions)
+are taken as the expected types of the element patterns ´p_1, \ldots ,
+p_n´.  If the case class is polymorphic, then its type parameters are
+instantiated so that the instantiation of ´c´ conforms to the expected
+type of the pattern. The instantiated formal parameter types of ´c´'s
+primary constructor are then taken as the expected types of the
+component patterns ´p_1, \ldots , p_n´.  The pattern matches all
+objects created from constructor invocations ´c(v_1 , \ldots , v_n)´
+where each element pattern ´p_i´ matches the corresponding value
+´v_i´.
+
+A special case arises when ´c´'s formal parameter types end in a
+repeated parameter. This is further discussed [here](#pattern-sequences).
+
+### Tuple Patterns
+
+```ebnf
+  SimplePattern   ::=  ‘(’ [Patterns] ‘)’
+```
+
+A _tuple pattern_ `(´p_1 , \ldots , p_n´)` is an alias
+for the constructor pattern `scala.Tuple´n´(´p_1 , \ldots , p_n´)`,
+where ´n \geq 2´. The empty tuple
+`()` is the unique value of type `scala.Unit`.
+
+### Extractor Patterns
+
+```ebnf
+  SimplePattern   ::=  StableId ‘(’ [Patterns] ‘)’
+```
+
+An _extractor pattern_ ´x(p_1 , \ldots , p_n)´ where ´n \geq 0´ is of
+the same syntactic form as a constructor pattern. However, instead of
+a case class, the stable identifier ´x´ denotes an object which has a
+member method named `unapply` or `unapplySeq` that matches
+the pattern.
+
+An extractor pattern cannot match the value `null`. The implementation
+ensures that the `unapply`/`unapplySeq` method is not applied to `null`.
+
+A type is said to be an _extractor type_ for some type `T` if it has a
+method `get` with return type `T`, and a method `isEmpty` with a return type
+that conforms to `Boolean`. `Option[T]` is an extractor type for type `T`.
+
+An `unapply` method in an object ´x´ _matches_ the pattern
+´x(p_1 , \ldots , p_n)´ if it has a single parameter (and, optionally, an
+implicit parameter list) and one of the following applies:
+
+* ´n=0´ and `unapply`'s result type conforms to `Boolean`. In this case
+  the extractor pattern matches all values ´v´ for which
+  `´x´.unapply(´v´)` yields `true`.
+* ´n=1´ and `unapply`'s result type is an extractor type for some
+  type ´T´.  In this case, the (only) argument pattern ´p_1´ is typed in
+  turn with expected type ´T´.  The extractor pattern matches then all
+  values ´v´ for which `´x´.unapply(´v´)` yields a value ´u´ for which `´u´.isEmpty` yields
+  `false`, `´u´.get` yields a value ´v_1´, and ´p_1´ matches ´v_1´.
+* ´n>1´ and `unapply`'s result type is
+  an extractor type for some type ´T´ with members ´\_1 , \ldots , \_n´ returning
+  types ´T_1 , \ldots , T_n´.  In this case, the argument patterns ´p_1
+  , \ldots , p_n´ are typed in turn with expected types ´T_1 , \ldots ,
+  T_n´.  The extractor pattern matches then all values ´v´ for which
+  `´x´.unapply(´v´)` yields a value ´u´ for which
+  `´u´.isEmpty` yields `false`, `´u´.get` yields some value ´t´, and each pattern
+  ´p_i´ matches the corresponding value ´t._1´ from
+  ´t._1 , \ldots , t._n´.
+
+An `unapplySeq` method in an object ´x´ matches the pattern
+´x(q_1 , \ldots , q_m, p_1 , \ldots , p_n)´ if it takes exactly one argument
+and its result type is of the form `Option[(´T_1 , \ldots , T_m´, Seq[S])]` (if `m = 0`, the type `Option[Seq[S]]` is also accepted).
+This case is further discussed [below](#pattern-sequences).
+
+###### Example 1
+
+If we define an extractor object `Pair`:
+
+```scala
+object Pair {
+  def apply[A, B](x: A, y: B) = Tuple2(x, y)
+  def unapply[A, B](x: Tuple2[A, B]): Option[Tuple2[A, B]] = Some(x)
+}
+```
+
+This means that the name `Pair` can be used in place of `Tuple2` for tuple
+formation as well as for deconstruction of tuples in patterns.
+Hence, the following is possible:
+
+```scala
+val x = (1, 2)
+val y = x match {
+  case Pair(i, s) => Pair(s + i, i * i)
+}
+```
+
+###### Example 2
+
+If we define a class `NameBased`
+
+```scala
+class NameBased[A, B](a: A, b: B) {
+  def isEmpty = false
+  def get = this
+  def _1 = a
+  def _2 = b
+}
+```
+
+Then `NameBased` is an extractor type for `NameBased` itself, since it has a
+member `isEmpty` returning a value of type Boolean, and it has a member `get`
+returning a value of type `NameBased`.
+
+Since it also has members `_1` and `_2`, it can be used in an extractor pattern
+with n = 2 as follows:
+
+```scala
+object Extractor {
+  def unapply(x: Any) = new NameBased(1, "two")
+}
+
+"anything" match {
+  case Extractor(a, b) => println(s"\$a, \$b") //prints "1, two"
+}
+```
+
+
+### Pattern Sequences
+
+```ebnf
+SimplePattern ::= StableId ‘(’ [Patterns ‘,’] [varid ‘@’] ‘_’ ‘*’ ‘)’
+```
+
+A _pattern sequence_ ´p_1 , \ldots , p_n´ appears in two contexts.
+First, in a constructor pattern ´c(q_1 , \ldots , q_m, p_1 , \ldots , p_n)´, where ´c´ is a case class which has ´m+1´ primary constructor parameters,  ending in a [repeated parameter](04-basic-declarations-and-definitions.html#repeated-parameters) of type `S*`.
+Second, in an extractor pattern ´x(q_1 , \ldots , q_m, p_1 , \ldots , p_n)´ if the extractor object ´x´ does not have an `unapply` method,
+but it does define an `unapplySeq` method with a result type that is an extractor type for type `(T_1, ... , T_m, Seq[S])` (if `m = 0`, an extractor type for the type `Seq[S]` is also accepted). The expected type for the patterns ´p_i´ is ´S´.
+
+The last pattern in a pattern sequence may be a _sequence wildcard_ `_*`.
+Each element pattern ´p_i´ is type-checked with
+´S´ as expected type, unless it is a sequence wildcard. If a final
+sequence wildcard is present, the pattern matches all values ´v´ that
+are sequences which start with elements matching patterns
+´p_1 , \ldots , p_{n-1}´.  If no final sequence wildcard is given, the
+pattern matches all values ´v´ that are sequences of
+length ´n´ which consist of elements matching patterns ´p_1 , \ldots ,
+p_n´.
+
+### Infix Operation Patterns
+
+```ebnf
+  Pattern3  ::=  SimplePattern {id [nl] SimplePattern}
+```
+
+An _infix operation pattern_ ´p;\mathit{op};q´ is a shorthand for the
+constructor or extractor pattern ´\mathit{op}(p, q)´.  The precedence and
+associativity of operators in patterns is the same as in
+[expressions](06-expressions.html#prefix,-infix,-and-postfix-operations).
+
+An infix operation pattern ´p;\mathit{op};(q_1 , \ldots , q_n)´ is a
+shorthand for the constructor or extractor pattern ´\mathit{op}(p, q_1
+, \ldots , q_n)´.
+
+### Pattern Alternatives
+
+```ebnf
+  Pattern   ::=  Pattern1 { ‘|’ Pattern1 }
+```
+
+A _pattern alternative_ `´p_1´ | ´\ldots´ | ´p_n´`
+consists of a number of alternative patterns ´p_i´. All alternative
+patterns are type checked with the expected type of the pattern. They
+may not bind variables other than wildcards. The alternative pattern
+matches a value ´v´ if at least one its alternatives matches ´v´.
+
+### XML Patterns
+
+XML patterns are treated [here](10-xml-expressions-and-patterns.html#xml-patterns).
+
+### Regular Expression Patterns
+
+Regular expression patterns have been discontinued in Scala from version 2.0.
+
+Later version of Scala provide a much simplified version of regular
+expression patterns that cover most scenarios of non-text sequence
+processing.  A _sequence pattern_ is a pattern that stands in a
+position where either (1) a pattern of a type `T` which is
+conforming to
+`Seq[A]` for some `A` is expected, or (2) a case
+class constructor that has an iterated formal parameter
+`A*`.  A wildcard star pattern `_*` in the
+rightmost position stands for arbitrary long sequences. It can be
+bound to variables using `@`, as usual, in which case the variable will have the
+type `Seq[A]`.
+
+### Irrefutable Patterns
+
+A pattern ´p´ is _irrefutable_ for a type ´T´, if one of the following applies:
+
+1.  ´p´ is a variable pattern,
+1.  ´p´ is a typed pattern ´x: T'´, and ´T <: T'´,
+1.  ´p´ is a constructor pattern ´c(p_1 , \ldots , p_n)´, the type ´T´
+    is an instance of class ´c´, the [primary constructor](05-classes-and-objects.html#class-definitions)
+    of type ´T´ has argument types ´T_1 , \ldots , T_n´, and each ´p_i´ is
+    irrefutable for ´T_i´.
+1.  ´p´ is an extractor pattern for which the extractor type is `Some[´T´]` for
+    some type ´T´
+1.  ´p´ is an extractor pattern for which the extractor types `isEmpty` method
+    is the singleton type `false`
+1.  ´p´ is an extractor pattern for which the return type is the singleton type
+    `true`
+
+## Type Patterns
+
+```ebnf
+  TypePat           ::=  Type
+```
+
+Type patterns consist of types, type variables, and wildcards.
+A type pattern ´T´ is of one of the following  forms:
+
+* A reference to a class ´C´, ´p.C´, or `´T´#´C´`.  This
+  type pattern matches any non-null instance of the given class.
+  Note that the prefix of the class, if it exists, is relevant for determining
+  class instances. For instance, the pattern ´p.C´ matches only
+  instances of classes ´C´ which were created with the path ´p´ as
+  prefix. This also applies to prefixes which are not given syntactically.
+  For example, if ´C´ refers to a class defined in the nearest enclosing
+  class and is thus equivalent to ´this.C´, it is considered to have a prefix.
+
+  The bottom types `scala.Nothing` and `scala.Null` cannot
+  be used as type patterns, because they would match nothing in any case.
+
+* A singleton type `´p´.type`. This type pattern matches only the value
+  denoted by the path ´p´ (the `eq` method is used to compare the matched value
+  to ´p´).
+
+* A literal type `´lit´`. This type pattern matches only the value
+  denoted by the literal ´lit´ (the `==` method is used to compare the matched
+  value to ´lit´).
+
+* A compound type pattern `´T_1´ with ´\ldots´ with ´T_n´` where each ´T_i´ is a
+  type pattern. This type pattern matches all values that are matched by each of
+  the type patterns ´T_i´.
+
+* A parameterized type pattern ´T[a_1 , \ldots , a_n]´, where the ´a_i´
+  are type variable patterns or wildcards `_`.
+  This type pattern matches all values which match ´T´ for
+  some arbitrary instantiation of the type variables and wildcards. The
+  bounds or alias type of these type variable are determined as
+  described [here](#type-parameter-inference-in-patterns).
+
+* A parameterized type pattern `scala.Array´[T_1]´`, where
+  ´T_1´ is a type pattern. This type pattern matches any non-null instance
+  of type `scala.Array´[U_1]´`, where ´U_1´ is a type matched by ´T_1´.
+
+Types which are not of one of the forms described above are also
+accepted as type patterns. However, such type patterns will be translated to their
+[erasure](03-types.html#type-erasure).  The Scala
+compiler will issue an "unchecked" warning for these patterns to
+flag the possible loss of type-safety.
+
+A _type variable pattern_ is a simple identifier which starts with
+a lower case letter.
+
+## Type Parameter Inference in Patterns
+
+Type parameter inference is the process of finding bounds for the
+bound type variables in a typed pattern or constructor
+pattern. Inference takes into account the expected type of the
+pattern.
+
+### Type parameter inference for typed patterns
+
+Assume a typed pattern ´p: T'´. Let ´T´ result from ´T'´ where all wildcards in
+´T'´ are renamed to fresh variable names. Let ´a_1 , \ldots , a_n´ be
+the type variables in ´T´. These type variables are considered bound
+in the pattern. Let the expected type of the pattern be ´\mathit{pt}´.
+
+Type parameter inference constructs first a set of subtype constraints over
+the type variables ´a_i´. The initial constraints set ´\mathcal{C}\_0´ reflects
+just the bounds of these type variables. That is, assuming ´T´ has
+bound type variables ´a_1 , \ldots , a_n´ which correspond to class
+type parameters ´a_1' , \ldots , a_n'´ with lower bounds ´L_1, \ldots , L_n´
+and upper bounds ´U_1 , \ldots , U_n´, ´\mathcal{C}_0´ contains the constraints
+
+$$
+\begin{cases}
+a_i &<: \sigma U_i & \quad (i = 1, \ldots , n) \\\\
+\sigma L_i &<: a_i & \quad (i = 1, \ldots , n)
+\end{cases}
+$$
+
+where ´\sigma´ is the substitution ´[a_1' := a_1 , \ldots , a_n' :=a_n]´.
+
+The set ´\mathcal{C}_0´ is then augmented by further subtype constraints. There are two
+cases.
+
+###### Case 1
+If there exists a substitution ´\sigma´ over the type variables ´a_i , \ldots , a_n´ such that ´\sigma T´ conforms to ´\mathit{pt}´, one determines the weakest subtype constraints
+´\mathcal{C}\_1´ over the type variables ´a_1, \ldots , a_n´ such that ´\mathcal{C}\_0 \wedge \mathcal{C}_1´ implies that ´T´ conforms to ´\mathit{pt}´.
+
+###### Case 2
+Otherwise, if ´T´ can not be made to conform to ´\mathit{pt}´ by
+instantiating its type variables, one determines all type variables in
+´\mathit{pt}´ which are defined as type parameters of a method enclosing
+the pattern. Let the set of such type parameters be ´b_1 , \ldots ,
+b_m´. Let ´\mathcal{C}\_0'´ be the subtype constraints reflecting the bounds of the
+type variables ´b_i´.  If ´T´ denotes an instance type of a final
+class, let ´\mathcal{C}\_2´ be the weakest set of subtype constraints over the type
+variables ´a_1 , \ldots , a_n´ and ´b_1 , \ldots , b_m´ such that
+´\mathcal{C}\_0 \wedge \mathcal{C}\_0' \wedge \mathcal{C}\_2´ implies that ´T´ conforms to
+´\mathit{pt}´.  If ´T´ does not denote an instance type of a final class,
+let ´\mathcal{C}\_2´ be the weakest set of subtype constraints over the type variables
+´a_1 , \ldots , a_n´ and ´b_1 , \ldots , b_m´ such that ´\mathcal{C}\_0 \wedge
+\mathcal{C}\_0' \wedge \mathcal{C}\_2´ implies that it is possible to construct a type
+´T'´ which conforms to both ´T´ and ´\mathit{pt}´. It is a static error if
+there is no satisfiable set of constraints ´\mathcal{C}\_2´ with this property.
+
+The final step consists in choosing type bounds for the type
+variables which imply the established constraint system. The process
+is different for the two cases above.
+
+###### Case 1
+We take ´a_i >: L_i <: U_i´ where each ´L_i´ is minimal and each ´U_i´ is maximal wrt ´<:´ such that ´a_i >: L_i <: U_i´ for ´i = 1, \ldots, n´ implies ´\mathcal{C}\_0 \wedge \mathcal{C}\_1´.
+
+###### Case 2
+We take ´a_i >: L_i <: U_i´ and ´b\_i >: L_i' <: U_i' ´ where each ´L_i´
+and ´L_j'´ is minimal and each ´U_i´ and ´U_j'´ is maximal such that
+´a_i >: L_i <: U_i´ for ´i = 1 , \ldots , n´ and
+´b_j >: L_j' <: U_j'´ for ´j = 1 , \ldots , m´
+implies ´\mathcal{C}\_0 \wedge \mathcal{C}\_0' \wedge \mathcal{C}_2´.
+
+In both cases, local type inference is permitted to limit the
+complexity of inferred bounds. Minimality and maximality of types have
+to be understood relative to the set of types of acceptable
+complexity.
+
+### Type parameter inference for constructor patterns
+Assume a constructor pattern ´C(p_1 , \ldots , p_n)´ where class ´C´
+has type parameters ´a_1 , \ldots , a_n´.  These type parameters
+are inferred in the same way as for the typed pattern
+`(_: ´C[a_1 , \ldots , a_n]´)`.
+
+###### Example
+Consider the program fragment:
+
+```scala
+val x: Any
+x match {
+  case y: List[a] => ...
+}
+```
+
+Here, the type pattern `List[a]` is matched against the
+expected type `Any`. The pattern binds the type variable
+`a`.  Since `List[a]` conforms to `Any`
+for every type argument, there are no constraints on `a`.
+Hence, `a` is introduced as an abstract type with no
+bounds. The scope of `a` is right-hand side of its case clause.
+
+On the other hand, if `x` is declared as
+
+```scala
+val x: List[List[String]],
+```
+
+this generates the constraint
+`List[a] <: List[List[String]]`, which simplifies to
+`a <: List[String]`, because `List` is covariant. Hence,
+`a` is introduced with upper bound
+`List[String]`.
+
+###### Example
+Consider the program fragment:
+
+```scala
+val x: Any
+x match {
+  case y: List[String] => ...
+}
+```
+
+Scala does not maintain information about type arguments at run-time,
+so there is no way to check that `x` is a list of strings.
+Instead, the Scala compiler will [erase](03-types.html#type-erasure) the
+pattern to `List[_]`; that is, it will only test whether the
+top-level runtime-class of the value `x` conforms to
+`List`, and the pattern match will succeed if it does.  This
+might lead to a class cast exception later on, in the case where the
+list `x` contains elements other than strings.  The Scala
+compiler will flag this potential loss of type-safety with an
+"unchecked" warning message.
+
+###### Example
+Consider the program fragment
+
+```scala
+class Term[A]
+class Number(val n: Int) extends Term[Int]
+def f[B](t: Term[B]): B = t match {
+  case y: Number => y.n
+}
+```
+
+The expected type of the pattern `y: Number` is
+`Term[B]`.  The type `Number` does not conform to
+`Term[B]`; hence Case 2 of the rules above
+applies. This means that `B` is treated as another type
+variable for which subtype constraints are inferred. In our case the
+applicable constraint is `Number <: Term[B]`, which
+entails `B = Int`.  Hence, `B` is treated in
+the case clause as an abstract type with lower and upper bound
+`Int`. Therefore, the right hand side of the case clause,
+`y.n`, of type `Int`, is found to conform to the
+function's declared result type, `Number`.
+
+## Pattern Matching Expressions
+
+```ebnf
+  Expr            ::=  PostfixExpr ‘match’ ‘{’ CaseClauses ‘}’
+  CaseClauses     ::=  CaseClause {CaseClause}
+  CaseClause      ::=  ‘case’ Pattern [Guard] ‘=>’ Block
+```
+
+A _pattern matching expression_
+
+```scala
+e match { case ´p_1´ => ´b_1´ ´\ldots´ case ´p_n´ => ´b_n´ }
+```
+
+consists of a selector expression ´e´ and a number ´n > 0´ of
+cases. Each case consists of a (possibly guarded) pattern ´p_i´ and a
+block ´b_i´. Each ´p_i´ might be complemented by a guard
+`if ´e´` where ´e´ is a boolean expression.
+The scope of the pattern
+variables in ´p_i´ comprises the pattern's guard and the corresponding block ´b_i´.
+
+Let ´T´ be the type of the selector expression ´e´ and let ´a_1
+, \ldots , a_m´ be the type parameters of all methods enclosing
+the pattern matching expression.  For every ´a_i´, let ´L_i´ be its
+lower bound and ´U_i´ be its higher bound.  Every pattern ´p \in \{p_1, , \ldots , p_n\}´
+can be typed in two ways. First, it is attempted
+to type ´p´ with ´T´ as its expected type. If this fails, ´p´ is
+instead typed with a modified expected type ´T'´ which results from
+´T´ by replacing every occurrence of a type parameter ´a_i´ by
+*undefined*.  If this second step fails also, a compile-time
+error results. If the second step succeeds, let ´T_p´ be the type of
+pattern ´p´ seen as an expression. One then determines minimal bounds
+´L_11 , \ldots , L_m'´ and maximal bounds ´U_1' , \ldots , U_m'´ such
+that for all ´i´, ´L_i <: L_i'´ and ´U_i' <: U_i´ and the following
+constraint system is satisfied:
+
+$$
+L_1 <: a_1 <: U_1\;\wedge\;\ldots\;\wedge\;L_m <: a_m <: U_m \ \Rightarrow\ T_p <: T
+$$
+
+If no such bounds can be found, a compile time error results.  If such
+bounds are found, the pattern matching clause starting with ´p´ is
+then typed under the assumption that each ´a_i´ has lower bound ´L_i'´
+instead of ´L_i´ and has upper bound ´U_i'´ instead of ´U_i´.
+
+The expected type of every block ´b_i´ is the expected type of the
+whole pattern matching expression.  The type of the pattern matching
+expression is then the [weak least upper bound](03-types.html#weak-conformance)
+of the types of all blocks
+´b_i´.
+
+When applying a pattern matching expression to a selector value,
+patterns are tried in sequence until one is found which matches the
+[selector value](#patterns). Say this case is `case ´p_i \Rightarrow b_i´`.
+The result of the whole expression is the result of evaluating ´b_i´,
+where all pattern variables of ´p_i´ are bound to
+the corresponding parts of the selector value.  If no matching pattern
+is found, a `scala.MatchError` exception is thrown.
+
+The pattern in a case may also be followed by a guard suffix
+`if e` with a boolean expression ´e´.  The guard expression is
+evaluated if the preceding pattern in the case matches. If the guard
+expression evaluates to `true`, the pattern match succeeds as
+normal. If the guard expression evaluates to `false`, the pattern
+in the case is considered not to match and the search for a matching
+pattern continues.
+
+In the interest of efficiency the evaluation of a pattern matching
+expression may try patterns in some other order than textual
+sequence. This might affect evaluation through
+side effects in guards. However, it is guaranteed that a guard
+expression is evaluated only if the pattern it guards matches.
+
+If the selector of a pattern match is an instance of a
+[`sealed` class](05-classes-and-objects.html#modifiers),
+the compilation of pattern matching can emit warnings which diagnose
+that a given set of patterns is not exhaustive, i.e. that there is a
+possibility of a `MatchError` being raised at run-time.
+
+###### Example
+
+Consider the following definitions of arithmetic terms:
+
+```scala
+abstract class Term[T]
+case class Lit(x: Int) extends Term[Int]
+case class Succ(t: Term[Int]) extends Term[Int]
+case class IsZero(t: Term[Int]) extends Term[Boolean]
+case class If[T](c: Term[Boolean],
+                 t1: Term[T],
+                 t2: Term[T]) extends Term[T]
+```
+
+There are terms to represent numeric literals, incrementation, a zero
+test, and a conditional. Every term carries as a type parameter the
+type of the expression it represents (either `Int` or `Boolean`).
+
+A type-safe evaluator for such terms can be written as follows.
+
+```scala
+def eval[T](t: Term[T]): T = t match {
+  case Lit(n)        => n
+  case Succ(u)       => eval(u) + 1
+  case IsZero(u)     => eval(u) == 0
+  case If(c, u1, u2) => eval(if (eval(c)) u1 else u2)
+}
+```
+
+Note that the evaluator makes crucial use of the fact that type
+parameters of enclosing methods can acquire new bounds through pattern
+matching.
+
+For instance, the type of the pattern in the second case,
+`Succ(u)`, is `Int`. It conforms to the selector type
+`T` only if we assume an upper and lower bound of `Int` for `T`.
+Under the assumption `Int <: T <: Int` we can also
+verify that the type right hand side of the second case, `Int`
+conforms to its expected type, `T`.
+
+## Pattern Matching Anonymous Functions
+
+```ebnf
+  BlockExpr ::= ‘{’ CaseClauses ‘}’
+```
+
+An anonymous function can be defined by a sequence of cases
+
+```scala
+{ case ´p_1´ => ´b_1´ ´\ldots´ case ´p_n´ => ´b_n´ }
+```
+
+which appear as an expression without a prior `match`.  The
+expected type of such an expression must in part be defined. It must
+be either `scala.Function´k´[´S_1 , \ldots , S_k´, ´R´]` for some ´k > 0´,
+or `scala.PartialFunction[´S_1´, ´R´]`, where the
+argument type(s) ´S_1 , \ldots , S_k´ must be fully determined, but the result type
+´R´ may be undetermined.
+
+If the expected type is [SAM-convertible](06-expressions.html#sam-conversion)
+to `scala.Function´k´[´S_1 , \ldots , S_k´, ´R´]`,
+the expression is taken to be equivalent to the anonymous function:
+
+```scala
+(´x_1: S_1 , \ldots , x_k: S_k´) => (´x_1 , \ldots , x_k´) match {
+  case ´p_1´ => ´b_1´ ´\ldots´ case ´p_n´ => ´b_n´
+}
+```
+
+Here, each ´x_i´ is a fresh name.
+As was shown [here](06-expressions.html#anonymous-functions), this anonymous function is in turn
+equivalent to the following instance creation expression, where
+ ´T´ is the weak least upper bound of the types of all ´b_i´.
+
+```scala
+new scala.Function´k´[´S_1 , \ldots , S_k´, ´T´] {
+  def apply(´x_1: S_1 , \ldots , x_k: S_k´): ´T´ = (´x_1 , \ldots , x_k´) match {
+    case ´p_1´ => ´b_1´ ´\ldots´ case ´p_n´ => ´b_n´
+  }
+}
+```
+
+If the expected type is `scala.PartialFunction[´S´, ´R´]`,
+the expression is taken to be equivalent to the following instance creation expression:
+
+```scala
+new scala.PartialFunction[´S´, ´T´] {
+  def apply(´x´: ´S´): ´T´ = x match {
+    case ´p_1´ => ´b_1´ ´\ldots´ case ´p_n´ => ´b_n´
+  }
+  def isDefinedAt(´x´: ´S´): Boolean = {
+    case ´p_1´ => true ´\ldots´ case ´p_n´ => true
+    case _ => false
+  }
+}
+```
+
+Here, ´x´ is a fresh name and ´T´ is the weak least upper bound of the
+types of all ´b_i´. The final default case in the `isDefinedAt`
+method is omitted if one of the patterns ´p_1 , \ldots , p_n´ is
+already a variable or wildcard pattern.
+
+###### Example
+Here's an example which uses 
+`foldLeft` to compute the scalar product of
+two vectors:
+
+```scala
+def scalarProduct(xs: Array[Double], ys: Array[Double]) =
+  (xs zip ys).foldLeft(0.0) {
+    case (a, (b, c)) => a + b * c
+  }
+```
+
+The case clauses in this code are equivalent to the following
+anonymous function:
+
+```scala
+(x, y) => (x, y) match {
+  case (a, (b, c)) => a + b * c
+}
+```
diff --git a/docs/_spec/09-top-level-definitions.md b/docs/_spec/09-top-level-definitions.md
new file mode 100644
index 000000000000..33c436e8d77b
--- /dev/null
+++ b/docs/_spec/09-top-level-definitions.md
@@ -0,0 +1,210 @@
+---
+title: Top-Level Definitions
+layout: default
+chapter: 9
+---
+
+# Top-Level Definitions
+
+## Compilation Units
+
+```ebnf
+CompilationUnit  ::=  {‘package’ QualId semi} TopStatSeq
+TopStatSeq       ::=  TopStat {semi TopStat}
+TopStat          ::=  {Annotation} {Modifier} TmplDef
+                   |  Import
+                   |  Packaging
+                   |  PackageObject
+                   |
+QualId           ::=  id {‘.’ id}
+```
+
+A compilation unit consists of a sequence of packagings, import
+clauses, and class and object definitions, which may be preceded by a
+package clause.
+
+A _compilation unit_
+
+```scala
+package ´p_1´;
+´\ldots´
+package ´p_n´;
+´\mathit{stats}´
+```
+
+starting with one or more package
+clauses is equivalent to a compilation unit consisting of the
+packaging
+
+```scala
+package ´p_1´ { ´\ldots´
+  package ´p_n´ {
+    ´\mathit{stats}´
+  } ´\ldots´
+}
+```
+
+Every compilation unit implicitly imports the following packages, in the given order:
+ 1. the package `java.lang`,
+ 2. the package `scala`, and
+ 3. the object [`scala.Predef`](12-the-scala-standard-library.html#the-predef-object), unless there is an explicit top-level import that references `scala.Predef`.
+
+Members of a later import in that order hide members of an earlier import.
+
+The exception to the implicit import of `scala.Predef` can be useful to hide, e.g., predefined implicit conversions.
+
+## Packagings
+
+```ebnf
+Packaging       ::=  ‘package’ QualId [nl] ‘{’ TopStatSeq ‘}’
+```
+
+A _package_ is a special object which defines a set of member classes,
+objects and packages.  Unlike other objects, packages are not introduced
+by a definition.  Instead, the set of members of a package is determined by
+packagings.
+
+A packaging `package ´p´ { ´\mathit{ds}´ }` injects all
+definitions in ´\mathit{ds}´ as members into the package whose qualified name
+is ´p´. Members of a package are called _top-level_ definitions.
+If a definition in ´\mathit{ds}´ is labeled `private`, it is
+visible only for other members in the package.
+
+Inside the packaging, all members of package ´p´ are visible under their
+simple names. However this rule does not extend to members of enclosing
+packages of ´p´ that are designated by a prefix of the path ´p´.
+
+```scala
+package org.net.prj {
+  ...
+}
+```
+
+all members of package `org.net.prj` are visible under their
+simple names, but members of packages `org` or `org.net` require
+explicit qualification or imports.
+
+Selections ´p´.´m´ from ´p´ as well as imports from ´p´
+work as for objects. However, unlike other objects, packages may not
+be used as values. It is illegal to have a package with the same fully
+qualified name as a module or a class.
+
+Top-level definitions outside a packaging are assumed to be injected
+into a special empty package. That package cannot be named and
+therefore cannot be imported. However, members of the empty package
+are visible to each other without qualification.
+
+## Package Objects
+
+```ebnf
+PackageObject   ::=  ‘package’ ‘object’ ObjectDef
+```
+
+A _package object_ `package object ´p´ extends ´t´` adds the
+members of template ´t´ to the package ´p´. There can be only one
+package object per package. The standard naming convention is to place
+the definition above in a file named `package.scala` that's
+located in the directory corresponding to package ´p´.
+
+The package object should not define a member with the same name as
+one of the top-level objects or classes defined in package ´p´. If
+there is a name conflict, the behavior of the program is currently
+undefined. It is expected that this restriction will be lifted in a
+future version of Scala.
+
+## Package References
+
+```ebnf
+QualId           ::=  id {‘.’ id}
+```
+
+A reference to a package takes the form of a qualified identifier.
+Like all other references, package references are relative. That is,
+a package reference starting in a name ´p´ will be looked up in the
+closest enclosing scope that defines a member named ´p´.
+
+If a package name is shadowed, it's possible to refer to its
+fully-qualified name by prefixing it with
+the special predefined name `_root_`, which refers to the
+outermost root package that contains all top-level packages.
+
+The name `_root_` has this special denotation only when
+used as the first element of a qualifier; it is an ordinary
+identifier otherwise.
+
+###### Example
+Consider the following program:
+
+```scala
+package b {
+  class B
+}
+
+package a {
+  package b {
+    class A {
+      val x = new _root_.b.B
+    }
+    class C {
+      import _root_.b._
+      def y = new B
+    }
+  }
+}
+
+```
+
+Here, the reference `_root_.b.B` refers to class `B` in the
+toplevel package `b`. If the `_root_` prefix had been
+omitted, the name `b` would instead resolve to the package
+`a.b`, and, provided that package does not also
+contain a class `B`, a compiler-time error would result.
+
+## Programs
+
+A _program_ is a top-level object that has a member method
+_main_ of type `(Array[String])Unit`. Programs can be
+executed from a command shell. The program's command arguments are
+passed to the `main` method as a parameter of type
+`Array[String]`.
+
+The `main` method of a program can be directly defined in the
+object, or it can be inherited. The scala library defines a special class
+`scala.App` whose body acts as a `main` method.
+An objects ´m´ inheriting from this class is thus a program,
+which executes the initialization code of the object ´m´.
+
+###### Example
+The following example will create a hello world program by defining
+a method `main` in module `test.HelloWorld`.
+
+```scala
+package test
+object HelloWorld {
+  def main(args: Array[String]) { println("Hello World") }
+}
+```
+
+This program can be started by the command
+
+```scala
+scala test.HelloWorld
+```
+
+In a Java environment, the command
+
+```scala
+java test.HelloWorld
+```
+
+would work as well.
+
+`HelloWorld` can also be defined without a `main` method
+by inheriting from `App` instead:
+
+```scala
+package test
+object HelloWorld extends App {
+  println("Hello World")
+}
+```
diff --git a/docs/_spec/10-xml-expressions-and-patterns.md b/docs/_spec/10-xml-expressions-and-patterns.md
new file mode 100644
index 000000000000..a9b7edb14fff
--- /dev/null
+++ b/docs/_spec/10-xml-expressions-and-patterns.md
@@ -0,0 +1,145 @@
+---
+title: XML
+layout: default
+chapter: 10
+---
+
+# XML Expressions and Patterns
+
+__By Burak Emir__
+
+This chapter describes the syntactic structure of XML expressions and patterns.
+It follows as closely as possible the XML 1.0 specification,
+changes being mandated by the possibility of embedding Scala code fragments.
+
+## XML expressions
+
+XML expressions are expressions generated by the following production, where the
+opening bracket `<` of the first element must be in a position to start the lexical
+[XML mode](01-lexical-syntax.html#xml-mode).
+
+```ebnf
+XmlExpr ::= XmlContent {Element}
+```
+
+Well-formedness constraints of the XML specification apply, which
+means for instance that start tags and end tags must match, and
+attributes may only be defined once, except for constraints
+related to entity resolution.
+
+The following productions describe Scala's extensible markup language,
+designed as close as possible to the W3C extensible markup language
+standard. Only the productions for attribute values and character data are changed.
+Scala does not support declarations. Entity references are not resolved at runtime.
+
+```ebnf
+Element       ::=    EmptyElemTag
+                |    STag Content ETag
+
+EmptyElemTag  ::=    ‘<’ Name {S Attribute} [S] ‘/>’
+
+STag          ::=    ‘<’ Name {S Attribute} [S] ‘>’
+ETag          ::=    ‘</’ Name [S] ‘>’
+Content       ::=    [CharData] {Content1 [CharData]}
+Content1      ::=    XmlContent
+                |    Reference
+                |    ScalaExpr
+XmlContent    ::=    Element
+                |    CDSect
+                |    PI
+                |    Comment
+```
+
+If an XML expression is a single element, its value is a runtime
+representation of an XML node (an instance of a subclass of
+`scala.xml.Node`). If the XML expression consists of more
+than one element, then its value is a runtime representation of a
+sequence of XML nodes (an instance of a subclass of
+`scala.Seq[scala.xml.Node]`).
+
+If an XML expression is an entity reference, CDATA section, processing
+instruction, or a comment, it is represented by an instance of the
+corresponding Scala runtime class.
+
+By default, beginning and trailing whitespace in element content is removed,
+and consecutive occurrences of whitespace are replaced by a single space
+character `\u0020`. This behavior can be changed to preserve all whitespace
+with a compiler option.
+
+```ebnf
+Attribute  ::=    Name Eq AttValue
+
+AttValue      ::=    ‘"’ {CharQ | CharRef} ‘"’
+                |    ‘'’ {CharA | CharRef} ‘'’
+                |    ScalaExpr
+
+ScalaExpr     ::=    Block
+
+CharData      ::=   { CharNoRef } ´\textit{ without}´ {CharNoRef}‘{’CharB {CharNoRef}
+                                  ´\textit{ and without}´ {CharNoRef}‘]]>’{CharNoRef}
+```
+
+<!-- {% raw  %} sigh: liquid borks on the double brace below; brace yourself, liquid! -->
+XML expressions may contain Scala expressions as attribute values or
+within nodes. In the latter case, these are embedded using a single opening
+brace `{` and ended by a closing brace `}`. To express a single opening braces
+within XML text as generated by CharData, it must be doubled.
+Thus, `{{` represents the XML text `{` and does not introduce an embedded Scala expression.
+<!-- {% endraw %} -->
+
+```ebnf
+BaseChar, CDSect, Char, Comment, CombiningChar, Ideographic, NameChar, PI, S, Reference
+              ::=  ´\textit{“as in W3C XML”}´
+
+Char1         ::=  Char ´\textit{ without}´ ‘<’ | ‘&’
+CharQ         ::=  Char1 ´\textit{ without}´ ‘"’
+CharA         ::=  Char1 ´\textit{ without}´ ‘'’
+CharB         ::=  Char1 ´\textit{ without}´ ‘{’
+
+Name          ::=  XNameStart {NameChar}
+
+XNameStart    ::= ‘_’ | BaseChar | Ideographic
+                 ´\textit{ (as in W3C XML, but without }´ ‘:’´)´
+```
+
+## XML patterns
+
+XML patterns are patterns generated by the following production, where
+the opening bracket `<` of the element patterns must be in a position
+to start the lexical [XML mode](01-lexical-syntax.html#xml-mode).
+
+```ebnf
+XmlPattern  ::= ElementPattern
+```
+
+Well-formedness constraints of the XML specification apply.
+
+An XML pattern has to be a single element pattern. It
+matches exactly those runtime
+representations of an XML tree
+that have the same structure as described by the pattern.
+XML patterns may contain [Scala patterns](08-pattern-matching.html#pattern-matching-expressions).
+
+Whitespace is treated the same way as in XML expressions.
+
+By default, beginning and trailing whitespace in element content is removed,
+and consecutive occurrences of whitespace are replaced by a single space
+character `\u0020`. This behavior can be changed to preserve all whitespace
+with a compiler option.
+
+```ebnf
+ElemPattern   ::=    EmptyElemTagP
+                |    STagP ContentP ETagP
+
+EmptyElemTagP ::=    ‘<’  Name [S] ‘/>’
+STagP         ::=    ‘<’  Name [S] ‘>’
+ETagP         ::=    ‘</’ Name [S] ‘>’
+ContentP      ::=    [CharData] {(ElemPattern|ScalaPatterns) [CharData]}
+ContentP1     ::=    ElemPattern
+                |    Reference
+                |    CDSect
+                |    PI
+                |    Comment
+                |    ScalaPatterns
+ScalaPatterns ::=    ‘{’ Patterns ‘}’
+```
diff --git a/docs/_spec/11-annotations.md b/docs/_spec/11-annotations.md
new file mode 100644
index 000000000000..388d99b60e56
--- /dev/null
+++ b/docs/_spec/11-annotations.md
@@ -0,0 +1,176 @@
+---
+title: Annotations
+layout: default
+chapter: 11
+---
+
+# Annotations
+
+```ebnf
+  Annotation       ::=  ‘@’ SimpleType {ArgumentExprs}
+  ConstrAnnotation ::=  ‘@’ SimpleType ArgumentExprs
+```
+
+## Definition
+
+Annotations associate meta-information with definitions.
+A simple annotation has the form `@´c´` or `@´c(a_1 , \ldots , a_n)´`.
+Here, ´c´ is a constructor of a class ´C´, which must conform
+to the class `scala.Annotation`.
+
+Annotations may apply to definitions or declarations, types, or
+expressions.  An annotation of a definition or declaration appears in
+front of that definition.  An annotation of a type appears after
+that type. An annotation of an expression ´e´ appears after the
+expression ´e´, separated by a colon. More than one annotation clause
+may apply to an entity. The order in which these annotations are given
+does not matter.
+
+Examples:
+
+```scala
+@deprecated("Use D", "1.0") class C { ... } // Class annotation
+@transient @volatile var m: Int             // Variable annotation
+String @local                               // Type annotation
+(e: @unchecked) match { ... }               // Expression annotation
+```
+
+## Predefined Annotations
+
+### Java Platform Annotations
+
+The meaning of annotation clauses is implementation-dependent. On the
+Java platform, the following annotations have a standard meaning.
+
+  * `@transient` Marks a field to be non-persistent; this is
+    equivalent to the `transient`
+    modifier in Java.
+
+  * `@volatile` Marks a field which can change its value
+    outside the control of the program; this
+    is equivalent to the `volatile`
+    modifier in Java.
+
+  * `@SerialVersionUID(<longlit>)` Attaches a serial version identifier (a
+    `long` constant) to a class.
+    This is equivalent to the following field
+    definition in Java:
+
+    ```java
+    private final static SerialVersionUID = <longlit>
+    ```
+
+  * `@throws(<classlit>)` A Java compiler checks that a program contains handlers for checked exceptions
+    by analyzing which checked exceptions can result from the execution of a method or
+    constructor. For each checked exception which is a possible result, the
+    `throws`
+    clause for the method or constructor must mention the class of that exception
+    or one of the superclasses of the class of that exception.
+
+### Java Beans Annotations
+
+  * `@scala.beans.BeanProperty` When prefixed to a definition of some variable `X`, this
+    annotation causes getter and setter methods `getX`, `setX`
+    in the Java bean style to be added in the class containing the
+    variable. The first letter of the variable appears capitalized after
+    the `get` or `set`. When the annotation is added to the
+    definition of an immutable value definition `X`, only a getter is
+    generated. The construction of these methods is part of
+    code-generation; therefore, these methods become visible only once a
+    classfile for the containing class is generated.
+
+  * `@scala.beans.BooleanBeanProperty` This annotation is equivalent to `scala.reflect.BeanProperty`, but
+    the generated getter method is named `isX` instead of `getX`.
+
+### Deprecation Annotations
+
+  * `@deprecated(message: <stringlit>, since: <stringlit>)`<br/>
+    Marks a definition as deprecated. Accesses to the
+    defined entity will then cause a deprecated warning mentioning the
+    _message_ `<stringlit>` to be issued from the compiler.
+    The argument _since_ documents since when the definition should be considered deprecated.<br/>
+    Deprecated warnings are suppressed in code that belongs itself to a definition
+    that is labeled deprecated.
+
+  * `@deprecatedName(name: <stringlit>, since: <stringlit>)`<br/>
+    Marks a formal parameter name as deprecated. Invocations of this entity
+    using named parameter syntax referring to the deprecated parameter name cause a deprecation warning.
+
+### Scala Compiler Annotations
+
+  * `@unchecked` When applied to the selector of a `match` expression,
+    this attribute suppresses any warnings about non-exhaustive pattern
+    matches that would otherwise be emitted. For instance, no warnings
+    would be produced for the method definition below.
+
+    ```scala
+    def f(x: Option[Int]) = (x: @unchecked) match {
+      case Some(y) => y
+    }
+    ```
+
+    Without the `@unchecked` annotation, a Scala compiler could
+    infer that the pattern match is non-exhaustive, and could produce a
+    warning because `Option` is a `sealed` class.
+
+  * `@uncheckedStable` When applied a value declaration or definition, it allows the defined
+    value to appear in a path, even if its type is [volatile](03-types.html#volatile-types).
+    For instance, the following member definitions are legal:
+
+    ```scala
+    type A { type T }
+    type B
+    @uncheckedStable val x: A with B // volatile type
+    val y: x.T                       // OK since `x' is still a path
+    ```
+
+    Without the `@uncheckedStable` annotation, the designator `x`
+    would not be a path since its type `A with B` is volatile. Hence,
+    the reference `x.T` would be malformed.
+
+    When applied to value declarations or definitions that have non-volatile
+    types, the annotation has no effect.
+
+  * `@specialized` When applied to the definition of a type parameter, this annotation causes
+    the compiler
+    to generate specialized definitions for primitive types. An optional list of
+    primitive
+    types may be given, in which case specialization takes into account only
+    those types.
+    For instance, the following code would generate specialized traits for
+    `Unit`, `Int` and `Double`
+
+    ```scala
+    trait Function0[@specialized(Unit, Int, Double) T] {
+      def apply: T
+    }
+    ```
+
+    Whenever the static type of an expression matches a specialized variant of
+    a definition, the compiler will instead use the specialized version.
+    See the [specialization sid](https://docs.scala-lang.org/sips/scala-specialization.html) for more details of the implementation.
+    
+
+## User-defined Annotations
+
+Other annotations may be interpreted by platform- or application-dependent
+tools. The class `scala.annotation.Annotation` is the base class for
+user-defined annotations. It has two sub-traits:
+- `scala.annotation.StaticAnnotation`: Instances of a subclass of this trait
+  will be stored in the generated class files, and therefore accessible to
+  runtime reflection and later compilation runs.
+- `scala.annotation.ConstantAnnotation`: Instances of a subclass of this trait
+  may only have arguments which are
+  [constant expressions](06-expressions.html#constant-expressions), and are
+  also stored in the generated class files.
+- If an annotation class inherits from neither `scala.ConstantAnnotation` nor
+  `scala.StaticAnnotation`, its instances are visible only locally during the
+  compilation run that analyzes them.
+
+## Host-platform Annotations
+
+The host platform may define its own annotation format. These annotations do not
+extend any of the classes in the `scala.annotation` package, but can generally
+be used in the same way as Scala annotations. The host platform may impose
+additional restrictions on the expressions which are valid as annotation
+arguments.
diff --git a/docs/_spec/12-the-scala-standard-library.md b/docs/_spec/12-the-scala-standard-library.md
new file mode 100644
index 000000000000..80d66c0c4166
--- /dev/null
+++ b/docs/_spec/12-the-scala-standard-library.md
@@ -0,0 +1,816 @@
+---
+title: Standard Library
+layout: default
+chapter: 12
+---
+
+# The Scala Standard Library
+
+The Scala standard library consists of the package `scala` with a
+number of classes and modules. Some of these classes are described in
+the following.
+
+![Class hierarchy of Scala](public/images/classhierarchy.png)
+
+## Root Classes
+
+The root of this hierarchy is formed by class `Any`.
+Every class in a Scala execution environment inherits directly or
+indirectly from this class.  Class `Any` has two direct
+subclasses: `AnyRef` and `AnyVal`.
+
+The subclass `AnyRef` represents all values which are represented
+as objects in the underlying host system. Classes written in other languages
+inherit from `scala.AnyRef`.
+
+The predefined subclasses of class `AnyVal` describe
+values which are not implemented as objects in the underlying host
+system.
+
+User-defined Scala classes which do not explicitly inherit from
+`AnyVal` inherit directly or indirectly from `AnyRef`. They cannot
+inherit from both `AnyRef` and `AnyVal`.
+
+Classes `AnyRef` and `AnyVal` are required to provide only
+the members declared in class `Any`, but implementations may add
+host-specific methods to these classes (for instance, an
+implementation may identify class `AnyRef` with its own root
+class for objects).
+
+The signatures of these root classes are described by the following
+definitions.
+
+```scala
+package scala
+/** The universal root class */
+abstract class Any {
+
+  /** Defined equality; abstract here */
+  def equals(that: Any): Boolean
+
+  /** Semantic equality between values */
+  final def == (that: Any): Boolean  =
+    if (null eq this) null eq that else this equals that
+
+  /** Semantic inequality between values */
+  final def != (that: Any): Boolean  =  !(this == that)
+
+  /** Hash code; abstract here */
+  def hashCode: Int = ´\ldots´
+
+  /** Textual representation; abstract here */
+  def toString: String = ´\ldots´
+
+  /** Type test; needs to be inlined to work as given */
+  def isInstanceOf[a]: Boolean
+
+  /** Type cast; needs to be inlined to work as given */ */
+  def asInstanceOf[A]: A = this match {
+    case x: A => x
+    case _ => if (this eq null) this
+              else throw new ClassCastException()
+  }
+}
+
+/** The root class of all value types */
+final class AnyVal extends Any
+
+/** The root class of all reference types */
+class AnyRef extends Any {
+  def equals(that: Any): Boolean      = this eq that
+  final def eq(that: AnyRef): Boolean = ´\ldots´ // reference equality
+  final def ne(that: AnyRef): Boolean = !(this eq that)
+
+  def hashCode: Int = ´\ldots´     // hashCode computed from allocation address
+  def toString: String  = ´\ldots´ // toString computed from hashCode and class name
+
+  def synchronized[T](body: => T): T // execute `body` in while locking `this`.
+}
+```
+
+The type test `´x´.isInstanceOf[´T´]` is equivalent to a typed
+pattern match
+
+```scala
+´x´ match {
+  case _: ´T'´ => true
+  case _ => false
+}
+```
+
+where the type ´T'´ is the same as ´T´ except if ´T´ is
+of the form ´D´ or ´D[\mathit{tps}]´ where ´D´ is a type member of some outer class ´C´.
+In this case ´T'´ is `´C´#´D´` (or `´C´#´D[tps]´`, respectively), whereas ´T´ itself would expand to `´C´.this.´D[tps]´`.
+In other words, an `isInstanceOf` test does not check that types have the same enclosing instance.
+
+The test `´x´.asInstanceOf[´T´]` is treated specially if ´T´ is a
+[numeric value type](#value-classes). In this case the cast will
+be translated to an application of a [conversion method](#numeric-value-types)
+`x.to´T´`. For non-numeric values ´x´ the operation will raise a
+`ClassCastException`.
+
+## Value Classes
+
+Value classes are classes whose instances are not represented as
+objects by the underlying host system.  All value classes inherit from
+class `AnyVal`. Scala implementations need to provide the
+value classes `Unit`, `Boolean`, `Double`, `Float`,
+`Long`, `Int`, `Char`, `Short`, and `Byte`
+(but are free to provide others as well).
+The signatures of these classes are defined in the following.
+
+### Numeric Value Types
+
+Classes `Double`, `Float`,
+`Long`, `Int`, `Char`, `Short`, and `Byte`
+are together called _numeric value types_. Classes `Byte`,
+`Short`, or `Char` are called _subrange types_.
+Subrange types, as well as `Int` and `Long` are called _integer types_, whereas `Float` and `Double` are called _floating point types_.
+
+Numeric value types are ranked in the following partial order:
+
+```scala
+Byte - Short
+             \
+               Int - Long - Float - Double
+             /
+        Char
+```
+
+`Byte` and `Short` are the lowest-ranked types in this order,
+whereas `Double` is the highest-ranked.  Ranking does _not_
+imply a [conformance relationship](03-types.html#conformance); for
+instance `Int` is not a subtype of `Long`.  However, object
+[`Predef`](#the-predef-object) defines [views](07-implicits.html#views)
+from every numeric value type to all higher-ranked numeric value types.
+Therefore, lower-ranked types are implicitly converted to higher-ranked types
+when required by the [context](06-expressions.html#implicit-conversions).
+
+Given two numeric value types ´S´ and ´T´, the _operation type_ of
+´S´ and ´T´ is defined as follows: If both ´S´ and ´T´ are subrange
+types then the operation type of ´S´ and ´T´ is `Int`.  Otherwise
+the operation type of ´S´ and ´T´ is the larger of the two types wrt
+ranking. Given two numeric values ´v´ and ´w´ the operation type of
+´v´ and ´w´ is the operation type of their run-time types.
+
+Any numeric value type ´T´ supports the following methods.
+
+  * Comparison methods for equals (`==`), not-equals (`!=`),
+    less-than (`<`), greater-than (`>`), less-than-or-equals
+    (`<=`), greater-than-or-equals (`>=`), which each exist in 7
+    overloaded alternatives. Each alternative takes a parameter of some
+    numeric value type. Its result type is type `Boolean`. The
+    operation is evaluated by converting the receiver and its argument to
+    their operation type and performing the given comparison operation of
+    that type.
+  * Arithmetic methods addition (`+`), subtraction (`-`),
+    multiplication (`*`), division (`/`), and remainder
+    (`%`), which each exist in 7 overloaded alternatives. Each
+    alternative takes a parameter of some numeric value type ´U´.  Its
+    result type is the operation type of ´T´ and ´U´. The operation is
+    evaluated by converting the receiver and its argument to their
+    operation type and performing the given arithmetic operation of that
+    type.
+  * Parameterless arithmetic methods identity (`+`) and negation
+    (`-`), with result type ´T´.  The first of these returns the
+    receiver unchanged, whereas the second returns its negation.
+  * Conversion methods `toByte`, `toShort`, `toChar`,
+    `toInt`, `toLong`, `toFloat`, `toDouble` which
+    convert the receiver object to the target type, using the rules of
+    Java's numeric type cast operation. The conversion might truncate the
+    numeric value (as when going from `Long` to `Int` or from
+    `Int` to `Byte`) or it might lose precision (as when going
+    from `Double` to `Float` or when converting between
+    `Long` and `Float`).
+
+Integer numeric value types support in addition the following operations:
+
+  * Bit manipulation methods bitwise-and (`&`), bitwise-or
+    {`|`}, and bitwise-exclusive-or (`^`), which each exist in 5
+    overloaded alternatives. Each alternative takes a parameter of some
+    integer numeric value type. Its result type is the operation type of
+    ´T´ and ´U´. The operation is evaluated by converting the receiver and
+    its argument to their operation type and performing the given bitwise
+    operation of that type.
+
+  * A parameterless bit-negation method (`~`). Its result type is
+    the receiver type ´T´ or `Int`, whichever is larger.
+    The operation is evaluated by converting the receiver to the result
+    type and negating every bit in its value.
+  * Bit-shift methods left-shift (`<<`), arithmetic right-shift
+    (`>>`), and unsigned right-shift (`>>>`). Each of these
+    methods has two overloaded alternatives, which take a parameter ´n´
+    of type `Int`, respectively `Long`. The result type of the
+    operation is the receiver type ´T´, or `Int`, whichever is larger.
+    The operation is evaluated by converting the receiver to the result
+    type and performing the specified shift by ´n´ bits.
+
+Numeric value types also implement operations `equals`,
+`hashCode`, and `toString` from class `Any`.
+
+The `equals` method tests whether the argument is a numeric value
+type. If this is true, it will perform the `==` operation which
+is appropriate for that type. That is, the `equals` method of a
+numeric value type can be thought of being defined as follows:
+
+```scala
+def equals(other: Any): Boolean = other match {
+  case that: Byte   => this == that
+  case that: Short  => this == that
+  case that: Char   => this == that
+  case that: Int    => this == that
+  case that: Long   => this == that
+  case that: Float  => this == that
+  case that: Double => this == that
+  case _ => false
+}
+```
+
+The `hashCode` method returns an integer hashcode that maps equal
+numeric values to equal results. It is guaranteed to be the identity
+for type `Int` and for all subrange types.
+
+The `toString` method displays its receiver as an integer or
+floating point number.
+
+###### Example
+
+This is the signature of the numeric value type `Int`:
+
+```scala
+package scala
+abstract sealed class Int extends AnyVal {
+  def == (that: Double): Boolean  // double equality
+  def == (that: Float): Boolean   // float equality
+  def == (that: Long): Boolean    // long equality
+  def == (that: Int): Boolean     // int equality
+  def == (that: Short): Boolean   // int equality
+  def == (that: Byte): Boolean    // int equality
+  def == (that: Char): Boolean    // int equality
+  /* analogous for !=, <, >, <=, >= */
+
+  def + (that: Double): Double    // double addition
+  def + (that: Float): Double     // float addition
+  def + (that: Long): Long        // long addition
+  def + (that: Int): Int          // int addition
+  def + (that: Short): Int        // int addition
+  def + (that: Byte): Int         // int addition
+  def + (that: Char): Int         // int addition
+  /* analogous for -, *, /, % */
+
+  def & (that: Long): Long        // long bitwise and
+  def & (that: Int): Int          // int bitwise and
+  def & (that: Short): Int        // int bitwise and
+  def & (that: Byte): Int         // int bitwise and
+  def & (that: Char): Int         // int bitwise and
+  /* analogous for |, ^ */
+
+  def << (cnt: Int): Int          // int left shift
+  def << (cnt: Long): Int         // long left shift
+  /* analogous for >>, >>> */
+
+  def unary_+ : Int               // int identity
+  def unary_- : Int               // int negation
+  def unary_~ : Int               // int bitwise negation
+
+  def toByte: Byte                // convert to Byte
+  def toShort: Short              // convert to Short
+  def toChar: Char                // convert to Char
+  def toInt: Int                  // convert to Int
+  def toLong: Long                // convert to Long
+  def toFloat: Float              // convert to Float
+  def toDouble: Double            // convert to Double
+}
+```
+
+### Class `Boolean`
+
+Class `Boolean` has only two values: `true` and
+`false`. It implements operations as given in the following
+class definition.
+
+```scala
+package scala
+abstract sealed class Boolean extends AnyVal {
+  def && (p: => Boolean): Boolean = // boolean and
+    if (this) p else false
+  def || (p: => Boolean): Boolean = // boolean or
+    if (this) true else p
+  def &  (x: Boolean): Boolean =    // boolean strict and
+    if (this) x else false
+  def |  (x: Boolean): Boolean =    // boolean strict or
+    if (this) true else x
+  def == (x: Boolean): Boolean =    // boolean equality
+    if (this) x else x.unary_!
+  def != (x: Boolean): Boolean =    // boolean inequality
+    if (this) x.unary_! else x
+  def unary_!: Boolean =            // boolean negation
+    if (this) false else true
+}
+```
+
+The class also implements operations `equals`, `hashCode`,
+and `toString` from class `Any`.
+
+The `equals` method returns `true` if the argument is the
+same boolean value as the receiver, `false` otherwise.  The
+`hashCode` method returns a fixed, implementation-specific hash-code when invoked on `true`,
+and a different, fixed, implementation-specific hash-code when invoked on `false`. The `toString` method
+returns the receiver converted to a string, i.e. either `"true"` or `"false"`.
+
+### Class `Unit`
+
+Class `Unit` has only one value: `()`. It implements only
+the three methods `equals`, `hashCode`, and `toString`
+from class `Any`.
+
+The `equals` method returns `true` if the argument is the
+unit value `()`, `false` otherwise.  The
+`hashCode` method returns a fixed, implementation-specific hash-code,
+The `toString` method returns `"()"`.
+
+## Standard Reference Classes
+
+This section presents some standard Scala reference classes which are
+treated in a special way by the Scala compiler – either Scala provides
+syntactic sugar for them, or the Scala compiler generates special code
+for their operations. Other classes in the standard Scala library are
+documented in the Scala library documentation by HTML pages.
+
+### Class `String`
+
+Scala's `String` class is usually derived from the standard String
+class of the underlying host system (and may be identified with
+it). For Scala clients the class is taken to support in each case a
+method
+
+```scala
+def + (that: Any): String
+```
+
+which concatenates its left operand with the textual representation of its
+right operand.
+
+### The `Tuple` classes
+
+Scala defines tuple classes `Tuple´n´` for ´n = 2 , \ldots , 22´.
+These are defined as follows.
+
+```scala
+package scala
+case class Tuple´n´[+T_1, ..., +T_n](_1: T_1, ..., _´n´: T_´n´) {
+  def toString = "(" ++ _1 ++ "," ++ ´\ldots´ ++ "," ++ _´n´ ++ ")"
+}
+```
+
+### The `Function` Classes
+
+Scala defines function classes `Function´n´` for ´n = 1 , \ldots , 22´.
+These are defined as follows.
+
+```scala
+package scala
+trait Function´n´[-T_1, ..., -T_´n´, +R] {
+  def apply(x_1: T_1, ..., x_´n´: T_´n´): R
+  def toString = "<function>"
+}
+```
+
+The `PartialFunction` subclass of `Function1` represents functions that (indirectly) specify their domain.
+Use the `isDefined` method to query whether the partial function is defined for a given input (i.e., whether the input is part of the function's domain).
+
+```scala
+class PartialFunction[-A, +B] extends Function1[A, B] {
+  def isDefinedAt(x: A): Boolean
+}
+```
+
+The implicitly imported [`Predef`](#the-predef-object) object defines the name
+`Function` as an alias of `Function1`.
+
+### Class `Array`
+
+All operations on arrays desugar to the corresponding operations of the
+underlying platform. Therefore, the following class definition is given for
+informational purposes only:
+
+```scala
+final class Array[T](_length: Int)
+extends java.io.Serializable with java.lang.Cloneable {
+  def length: Int = ´\ldots´
+  def apply(i: Int): T = ´\ldots´
+  def update(i: Int, x: T): Unit = ´\ldots´
+  override def clone(): Array[T] = ´\ldots´
+}
+```
+
+If ´T´ is not a type parameter or abstract type, the type `Array[T]`
+is represented as the array type `|T|[]` in the
+underlying host system, where `|T|` is the erasure of `T`.
+If ´T´ is a type parameter or abstract type, a different representation might be
+used (it is `Object` on the Java platform).
+
+#### Operations
+
+`length` returns the length of the array, `apply` means subscripting,
+and `update` means element update.
+
+Because of the syntactic sugar for `apply` and `update` operations,
+we have the following correspondences between Scala and Java code for
+operations on an array `xs`:
+
+|_Scala_           |_Java_      |
+|------------------|------------|
+|`xs.length`       |`xs.length` |
+|`xs(i)`           |`xs[i]`     |
+|`xs(i) = e`       |`xs[i] = e` |
+
+Two implicit conversions exist in `Predef` that are frequently applied to arrays:
+a conversion to `scala.collection.mutable.ArrayOps` and a conversion to
+`scala.collection.mutable.ArraySeq` (a subtype of `scala.collection.Seq`).
+
+Both types make many of the standard operations found in the Scala
+collections API available. The conversion to `ArrayOps` is temporary, as all operations
+defined on `ArrayOps` return a value of type `Array`, while the conversion to `ArraySeq`
+is permanent as all operations return a value of type `ArraySeq`.
+The conversion to `ArrayOps` takes priority over the conversion to `ArraySeq`.
+
+Because of the tension between parametrized types in Scala and the ad-hoc
+implementation of arrays in the host-languages, some subtle points
+need to be taken into account when dealing with arrays. These are
+explained in the following.
+
+#### Variance
+
+Unlike arrays in Java, arrays in Scala are _not_
+co-variant; That is, ´S <: T´ does not imply
+`Array[´S´] ´<:´ Array[´T´]` in Scala.
+However, it is possible to cast an array
+of ´S´ to an array of ´T´ if such a cast is permitted in the host
+environment.
+
+For instance `Array[String]` does not conform to
+`Array[Object]`, even though `String` conforms to `Object`.
+However, it is possible to cast an expression of type
+`Array[String]` to `Array[Object]`, and this
+cast will succeed without raising a `ClassCastException`. Example:
+
+```scala
+val xs = new Array[String](2)
+// val ys: Array[Object] = xs   // **** error: incompatible types
+val ys: Array[Object] = xs.asInstanceOf[Array[Object]] // OK
+```
+
+The instantiation of an array with a polymorphic element type ´T´ requires
+information about type ´T´ at runtime.
+This information is synthesized by adding a [context bound](07-implicits.html#context-bounds-and-view-bounds)
+of `scala.reflect.ClassTag` to type ´T´.
+An example is the
+following implementation of method `mkArray`, which creates
+an array of an arbitrary type ´T´, given a sequence of ´T´`s which
+defines its elements:
+
+```scala
+import reflect.ClassTag
+def mkArray[T : ClassTag](elems: Seq[T]): Array[T] = {
+  val result = new Array[T](elems.length)
+  var i = 0
+  for (elem <- elems) {
+    result(i) = elem
+    i += 1
+  }
+  result
+}
+```
+
+If type ´T´ is a type for which the host platform offers a specialized array
+representation, this representation is used.
+
+###### Example
+On the Java Virtual Machine, an invocation of `mkArray(List(1,2,3))`
+will return a primitive array of `int`s, written as `int[]` in Java.
+
+#### Companion object
+
+`Array`'s companion object provides various factory methods for the
+instantiation of single- and multi-dimensional arrays, an extractor method
+[`unapplySeq`](08-pattern-matching.html#extractor-patterns) which enables pattern matching
+over arrays and additional utility methods:
+
+```scala
+package scala
+object Array {
+  /** copies array elements from `src` to `dest`. */
+  def copy(src: AnyRef, srcPos: Int,
+           dest: AnyRef, destPos: Int, length: Int): Unit = ´\ldots´
+
+  /** Returns an array of length 0 */
+  def empty[T: ClassTag]: Array[T] =
+
+  /** Create an array with given elements. */
+  def apply[T: ClassTag](xs: T*): Array[T] = ´\ldots´
+
+  /** Creates array with given dimensions */
+  def ofDim[T: ClassTag](n1: Int): Array[T] = ´\ldots´
+  /** Creates a 2-dimensional array */
+  def ofDim[T: ClassTag](n1: Int, n2: Int): Array[Array[T]] = ´\ldots´
+  ´\ldots´
+
+  /** Concatenate all argument arrays into a single array. */
+  def concat[T: ClassTag](xss: Array[T]*): Array[T] = ´\ldots´
+
+  /** Returns an array that contains the results of some element computation a number
+    * of times. */
+  def fill[T: ClassTag](n: Int)(elem: => T): Array[T] = ´\ldots´
+  /** Returns a two-dimensional array that contains the results of some element
+    * computation a number of times. */
+  def fill[T: ClassTag](n1: Int, n2: Int)(elem: => T): Array[Array[T]] = ´\ldots´
+  ´\ldots´
+
+  /** Returns an array containing values of a given function over a range of integer
+    * values starting from 0. */
+  def tabulate[T: ClassTag](n: Int)(f: Int => T): Array[T] = ´\ldots´
+  /** Returns a two-dimensional array containing values of a given function
+    * over ranges of integer values starting from `0`. */
+  def tabulate[T: ClassTag](n1: Int, n2: Int)(f: (Int, Int) => T): Array[Array[T]] = ´\ldots´
+  ´\ldots´
+
+  /** Returns an array containing a sequence of increasing integers in a range. */
+  def range(start: Int, end: Int): Array[Int] = ´\ldots´
+  /** Returns an array containing equally spaced values in some integer interval. */
+  def range(start: Int, end: Int, step: Int): Array[Int] = ´\ldots´
+
+  /** Returns an array containing repeated applications of a function to a start value. */
+  def iterate[T: ClassTag](start: T, len: Int)(f: T => T): Array[T] = ´\ldots´
+
+  /** Enables pattern matching over arrays */
+  def unapplySeq[A](x: Array[A]): Option[IndexedSeq[A]] = Some(x)
+}
+```
+
+## Class Node
+
+```scala
+package scala.xml
+
+trait Node {
+
+  /** the label of this node */
+  def label: String
+
+  /** attribute axis */
+  def attribute: Map[String, String]
+
+  /** child axis (all children of this node) */
+  def child: Seq[Node]
+
+  /** descendant axis (all descendants of this node) */
+  def descendant: Seq[Node] = child.toList.flatMap {
+    x => x::x.descendant.asInstanceOf[List[Node]]
+  }
+
+  /** descendant axis (all descendants of this node) */
+  def descendant_or_self: Seq[Node] = this::child.toList.flatMap {
+    x => x::x.descendant.asInstanceOf[List[Node]]
+  }
+
+  override def equals(x: Any): Boolean = x match {
+    case that:Node =>
+      that.label == this.label &&
+        that.attribute.sameElements(this.attribute) &&
+          that.child.sameElements(this.child)
+    case _ => false
+  }
+
+ /** XPath style projection function. Returns all children of this node
+  *  that are labeled with 'that'. The document order is preserved.
+  */
+    def \(that: Symbol): NodeSeq = {
+      new NodeSeq({
+        that.name match {
+          case "_" => child.toList
+          case _ =>
+            var res:List[Node] = Nil
+            for (x <- child.elements if x.label == that.name) {
+              res = x::res
+            }
+            res.reverse
+        }
+      })
+    }
+
+ /** XPath style projection function. Returns all nodes labeled with the
+  *  name 'that' from the 'descendant_or_self' axis. Document order is preserved.
+  */
+  def \\(that: Symbol): NodeSeq = {
+    new NodeSeq(
+      that.name match {
+        case "_" => this.descendant_or_self
+        case _ => this.descendant_or_self.asInstanceOf[List[Node]].
+        filter(x => x.label == that.name)
+      })
+  }
+
+  /** hashcode for this XML node */
+  override def hashCode =
+    Utility.hashCode(label, attribute.toList.hashCode, child)
+
+  /** string representation of this node */
+  override def toString = Utility.toXML(this)
+
+}
+```
+
+## The `Predef` Object
+
+The `Predef` object defines standard functions and type aliases
+for Scala programs. It is implicitly imported, as described in
+[the chapter on name binding](02-identifiers-names-and-scopes.html),
+so that all its defined members are available without qualification.
+Its definition for the JVM environment conforms to the following signature:
+
+```scala
+package scala
+object Predef {
+
+  // classOf ---------------------------------------------------------
+
+  /** Returns the runtime representation of a class type. */
+  def classOf[T]: Class[T] = null
+   // this is a dummy, classOf is handled by compiler.
+
+  // valueOf -----------------------------------------------------------
+
+  /** Retrieve the single value of a type with a unique inhabitant. */
+  @inline def valueOf[T](implicit vt: ValueOf[T]): T {} = vt.value
+   // instances of the ValueOf type class are provided by the compiler.
+
+  // Standard type aliases ---------------------------------------------
+
+  type String    = java.lang.String
+  type Class[T]  = java.lang.Class[T]
+
+  // Miscellaneous -----------------------------------------------------
+
+  type Function[-A, +B] = Function1[A, B]
+
+  type Map[A, +B] = collection.immutable.Map[A, B]
+  type Set[A] = collection.immutable.Set[A]
+
+  val Map = collection.immutable.Map
+  val Set = collection.immutable.Set
+
+  // Manifest types, companions, and incantations for summoning ---------
+
+  type ClassManifest[T] = scala.reflect.ClassManifest[T]
+  type Manifest[T]      = scala.reflect.Manifest[T]
+  type OptManifest[T]   = scala.reflect.OptManifest[T]
+  val ClassManifest     = scala.reflect.ClassManifest
+  val Manifest          = scala.reflect.Manifest
+  val NoManifest        = scala.reflect.NoManifest
+
+  def manifest[T](implicit m: Manifest[T])           = m
+  def classManifest[T](implicit m: ClassManifest[T]) = m
+  def optManifest[T](implicit m: OptManifest[T])     = m
+
+  // Minor variations on identity functions -----------------------------
+  def identity[A](x: A): A         = x
+  def implicitly[T](implicit e: T) = e    // for summoning implicit values from the nether world
+  @inline def locally[T](x: T): T  = x    // to communicate intent and avoid unmoored statements
+
+  // Asserts, Preconditions, Postconditions -----------------------------
+
+  def assert(assertion: Boolean) {
+    if (!assertion)
+      throw new java.lang.AssertionError("assertion failed")
+  }
+
+  def assert(assertion: Boolean, message: => Any) {
+    if (!assertion)
+      throw new java.lang.AssertionError("assertion failed: " + message)
+  }
+
+  def assume(assumption: Boolean) {
+    if (!assumption)
+      throw new IllegalArgumentException("assumption failed")
+  }
+
+  def assume(assumption: Boolean, message: => Any) {
+    if (!assumption)
+      throw new IllegalArgumentException(message.toString)
+  }
+
+  def require(requirement: Boolean) {
+    if (!requirement)
+      throw new IllegalArgumentException("requirement failed")
+  }
+
+  def require(requirement: Boolean, message: => Any) {
+    if (!requirement)
+      throw new IllegalArgumentException("requirement failed: "+ message)
+  }
+```
+
+```scala
+  // Printing and reading -----------------------------------------------
+
+  def print(x: Any) = Console.print(x)
+  def println() = Console.println()
+  def println(x: Any) = Console.println(x)
+  def printf(text: String, xs: Any*) = Console.printf(text.format(xs: _*))
+
+  // Implicit conversions ------------------------------------------------
+
+  ...
+}
+```
+
+### Predefined Implicit Definitions
+
+The `Predef` object also contains a number of implicit definitions, which are available by default (because `Predef` is implicitly imported).
+Implicit definitions come in two priorities. High-priority implicits are defined in the `Predef` class itself whereas low priority implicits are defined in a class inherited by `Predef`. The rules of
+static [overloading resolution](06-expressions.html#overloading-resolution)
+stipulate that, all other things being equal, implicit resolution
+prefers high-priority implicits over low-priority ones.
+
+The available low-priority implicits include definitions falling into the following categories.
+
+1.  For every primitive type, a wrapper that takes values of that type
+    to instances of a `runtime.Rich*` class. For instance, values of type `Int`
+    can be implicitly converted to instances of class `runtime.RichInt`.
+
+1.  For every array type with elements of primitive type, a wrapper that
+    takes the arrays of that type to instances of a `ArraySeq` class. For instance, values of type `Array[Float]` can be implicitly converted to instances of class `ArraySeq[Float]`.
+    There are also generic array wrappers that take elements
+    of type `Array[T]` for arbitrary `T` to `ArraySeq`s.
+
+1.  An implicit conversion from `String` to `WrappedString`.
+
+The available high-priority implicits include definitions falling into the following categories.
+
+  * An implicit wrapper that adds `ensuring` methods
+    with the following overloaded variants to type `Any`.
+
+    ```scala
+    def ensuring(cond: Boolean): A = { assert(cond); x }
+    def ensuring(cond: Boolean, msg: Any): A = { assert(cond, msg); x }
+    def ensuring(cond: A => Boolean): A = { assert(cond(x)); x }
+    def ensuring(cond: A => Boolean, msg: Any): A = { assert(cond(x), msg); x }
+    ```
+
+  * An implicit wrapper that adds a `->` method with the following implementation
+    to type `Any`.
+
+    ```scala
+    def -> [B](y: B): (A, B) = (x, y)
+    ```
+
+  * For every array type with elements of primitive type, a wrapper that
+    takes the arrays of that type to instances of a `runtime.ArrayOps`
+    class. For instance, values of type `Array[Float]` can be implicitly
+    converted to instances of class `runtime.ArrayOps[Float]`.  There are
+    also generic array wrappers that take elements of type `Array[T]` for
+    arbitrary `T` to `ArrayOps`s.
+
+  * An implicit wrapper that adds `+` and `formatted` method with the following
+    implementations to type `Any`.
+
+    ```scala
+    def +(other: String) = String.valueOf(self) + other
+    def formatted(fmtstr: String): String = fmtstr format self
+    ```
+
+  * Numeric primitive conversions that implement the transitive closure of the
+    following mappings:
+
+    ```
+    Byte  -> Short
+    Short -> Int
+    Char  -> Int
+    Int   -> Long
+    Long  -> Float
+    Float -> Double
+    ```
+
+  * Boxing and unboxing conversions between primitive types and their boxed
+    versions:
+
+    ```
+    Byte    <-> java.lang.Byte
+    Short   <-> java.lang.Short
+    Char    <-> java.lang.Character
+    Int     <-> java.lang.Integer
+    Long    <-> java.lang.Long
+    Float   <-> java.lang.Float
+    Double  <-> java.lang.Double
+    Boolean <-> java.lang.Boolean
+    ```
+
+  * An implicit definition that generates instances of type `T <:< T`, for
+    any type `T`. Here, `<:<` is a class defined as follows.
+
+    ```scala
+    sealed abstract class <:<[-From, +To] extends (From => To)
+    ```
+
+    Implicit parameters of `<:<` types are typically used to implement type constraints.
diff --git a/docs/_spec/13-syntax-summary.md b/docs/_spec/13-syntax-summary.md
new file mode 100644
index 000000000000..6ece538e2ff1
--- /dev/null
+++ b/docs/_spec/13-syntax-summary.md
@@ -0,0 +1,330 @@
+---
+title: Syntax Summary
+layout: default
+chapter: 13
+---
+
+# Syntax Summary
+
+The following descriptions of Scala tokens uses literal characters `‘c’` when referring to the ASCII fragment `\u0000` – `\u007F`.
+
+## Lexical Syntax
+
+The lexical syntax of Scala is given by the following grammar in EBNF form:
+
+```ebnf
+whiteSpace       ::=  ‘\u0020’ | ‘\u0009’ | ‘\u000D’ | ‘\u000A’
+upper            ::=  ‘A’ | … | ‘Z’ | ‘$’ and any character in Unicode categories Lu, Lt or Nl,
+                      and any character in Unicode categories Lo and Lm that doesn't have
+                      contributory property Other_Lowercase
+lower            ::=  ‘a’ | … | ‘z’ | ‘_’ and any character in Unicode category Ll,
+                      and any character in Unicode categories Lo or Lm that has contributory
+                      property Other_Lowercase
+letter           ::=  upper | lower
+digit            ::=  ‘0’ | … | ‘9’
+paren            ::=  ‘(’ | ‘)’ | ‘[’ | ‘]’ | ‘{’ | ‘}’
+delim            ::=  ‘`’ | ‘'’ | ‘"’ | ‘.’ | ‘;’ | ‘,’
+opchar           ::=  ‘!’ | ‘#’ | ‘%’ | ‘&’ | ‘*’ | ‘+’ | ‘-’ | ‘/’ | ‘:’ |
+                      ‘<’ | ‘=’ | ‘>’ | ‘?’ | ‘@’ | ‘\’ | ‘^’ | ‘|’ | ‘~’
+                      and any character in Unicode categories Sm or So
+printableChar    ::=  all characters in [\u0020, \u007E] inclusive
+UnicodeEscape    ::=  ‘\’ ‘u’ {‘u’} hexDigit hexDigit hexDigit hexDigit
+hexDigit         ::=  ‘0’ | … | ‘9’ | ‘A’ | … | ‘F’ | ‘a’ | … | ‘f’
+charEscapeSeq    ::=  ‘\’ (‘b’ | ‘t’ | ‘n’ | ‘f’ | ‘r’ | ‘"’ | ‘'’ | ‘\’)
+escapeSeq        ::=  UnicodeEscape | charEscapeSeq
+op               ::=  opchar {opchar}
+varid            ::=  lower idrest
+boundvarid       ::=  varid
+                   |  ‘`’ varid ‘`’
+plainid          ::=  upper idrest
+                   |  varid
+                   |  op
+id               ::=  plainid
+                   |  ‘`’ { charNoBackQuoteOrNewline | escapeSeq } ‘`’
+idrest           ::=  {letter | digit} [‘_’ op]
+
+integerLiteral   ::=  (decimalNumeral | hexNumeral) [‘L’ | ‘l’]
+decimalNumeral   ::=  digit {digit}
+hexNumeral       ::=  ‘0’ (‘x’ | ‘X’) hexDigit {hexDigit}
+
+floatingPointLiteral
+                 ::=  digit {digit} ‘.’ digit {digit} [exponentPart] [floatType]
+                   |  ‘.’ digit {digit} [exponentPart] [floatType]
+                   |  digit {digit} exponentPart [floatType]
+                   |  digit {digit} [exponentPart] floatType
+exponentPart     ::=  (‘E’ | ‘e’) [‘+’ | ‘-’] digit {digit}
+floatType        ::=  ‘F’ | ‘f’ | ‘D’ | ‘d’
+
+booleanLiteral   ::=  ‘true’ | ‘false’
+
+characterLiteral ::=  ‘'’ (charNoQuoteOrNewline | escapeSeq) ‘'’
+
+stringLiteral    ::=  ‘"’ {stringElement} ‘"’
+                   |  ‘"""’ multiLineChars ‘"""’
+stringElement    ::=  charNoDoubleQuoteOrNewline
+                   |  escapeSeq
+multiLineChars   ::=  {[‘"’] [‘"’] charNoDoubleQuote} {‘"’}
+
+interpolatedString
+                 ::=  alphaid ‘"’ {[‘\’] interpolatedStringPart | ‘\\’ | ‘\"’} ‘"’
+                   |  alphaid ‘"""’ {[‘"’] [‘"’] char \ (‘"’ | ‘\$’) | escape} {‘"’} ‘"""’
+interpolatedStringPart
+                 ::= printableChar \ (‘"’ | ‘$’ | ‘\’) | escape
+escape           ::=  ‘\$\$’
+                   |  ‘\$"’
+                   |  ‘\$’ alphaid
+                   |  ‘\$’ BlockExpr
+alphaid          ::=  upper idrest
+                   |  varid
+
+symbolLiteral    ::=  ‘'’ plainid
+
+comment          ::=  ‘/*’ “any sequence of characters; nested comments are allowed” ‘*/’
+                   |  ‘//’ “any sequence of characters up to end of line”
+
+nl               ::=  ´\mathit{“new line character”}´
+semi             ::=  ‘;’ |  nl {nl}
+```
+
+## Context-free Syntax
+
+The context-free syntax of Scala is given by the following EBNF
+grammar:
+
+```ebnf
+  Literal           ::=  [‘-’] integerLiteral
+                      |  [‘-’] floatingPointLiteral
+                      |  booleanLiteral
+                      |  characterLiteral
+                      |  stringLiteral
+                      |  interpolatedString
+                      |  symbolLiteral
+                      |  ‘null’
+
+  QualId            ::=  id {‘.’ id}
+  ids               ::=  id {‘,’ id}
+
+  Path              ::=  StableId
+                      |  [id ‘.’] ‘this’
+  StableId          ::=  id
+                      |  Path ‘.’ id
+                      |  [id ‘.’] ‘super’ [ClassQualifier] ‘.’ id
+  ClassQualifier    ::=  ‘[’ id ‘]’
+
+  Type              ::=  FunctionArgTypes ‘=>’ Type
+                      |  InfixType [ExistentialClause]
+  FunctionArgTypes  ::= InfixType
+                      | ‘(’ [ ParamType {‘,’ ParamType } ] ‘)’
+  ExistentialClause ::=  ‘forSome’ ‘{’ ExistentialDcl {semi ExistentialDcl} ‘}’
+  ExistentialDcl    ::=  ‘type’ TypeDcl
+                      |  ‘val’ ValDcl
+  InfixType         ::=  CompoundType {id [nl] CompoundType}
+  CompoundType      ::=  AnnotType {‘with’ AnnotType} [Refinement]
+                      |  Refinement
+  AnnotType         ::=  SimpleType {Annotation}
+  SimpleType        ::=  SimpleType TypeArgs
+                      |  SimpleType ‘#’ id
+                      |  StableId
+                      |  Path ‘.’ ‘type’
+                      |  ‘(’ Types ‘)’
+  TypeArgs          ::=  ‘[’ Types ‘]’
+  Types             ::=  Type {‘,’ Type}
+  Refinement        ::=  [nl] ‘{’ RefineStat {semi RefineStat} ‘}’
+  RefineStat        ::=  Dcl
+                      |  ‘type’ TypeDef
+                      |
+  TypePat           ::=  Type
+
+  Ascription        ::=  ‘:’ InfixType
+                      |  ‘:’ Annotation {Annotation}
+                      |  ‘:’ ‘_’ ‘*’
+
+  Expr              ::=  (Bindings | [‘implicit’] id | ‘_’) ‘=>’ Expr
+                      |  Expr1
+  Expr1             ::=  ‘if’ ‘(’ Expr ‘)’ {nl} Expr [[semi] ‘else’ Expr]
+                      |  ‘while’ ‘(’ Expr ‘)’ {nl} Expr
+                      |  ‘try’ Expr [‘catch’ Expr] [‘finally’ Expr]
+                      |  ‘do’ Expr [semi] ‘while’ ‘(’ Expr ‘)’
+                      |  ‘for’ (‘(’ Enumerators ‘)’ | ‘{’ Enumerators ‘}’) {nl} [‘yield’] Expr
+                      |  ‘throw’ Expr
+                      |  ‘return’ [Expr]
+                      |  [SimpleExpr ‘.’] id ‘=’ Expr
+                      |  PrefixOperator SimpleExpr ‘=’ Expr
+                      |  SimpleExpr1 ArgumentExprs ‘=’ Expr
+                      |  PostfixExpr
+                      |  PostfixExpr Ascription
+                      |  PostfixExpr ‘match’ ‘{’ CaseClauses ‘}’
+  PostfixExpr       ::=  InfixExpr [id [nl]]
+  InfixExpr         ::=  PrefixExpr
+                      |  InfixExpr id [nl] InfixExpr
+  PrefixExpr        ::=  [PrefixOperator] SimpleExpr
+  PrefixOperator    ::=  ‘-’ | ‘+’ | ‘~’ | ‘!’
+  SimpleExpr        ::=  ‘new’ (ClassTemplate | TemplateBody)
+                      |  BlockExpr
+                      |  SimpleExpr1 [‘_’]
+  SimpleExpr1       ::=  Literal
+                      |  Path
+                      |  ‘_’
+                      |  ‘(’ [Exprs] ‘)’
+                      |  SimpleExpr ‘.’ id
+                      |  SimpleExpr TypeArgs
+                      |  SimpleExpr1 ArgumentExprs
+                      |  XmlExpr
+  Exprs             ::=  Expr {‘,’ Expr}
+  ArgumentExprs     ::=  ‘(’ [Exprs] ‘)’
+                      |  ‘(’ [Exprs ‘,’] PostfixExpr ‘:’ ‘_’ ‘*’ ‘)’
+                      |  [nl] BlockExpr
+  BlockExpr         ::=  ‘{’ CaseClauses ‘}’
+                      |  ‘{’ Block ‘}’
+  Block             ::=  BlockStat {semi BlockStat} [ResultExpr]
+  BlockStat         ::=  Import
+                      |  {Annotation} [‘implicit’] [‘lazy’] Def
+                      |  {Annotation} {LocalModifier} TmplDef
+                      |  Expr1
+                      |
+  ResultExpr        ::=  Expr1
+                      |  (Bindings | ([‘implicit’] id | ‘_’) ‘:’ CompoundType) ‘=>’ Block
+
+  Enumerators       ::=  Generator {semi Generator}
+  Generator         ::=  [‘case’] Pattern1 ‘<-’ Expr {[semi] Guard | semi Pattern1 ‘=’ Expr}
+
+  CaseClauses       ::=  CaseClause { CaseClause }
+  CaseClause        ::=  ‘case’ Pattern [Guard] ‘=>’ Block
+  Guard             ::=  ‘if’ PostfixExpr
+
+  Pattern           ::=  Pattern1 { ‘|’ Pattern1 }
+  Pattern1          ::=  boundvarid ‘:’ TypePat
+                      |  ‘_’ ‘:’ TypePat
+                      |  Pattern2
+  Pattern2          ::=  id [‘@’ Pattern3]
+                      |  Pattern3
+  Pattern3          ::=  SimplePattern
+                      |  SimplePattern { id [nl] SimplePattern }
+  SimplePattern     ::=  ‘_’
+                      |  varid
+                      |  Literal
+                      |  StableId
+                      |  StableId ‘(’ [Patterns] ‘)’
+                      |  StableId ‘(’ [Patterns ‘,’] [id ‘@’] ‘_’ ‘*’ ‘)’
+                      |  ‘(’ [Patterns] ‘)’
+                      |  XmlPattern
+  Patterns          ::=  Pattern [‘,’ Patterns]
+                      |  ‘_’ ‘*’
+
+  TypeParamClause   ::=  ‘[’ VariantTypeParam {‘,’ VariantTypeParam} ‘]’
+  FunTypeParamClause::=  ‘[’ TypeParam {‘,’ TypeParam} ‘]’
+  VariantTypeParam  ::=  {Annotation} [‘+’ | ‘-’] TypeParam
+  TypeParam         ::=  (id | ‘_’) [TypeParamClause] [‘>:’ Type] [‘<:’ Type]
+                         {‘<%’ Type} {‘:’ Type}
+  ParamClauses      ::=  {ParamClause} [[nl] ‘(’ ‘implicit’ Params ‘)’]
+  ParamClause       ::=  [nl] ‘(’ [Params] ‘)’
+  Params            ::=  Param {‘,’ Param}
+  Param             ::=  {Annotation} id [‘:’ ParamType] [‘=’ Expr]
+  ParamType         ::=  Type
+                      |  ‘=>’ Type
+                      |  Type ‘*’
+  ClassParamClauses ::=  {ClassParamClause}
+                         [[nl] ‘(’ ‘implicit’ ClassParams ‘)’]
+  ClassParamClause  ::=  [nl] ‘(’ [ClassParams] ‘)’
+  ClassParams       ::=  ClassParam {‘,’ ClassParam}
+  ClassParam        ::=  {Annotation} {Modifier} [(‘val’ | ‘var’)]
+                         id ‘:’ ParamType [‘=’ Expr]
+  Bindings          ::=  ‘(’ Binding {‘,’ Binding} ‘)’
+  Binding           ::=  (id | ‘_’) [‘:’ Type]
+
+  Modifier          ::=  LocalModifier
+                      |  AccessModifier
+                      |  ‘override’
+  LocalModifier     ::=  ‘abstract’
+                      |  ‘final’
+                      |  ‘sealed’
+                      |  ‘implicit’
+                      |  ‘lazy’
+  AccessModifier    ::=  (‘private’ | ‘protected’) [AccessQualifier]
+  AccessQualifier   ::=  ‘[’ (id | ‘this’) ‘]’
+
+  Annotation        ::=  ‘@’ SimpleType {ArgumentExprs}
+  ConstrAnnotation  ::=  ‘@’ SimpleType ArgumentExprs
+
+  TemplateBody      ::=  [nl] ‘{’ [SelfType] TemplateStat {semi TemplateStat} ‘}’
+  TemplateStat      ::=  Import
+                      |  {Annotation [nl]} {Modifier} Def
+                      |  {Annotation [nl]} {Modifier} Dcl
+                      |  Expr
+                      |
+  SelfType          ::=  id [‘:’ Type] ‘=>’
+                      |  ‘this’ ‘:’ Type ‘=>’
+
+  Import            ::=  ‘import’ ImportExpr {‘,’ ImportExpr}
+  ImportExpr        ::=  StableId ‘.’ (id | ‘_’ | ImportSelectors)
+  ImportSelectors   ::=  ‘{’ {ImportSelector ‘,’} (ImportSelector | ‘_’) ‘}’
+  ImportSelector    ::=  id [‘=>’ id | ‘=>’ ‘_’]
+
+  Dcl               ::=  ‘val’ ValDcl
+                      |  ‘var’ VarDcl
+                      |  ‘def’ FunDcl
+                      |  ‘type’ {nl} TypeDcl
+
+  ValDcl            ::=  ids ‘:’ Type
+  VarDcl            ::=  ids ‘:’ Type
+  FunDcl            ::=  FunSig [‘:’ Type]
+  FunSig            ::=  id [FunTypeParamClause] ParamClauses
+  TypeDcl           ::=  id [TypeParamClause] [‘>:’ Type] [‘<:’ Type]
+
+  PatVarDef         ::=  ‘val’ PatDef
+                      |  ‘var’ VarDef
+  Def               ::=  PatVarDef
+                      |  ‘def’ FunDef
+                      |  ‘type’ {nl} TypeDef
+                      |  TmplDef
+  PatDef            ::=  Pattern2 {‘,’ Pattern2} [‘:’ Type] ‘=’ Expr
+  VarDef            ::=  PatDef
+                      |  ids ‘:’ Type ‘=’ ‘_’
+  FunDef            ::=  FunSig [‘:’ Type] ‘=’ Expr
+                      |  FunSig [nl] ‘{’ Block ‘}’
+                      |  ‘this’ ParamClause ParamClauses
+                         (‘=’ ConstrExpr | [nl] ConstrBlock)
+  TypeDef           ::=  id [TypeParamClause] ‘=’ Type
+
+  TmplDef           ::=  [‘case’] ‘class’ ClassDef
+                      |  [‘case’] ‘object’ ObjectDef
+                      |  ‘trait’ TraitDef
+  ClassDef          ::=  id [TypeParamClause] {ConstrAnnotation} [AccessModifier]
+                         ClassParamClauses ClassTemplateOpt
+  TraitDef          ::=  id [TypeParamClause] TraitTemplateOpt
+  ObjectDef         ::=  id ClassTemplateOpt
+  ClassTemplateOpt  ::=  ‘extends’ ClassTemplate | [[‘extends’] TemplateBody]
+  TraitTemplateOpt  ::=  ‘extends’ TraitTemplate | [[‘extends’] TemplateBody]
+  ClassTemplate     ::=  [EarlyDefs] ClassParents [TemplateBody]
+  TraitTemplate     ::=  [EarlyDefs] TraitParents [TemplateBody]
+  ClassParents      ::=  Constr {‘with’ AnnotType}
+  TraitParents      ::=  AnnotType {‘with’ AnnotType}
+  Constr            ::=  AnnotType {ArgumentExprs}
+  EarlyDefs         ::=  ‘{’ [EarlyDef {semi EarlyDef}] ‘}’ ‘with’
+  EarlyDef          ::=  {Annotation [nl]} {Modifier} PatVarDef
+
+  ConstrExpr        ::=  SelfInvocation
+                      |  ConstrBlock
+  ConstrBlock       ::=  ‘{’ SelfInvocation {semi BlockStat} ‘}’
+  SelfInvocation    ::=  ‘this’ ArgumentExprs {ArgumentExprs}
+
+  TopStatSeq        ::=  TopStat {semi TopStat}
+  TopStat           ::=  {Annotation [nl]} {Modifier} TmplDef
+                      |  Import
+                      |  Packaging
+                      |  PackageObject
+                      |
+  Packaging         ::=  ‘package’ QualId [nl] ‘{’ TopStatSeq ‘}’
+  PackageObject     ::=  ‘package’ ‘object’ ObjectDef
+
+  CompilationUnit   ::=  {‘package’ QualId semi} TopStatSeq
+```
+
+<!-- TODO add:
+SeqPattern ::= ...
+
+SimplePattern    ::= StableId  [TypePatArgs] [‘(’ [SeqPatterns] ‘)’]
+TypePatArgs ::= ‘[’ TypePatArg {‘,’ TypePatArg} ‘]’
+TypePatArg    ::=  ‘_’ |   varid}
+
+-->
diff --git a/docs/_spec/14-references.md b/docs/_spec/14-references.md
new file mode 100644
index 000000000000..cc088dfcae11
--- /dev/null
+++ b/docs/_spec/14-references.md
@@ -0,0 +1,207 @@
+---
+title: References
+layout: default
+chapter: 14
+---
+
+# References
+
+TODO (see comments in markdown source)
+
+<!-- TODO
+
+provide a nice reading list to get up to speed with theory,...
+
+## Scala's Foundations
+[@scala-overview-tech-report;
+@odersky:scala-experiment;
+@odersky:sca;
+@odersky-et-al:ecoop03;
+@odersky-zenger:fool12]
+
+## Learning Scala
+
+## Related Work
+
+%% Article
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+@article{milner:polymorphism,
+  author	= {Robin Milner},
+  title		= {A {T}heory of {T}ype {P}olymorphism in {P}rogramming},
+  journal	= {Journal of Computer and System Sciences},
+  year		= {1978},
+  month		= {Dec},
+  volume	= {17},
+  pages		= {348-375},
+  folder	= { 2-1}
+}
+
+@Article{wirth:ebnf,
+  author	= "Niklaus Wirth",
+  title		= "What can we do about the unnecessary diversity of notation
+for syntactic definitions?",
+  journal	= "Comm. ACM",
+  year		= 1977,
+  volume	= 20,
+  pages		= "822-823",
+  month		= nov
+}
+
+%% Book
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+@Book{abelson-sussman:structure,
+  author	= {Harold Abelson and Gerald Jay Sussman and Julie Sussman},
+  title		= {The Structure and Interpretation of Computer Programs, 2nd
+                  edition},
+  publisher	= {MIT Press},
+  address	= {Cambridge, Massachusetts},
+  year		= {1996},
+  url		= {http://mitpress.mit.edu/sicp/full-text/sicp/book/book.html}
+}
+
+@Book{goldberg-robson:smalltalk-language,
+  author	= "Adele Goldberg and David Robson",
+  title		= "{Smalltalk-80}; The {L}anguage and Its {I}mplementation",
+  publisher	= "Addison-Wesley",
+  year		= "1983",
+  note		= "ISBN 0-201-11371-6"
+}
+
+@Book{matsumtoto:ruby,
+  author	= {Yukihiro Matsumoto},
+  title		= {Ruby in a {N}utshell},
+  publisher	= {O'Reilly \& Associates},
+  year		= "2001",
+  month		= "nov",
+  note		= "ISBN 0-596-00214-9"
+}
+
+@Book{rossum:python,
+  author	= {Guido van Rossum and Fred L. Drake},
+  title		= {The {P}ython {L}anguage {R}eference {M}anual},
+  publisher	= {Network Theory Ltd},
+  year		= "2003",
+  month		= "sep",
+  note		= {ISBN 0-954-16178-5\hspace*{\fill}\\
+                  \verb@http://www.python.org/doc/current/ref/ref.html@}
+}
+
+@Manual{odersky:scala-reference,
+  title =        {The {S}cala {L}anguage {S}pecification, Version 2.4},
+  author =       {Martin Odersky},
+  organization = {EPFL},
+  month =        feb,
+  year =         2007,
+  note =         {https://www.scala-lang.org/docu/manuals.html}
+}
+
+@Book{odersky:scala-reference,
+  ALTauthor =    {Martin Odersky},
+  ALTeditor =    {},
+  title =        {The {S}cala {L}anguage {S}pecification, Version 2.4},
+  publisher =    {},
+  year =         {},
+  OPTkey =       {},
+  OPTvolume =    {},
+  OPTnumber =    {},
+  OPTseries =    {},
+  OPTaddress =   {},
+  OPTedition =   {},
+  OPTmonth =     {},
+  OPTnote =      {},
+  OPTannote =    {}
+}
+
+%% InProceedings
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+@InProceedings{odersky-et-al:fool10,
+  author	= {Martin Odersky and Vincent Cremet and Christine R\"ockl
+                  and Matthias Zenger},
+  title		= {A {N}ominal {T}heory of {O}bjects with {D}ependent {T}ypes},
+  booktitle	= {Proc. FOOL 10},
+  year		= 2003,
+  month		= jan,
+  note		= {\hspace*{\fill}\\
+                  \verb@https://www.cis.upenn.edu/~bcpierce/FOOL/FOOL10.html@}
+}
+
+%% Misc
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+@Misc{w3c:dom,
+  author	= {W3C},
+  title		= {Document Object Model ({DOM})},
+  howpublished	= {\hspace*{\fill}\\
+                  \verb@https://www.w3.org/DOM/@}
+}
+
+@Misc{w3c:xml,
+  author	= {W3C},
+  title		= {Extensible {M}arkup {L}anguage ({XML})},
+  howpublished	= {\hspace*{\fill}\\
+                  \verb@https://www.w3.org/TR/REC-xml@}
+}
+
+@TechReport{scala-overview-tech-report,
+  author =       {Martin Odersky and al.},
+  title =        {An {O}verview of the {S}cala {P}rogramming {L}anguage},
+  institution =  {EPFL Lausanne, Switzerland},
+  year =         2004,
+  number =       {IC/2004/64}
+}
+
+@InProceedings{odersky:sca,
+  author =       {Martin Odersky and Matthias Zenger},
+  title =        {Scalable {C}omponent {A}bstractions},
+  booktitle =    {Proc. OOPSLA},
+  year =         2005
+}
+
+@InProceedings{odersky-et-al:ecoop03,
+  author =       {Martin Odersky and Vincent Cremet and Christine R\"ockl and Matthias Zenger},
+  title =        {A {N}ominal {T}heory of {O}bjects with {D}ependent {T}ypes},
+  booktitle =    {Proc. ECOOP'03},
+  year =         2003,
+  month =        jul,
+  series =       {Springer LNCS}
+}
+
+@InCollection{cremet-odersky:pilib,
+  author =       {Vincent Cremet and Martin Odersky},
+  title =        {PiLib} - A {H}osted {L}anguage for {P}i-{C}alculus {S}tyle {C}oncurrency},
+  booktitle =    {Domain-Specific Program Generation},
+  publisher =    {Springer},
+  year =         2005,
+  volume =       3016,
+  series =       {Lecture Notes in Computer Science}
+}
+
+@InProceedings{odersky-zenger:fool12,
+  author =       {Martin Odersky and Matthias Zenger},
+  title =        {Independently {E}xtensible {S}olutions to the {E}xpression {P}roblem},
+  booktitle =    {Proc. FOOL 12},
+  year =         2005,
+  month =        jan,
+  note =         {\verb@https://homepages.inf.ed.ac.uk/wadler/fool@}
+}
+
+@InProceedings{odersky:scala-experiment,
+  author =       {Martin Odersky},
+  title =        {The {S}cala {E}xperiment - {C}an {W}e {P}rovide {B}etter {L}anguage {S}upport for {C}omponent {S}ystems?},
+  booktitle =    {Proc. ACM Symposium on Principles of Programming Languages},
+  year =         2006
+}
+
+@MISC{kennedy-pierce:decidable,
+  author = {Andrew J. Kennedy and Benjamin C. Pierce},
+  title = {On {D}ecidability of {N}ominal {S}ubtyping with {V}ariance},
+  year = {2007},
+  month = jan,
+  note = {FOOL-WOOD '07},
+  short = {https://www.cis.upenn.edu/~bcpierce/papers/variance.pdf}
+}
+
+-->
diff --git a/docs/_spec/15-changelog.md b/docs/_spec/15-changelog.md
new file mode 100644
index 000000000000..5d24511ff1cb
--- /dev/null
+++ b/docs/_spec/15-changelog.md
@@ -0,0 +1,847 @@
+---
+title: Changelog
+layout: default
+chapter: 15
+---
+
+# Changelog
+
+This changelog was no longer maintained after version 2.8.0.
+
+A pull request updating this chapter to list the most significant
+changes made in more recent Scala versions would be highly welcome.
+
+Many language changes, especially larger ones, are documented in SIP
+(Scala Improvement Process) proposals.  Most proposals that were
+accepted and implemented have not merged into the main spec.  Pull
+requests that merge SIPs into the main spec are also highly welcome.
+
+To find out what has changed in Scala 2 since 2.8.0, you can consult
+the following sources:
+
+* Scala release notes (recent versions): https://github.com/scala/scala/releases
+* Scala release notes (older versions): https://scala-lang.org/blog/announcements/
+* Scala release notes (even older versions): presumably findable via search engine
+* Spec changelog in version control: https://github.com/scala/scala/commits/2.13.x/spec
+* SIPs: https://docs.scala-lang.org/sips/all.html
+
+## Changes in Version 2.8.0
+
+Trailing commas in expression, argument, type or pattern sequences are
+no longer supported.
+
+Changed visibility rules for nested packages (where done?)
+
+Changed [visibility rules](02-identifiers-names-and-scopes.html)
+so that packages are no longer treated specially.
+
+Added section on [weak conformance](03-types.html#weak-conformance).
+Relaxed type rules for conditionals,
+match expressions, try expressions to compute their result type using
+least upper bound wrt weak conformance. Relaxed type rule for local type
+inference so that argument types need only weekly conform to inferred
+formal parameter types. Added section on
+[numeric widening](06-expressions.html#numeric-widening) to support
+weak conformance.
+
+Tightened rules to avoid accidental [overrides](05-classes-and-objects.html#overriding).
+
+Removed class literals.
+
+Added section on [context bounds](07-implicits.html#context-bounds-and-view-bounds).
+
+Clarified differences between [`isInstanceOf` and pattern matches](12-the-scala-standard-library.html#root-classes).
+
+Allowed [`implicit` modifier on function literals](06-expressions.html#anonymous-functions) with a single parameter.
+
+## Changes in Version 2.7.2
+
+_(10-Nov-2008)_
+
+#### Precedence of Assignment Operators
+
+The [precedence of assignment operators](06-expressions.html#prefix,-infix,-and-postfix-operations)
+has been brought in line with. From now on `+=`, has the same precedence as `=`.
+
+#### Wildcards as function parameters
+
+A formal parameter to an anonymous function may now be a
+[wildcard represented by an underscore](06-expressions.html#placeholder-syntax-for-anonymous-functions).
+
+>      _ => 7   // The function that ignores its argument
+>               // and always returns 7.
+
+#### Unicode alternative for left arrow
+
+The Unicode glyph ‘´\leftarrow´’ ´`\u2190`´ is now treated as a reserved
+identifier, equivalent to the ASCII symbol ‘`<-`’.
+
+## Changes in Version 2.7.1
+
+_(09-April-2008)_
+
+#### Change in Scoping Rules for Wildcard Placeholders in Types
+
+A wildcard in a type now binds to the closest enclosing type
+application. For example `List[List[_]]` is now equivalent to this
+existential type:
+
+    List[List[t] forSome { type t }]
+
+In version 2.7.0, the type expanded instead to:
+
+    List[List[t]] forSome { type t }
+
+The new convention corresponds exactly to the way wildcards in Java are
+interpreted.
+
+#### No Contractiveness Requirement for Implicits
+
+The contractiveness requirement for
+[implicit method definitions](07-implicits.html#implicit-parameters)
+has been dropped. Instead, it is checked for each implicit expansion individually
+that the expansion does not result in a cycle or a tree of infinitely
+growing types.
+
+## Changes in Version 2.7.0
+
+_(07-Feb-2008)_
+
+#### Java Generics
+
+Scala now supports Java generic types by default:
+
+-   A generic type in Java such as `ArrayList<String>` is translated to
+    a generic type in Scala: `ArrayList[String]`.
+
+-   A wildcard type such as `ArrayList<? extends Number>` is translated
+    to `ArrayList[_ <: Number]`. This is itself a shorthand for the
+    existential type `ArrayList[T] forSome { type T <: Number }`.
+
+-   A raw type in Java such as `ArrayList` is translated to
+    `ArrayList[_]`, which is a shorthand for
+    `ArrayList[T] forSome { type T }`.
+
+This translation works if `-target:jvm-1.5` is specified, which is the
+new default. For any other target, Java generics are not recognized. To
+ensure upgradability of Scala codebases, extraneous type parameters for
+Java classes under `-target:jvm-1.4` are simply ignored. For instance,
+when compiling with `-target:jvm-1.4`, a Scala type such as
+`ArrayList[String]` is simply treated as the unparameterized type
+`ArrayList`.
+
+#### Changes to Case Classes
+
+The Scala compiler generates a [companion extractor object for every case class]
+(05-classes-and-objects.html#case-classes) now. For instance, given the case class:
+
+      case class X(elem: String)
+
+the following companion object is generated:
+
+      object X {
+        def unapply(x: X): Some[String] = Some(x.elem)
+        def apply(s: String): X = new X(s)
+      }
+
+If the object exists already, only the `apply` and `unapply` methods are
+added to it.
+
+Three restrictions on case classes have been removed.
+
+1.  Case classes can now inherit from other case classes.
+
+2.  Case classes may now be `abstract`.
+
+3.  Case classes may now come with companion objects.
+
+## Changes in Version 2.6.1
+
+_(30-Nov-2007)_
+
+#### Mutable variables introduced by pattern binding
+
+[Mutable variables can now be introduced by a pattern matching definition]
+(04-basic-declarations-and-definitions.html#variable-declarations-and-definitions),
+just like values can. Examples:
+
+      var (x, y) = if (positive) (1, 2) else (-1, -3)
+      var hd :: tl = mylist
+
+#### Self-types
+
+Self types can now be introduced without defining an alias name for
+[`this`](05-classes-and-objects.html#templates). Example:
+
+      class C {
+        type T <: Trait
+        trait Trait { this: T => ... }
+      }
+
+## Changes in Version 2.6
+
+_(27-July-2007)_
+
+#### Existential types
+
+It is now possible to define [existential types](03-types.html#existential-types).
+An existential type has the form `T forSome {Q}` where `Q` is a sequence of value and/or
+type declarations. Given the class definitions
+
+    class Ref[T]
+    abstract class Outer { type T }
+
+one may for example write the following existential types
+
+    Ref[T] forSome { type T <: java.lang.Number }
+    Ref[x.T] forSome { val x: Outer }
+
+#### Lazy values
+
+It is now possible to define lazy value declarations using the new modifier
+[`lazy`](04-basic-declarations-and-definitions.html#value-declarations-and-definitions).
+A `lazy` value definition evaluates its right hand
+side ´e´ the first time the value is accessed. Example:
+
+    import compat.Platform._
+    val t0 = currentTime
+    lazy val t1 = currentTime
+    val t2 = currentTime
+
+    println("t0 <= t2: " + (t0 <= t2))  //true
+    println("t1 <= t2: " + (t1 <= t2))  //false (lazy evaluation of t1)
+
+#### Structural types
+
+It is now possible to declare structural types using [type refinements]
+(03-types.html#compound-types). For example:
+
+    class File(name: String) {
+      def getName(): String = name
+      def open() { /*..*/ }
+      def close() { println("close file") }
+    }
+    def test(f: { def getName(): String }) { println(f.getName) }
+
+    test(new File("test.txt"))
+    test(new java.io.File("test.txt"))
+
+There’s also a shorthand form for creating values of structural types.
+For instance,
+
+    new { def getName() = "aaron" }
+
+is a shorthand for
+
+    new AnyRef{ def getName() = "aaron" }
+
+## Changes in Version 2.5
+
+_(02-May-2007)_
+
+#### Type constructor polymorphism
+
+_Implemented by Adriaan Moors_
+
+[Type parameters](04-basic-declarations-and-definitions.html#type-parameters)
+and abstract
+[type members](04-basic-declarations-and-definitions.html#type-declarations-and-type-aliases) can now also abstract over [type constructors](03-types.html#type-constructors).
+
+This allows a more precise `Iterable` interface:
+
+    trait Iterable[+T] {
+      type MyType[+T] <: Iterable[T] // MyType is a type constructor
+
+      def filter(p: T => Boolean): MyType[T] = ...
+      def map[S](f: T => S): MyType[S] = ...
+    }
+
+    abstract class List[+T] extends Iterable[T] {
+      type MyType[+T] = List[T]
+    }
+
+This definition of `Iterable` makes explicit that mapping a function
+over a certain structure (e.g., a `List`) will yield the same structure
+(containing different elements).
+
+#### Early object initialization
+
+[Early object initialization](05-classes-and-objects.html#early-definitions)
+makes it possible to initialize some fields of an object before any
+parent constructors are called. This is particularly useful for
+traits, which do not have normal constructor parameters. Example:
+
+    trait Greeting {
+      val name: String
+      val msg = "How are you, "+name
+    }
+    class C extends {
+      val name = "Bob"
+    } with Greeting {
+      println(msg)
+    }
+
+In the code above, the field is initialized before the constructor of is
+called. Therefore, field `msg` in class is properly initialized to .
+
+#### For-comprehensions, revised
+
+The syntax of [for-comprehensions](06-expressions.html#for-comprehensions-and-for-loops)
+has changed.
+In the new syntax, generators do not start with a `val` anymore, but filters
+start with an `if` (and are called guards).
+A semicolon in front of a guard is optional. For example:
+
+    for (val x <- List(1, 2, 3); x % 2 == 0) println(x)
+
+is now written
+
+    for (x <- List(1, 2, 3) if x % 2 == 0) println(x)
+
+The old syntax is still available but will be deprecated in the future.
+
+#### Implicit anonymous functions
+
+It is now possible to define [anonymous functions using underscores]
+(06-expressions.html#placeholder-syntax-for-anonymous-functions) in
+parameter position. For instance, the expressions in the left column
+are each function values which expand to the anonymous functions on
+their right.
+
+    _ + 1                  x => x + 1
+    _ * _                  (x1, x2) => x1 * x2
+    (_: int) * 2           (x: int) => (x: int) * 2
+    if (_) x else y        z => if (z) x else y
+    _.map(f)               x => x.map(f)
+    _.map(_ + 1)           x => x.map(y => y + 1)
+
+As a special case, a [partially unapplied method](06-expressions.html#method-values)
+is now designated `m _`   instead of the previous notation  `&m`.
+
+The new notation will displace the special syntax forms `.m()` for
+abstracting over method receivers and `&m` for treating an unapplied
+method as a function value. For the time being, the old syntax forms are
+still available, but they will be deprecated in the future.
+
+#### Pattern matching anonymous functions, refined
+
+It is now possible to use [case clauses to define a function value]
+(08-pattern-matching.html#pattern-matching-anonymous-functions)
+directly for functions of arities greater than one. Previously, only
+unary functions could be defined that way. Example:
+
+    def scalarProduct(xs: Array[Double], ys: Array[Double]) =
+      (xs zip ys).foldLeft(0.0) {
+        case (a, (b, c)) => a + b * c
+      }
+
+## Changes in Version 2.4
+
+_(09-Mar-2007)_
+
+#### Object-local private and protected
+
+The `private` and `protected` modifiers now accept a
+[`[this]` qualifier](05-classes-and-objects.html#modifiers).
+A definition ´M´ which is labelled `private[this]` is private,
+and in addition can be accessed only from within the current object.
+That is, the only legal prefixes for ´M´ are `this` or `´C´.this`.
+Analogously, a definition ´M´ which is labelled `protected[this]` is
+protected, and in addition can be accessed only from within the current
+object.
+
+#### Tuples, revised
+
+The syntax for [tuples](06-expressions.html#tuples) has been changed from ´\\{…\\}´ to
+´(…)´. For any sequence of types ´T_1 , … , T_n´,
+
+´(T_1 , … , T_n)´ is a shorthand for `Tuple´n´[´T_1 , … , T_n´]`.
+
+Analogously, for any sequence of expressions or patterns ´x_1
+, … , x_n´,
+
+´(x_1 , … , x_n)´ is a shorthand for `Tuple´n´(´x_1 , … , x_n´)`.
+
+#### Access modifiers for primary constructors
+
+The primary constructor of a class can now be marked [`private` or `protected`]
+(05-classes-and-objects.html#class-definitions).
+If such an access modifier is given, it comes between the name of the class and its
+value parameters. Example:
+
+    class C[T] private (x: T) { ... }
+
+#### Annotations
+
+The support for attributes has been extended and its syntax changed.
+Attributes are now called [*annotations*](11-annotations.html). The syntax has
+been changed to follow Java’s conventions, e.g. `@attribute` instead of
+`[attribute]`. The old syntax is still available but will be deprecated
+in the future.
+
+Annotations are now serialized so that they can be read by compile-time
+or run-time tools. Class has two sub-traits which are used to indicate
+how annotations are retained. Instances of an annotation class
+inheriting from trait will be stored in the generated class files.
+Instances of an annotation class inheriting from trait will be visible
+to the Scala type-checker in every compilation unit where the annotated
+symbol is accessed.
+
+#### Decidable subtyping
+
+The implementation of subtyping has been changed to prevent infinite
+recursions.
+[Termination of subtyping](05-classes-and-objects.html#inheritance-closure)
+is now ensured by a new restriction of class graphs to be finitary.
+
+#### Case classes cannot be abstract
+
+It is now explicitly ruled out that case classes can be abstract. The
+specification was silent on this point before, but did not explain how
+abstract case classes were treated. The Scala compiler allowed the
+idiom.
+
+#### New syntax for self aliases and self types
+
+It is now possible to give an explicit alias name and/or type for the
+[self reference](05-classes-and-objects.html#templates) `this`. For instance, in
+
+    class C { self: D =>
+      ...
+    }
+
+the name `self` is introduced as an alias for `this` within `C` and the
+[self type](05-classes-and-objects.html#class-definitions) of `C` is
+assumed to be `D`. This construct is introduced now in order to replace
+eventually both the qualified this construct and the clause in Scala.
+
+#### Assignment Operators
+
+It is now possible to [combine operators with assignments]
+(06-expressions.html#assignment-operators). Example:
+
+    var x: int = 0
+    x += 1
+
+## Changes in Version 2.3.2
+
+_(23-Jan-2007)_
+
+#### Extractors
+
+It is now possible to define patterns independently of case classes, using
+`unapply` methods in [extractor objects](08-pattern-matching.html#extractor-patterns).
+Here is an example:
+
+    object Twice {
+      def apply(x:Int): int = x*2
+      def unapply(z:Int): Option[int] = if (z%2==0) Some(z/2) else None
+    }
+    val x = Twice(21)
+    x match { case Twice(n) => Console.println(n) } // prints 21
+
+In the example, `Twice` is an extractor object with two methods:
+
+-   The `apply` method is used to build even numbers.
+
+-   The `unapply` method is used to decompose an even number; it is in a sense
+    the reverse of `apply`. `unapply` methods return option types:
+    `Some(...)` for a match that succeeds, `None` for a match that fails.
+    Pattern variables are returned as the elements of `Some`.
+    If there are several variables, they are grouped in a tuple.
+
+In the second-to-last line, `Twice`’s method is used to construct a number `x`.
+In the last line, `x` is tested against the pattern `Twice(n)`.
+This pattern succeeds for even numbers and assigns to the variable `n` one half
+of the number that was tested.
+The pattern match makes use of the `unapply` method of object `Twice`.
+More details on extractors can be found in the paper “Matching Objects with
+Patterns” by Emir, Odersky and Williams.
+
+#### Tuples
+
+A new [lightweight syntax for tuples](06-expressions.html#tuples) has been introduced.
+For any sequence of types ´T_1 , … , T_n´,
+
+´\{T_1 , … , T_n \}´ is a shorthand for `Tuple´n´[´T_1 , … , T_n´]`.
+
+Analogously, for any sequence of expressions or patterns ´x_1, … , x_n´,
+
+´\{x_1 , … , x_n \}´ is a shorthand for `Tuple´n´(´x_1 , … , x_n´)`.
+
+#### Infix operators of greater arities
+
+It is now possible to use methods which have more than one parameter as
+[infix operators](06-expressions.html#infix-operations). In this case, all
+method arguments are written as a normal parameter list in parentheses. Example:
+
+    class C {
+      def +(x: int, y: String) = ...
+    }
+    val c = new C
+    c + (1, "abc")
+
+#### Deprecated attribute
+
+A new standard attribute [`deprecated`](11-annotations.html#deprecation-annotations)
+is available. If a member definition is marked with this attribute, any
+reference to the member will cause a “deprecated” warning message to be emitted.
+
+## Changes in Version 2.3
+
+_(23-Nov-2006)_
+
+#### Procedures
+
+A simplified syntax for [methods returning `unit`]
+(04-basic-declarations-and-definitions.html#procedures) has been introduced.
+Scala now allows the following shorthands:
+
+`def f(params)` **for** `def f(params): unit`  
+`def f(params) { ... }` **for** `def f(params): unit = { ... }`
+
+#### Type Patterns
+
+The [syntax of types in patterns](08-pattern-matching.html#type-patterns) has
+been refined.
+Scala now distinguishes between type variables (starting with a lower case
+letter) and types as type arguments in patterns.
+Type variables are bound in the pattern.
+Other type arguments are, as in previous versions, erased.
+The Scala compiler will now issue an “unchecked” warning at places where type
+erasure might compromise type-safety.
+
+#### Standard Types
+
+The recommended names for the two bottom classes in Scala’s type
+hierarchy have changed as follows:
+
+    All      ==>     Nothing
+    AllRef   ==>     Null
+
+The old names are still available as type aliases.
+
+## Changes in Version 2.1.8
+
+_(23-Aug-2006)_
+
+#### Visibility Qualifier for protected
+
+Protected members can now have a visibility qualifier, e.g.
+[`protected[<qualifier>]`](05-classes-and-objects.html#protected).
+In particular, one can now simulate package protected access as in Java writing
+
+      protected[P] def X ...
+
+where would name the package containing `X`.
+
+#### Relaxation of Private Access
+
+[Private members of a class](05-classes-and-objects.html#private) can now be
+referenced from the companion module of the class and vice versa.
+
+#### Implicit Lookup
+
+The lookup method for [implicit definitions](07-implicits.html#implicit-parameters)
+has been generalized.
+When searching for an implicit definition matching a type ´T´, now are considered
+
+1.  all identifiers accessible without prefix, and
+
+2.  all members of companion modules of classes associated with ´T´.
+
+(The second clause is more general than before). Here, a class is _associated_
+with a type ´T´ if it is referenced by some part of ´T´, or if it is a
+base class of some part of ´T´.
+For instance, to find implicit members corresponding to the type
+
+      HashSet[List[Int], String]
+
+one would now look in the companion modules (aka static parts) of `HashSet`,
+`List`, `Int`, and `String`. Before, it was just the static part of .
+
+#### Tightened Pattern Match
+
+A typed [pattern match with a singleton type `p.type`](08-pattern-matching.html#type-patterns)
+now tests whether the selector value is reference-equal to `p`. Example:
+
+      val p = List(1, 2, 3)
+      val q = List(1, 2)
+      val r = q
+      r match {
+        case _: p.type => Console.println("p")
+        case _: q.type => Console.println("q")
+      }
+
+This will match the second case and hence will print “q”. Before, the
+singleton types were erased to `List`, and therefore the first case would have
+matched, which is non-sensical.
+
+## Changes in Version 2.1.7
+
+_(19-Jul-2006)_
+
+#### Multi-Line string literals
+
+It is now possible to write [multi-line string-literals]
+(01-lexical-syntax.html#string-literals) enclosed in triple quotes. Example:
+
+    """this is a
+       multi-line
+       string literal"""
+
+No escape substitutions except for unicode escapes are performed in such
+string literals.
+
+#### Closure Syntax
+
+The syntax of [closures](06-expressions.html#anonymous-functions)
+has been slightly restricted. The form
+
+      x: T => E
+
+is valid only when enclosed in braces, i.e.  `{ x: T => E }`. The
+following is illegal, because it might be read as the value x typed with
+the type `T => E`:
+
+      val f = x: T => E
+
+Legal alternatives are:
+
+      val f = { x: T => E }
+      val f = (x: T) => E
+
+## Changes in Version 2.1.5
+
+_(24-May-2006)_
+
+#### Class Literals
+
+There is a new syntax for [class literals](06-expressions.html#literals):
+For any class type ´C´, `classOf[´C´]` designates the run-time
+representation of ´C´.
+
+## Changes in Version 2.0
+
+_(12-Mar-2006)_
+
+Scala in its second version is different in some details from the first
+version of the language. There have been several additions and some old
+idioms are no longer supported. This appendix summarizes the main
+changes.
+
+#### New Keywords
+
+The following three words are now reserved; they cannot be used as
+[identifiers](01-lexical-syntax.html#identifiers):
+
+    implicit    match     requires
+
+#### Newlines as Statement Separators
+
+[Newlines](https://www.scala-lang.org/files/archive/spec/2.11/)
+can now be used as statement separators in place of semicolons.
+
+#### Syntax Restrictions
+
+There are some other situations where old constructs no longer work:
+
+##### *Pattern matching expressions*
+
+The `match` keyword now appears only as infix operator between a
+selector expression and a number of cases, as in:
+
+      expr match {
+        case Some(x) => ...
+        case None => ...
+      }
+
+Variants such as ` expr.match {...} ` or just ` match {...} ` are no
+longer supported.
+
+##### *“With” in extends clauses*
+
+The idiom
+
+    class C with M { ... }
+
+is no longer supported. A `with` connective is only allowed following an
+`extends` clause. For instance, the line above would have to be written
+
+    class C extends AnyRef with M { ... } .
+
+However, assuming `M` is a [trait](05-classes-and-objects.html#traits),
+it is also legal to write
+
+    class C extends M { ... }
+
+The latter expression is treated as equivalent to
+
+    class C extends S with M { ... }
+
+where `S` is the superclass of `M`.
+
+##### *Regular Expression Patterns*
+
+The only form of regular expression pattern that is currently supported
+is a sequence pattern, which might end in a sequence wildcard . Example:
+
+    case List(1, 2, _*) => ... // will match all lists starting with 1, 2, ...
+
+It is at current not clear whether this is a permanent restriction. We
+are evaluating the possibility of re-introducing full regular expression
+patterns in Scala.
+
+#### Selftype Annotations
+
+The recommended syntax of selftype annotations has changed.
+
+    class C: T extends B { ... }
+
+becomes
+
+    class C requires T extends B { ... }
+
+That is, selftypes are now indicated by the new `requires` keyword. The
+old syntax is still available but is considered deprecated.
+
+#### For-comprehensions
+
+[For-comprehensions](06-expressions.html#for-comprehensions-and-for-loops)
+now admit value and pattern definitions. Example:
+
+    for {
+      val x <- List.range(1, 100)
+      val y <- List.range(1, x)
+      val z = x + y
+      isPrime(z)
+    } yield Pair(x, y)
+
+Note the definition  `val z = x + y` as the third item in the
+for-comprehension.
+
+#### Conversions
+
+The rules for [implicit conversions of methods to functions]
+(06-expressions.html#method-conversions) have been tightened.
+Previously, a parameterized method used as a value was always
+implicitly converted to a function. This could lead to unexpected
+results when method arguments where forgotten. Consider for instance the
+statement below:
+
+    show(x.toString)
+
+where `show` is defined as follows:
+
+    def show(x: String) = Console.println(x) .
+
+Most likely, the programmer forgot to supply an empty argument list `()`
+to `toString`. The previous Scala version would treat this code as a
+partially applied method, and expand it to:
+
+    show(() => x.toString())
+
+As a result, the address of a closure would be printed instead of the
+value of `s`.
+
+Scala version 2.0 will apply a conversion from partially applied method
+to function value only if the expected type of the expression is indeed
+a function type. For instance, the conversion would not be applied in
+the code above because the expected type of `show`’s parameter is
+`String`, not a function type.
+
+The new convention disallows some previously legal code. Example:
+
+    def sum(f: int => double)(a: int, b: int): double =
+      if (a > b) 0 else f(a) + sum(f)(a + 1, b)
+
+    val sumInts  =  sum(x => x)  // error: missing arguments
+
+The partial application of `sum` in the last line of the code above will
+not be converted to a function type. Instead, the compiler will produce
+an error message which states that arguments for method `sum` are
+missing. The problem can be fixed by providing an expected type for the
+partial application, for instance by annotating the definition of
+`sumInts` with its type:
+
+    val sumInts: (int, int) => double  =  sum(x => x)  // OK
+
+On the other hand, Scala version 2.0 now automatically applies methods
+with empty parameter lists to `()` argument lists when necessary. For
+instance, the `show` expression above will now be expanded to
+
+    show(x.toString()) .
+
+Scala version 2.0 also relaxes the rules of overriding with respect to
+empty parameter lists. The revised definition of
+[_matching members_](05-classes-and-objects.html#class-members)
+makes it now possible to override a method with an
+explicit, but empty parameter list `()` with a parameterless method, and
+_vice versa_. For instance, the following class definition
+is now legal:
+
+    class C {
+      override def toString: String = ...
+    }
+
+Previously this definition would have been rejected, because the
+`toString` method as inherited from `java.lang.Object` takes an empty
+parameter list.
+
+#### Class Parameters
+
+A [class parameter](05-classes-and-objects.html#class-definitions)
+may now be prefixed by `val` or `var`.
+
+#### Private Qualifiers
+
+Previously, Scala had three levels of visibility:
+<span>*private*</span>, <span>*protected*</span> and
+<span>*public*</span>. There was no way to restrict accesses to members
+of the current package, as in Java.
+
+Scala 2 now defines [access qualifiers](05-classes-and-objects.html#modifiers)
+that let one express this level of visibility, among others. In the definition
+
+    private[C] def f(...)
+
+access to `f` is restricted to all code within the class or package `C`
+(which must contain the definition of `f`).
+
+#### Changes in the Mixin Model
+
+The model which details [mixin composition of classes]
+(05-classes-and-objects.html#templates) has changed significantly.
+The main differences are:
+
+1.  We now distinguish between <span>*traits*</span> that are used as
+    mixin classes and normal classes. The syntax of traits has been
+    generalized from version 1.0, in that traits are now allowed to have
+    mutable fields. However, as in version 1.0, traits still may not
+    have constructor parameters.
+
+2.  Member resolution and super accesses are now both defined in terms
+    of a <span>*class linearization*</span>.
+
+3.  Scala’s notion of method overloading has been generalized; in
+    particular, it is now possible to have overloaded variants of the
+    same method in a subclass and in a superclass, or in several
+    different mixins. This makes method overloading in Scala
+    conceptually the same as in Java.
+
+#### Implicit Parameters
+
+Views in Scala 1.0 have been replaced by the more general concept of
+[implicit parameters](07-implicits.html#implicit-parameters).
+
+#### Flexible Typing of Pattern Matching
+
+The new version of Scala implements more flexible typing rules when it
+comes to [pattern matching over heterogeneous class hierarchies]
+(08-pattern-matching.html#pattern-matching-expressions).
+A <span>*heterogeneous class hierarchy*</span> is one where subclasses
+inherit a common superclass with different parameter types. With the new
+rules in Scala version 2.0 one can perform pattern matches over such
+hierarchies with more precise typings that keep track of the information
+gained by comparing the types of a selector and a matching pattern.
+This gives Scala capabilities analogous to guarded algebraic data types.
diff --git a/docs/_spec/README.md b/docs/_spec/README.md
new file mode 100644
index 000000000000..d748dddedfd2
--- /dev/null
+++ b/docs/_spec/README.md
@@ -0,0 +1,45 @@
+# Scala Language Reference
+
+First of all, the language specification is meant to be correct, precise and clear.
+
+Second, editing, previewing and generating output for the markdown should be simple and easy.
+
+Third, we'd like to support different output formats. An html page per chapter with MathJax seems like a good start, as it satisfies the second requirement, and enables the first one.
+
+## Editing
+
+We are using Jekyll and [Redcarpet](https://github.com/vmg/redcarpet) to generate the html.
+
+Check `Gemfile` for the current versions.
+
+We aim to track the configuration GitHub Pages uses but differences may arise as GitHub Pages evolves.
+
+## Building
+
+Travis CI builds the spec automatically after every merged pull release and publishes to https://www.scala-lang.org/files/archive/spec/2.13/.
+
+To preview locally, run the following commands in the root of your checkout scala/scala:
+`bundle install` to install Jekyll and `bundle exec jekyll serve -d build/spec/ -s spec/ -w --baseurl=""` to start it,
+and open http://0.0.0.0:4000/ to view the spec. Jekyll will rebuild as you edit the markdown, but make sure to restart it when you change `_config.yml`.
+
+## General Advice for editors
+
+- All files must be saved as UTF-8: ensure your editors are configured appropriately.
+- Use of the appropriate unicode characters instead of the latex modifiers for accents, etc. is necessary. For example, é instead of `\'e`.
+- MathJAX errors  will appear within the  rendered DOM as span  elements with class `mtext` and style attribute `color: red` applied. It is  possible to search for this combination in the development  tools of the browser of your choice. In chrome, CTRL+F / CMD+F within the inspect element panel allows you to do this.
+
+### Macro replacements:
+
+- While  MathJAX just  support LaTeX style  command definition,  it is recommended  to not use  this as  it will likely cause issues with preparing the document for PDF or ebook distribution.
+- `\SS` (which I could not find defined within the latex source) seems to be closest to `\mathscr{S}`
+- `\TYPE` is equivalent to `\boldsymbol{type}'
+- As MathJAX has  no support for slanted font (latex  command \sl), so in all instances  this should be replaced with \mathit{}
+- The macro \U{ABCD} used for unicode character references can be replaced with \\uABCD.
+- The macro \URange{ABCD}{DCBA} used for unicode character ranges can be replaced with \\uABCD-\\uDBCA.
+- The macro \commadots can be replaced with ` , … , `.
+- There is no adequate replacement for `\textsc{...}`  (small caps) in pandoc markdown. While unicode contains a number of  small capital  letters, it  is notably  missing Q and  X as  these glyphs  are intended  for phonetic spelling, therefore these  cannot be reliably used. For now,  the best option is to use  underscore emphasis and capitalise the text manually, `_LIKE THIS_`.
+
+### Unicode Character replacements
+
+- The unicode  left and right single  quotation marks (‘ and ’ (U+2018 and U+2019, respectively)) have been used in  place of ` and ', where the quotation marks  are intended to  be paired. These can  be typed on  a mac using  Option+] for a left  quote and Option+Shift+] for the right quote.
+- Similarly for left and right double quotation marks (“ and ” (U+201C and U+201D, respectively)) in place of ". These can be typed on a mac using Option+[ and Option+Shift+].
diff --git a/docs/_spec/_config.yml b/docs/_spec/_config.yml
new file mode 100644
index 000000000000..bd1f691c65d0
--- /dev/null
+++ b/docs/_spec/_config.yml
@@ -0,0 +1,11 @@
+baseurl: /files/archive/spec/2.13
+latestScalaVersion: 2.13
+thisScalaVersion: 2.13
+versionCompareMessage: "an upcoming"
+safe: true
+lsi: false
+highlighter: false
+markdown: redcarpet
+encoding: utf-8
+redcarpet:
+  extensions: ["no_intra_emphasis", "fenced_code_blocks", "autolink", "tables", "with_toc_data", "strikethrough", "lax_spacing", "space_after_headers", "superscript", "footnotes"]
diff --git a/docs/_spec/_includes/numbering.css b/docs/_spec/_includes/numbering.css
new file mode 100644
index 000000000000..2a22ce28b558
--- /dev/null
+++ b/docs/_spec/_includes/numbering.css
@@ -0,0 +1,60 @@
+h1 {
+  /* must reset here */
+  counter-reset: chapter {{ page.chapter }};
+}
+h1:before {
+  /* and must reset again here */
+  counter-reset: chapter {{ page.chapter }};
+  content: "Chapter " counter(chapter);
+  display: block;
+}
+
+h2 {
+  /* must increment here */
+  counter-increment: section;
+  counter-reset: subsection;
+}
+h2:before {
+  /* and must reset again here */
+  counter-reset: chapter {{ page.chapter }};
+
+  content: counter(chapter) "." counter(section) ;
+  display: inline;
+  margin-right: 1em;
+}
+h2:after {
+  /* can only have one counter-reset per tag, so can't do it in h2/h2:before... */
+  counter-reset: example;
+}
+
+h3 {
+  /* must increment here */
+  counter-increment: subsection;
+}
+h3:before {
+  /* and must reset again here */
+  counter-reset: chapter {{ page.chapter }};
+
+  content: counter(chapter) "." counter(section) "." counter(subsection);
+  display: inline;
+  margin-right: 1em;
+}
+h3[id*='example'] {
+  /* must increment here */
+  counter-increment: example;
+  display: inline;
+}
+h3[id*='example']:before {
+  /* and must reset again here */
+  counter-reset: chapter {{ page.chapter }};
+
+  content: "Example " counter(chapter) "." counter(section) "." counter(example);
+  display: inline;
+  margin-right: 1em;
+}
+
+.no-numbering, .no-numbering:before, .no-numbering:after {
+  content: normal;
+  counter-reset: none;
+  counter-increment: none;
+}
diff --git a/docs/_spec/_includes/table-of-contents.yml b/docs/_spec/_includes/table-of-contents.yml
new file mode 100644
index 000000000000..b70f97da5424
--- /dev/null
+++ b/docs/_spec/_includes/table-of-contents.yml
@@ -0,0 +1,23 @@
+
+<div class="hidden-print">
+
+  <h1>Table of Contents</h1>
+
+  <ol>
+    {% assign sorted_pages = site.pages | sort:"name" %}
+    {% for post in sorted_pages %}
+      <!-- exclude this page from the toc, not sure how to check
+          whether there is no chapter variable in the page  -->
+      {% if post.chapter >= 0 %}
+        <li>
+          <a href="{{site.baseurl}}{{ post.url }}"> {{ post.title }}</a>
+        </li>
+      {% endif %}
+    {% endfor %}
+  </ol>
+</div>
+
+<p class="print-only">
+  This document was generated from <a href="{{ site.baseurl}}/../{{ site.latestScalaVersion }}/">
+  HTML version of Scala {{ site.latestScalaVersion }} spec</a>
+</p>
diff --git a/docs/_spec/_includes/version-notice.yml b/docs/_spec/_includes/version-notice.yml
new file mode 100644
index 000000000000..5a7286631c11
--- /dev/null
+++ b/docs/_spec/_includes/version-notice.yml
@@ -0,0 +1,3 @@
+{% if site.thisScalaVersion != site.latestScalaVersion %}
+<div class="version-notice">This is the specification of {{ site.versionCompareMessage }} version of Scala. See the <a href="{{ site.baseurl}}/../{{ site.latestScalaVersion }}/">Scala {{ site.latestScalaVersion }} spec</a>.</div>
+{% endif %}
diff --git a/docs/_spec/_layouts/default.yml b/docs/_spec/_layouts/default.yml
new file mode 100644
index 000000000000..2589a105dff2
--- /dev/null
+++ b/docs/_spec/_layouts/default.yml
@@ -0,0 +1,51 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta http-equiv='Content-Type' content='text/html; charset=utf-8' />
+
+  <link rel="icon" type="image/png" href="public/favicon.ico">
+  <link rel="shortcut icon" type="image/png" href="public/favicon.ico">
+
+  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/katex@0.10.0/dist/katex.min.css" integrity="sha384-9eLZqc9ds8eNjO3TmqPeYcDj8n+Qfa4nuSiGYa6DjLNcv9BtN69ZIulL9+8CqC9Y" crossorigin="anonymous">
+  <script defer src="https://cdn.jsdelivr.net/npm/katex@0.10.0/dist/katex.min.js" integrity="sha384-K3vbOmF2BtaVai+Qk37uypf7VrgBubhQreNQe9aGsz9lB63dIFiQVlJbr92dw2Lx" crossorigin="anonymous"></script>
+  <script defer src="https://cdn.jsdelivr.net/npm/katex@0.10.0/dist/contrib/auto-render.min.js" integrity="sha384-kmZOZB5ObwgQnS/DuDg6TScgOiWWBiVt0plIRkZCmE6rDZGrEOQeHM5PcHi+nyqe" crossorigin="anonymous"></script>
+
+  <script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
+  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/8.2/styles/default.min.css">
+  <!-- need to use include to see value of page.chapter variable -->
+  <style type="text/css">
+    {% include numbering.css %}
+  </style>
+  <link rel="stylesheet" type="text/css" href="public/stylesheets/screen.css">
+  <link rel="stylesheet" type="text/css" media="(max-width: 1400px), (orientation: portrait)" href="public/stylesheets/screen-small.css">
+  <link rel="stylesheet" type="text/css" media="print" href="public/stylesheets/print.css">
+  <link rel="stylesheet" type="text/css" href="public/stylesheets/fonts.css">
+  <title>{{ page.title }} | Scala {{ site.thisScalaVersion }}</title>
+</head>
+
+<body>
+  <header class="hidden-print">
+    <nav id="chapters">
+      <a href="{{site.baseurl}}/" title="Table of Contents">Scala {{ site.thisScalaVersion }}</a>
+      <a id="github" href="https://github.com/scala/scala/tree/2.13.x/spec"><img src="public/images/github-logo@2x.png" alt="Edit at GitHub"></a>
+      {% assign sorted_pages = site.pages | sort:"name" %}
+      {% for post in sorted_pages %}
+        {% if post.chapter >= 0 %}
+        <a href="{{site.baseurl}}{{ post.url }}">{{post.chapter}} {{ post.title }}</a>
+        {% endif %}
+      {% endfor %}
+    </nav>
+  </header>
+  <aside class="left hidden-print"><nav id="toc"></nav></aside>
+
+  <main id="content">
+{% include version-notice.yml %}
+{{ content }}
+  </main>
+
+  <script>window.jekyllEnv = '{{jekyll.environment}}';</script>
+  <script src="public/scripts/toc.js"></script>
+  <script src="public/scripts/highlight.pack.js"></script>
+  <script src="public/scripts/main.js"></script>
+</body>
+</html>
diff --git a/docs/_spec/_layouts/toc.yml b/docs/_spec/_layouts/toc.yml
new file mode 100644
index 000000000000..1106222bd088
--- /dev/null
+++ b/docs/_spec/_layouts/toc.yml
@@ -0,0 +1,34 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta http-equiv='Content-Type' content='text/html; charset=utf-8' />
+
+  <link rel="icon" type="image/png" href="public/favicon.ico">
+  <link rel="shortcut icon" type="image/png" href="public/favicon.ico">
+
+  <script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
+  <title>{{ page.title }} | Scala {{ site.thisScalaVersion }}</title>
+
+  <link rel="stylesheet" type="text/css" href="public/stylesheets/screen.css">
+  <link rel="stylesheet" type="text/css" href="public/stylesheets/screen-toc.css">
+  <link rel="stylesheet" type="text/css" media="print" href="public/stylesheets/print.css">
+  <link rel="stylesheet" type="text/css" href="public/stylesheets/fonts.css">
+</head>
+
+<body>
+<header>
+  <div id="header-main">
+  <img id="scala-logo" src="public/images/scala-spiral-white.png" />
+  <span id="title">Scala Language Specification</span>
+  <a id="github" href="https://github.com/scala/scala/tree/{{ site.thisScalaVersion }}.x/spec"><img src="public/images/github-logo@2x.png" alt="Edit at GitHub"></a>
+  </div>
+  <div id="header-sub">Version {{ site.thisScalaVersion }}</div>
+</header>
+<main>
+{% include version-notice.yml %}
+{{ content }}
+</main>
+
+<script>window.status = "loaded";</script>
+</body>
+</html>
diff --git a/docs/_spec/id_dsa_travis.enc b/docs/_spec/id_dsa_travis.enc
new file mode 100644
index 000000000000..6709463580af
--- /dev/null
+++ b/docs/_spec/id_dsa_travis.enc
@@ -0,0 +1,68 @@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 --git a/docs/_spec/index.md b/docs/_spec/index.md
new file mode 100644
index 000000000000..df126db7bd44
--- /dev/null
+++ b/docs/_spec/index.md
@@ -0,0 +1,55 @@
+---
+title: Scala Language Specification
+layout: toc
+---
+
+{% include table-of-contents.yml %}
+
+#### Authors and Contributors
+
+Martin Odersky, Philippe Altherr, Vincent Cremet, Gilles Dubochet, Burak Emir, Philipp Haller, Stéphane Micheloud, Nikolay Mihaylov, Adriaan Moors, Lukas Rytz, Michel Schinz, Erik Stenman, Matthias Zenger
+
+Markdown Conversion by Iain McGinniss.
+
+#### Preface
+
+Scala is a Java-like programming language which unifies
+object-oriented and functional programming.  It is a pure
+object-oriented language in the sense that every value is an
+object. Types and behavior of objects are described by
+classes. Classes can be composed using mixin composition.  Scala is
+designed to work seamlessly with less pure but mainstream
+object-oriented languages like Java.
+
+Scala is a functional language in the sense that every function is a
+value. Nesting of function definitions and higher-order functions are
+naturally supported. Scala also supports a general notion of pattern
+matching which can model the algebraic types used in many functional
+languages.
+
+Scala has been designed to interoperate seamlessly with Java.
+Scala classes can call Java methods, create Java objects, inherit from Java
+classes and implement Java interfaces. None of this requires interface
+definitions or glue code.
+
+Scala has been developed from 2001 in the programming methods
+laboratory at EPFL. Version 1.0 was released in November 2003. This
+document describes the second version of the language, which was
+released in March 2006. It acts as a reference for the language
+definition and some core library modules. It is not intended to teach
+Scala or its concepts; for this there are [other documents](14-references.html).
+
+Scala has been a collective effort of many people. The design and the
+implementation of version 1.0 was completed by Philippe Altherr,
+Vincent Cremet, Gilles Dubochet, Burak Emir, Stéphane Micheloud,
+Nikolay Mihaylov, Michel Schinz, Erik Stenman, Matthias Zenger, and
+the author. Iulian Dragos, Gilles Dubochet, Philipp Haller, Sean
+McDirmid, Lex Spoon, and Geoffrey Washburn joined in the effort to
+develop the second version of the language and tools.  Gilad Bracha,
+Craig Chambers, Erik Ernst, Matthias Felleisen, Shriram Krishnamurti,
+Gary Leavens, Sebastian Maneth, Erik Meijer, Klaus Ostermann, Didier
+Rémy, Mads Torgersen, and Philip Wadler have shaped the design of
+the language through lively and inspiring discussions and comments on
+previous versions of this document.  The contributors to the Scala
+mailing list have also given very useful feedback that helped us
+improve the language and its tools.
diff --git a/docs/_spec/public/favicon.ico b/docs/_spec/public/favicon.ico
new file mode 100644
index 0000000000000000000000000000000000000000..9eb6ef516488909512715a5b752f0a9fe46c89e9
GIT binary patch
literal 6518
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

literal 0
HcmV?d00001

diff --git a/docs/_spec/public/fonts/Heuristica-Bold.woff b/docs/_spec/public/fonts/Heuristica-Bold.woff
new file mode 100644
index 0000000000000000000000000000000000000000..904579683d54e3e033fe1180b36fe9e1a5dba551
GIT binary patch
literal 106188
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
BkWv5u

literal 0
HcmV?d00001

diff --git a/docs/_spec/public/fonts/Heuristica-BoldItalic.woff b/docs/_spec/public/fonts/Heuristica-BoldItalic.woff
new file mode 100644
index 0000000000000000000000000000000000000000..a3c5234453751c651ce4080689a68deb64536aa7
GIT binary patch
literal 104316
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
D(%L$|

literal 0
HcmV?d00001

diff --git a/docs/_spec/public/fonts/Heuristica-Regular.woff b/docs/_spec/public/fonts/Heuristica-Regular.woff
new file mode 100644
index 0000000000000000000000000000000000000000..f5c1f8b2dbc554962717e3b45cb9a9f24edf9e35
GIT binary patch
literal 141416
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%0D0vEZm%K+%#f
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

literal 0
HcmV?d00001

diff --git a/docs/_spec/public/fonts/Heuristica-RegularItalic.woff b/docs/_spec/public/fonts/Heuristica-RegularItalic.woff
new file mode 100644
index 0000000000000000000000000000000000000000..d2c8664593dced0b39e0d3e0721613b5f28254d2
GIT binary patch
literal 104700
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
TBzJ^0kbl+U47hQI0Kk6%XYVT3

literal 0
HcmV?d00001

diff --git a/docs/_spec/public/fonts/LuxiMono-Bold.woff b/docs/_spec/public/fonts/LuxiMono-Bold.woff
new file mode 100644
index 0000000000000000000000000000000000000000..8581bb5aa4584a8281f1ae761b5fe5da8352832c
GIT binary patch
literal 26560
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
O?K_dUKMR8?&Hw;(z{*7c

literal 0
HcmV?d00001

diff --git a/docs/_spec/public/fonts/LuxiMono-BoldOblique.woff b/docs/_spec/public/fonts/LuxiMono-BoldOblique.woff
new file mode 100644
index 0000000000000000000000000000000000000000..607ccf5cd03005f9d9c48df3cfcbc4f3aa724780
GIT binary patch
literal 29480
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
U?g0LW_<pk^zLkRZ2QTd_e354N3;+NC

literal 0
HcmV?d00001

diff --git a/docs/_spec/public/fonts/LuxiMono-Regular.woff b/docs/_spec/public/fonts/LuxiMono-Regular.woff
new file mode 100644
index 0000000000000000000000000000000000000000..a478ad9ef2dd7c8bee8169f319861ad8f20fb81c
GIT binary patch
literal 26432
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

literal 0
HcmV?d00001

diff --git a/docs/_spec/public/fonts/LuxiMono-RegularOblique.woff b/docs/_spec/public/fonts/LuxiMono-RegularOblique.woff
new file mode 100644
index 0000000000000000000000000000000000000000..26999f990fa9f9302762b55318c27d4d24f26bf8
GIT binary patch
literal 29300
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

literal 0
HcmV?d00001

diff --git a/docs/_spec/public/fonts/LuxiSans-Bold.woff b/docs/_spec/public/fonts/LuxiSans-Bold.woff
new file mode 100644
index 0000000000000000000000000000000000000000..162621568b5307556c0cf0539c7e4ee3b572564e
GIT binary patch
literal 13592
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
BcHRI0

literal 0
HcmV?d00001

diff --git a/docs/_spec/public/fonts/LuxiSans-Regular.woff b/docs/_spec/public/fonts/LuxiSans-Regular.woff
new file mode 100644
index 0000000000000000000000000000000000000000..89d980218f7aaf5454a10e43ea70f7dcef069787
GIT binary patch
literal 13568
zcmY+rb95!m_dR@XoQaKzZQGgHn%K5&+qP|66KkT0GqE$Vo%_r4`M&?Wwbt&cz5CRu
z)4f)ouI^Rkt{^TB00O=WI{<+3U#%|mfBe7p|G$Wf|C9p&fOB6e-hWU6$xTa$iiv+|
z=U*KE3q*ht0EC31f(ift1`hy0+5-SEm^C}Wt`aJ$KL7w|pD!D_FEDk0IzAOt7+Jow
ziZ8D41p^0E8De8wLx(Tz`HL@n`Hf=obSE-)b0PZj^ZQGq`~n}%IZUvbgSqXOb`JnR
zyaE8QiP3Og!sdp~Uwsj-zieRsKOmdic$$4_U;c>d0054dVwHDq3sXZA0D$4YaoN7W
z0ahEJY4Ig~X&Yah;0t6(Q&9O9wk{rD+WS`=<X_mhEus*!u{Zv*V<P*q+4{nD@=IZl
zt)a))xXch=oajFQbHU*43~f!nv@bhg3;+P`q<H5R>tOHf0sycyd}&|t0lP4exH%o1
zOuzcFc6{|q_z!oYB<F7bi-k?{i<5kT3>Fom)a`$<u-Sa^$p2z_Y=BR5H#PdYHn#un
z71V!FVpXdDs)1hs{N^v3{jY96uax<(o?Zerd8`{7m>3xBfE&R=AsZMOKn$`FnE~&x
z0kArN$}by_b=6dBMO9VwG0^drH-mtpkP>Vv?y(t-r4*Tg8F#RY3NUy|rruO;nyu7_
zsvL>`x1)Hq{q)ZgWA2lT%0=v~3~95Oh?{X_X7t1uu%DxfyA&ETm+o<X4M^F}D_dtE
zjk6lx1aiv^f@K{~mS)UQHm8xhYUxxe!Z#N2nU~G}T6KM|+Mgmh`j@v8`vT$PQCe4K
zWoL4=N|^!+46Ub4P;~tm_Hs>_+Ot};H56w>t_#UK6E{64o+Hfz&V#Hw_=j>2X<pk;
zpBK?jy*qECPu2Jh=Bo<p+-{A!R{l2j?fp&F=N#Qr1lRHR3OD7?$IsR8OP|XXCl#Ga
z#EbjWNKF__E2(D7v_ovxZJm|eN4ihv5}q&JGW+QDqAbN2#;@pOxN_+B@>cLOV_9~w
ztlQKBZ2t)E;4;hEwsihLI1h}dJ9VXRLUFExWv8ETxZ^01%-eCkCXJI+xfbJ#=4A08
zNN_@KW}bhRFgwJLoN_heO@mu}$}XF-eP^5Z*)i&e^knRwwsT215g>V|7Ei{ouA_-N
zHjyve<qI{Zp`A{l!tcj9LU?UR6o5#T5<JQVnr1F|O}0>vI|o`S5zHbxqAX!%yQOCE
zYyD6)%#)Y!HtdC3u*{elatV=#OervNGH+0Jz!%#RkmK}Av7X@nVHZun$~&=Lg7Wht
z$A~>?a>%5PTxDlw$C6e+t0jV`X_~&Lr6S-GV*x?p4a%qYS~s{Jsg9rvx8Qa6XJ1a0
zy2=ADQ|&z6&p)ydquYjb;g;X&#wzz*<&CC)^34L3po<WPVUZi%Ul&7uV284x9|ht<
zJW#ungiXX5LppG--3On8pIYdMkp_u}ocp~@a6zc!^M&tPmfqIyu8-$NFtaN5%O6gd
z^oku4T>A%I0k-88jN~BC!wm#syxIBKJ$L{s3>}YyDo}eQ5mv}cR2)0?^QsplZ(y0Z
zCT@vq1KKt#9zWFwyAhW#WR<&;WTDn%<|@U?p|JE?{;@~rnOkI;(Pm!q1;`8BDFvtj
zo0W#WPgOWLdEz^M9aPQn1^Q*+Oqhxv?USav6N>OVa=~ZN&~vEY!_(%g{_4h_KDFw}
zAvR{$<JdQa%e3D=q|%Gq*{2fVNhv!$v6t{>T|czg7JYKoa4YB}tR+aV#cS&~pbfW$
zw!vudh50MBifhOVsm*DFG^hsq*KZZ^7YB?shK;v@a~W?@A(Jgs=l7rFPi3gXp2+$M
zoyj#rCbkajSV^7VrXel*V$7(s?u7h;jwA}E=4vEZal%rWLgwgtiZc}$mj~O@>Mo44
zq%)G4rpAW#iFw2+vsbxC5g3`xBY7fck~$N3(}$WotMPO2k83n#GW(eN!;6+8)yngh
zA?WvL6Xm8m`R-1<iTP>%X#8ZUWRqlcp6>tYANk!Sn?H79ngVw+hc}mNyhb8<Q^bw_
z^ZQO^=rQJ&w(d4cyS2bS93rcMX~OfC9mZ)o<EMPki+dj=aSks#N8{V~8EY=fplX<l
zzYI+dM;jevT{?l$xLrEJ>3>h0zT0(8U>|rd#a9c{$PKO$<(`&yqwuUMgnL!e4<0<Q
zc=le_{yxUps{w?EcF^y6tN!+jEVF>!o-4&IW$I5)G~O-Cq|TGHL$${I7%y=a&S5;r
zJ-BiC)VJC9Hr%(P&Ac#a>)y_yJEDj21Jb5nsS-GAjPp7phYQ1l-|$C3AtMlF3Fm-2
zB8q;GU_h=V`nNlCkY;jY7F@%p7Qt9ObVuOZ37qZfPGL;YlrZDxb9GONA6k%9cwrps
zMo;Dif`FF~Fmi`!V~#@vM($+<g?$naTp%%))KaN$EP_w8;R15S5{9Lp(B)C2++X?j
z|MIcXoZ+0Yfs^AMtl`d-6y1bzf`I`riuE0YM21X91OVhsLR<f5Yt%Q`5+0Zu80v~y
z%?u7+%obwSHx7WngO}Yn|6M~w0f*eoN(7{2M}mZcgxZ3Jx3L8M39ur^u?K`w24i?P
z<^hzy!OH^P5567#Z)^htvj77eC~+uc3*asGfDdLEJQ4jU5dhr~yvYOSA2udajp~jv
zveKM-g#WK=ke~)MV=$OTj<7I*Vdfch1{wn)eQZAx9SXmLuRt4pGgZ861c(=$GD(S3
z5DkRX0Zv3Q)i~S`<r(Y<^aT8X!o-FsO3aS1Qq-0>n%tg{V&tY6s_d=^a`d+Ny8OQ2
zBBaJ>Dy+_MGPKs;wRydvB`D3Y)H&Ue6d3IZ^#wrzzY2B|<{GXe#w$)TRy&?UM4|o#
zk}+xil+9uQyx-Cj{qLHDAY;_vd4)3`=)u9WIb?1@#~^8LGLU7#9gdC$B#<WnG5yOf
zSJl#eK^#4`hb%66jvNls6^GTaV17J=9-GOMX2gwH7Z0WuLbrs@<&c-~O|$=qy5;zu
zRIv6bE<GeIZ-IkS;%X+lx?QIiC)!xFQ~}&EmgncK6H)5YnDVJW<oB-K!^WfmBD-<5
zJ!(s|)@0EM8&2L78J!uo)Ecy!<QpgC>T;S{R`LhooWbG_b;@<3b;({fDO3eKL8%t5
z;Abi+FlwAou2i!y)T()+v?@eX>2ST`#E5JtWe(hjilL$|LYhmw*{;%7D1#EGR8pNr
zJ=>#hN1p2@XsH^sb6ftH#@)tOr79sB@iJ1-DmAwfE|l_!a=2Dx@sO<FrUXl64J3;x
zIxUSW((uJ)`QNsP)53)tSEXt;m8EG{@p+s0I0<}F&v6cU%EPjmws6K3S*2RHk?A(@
zOlAjaa@KiYRG>?SWNtOI#!}<A61zo04D<YWaI&N|Dpk*K7fSX-&1U9|3}u@aCSphN
z_jf`^zh~@v?i^0;ajzLQKt0qsohM2<zo*3{38gm`h9gTB;iGW`{&_@n!=p@23+r?!
zLgkbEE~Nc4Q^U@t_ubgOV^&>S?o4V<oN(kx<;0ytbC(Maw^m}$hM>F7`cNQPt7@}%
zHIW;?3f<8^Ki@r9lM?=}C8PfJ_V*J*!3(Dl-#+wh8MV%OyR1@??_YG&bx4(;7FdNe
z7fIA*7U^=#a^B16?Cb8b%p%@1lGC8{&RNnY?w);O&WrAGxi<o*g}(TW7D6J<+8=i7
zP)-YaLUvlQ8!fcruIDgp2!CeEX@UwYO&*3iYHQfRG}-^$mqt!>M-ZP?qv5+QFVpy=
zgO(y0@y1Id^DdiobkN)_H`}gvPu=u4wOId!)sAw;rG(!w{n?)jnYpz`1hsLxc567N
zE2at~RTwA(ps1{&Q8Sj;<cVrm&iAGW0~~SoxToZnlzsD<*?bvi-@4+H(XPDtHo2zg
zS9G;R(_Di$GWg%Mqhwt_ihD{^{~biQ9-3&khB226Mi-sYN_ob$x$R?-tEz29|FL@U
zLA^CuaS*YXTIPp$3!#?tj0j)(NiB`kno@j@9Nvy@O5iXV45t+~+=1wdWMw^kTIhxS
z9gaAxu%#EdL6TY*W4mS2{f400di}&>FY4Nblshs)!7=rN%A=~f*v|#pR<GHv(oj0}
z->Ja9%K2HF?@u+{%Kh^Z`lSK(=`L~kk$be4ERD_Yh+0oVNEn22bCRml%w5cr*s-Q^
zFWCVMqm%a7wOTg);cu16Em5lOD9OIgdjvUd?fRzuY0gvQU7+=X_E?=8XR@Pqu|WT0
zq4TtwATM(kWMd#V9PZHS-~r;0D?H=bwZE)9s2>3?`atu-B4=8Kur4u%rgJK7OxLby
zDvY3&yUOj)s)U7&rH4@*K0#b)8a7@+t^c)ujQ1~Hodf_En-dO25r=L?xmQQmn3c`<
znN-mLUFUNy`~ZRgnK{m}x(6RH1OBJ+PB@2rydZoh7y<I|9abkhppQJ_0M-FA{5bI{
z`7z=za3>goB#{OQ!~s$#4qzWy_ztZTjFA%zs*@c!A4T{MEH{LHvdDF8Vl`T3|KSgg
zfWGDv3Pr1OsAvw%%tULnM**xfUjvl2aLhz6lY`fg*AzIJk1Y~q|AvS~!q|-rMgP4)
zW&gH_MSVJwhs>K&H?qUj0q3pxf&5FuT8pnqJ`ex|fdEJz>#f?b9zVs}>QtV#E?sz}
zj>{I-+An9Mo6QX2LMRLotYNg18^~*b!YOh>iDD*>LgdKE7|7~mHYCL3*utiJ<9i|l
zR5Uz03-g99IzmLcJu0r=(I>x;y|-n~6E?cqt7abaK{;Kh(q1S(D5*&!MDI&3fJ7Hv
z_={7p>di<eDGFWqDO8`*h?4J3gN%fWXQ<iT_z-^l60KF1YD??UWeq=92g|5Q?fN!k
z1mql~opO+$yZ=Po;f@CY-}b}f+{9^#q*_80ag{@!gd*Vqg>$r9mc-~|FsV9$E4uQk
zX|Rb1O~Um<kz}e^m*W%7S}_5%GGoMdUeM#`4j(+{MRwyRa(0mstyifG(#0-_#L1hP
zMUqVrLef;os8GGbIbNFeDm~6w<kio9nB}wpSbw*4hChXuAMe3;BYWV+ifJB6vX~Z4
zC1)5knL$*Lk#VrBiZHNc!!X08;F^fk-;hehjVn;ZWX9l<bRN9hz3pAN(O{+IrDcDK
z?d=;G7ZuYbnk_wH?2j}5<+aSmlk&NDyJ^h6NWy`>tmjGgFnnH-+E%sAb@Uret7?|Q
zlJ1v&NA%~_Z{77d^<33O2(H>C=ZNyJTBBXEAv-rCwFJVGR76bvMJqvaU67)gAhDg`
zpAp4q#|`y%Z<&;ijz&}tQe+}BfDWY!1%DhXLPdpL3j8teZK6p-o)qFHCYD}=@&k5~
zApUNWXu`Db?Y)@6oa!@4T6x;ar=%+0h03$dEddLo)~v+5<oM9--zqiZ7%GOX)U0B0
zaR<*mPp{a&jP&e4j%LxpW9uzDb$6EbHktI7q2&vYy~O?Gzcv@F1|#FpNmz6hInDcP
zc7}usEQ4Zi8-M<UBg*|V_B+ZfkiUun9?51YGy4uqA*E=!4II>{-bwtj$uQAvjG!`k
zzKHH}PpR&(X3ZK9b{g*lz6~kPEpt(wqF2(PyBH#y%t5Ax7w||{CMy3>v<e1FKMbG~
z;caT(C2a8K6Tj<y64A2<MSukh>r3Ci&J`KV<++;e!)z5PF0R`vIE;xfq_bAboee|C
zlmyjn7V4hmaBy2bLP!*ma`3Qhp%Pl9Oh;*QbyIJkAaEPZETdbsTUN!jX_7cM-8t>L
z*Xbt`TK2Fjv|GP-IPUBDw47f$?z_=@JA|gR!+{7u@B7A=1cH8)dXfub8_(rVtxdOw
zy%?$F$)7sfN}9f>3$ucbSM@a&o7zfBEHAN}7#Mq~y8<gmk7B05w+cp-7gFZRhivW<
zaEWB4wpH{%{BJ|5Y2VnvH6n}Vlo7beB2$V86X!?<<%s+ax6(Fl^HBFXA*CbB%DUhs
zepqXF%<PQ^!RN>14$tDnAG}ta#98SfE=dH+$J=4zrzUSw^AE-NnM;^bJvEra>GR*s
z+Wu8bwaI4oADCkN-D54B-#Vq2=L6oCySTweSFP>2R;8(u?{A}dF_|iIRHx<odh%zW
zSFhh))w6TzVJ?csd|q(N8?Qt|ZM!FDD|x<d<$xUn!*{D6Die)Rqtk_Jj1eB?6yhh`
zdz7QrT%{09@EmyyMP(9{W;}+_tkEe%?q%J4-uD^#`EHlo2x*sk2()pR0LW0qp<*#?
zCH9St#4Yyzvy2H{GrzunsVnJcJnVG3-f_BySN=T~dP9Gnh!LTFSx9mPI=hZ_ibKtq
z&YZ1Q7URavM+)N>hRJkY-gU+1{qcm7Uuww7wbJOi<c|n{%-?WllppCc3tx>spUj5n
z<qGwa-;BuTF(TWID5EwBVBLbZFrbo^iinI+lrt<O9tb1q6^;DH-vVGkjo%^WV;F=5
zIU}c|T}TzwpDi5>KXX|*36)zwP8Y{7%iupKi<ei#w8+nQiQ<wUN}jr96U_MP4*Qk8
z!o8)r5IBIg;9xo2YOk$nA=q7|qvE8K^0oYVmP%&vUT2hH5Md2h()yAYcpvUxe}>nb
z7$Cgyv89~3;Z~+ZAAqG86twkH{icSAi2CJo&zH9%8zsaaWxzQu7y~XH3HY^z`wu5l
zseq?QFUxAWxhg}7UJb*p`BYH_j@`zq^mto~1Aj$t5O-&G4vp2ahc)b)PfEfwHMp+6
zh~1=_bS$n}5pvqam-!yzag-z=k8}0Ma65RGKl*|RPawxGeB=yQzW_6H(GPEEF07+f
zBV4iMv$GLrnQLf${paE**u27zcn5|C2=$8z++nTu_y&qD*#i(qR^N|d8rBYe&lae=
z$m(Z4G+p^%e-hZ;O2Sq=C;zD|m+fts;}@Tki|8hN$F-1(jrGh@BDW;vpA0C8m$CNj
zco8Fb1ofle?}s5M@VlVITXE}lGjV5bWD#a3)SNw|3UviFAFiuZ(-r78TmS7UJY8(2
z7q-bM)%jfuc!%-dd_sFO3_4{z4?sU$_Fe|NZ1@w>+olh;`(SqpX>UXaYUE1sKsxg}
zI>8i?quSA?IOSqT3=~b$9Me=Kg;TWQ9o>f@hW^&-RKFScmu<gz+v&0Q0X&u_<DPjm
ztjJX?2*Css7gvZc29J`g3`vnp`av$>Ng@@~+^$UG@EFHWHA*Hy;hTpvAPb|THdT=H
zqH@G2uK@D6IM(mK9cem*4E;;H9Z^EQZPQ`@I{5bXnEClo6CbwC|2BL}%}PkK*?RNc
z@R+@wQQB@p0gBq;NWy4u6gxHP*)1R(PvPAHK?uYk(mPceqJr<EOf7bTpzhV$T3%Jj
zF}x!0sl;b%Qo>7gHG}`JxJT1$`VdDj2KU8qrV~Yl(QaMC`+hGd6z;W7bG6uTf0VHO
zyWsbmySkzx@D{nTT0(e`_3mmTqfP!suZYvXa|H!Djb9%mIJWb+zI52d1|bXBlkJh~
zBJEEh6<`I)O1?t6!~66V!_WFilH}_FQ#fJnIF5Y=F*7i|IHW)(9(uRfQ;LNb1Fhby
z&NW#Nuw`G0So^IPob2#^$7XQupw~CZCp4K+uGow*_R{$uww#foqi{`gx%rUZu9ObJ
zk}Su+w!Yq0bzLqS3Ht373l7zCvxXu`z3Y5Ut}{7Xy=z0dU6R6=PqIWyJ)M>d>ie!(
zuL#%<g7@Fb^nHiq$5qtz1VM8mL6pZvI;F6nDU!`xT}RbO%4`D&hROs0i#nu99|B|N
z9oeeGIxROfDLpkUH!VN^P?#4OoP?Gv$HWe6Gv`UoTGDj3G_$SG>(R4_Y342r^i*Db
zHv8E?DVBY$e*dv)17n}!e66;h--x!f$ifbP@D<H;yr<1X(w!h**Y2>R!+>wTu9E};
z;b*yoL`*<k!q@{p^aWx3D@Rh02-ITh*m+d|6$)=&MvQwFOuQ0=@hk=wG!bwZlc3_H
z<R(DUhWL-))Lc@0pW{=qTX+2kU-K~_CU|7q|4QBrS29*K*A<<|T8t+V-n@#GI>w<X
zs8ATP(-tTlr&h~~oINmP$=?-eCDr_g?>y*k!=jGH&>&8ksh6huVx#k_kHh*A>#rBO
zy@vl`vguT~OZaqjzPDet4NPQ@`^O>dW>@P}O%kdE?;FFapr@1OOB!o;89amkbM1(X
z*$kf+zwPS8<g`S7pLb#j5~5(Q-P5dYSB&Ffn=mw)h$1HCBx*cL{38;WVvD2%9m8<X
z^n!Y({IzO*_csNYbT4uWjbt<yRMtNW3mqT)@@x1$EQcNiD^{#<b4w6ap4J-+b<9(t
zyM*r@FA5eOk868K+dNA1_;U8o7T1#)>YYoB?+w7(IEcMnne-IqbF#Oyh~0R;ue5%%
zlIGM{an;cF+e%40>r>HotqAczDkeQ`j9W{D0z|#`tk6esWYAXzY%Bv2_r@g=tWPRA
z{hItN!MlnfLk|yNJnuhu!VL}%76}$HUUV3CsAe>m@ws?xc2s?wr`rLU=^4e3%*wA(
zJ)mpD>=5xBn4~y2v4Lw`Ycp8MCo^>E7Zua&(!Aesy#+MgbsSqJP-023wytlT!YGC?
zK1`83fW)O@8UfFl6uJk_B3pU<4Q*{|`zY?`LpA|?@0gqmN|)&eV3-5H#|DH8*)NUx
zX8IHtRVPZSn^hppFfkr}Fq=4VZ<t5hfRRU~>l*MN4P}isQxfD$rq6YH0lbn`4^q&V
zlJ8tFH3l#a9X41k+24+COTU9k)*wBnWMuaCJfevVZ|0JAN0L|AJ3g0VFM7JwKX=X%
zb??%h{jGj=UEyBV^HPT`%`^}YLApbOhuecQ3I)wiu8DqIhL(A?6rY<CLh#a(4+`qR
z;o;JtJ|vqPj%Edd?S`xb_PAJH`J&nr4J4uJJZ7u3c+A}P>&-v*>o8;FPYoT%3?$8i
z@R<KqI>Nj>A@O#j<f7J`1eJT{Q~K{XVu75hK3>szx?SZIT1(fbPfwQ<uqCo)@&?gh
zkgdP{hzyWv>D4`c5hIcnkOVqdDhyaj(5{uplMq`P-$vJ88tO0M54=(!UWPpzkG0u-
zoOjNo?K#Sr5qg-J>*}1<eW*_(60rI24cBTjH21&XFN}`$SF9B(Fiz`pxP2wQM%KUZ
zf3@Lgeg{EFdK?nH-7M$vv#$5Fxh?YR`+NUuVHo#i=(fFbJ#)+Vf4|B1H}dc7FtZiZ
z@@2b76vX#-*uz6;{=t+<IHFT3;l_NeD%&Wj+Tvn5;G-a1W-NNC$du|42nSu&6TEd+
z6vPCv%jb1K#ZwY!0J+t}qFsut1?X(~?%h55VKQyX^{_3yKRweBH(e}pY7j#LuYU;K
z5aA;6<H@|XLS81@(k0s^z{sRAE$UnTgI%BNs)r}Ha}p0<`rF<3S3@-A=KW$x$g@Us
z)LnLs7qFa!$M+PmMo&aj6;$7PkIu&Mz2y{gB~I)~*Dy1o#b>8rfZuvmH9}y%zoW^B
z^-bQ=L?S;|En%U{;PIw+e@qI^i^qJrjeLtIf5~ce0|?Hf+$b)zR)-2_xo;E7hdbzz
z8FE4)#mDN6KTC?olQ*4bx1YII)LiBfDcwT8lvfm{-JA;jIVxZfJ)0xojcL_qZ>FDb
z5JI6FRx*Y5`HDyv@U|_mcBsF<8GD($(WX-m2Z6+%yhZR2r$D@~ixFS!b?Ky^F2+ht
zg!_R_14GU=?>#dRnKHwL{?F39tAu=x!7N@E+-IA^?pr)ntZVq%UCrxee_rto=Q4kg
z*N%52T8>4?b^~thecHlCLlKec4~%$2Zgtm}mvaB-xFA(p)mDXCojIRaJ7<NoE~?n8
zrpe@*JMN+jVLyx~1EP_20;8)9a26TvpQDGx{=Gfs!-w$m($swoGk6USwRi`1a+KZe
zH)3$|orI(WZ-U{E?WpC=yk=MtLdWuhvO~H;3<n7mGEwKRa{9mW)r?{#+uNH8BMK(*
zyx7Wxa-??c3>R>zPui;Z6+Gi~U(@*8L7#=rdfA%2r{)n3&7(+J>U91l_z8V7c7K{L
zcR$RKJWtqR0_Tq}r)GrB*PglFc;6%*Mwzg$?cjJH9=zbM+yl>xiW-)v7qx335GBdC
z0=JuDuDUTDg#vZlCVgcrUHXM|Ie8a!FB`egDEPSO{@uFeb?IaTdwsByHT2mlW!}A{
zi!h9#*If1guxmj(W-jatW?z={EtRhb;N!_U(+p<8t0T!FM%on_da)2(DO{AyM&F(D
zroqk8M;=`*)79>B3EfbwUM*(?-B+^qpP@-V)2DuPSR{@Lc3j3qc+gg`o+S9bG_b*k
z+$O|(d-!LlWqUIceGK9>^hHM~dcsair7s1*MBz@AER5Se;dG_by9&l?O_iB%EM#pL
z%U#OGD}b=-Dii8HX+-Y3Pnq;n3!}=!ci3xZeobm(AOKZE5O9yZOK;S!x#Q{Jj}eGP
z{>2ERzLuz`QEi<H*JPAUgk+p)mW}}EZxAhjXg_|CEW#-KDlpOc!HZ=NSMq~5W3a9P
z$=@)4_jY^Y-}KDws#&g0hw8<Gbxy?J%kW@DV}He3KDAyeNY(cWNVHt9TwPbeQZ|lo
zX~C^?x{p=7f2XHZ{#g9E2cWry$XG-Lwd4<ed`2cOMeQ3=3U}hIycASJ2XMcyO#IWm
zv=A7!sF2BHI=PEQxhd#c<@E3yr!CT!%lEbP$&mjypYzdX*7Uje<Nh)|oOJ<sh;7}?
zj^}qnwCMJ~SkXKZliy5>j?aae;#s(YCQt{Y*PP?`T79w08_E>zQe3L#R|U24%tEv;
z8h4-{nXh8;|2F^by&c@YRs?-Y$kWEoGyBr$8+tu4Pe3T$@wy-b*;Ck0X9{MDn7rHF
z+fW|7h}%_=Of>p|*39$NQuC+Gr>CA#|0I(!e67O5e;PL3RiM}i%#bZo3c_$$Y>r>{
zvagSB@wnCOx?)daba^4O;$`x<J|8SRsFca(T4kp=Ila0aemohX{^s&N`mNa(s%w!$
zD%k4D+U@3iSIy3j3}q#UaC0Ov<NHGj9w)K}{EQ^tc*OH0Hkv9*qLzmc7`2;7iZ;X6
zlI<dZXhK3pLBj`c4zF5V^9m!l@=N2W>Y)LyZX<kWx{Ba#_Z!6|EXb?OP-9?x&y_M!
zk<ZP+?~374*rmohJ>`@pi@Q7+oL$TF&3Gh$$8Lm{VyigrpyP--@<aMjeNYqUahZb~
zOvZqlGPHgzuFMD)Z)PndJXl<UTm=cbX`Q7^=ygRg$%s*-IeHV9KTA#T<MMUn!}oPn
zndWNE*Y^E+o!@35EVytwHFoo_nZz;X&p7J8u)I!vIB9vzh2fi7TU`>GrXz6r(>=6#
zV>T48Tg(HrckHR+*KE6%{vKUnJ>E0j7pTbT$4QutxRD30RQ4iwm@a7FY1H?}J}$f4
z$pk=%F$*p^f>{Ti4hmBWT>Wf13qm~|Wx)KWth1&2h@V@j9NMAorNboXj&CO|i&^d9
zPH*>{P*TWAiOdi4_N#rlo=Oq?({~KA83375^Q<d=e&?f|Zh4Hjyq44}QcT}Mp&Vit
zPgO8Mwot3NgJ6SCPI6WH9jvoO7{q?HxCd^b{Z07SA?Xb7&`Ow)w*ypJ%XQpWPm)XT
zWgOQ)4Vxk%exmdFiVl)Qnkx*#*D4e+-w`b%?rMmJ$XZeKxKQkkO<N1+L^(4;-&wzb
zk?piQ``iRLWbAs*?+!@Vr_yOVkn-ik*fNwa@q<jtK@kx!h(qg8!?TFj%v0f&b5O4v
z2D-ao-a*7a{=}cS)4}^WJXwAQR$X2>_?iSu3)B&c-kv$Qp2l19L_mm%I>=RLozpC_
z!o>u9%XmX$ImuM+^ajsec<*_0th;hN>8=*-!_g=Q&*P|UcRsV<g>38R_I<p+0b_jo
zgJdQ!kBwE!*Pt~zk9K*Q^jB9%AtxFC<j*mr;O0!$30*Gu=Jw<%bGkCFuohnP3&~In
z?BBX0jkck+GK%FA#@gP>`VYYzdxzRzmQU^B6(i2SfF<8&Owr$V3&w`hV~}qR=|boA
zI#39tsD2_kDbTVvA<D@)q_Hp2a1L`1qPbMy5gU;X;6&5%KyL0u2FfmO=pTwRfB(g>
zR!X^pjmPVkyj3Dn8aiFQONlwS(!(#@r*3n%osXcY*nHc|>vq1AJzV4xQip|DYT3&~
zx;+i=!xgjNJ}~q;F1kW%#ifdm4W`CZ6v!SRl{kz7P2OwoPkua=N|tDna13>BAKaWl
zPel9v473dnh)W(19ryB4CzezY!WxE7`H}u83#CWQvz3(;p+|Y@nTI*;tfGW`;!=`Q
zoOYt-0@K4<F_KG0HSTPT0_y>_NxNj${#UuSY8rW8GWtkPzI*u;zWvBUffIS}>)+eL
zZHv5}d|OU+{;IkD${hEsEjDWy6w+FE<7F$FqKc6j(qrcq&6MWNpF7y^93A5J0g%ah
zbzJNTy~BHHo4%(8@il4{=~jzyg5Vs6Gj#5_rZr|pgOxQ7QPY1#Zgi&l;(DZb;nLsD
zcl&W4azee6)2e68WZEm&HMx{UYnf|vQzAL|1v&XgvkSW8&hzwI%^sda2>Up%j)U)x
z&hRcz%{lG6M*B7z_wiZj!f$=o*GMioAup)@*^`=OC-9!xs}ONZwU*z$@=os+l4<qH
z&UZxQ+@5kgzC2#ITt-9B%o>JM$a`3RrkC?B+Js4FU3DbPE)(YQY3_@5Tp}-`399Q=
zRF0y9u?$!J+&!j>3h6`h5F4ars7Itmxa%b`pg|=Qz2%X<t(QQtj_TnH?S}lP7%QY_
zzS~Q)3tvP{{*CGPd(j!a>3P*1l>^3={LHj4`3&!Gc9<Jpx8Xr7&KVhnj5YA{HQyfu
zbrQXE#;6l+Z9^a5$p8G14<d`D-mH}Ew&E<mTOiKo5!=KyZ4-BN4Z=`iI3{W8GbHSO
zy<f0i@qry!2$#GZDO3v1R%>2n(v%)|k(-ozed!G<&j(B0*lK#1jy+$1#n%gBRJ+G!
zZ~gv{1&i~Ud$c<<#u@6ngSp1D)CO_$@C_!WQRxr!ZyvlCWhDIK`W1*v)LsC|_$d>=
z-@i!b4sp=<a46ZUQ7YKk$M<%)()WuMBY!FE<n<pDXfXFUc|4guJp3_!5ZO8G;H=S)
zt+da(*d0B*MPAfKcG@q`IU>p<gFgwQE-0QTI5AP!D1rGmiWY9M5{(~z>wtw_K+}UW
zIU*%Cl<mWJ^>lgIPRukJLBUgWlA_dq12|+n!9G9TpsabNg7)woLOo$8a0_{#Q$diy
z$*MoE@@}*mU2j$I1d)+<R;{%P>VMk&jr;uQ{99uP{m7YDTi5sP-@;$x?D(xLe(&oh
zV#4@;3&+$gSZc0L+@oQc>Tsx%$c3((%o8tBbjkG%i#7?kiT|hxROjDzdg#@;;<XSm
zMP9#BtsNegHkUnrcu=FQcjIxEe<1=Z3+q#tbF1DlE*l7VSjOd!eSda`Bb+BE))%&V
z)r;}`M#+{DxNJem=5$j#6y@^4Q`k<~+-NkdSd@f8&x`8w;jyKP3ahH9Zm78xRzP!z
z=^i1DGY&yJXBpTIwJ}1h-aW9edA&{Pj20de8d_;+6+-_f>{|+07OvWNLHRYcB}WY(
zHoJG>70maSxrrVE&pV|cca6qN&lKTib&Pddh-xx^LAR%`X~AFMAG$H%<~Bi>@%0Kl
z$$-=ceG%RO%)rdFCDh97Il?oVck~6@8Q%0n3RAZ?shqPu`W3hXuh+H+>H_G<o6rJ2
zcYoBgmNS^;gu@W8ED1V?SUhram|)Ct3e8W6=VmLXU?C&xA*v*D7b8Xguw956<9fG$
z2nWkUH)s6~O1FsQz#gsWO}wPMDvWBL@w_4zRTQ+I46eJrX1wu!7`#sAdco`lJKRVi
zW70m7d`&3xSw!u0W9V`{U@IPLy`t@Wr+JEVa<t{&%N%x_HL*Ek5W`$Fl0i|s_SBRm
z_?xdt98T#f=Es)&wJsU`E3a1MJc&3xh+3Q-Rx6|;&A4qZ@9LyC<5T78Fz(6H=W0CC
zDSM_<Gg!Y}(EEPwC@b5Y`^MVLbYLfs|8SBr-=uw&@o%1w1Ld;MWU|7tLjLDuU{%$w
z>J?swK<*trheF*b{|#T?y5*0)A+)xd5Yqi*pPcYxfp~C_33&A+=^iV&M+zrFdMnRt
z5c>dTFu`s8EqEo59~)5zihaH&Sf|ofKc$3Cp3`STI{wJz(>!Tn{!!%n@XLmDIZ9`a
zxWc;+!>`U>vfyly)b}P&4tz;<F#921KkGRasfwfo1lIH1oWpp<v}{E3X&DXC*@P~o
zI>n~Zp*{~+0@M&;A-D&jobkT<_f)VeRl>I@WJXzwf!*3GK8b%?HqRQx^{>(243h8w
zJrDV6fUqP*bm23>Z`G9~WLCt^_sPt#xvW<NvGWdUV}6l-gPUnrzRaV-FqizX&T28*
zOxtT`%#e>>>#O)V&0hKg6SkCFXD~JoWWiUPaU&oPC-L+R-(-0V^k1j7=8V%B87qdz
z<1)U`HM(!p*_CpK)Kd7+PZM}*bH2pzGal_S%0BYjU}xiczF7RK0%}9b#~1Y{YUBu=
zJ4~NoaDte}h{o_`i>JaUd33Gnv$BC3Y+IIz9@(*k*PU7p%RezJ)8eT|!6>yXG36UX
z@fK>Gp&Le{zK!#F{xPDK<<%mDUa&Cq?Y%JSeVZab#qrUvR<aj4Gzuxg$f6D&67DIB
zqKJR`46Hb8ZPEO*fqTJ^H~-uFhz?>dY&bLCEm$4EOp?CAycaGU^7?bjaso}4eBJ<6
zaTs(Q@O$8+e0xkF==bVsk>?rlor7n$o+1Tgr?(S&Nx2>V@+*H6+#$?4wW%jBewpB+
zN|3INfD06ysQ=()Vsy5>)HjAeYjorywtZZBZ)wfGyrk3khm^e+e{KVIuzTaL3A8`n
z_~mGSLw_S<zAwT`FMVJe$4C0#;T8LM7R<fZ{!2<z&o`+r&k9jk=L0YohTr}okQ3&9
z<n==Bul7y(m*XtX<b^stVLWkX3~)GpkQ_OF{F8b#j8p^-60Z;H8DSLBSAU%HgxH8h
z?F?phmSmaXw0sPI5b;uCb$9<s=ENrvNO+M^h;(-Xdy~)%{2*NbRr<4i7cl81$DazC
zvR_bnc(~kXf9XoCiM$lmTg-ckFcuQ-^r+U_tF?li$l#ldCNOMKe`~X>gpp~a?t%%=
z?8k^KAl~9_w{Y0?C;bD#m#H;eZM27g1^pAVhFwD9f`0qXt6^ewTZyI1RiT*r`JoH;
zZ*kGIHQY(6DnC?OJi+oDqg<UT=2}<G`MkfT=GeLXrcQJeoVZIHqq5cE@<)713<Ke+
zbLpHW=~1mGXm`_zUBb5Ju(wX%YJ@dfY0Im>M-=$!hF$n=ml52cCH}VW7aB!t0+t8k
zFs-qkME|)T&dc8ey|uf*<u^z~xOoUfSU6-ZZXp9tN29MVmmpKq+$LT(!q$=kP(;x1
zh!b33Abe=6QzyC{s?=e?2g*BWV}J(z<pyG-za{~e1Uh&SGVv6-C7Tb=Kk;pZm-Qu<
zh<f2Umy74($<B3Y?Lx_omlEEryC8?EiBtF>;z@P=rfAm5Ck|cH;k6Hk{Lu7cp$4!w
zE2c_*XuLesxTdRzlcS%KnS~@Arm2gBILYYMa>)C)<j{Hz<ZtZc_$xzJD+UrW4iYlv
zhP5H^RtRruj>k!yKGM62ub7j_)3n?b+%sR4z~c-Vv~vOiu$W$D{<k*ye{1Co*f{c>
zIzNT^`lr>Qyb+<0xx7;y(PBRHUm3%OqUn<Z69a<-VadJ$LIe?{{;$tY!h1Q8to&W!
zBY%2#1b{9KJOubKLHhpZQ!Ig5W=Ih|R3UlQ#lewI16@Z4B9snDi}($d2C7CA0zarA
zS#perdu@PT1uHjNb3`r&y`;ZL1PdhcaT&d|yT9Q+>)FY;^0ure^7WUL=}$MPRBuiN
z?Y5!xaxk33N(F!4weX_71()wE>7D*~*pkniJbw@lZxEpN>lI}~2ugxusKNf7dES$2
z`Fk^FVaTFo8ESpa*ixpZyRbb+>-vKPgZ9gse;m)4ez{+fT^N#8k#>VDDCQ;p(aa_L
zMP$nq<QH_gk7W_G4kEiJRbMdw4DiOf*PZtJmY(0yV>#(3{Vwq2#=ZTQ!E*(%>-3RE
zH+iDBO<-Q&Zee?q(vNJZzNFL3TG<vx1_QSk`ouCd9}Qg^*C6jOIPM-C=x&qtwPfVK
z`)Dv1I7k;J6+;(eE9)j(o{`6V$Ml_9!LV=mJytA2ESx;T6lzL9jboW>*|Y|<y0>c9
z@L?Qplt1Vf`+*;h9*!b`c8ob=uS2a9-J$1T?O5(`wfi|hI)paD8hQ+1{9cb>k9EZ^
zK-!1c2mKEAPW*2BP6@#UaSl-haRh^h>OnS6LPdE(<RLC8MkRa_(vaa0b<K-HpNO7l
zT;x-PTlAH)B0D2&QPh#^(F7@p$(1M@h4+F>@=S6L=q3o2e<(vLV+C9jAU=!#OJ@sj
z$!Ph8-30`U?}*g=Z%qsU;0}-hKz_BqHZA~Y0Gt53uT}&w;y=M-Jyp3|9!v?Dznka>
z8zv^^=-#N&KDfHZK+qtzg`$)!TbNhsA&Ox-o%P&k{WUG!JHXho5M+3$?%~#f9W!h|
z;eM65lDU=%X8@}p`AgCaz;_$d5NK*eYC{r>6^qtzUFC>s{k-Ubs7YGt_^mpu_=eA?
zxXck(d$f5J2M?PNm+=?N3cKELpXSmt0_{=n=+$^8QU#F^p*zgHFr2NZ;_5F94o}{3
zrCZVT7)2_Xm~aN?utoYj8b>UCE$GF#9oCg)3!ye-&KA+%@WVwF(|R{x<`u@-M#bV~
z+DBA5Ll|{Ui*~X%754g44I=`esLAB*LIR0=>3$&Z^=fg^tgu^AJM(OYskt;EzM;G4
zkERyU_>fuSoTSbUQ3A?iRQ(0af|q)nSprXzW`g(Iv5&FMpB<qc(RFPglQ>RvM`QAH
z<uDQs5Zl3K`RXkp!bI$y51x}-GJG-5MdW&0PY{9o8FL%8J!z8W-yBC>h0_dGpRI3V
zH;1btD3E?|P4p6vjZcv8kwK##>%KGU3SfrFp}X!Uy}`Xtecdj+-&Vb^k}8CZV&;+e
zxBm!I8TMNrA5COR$wR?`X0al~YBU-R#{$u??D#xxb}5AtkPS&hBT*=YzhAh_Nnvf?
z&&d#ez%z{_55+J|V(-f`O`tFQW}3po<$;n?E}2Lmm&o(P)G&!ORnsW_g?olhtz;G~
z*S2aFuKT!p93T?Mbrhm9!*v`aQ`d16rhVCQ94J9!gx1Y9OwHgJEzz@w)(=5OMGPw=
zTJ(NR%N!{)sO0<MSARM)s;#@wQe-Kt($+N3N99^tC`+R<*}_u%o5p#vr^%qIT2J?>
zXR$gq{<wV7d|C&`birjx`7TtD`b1P;rUNjptkDPr#%XrKd~J6zCTakZiZ+0gIy7L3
z5fOczMpTk%fKt)YXkh!^K&5G5Miiy0(Evtn*Z>qWCN*jRBNc6e147X>!9#r=(7z6v
zO%PPDV#=aT@G#IcjZi?*MlxW8l1772ghnG2xM(BAf2;!n@E-+=YJQatASko}BDN6{
zAo^d9KsPYBdCi^t^~>{CA08ZBn*tmhoD`ge3L4-<1o5?-$76lpzyQHC0Bk0i=(ktU
z9a%O<$_&IG`@m;>(U@txAYmsuw;W0wd~OAn&44)~<_0YjA22CAsk{-ms6aEOV<C$i
zFNYh2odkcG9Ip<-LbmZM8wR0vGLd0L3o^%LePnn<qzXQU-&Iiu>TK`}NQ1xkkl!-x
hm=XX)hVfB`PI#;uK7i$tgx>!iYM@fR(%0^z{|C!kuK54}

literal 0
HcmV?d00001

diff --git a/docs/_spec/public/images/classhierarchy.pdf b/docs/_spec/public/images/classhierarchy.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..58e050174b65669c9d5d12cfd5f0420e14265e24
GIT binary patch
literal 84078
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

literal 0
HcmV?d00001

diff --git a/docs/_spec/public/images/classhierarchy.png b/docs/_spec/public/images/classhierarchy.png
new file mode 100644
index 0000000000000000000000000000000000000000..3da25ecbf2d579a8330754ff3d6173c4a6dcfa57
GIT binary patch
literal 117555
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%0DWJzHXD30)#;Gzhu1NAQ1%KP^Usr}}(+&gcwi
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
ST-$`aYk)S<r=EBG>wf|ItD{i>

literal 0
HcmV?d00001

diff --git a/docs/_spec/public/images/github-logo@2x.png b/docs/_spec/public/images/github-logo@2x.png
new file mode 100644
index 0000000000000000000000000000000000000000..285b0fee2f32c760121718e28cc489c6eb2ca884
GIT binary patch
literal 1753
zcmeAS@N?(olHy`uVBq!ia0vp^3LwnE1|*BCs=fdz$r9IylHmNblJdl&R0hYC{G?O`
z&)mfH)S%SFl*+=BsWuD@%u1Od5hW46K32*3xq68pHF_1f1wh>l3^w)^1&PVosU-?Y
zsp*+{wo31J?^jaDOtDo8H}y5}EpSfF$n>ZxN)4{^3rViZPPR-@vbR&PsjvbXkegbP
zs8ErclUHn2VXFi-*9yo63F|8<fR&VF+bTgE72zA8;GAESs$i;Tpqp%9W}skZsAp(w
zVs37(qhMrUXrOOkq;F`XYiMp|Y-D9%pa2C*K--E^(yW49+@N*=dA3R!B_#z``ugSN
z<$C4Ddih1^`i7R4mLM~XjC6r2bc-wVN)jt{^NN*WCb*;)Cl_TFlw{`TDS%8&Ov*1U
zu~h=P6yk;40=Thx#n4~^2AF<DVu8M)o&m^9FonLp_?717!c`ZS1f?R}i`C%bkjjEo
z{h-w1{L-RiV8o><gRCmBaxO|uEXgkl$<NP$g<?QPeo20DMt*^UbFis`Z(?$09*7TC
z@9S&jnO9trn3tUD>0+w{G(j&jGsViy$k^G<#l*<b(%Hb!(ACJo%*5E$+||g^+0Dts
z)z}55*Cju>G&eP`1g19yq1PCvUQklVEdbi=l3J8mmYU*Ll%J~r_OewbZnqfVG!Lpb
z1-Dxaaq86vIz}H9u}BdO69T3l5EGtkfgE_kPt60S_99@i-f;Hl9$;?q^>lFzskpUf
zy0=GYph(;MuWM(l*O<lf^VFgh>pYv;1Wh}Z97|oif!##Yc~M3ZzlPT7%udh43R=Mn
z+0q^?P@kgY%5Tc<s`yCRckirw|3v?H9(`2t{$rI`&795GZ&tspe_#CV-fI@+i5>?Q
zr#2OBkZo~bj9^kZAn}5E?gCjG#>ev(bu~zcG*uaheas8`u6Ckd)LtT$?b3nD0M?)>
z^-OyhZ4)N!OI^S*rI9DJT<S_wcS4q;vBKiI<!&bIvm7ivI*k^E0A07aH(6-)fwjHS
z6M{Yjo7S;9$;C}gHNI{2jd@MK>H-d)6>i~<K{9i#J#J^axm>Jay5u;0RSi>0v#Ek&
z-?^n{qb9KWt=f_AIBRx;cG{Ci)`vfp-&;Q0uSnw(-xHG`$F^Pla(&g0>1!EgPRq2b
z;S_pVpD`_5e+T=o18YA0XPkd9_CoTlJK^gO|5RJ{bK!sSg4z6OXW6eyMef-;ga1yX
z>~<N(PknWle;)8jpUcnm%IA#xm;Pp-!jKiGc844l+1&GJt9aV`8*Asi6?SLl-tVw!
zRfWx?`JpR!oRrxcQOjg@xc81oe6!?MPdSbs>7uXd+G;y<1sH$o)EM=e{nS_>qO#(X
zcpUf9nTHQ;Sf$YJzp9^UlFuH+xXmsO6Ixx0yL^9YDDbHDE~r;ya;w;X$K=<G#SFiz
zrhl?hW7@ZA!=;d{?|}}pHN`*N(muUtqIc2>ox@36ZS{|-9n=yv@3q_5#$tLYX2a#0
zl~?V0{)xN@e=2)s+mU%)i);jzEmB(*!yfiwpHR;c!=jVi{kvo?pUp}ul6fv$D&cvp
zsKxrRquu%Bx(kc?BC{`To8N5ltjLF5;<lx$^w&%c&*MDuB?dEBJUNqN=(y_HPqQZu
zx5bnlUna!9%--tjk+&kj)WPVPp8?moroRuGZXLh-rc#8_bXDBiXtybhb}Mv#2;7ib
z?3^9^xuh=QDdXKYr%g3=!#rQgxa-`!WT~b*-KOKh$EKc#C3XV3nxz`d%~}c48iD8c
za!uI3==dr710lB0>Kz+o_l5T!p3`W=&*XH*@X)F2XK(UWh(4$hF3l=El6>jguDa*k
zf(xdvcq1&#{i34j^_~<%`{ma*9gNFcswfw?^N+3kv$ET)^BThpUa7u_XJljGYQA-<
Te@gmWP-Wxk>gTe~DWM4f?xCf(

literal 0
HcmV?d00001

diff --git a/docs/_spec/public/images/scala-spiral-white.png b/docs/_spec/public/images/scala-spiral-white.png
new file mode 100644
index 0000000000000000000000000000000000000000..46aaf80824c1b820733039260d6e37733a276a32
GIT binary patch
literal 1442
zcmeAS@N?(olHy`uVBq!ia0vp^azJdr!3HGRrk#2Mq$EpRBT9nv(@M${i&7aJQ}UBi
z6+Ckj(^G>|6H_V+Po~;1Ffc1+hD4M^`1)8S=jZArg4F0$<Q4#RGcefLR}>^BXQ!4Z
zB&DWj=GiK}-@RW+Av48RDcsc8z_-9TH6zobswg$M$}c3jDm&RSMakYy!KT6rXh3di
zNuokUZcbjYRfVk**jy_h8zii+qySb@l5ML5aa4qFfP!;=QL2Keo`G(%fti7VnW3Jc
zv5C34xsHO7fuVuEfswwUk*=Y+m9dePfq?=PC;@FNN=dT{a&d#&1?1T(Wt5Z@Sn2DR
zmzV368|&p4rRy77T3Uk4Ff!5ws?aU2%qvN((9J7WhMC}!TAW;zSx}OhpQivaF)=B>
zw8T~k=u(Imatq+b<`qMO2^e7d6^RA<hI$4dFToW0`r=obn+sQ6ToROua4%Mai$f|4
zQuTvUi}Op1l7SJIrVO&Gz{<HOHL)bWC?r2W2NsF}8Tlpo#Toep3eLf%3ciWSnRy^S
zSiP^Wm1kaYNn&1ds;7&s63_&_%*+%kLnm`5Ge<WQM+-9}Lqk_1OG{TrS2H(Pb2B$X
zV{;<|m|mCs<kH;Kyb_q+6og(=oO(e?A-4c%vrB4GW?5>ATTy<l0@%w|nYi6zgws5z
z-W1$!F~+G^ALtl;P{bldG)xGXdO%EgvITPB2|qOtnA(eg$=a#%=W+%HCNWPJ$B>F!
zZ>Ia|Gds#0^9@=kbR}BDNm=EH<Kttlj~~1{wRB&jzQRYrA1ro_Evqf2@H@!L>{<3m
zb;TBGN6#x&Zu30Vgi}}VzU@&qDL!rc&42aAn`c)VEn3EPcH7$}_YZMIux*P!#1g?=
zIor2F)k&N^*dfmSOu9>Jlf*8G?*5Nf@1E>G<oMCTea$b;xBt%jW_T~|`da*i%YW8~
zx7^%E8gI0xHL}_t<xk*Va$wu^M@$xs?g{*N8kJU-d+SWs=RbEqbO%f12gi%M)ux`A
zrajFy-tw1?rFqvYrQkcv&kl5G*0K33u-~)DQq`(a)@ar1YjQMT{Pkshm29nX>QSzh
ztaB3>N`fW+8O}9m2(-I$e4qFh0~;SljxEh@7mg%!eyDu@@{9L1uVV*I!j~~$*}1V%
zWs616?ulCuPLu3dt+{QLq8)?h{v-Mc@^6})3tml)aD8N$Y?%C}W^G<a{>&ir2eUY*
z=}z>EkK}naw@ZFT*!MYSSyL_9UoLs~)XbVQ?TOv`?#(?eCzVf5lWboG)I4D)ulGlx
z$2mI=dE}&Y95G3}5onbtz{}HZcIniL?xK}lf7VXhc=Jren@78~-(N_ZcdK{GrzZmH
z)2jlltJIqIS_%9wFT9n%(dN~frl}MBjVhh)ut+;`oL;?jn&6DI2g?<_cK+?t<+|jv
zdVRL(VlVr3J#AWfQ)jvEj4z$XTD~PRCBWwK)9(Kw2@EFeJ;v9I8=FC;rl+f)%Q~lo
FCIHvI5+DEo

literal 0
HcmV?d00001

diff --git a/docs/_spec/public/octicons/LICENSE.txt b/docs/_spec/public/octicons/LICENSE.txt
new file mode 100644
index 000000000000..259b43d14de3
--- /dev/null
+++ b/docs/_spec/public/octicons/LICENSE.txt
@@ -0,0 +1,9 @@
+(c) 2012-2014 GitHub
+
+When using the GitHub logos, be sure to follow the GitHub logo guidelines (https://github.com/logos)
+
+Font License: SIL OFL 1.1 (http://scripts.sil.org/OFL)
+Applies to all font files
+
+Code License: MIT (http://choosealicense.com/licenses/mit/)
+Applies to all other files
diff --git a/docs/_spec/public/octicons/octicons.css b/docs/_spec/public/octicons/octicons.css
new file mode 100644
index 000000000000..a5dcd153a856
--- /dev/null
+++ b/docs/_spec/public/octicons/octicons.css
@@ -0,0 +1,235 @@
+@font-face {
+  font-family: 'octicons';
+  src: url('octicons.eot?#iefix') format('embedded-opentype'),
+       url('octicons.woff') format('woff'),
+       url('octicons.ttf') format('truetype'),
+       url('octicons.svg#octicons') format('svg');
+  font-weight: normal;
+  font-style: normal;
+}
+
+/*
+
+.octicon is optimized for 16px.
+.mega-octicon is optimized for 32px but can be used larger.
+
+*/
+.octicon, .mega-octicon {
+  font: normal normal normal 16px/1 octicons;
+  display: inline-block;
+  text-decoration: none;
+  text-rendering: auto;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+  -webkit-user-select: none;
+  -moz-user-select: none;
+  -ms-user-select: none;
+  user-select: none;
+}
+.mega-octicon { font-size: 32px; }
+
+
+.octicon-alert:before { content: '\f02d'} /*  */
+.octicon-alignment-align:before { content: '\f08a'} /*  */
+.octicon-alignment-aligned-to:before { content: '\f08e'} /*  */
+.octicon-alignment-unalign:before { content: '\f08b'} /*  */
+.octicon-arrow-down:before { content: '\f03f'} /*  */
+.octicon-arrow-left:before { content: '\f040'} /*  */
+.octicon-arrow-right:before { content: '\f03e'} /*  */
+.octicon-arrow-small-down:before { content: '\f0a0'} /*  */
+.octicon-arrow-small-left:before { content: '\f0a1'} /*  */
+.octicon-arrow-small-right:before { content: '\f071'} /*  */
+.octicon-arrow-small-up:before { content: '\f09f'} /*  */
+.octicon-arrow-up:before { content: '\f03d'} /*  */
+.octicon-beer:before { content: '\f069'} /*  */
+.octicon-book:before { content: '\f007'} /*  */
+.octicon-bookmark:before { content: '\f07b'} /*  */
+.octicon-briefcase:before { content: '\f0d3'} /*  */
+.octicon-broadcast:before { content: '\f048'} /*  */
+.octicon-browser:before { content: '\f0c5'} /*  */
+.octicon-bug:before { content: '\f091'} /*  */
+.octicon-calendar:before { content: '\f068'} /*  */
+.octicon-check:before { content: '\f03a'} /*  */
+.octicon-checklist:before { content: '\f076'} /*  */
+.octicon-chevron-down:before { content: '\f0a3'} /*  */
+.octicon-chevron-left:before { content: '\f0a4'} /*  */
+.octicon-chevron-right:before { content: '\f078'} /*  */
+.octicon-chevron-up:before { content: '\f0a2'} /*  */
+.octicon-circle-slash:before { content: '\f084'} /*  */
+.octicon-circuit-board:before { content: '\f0d6'} /*  */
+.octicon-clippy:before { content: '\f035'} /*  */
+.octicon-clock:before { content: '\f046'} /*  */
+.octicon-cloud-download:before { content: '\f00b'} /*  */
+.octicon-cloud-upload:before { content: '\f00c'} /*  */
+.octicon-code:before { content: '\f05f'} /*  */
+.octicon-color-mode:before { content: '\f065'} /*  */
+.octicon-comment-add:before,
+.octicon-comment:before { content: '\f02b'} /*  */
+.octicon-comment-discussion:before { content: '\f04f'} /*  */
+.octicon-credit-card:before { content: '\f045'} /*  */
+.octicon-dash:before { content: '\f0ca'} /*  */
+.octicon-dashboard:before { content: '\f07d'} /*  */
+.octicon-database:before { content: '\f096'} /*  */
+.octicon-device-camera:before { content: '\f056'} /*  */
+.octicon-device-camera-video:before { content: '\f057'} /*  */
+.octicon-device-desktop:before { content: '\f27c'} /*  */
+.octicon-device-mobile:before { content: '\f038'} /*  */
+.octicon-diff:before { content: '\f04d'} /*  */
+.octicon-diff-added:before { content: '\f06b'} /*  */
+.octicon-diff-ignored:before { content: '\f099'} /*  */
+.octicon-diff-modified:before { content: '\f06d'} /*  */
+.octicon-diff-removed:before { content: '\f06c'} /*  */
+.octicon-diff-renamed:before { content: '\f06e'} /*  */
+.octicon-ellipsis:before { content: '\f09a'} /*  */
+.octicon-eye-unwatch:before,
+.octicon-eye-watch:before,
+.octicon-eye:before { content: '\f04e'} /*  */
+.octicon-file-binary:before { content: '\f094'} /*  */
+.octicon-file-code:before { content: '\f010'} /*  */
+.octicon-file-directory:before { content: '\f016'} /*  */
+.octicon-file-media:before { content: '\f012'} /*  */
+.octicon-file-pdf:before { content: '\f014'} /*  */
+.octicon-file-submodule:before { content: '\f017'} /*  */
+.octicon-file-symlink-directory:before { content: '\f0b1'} /*  */
+.octicon-file-symlink-file:before { content: '\f0b0'} /*  */
+.octicon-file-text:before { content: '\f011'} /*  */
+.octicon-file-zip:before { content: '\f013'} /*  */
+.octicon-flame:before { content: '\f0d2'} /*  */
+.octicon-fold:before { content: '\f0cc'} /*  */
+.octicon-gear:before { content: '\f02f'} /*  */
+.octicon-gift:before { content: '\f042'} /*  */
+.octicon-gist:before { content: '\f00e'} /*  */
+.octicon-gist-secret:before { content: '\f08c'} /*  */
+.octicon-git-branch-create:before,
+.octicon-git-branch-delete:before,
+.octicon-git-branch:before { content: '\f020'} /*  */
+.octicon-git-commit:before { content: '\f01f'} /*  */
+.octicon-git-compare:before { content: '\f0ac'} /*  */
+.octicon-git-merge:before { content: '\f023'} /*  */
+.octicon-git-pull-request-abandoned:before,
+.octicon-git-pull-request:before { content: '\f009'} /*  */
+.octicon-globe:before { content: '\f0b6'} /*  */
+.octicon-graph:before { content: '\f043'} /*  */
+.octicon-heart:before { content: '\2665'} /* ♥ */
+.octicon-history:before { content: '\f07e'} /*  */
+.octicon-home:before { content: '\f08d'} /*  */
+.octicon-horizontal-rule:before { content: '\f070'} /*  */
+.octicon-hourglass:before { content: '\f09e'} /*  */
+.octicon-hubot:before { content: '\f09d'} /*  */
+.octicon-inbox:before { content: '\f0cf'} /*  */
+.octicon-info:before { content: '\f059'} /*  */
+.octicon-issue-closed:before { content: '\f028'} /*  */
+.octicon-issue-opened:before { content: '\f026'} /*  */
+.octicon-issue-reopened:before { content: '\f027'} /*  */
+.octicon-jersey:before { content: '\f019'} /*  */
+.octicon-jump-down:before { content: '\f072'} /*  */
+.octicon-jump-left:before { content: '\f0a5'} /*  */
+.octicon-jump-right:before { content: '\f0a6'} /*  */
+.octicon-jump-up:before { content: '\f073'} /*  */
+.octicon-key:before { content: '\f049'} /*  */
+.octicon-keyboard:before { content: '\f00d'} /*  */
+.octicon-law:before { content: '\f0d8'} /*  */
+.octicon-light-bulb:before { content: '\f000'} /*  */
+.octicon-link:before { content: '\f05c'} /*  */
+.octicon-link-external:before { content: '\f07f'} /*  */
+.octicon-list-ordered:before { content: '\f062'} /*  */
+.octicon-list-unordered:before { content: '\f061'} /*  */
+.octicon-location:before { content: '\f060'} /*  */
+.octicon-gist-private:before,
+.octicon-mirror-private:before,
+.octicon-git-fork-private:before,
+.octicon-lock:before { content: '\f06a'} /*  */
+.octicon-logo-github:before { content: '\f092'} /*  */
+.octicon-mail:before { content: '\f03b'} /*  */
+.octicon-mail-read:before { content: '\f03c'} /*  */
+.octicon-mail-reply:before { content: '\f051'} /*  */
+.octicon-mark-github:before { content: '\f00a'} /*  */
+.octicon-markdown:before { content: '\f0c9'} /*  */
+.octicon-megaphone:before { content: '\f077'} /*  */
+.octicon-mention:before { content: '\f0be'} /*  */
+.octicon-microscope:before { content: '\f089'} /*  */
+.octicon-milestone:before { content: '\f075'} /*  */
+.octicon-mirror-public:before,
+.octicon-mirror:before { content: '\f024'} /*  */
+.octicon-mortar-board:before { content: '\f0d7'} /*  */
+.octicon-move-down:before { content: '\f0a8'} /*  */
+.octicon-move-left:before { content: '\f074'} /*  */
+.octicon-move-right:before { content: '\f0a9'} /*  */
+.octicon-move-up:before { content: '\f0a7'} /*  */
+.octicon-mute:before { content: '\f080'} /*  */
+.octicon-no-newline:before { content: '\f09c'} /*  */
+.octicon-octoface:before { content: '\f008'} /*  */
+.octicon-organization:before { content: '\f037'} /*  */
+.octicon-package:before { content: '\f0c4'} /*  */
+.octicon-paintcan:before { content: '\f0d1'} /*  */
+.octicon-pencil:before { content: '\f058'} /*  */
+.octicon-person-add:before,
+.octicon-person-follow:before,
+.octicon-person:before { content: '\f018'} /*  */
+.octicon-pin:before { content: '\f041'} /*  */
+.octicon-playback-fast-forward:before { content: '\f0bd'} /*  */
+.octicon-playback-pause:before { content: '\f0bb'} /*  */
+.octicon-playback-play:before { content: '\f0bf'} /*  */
+.octicon-playback-rewind:before { content: '\f0bc'} /*  */
+.octicon-plug:before { content: '\f0d4'} /*  */
+.octicon-repo-create:before,
+.octicon-gist-new:before,
+.octicon-file-directory-create:before,
+.octicon-file-add:before,
+.octicon-plus:before { content: '\f05d'} /*  */
+.octicon-podium:before { content: '\f0af'} /*  */
+.octicon-primitive-dot:before { content: '\f052'} /*  */
+.octicon-primitive-square:before { content: '\f053'} /*  */
+.octicon-pulse:before { content: '\f085'} /*  */
+.octicon-puzzle:before { content: '\f0c0'} /*  */
+.octicon-question:before { content: '\f02c'} /*  */
+.octicon-quote:before { content: '\f063'} /*  */
+.octicon-radio-tower:before { content: '\f030'} /*  */
+.octicon-repo-delete:before,
+.octicon-repo:before { content: '\f001'} /*  */
+.octicon-repo-clone:before { content: '\f04c'} /*  */
+.octicon-repo-force-push:before { content: '\f04a'} /*  */
+.octicon-gist-fork:before,
+.octicon-repo-forked:before { content: '\f002'} /*  */
+.octicon-repo-pull:before { content: '\f006'} /*  */
+.octicon-repo-push:before { content: '\f005'} /*  */
+.octicon-rocket:before { content: '\f033'} /*  */
+.octicon-rss:before { content: '\f034'} /*  */
+.octicon-ruby:before { content: '\f047'} /*  */
+.octicon-screen-full:before { content: '\f066'} /*  */
+.octicon-screen-normal:before { content: '\f067'} /*  */
+.octicon-search-save:before,
+.octicon-search:before { content: '\f02e'} /*  */
+.octicon-server:before { content: '\f097'} /*  */
+.octicon-settings:before { content: '\f07c'} /*  */
+.octicon-log-in:before,
+.octicon-sign-in:before { content: '\f036'} /*  */
+.octicon-log-out:before,
+.octicon-sign-out:before { content: '\f032'} /*  */
+.octicon-split:before { content: '\f0c6'} /*  */
+.octicon-squirrel:before { content: '\f0b2'} /*  */
+.octicon-star-add:before,
+.octicon-star-delete:before,
+.octicon-star:before { content: '\f02a'} /*  */
+.octicon-steps:before { content: '\f0c7'} /*  */
+.octicon-stop:before { content: '\f08f'} /*  */
+.octicon-repo-sync:before,
+.octicon-sync:before { content: '\f087'} /*  */
+.octicon-tag-remove:before,
+.octicon-tag-add:before,
+.octicon-tag:before { content: '\f015'} /*  */
+.octicon-telescope:before { content: '\f088'} /*  */
+.octicon-terminal:before { content: '\f0c8'} /*  */
+.octicon-three-bars:before { content: '\f05e'} /*  */
+.octicon-tools:before { content: '\f031'} /*  */
+.octicon-trashcan:before { content: '\f0d0'} /*  */
+.octicon-triangle-down:before { content: '\f05b'} /*  */
+.octicon-triangle-left:before { content: '\f044'} /*  */
+.octicon-triangle-right:before { content: '\f05a'} /*  */
+.octicon-triangle-up:before { content: '\f0aa'} /*  */
+.octicon-unfold:before { content: '\f039'} /*  */
+.octicon-unmute:before { content: '\f0ba'} /*  */
+.octicon-versions:before { content: '\f064'} /*  */
+.octicon-remove-close:before,
+.octicon-x:before { content: '\f081'} /*  */
+.octicon-zap:before { content: '\26A1'} /* ⚡ */
diff --git a/docs/_spec/public/octicons/octicons.eot b/docs/_spec/public/octicons/octicons.eot
new file mode 100644
index 0000000000000000000000000000000000000000..22881a8b6c4342720d2d4318ef5887c8abbfc8a2
GIT binary patch
literal 31440
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
XF}5Pg<jC#560I1^7f%CEAY}Z1zp7cN

literal 0
HcmV?d00001

diff --git a/docs/_spec/public/octicons/octicons.svg b/docs/_spec/public/octicons/octicons.svg
new file mode 100644
index 000000000000..ea3e0f161528
--- /dev/null
+++ b/docs/_spec/public/octicons/octicons.svg
@@ -0,0 +1,198 @@
+<?xml version="1.0" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<svg xmlns="http://www.w3.org/2000/svg">
+<metadata>
+(c) 2012-2014 GitHub
+
+When using the GitHub logos, be sure to follow the GitHub logo guidelines (https://github.com/logos)
+
+Font License: SIL OFL 1.1 (http://scripts.sil.org/OFL)
+Applies to all font files
+
+Code License: MIT (http://choosealicense.com/licenses/mit/)
+Applies to all other files
+</metadata>
+<defs>
+<font id="octicons" horiz-adv-x="1024" >
+<font-face font-family="octicons" font-weight="400" font-stretch="normal" units-per-em="1024" ascent="832" descent="-192" />
+<missing-glyph d="M512 832C229.25 832 0 602.75 0 320c0-226.25 146.688-418.125 350.156-485.812 25.594-4.688 34.938 11.125 34.938 24.625 0 12.188-0.469 52.562-0.719 95.312C242-76.81200000000001 211.906 14.5 211.906 14.5c-23.312 59.125-56.844 74.875-56.844 74.875-46.531 31.75 3.53 31.125 3.53 31.125 51.406-3.562 78.47-52.75 78.47-52.75 45.688-78.25 119.875-55.625 149-42.5 4.654 33 17.904 55.625 32.5 68.375C304.906 106.56200000000001 185.344 150.5 185.344 346.688c0 55.938 19.969 101.562 52.656 137.406-5.219 13-22.844 65.094 5.062 135.562 0 0 42.938 13.75 140.812-52.5 40.812 11.406 84.594 17.031 128.125 17.219 43.5-0.188 87.312-5.875 128.188-17.281 97.688 66.312 140.688 52.5 140.688 52.5 28-70.531 10.375-122.562 5.125-135.5 32.812-35.844 52.625-81.469 52.625-137.406 0-196.688-119.75-240-233.812-252.688 18.438-15.875 34.75-47 34.75-94.75 0-68.438-0.688-123.625-0.688-140.5 0-13.625 9.312-29.562 35.25-24.562C877.438-98 1024 93.875 1024 320 1024 602.75 794.75 832 512 832z" horiz-adv-x="1024" />
+<glyph glyph-name="alert" unicode="&#xf02d;" d="M1005.854 31.753000000000043l-438.286 767C556.173 818.694 534.967 831 512 831s-44.173-12.306-55.567-32.247l-438.286-767c-11.319-19.809-11.238-44.144 0.213-63.876C29.811-51.85500000000002 50.899-64 73.714-64h876.572c22.814 0 43.903 12.145 55.354 31.877S1017.173 11.94399999999996 1005.854 31.753000000000043zM576 64H448V192h128V64zM576 256H448V512h128V256z" horiz-adv-x="1024" />
+<glyph glyph-name="alignment-align" unicode="&#xf08a;" d="M192 768C85.938 768 0 682.062 0 576s85.938-192 192-192c106.062 0 192 85.938 192 192S298.062 768 192 768zM672 224l160 160H384v-448l160 160 288-288 128 128L672 224z" horiz-adv-x="960" />
+<glyph glyph-name="alignment-aligned-to" unicode="&#xf08e;" d="M384 256l128 128 288-288 160 160v-448H512l160 160L384 256zM192 384C85.938 384 0 469.938 0 576S85.938 768 192 768c106.062 0 192-85.938 192-192S298.062 384 192 384z" horiz-adv-x="960" />
+<glyph glyph-name="alignment-unalign" unicode="&#xf08b;" d="M512 640L384 512 128 768 0 640l256-256L128 256l64-64 384 384L512 640zM640 256l128 128-64 64L320 64l64-64 128 128 256-256 128 128L640 256z" horiz-adv-x="896" />
+<glyph glyph-name="arrow-down" unicode="&#xf03f;" d="M448 384V640H192v-256H0l320-384 320 384H448z" horiz-adv-x="640" />
+<glyph glyph-name="arrow-left" unicode="&#xf040;" d="M384 448V640L0 320l384-320V192h256V448H384z" horiz-adv-x="640" />
+<glyph glyph-name="arrow-right" unicode="&#xf03e;" d="M640 320L256 640v-192H0v-256h256v-192L640 320z" horiz-adv-x="640" />
+<glyph glyph-name="arrow-small-down" unicode="&#xf0a0;" d="M256 384V512H128v-128H0l192-256 192 256H256z" horiz-adv-x="384" />
+<glyph glyph-name="arrow-small-left" unicode="&#xf0a1;" d="M256 384V512L0 320l256-192V256h128V384H256z" horiz-adv-x="384" />
+<glyph glyph-name="arrow-small-right" unicode="&#xf071;" d="M384 320L128 512v-128H0v-128h128v-128L384 320z" horiz-adv-x="384" />
+<glyph glyph-name="arrow-small-up" unicode="&#xf09f;" d="M192 512L0 256h128v-128h128V256h128L192 512z" horiz-adv-x="384" />
+<glyph glyph-name="arrow-up" unicode="&#xf03d;" d="M320 640L0 256h192v-256h256V256h192L320 640z" horiz-adv-x="640" />
+<glyph glyph-name="beer" unicode="&#xf069;" d="M896 576c-31 0-192 0-192 0v128c0 71-158 128-352 128s-352-57-352-128v-768c0-71 158-128 352-128s352 57 352 128v128s160 0 192 0 64 30 64 64 0 350 0 384-29 64-64 64z m-704-576h-64v512h64v-512z m192-64h-64v512h64v-512z m192 64h-64v512h64v-512z m-224 640c-124 0-224 29-224 64s100 64 224 64 224-29 224-64-100-64-224-64z m480-448h-128v256h128v-256z" horiz-adv-x="1024" />
+<glyph glyph-name="book" unicode="&#xf007;" d="M768 256h-128c-34 0-64-32-64-64h256c0 34-32 64-64 64z m-55 416c-167 0-209-32-233-56-24 24-66 56-233 56s-247-46-247-78v-586c29 16 119 48 214 56 115 9 234-9 234-32 0-16 8-31 31-32 0 0 0 0 1 0 0 0 0 0 1 0 23 1 31 16 31 32 0 23 119 41 234 32 94-7 185-40 214-56v586c0 32-80 78-247 78z m-265-572c-30 16-103 28-192 28s-170-12-192-27c0 0 0 411 0 443s64 59 192 59 192-27 192-59 0-444 0-444z m448 1c-22 15-103 27-192 27s-162-12-192-28c0 0 0 412 0 444s64 59 192 59 192-27 192-59 0-443 0-443z m-128 283h-128c-34 0-64-32-64-64h256c0 34-32 64-64 64z m0 128h-128c-34 0-64-32-64-64h256c0 34-32 64-64 64z m-448-128h-128c-32 0-64-30-64-64h256c0 32-30 64-64 64z m0-128h-128c-32 0-64-30-64-64h256c0 32-30 64-64 64z m0 256h-128c-32 0-64-30-64-64h256c0 32-30 64-64 64z" horiz-adv-x="1024" />
+<glyph glyph-name="bookmark" unicode="&#xf07b;" d="M0 704v-768l192 128 192-128V704H0zM316.25 507.25l-71.875-51.938 27.188-83.406c2.75-8.375-0.688-11.062-7.562-6.594l-72 52.094-72-52.031c-6.844-4.469-10.312-1.781-7.562 6.594l27.219 83.406L67.783 507.25c-6.469 5.125-5 9.219 3.906 9.219l88 0.125 27.125 83.094c2.812 8.812 7.562 8.812 10.375 0l27.188-83.094 87.938-0.125C321.25 516.469 322.688 512.375 316.25 507.25z" horiz-adv-x="384" />
+<glyph glyph-name="briefcase" unicode="&#xf0d3;" d="M896 640H640v66c0 34.2-27.8 62-62 62H446c-34.2 0-62-27.8-62-62v-66H128c-35.3 0-64-28.7-64-64v-512c0-35.3 28.7-64 64-64h768c35.3 0 64 28.7 64 64V576C960 611.3 931.3 640 896 640zM448 688c0 8.8 7.2 16 16 16h96c8.8 0 16-7.2 16-16v-48H448V688zM896 320H576v-64H448v64H128V576h64v-192h640V576h64V320z" horiz-adv-x="1024" />
+<glyph glyph-name="broadcast" unicode="&#xf048;" d="M448 640c142 0 256-115 256-256 0-69-28-132-72-178l-16-93c91 56 152 156 152 271 0 177-143 320-320 320s-320-143-320-320c0-115 61-215 152-271l-16 93c-45 46-72 109-72 178 0 142 114 256 256 256z m-64-320c-36 0-64-29-64-64v-128c0-36 30-64 64-64v-256h128v256c34 0 64 28 64 64v128c0 35-28 64-64 64s-64 0-64 0-28 0-64 0z m192 128c0 71-57 128-128 128s-128-57-128-128 57-128 128-128 128 57 128 128z m-128 384c-247 0-448-201-448-448 0-197 128-363 305-423l-12 72c-135 60-229 194-229 351 0 212 172 384 384 384s384-172 384-384c0-157-94-291-229-351l-12-72c177 60 305 225 305 423 0 247-201 448-448 448z" horiz-adv-x="896" />
+<glyph glyph-name="browser" unicode="&#xf0c5;" d="M320 640h64v-64h-64V640zM192 640h64v-64h-64V640zM64 640h64v-64H64V640zM832 0H64V512h768V0zM832 576H448v64h384V576zM896 640c0 35.35-28.65 64-64 64H64c-35.35 0-64-28.65-64-64v-640c0-35.35 28.65-64 64-64h768c35.35 0 64 28.65 64 64V640z" horiz-adv-x="896" />
+<glyph glyph-name="bug" unicode="&#xf091;" d="M243.621 675.469C190.747 618.688 205.34 528 205.34 528s53.968-64 160-64c106.031 0 160.031 64 160.031 64s14.375 89.469-37.375 146.312c32.375 18.031 51.438 44.094 43.562 61.812-8.938 19.969-48.375 21.75-88.25 3.969-14.812-6.594-27.438-14.969-37.25-23.875-12.438 2.25-25.625 3.781-40.72 3.781-14.061 0-26.561-1.344-38.344-3.25-9.656 8.75-22.062 16.875-36.531 23.344-39.875 17.719-79.375 15.938-88.25-3.969C194.465 718.781 212.497 693.438 243.621 675.469zM644.746 262.25c-8.25 1.75-16.125 2.75-23.75 3.5 0 2.125 0.375 4.125 0.375 6.312 0 33.594-4.75 65.654-12.438 96.125 16.438-1.406 37.375 2.375 58.562 11.779 39.875 17.781 65 48.375 56.125 68.219-8.875 19.969-48.375 21.75-88.25 3.969-18.625-8.312-33.812-19.469-44-30.906-7.75 18.25-16.5 35.781-26.812 51.719-30.188-25.156-87.312-62.719-167.062-71.062v-321.781c0 0-0.25-32-32.031-32-31.75 0-32 32-32 32V401.781c-79.811 8.344-136.968 45.969-167.093 71.062-9.875-15.312-18.375-32-25.938-49.344-10.281 10.625-24.625 20.844-41.969 28.594-39.875 17.719-79.375 15.938-88.25-3.969-8.906-19.906 16.25-50.438 56.125-68.219 19.844-8.846 39.531-12.812 55.469-12.096-7.656-30.404-12.469-62.344-12.469-95.812 0-2.188 0.375-4.25 0.438-6.5-6.719-0.75-13.688-1.75-20.781-3.25-51.969-10.75-91.781-37.625-88.844-59.812 2.938-22.312 47.5-31.5 99.594-20.688 6.781 1.375 13.438 3.125 19.781 5.062C128.684 146 143.34 108.125 163.622 75.5c-12.031-6.062-24.531-15-36.031-26.625C95.715 17 82.779-21.75 98.715-37.68799999999999c15.938-15.937 54.656-3 86.531 28.812 9.344 9.375 16.844 19.25 22.656 29C251.434-22.5 305.965-48 365.465-48c60.343 0 115.781 26.25 159.531 69.938 5.875-10.312 13.75-20.812 23.625-30.688 31.812-31.875 70.625-44.812 86.562-28.875s3 54.625-28.875 86.5c-12.312 12.375-25.688 21.75-38.438 27.938 20.125 32.5 34.625 70.375 43.688 111.062 7.188-2.25 14.688-4.375 22.562-6.062 52.061-10.812 96.625-1.562 99.625 20.688C736.558 224.625 696.746 251.5 644.746 262.25z" horiz-adv-x="733.886" />
+<glyph glyph-name="calendar" unicode="&#xf068;" d="M704 320h-64v-128h64V320zM576 320h-64v-128h64V320zM704 512h-64v-128h64V512zM832 320h-64v-128h64V320zM576 128h-64v-128h64V128zM768 832h-64v-128h64V832zM256 832h-64v-128h64V832zM832 512h-64v-128h64V512zM576 512h-64v-128h64V512zM320 128h-64v-128h64V128zM192 320h-64v-128h64V320zM320 320h-64v-128h64V320zM832 768v-128H640V768H320v-128H128V768H0v-896h960V768H832zM896-64H64V576h832V-64zM192 128h-64v-128h64V128zM448 512h-64v-128h64V512zM448 128h-64v-128h64V128zM320 512h-64v-128h64V512zM448 320h-64v-128h64V320zM704 128h-64v-128h64V128z" horiz-adv-x="1024" />
+<glyph glyph-name="check" unicode="&#xf03a;" d="M640 640L256 256 128 384 0 256l256-256 512 512L640 640z" horiz-adv-x="768" />
+<glyph glyph-name="checklist" unicode="&#xf076;" d="M760.688 315.78099999999995l-49.812 49.656c-6.438 6.529-16.938 6.594-23.375 0L582.5 260.5 462.375 140.125l-93.031 93.125c-6.531 6.562-17.031 6.562-23.5 0l-49.719-49.688c-6.531-6.562-6.531-17.062 0-23.562l104.781-104.875 17.969-17.875 31.688-31.812c6.562-6.562 17.188-6.562 23.562 0l49.625 49.688L760.625 292.22C767.25 298.688 767.25 309.188 760.688 315.78099999999995zM228.469 251.188L278.156 301c42.469 42.375 116.344 42.438 158.781-0.062l25.312-25.312L576 384V704H0v-704h320l-91.531 92.125C184.688 136.062 184.688 207.375 228.469 251.188zM192 640h320v-64H192V640zM192 512h320v-64H192V512zM128 320H64v64h64V320zM128 448H64v64h64V448zM128 576H64v64h64V576zM192 384h64v-64h-64V384z" horiz-adv-x="765.602" />
+<glyph glyph-name="chevron-down" unicode="&#xf0a3;" d="M512 512L320 320 128 512 0 384l320-320 320 320L512 512z" horiz-adv-x="640" />
+<glyph glyph-name="chevron-left" unicode="&#xf0a4;" d="M448 512L320 640 0 320l320-320 128 128L256 320 448 512z" horiz-adv-x="448" />
+<glyph glyph-name="chevron-right" unicode="&#xf078;" d="M128 640L0 512l192-192L0 128l128-128 320 320L128 640z" horiz-adv-x="448" />
+<glyph glyph-name="chevron-up" unicode="&#xf0a2;" d="M320 576L0 256l128-128 192 192 192-192 128 128L320 576z" horiz-adv-x="640" />
+<glyph glyph-name="circle-slash" unicode="&#xf084;" d="M320 640C143.219 640 0 496.781 0 320c0-176.75 143.219-320 320-320 176.75 0 320 143.25 320 320C640 496.781 496.75 640 320 640zM320 512c27.656 0 53.688-6.094 77.438-16.562L144.562 242.562C134.094 266.312 128 292.34400000000005 128 320 128 426 213.938 512 320 512zM320 128c-28.031 0-54.531 6.375-78.594 17.125l253.906 252.5C505.875 373.812 512 347.719 512 320 512 213.938 426.062 128 320 128z" horiz-adv-x="640" />
+<glyph glyph-name="circuit-board" unicode="&#xf0d6;" d="M320 576c35.346 0 64-28.654 64-64 0-35.346-28.654-64-64-64s-64 28.654-64 64C256 547.346 284.654 576 320 576zM960 64c0-106.039-85.961-192-192-192H320l192 192h81.128c22.132-38.258 63.494-64 110.872-64 70.692 0 128 57.308 128 128s-57.308 128-128 128c-47.377 0-88.74-25.742-110.872-64H448L156.044-99.95600000000002C100.845-66.23199999999997 64-5.419999999999959 64 64V576c0 106.039 85.961 192 192 192v-145.128C217.742 600.74 192 559.377 192 512c0-70.692 57.308-128 128-128 47.276 0 88.56 25.633 110.727 63.756l162.416 0.219C615.279 409.731 656.633 384 704 384c70.692 0 128 57.308 128 128s-57.308 128-128 128c-47.388 0-88.758-25.753-110.887-64.025l-162.097-0.219c-11.246 19.54-27.503 35.828-47.016 47.116V768h384c106.039 0 192-85.961 192-192V64zM640 128c0 35.346 28.654 64 64 64s64-28.654 64-64c0-35.346-28.654-64-64-64S640 92.654 640 128zM640 512c0 35.346 28.654 64 64 64s64-28.654 64-64c0-35.346-28.654-64-64-64S640 476.654 640 512z" horiz-adv-x="1024" />
+<glyph glyph-name="clippy" unicode="&#xf035;" d="M704-64h-640v576h640v-192h64v320c0 35-29 64-64 64h-192c0 71-57 128-128 128s-128-57-128-128h-192c-35 0-64-29-64-64v-704c0-35 29-64 64-64h640c35 0 64 29 64 64v128h-64v-128z m-512 704c29 0 29 0 64 0s64 29 64 64 29 64 64 64 64-29 64-64 32-64 64-64 33 0 64 0 64-29 64-64h-512c0 39 28 64 64 64z m-64-512h128v64h-128v-64z m448 128v128l-256-192 256-192v128h320v128h-320z m-448-256h192v64h-192v-64z m320 448h-320v-64h320v64z m-192-128h-128v-64h128v64z" horiz-adv-x="896" />
+<glyph glyph-name="clock" unicode="&#xf046;" d="M384 256h256l64 64-64 64H512V576l-64 64-64-64V256zM448 768C200.562 768 0 567.438 0 320c0-247.438 200.562-448 448-448 247.438 0 448 200.562 448 448C896 567.438 695.438 768 448 768zM448 0c-176.25 0-320 143.75-320 320 0 175.938 144.188 319.5 320 320 175.812-0.5 320-144.062 320-320C768 143.75 624.25 0 448 0z" horiz-adv-x="896" />
+<glyph glyph-name="cloud-download" unicode="&#xf00b;" d="M832 512c-8.75 0-17.125-1.406-25.625-2.562C757.625 623.75 644.125 704 512 704c-132.156 0-245.562-80.25-294.406-194.562C209.156 510.594 200.781 512 192 512 85.938 512 0 426.062 0 320s85.938-192 192-192c20.531 0 39.875 4.25 58.375 10.375C284.469 100.625 331.312 75.25 384 67.5v65.25c-49.844 10.375-91.594 42.812-112.625 87.875C249.531 203 222.219 192 192 192c-70.656 0-128 57.375-128 128 0 70.656 57.344 128 128 128 25.281 0 48.625-7.562 68.406-20.094C281.344 548.219 385.594 640 512 640c126.5 0 229.75-92.219 250.5-212.75 20 13 43.875 20.75 69.5 20.75 70.625 0 128-57.344 128-128 0-70.625-57.375-128-128-128-10.25 0-20 1.5-29.625 3.75C773.438 154.875 725.938 128 672 128c-11.062 0-21.625 1.625-32 4v-64.938c10.438-1.688 21.062-3.062 32-3.062 61.188 0 116.5 24.625 156.938 64.438C830 128.375 830.875 128 832 128c106.062 0 192 85.938 192 192S938.062 512 832 512zM576 320H448v-320H320l192-192 192 192H576V320z" horiz-adv-x="1024" />
+<glyph glyph-name="cloud-upload" unicode="&#xf00c;" d="M512 448L320 256h128v-320h128V256h128L512 448zM832 512c-8.75 0-17.125-1.406-25.625-2.562C757.625 623.812 644.125 704 512 704c-132.156 0-245.562-80.188-294.406-194.562C209.156 510.594 200.781 512 192 512 85.938 512 0 426 0 320c0-106.062 85.938-192 192-192 20.531 0 39.875 4.25 58.375 10.438C284.469 100.625 331.312 75.25 384 67.5v65.25c-49.844 10.375-91.594 42.812-112.625 87.75C249.531 203 222.219 192 192 192c-70.656 0-128 57.375-128 128 0 70.656 57.344 128 128 128 25.281 0 48.625-7.562 68.406-20.156C281.344 548.219 385.594 640 512 640c126.5 0 229.75-92.219 250.5-212.75 20 13 43.875 20.75 69.5 20.75 70.625 0 128-57.344 128-128 0-70.625-57.375-128-128-128-10.25 0-20 1.5-29.625 3.75C773.438 154.875 725.938 128 672 128c-11.062 0-21.625 1.625-32 4v-64.938c10.438-1.688 21.062-3.062 32-3.062 61.188 0 116.5 24.688 157 64.438 1 0 1.875-0.438 3-0.438 106.062 0 192 85.938 192 192C1024 426 938.062 512 832 512z" horiz-adv-x="1024" />
+<glyph glyph-name="code" unicode="&#xf05f;" d="M608 640l-96-96 224-224L512 96l96-96 288 320L608 640zM288 640L0 320l288-320 96 96L160 320l224 224L288 640z" horiz-adv-x="896" />
+<glyph glyph-name="color-mode" unicode="&#xf065;" d="M0 704v-768h768V704H0zM64 0V640h640L64 0z" horiz-adv-x="768" />
+<glyph glyph-name="comment" unicode="&#xf02b;" d="M768 704H128C66 704 0 640 0 576v-384c0-128 128-128 128-128h64v-256l256 256c0 0 258 0 320 0s128 68 128 128V576C896 638 832 704 768 704z" horiz-adv-x="896" />
+<glyph glyph-name="comment-discussion" unicode="&#xf04f;" d="M256 320c0 64 0 192 0 192s-160 0-192 0-64-32-64-64 0-288 0-320 32-64 64-64 64 0 64 0v-192l194 192s162 0 192 0 62 32 62 64 0 64 0 64-128 0-192 0-128 64-128 128z m576 384c-32 0-416 0-448 0s-64-32-64-64 0-288 0-320 32-64 64-64 190 0 190 0l194-192v192s32 0 64 0 64 32 64 64 0 288 0 320-32 64-64 64z" horiz-adv-x="896" />
+<glyph glyph-name="credit-card" unicode="&#xf045;" d="M128 128h128v64h-128v-64z m192 0h128v64h-128v-64z m64 192h-256v-64h256v64z m-128 64h64l128 128h-64l-128-128z m192-128h192v64h-192v-64z m512 384c-32 0-864 0-896 0s-64-32-64-64 0-480 0-512 32-64 64-64 864 0 896 0 64 32 64 64 0 480 0 512-32 64-64 64z m0-256v-288s0-32-32-32h-832c-32 0-32 32-32 32v288h64l128 128h-192v32s0 32 32 32h832c32 0 32-32 32-32v-32h-384l-128-128h512z" horiz-adv-x="1024" />
+<glyph glyph-name="dash" unicode="&#xf0ca;" d="M0 384v-128h512V384H0z" horiz-adv-x="512" />
+<glyph glyph-name="dashboard" unicode="&#xf07d;" d="M416 367.5c-61.562 0-111.5-49.938-111.5-111.5S354.438 144.5 416 144.5 527.5 194.438 527.5 256c0 8.5-1.125 16.75-3 24.688C606.125 375.625 732.5 523.656 800 608c23.125 28.875-2.312 56.188-32 32-85.188-69.375-232.312-194.688-326.906-275.594C433.031 366.281 424.625 367.5 416 367.5zM447.875 576.125c0 17.656-14.344 32-32 32s-32-14.344-32-32 14.344-32 32-32S447.875 558.469 447.875 576.125zM639.875 320.125c0-17.656 14.375-32 32-32s32 14.344 32 32-14.375 32-32 32S639.875 337.781 639.875 320.125zM287.875 576.125c-17.656 0-32-14.344-32-32s14.344-32 32-32 32 14.344 32 32S305.531 576.125 287.875 576.125zM223.875 448.125c0 17.656-14.344 32-32 32s-32-14.344-32-32 14.344-32 32-32S223.875 430.469 223.875 448.125zM127.875 320.125c0-17.656 14.344-32 32-32s32 14.344 32 32-14.344 32-32 32S127.875 337.781 127.875 320.125zM575.875 544.125c0 17.656-14.375 32-32 32s-32-14.344-32-32 14.375-32 32-32S575.875 526.469 575.875 544.125zM792.875 495.312l-68.75-89.938C731.625 378.188 736 349.625 736 320c0-176.75-143.312-320-320-320S96 143.25 96 320c0 176.688 143.312 320 320 320 65.875 0 127-19.969 177.875-54.094l79.25 60.625C602.375 702.406 513.25 736 416 736 186.25 736 0 549.75 0 320s186.25-416 416-416 416 186.25 416 416C832 382.719 817.75 442 792.875 495.312z" horiz-adv-x="832" />
+<glyph glyph-name="database" unicode="&#xf096;" d="M384-128C171.969-128 0-70.625 0 0c0 38.625 0 80.875 0 128 0 11.125 5.562 21.688 13.562 32C56.375 104.875 205.25 64 384 64s327.625 40.875 370.438 96c8-10.312 13.562-20.875 13.562-32 0-37.062 0-76.375 0-128C768-70.625 596-128 384-128zM384 128C171.969 128 0 185.375 0 256c0 38.656 0 80.844 0 128 0 6.781 2.562 13.375 6 19.906l0 0C7.938 408 10.5 412.031 13.562 416 56.375 360.906 205.25 320 384 320s327.625 40.906 370.438 96c3.062-3.969 5.625-8 7.562-12.094l0 0c3.438-6.531 6-13.125 6-19.906 0-37.062 0-76.344 0-128C768 185.375 596 128 384 128zM384 384C171.969 384 0 441.344 0 512c0 20.219 0 41.594 0 64 0 20.344 0 41.469 0 64C0 710.656 171.969 768 384 768c212 0 384-57.344 384-128 0-19.969 0-41.156 0-64 0-19.594 0-40.25 0-64C768 441.344 596 384 384 384zM384 704c-141.375 0-256-28.594-256-64s114.625-64 256-64 256 28.594 256 64S525.375 704 384 704z" horiz-adv-x="768" />
+<glyph glyph-name="device-camera" unicode="&#xf056;" d="M512 447.999c-70.691 0-127.999-57.308-127.999-127.999S441.309 192.00099999999998 512 192.00099999999998c5.713 0 11.337 0.38 16.852 1.105-46.344 7.058-81.851 47.079-81.851 95.394 0 53.295 43.204 96.499 96.499 96.499 48.314 0 88.336-35.507 95.394-81.851 0.726 5.515 1.105 11.139 1.105 16.852C639.999 390.691 582.691 447.999 512 447.999zM896 576H767.999L640 704H384L255.999 576H128c-35.348 0-64-28.652-64-64v-448c0-35.347 28.652-64 64-64h768c35.347 0 64 28.653 64 64V512C960 547.348 931.347 576 896 576zM416 640h192l64-64H352L416 640zM160.143 64C142.391 64 128 78.39099999999996 128 96.14300000000003V384h64v64h-64v31.857C128 497.609 142.391 512 160.143 512h182.526c-3.98-3.518-7.881-7.174-11.688-10.98-99.974-99.975-99.974-262.064 0-362.039l74.98-74.98H160.143zM512 128.00099999999998c-106.038 0-191.999 85.961-191.999 191.999S405.962 511.999 512 511.999 703.999 426.038 703.999 320 618.038 128.00099999999998 512 128.00099999999998zM832 352L681.327 512H832V352z" horiz-adv-x="1024" />
+<glyph glyph-name="device-camera-video" unicode="&#xf057;" d="M576 640c-35.347 0-64-28.653-64-64s28.653-64 64-64 64 28.653 64 64S611.347 640 576 640zM896 448L768 320v64c0 30.625-21.515 56.21-50.25 62.503C748.958 480.646 768 526.097 768 575.998 768 682.038 682.039 768 576 768c-101.123 0-183.986-78.178-191.45-177.393C350.516 621.306 305.442 640 256 640c-106.038 0-192-85.962-192-192.002C64 341.961 149.962 256 256 256h-64v-128h64v-128c0-35.347 28.653-64 64-64h384c35.347 0 64 28.653 64 64v64l128-128h64V448H896zM256 512c-35.347 0-64-28.653-64-64s28.653-64 64-64v-64c-70.692 0-128 57.308-128 127.999C128 518.692 185.308 576 256 576s128-57.307 128-128h-64C320 483.347 291.347 512 256 512zM576 128H448V256h128V128zM704 237.21299999999997c-33.526 33.547-70.276 70.317-73.373 73.414C624.837 316.418 616.837 320 608 320H416c-17.674 0-32-14.326-32-32v-192c0-8.329 3.183-15.915 8.396-21.607 0.53-0.58 39.123-39.164 74.409-74.393H352c-17.674 0-32 14.326-32 32V352c0 17.674 14.326 32 32 32h320c17.674 0 32-14.326 32-32V237.21299999999997zM576 448c-70.692 0-128 57.308-128 127.999C448 646.692 505.308 704 576 704s128-57.308 128-128.001C704 505.308 646.692 448 576 448zM896 128l-64 64 0.082 128.084L896 384.002V128z" horiz-adv-x="1024" />
+<glyph glyph-name="device-desktop" unicode="&#xf27c;" d="M960 768c-32 0-864 0-896 0s-64-32-64-64 0-544 0-576 32-64 64-64 320 0 320 0-192-64-192-128c0-32 32-64 64-64s480 0 512 0 64 32 64 64c0 64-192 128-192 128s288 0 320 0 64 32 64 64 0 544 0 576-32 64-64 64z m0-640h-896v576h896v-576z m-64 512h-192c-384-64-542-300-576-384v-64h768v448z" horiz-adv-x="1024" />
+<glyph glyph-name="device-mobile" unicode="&#xf038;" d="M576 832H64C28.688 832 0 803.312 0 768v-896c0-35.375 28.688-64 64-64h512c35.375 0 64 28.625 64 64V768C640 803.312 611.375 832 576 832zM288 768h64c17.625 0 32-14.344 32-32s-14.375-32-32-32h-64c-17.656 0-32 14.344-32 32S270.344 768 288 768zM352-128h-64c-17.656 0-32 14.375-32 32s14.344 32 32 32h64c17.625 0 32-14.375 32-32S369.625-128 352-128zM576 0H64V640h512V0z" horiz-adv-x="640" />
+<glyph glyph-name="diff" unicode="&#xf04d;" d="M448 576H320v-128H192v-128h128v-128h128V320h128V448H448V576zM192-64h384V64H192V-64zM640 832H128v-64h480l224-224v-608h64V576L640 832zM0 704v-896h768V512L576 704H0zM704-128H64V640h480l160-160V-128z" horiz-adv-x="896" />
+<glyph glyph-name="diff-added" unicode="&#xf06b;" d="M512 512h-128v-128h-128v-128h128v-128h128v128h128v128h-128v128z m320 256c-32 0-736 0-768 0s-64-32-64-64 0-736 0-768 32-64 64-64 736 0 768 0 64 32 64 64 0 736 0 768-32 64-64 64z m-64-736c0-16-17-32-32-32s-558 0-576 0-32 12-32 32c0 16 0 560 0 576s16 32 32 32 561 0 576 0 32-16 32-32 0-560 0-576z" horiz-adv-x="896" />
+<glyph glyph-name="diff-ignored" unicode="&#xf099;" d="M832 768h-768c-32 0-64-32-64-64v-768c0-32 32-64 64-64h768c32 0 64 32 64 64v768c0 32-32 64-64 64z m-64-736c0-16-17-32-32-32h-576c-18 0-32 12-32 32v576c0 16 16 32 32 32h576c15 0 32-16 32-32v-576z m-512 194v-98h98l286 286v98h-98l-286-286z" horiz-adv-x="896" />
+<glyph glyph-name="diff-modified" unicode="&#xf06d;" d="M832 768h-768c-32 0-64-32-64-64v-768c0-32 32-64 64-64h768c32 0 64 32 64 64v768c0 32-32 64-64 64z m-64-736c0-16-17-32-32-32h-576c-18 0-32 12-32 32v576c0 16 16 32 32 32h576c15 0 32-16 32-32v-576z m-320 416c-71 0-128-57-128-128s57-128 128-128 128 57 128 128-57 128-128 128z" horiz-adv-x="896" />
+<glyph glyph-name="diff-removed" unicode="&#xf06c;" d="M832 768h-768c-32 0-64-32-64-64v-768c0-32 32-64 64-64h768c32 0 64 32 64 64v768c0 32-32 64-64 64z m-64-736c0-16-17-32-32-32h-576c-18 0-32 12-32 32v576c0 16 16 32 32 32h576c15 0 32-16 32-32v-576z m-512 224h384v128h-384v-128z" horiz-adv-x="896" />
+<glyph glyph-name="diff-renamed" unicode="&#xf06e;" d="M832 768h-768c-32 0-64-32-64-64v-768c0-32 32-64 64-64h768c32 0 64 32 64 64v768c0 32-32 64-64 64z m-64-736c0-16-17-32-32-32h-576c-18 0-32 12-32 32v576c0 16 16 32 32 32h576c15 0 32-16 32-32v-576z m-320 352h-192v-128h192v-128l256 192-256 192v-128z" horiz-adv-x="896" />
+<glyph glyph-name="ellipsis" unicode="&#xf09a;" d="M640 512c-64 0-448 0-512 0s-128-64-128-128 0-64 0-128 64-128 128-128 448 0 512 0 128 64 128 128 0 64 0 128-64 128-128 128z m-384-256h-128v128h128v-128z m192 0h-128v128h128v-128z m192 0h-128v128h128v-128z" horiz-adv-x="768" />
+<glyph glyph-name="eye" unicode="&#xf04e;" d="M512 704c-192 0-416-128-512-384 96-192 288-320 512-320s416 128 512 320c-96 256-320 384-512 384z m0-640c-192 0-352 128-384 256 32 128 192 256 384 256s352-128 384-256c-32-128-192-256-384-256z m0 448c-20 0-38-4-56-9 33-15 56-48 56-87 0-53-43-96-96-96-39 0-72 23-87 56-5-18-9-36-9-56 0-106 86-192 192-192s192 86 192 192-86 192-192 192z" horiz-adv-x="1024" />
+<glyph glyph-name="file-binary" unicode="&#xf094;" d="M0-128V768h576l192-192v-704H0zM704 512L512 704H64v-768h640V512zM320 320H128V576h192V320zM256 512h-64v-128h64V512zM256 64h64v-64H128v64h64V192h-64v64h128V64zM512 384h64v-64H384v64h64V512h-64v64h128V384zM576 0H384V256h192V0zM512 192h-64v-128h64V192z" horiz-adv-x="768" />
+<glyph glyph-name="file-code" unicode="&#xf010;" d="M288 448L128 288l160-160 64 64-96 96 96 96L288 448zM416 384l96-96-96-96 64-64 160 160L480 448 416 384zM576 768H0v-896h768V576L576 768zM704-64H64V704h448l192-192V-64z" horiz-adv-x="768" />
+<glyph glyph-name="file-directory" unicode="&#xf016;" d="M832 640c-32 0-336 0-352 0s-32 16-32 32 0 0 0 32-32 64-64 64-288 0-320 0-64-32-64-64 0-704 0-704h896s0 544 0 576-32 64-64 64z m-448 0h-320s0 15 0 32 16 32 32 32 241 0 256 0 32-15 32-32 0-32 0-32z" horiz-adv-x="896" />
+<glyph glyph-name="file-media" unicode="&#xf012;" d="M576 768H0v-896h768V576L576 768zM704-64H64V704h448l192-192V-64zM128 576v-512h128c0 70.625 57.344 128 128 128-70.656 0-128 57.375-128 128 0 70.656 57.344 128 128 128 70.625 0 128-57.344 128-128 0-70.625-57.375-128-128-128 70.625 0 128-57.375 128-128h128V448L512 576H128z" horiz-adv-x="768" />
+<glyph glyph-name="file-pdf" unicode="&#xf014;" d="M576 768H0v-896h768V576L576 768zM64 704h255.812c-13.188-4.094-27.281-15.031-34.625-42.875-13.25-49.406-7.031-130.75 15.625-209.344C276.688 370.562 178.188 175.125 171.531 163.5c-15.625-4.875-65.344-23.625-107.531-59.812V704zM347.125 396.531c57.625-149.781 95-149.531 135.188-167.594C398.344 216 334.219 206.75 249.781 169.5 246.094 163.062 326.281 315.40599999999995 347.125 396.531zM704-64H65.844 64v0.375c0.781-0.062 1.094-0.375 1.844-0.375 33.812 0 84.75 21 180.562 182.375 38.188 15.438 72.062 26.875 78.469 28.938 58.812 14.875 125 26.625 187.562 33.375C566.875 153.5 639.125 135 680.25 132.375c9.625-0.5 16.062 1.188 23.75 2V-64zM704 246.625c-23.688 14.688-54 25-89.125 25-24.25 0-50.625-1.375-78.688-4.375-26.938 13-92.562 32.719-147.188 190.219 17.094 103.625 12.719 173.562 12.719 173.562 6.781 52.938-23.344 72.844-51.625 72.844 0 0-0.279 0.125-0.344 0.125H512l192-192V246.625z" horiz-adv-x="768" />
+<glyph glyph-name="file-submodule" unicode="&#xf017;" d="M832 320c-32 0-192 0-192 0 0 32-32 64-64 64s-96 0-128 0-64-32-64-64 0-320 0-320h512s0 224 0 256-32 64-64 64z m-256-64h-128s0 17 0 32 15 32 32 32 48 0 64 0 32-15 32-32 0-32 0-32z m256 320c-32 0-336 0-352 0s-32 17-32 32 0 0 0 32-32 64-64 64-288 0-320 0-64-32-64-64 0-640 0-640h320s0 352 0 384 32 64 64 64 224 0 256 0 64-32 64-64h192s0 96 0 128-32 64-64 64z m-448 0h-320s0 16 0 32 16 32 32 32 240 0 256 0 32-17 32-32 0-32 0-32z" horiz-adv-x="896" />
+<glyph glyph-name="file-symlink-directory" unicode="&#xf0b1;" d="M832 640h-352c-16 0-32 16-32 32s0 0 0 32-32 64-64 64h-320c-32 0-64-32-64-64s0-704 0-704h896s0 544 0 576-32 64-64 64z m-768 32c0 17 16 32 32 32h256c15 0 32-15 32-32s0-32 0-32h-320s0 15 0 32z m384-544v128c-125 0-224-56-256-192 0 209 107 320 256 320 0 49 0 128 0 128l256-192-256-192z" horiz-adv-x="896" />
+<glyph glyph-name="file-symlink-file" unicode="&#xf0b0;" d="M576 768h-576v-896h768v704l-192 192z m128-832h-640v768h448l192-192v-576z m-320 448c-149 0-256-111-256-320 32 136 131 192 256 192v-128l256 192-256 192s0-79 0-128z" horiz-adv-x="768" />
+<glyph glyph-name="file-text" unicode="&#xf011;" d="M448 576H128v-64h320V576zM576 768H0v-896h768V576L576 768zM704-64H64V704h448l192-192V-64zM128 64h512v64H128V64zM128 192h512v64H128V192zM128 320h512v64H128V320z" horiz-adv-x="768" />
+<glyph glyph-name="file-zip" unicode="&#xf013;" d="M320 256v64h-64v-64H320zM320 384v64h-64v-64H320zM320 512v64h-64v-64H320zM192 448h64v64h-64V448zM576 768H0v-896h768V576L576 768zM704-64H64V704h192v-64h64v64h192l192-192V-64zM192 576h64v64h-64V576zM192 320h64v64h-64V320zM192 192l-64-64v-128h256V128l-64 64h-64v64h-64V192zM320 128v-64H192v64H320z" horiz-adv-x="768" />
+<glyph glyph-name="flame" unicode="&#xf0d2;" d="M433 787c50-134 24-207-32-265-61-64-156-112-223-206-89-125-104-400 217-472-135 71-164 277-18 406-38-125 32-205 119-176 85 29 141-32 139-102-1-48-20-89-69-112 209 37 293 210 293 342 0 174-155 198-77 344-93-8-125-69-116-169 6-66-63-111-114-81-41 25-40 73-4 109 77 76 107 251-115 382z" horiz-adv-x="1024" />
+<glyph glyph-name="fold" unicode="&#xf0cc;" d="M896 576H672l-64-64h192L672 384H224L96 512h192l-64 64H0v-63.999L160 352 0 192v-64h224l64 64H96l128 128h448l128-128H608l64-64h224v64L736 352l160 160.001V576zM640 640H512V832H384v-192H256l192-192L640 640zM256 64h128v-192h128V64h128L448 256 256 64z" horiz-adv-x="896" />
+<glyph glyph-name="gear" unicode="&#xf02f;" d="M447.938 482C358.531 482 286 409.469 286 320c0-89.375 72.531-162.062 161.938-162.062 89.438 0 161.438 72.688 161.438 162.062C609.375 409.469 537.375 482 447.938 482zM772.625 226.938l-29.188-70.312 52.062-102.25 6.875-13.5-72.188-72.188L611.75 24.625l-70.312-28.875L505.75-113.5l-4.562-14.5H399.156L355-4.687999999999988l-70.312 29-102.404-51.938-13.5-6.75-72.156 72.125 55.875 118.5-28.969 70.25L14.469 262.125 0 266.812V368.781L123.406 413l28.969 70.188-51.906 102.469-6.844 13.438 72.062 72.062 118.594-55.844 70.219 29.031 35.656 109.188L394.75 768h102l44.188-123.469 70.125-29.031L713.5 667.469l13.625 6.844 72.125-72.062-55.875-118.406L772.25 413.5l109.375-35.656L896 373.25v-101.938L772.625 226.938z" horiz-adv-x="896" />
+<glyph glyph-name="gift" unicode="&#xf042;" d="M448-128h320V192H448V-128zM64-128h320V192H64V-128zM447.75 455.812c31.469 3.5 66.875 7.406 87.375 9.719C619 474.875 694.5 550.406 703.812 634.25c9.312 83.75-51 144.125-134.688 134.719C503.688 761.656 443.844 714 416 653.625 388.156 714 328.312 761.656 262.906 769.031 179.188 778.375 118.781 718 128.188 634.25c9.344-83.844 84.875-159.312 168.656-168.719 20.531-2.312 55.938-6.281 87.406-9.719C383.75 451.594 384 448 384 448h64C448 448 448.25 451.594 447.75 455.812zM555.375 691.312c45.25 5.062 78-27.562 72.875-72.875-5-45.312-45.875-86.156-91.125-91.219-45.375-5.031-78 27.594-72.938 72.906C469.249 645.436 510.125 686.281 555.375 691.312zM294.906 527.219c-45.25 5.062-86.062 45.906-91.125 91.219-5.063 45.313 27.594 77.938 72.812 72.875 45.312-5.031 86.156-45.875 91.222-91.188C372.875 554.812 340.219 522.188 294.906 527.219zM448 448v-192h384V448H448zM0 256h384V448H0V256z" horiz-adv-x="896" />
+<glyph glyph-name="gist" unicode="&#xf00e;" d="M416 448l96-96-96-96 64-64 160 160-160 160-64-64z m-416 320v-832h768v832h-768z m704-768h-640v704h640v-704z m-352 256l-96 96 96 96-64 64-160-160 160-160 64 64z" horiz-adv-x="768" />
+<glyph glyph-name="gist-secret" unicode="&#xf08c;" d="M193 128l128-192h-256l-65 256 257 64-64-128z m448 128l64-128-128-192h256l64 256-256 64z m-84 0h-216l44-102-64-218h256l-64 218 44 102z m84 192h-384l-128-64h640l-128 64z m-64 256l-128-64-128 64-64-192h384l-64 192z" horiz-adv-x="896" />
+<glyph glyph-name="git-branch" unicode="&#xf020;" d="M512 640c-71 0-128-57-128-128 0-47 26-88 64-110v-18c0-64-64-128-128-128-53 0-95-11-128-29v303c38 22 64 63 64 110 0 71-57 128-128 128s-128-57-128-128c0-47 26-88 64-110v-419c-38-22-64-63-64-110 0-71 57-128 128-128s128 57 128 128c0 34-13 64-34 87 19 23 49 41 98 41 128 0 256 128 256 256v18c38 22 64 63 64 110 0 71-57 128-128 128z m-384 64c35 0 64-29 64-64s-29-64-64-64-64 29-64 64 29 64 64 64z m0-768c-35 0-64 29-64 64s29 64 64 64 64-29 64-64-29-64-64-64z m384 512c-35 0-64 29-64 64s29 64 64 64 64-29 64-64-29-64-64-64z" horiz-adv-x="640" />
+<glyph glyph-name="git-commit" unicode="&#xf01f;" d="M694.875 384C666.375 494.219 567.125 576 448 576c-119.094 0-218.375-81.781-246.906-192H0v-128h201.094C229.625 145.75 328.906 64 448 64c119.125 0 218.375 81.75 246.875 192H896V384H694.875zM448 192c-70.656 0-128 57.375-128 128 0 70.656 57.344 128 128 128 70.625 0 128-57.344 128-128C576 249.375 518.625 192 448 192z" horiz-adv-x="896" />
+<glyph glyph-name="git-compare" unicode="&#xf0ac;" d="M832 110s0 306 0 402-96 192-192 192c-64 0-64 0-64 0v128l-192-192 192-192v128s32 0 64 0 64-32 64-64 0-402 0-402c-38-22-64-63-64-110 0-71 57-128 128-128s128 57 128 128c0 47-26 88-64 110z m-64-174c-35 0-64 29-64 64s29 64 64 64 64-29 64-64-29-64-64-64z m-448 128s-32 0-64 0-64 32-64 64 0 402 0 402c38 22 64 63 64 110 0 71-57 128-128 128s-128-57-128-128c0-47 26-88 64-110 0 0 0-306 0-402s96-192 192-192c64 0 64 0 64 0v-128l192 192-192 192v-128z m-192 512c-35 0-64 29-64 64s29 64 64 64 64-29 64-64-29-64-64-64z" horiz-adv-x="896" />
+<glyph glyph-name="git-merge" unicode="&#xf023;" d="M640 384c-47.625 0-88.625-26.312-110.625-64.906C523.625 319.5 518 320 512 320c-131.062 0-255.438 99.844-300.812 223.438C238.469 566.906 256 601.281 256 640c0 70.656-57.344 128-128 128S0 710.656 0 640c0-47.219 25.844-88.062 64-110.281V110.25C25.844 88.06200000000001 0 47.25 0 0c0-70.625 57.344-128 128-128s128 57.375 128 128c0 47.25-25.844 88.062-64 110.25V340.531C276.156 251.5 392.375 192 512 192c6.375 0 11.625 0.438 17.375 0.625C551.5 154.188 592.5 128 640 128c70.625 0 128 57.375 128 128C768 326.656 710.625 384 640 384zM128-64c-35.312 0-64 28.625-64 64 0 35.312 28.688 64 64 64 35.406 0 64-28.688 64-64C192-35.375 163.406-64 128-64zM128 576c-35.312 0-64 28.594-64 64s28.688 64 64 64c35.406 0 64-28.594 64-64S163.406 576 128 576zM640 192c-35.312 0-64 28.625-64 64 0 35.406 28.688 64 64 64 35.375 0 64-28.594 64-64C704 220.625 675.375 192 640 192z" horiz-adv-x="768" />
+<glyph glyph-name="git-pull-request" unicode="&#xf009;" d="M704 110s0 306 0 402-96 192-192 192c-64 0-64 0-64 0v128l-192-192 192-192v128s32 0 64 0 64-32 64-64 0-402 0-402c-38-22-64-63-64-110 0-71 57-128 128-128s128 57 128 128c0 47-26 88-64 110z m-64-174c-35 0-64 29-64 64s29 64 64 64 64-29 64-64-29-64-64-64z m-512 832c-71 0-128-57-128-128 0-47 26-88 64-110v-419c-38-22-64-63-64-110 0-71 57-128 128-128s128 57 128 128c0 47-26 88-64 110v419c38 22 64 63 64 110 0 71-57 128-128 128z m0-832c-35 0-64 29-64 64s29 64 64 64 64-29 64-64-29-64-64-64z m0 640c-35 0-64 29-64 64s29 64 64 64 64-29 64-64-29-64-64-64z" horiz-adv-x="768" />
+<glyph glyph-name="globe" unicode="&#xf0b6;" d="M512 704c-212.077 0-384-171.923-384-384s171.923-384 384-384c25.953 0 51.303 2.582 75.812 7.49-9.879 4.725-10.957 40.174-1.188 60.385 10.875 22.5 45 79.5 11.25 98.625s-24.375 27.75-45 49.875-12.19 25.451-13.5 31.125c-4.5 19.5 19.875 48.75 21 51.75s1.125 14.25 0.75 17.625S545.75 265.25 542 265.625s-5.625-6-10.875-6.375-28.125 13.875-33 17.625-7.125 12.75-13.875 19.5-7.5 1.5-18 5.625-44.25 16.5-70.125 27-28.125 25.219-28.5 35.625-15.75 25.5-22.961 36.375c-7.209 10.875-8.539 25.875-11.164 22.5s13.5-42.75 10.875-43.875-8.25 10.875-15.75 20.625 7.875 4.5-16.125 51.75 7.5 71.344 9 96 20.25-9 10.5 6.75 0.75 48.75-6.75 60.75S275 602 275 602c1.125 11.625 37.5 31.5 63.75 49.875s42.281 4.125 63.375-2.625 22.5-4.5 15.375 2.25 3 10.125 19.5 7.5 21-22.5 46.125-20.625 2.625-4.875 6-11.25-3.75-5.625-20.25-16.875S469.25 599 498.5 577.625s20.25 14.25 17.25 30S537.125 611 537.125 611c18-12 14.674-0.66 27.799-4.785S613.625 572 613.625 572c-44.625-24.375-16.5-27-9-32.625s-15.375-16.5-15.375-16.5c-9.375 9.375-10.875-0.375-16.875-3.75s-0.375-12-0.375-12c-31.031-4.875-24-37.5-23.625-45.375s-19.875-19.875-25.125-31.125S536.75 395 527 393.5s-19.5 36.75-72 22.5c-15.828-4.297-51-22.5-32.25-59.625s49.875 10.5 60.375 5.25-3-28.875-0.75-29.25 29.625-1.031 31.125-33 41.625-29.25 50.25-30 37.5 23.625 41.625 24.75S626 309.125 662 288.5s54.375-17.625 66.75-26.25 3.75-25.875 15.375-31.5 58.125 1.875 69.75-17.25-48-115.125-66.75-125.625S719.75 53.375 701 38s-45-34.406-69.75-49.125c-21.908-13.027-25.85-36.365-35.609-43.732C767.496-16.67999999999995 896 136.64999999999998 896 320 896 532.077 724.077 704 512 704zM602 343.625c-5.25-1.5-16.125-11.25-42.75 4.5s-45 12.75-47.25 15.375c0 0-2.25 6.375 9.375 7.5 23.871 2.311 54-22.125 60.75-22.5s10.125 6.75 22.125 2.883C616.25 347.52 607.25 345.125 602 343.625zM476.375 665.75c-2.615 1.902 2.166 4.092 5.016 7.875 1.645 2.186 0.425 5.815 2.484 7.875 5.625 5.625 33.375 13.5 27.949-1.875C506.4 664.25 480.5 662.75 476.375 665.75zM543.5 617c-9.375 0.375-31.443 2.707-27.375 6.75 15.844 15.75-6 20.25-19.5 21.375S477.5 653.75 484.25 654.5s33.75-0.375 38.25-4.125 28.875-13.5 30.375-20.625S552.875 616.625 543.5 617zM624.875 619.625c-7.5-6-45.24 21.529-52.5 27.75-31.5 27-48.375 18-54.99 22.5-6.617 4.5-4.26 10.5 5.865 19.5s38.625-3 55.125-4.875 35.625-14.625 36-29.781C614.75 639.564 632.375 625.625 624.875 619.625z" horiz-adv-x="1024" />
+<glyph glyph-name="graph" unicode="&#xf043;" d="M704 576H512v-640h192V576zM960 384H768v-448h192V384zM64-128V0h64v64H64V192h64v64H64V384h64v64H64V576h64v64H64V768h64V832H0v-1024h1024v64H64zM448 256H256v-320h192V256z" horiz-adv-x="1024" />
+<glyph glyph-name="heart" unicode="&#x2665;" d="M384-32c399 314 384 425 384 512s-72 192-192 192-192-128-192-128-72 128-192 128-192-105-192-192-15-198 384-512z" horiz-adv-x="768.199" />
+<glyph glyph-name="history" unicode="&#xf07e;" d="M448 768c-90.938 0-175.312-27.531-245.938-74.062L128 768v-256h256l-88 88c45.438 24.688 96.688 40 152 40 176.75 0 320-143.219 320-320 0-176.75-143.25-320-320-320-176.781 0-320 143.25-320 320 0 45.562 9.781 88.781 27 128H64v99.406C24.312 480.5 0 403.406 0 320c0-247.438 200.562-448 448-448 247.438 0 448 200.562 448 448C896 567.438 695.438 768 448 768zM447.031 1L512 64V256h128l64 64-64 64H512l-64 64L320 320l64-64v-192L447.031 1z" horiz-adv-x="896" />
+<glyph glyph-name="home" unicode="&#xf08d;" d="M192 256l64-384h192V192h128v-320h192l64 384L512 576 192 256zM832 448V704H704l0.312-128.312L512 768 0 256h128l384 384 384-384h128L832 448z" horiz-adv-x="1024" />
+<glyph glyph-name="horizontal-rule" unicode="&#xf070;" d="M63.938 384h128v-128h64V639.938h-64V448h-128V639.938H0V256h63.938V384zM639.875 256V384h-63.938v-128H639.875zM639.875 448V575.938h-63.938V448H639.875zM447.938 448V575.938h128v64h-192V256h64V384h128v64H447.938zM0 0h639.875V128H0V0z" horiz-adv-x="639.875" />
+<glyph glyph-name="hourglass" unicode="&#xf09e;" d="M571 320c118 85 197 240 197 384 0 71-172 128-384 128s-384-57-384-128c0-144 80-299 197-384-118-85-197-240-197-384 0-71 172-128 384-128s384 57 384 128c0 144-80 299-197 384z m-187 448c141 0 256-29 256-64s-115-64-256-64-256 29-256 64 115 64 256 64z m-64-706c-154-7-238-40-253-82 16 114 75 189 141 251 73 68 112 60 112 103v-273z m-105 352c-70 55-122 130-142 215 70-32 183-53 311-53s241 21 311 53c-20-85-72-160-142-215-24 17-70 34-169 34s-145-17-169-34z m233-352v273c0-43 39-35 112-103 66-62 125-138 141-251-14 41-99 75-253 82z" horiz-adv-x="768" />
+<glyph glyph-name="hubot" unicode="&#xf09d;" d="M512 768c-283 0-512-229-512-512 0 0 0-192 0-256s64-128 128-128 704 0 768 0 128 64 128 128 0 256 0 256c0 283-229 512-512 512z m96-768h-192c-18 0-32 14-32 32s14 32 32 32h192c18 0 32-14 32-32s-14-32-32-32z m288 128c0-32-32-64-64-64s-128 0-128 0c0 32-32 64-64 64s-224 0-256 0-64-32-64-64c0 0-96 0-128 0s-64 32-64 64 0 360 0 360c78 129 220 216 384 216s306-87 384-216c0 0 0-328 0-360z m-128 384c-32 0-480 0-512 0s-64-32-64-64 0-96 0-128 32-64 64-64 480 0 512 0 64 32 64 64 0 96 0 128-32 64-64 64z m0-128l-64-64h-128l-64 64-64-64h-128l-64 64v64h64l64-64 64 64h128l64-64 64 64h64v-64z" horiz-adv-x="1024" />
+<glyph glyph-name="inbox" unicode="&#xf0cf;" d="M704 640H64L0 256v-256h768V256L704 640zM576 256l-64-128H256l-64 128H79l49 320h512l49-320H576z" horiz-adv-x="768" />
+<glyph glyph-name="info" unicode="&#xf059;" d="M448 448c35 0 64 29 64 64s-29 64-64 64-64-29-64-64 29-64 64-64z m0 320c-247 0-448-201-448-448s201-448 448-448 448 201 448 448-201 448-448 448z m0-768c-177 0-320 143-320 320s143 320 320 320 320-143 320-320-143-320-320-320z m64 320c0 32-32 64-64 64s-32 0-64 0-64-32-64-64h64s0-160 0-192 32-64 64-64 32 0 64 0 64 32 64 64h-64s0 160 0 192z" horiz-adv-x="896" />
+<glyph glyph-name="issue-closed" unicode="&#xf028;" d="M704 515.969l-96-96L768 256l256 256-96 96L769.25 449.219 704 515.969zM512 0c-176.781 0-320 143.25-320 320 0 176.781 143.219 320 320 320 88.375 0 168.375-35.844 226.25-93.75l90.562 90.5C747.75 717.875 635.75 768 512 768 264.562 768 64 567.438 64 320c0-247.438 200.562-448 448-448 247.438 0 448 200.562 448 448L759.75 119.75C768.688 130.75 684.75 0 512 0zM576 576H448v-320h128V576zM448 64h128V192H448V64z" horiz-adv-x="1024" />
+<glyph glyph-name="issue-opened" unicode="&#xf026;" d="M448 768C200.562 768 0 567.438 0 320c0-247.438 200.562-448 448-448 247.438 0 448 200.562 448 448C896 567.438 695.438 768 448 768zM448 0c-176.781 0-320 143.25-320 320 0 176.781 143.219 320 320 320 176.75 0 320-143.219 320-320C768 143.25 624.75 0 448 0zM384 64h128V192H384V64zM384 256h128V576H384V256z" horiz-adv-x="896" />
+<glyph glyph-name="issue-reopened" unicode="&#xf027;" d="M639.125 64.75C585.75 24.625 520 0 448 0c-176.781 0-320 143.25-320 320 0 45.562 9.781 88.781 27 128H64v99.469C24.312 480.562 0 403.406 0 320c0-247.438 200.562-448 448-448 107.375 0 204.5 39.312 281.75 102.25L768-64V128H576L639.125 64.75zM384 64h128V192H384V64zM512 576H384v-320h128V576zM896 320c0 247.438-200.562 448-448 448-107.406 0-204.531-39.312-281.656-102.344L128 704v-192h192l-63.156 63.156C310.281 615.312 376 640 448 640c176.75 0 320-143.219 320-320 0-45.562-9.75-88.75-27-128h91v-99.5C871.688 159.438 896 236.5 896 320z" horiz-adv-x="896" />
+<glyph glyph-name="jersey" unicode="&#xf019;" d="M704 832h-192c0-32-33-64-97-64s-95 32-95 64h-192c0-128-2-384-128-384 0 0-1-544-1-576s32-64 64-64 672 0 704 0 64 32 64 64 0 576 0 576c-126 0-128 256-128 384z m-609-960c-16 0-31 10-31 32 0 32 0 480 0 480 119 64 128 192 128 384h64c0-96 32-191 160-192s160 96 160 192h64c0-186 32-276 64-339v-557s-593 0-609 0z m385 576l-32-32v-320l32-32h128l32 32v320l-32 32h-128z m96-320h-64v256h64v-256z m-352 320l-32-32v-320l32-32h128l32 32v320l-32 32h-128z m96-320h-64v256h64v-256z" horiz-adv-x="896" />
+<glyph glyph-name="jump-down" unicode="&#xf072;" d="M767.75 640H0.25L384 256.25 767.75 640zM0 128v-128h768V128H0z" horiz-adv-x="768" />
+<glyph glyph-name="jump-left" unicode="&#xf0a5;" d="M256.25 320L640-63.75v767.5L256.25 320zM0-64h128V704H0V-64z" horiz-adv-x="640" />
+<glyph glyph-name="jump-right" unicode="&#xf0a6;" d="M0-63.75L383.75 320 0 703.812V-63.75zM512 704v-768h128V704H512z" horiz-adv-x="640" />
+<glyph glyph-name="jump-up" unicode="&#xf073;" d="M0.188 0h767.5L384 383.75 0.188 0zM0 640v-128h768V640H0z" horiz-adv-x="768" />
+<glyph glyph-name="key" unicode="&#xf049;" d="M640.9 768.1c-141.4 0-256-114.6-256-256 0-19.6 2.2-38.6 6.4-56.9L0 64v-64l64-64h128l64 64v64h64v64h64v64h128l70.8 70.8c18.7-4.3 38.1-6.6 58.1-6.6 141.4 0 256 114.6 256 256S782.2 768.1 640.9 768.1zM384 320L64 0v64l320 320V320zM704 512c-35.3 0-64 28.7-64 64 0 35.3 28.7 64 64 64s64-28.7 64-64C768 540.7 739.3 512 704 512z" horiz-adv-x="896.9" />
+<glyph glyph-name="keyboard" unicode="&#xf00d;" d="M640 256h64V384h-64V256zM768 576h-64v-128h64V576zM640 576h-64v-128h64V576zM512 256h64V384h-64V256zM384 64h320V192H384V64zM768 256h128V576h-64v-192h-64V256zM256 64h64V192h-64V64zM768 64h128V192H768V64zM512 576h-64v-128h64V576zM192 384h-64v-128h64V384zM192 192h-64v-128h64V192zM0 704v-768h1024V704H0zM960 0H64V640h896V0zM384 256h64V384h-64V256zM256 576H128v-128h128V576zM384 576h-64v-128h64V576zM256 256h64V384h-64V256z" horiz-adv-x="1024" />
+<glyph glyph-name="law" unicode="&#xf0d8;" d="M514 640c34 1 61 28 62 62 1 37-29 67-66 66-34-1-61-28-62-62-1-37 29-67 66-66z m464-384h-18l-127 246c18 2 36 9 52 16 24 11 29 43 11 62l-1 1c-11 11-28 15-43 8-14-6-34-13-53-13-56 0-81 64-287 64s-231-64-287-64c-20 0-39 6-53 13-15 6-32 3-43-8l-1-1c-18-19-13-50 11-62 16-8 34-14 52-16l-127-246h-18c-8 0-14-7-13-15 11-64 92-113 191-113s180 49 191 113c1 8-5 15-13 15h-18l-127 245c83 7 127 49 191 49v-486c-35 0-64-29-64-64h-71c-28 0-57-29-57-64h512c0 35-29 64-71 64h-57c0 35-29 64-64 64v486c64 0 108-42 191-49l-127-245h-18c-8 0-14-7-13-15 11-64 92-113 191-113s180 49 191 113c1 8-5 15-13 15z m-658 0h-192l96 180 96-180z m384 0l96 180 96-180h-192z" horiz-adv-x="1024" />
+<glyph glyph-name="light-bulb" unicode="&#xf000;" d="M512 768c-176.731 0-320-143.269-320-320 0-104.69 50.278-197.633 128-256.015V0c0-35.346 28.653-64 64-64 0-35.346 28.653-64 64-64h128c35.347 0 64 28.654 64 64 35.347 0 64 28.654 64 64V191.985C781.722 250.36699999999996 832 343.31 832 448 832 624.731 688.731 768 512 768zM640 32c0-17.673-14.326-32-32-32H416c-17.674 0-32 14.327-32 32v32h256V32zM704 278.693c-33.234-33.03-64-42.389-64-124.041V128h-64V256l128 128v64l-64 64-64-64-64 64-64-64-64 64-64-64v-64l128-128v-128h-64v26.652c0 81.652-30.766 91.011-64 124.041C280.177 323.82 256 383.082 256 448c0 141.385 114.615 256 256 256s256-114.615 256-256C768 383.082 743.823 323.82 704 278.693zM512 256L384 384v64l64-64 64 64 64-64 64 64v-64L512 256z" horiz-adv-x="1024" />
+<glyph glyph-name="link" unicode="&#xf05c;" d="M768 576h-138c48-32 93-89 107-128h30c65 0 128-64 128-128s-65-128-128-128h-192c-63 0-128 64-128 128 0 23 7 45 18 64h-137c-5-21-8-42-8-64 0-128 127-256 255-256s65 0 193 0 256 128 256 256-128 256-256 256z m-481-384h-30c-65 0-128 64-128 128s65 128 128 128h192c63 0 128-64 128-128 0-23-7-45-18-64h137c5 21 8 42 8 64 0 128-127 256-255 256s-65 0-193 0-256-128-256-256 128-256 256-256h138c-48 32-93 89-107 128z" horiz-adv-x="1024" />
+<glyph glyph-name="link-external" unicode="&#xf07f;" d="M640 64H128V574.094L256 576V704H0v-768h768V256H640V64zM384 704l128-128L320 384l128-128 192 192 128-128V704H384z" horiz-adv-x="768" />
+<glyph glyph-name="list-ordered" unicode="&#xf062;" d="M320 256h448v128h-448v-128z m0-256h448v128h-448v-128z m0 640v-128h448v128h-448z m-241-256h78v256h-36l-85-23v-50l43 2v-185z m110-206c0 36-12 78-96 78-33 0-64-6-83-16l1-66c21 10 42 15 67 15s32-11 32-28c0-26-30-58-110-112v-50h192v67l-91-2c49 30 87 66 87 113l1 1z" horiz-adv-x="768" />
+<glyph glyph-name="list-unordered" unicode="&#xf061;" d="M0 256h128v128h-128v-128z m0 256h128v128h-128v-128z m0-512h128v128h-128v-128z m256 256h512v128h-512v-128z m0 256h512v128h-512v-128z m0-512h512v128h-512v-128z" horiz-adv-x="768" />
+<glyph glyph-name="location" unicode="&#xf060;" d="M320 832c-177 0-320-143-320-320s160-416 320-704c160 288 320 527 320 704s-143 320-320 320z m0-448c-71 0-128 57-128 128s57 128 128 128 128-57 128-128-57-128-128-128z" horiz-adv-x="640" />
+<glyph glyph-name="lock" unicode="&#xf06a;" d="M704 384c-32 0-64 0-64 0s0 64 0 192-128 256-256 256-256-128-256-256 0-192 0-192-32 0-64 0-64-32-64-64 0-416 0-448 32-64 64-64 608 0 640 0 64 32 64 64 0 416 0 448-32 64-64 64z m-192-128h-384v-64h384v-64h-384v-64h384v-64h-384v-64h384v-64h-448v448h448v-64z m0 128h-256s0 128 0 192 64 128 128 128 128-64 128-128 0-192 0-192z" horiz-adv-x="768" />
+<glyph glyph-name="logo-github" unicode="&#xf092;" d="M552.73 499.865H311.557c-6.205 0-11.25-5.045-11.25-11.297v-117.887c0-6.252 5.045-11.272 11.25-11.272h94.109v-146.542c0 0-21.145-7.057-79.496-7.057-68.914 0-165.156 25.244-165.156 236.795 0 211.642 100.197 239.491 194.307 239.491 81.465 0 116.514-14.304 138.869-21.241 7.01-2.203 13.404 4.831 13.404 11.105L534.543 785.87c0 2.912-1.041 6.417-4.262 8.785C521.186 801.048 465.865 832 326.168 832 165.133 832 0 763.513 0 434.243 0 105.02099999999996 189.051 56 348.381 56c131.883 0 212.021 56.314 212.021 56.314 3.268 1.801 3.6 6.395 3.6 8.479V488.568C563.955 494.773 558.887 499.865 552.73 499.865zM1772.381 803.866h-135.695c-6.252 0-11.271-5.044-11.271-11.296v-262.393h-211.619V792.57c0 6.252-5.068 11.296-11.178 11.296h-135.838c-6.111 0-11.084-5.044-11.084-11.296v-710.473c0-6.299 5.021-11.32 11.084-11.32h135.838c6.203 0 11.178 5.068 11.178 11.32V385.933h211.619l-0.475-303.883c0-6.3 5.021-11.272 11.084-11.272h135.885c6.252 0 11.131 5.068 11.131 11.272l0.473 710.521C1783.607 798.822 1778.539 803.866 1772.381 803.866zM714.949 787.763c-48.357 0-87.574-39.572-87.574-88.403 0-48.855 39.217-88.428 87.574-88.428s87.527 39.572 87.527 88.428C802.477 748.19 763.307 787.763 714.949 787.763zM792.861 559.874c0 6.205-5.02 11.344-11.131 11.344H646.32c-6.348 0-11.746-6.394-11.746-12.67 0 0 0-394.654 0-469.867 0-13.735 8.572-17.903 19.703-17.903 0 0 57.688 0 121.959 0 13.311 0 16.814 6.536 16.814 18.188-0.094 25.197-0.094 123.808-0.094 142.942C792.861 250.09500000000003 792.861 559.874 792.861 559.874zM2297.973 570.152h-134.701c-6.158 0-11.084-5.092-11.084-11.344v-348.31c0 0-34.244-25.197-82.934-25.197-48.547 0-61.525 22.024-61.525 69.719 0 47.553 0 303.835 0 303.835 0 6.252-5.068 11.345-11.131 11.345h-136.643c-6.252 0-11.178-5.093-11.178-11.345 0 0 0-185.521 0-326.807 0-141.284 78.766-175.906 186.99-175.906 88.854 0 160.609 49.115 160.609 49.115s3.363-25.766 5.068-28.844c1.422-3.078 5.447-6.158 9.852-6.158h86.58c6.158 0 11.178 5.069 11.178 11.321l0.379 477.278C2309.15 565.0609999999999 2304.129 570.152 2297.973 570.152zM2666.932 586.1610000000001c-76.539 0-128.592-34.148-128.592-34.148V792.57c0 6.252-5.068 11.296-11.131 11.296h-136.264c-6.109 0-11.131-5.044-11.131-11.296l-0.379-710.521c0-6.3 5.068-11.272 11.225-11.272 0 0 94.773 0 94.869 0 4.215 0 7.389 2.179 9.805 5.968 2.369 3.837 5.73 32.775 5.73 32.775s55.557-52.763 161.035-52.763c123.807 0 194.758 62.804 194.758 281.906C2856.859 557.482 2743.471 586.1610000000001 2666.932 586.1610000000001zM2613.791 185.77499999999998c-46.701 1.421-78.34 22.64-78.34 22.64v225.07c0 0 31.307 19.206 69.672 22.593 48.547 4.31 95.438-10.326 95.438-126.13C2700.322 207.94100000000003 2679.199 183.83399999999995 2613.791 185.77499999999998zM1185.125 188.33299999999997c-5.969 0-21.219-2.368-36.85-2.368-49.92 0-66.971 23.256-66.971 53.331 0 30.218 0 199.85 0 199.85h101.926c6.252 0 11.178 5.044 11.178 11.343v109.48c0.094 6.299-4.926 11.344-11.178 11.344h-101.926l-0.143 134.535c0 5.092-2.699 7.625-8.572 7.625H933.861c-5.352 0-8.336-2.391-8.336-7.578v-139.035c0 0-69.576-16.79-74.266-18.188-4.641-1.326-8.051-5.684-8.051-10.822v-87.408c0-6.252 5.068-11.344 11.178-11.344h71.139c0 0 0-91.34 0-210.222 0-156.109 109.553-171.455 183.439-171.455 33.723 0 74.076 10.988 80.848 13.356 4.074 1.421 6.395 5.637 6.395 10.136l0.047 96.101C1196.254 183.312 1190.998 188.428 1185.125 188.33299999999997z" horiz-adv-x="2856.857" />
+<glyph glyph-name="mail" unicode="&#xf03b;" d="M0 640v-640h896V640H0zM768 576L448 312 128 576H768zM64 512l252.031-191.625L64 128V512zM128 64l254 206.25L448 220l65.875 50.125L768 64H128zM832 128L579.625 320.062 832 512V128z" horiz-adv-x="896" />
+<glyph glyph-name="mail-read" unicode="&#xf03c;" d="M576 448H256v-64h320V448zM384 576H256v-64h128V576zM768 603.469V704H627.188L448 832 268.812 704H128v-100.531L0 512v-640h896V512L768 603.469zM192 640h512v-244.812L448 184 192 395.188V640zM64 384l252.031-191.625L64 0V384zM128-64l254 206.25L448 92l65.875 50.125L768-64H128zM832 0L579.625 192.062 832 384V0z" horiz-adv-x="896" />
+<glyph glyph-name="mail-reply" unicode="&#xf051;" d="M384 672l-384-288 384-288v192c111 0 329-61 384-280 0 291-196 451-384 472v192z" horiz-adv-x="768" />
+<glyph glyph-name="mark-github" unicode="&#xf00a;" d="M512 832C229.25 832 0 602.75 0 320c0-226.25 146.688-418.125 350.156-485.812 25.594-4.688 34.938 11.125 34.938 24.625 0 12.188-0.469 52.562-0.719 95.312C242-76.81200000000001 211.906 14.5 211.906 14.5c-23.312 59.125-56.844 74.875-56.844 74.875-46.531 31.75 3.53 31.125 3.53 31.125 51.406-3.562 78.47-52.75 78.47-52.75 45.688-78.25 119.875-55.625 149-42.5 4.654 33 17.904 55.625 32.5 68.375C304.906 106.56200000000001 185.344 150.5 185.344 346.688c0 55.938 19.969 101.562 52.656 137.406-5.219 13-22.844 65.094 5.062 135.562 0 0 42.938 13.75 140.812-52.5 40.812 11.406 84.594 17.031 128.125 17.219 43.5-0.188 87.312-5.875 128.188-17.281 97.688 66.312 140.688 52.5 140.688 52.5 28-70.531 10.375-122.562 5.125-135.5 32.812-35.844 52.625-81.469 52.625-137.406 0-196.688-119.75-240-233.812-252.688 18.438-15.875 34.75-47 34.75-94.75 0-68.438-0.688-123.625-0.688-140.5 0-13.625 9.312-29.562 35.25-24.562C877.438-98 1024 93.875 1024 320 1024 602.75 794.75 832 512 832z" horiz-adv-x="1024" />
+<glyph glyph-name="markdown" unicode="&#xf0c9;" d="M950.154 640H73.846C33.127 640 0 606.873 0 566.154v-492.308C0 33.125 33.127 0 73.846 0h876.308c40.721 0 73.846 33.125 73.846 73.846V566.154C1024 606.873 990.875 640 950.154 640zM576 128.125L448 128V320l-96-123.077L256 320v-192H128V512h128l96-128 96 128 128 0.125V128.125zM767.091 96.125L608 320h96V512h128v-192h96L767.091 96.125z" horiz-adv-x="1024" />
+<glyph glyph-name="megaphone" unicode="&#xf077;" d="M832 800c-130 0-124-130-704-128C57.344 672 0 557.375 0 416s57.344-256 128-256c22.781 0 43.188-0.5 64.188-0.875L256-128l192-32 64 96-45.125 203.125C709.375 102.875 733.75 32 832 32c106 0 192 172 192 384C1024 628.031 938 800 832 800zM197 349.062c-39.188 1.469-82.188 2.25-127.562 2.625C66 371.406 64 393.094 64 416c0 88.375 28.688 192 64 192 39.031-0.125 75 0.438 109 1.406C209.656 562.438 192 493.688 192 416 192 392.688 194.062 370.562 197 349.062zM261.312 346.062C258.125 368.312 256 391.625 256 416c0 79.5 18.438 149.5 46.906 196.219 155.156 8.312 251.906 28.469 319.031 50.188C593.625 595.531 576 510.344 576 416c0-40 3.875-78 9.5-114.312C513.344 320.375 412.812 337.406 261.312 346.062zM832 128c-12.125 0-23.688 5.062-34.812 12.125-15.25 67.312-83.438 418.344 117.438 494.188C942.125 581.5 960 503.812 960 416 960 257 902.625 128 832 128z" horiz-adv-x="1024" />
+<glyph glyph-name="mention" unicode="&#xf0be;" d="M466.697 732.899C238.66 760.898 31.1 598.735 3.102 370.698c-28-228.038 134.163-435.598 362.2-463.597 71.429-8.756 145.115 0.913 213.325 29.946l-0.016 0.032c24.404 10.357 35.788 38.538 25.431 62.939-10.359 24.403-38.538 35.787-62.94 25.43l-0.001 0.004c-52.472-22.339-109.15-29.799-164.1-23.067-175.413 21.538-300.153 181.2-278.616 356.613 21.538 175.413 181.199 300.154 356.613 278.616 175.412-21.538 300.154-181.199 278.617-356.612-4.309-35.083-21.542-55.725-61.6-55.725-42.5 0-64 45.889-64 81.222V432c0 26.51-21.49 48-48 48-9.699 0-18.72-2.887-26.269-7.833-25.684 20.259-57.437 33.87-94.349 38.402-105.246 12.923-201.045-61.924-213.967-167.17C212.508 238.15200000000004 287.354 142.35400000000004 392.6 129.43200000000002c57.379-7.045 116.216 14.707 157.871 53.13 24.959-28.124 59.866-47.624 100.121-52.567 87.707-10.769 167.537 51.602 178.307 139.309C856.898 497.34 694.734 704.899 466.697 732.899zM511.285 308.30100000000004c-6.462-52.623-54.361-90.047-106.985-83.585-52.623 6.461-90.046 54.36-83.585 106.984 6.461 52.623 54.361 90.046 106.984 83.585C480.322 408.823 517.746 360.924 511.285 308.30100000000004z" horiz-adv-x="832" />
+<glyph glyph-name="microscope" unicode="&#xf089;" d="M617-64c86.312 18.75 151 100 151 192 0 58.438-26.625 110.125-67.875 145.375C702.5 288.625 704 304.125 704 320c0 104.844-49.875 197.875-128 256l64 64v64l64 64L640 832l-64-64h-64L256 512l-128-64v-128l64-64h128l64 128 96 96c55.5-33.406 96-90.438 96-160-106.062 0-192-85.938-192-192H0v-64h192c19.125-14.25 42.062-22.125 64-32v-96H128L0-192h768L640-64H617zM512 128c0 35.375 28.625 64 64 64s64-28.625 64-64c0-35.312-28.625-64-64-64S512 92.68799999999999 512 128z" horiz-adv-x="768" />
+<glyph glyph-name="milestone" unicode="&#xf075;" d="M704 640H0v-256h704l128 128L704 640zM448 448H320V576h128V448zM448 832H320v-128h128V832zM320-192h128V320H320V-192z" horiz-adv-x="832" />
+<glyph glyph-name="mirror" unicode="&#xf024;" d="M320 512L128 320l192-192V256h384v-128l192 192L704 512v-128H320V512zM512 832L0 512v-704l512 256 512-256V512L512 832zM960-64L576 128v64H448v-64L64-64V448l384 256v-256h128V704l384-256V-64z" horiz-adv-x="1024" />
+<glyph glyph-name="mortar-board" unicode="&#xf0d7;" d="M501 244l-245 76s0-96 0-160 115-96 256-96 256 32 256 96 0 160 0 160l-245-76c-7-2-15-2-23 0h1z m18 409c-4 1-9 1-13 0l-489-152c-21-7-21-36 0-43l111-35v-113c-19-11-32-32-32-55 0-12 3-23 9-32-5-9-9-20-9-32v-165c0-35 128-35 128 0v165c0 12-3 23-9 32 5 9 9 20 9 32 0 24-13 44-32 55v93l313-98c4-1 9-1 13 0l489 152c21 7 21 36 0 43l-488 153z m-6-205c-35 0-64 14-64 32s29 32 64 32 64-14 64-32-29-32-64-32z" horiz-adv-x="1024" />
+<glyph glyph-name="move-down" unicode="&#xf0a8;" d="M640 512H448V832H192v-320H0l320-384L640 512zM0-192h640V0H0V-192z" horiz-adv-x="640" />
+<glyph glyph-name="move-left" unicode="&#xf074;" d="M0 0h192V640H0V0zM704 448V640L320 320l384-320V192h320V448H704z" horiz-adv-x="1024" />
+<glyph glyph-name="move-right" unicode="&#xf0a9;" d="M832 640v-640h192V640H832zM320 448H0v-256h320v-192l384 320L320 640V448z" horiz-adv-x="1024" />
+<glyph glyph-name="move-up" unicode="&#xf0a7;" d="M0 128h192v-320h256V128h192L320 512 0 128zM0 832v-192h640V832H0z" horiz-adv-x="640" />
+<glyph glyph-name="mute" unicode="&#xf080;" d="M128 448H0v-256h128l256-192h64V640h-64L128 448zM864 416l-64 64-96-96-96 96-63-63.5 95-96.5-96-96 64-64 96 96 96-96 64 64-96 96L864 416z" horiz-adv-x="896" />
+<glyph glyph-name="no-newline" unicode="&#xf09c;" d="M896 512v-128H768V512L576 320l192-192V256h192c0 0 64 0.375 64 64s0 192 0 192H896zM224 544C100.281 544 0 443.719 0 320c0-123.75 100.281-224 224-224s224 100.25 224 224C448 443.719 347.719 544 224 544zM96 320c0 70.656 57.344 128 128 128 18.75 0 36.406-4.219 52.469-11.531L107.531 267.5C100.219 283.625 96 301.25 96 320zM224 192c-18.75 0-36.406 4.25-52.469 11.5l168.938 168.969C347.781 356.406 352 338.75 352 320 352 249.375 294.656 192 224 192z" horiz-adv-x="1024" />
+<glyph glyph-name="octoface" unicode="&#xf008;" d="M940.812 554.312c8.25 20.219 35.375 101.75-8.562 211.906 0 0-67.375 21.312-219.875-82.906C648.5 700.875 579.875 703.5 512 703.5c-67.906 0-136.438-2.625-200.5-20.25C159.031 787.531 91.719 766.219 91.719 766.219 47.812 656 74.938 574.531 83.188 554.312 31.5 498.438 0 427.125 0 339.656 0 10.437999999999988 213.25-64 510.844-64 808.562-64 1024 10.437999999999988 1024 339.656 1024 427.125 992.5 498.438 940.812 554.312zM512-1c-211.406 0-382.781 9.875-382.781 214.688 0 48.938 24.062 94.595 65.344 132.312 68.75 62.969 185.281 29.688 317.438 29.688 132.25 0 248.625 33.281 317.438-29.625 41.312-37.78 65.438-83.312 65.438-132.312C894.875 8.875 723.375-1 512-1zM351.156 319.562c-42.469 0-76.906-51.062-76.906-114.188s34.438-114.312 76.906-114.312c42.375 0 76.812 51.188 76.812 114.312S393.531 319.562 351.156 319.562zM672.875 319.562C630.5 319.562 596 268.5 596 205.375s34.5-114.312 76.875-114.312 76.812 51.188 76.812 114.312C749.75 268.5 715.312 319.562 672.875 319.562z" horiz-adv-x="1024" />
+<glyph glyph-name="organization" unicode="&#xf037;" d="M768 448h-64H576h-64-64-64-64H192h-64C57.344 448 0 390.656 0 320v-64c0-47.25 25.844-88.062 64-110.25V-64h256v-128h256V-64h256V145.75c38.125 22.188 64 62.938 64 110.25v64C896 390.656 838.625 448 768 448zM256 0H128V256H64v64c0 35.312 28.688 64 64 64h81.719c-11-18.875-17.719-40.562-17.719-64v-128c0-47.25 25.844-88.062 64-110.25V0zM576 128V256h-64v-384H384V256h-64v-128c-35.312 0-64 28.625-64 64V320c0 35.312 28.688 64 64 64h256c35.375 0 64-28.688 64-64v-128C640 156.625 611.375 128 576 128zM832 256h-64v-256H640v81.75c38.125 22.188 64 62.938 64 110.25V320c0 23.438-6.75 45.125-17.75 64H768c35.375 0 64-28.688 64-64V256zM303.688 514.625C338.875 474.125 390.156 448 448 448c57.875 0 109.125 26.125 144.312 66.625C614.125 475.062 655.688 448 704 448c70.625 0 128 57.344 128 128s-57.375 128-128 128c-25.625 0-49.375-7.688-69.375-20.688C614.875 768.438 539.062 832 448 832S281.094 768.438 261.375 683.312C241.344 696.312 217.594 704 192 704c-70.656 0-128-57.344-128-128s57.344-128 128-128C240.312 448 281.844 475.062 303.688 514.625zM704 640c35.375 0 64-28.594 64-64s-28.625-64-64-64c-35.312 0-64 28.594-64 64S668.688 640 704 640zM448 768c70.625 0 128-57.344 128-128s-57.375-128-128-128c-70.656 0-128 57.344-128 128S377.344 768 448 768zM192 512c-35.312 0-64 28.594-64 64s28.688 64 64 64c35.406 0 64-28.594 64-64S227.406 512 192 512z" horiz-adv-x="896" />
+<glyph glyph-name="package" unicode="&#xf0c4;" d="M480 768L0 640v-576l480-128 480 128V640L480 768zM63.875 111.06600000000003L63.5 544l384.498-102.533 0.001-432.833L63.875 111.06600000000003zM63.5 608l160.254 42.734L640 539.735v-0.135l-160-42.667L63.5 608zM896.125 111.06600000000003L512.001 8.634000000000015l0.001 432.833L640 475.6v-156l128 34.135V509.733L896.5 544 896.125 111.06600000000003zM768 573.733v0.125L351.734 684.862 480 719.066 896.5 608 768 573.733z" horiz-adv-x="1024" />
+<glyph glyph-name="paintcan" unicode="&#xf0d1;" d="M384 832C171.923 832 0 660.077 0 448v-64c0-35.346 28.654-64 64-64v-320c0-70.692 143.269-128 320-128s320 57.308 320 128V320c35.346 0 64 28.654 64 64v64C768 660.077 596.077 832 384 832zM576 192v-32c0-17.673-14.327-32-32-32s-32 14.327-32 32v32c0 17.673-14.327 32-32 32s-32-14.327-32-32v-160c0-17.673-14.327-32-32-32s-32 14.327-32 32V160c0 17.673-14.327 32-32 32s-32-14.327-32-32v-32c0-35.346-28.654-64-64-64s-64 28.654-64 64v64c-35.346 0-64 28.654-64 64V371.193C186.382 340.108 279.318 320 384 320s197.618 20.108 256 51.193V256C640 220.654 611.346 192 576 192zM384 384c-107.433 0-199.393 26.474-237.372 64 37.979 37.526 129.939 64 237.372 64s199.393-26.474 237.372-64C583.393 410.474 491.433 384 384 384zM384 576c-176.62 0-319.816-57.236-319.996-127.867-0.001 0.001-0.002 0.001-0.003 0.002C64.075 624.804 207.314 768 384 768c176.731 0 320-143.269 320-320C704 518.692 560.731 576 384 576z" horiz-adv-x="768" />
+<glyph glyph-name="pencil" unicode="&#xf058;" d="M704 768L576 640l192-192 128 128L704 768zM0 64l0.688-192.562L192-128l512 512L512 576 0 64zM192-64H64V64h64v-64h64V-64z" horiz-adv-x="896" />
+<glyph glyph-name="person" unicode="&#xf018;" d="M448 640C448 746 362.062 832 256 832S64 746 64 640c0-106.062 85.938-192 192-192S448 533.938 448 640zM256 512c-70.656 0-128 57.344-128 128S185.344 768 256 768c70.625 0 128-57.344 128-128S326.625 512 256 512zM384 448H256 128C57.344 448 0 390.656 0 320v-128c0-70.625 57.344-128 128-128v-256h256V64c70.625 0 128 57.375 128 128V320C512 390.656 454.625 448 384 448zM448 192c0-35.375-28.625-64-64-64V256h-64v-384H192V256h-64v-128c-35.312 0-64 28.625-64 64V320c0 35.312 28.688 64 64 64h256c35.375 0 64-28.688 64-64V192z" horiz-adv-x="512" />
+<glyph glyph-name="pin" unicode="&#xf041;" d="M196 128l64-320 64 320c-20-2-43-3-64-3s-44 1-64 3z m254 299c-33 17-62 59-62 85v64c0 22 12 39 23 52 15 13 24 29 24 45 0 53-61 95-175 95s-175-42-175-95c0-16 9-32 24-45 11-13 23-30 23-52v-64c0-26-29-68-62-85-38-19-70-54-70-88 0-74 101-148 260-148s260 73 260 148c0 33-31 68-70 88z" horiz-adv-x="519.657" />
+<glyph glyph-name="playback-fast-forward" unicode="&#xf0bd;" d="M0 64l384 256L0 576V64zM768 320L384 576v-256-256L768 320z" horiz-adv-x="768" />
+<glyph glyph-name="playback-pause" unicode="&#xf0bb;" d="M0 0h192V640H0V0zM320 640v-640h192V640H320z" horiz-adv-x="512" />
+<glyph glyph-name="playback-play" unicode="&#xf0bf;" d="M0 640l512-320L0 0V640z" horiz-adv-x="512" />
+<glyph glyph-name="playback-rewind" unicode="&#xf0bc;" d="M384 320l384-256V576L384 320zM0 320l384-256V320 576L0 320z" horiz-adv-x="768" />
+<glyph glyph-name="plug" unicode="&#xf0d4;" d="M1003.386 627.336l-0.905 0.905c-24.744 24.744-64.861 24.744-89.605 0l-45.707-45.707-90.51 90.51 45.707 45.707c24.744 24.744 24.744 64.861 0 89.605l-0.905 0.905c-24.744 24.744-64.861 24.744-89.605 0l-47.973-47.973C621.76 802.446 537.237 795.66 482.502 740.926l-24.89-24.89c-109.011-109.011-121.948-277.692-38.854-400.892l-4.138-4.138c-62.392-62.392-62.484-163.493-0.275-225.999 12.41-12.469 12.642-33.327 0.121-45.683-12.509-12.343-32.655-12.292-45.101 0.153l-89.427 89.427c-62.637 62.638-164.63 63.747-227.299 1.141-62.542-62.479-62.562-163.829-0.058-226.332l8.763-8.763c24.744-24.744 64.861-24.744 89.605 0l0.905 0.905c24.744 24.744 24.744 64.861 0 89.605l-8.292 8.292c-12.329 12.329-13.085 32.418-1.098 45.081 12.437 13.138 33.174 13.353 45.882 0.645l89.328-89.328c62.92-62.92 165.504-63.814 228.081-0.553 61.793 62.468 61.65 163.161-0.431 225.451-12.55 12.592-12.777 32.866-0.207 45.437l4.151 4.151c123.2-83.095 291.881-70.158 400.892 38.854l24.89 24.89c54.734 54.735 61.52 139.258 20.362 201.382l47.973 47.973C1028.129 562.475 1028.129 602.593 1003.386 627.336zM889.796 333.632c-37.49-37.49-98.274-37.49-135.765 0L527.757 559.906c-37.49 37.49-37.49 98.274 0 135.765 29.556 29.556 73.585 35.804 109.269 18.759l-41.839-41.839c-24.744-24.744-24.744-64.861 0-89.604l0.905-0.905c24.744-24.744 64.861-24.744 89.605 0l45.707 45.707 90.51-90.51-45.707-45.707c-24.744-24.744-24.744-64.861 0-89.605l0.905-0.905c24.744-24.744 64.861-24.744 89.604 0l41.839 41.839C925.6 407.218 919.351 363.188 889.796 333.632z" horiz-adv-x="1024" />
+<glyph glyph-name="plus" unicode="&#xf05d;" d="M384 384V640H256v-256H0v-128h256v-256h128V256h256V384H384z" horiz-adv-x="640" />
+<glyph glyph-name="podium" unicode="&#xf0af;" d="M320 832c-32 0-64-32-64-64s0-64 0-64h-64l-192-192v-128h192l64-384-128-64v-64h512v64l-128 64 64 384h192v128l-192 192h-256v64s14 0 32 0 32 17 32 32-16 32-32 32 0 0-32 0z m0-832l-53 320h118l-1-320h-64z m-224 512l128 128h32v-64h64v64h224l128-128h-576z" horiz-adv-x="768" />
+<glyph glyph-name="primitive-dot" unicode="&#xf052;" d="M-0.088 320c0 141.5 114.5 256 256 256 141.438 0 256-114.5 256-256s-114.562-256-256-256C114.413 64-0.088 178.5-0.088 320z" horiz-adv-x="511.825" />
+<glyph glyph-name="primitive-square" unicode="&#xf053;" d="M512 64H0V576h512V64z" horiz-adv-x="512" />
+<glyph glyph-name="pulse" unicode="&#xf085;" d="M736 320.062L563.188 486.406 422.406 288 352 729.594 152.438 320.062H0V192h230.406L288 307.188l57.594-345.562L576 288l102.375-96H896V320.062H736z" horiz-adv-x="896" />
+<glyph glyph-name="puzzle" unicode="&#xf0c0;" d="M755.75 256.85c-13.95 9.96-28.52 16.59-43.47 19.92-8.84 1.69-18.06 2.33-27.57 1.81-8.99-0.5-17.56-1.68-25.69-3.52-6.1-1.69-12.22-3.89-18.35-6.59-18.18-8.02-33.89-18.12-46.79-30.33-12.22-12.9-22.32-28.62-30.34-46.79-2.7-6.12-4.9-12.24-6.59-18.34-1.84-8.14-3.03-16.7-3.52-25.69-0.52-9.51 0.12-18.73 1.81-27.57 3.33-14.95 9.96-29.52 19.92-43.47 3.89-5.44 8.08-10.4 12.56-14.88 20.06-20.03 45.83-30.7 75.42-34.11 8.92-1.02 18.12-1.68 26.53-4.48 5.12-1.7 9.16-4.08 12.08-7.02 6.65-6.6 7.63-16.1 2.5-27.24-3.15-6.84-7.7-13.45-12.96-18.84l-2.79-2.86c-3.93-3.92-6.41-6.4-7.05-7.04-3.13-3.16-6.1-6.15-9.06-9.15l-2.96-2.92c-10.52-10.58-21.09-21.12-31.66-31.65-22.76-22.82-45.57-45.58-68.38-68.36-7.5-7.5-15-15-22.5-22.49-3.46-3.45-7.07-6.38-10.78-8.79-1.8-1.22-3.49-2.24-5.18-3.16-19.6-9.89-41.43-5.92-59.24 11.88-5.4 5.4-10.62 10.62-15.85 15.84-30.25 30.25-60.48 60.52-90.77 90.73-8.59 8.57-17.13 17.08-25.68 25.59-6.12 6.09-12.67 11.85-19.56 17.06-5.72 4.33-11.59 7.56-17.46 9.73-21.16 7.32-41.41 2.01-54.67-13.26-3.81-4.8-7-10.47-9.39-16.94-3.43-9.26-4.6-19.47-5.9-29.36-4.9-37.53-25.8-68.43-55.98-82.65-7.48-3.65-15.49-6.29-23.9-7.78-7.95-1.41-15.95-1.71-23.85-1.04-26.61 1.35-49.48 13.09-68.51 32.57-1.68 1.67-2.1 2.09-2.51 2.51-19.48 19.02-31.22 41.9-32.57 68.5-0.68 7.9-0.37 15.9 1.04 23.85 1.49 8.41 4.13 16.43 7.78 23.9 14.22 30.18 45.13 51.07 82.65 55.97 9.89 1.29 20.1 2.47 29.36 5.9 6.94 2.56 12.96 6.05 17.97 10.23 14.54 13.15 19.59 32.63 12.84 52.34-2.78 7.35-6 13.22-10.33 18.94-5.21 6.88-10.97 13.43-17.06 19.55-8.51 8.55-17.03 17.09-25.55 25.63-26.92 26.98-53.84 53.88-80.75 80.78l-10.03 10.03c-5.22 5.22-10.45 10.45-15.26 15.27-18.39 18.4-22.35 40.22-12.46 59.82 0.92 1.69 1.94 3.37 3.08 5.05 2.49 3.84 5.42 7.45 8.87 10.91 7.49 7.5 14.99 15 22.49 22.5 22.77 22.81 45.54 45.62 68.36 68.38 10.53 10.57 21.06 21.14 31.65 31.66l2.92 2.96c2.99 2.97 5.99 5.93 8.98 8.9 0.8 0.81 3.28 3.29 7.2 7.22l2.86 2.79c5.39 5.26 12 9.8 18.84 12.96 11.14 5.13 20.63 4.15 27.24-2.5 2.94-2.92 5.32-6.96 7.02-12.08 2.79-8.41 3.45-17.61 4.48-26.53 3.41-29.59 14.08-55.35 34.11-75.41 4.49-4.48 9.44-8.67 14.88-12.56 13.95-9.96 28.52-16.59 43.47-19.92 8.84-1.69 18.06-2.33 27.57-1.81 8.99 0.5 17.56 1.68 25.69 3.52 6.1 1.69 12.22 3.89 18.35 6.59 18.18 8.02 33.89 18.12 46.79 30.33 12.22 12.9 22.32 28.62 30.34 46.79 2.7 6.12 4.9 12.24 6.59 18.34 1.84 8.14 3.03 16.7 3.52 25.69 0.52 9.51-0.12 18.73-1.81 27.57-3.33 14.95-9.96 29.52-19.92 43.47-3.89 5.44-8.08 10.4-12.56 14.88-20.06 20.03-45.83 30.7-75.42 34.11-8.92 1.02-18.12 1.68-26.53 4.48-5.12 1.7-9.16 4.08-12.08 7.02-6.65 6.6-7.63 16.1-2.5 27.24 3.15 6.84 7.7 13.45 12.96 18.84l2.79 2.86c3.93 3.92 6.41 6.4 7.05 7.04 3.13 3.16 6.1 6.15 9.06 9.15l2.96 2.92c10.52 10.58 21.09 21.12 31.66 31.65 22.76 22.82 45.57 45.58 68.38 68.35 7.5 7.5 15 15 22.5 22.49 3.46 3.45 7.07 6.38 10.78 8.79 1.8 1.22 3.49 2.24 5.18 3.16 19.6 9.89 41.43 5.92 59.24-11.88 5.4-5.4 10.62-10.62 15.85-15.84 30.25-30.25 60.48-60.52 90.77-90.73 8.59-8.57 17.13-17.08 25.68-25.59 6.12-6.09 12.67-11.85 19.56-17.06 5.72-4.33 11.59-7.56 17.46-9.73 21.16-7.32 41.41-2.01 54.67 13.26 3.81 4.8 7 10.47 9.39 16.94 3.43 9.26 4.6 19.47 5.9 29.36 4.9 37.53 25.8 68.43 55.98 82.65 7.48 3.65 15.49 6.28 23.9 7.78 7.95 1.41 15.95 1.71 23.85 1.04 26.61-1.35 49.48-13.09 68.51-32.57 1.68-1.67 2.1-2.09 2.51-2.51 19.48-19.02 31.22-41.9 32.57-68.5 0.68-7.9 0.37-15.9-1.04-23.85-1.49-8.41-4.13-16.43-7.78-23.9-14.22-30.18-45.13-51.07-82.65-55.97-9.89-1.29-20.1-2.47-29.36-5.9-6.94-2.56-12.96-6.05-17.97-10.23-14.54-13.15-19.59-32.63-12.84-52.34 2.78-7.35 6-13.22 10.33-18.94 5.21-6.88 10.97-13.43 17.06-19.55 8.51-8.55 17.03-17.09 25.55-25.63 30.26-30.33 60.54-60.56 90.78-90.81 5.22-5.22 10.45-10.45 15.26-15.27 18.39-18.4 22.35-40.22 12.46-59.82-0.92-1.69-1.94-3.37-3.08-5.05-2.49-3.84-5.42-7.45-8.87-10.91-7.49-7.5-14.99-15-22.49-22.5-22.77-22.81-45.54-45.62-68.36-68.38-10.53-10.57-21.06-21.14-31.65-31.66l-2.92-2.96c-2.99-2.97-5.99-5.93-8.98-8.9-0.8-0.81-3.28-3.29-7.2-7.22l-2.86-2.79c-5.39-5.26-12-9.8-18.84-12.96-11.14-5.13-20.63-4.15-27.24 2.5-2.94 2.92-5.32 6.96-7.02 12.08-2.79 8.41-3.45 17.61-4.48 26.53-3.41 29.59-14.08 55.35-34.11 75.41C766.15 248.76999999999998 761.19 252.97000000000003 755.75 256.85z" horiz-adv-x="1024" />
+<glyph glyph-name="question" unicode="&#xf02c;" d="M448 64h128v128h-128v-128z m64 512c-96 0-192-96-192-192h128c0 32 32 64 64 64s64-32 64-64c0-64-128-64-128-128h128c64 22 128 64 128 160s-96 160-192 160z m0 256c-283 0-512-229-512-512s229-512 512-512 512 229 512 512-229 512-512 512z m0-896c-212 0-384 172-384 384s172 384 384 384 384-172 384-384-172-384-384-384z" horiz-adv-x="1024" />
+<glyph glyph-name="quote" unicode="&#xf063;" d="M0 320v-256h256V320H128c0 0 0 128 128 128V576C256 576 0 576 0 320zM640 448V576c0 0-256 0-256-256v-256h256V320H512C512 320 512 448 640 448z" horiz-adv-x="640" />
+<glyph glyph-name="radio-tower" unicode="&#xf030;" d="M306.838 441.261c15.868 16.306 15.868 42.731 0 59.037-20.521 21.116-30.643 48.417-30.705 76.124 0.062 27.77 10.183 55.039 30.705 76.186 15.868 16.337 15.868 42.764 0 59.069-7.934 8.184-18.272 12.275-28.706 12.275-10.371 0-20.804-4.029-28.738-12.213-36.266-37.297-54.633-86.433-54.57-135.317-0.062-48.792 18.305-97.927 54.57-135.161C265.262 424.955 290.97 424.955 306.838 441.261zM149.093 798.858c-8.121 8.309-18.68 12.463-29.3 12.463-10.558 0-21.179-4.154-29.237-12.463C30.8 737.509 0.751 656.856 0.813 576.422 0.751 496.081 30.8 415.272 90.494 353.985c16.181-16.618 42.356-16.618 58.537 0 16.118 16.587 16.118 43.513 0 60.067-43.7 44.98-65.44 103.456-65.44 162.368s21.74 117.449 65.44 162.368C165.149 755.439 165.149 782.365 149.093 798.858zM513.031 472.153c57.351 0 103.956 46.574 103.956 103.956 0 57.382-46.605 103.955-103.956 103.955-57.381 0-103.956-46.573-103.956-103.955C409.076 518.727 455.65 472.153 513.031 472.153zM933.539 798.233c-16.181 16.618-42.355 16.618-58.475 0-16.181-16.587-16.181-43.513 0-60.068 43.668-44.918 65.409-103.456 65.409-162.368 0-58.85-21.805-117.387-65.473-162.306-16.117-16.618-16.117-43.575 0.062-60.068 8.059-8.309 18.616-12.463 29.237-12.463 10.558 0 21.178 4.154 29.236 12.463 59.726 61.287 89.774 142.096 89.649 222.437C1023.313 656.138 993.264 736.947 933.539 798.233zM513.281 389.127L513.281 389.127c-26.489-0.062-53.04 6.466-77.091 19.429L235.057-127.59000000000003h95.209l54.819 63.973h255.891l53.977-63.973h95.272L589.124 408.431C565.384 395.655 539.395 389.127 513.281 389.127zM512.656 358.483L577.004 128.29999999999995H449.059L512.656 358.483zM385.086 0.3550000000000182l63.974 63.973h127.944l63.974-63.973H385.086zM717.194 710.958c-15.868-16.306-15.868-42.731 0-59.037 20.491-21.116 30.611-48.511 30.674-76.124-0.062-27.77-10.183-55.102-30.674-76.187-15.868-16.336-15.868-42.763 0-59.068 7.871-8.184 18.242-12.213 28.737-12.213 10.309 0 20.741 4.029 28.675 12.213 36.298 37.234 54.665 86.433 54.54 135.255 0.125 48.792-18.181 97.927-54.54 135.161C758.801 727.264 733.062 727.264 717.194 710.958z" horiz-adv-x="1024" />
+<glyph glyph-name="repo" unicode="&#xf001;" d="M320 576h-64v-64h64v64z m0 128h-64v-64h64v64z m384 128c-32 0-608 0-640 0s-64-32-64-64 0-736 0-768 32-64 64-64 128 0 128 0v-128l96 96 96-96v128s288 0 320 0 64 32 64 64 0 736 0 768-32 64-64 64z m0-800c0-16-15-32-32-32s-288 0-288 0v64h-192v-64s-79 0-96 0-32 17-32 32 0 96 0 96h640s0-80 0-96z m0 160h-512v576h513l-1-576z m-384 128h-64v-64h64v64z m0 128h-64v-64h64v64z" horiz-adv-x="768" />
+<glyph glyph-name="repo-clone" unicode="&#xf04c;" d="M320 448h-64v-64h64v64z m-128 320h256v64s-352 0-384 0-64-32-64-64 0-736 0-768 32-64 64-64 128 0 128 0v-128l96 96 96-96v128s286 0 320 0 64 32 64 64 0 192 0 192h-576v576z m512-640s0-79 0-96-14-32-32-32-288 0-288 0v64h-192v-64s-80 0-96 0-32 16-32 32 0 96 0 96h640z m-384 448h-64v-64h64v64z m-64-320h64v64h-64v-64z m704 576c-32 0-288 0-320 0s-64-32-64-64 0-352 0-384 32-64 64-64 64 0 64 0v-64l32 32 32-32v64s160 0 192 0 64 32 64 64 0 352 0 384-32 64-64 64z m-256-448s-15 0-32 0-32 15-32 32 0 32 0 32h64v-64z m256 32c0-16-15-32-32-32s-160 0-160 0v64h192s0-16 0-32z m0 96h-256v256h224s32 0 32-32 0-224 0-224z m-640 192h-64v-64h64v64z" horiz-adv-x="1024" />
+<glyph glyph-name="repo-force-push" unicode="&#xf04a;" d="M768 768c0 32-32 64-64 64s-608 0-640 0-64-32-64-64 0-768 0-768 0 32 0 0 32-64 64-64 128 0 128 0v-128l128 128v128h-128v-64s-79 0-96 0-32 15-32 32 0 96 0 96h256v64h-128v576h512v-576h-128v-64h128s0-80 0-96-15-32-32-32-96 0-96 0v-64s96 0 128 0 64 32 64 64 0 736 0 768z m-272-320h144l-192 256-192-256h144l-144-192h128v-448h128v448h128l-144 192z" horiz-adv-x="767.896" />
+<glyph glyph-name="repo-forked" unicode="&#xf002;" d="M768 704c0 71-57 128-128 128s-128-57-128-128c0-47 26-89 64-111v-106l-192-212-192 212v106c38 22 64 63 64 111 0 71-57 128-128 128s-128-57-128-128c0-47 26-89 64-111v-156l256-282v-109c-38-22-64-63-64-111 0-71 57-128 128-128s128 57 128 128c0 47-26 89-64 111v109l256 282v156c38 22 64 63 64 111z m-640 63c34 0 62-28 62-62s-28-62-62-62-62 28-62 62 28 62 62 62z m256-891c-34 0-62 28-62 62s28 62 62 62 62-28 62-62-28-62-62-62z m256 891c34 0 62-28 62-62s-28-62-62-62-62 28-62 62 28 62 62 62z" horiz-adv-x="768" />
+<glyph glyph-name="repo-pull" unicode="&#xf006;" d="M1024 512l-192 192v-128h-384v-128h384v-128l192 192z m-320-320h-512v576h512v-128h64s0 96 0 128-32 64-64 64-608 0-640 0-64-32-64-64 0-736 0-768 32-64 64-64 128 0 128 0v-128l96 96 96-96v128s288 0 320 0 64 32 64 64 0 384 0 384h-64v-192z m0-160c0-15-15-32-32-32s-288 0-288 0v64h-192v-64s-79 0-96 0-32 16-32 32 0 96 0 96h640s0-81 0-96z m-384 544h-64v-64h64v64z m0 128h-64v-64h64v64z m0-256h-64v-64h64v64z m-64-192h64v64h-64v-64z" horiz-adv-x="1024" />
+<glyph glyph-name="repo-push" unicode="&#xf005;" d="M448 512l-192-256h128v-448h128v448h128l-192 256z m-192 0h64v64h-64v-64z m64 192h-64v-64h64v64z m384 128c-32 0-608 0-640 0s-64-32-64-64 0-736 0-768 32-64 64-64 128 0 128 0v-128l128 128v128h-128v-64s-79 0-96 0-32 14-32 32 0 96 0 96h256v64h-128v576h513l-1-576h-128v-64h128s0-79 0-96-15-32-32-32-96 0-96 0v-64s96 0 128 0 64 32 64 64 0 736 0 768-32 64-64 64z" horiz-adv-x="768" />
+<glyph glyph-name="rocket" unicode="&#xf033;" d="M716.737 707.944c-71.926-41.686-148.041-96.13-218.436-166.555-45-45.031-81.213-88.78-110.39-129.778L209.538 378.65 0.047 169.00300000000004l186.818-5.815 131.562 131.562c-46.439-96.224-50.536-160.019-50.536-160.019l58.854-58.792c0 0 65.827 6.255 162.737 53.163L355.107-5.119000000000028l5.88-186.881 209.585 209.521 33.086 179.252c41.403 29.02 85.185 65.046 129.716 109.545 70.425 70.455 124.837 146.541 166.555 218.466-45.97 9.351-88.125 28.488-121.397 61.668C745.257 619.819 725.994 661.975 716.737 707.944zM786.161 745.157c5.004-45 19.952-81.274 44.78-105.98 24.769-24.985 60.98-39.902 106.138-44.844C1003.063 727.677 1023.953 832 1023.953 832S919.63 811.142 786.161 745.157z" horiz-adv-x="1024" />
+<glyph glyph-name="rss" unicode="&#xf034;" d="M128 192C57.344 192 0 134.625 0 64s57.344-128 128-128 128 57.375 128 128S198.656 192 128 192zM128 448c0 0-64-2-64-64s64-64 64-64c141.375 0 256-114.625 256-256 0 0 0-64 64-64s64 64 64 64C512 276 340.031 448 128 448zM128 704c0 0-64 0-64-64s64-64 64-64c282.75 0 512-229.25 512-512 0 0 0-64 64-64s64 64 64 64C768 417.406 481.5 704 128 704z" horiz-adv-x="768" />
+<glyph glyph-name="ruby" unicode="&#xf047;" d="M768 704H256L0 448l512-512 512 512L768 704zM128 448l192 192h384l192-192L512 64 128 448zM704 576H512v-448l320 320L704 576z" horiz-adv-x="1024" />
+<glyph glyph-name="screen-full" unicode="&#xf066;" d="M128 64h639.875V576H128V64zM255.938 448h384v-256h-384V448zM64 639.938h191.938v64H0V448h64V639.938zM64 192H0v-255.938h255.938V0H64V192zM639.938 703.938v-64h191.938V448h64V703.938H639.938zM831.875 0H639.938v-63.938h255.938V192h-64V0z" horiz-adv-x="895.875" />
+<glyph glyph-name="screen-normal" unicode="&#xf067;" d="M127.938 640.062H0v-64h191.938V768h-64V640.062zM0-0.06200000000001182h127.938V-128h64V63.93799999999999H0V-0.06200000000001182zM768.062 640.062V768h-64v-191.938H896v64H768.062zM704.062-128h64V-0.06200000000001182H896v64H704.062V-128zM192.062 128H704V512H192.062V128zM320 384h256v-128H320V384z" horiz-adv-x="896" />
+<glyph glyph-name="search" unicode="&#xf02e;" d="M960 0L710.875 249.125C746.438 307.188 768 374.844 768 448 768 660.031 596 832 384 832 171.969 832 0 660.031 0 448c0-212 171.969-384 384-384 73.156 0 140.812 21.562 198.875 57L832-128c17.5-17.5 46.5-17.375 64 0l64 64C977.5-46.5 977.5-17.5 960 0zM384 192c-141.375 0-256 114.625-256 256s114.625 256 256 256 256-114.625 256-256S525.375 192 384 192z" horiz-adv-x="973.125" />
+<glyph glyph-name="server" unicode="&#xf097;" d="M704 448h-640c-35 0-64-32-64-64v-128c0-32 32-64 64-64h640c32 0 64 32 64 64v128c0 32-32 64-64 64z m-576-192h-64v128h64v-128z m128 0h-64v128h64v-128z m128 0h-64v128h64v-128z m128 0h-64v128h64v-128z m192-128h-640c-35 0-64-32-64-64v-128c0-32 32-64 64-64h640c32 0 64 32 64 64v128c0 32-32 64-64 64z m-576-192h-64v128h64v-128z m128 0h-64v128h64v-128z m128 0h-64v128h64v-128z m128 0h-64v128h64v-128z m192 832h-640c-35 0-64-32-64-64v-128c0-32 32-64 64-64h640c32 0 64 32 64 64v128c0 32-32 64-64 64z m-576-192h-64v128h64v-128z m128 0h-64v128h64v-128z m128 0h-64v128h64v-128z m128 0h-64v128h64v-128z m192 64h-64v64h64v-64z" horiz-adv-x="768" />
+<glyph glyph-name="settings" unicode="&#xf07c;" d="M64-64h128V128H64V-64zM192 704H64v-320h128V704zM512 704H384v-128h128V704zM0 192h256V320H0V192zM384-64h128V320H384V-64zM320 384h256V512H320V384zM832 704H704v-384h128V704zM640 256v-128h256V256H640zM704-64h128V64H704V-64z" horiz-adv-x="896" />
+<glyph glyph-name="sign-in" unicode="&#xf036;" d="M640 256L640 384 896 384 896 512 640 512 640 640 448 496 448 640 192 768 704 768 704 576 768 576 768 832 64 832 64 0 448-192 448 0 768 0 768 320 704 320 704 64 448 64 448 400z" horiz-adv-x="896" />
+<glyph glyph-name="sign-out" unicode="&#xf032;" d="M640 64H384V640L128 768h512v-192h64V832H0v-832l384-192V0h320V320h-64V64zM1024 448L768 640v-128H512v-128h256v-128L1024 448z" horiz-adv-x="1024" />
+<glyph glyph-name="split" unicode="&#xf0c6;" d="M448 576l-256 256-192-192 311-300c15 81 43 136 133 230l5 6z m128 256l133-133-197-197c-99-99-128-162-128-309v-384h256v384c0 52 19 94 53 128l197 197 133-133v448h-448z" horiz-adv-x="1024" />
+<glyph glyph-name="squirrel" unicode="&#xf0b2;" d="M768 768c-141.385 0-256-83.75-256-186.875C512 457.25 544 387 512 192c0 288-177 405.783-256 405.783 3.266 32.17-30.955 42.217-30.955 42.217s-14-7.124-19.354-21.583c-17.231 20.053-36.154 17.54-36.154 17.54l-8.491-37.081c0 0-117.045-40.876-118.635-206.292C56 371 141.311 353.898 201.887 364.882c57.157-2.956 42.991-50.648 30.193-63.446C178.083 247.438 128 320 64 320s-64-64 0-64 64-64 192-64c-198-77 0-256 0-256h-64c-64 0-64-64-64-64s256 0 384 0c192 0 320 64 320 222.182 0 54.34-27.699 114.629-64 162.228C697.057 349.433 782.453 427.566 832 384s192-64 192 128C1024 653.385 909.385 768 768 768zM160 448c-17.674 0-32 14.327-32 32 0 17.674 14.326 32 32 32 17.673 0 32-14.326 32-32C192 462.327 177.673 448 160 448z" horiz-adv-x="1024" />
+<glyph glyph-name="star" unicode="&#xf02a;" d="M896 448l-313.5 40.781L448 768 313.469 488.781 0 448l230.469-208.875L171-63.93799999999999l277 148.812 277.062-148.812L665.5 239.125 896 448z" horiz-adv-x="896" />
+<glyph glyph-name="steps" unicode="&#xf0c7;" d="M136 768C60.89 768 0 667.71 0 544c0-68.83 17.02-141.84 34-254.54C47.3 201.16999999999996 79.67 128 136 128s94.08 48.79 94.08 137.97c0 30.37-24.97 78.75-26.08 120.03-2.02 74.46 49.93 104.17 49.93 173C253.93 682.71 211.1 768 136 768zM502.97 512c-75.1 0-117.93-85.29-117.93-209 0-68.83 51.95-98.54 49.93-173-1.109-41.28-26.08-89.66-26.08-120.03 0-89.18 37.75-137.97 94.08-137.97s88.7 73.17 102 161.46c16.98 112.7 34 185.71 34 254.54C638.97 411.71 578.08 512 502.97 512z" horiz-adv-x="640" />
+<glyph glyph-name="stop" unicode="&#xf08f;" d="M704 832H320L0 512v-384l320-320h384l320 320V512L704 832zM896 192L640-64H384L128 192V448l256 256h256l256-256V192zM448 256h128V576H448V256zM448 64h128V192H448V64z" horiz-adv-x="1024" />
+<glyph glyph-name="sync" unicode="&#xf087;" d="M655.461 358.531c11.875-81.719-13.062-167.781-76.812-230.594-94.188-92.938-239.5-104.375-346.375-34.562l74.875 73L31.96 204.75 70.367-64l84.031 80.5c150.907-111.25 364.938-100.75 502.063 34.562 79.5 78.438 115.75 182.562 111.25 285.312L655.461 358.531zM189.46 511.938c94.156 92.938 239.438 104.438 346.313 34.562l-75-72.969 275.188-38.406L697.586 704l-83.938-80.688C462.711 734.656 248.742 724.031 111.585 588.75 32.085 510.344-4.133 406.219 0.335 303.5l112.25-22.125C100.71 363.125 125.71 449.094 189.46 511.938z" horiz-adv-x="768.051" />
+<glyph glyph-name="tag" unicode="&#xf015;" d="M384 768H128L0 640v-256l512-512 384 384L384 768zM64 416V608l96 96h192l448-448L512-32 64 416zM448 512L256 320l256-256 192 192L448 512zM352 320l96 96 160-160-96-96L352 320zM320 544c0 53-43 96-96 96s-96-43-96-96 43-96 96-96S320 491 320 544zM224 512c-17.656 0-32 14.344-32 32s14.344 32 32 32 32-14.344 32-32S241.656 512 224 512z" horiz-adv-x="896" />
+<glyph glyph-name="telescope" unicode="&#xf088;" d="M76 409c32 8 229 59 229 59-1-6-2-19-2-19 0-71 49-128 128-128s128 59 128 128c0 11-8 22-19 32l49-3s7 2 31 8c-51-14-108 31-126 99s8 135 60 149c-24-6-31-8-31-8l-168-110c-34-9-55-46-46-80 2-9 7-17 12-23-7-12-12-26-15-40-27 1-51 19-59 46-9 34 11 69 45 78l-245-65c-34-9-54-43-45-77s41-54 73-46z m419-153h-128v-64l-320-320h128l192 128v-128h128v128l192-128h128l-320 320v64z m429 448c-18 68-70 110-122 96-69-18-98-28-186-51-51-14-79-80-61-148s74-115 125-102c87 23 117 33 186 51 51 14 76 85 58 154z m-70-90c-17-5-42 17-51 51s-4 66 13 70 42-17 51-51 4-66-13-70z" horiz-adv-x="929.875" />
+<glyph glyph-name="terminal" unicode="&#xf0c8;" d="M831 705H63c-35.35 0-64-28.65-64-64v-640c0-35.35 28.65-64 64-64h768c35.35 0 64 28.65 64 64V641C895 676.35 866.35 705 831 705zM127 257l128 128L127 513l64 64 192-192L191 193 127 257zM639 193H383v64h256V193z" horiz-adv-x="896" />
+<glyph glyph-name="three-bars" unicode="&#xf05e;" d="M0 640v-128h768v128h-768z m0-384h768v128h-768v-128z m0-256h768v128h-768v-128z" horiz-adv-x="768" />
+<glyph glyph-name="tools" unicode="&#xf031;" d="M286.547 366.984c16.843-16.812 81.716-85.279 81.716-85.279l35.968 37.093-56.373 58.248L456.072 491.98c0 0-48.842 47.623-27.468 28.655 20.438 75.903 1.812 160.589-55.842 220.243C315.608 800.064 234.392 819.47 161.425 799.096l123.653-127.715-32.53-125.309-121.06-33.438L7.898 640.3820000000001c-19.718-75.436-0.969-159.339 56.311-218.556C124.302 359.703 210.83 341.453 286.547 366.984zM698.815 242.769L549.694 95.46100000000001l245.932-254.805c20.062-20.812 46.498-31.188 72.872-31.188 26.25 0 52.624 10.375 72.811 31.188 40.249 41.624 40.249 108.997 0 150.62L698.815 242.769zM1023.681 670.162L867.06 832.001 405.387 354.703l56.373-58.248L185.425 10.839000000000055l-63.154-33.749-89.217-145.559 22.719-23.562 140.839 92.247 32.655 65.312 276.336 285.554 56.404-58.248L1023.681 670.162z" horiz-adv-x="1024" />
+<glyph glyph-name="trashcan" unicode="&#xf0d0;" d="M704 704H448c0 0 0 24.057 0 32 0 17.673-14.327 32-32 32s-32-14.327-32-32c0-17.673 0-32 0-32H128c-35.346 0-64-28.654-64-64v-64c0-35.346 28.654-64 64-64v-576c0-35.346 28.654-64 64-64h448c35.346 0 64 28.654 64 64V512c35.346 0 64 28.654 64 64v64C768 675.346 739.346 704 704 704zM640-32c0-17.673-14.327-32-32-32H224c-17.673 0-32 14.327-32 32V512h64v-480c0-17.673 14.327-32 32-32s32 14.327 32 32l0.387 480H384v-480c0-17.673 14.327-32 32-32s32 14.327 32 32l0.387 480h64L512 32c0-17.673 14.327-32 32-32s32 14.327 32 32V512h64V-32zM704 592c0-8.837-7.163-16-16-16H144c-8.837 0-16 7.163-16 16v32c0 8.837 7.163 16 16 16h544c8.837 0 16-7.163 16-16V592z" horiz-adv-x="768" />
+<glyph glyph-name="triangle-down" unicode="&#xf05b;" d="M0 448l383.75-383.75L767.5 448H0z" horiz-adv-x="767.5" />
+<glyph glyph-name="triangle-left" unicode="&#xf044;" d="M0 320.125l383.75-383.75v767.5L0 320.125z" horiz-adv-x="383.75" />
+<glyph glyph-name="triangle-right" unicode="&#xf05a;" d="M0.062 703.75L383.812 320 0.062-63.75V703.75z" horiz-adv-x="383.875" />
+<glyph glyph-name="triangle-up" unicode="&#xf0aa;" d="M383.75 576L0 192.25h767.5L383.75 576z" horiz-adv-x="767.5" />
+<glyph glyph-name="unfold" unicode="&#xf039;" d="M384 448h128V640h128L448 832 256 640h128V448zM576 576v-64h224L672 384H224L96 512h224v64H0v-63.999L160 352 0 192v-64h320v64H96l128 128h448l128-128H576v-64h320v64L736 352l160 160.001V576H576zM512 256H384v-192H256l192-192 192 192H512V256z" horiz-adv-x="896" />
+<glyph glyph-name="unmute" unicode="&#xf0ba;" d="M128 448H0v-256h128l256-192h64V640h-64L128 448zM538.51 410.51c-12.496 12.497-32.758 12.497-45.255 0-12.496-12.496-12.496-32.758 0-45.255 24.994-24.993 24.994-65.516 0-90.51-12.496-12.496-12.496-32.758 0-45.255 12.497-12.496 32.759-12.496 45.255 0C588.497 279.47900000000004 588.497 360.523 538.51 410.51zM629.02 501.019c-12.495 12.497-32.758 12.497-45.255 0-12.495-12.496-12.495-32.758 0-45.255 74.981-74.98 74.981-196.548 0-271.528-12.495-12.497-12.495-32.76 0-45.256 12.497-12.496 32.76-12.496 45.255 0C728.994 238.95399999999995 728.994 401.045 629.02 501.019zM719.529 591.529c-12.497 12.497-32.76 12.497-45.255 0-12.496-12.496-12.496-32.758 0-45.255 124.968-124.968 124.968-327.58 0-452.548-12.496-12.497-12.496-32.759 0-45.255 12.495-12.497 32.758-12.497 45.255 0C869.49 198.433 869.49 441.568 719.529 591.529z" horiz-adv-x="896" />
+<glyph glyph-name="versions" unicode="&#xf064;" d="M0 128h128v64H64V448h64v64H0V128zM384 640v-640h512V640H384zM768 128H512V512h256V128zM192 64h128v64h-64V512h64v64H192V64z" horiz-adv-x="896" />
+<glyph glyph-name="x" unicode="&#xf081;" d="M640 512L512 640 320 448 128 640 0 512l192-192L0 128l128-128 192 192 192-192 128 128L448 320 640 512z" horiz-adv-x="640" />
+<glyph glyph-name="zap" unicode="&#x26A1;" d="M640 384H384L576 832 0 256h256L64-192 640 384z" horiz-adv-x="640" />
+</font>
+</defs>
+</svg>
diff --git a/docs/_spec/public/octicons/octicons.ttf b/docs/_spec/public/octicons/octicons.ttf
new file mode 100644
index 0000000000000000000000000000000000000000..189ca2813d4920f3be1bd1a43b19a09740d1eb2c
GIT binary patch
literal 31272
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
F{||dHN2&k-

literal 0
HcmV?d00001

diff --git a/docs/_spec/public/octicons/octicons.woff b/docs/_spec/public/octicons/octicons.woff
new file mode 100644
index 0000000000000000000000000000000000000000..2b770e429f38d820c1916bb395f7e72ddafa60c5
GIT binary patch
literal 17492
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
XCFbMRtSHIN*e7dip8_F2%OL;&74Wc&

literal 0
HcmV?d00001

diff --git a/docs/_spec/public/scripts/LICENSE-highlight b/docs/_spec/public/scripts/LICENSE-highlight
new file mode 100644
index 000000000000..fe2f67b1628e
--- /dev/null
+++ b/docs/_spec/public/scripts/LICENSE-highlight
@@ -0,0 +1,24 @@
+Copyright (c) 2006, Ivan Sagalaev
+All rights reserved.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of highlight.js nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
+EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/docs/_spec/public/scripts/LICENSE-toc b/docs/_spec/public/scripts/LICENSE-toc
new file mode 100644
index 000000000000..4e236e8696c3
--- /dev/null
+++ b/docs/_spec/public/scripts/LICENSE-toc
@@ -0,0 +1,18 @@
+(The MIT License)
+Copyright (c) 2013 Greg Allen
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\ No newline at end of file
diff --git a/docs/_spec/public/scripts/highlight.pack.js b/docs/_spec/public/scripts/highlight.pack.js
new file mode 100644
index 000000000000..bfeca09abb51
--- /dev/null
+++ b/docs/_spec/public/scripts/highlight.pack.js
@@ -0,0 +1 @@
+var hljs=new function(){function j(v){return v.replace(/&/gm,"&amp;").replace(/</gm,"&lt;").replace(/>/gm,"&gt;")}function t(v){return v.nodeName.toLowerCase()}function h(w,x){var v=w&&w.exec(x);return v&&v.index==0}function r(w){var v=(w.className+" "+(w.parentNode?w.parentNode.className:"")).split(/\s+/);v=v.map(function(x){return x.replace(/^lang(uage)?-/,"")});return v.filter(function(x){return i(x)||/no(-?)highlight/.test(x)})[0]}function o(x,y){var v={};for(var w in x){v[w]=x[w]}if(y){for(var w in y){v[w]=y[w]}}return v}function u(x){var v=[];(function w(y,z){for(var A=y.firstChild;A;A=A.nextSibling){if(A.nodeType==3){z+=A.nodeValue.length}else{if(A.nodeType==1){v.push({event:"start",offset:z,node:A});z=w(A,z);if(!t(A).match(/br|hr|img|input/)){v.push({event:"stop",offset:z,node:A})}}}}return z})(x,0);return v}function q(w,y,C){var x=0;var F="";var z=[];function B(){if(!w.length||!y.length){return w.length?w:y}if(w[0].offset!=y[0].offset){return(w[0].offset<y[0].offset)?w:y}return y[0].event=="start"?w:y}function A(H){function G(I){return" "+I.nodeName+'="'+j(I.value)+'"'}F+="<"+t(H)+Array.prototype.map.call(H.attributes,G).join("")+">"}function E(G){F+="</"+t(G)+">"}function v(G){(G.event=="start"?A:E)(G.node)}while(w.length||y.length){var D=B();F+=j(C.substr(x,D[0].offset-x));x=D[0].offset;if(D==w){z.reverse().forEach(E);do{v(D.splice(0,1)[0]);D=B()}while(D==w&&D.length&&D[0].offset==x);z.reverse().forEach(A)}else{if(D[0].event=="start"){z.push(D[0].node)}else{z.pop()}v(D.splice(0,1)[0])}}return F+j(C.substr(x))}function m(y){function v(z){return(z&&z.source)||z}function w(A,z){return RegExp(v(A),"m"+(y.cI?"i":"")+(z?"g":""))}function x(D,C){if(D.compiled){return}D.compiled=true;D.k=D.k||D.bK;if(D.k){var z={};var E=function(G,F){if(y.cI){F=F.toLowerCase()}F.split(" ").forEach(function(H){var I=H.split("|");z[I[0]]=[G,I[1]?Number(I[1]):1]})};if(typeof D.k=="string"){E("keyword",D.k)}else{Object.keys(D.k).forEach(function(F){E(F,D.k[F])})}D.k=z}D.lR=w(D.l||/\b[A-Za-z0-9_]+\b/,true);if(C){if(D.bK){D.b="\\b("+D.bK.split(" ").join("|")+")\\b"}if(!D.b){D.b=/\B|\b/}D.bR=w(D.b);if(!D.e&&!D.eW){D.e=/\B|\b/}if(D.e){D.eR=w(D.e)}D.tE=v(D.e)||"";if(D.eW&&C.tE){D.tE+=(D.e?"|":"")+C.tE}}if(D.i){D.iR=w(D.i)}if(D.r===undefined){D.r=1}if(!D.c){D.c=[]}var B=[];D.c.forEach(function(F){if(F.v){F.v.forEach(function(G){B.push(o(F,G))})}else{B.push(F=="self"?D:F)}});D.c=B;D.c.forEach(function(F){x(F,D)});if(D.starts){x(D.starts,C)}var A=D.c.map(function(F){return F.bK?"\\.?("+F.b+")\\.?":F.b}).concat([D.tE,D.i]).map(v).filter(Boolean);D.t=A.length?w(A.join("|"),true):{exec:function(F){return null}}}x(y)}function c(T,L,J,R){function v(V,W){for(var U=0;U<W.c.length;U++){if(h(W.c[U].bR,V)){return W.c[U]}}}function z(V,U){if(h(V.eR,U)){return V}if(V.eW){return z(V.parent,U)}}function A(U,V){return !J&&h(V.iR,U)}function E(W,U){var V=M.cI?U[0].toLowerCase():U[0];return W.k.hasOwnProperty(V)&&W.k[V]}function w(aa,Y,X,W){var U=W?"":b.classPrefix,V='<span class="'+U,Z=X?"":"</span>";V+=aa+'">';return V+Y+Z}function N(){if(!I.k){return j(C)}var U="";var X=0;I.lR.lastIndex=0;var V=I.lR.exec(C);while(V){U+=j(C.substr(X,V.index-X));var W=E(I,V);if(W){H+=W[1];U+=w(W[0],j(V[0]))}else{U+=j(V[0])}X=I.lR.lastIndex;V=I.lR.exec(C)}return U+j(C.substr(X))}function F(){if(I.sL&&!f[I.sL]){return j(C)}var U=I.sL?c(I.sL,C,true,S):e(C);if(I.r>0){H+=U.r}if(I.subLanguageMode=="continuous"){S=U.top}return w(U.language,U.value,false,true)}function Q(){return I.sL!==undefined?F():N()}function P(W,V){var U=W.cN?w(W.cN,"",true):"";if(W.rB){D+=U;C=""}else{if(W.eB){D+=j(V)+U;C=""}else{D+=U;C=V}}I=Object.create(W,{parent:{value:I}})}function G(U,Y){C+=U;if(Y===undefined){D+=Q();return 0}var W=v(Y,I);if(W){D+=Q();P(W,Y);return W.rB?0:Y.length}var X=z(I,Y);if(X){var V=I;if(!(V.rE||V.eE)){C+=Y}D+=Q();do{if(I.cN){D+="</span>"}H+=I.r;I=I.parent}while(I!=X.parent);if(V.eE){D+=j(Y)}C="";if(X.starts){P(X.starts,"")}return V.rE?0:Y.length}if(A(Y,I)){throw new Error('Illegal lexeme "'+Y+'" for mode "'+(I.cN||"<unnamed>")+'"')}C+=Y;return Y.length||1}var M=i(T);if(!M){throw new Error('Unknown language: "'+T+'"')}m(M);var I=R||M;var S;var D="";for(var K=I;K!=M;K=K.parent){if(K.cN){D=w(K.cN,"",true)+D}}var C="";var H=0;try{var B,y,x=0;while(true){I.t.lastIndex=x;B=I.t.exec(L);if(!B){break}y=G(L.substr(x,B.index-x),B[0]);x=B.index+y}G(L.substr(x));for(var K=I;K.parent;K=K.parent){if(K.cN){D+="</span>"}}return{r:H,value:D,language:T,top:I}}catch(O){if(O.message.indexOf("Illegal")!=-1){return{r:0,value:j(L)}}else{throw O}}}function e(y,x){x=x||b.languages||Object.keys(f);var v={r:0,value:j(y)};var w=v;x.forEach(function(z){if(!i(z)){return}var A=c(z,y,false);A.language=z;if(A.r>w.r){w=A}if(A.r>v.r){w=v;v=A}});if(w.language){v.second_best=w}return v}function g(v){if(b.tabReplace){v=v.replace(/^((<[^>]+>|\t)+)/gm,function(w,z,y,x){return z.replace(/\t/g,b.tabReplace)})}if(b.useBR){v=v.replace(/\n/g,"<br>")}return v}function p(A){var B=r(A);if(/no(-?)highlight/.test(B)){return}var y;if(b.useBR){y=document.createElementNS("http://www.w3.org/1999/xhtml","div");y.innerHTML=A.innerHTML.replace(/\n/g,"").replace(/<br[ \/]*>/g,"\n")}else{y=A}var z=y.textContent;var v=B?c(B,z,true):e(z);var x=u(y);if(x.length){var w=document.createElementNS("http://www.w3.org/1999/xhtml","div");w.innerHTML=v.value;v.value=q(x,u(w),z)}v.value=g(v.value);A.innerHTML=v.value;A.className+=" hljs "+(!B&&v.language||"");A.result={language:v.language,re:v.r};if(v.second_best){A.second_best={language:v.second_best.language,re:v.second_best.r}}}var b={classPrefix:"hljs-",tabReplace:null,useBR:false,languages:undefined};function s(v){b=o(b,v)}function l(){if(l.called){return}l.called=true;var v=document.querySelectorAll("pre code");Array.prototype.forEach.call(v,p)}function a(){addEventListener("DOMContentLoaded",l,false);addEventListener("load",l,false)}var f={};var n={};function d(v,x){var w=f[v]=x(this);if(w.aliases){w.aliases.forEach(function(y){n[y]=v})}}function k(){return Object.keys(f)}function i(v){return f[v]||f[n[v]]}this.highlight=c;this.highlightAuto=e;this.fixMarkup=g;this.highlightBlock=p;this.configure=s;this.initHighlighting=l;this.initHighlightingOnLoad=a;this.registerLanguage=d;this.listLanguages=k;this.getLanguage=i;this.inherit=o;this.IR="[a-zA-Z][a-zA-Z0-9_]*";this.UIR="[a-zA-Z_][a-zA-Z0-9_]*";this.NR="\\b\\d+(\\.\\d+)?";this.CNR="(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)";this.BNR="\\b(0b[01]+)";this.RSR="!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~";this.BE={b:"\\\\[\\s\\S]",r:0};this.ASM={cN:"string",b:"'",e:"'",i:"\\n",c:[this.BE]};this.QSM={cN:"string",b:'"',e:'"',i:"\\n",c:[this.BE]};this.PWM={b:/\b(a|an|the|are|I|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such)\b/};this.CLCM={cN:"comment",b:"//",e:"$",c:[this.PWM]};this.CBCM={cN:"comment",b:"/\\*",e:"\\*/",c:[this.PWM]};this.HCM={cN:"comment",b:"#",e:"$",c:[this.PWM]};this.NM={cN:"number",b:this.NR,r:0};this.CNM={cN:"number",b:this.CNR,r:0};this.BNM={cN:"number",b:this.BNR,r:0};this.CSSNM={cN:"number",b:this.NR+"(%|em|ex|ch|rem|vw|vh|vmin|vmax|cm|mm|in|pt|pc|px|deg|grad|rad|turn|s|ms|Hz|kHz|dpi|dpcm|dppx)?",r:0};this.RM={cN:"regexp",b:/\//,e:/\/[gim]*/,i:/\n/,c:[this.BE,{b:/\[/,e:/\]/,r:0,c:[this.BE]}]};this.TM={cN:"title",b:this.IR,r:0};this.UTM={cN:"title",b:this.UIR,r:0}}();hljs.registerLanguage("scala",function(d){var b={cN:"annotation",b:"@[A-Za-z]+"};var c={cN:"string",b:'u?r?"""',e:'"""',r:10};var a={cN:"symbol",b:"'\\w[\\w\\d_]*(?!')"};var e={cN:"type",b:"\\b[A-Z][A-Za-z0-9_]*",r:0};var h={cN:"title",b:/[^0-9\n\t "'(),.`{}\[\]:;][^\n\t "'(),.`{}\[\]:;]+|[^0-9\n\t "'(),.`{}\[\]:;=]/,r:0};var i={cN:"class",bK:"class object trait type",e:/[:={\[(\n;]/,c:[{cN:"keyword",bK:"extends with",r:10},h]};var g={cN:"function",bK:"def val",e:/[:={\[(\n;]/,c:[h]};var f={cN:"javadoc",b:"/\\*\\*",e:"\\*/",c:[{cN:"javadoctag",b:"@[A-Za-z]+"}],r:10};return{k:{literal:"true false null",keyword:"type yield lazy override def with val var sealed abstract private trait object if forSome for while throw finally protected extends import final return else break new catch super class case package default try this match continue throws implicit"},c:[d.CLCM,d.CBCM,c,d.QSM,a,e,g,i,d.CNM,b]}});
\ No newline at end of file
diff --git a/docs/_spec/public/scripts/main.js b/docs/_spec/public/scripts/main.js
new file mode 100644
index 000000000000..9ade9c770f1e
--- /dev/null
+++ b/docs/_spec/public/scripts/main.js
@@ -0,0 +1,71 @@
+function currentChapter() {
+  var path = document.location.pathname;
+  var idx  = path.lastIndexOf("/") + 1;
+  var chap = path.substring(idx, idx + 2);
+  return parseInt(chap, 10);
+}
+
+function heading(i, heading, $heading) {
+  var currentLevel = parseInt(heading.tagName.substring(1));
+  var result = "";
+  if (currentLevel === this.headerLevel) {
+    this.headerCounts[this.headerLevel] += 1;
+    return "" + this.headerCounts[this.headerLevel] + " " + $heading.text();
+  } else if (currentLevel < this.headerLevel) {
+    while(currentLevel < this.headerLevel) {
+      this.headerCounts[this.headerLevel] = 1;
+      this.headerLevel -= 1;
+    }
+    this.headerCounts[this.headerLevel] += 1;
+    return "" + this.headerCounts[this.headerLevel]+ " " + $heading.text();
+  } else {
+    while(currentLevel > this.headerLevel) {
+      this.headerLevel += 1;
+      this.headerCounts[this.headerLevel] = 1;
+    }
+    return "" + this.headerCounts[this.headerLevel]+ " " + $heading.text();
+  }
+}
+
+// ignore when using wkhtmltopdf, or it won't work...
+if(window.jekyllEnv !== 'spec-pdf') {
+  $('#toc').toc(
+    {
+      'selectors': 'h1,h2,h3',
+      'smoothScrolling': false,
+      'chapter': currentChapter(),
+      'headerLevel': 1,
+      'headerCounts': [-1, currentChapter() - 1, 1, 1],
+      'headerText': heading
+    }
+  );
+}
+
+// no language auto-detect so that EBNF isn't detected as scala
+hljs.configure({
+  languages: []
+});
+
+// KaTeX configuration
+document.addEventListener("DOMContentLoaded", function() {
+  renderMathInElement(document.body, {
+    delimiters: [
+      {left: "´", right: "´", display: false}, // "display: false" -> inline
+      {left: "$$", right: "$$", display: true}
+    ],
+    ignoredTags: ['script', 'noscript', 'style', 'textarea'],
+  });
+  // syntax highlighting after KaTeX is loaded,
+  // so that math can be used in code blocks
+  hljs.initHighlighting();
+  $("pre nobr").addClass("fixws");
+  // point when all necessary js is done, so PDF to be rendered
+  window.status = "loaded";
+});
+
+$("#chapters a").each(function (index) {
+ if (document.location.pathname.endsWith($(this).attr("href")))
+   $(this).addClass("chapter-active");
+ else
+   $(this).removeClass("chapter-active");
+});
diff --git a/docs/_spec/public/scripts/toc.js b/docs/_spec/public/scripts/toc.js
new file mode 100644
index 000000000000..5b0bded12cfc
--- /dev/null
+++ b/docs/_spec/public/scripts/toc.js
@@ -0,0 +1,128 @@
+/*!
+ * toc - jQuery Table of Contents Plugin
+ * v0.3.2
+ * http://projects.jga.me/toc/
+ * copyright Greg Allen 2014
+ * MIT License
+*/
+(function($) {
+var verboseIdCache = {};
+$.fn.toc = function(options) {
+  var self = this;
+  var opts = $.extend({}, jQuery.fn.toc.defaults, options);
+
+  var container = $(opts.container);
+  var headings = $(opts.selectors, container);
+  var headingOffsets = [];
+  var activeClassName = opts.activeClass;
+
+  var scrollTo = function(e, callback) {
+    $('li', self).removeClass(activeClassName);
+    $(e.target).parent().addClass(activeClassName);
+  };
+
+  //highlight on scroll
+  var timeout;
+  var highlightOnScroll = function(e) {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+    timeout = setTimeout(function() {
+      var top = $(window).scrollTop(),
+        highlighted, closest = Number.MAX_VALUE, index = 0;
+      
+      for (var i = 0, c = headingOffsets.length; i < c; i++) {
+        var currentClosest = Math.abs(headingOffsets[i] - top);
+        if (currentClosest < closest) {
+          index = i;
+          closest = currentClosest;
+        }
+      }
+      
+      $('li', self).removeClass(activeClassName);
+      highlighted = $('li:eq('+ index +')', self).addClass(activeClassName);
+      opts.onHighlight(highlighted);      
+    }, 50);
+  };
+  if (opts.highlightOnScroll) {
+    $(window).on('scroll', highlightOnScroll);
+    highlightOnScroll();
+  }
+
+  return this.each(function() {
+    //build TOC
+    var el = $(this);
+    var ul = $(opts.listType);
+
+    headings.each(function(i, heading) {
+      var $h = $(heading);
+      headingOffsets.push($h.offset().top - opts.highlightOffset);
+
+      var anchorName = opts.anchorName(i, heading, opts.prefix);
+
+      //add anchor
+      if(heading.id !== anchorName) {
+        var anchor = $('<span/>').attr('id', anchorName).insertBefore($h);
+      }
+
+      //build TOC item
+      var a = $('<a/>')
+        .text(opts.headerText(i, heading, $h))
+        .attr('href', '#' + anchorName)
+        .on('click', function(e) {
+          $(window).off('scroll', highlightOnScroll);
+          scrollTo(e, function() {
+            $(window).on('scroll', highlightOnScroll);
+          });
+          el.trigger('selected', $(this).attr('href'));
+        });
+
+      var li = $('<li/>')
+        .addClass(opts.itemClass(i, heading, $h, opts.prefix))
+        .append(a);
+
+      ul.append(li);
+    });
+    el.html(ul);
+  });
+};
+
+
+jQuery.fn.toc.defaults = {
+  container: 'body',
+  listType: '<ul/>',
+  selectors: 'h1,h2,h3',
+  prefix: 'toc',
+  activeClass: 'toc-active',
+  onHighlight: function() {},
+  highlightOnScroll: true,
+  highlightOffset: 100,
+  anchorName: function(i, heading, prefix) {
+    if(heading.id.length) {
+      return heading.id;
+    }
+
+    var candidateId = $(heading).text().replace(/[^a-z0-9]/ig, ' ').replace(/\s+/g, '-').toLowerCase();
+    if (verboseIdCache[candidateId]) {
+      var j = 2;
+      
+      while(verboseIdCache[candidateId + j]) {
+        j++;
+      }
+      candidateId = candidateId + '-' + j;
+      
+    }
+    verboseIdCache[candidateId] = true;
+
+    return prefix + '-' + candidateId;
+  },
+  headerText: function(i, heading, $heading) {
+    return $heading.text();
+  },
+  itemClass: function(i, heading, $heading, prefix) {
+    return prefix + '-' + $heading[0].tagName.toLowerCase();
+  }
+
+};
+
+})(jQuery);
diff --git a/docs/_spec/public/stylesheets/fonts.css b/docs/_spec/public/stylesheets/fonts.css
new file mode 100644
index 000000000000..36efb2bbd5a0
--- /dev/null
+++ b/docs/_spec/public/stylesheets/fonts.css
@@ -0,0 +1,73 @@
+@font-face {
+    font-family: 'Luxi Sans';
+    src: local('Luxi Sans Regular'),
+         url('../fonts/LuxiSans-Regular.woff') format('woff');
+    font-weight: normal;
+    font-style: normal;
+}
+
+@font-face {
+    font-family: 'Luxi Sans';
+    src: local('Luxi Sans Bold'),
+         url('../fonts/LuxiSans-Bold.woff') format('woff');
+    font-weight: bold;
+    font-style: normal;
+}
+
+@font-face {
+    font-family: 'Luxi Mono';
+    src: local('Luxi Mono Regular'),
+         url('../fonts/LuxiMono-Regular.woff') format('woff');
+    font-weight: normal;
+    font-style: normal;
+}
+@font-face {
+    font-family: 'Luxi Mono';
+    src: local('Luxi Mono Oblique'),
+         url('../fonts/LuxiMono-BoldOblique.woff') format('woff');
+    font-weight: normal;
+    font-style: oblique;
+}
+@font-face {
+    font-family: 'Luxi Mono';
+    src: local('Luxi Mono Bold'),
+         url('../fonts/LuxiMono-Bold.woff') format('woff');
+    font-weight: bold;
+    font-style: normal;
+}
+@font-face {
+    font-family: 'Luxi Mono';
+    src: local('Luxi Mono Bold Oblique'),
+         url('../fonts/LuxiMono-BoldOblique.woff') format('woff');
+    font-weight: bold;
+    font-style: oblique;
+}
+
+@font-face {
+    font-family: 'Heuristica';
+    src: local('Heuristica Regular'),
+         url('../fonts/Heuristica-Regular.woff') format('woff');
+    font-weight: normal;
+    font-style: normal;
+}
+@font-face {
+    font-family: 'Heuristica';
+    src: local('Heuristica Italic'),
+         url('../fonts/Heuristica-RegularItalic.woff') format('woff');
+    font-weight: normal;
+    font-style: italic;
+}
+@font-face {
+    font-family: 'Heuristica';
+    src: local('Heuristica Bold'),
+         url('../fonts/Heuristica-Bold.woff') format('woff');
+    font-weight: bold;
+    font-style: normal;
+}
+@font-face {
+    font-family: 'Heuristica';
+    src: local('Heuristica Bold Italic'),
+         url('../fonts/Heuristica-BoldItalic.woff') format('woff');
+    font-weight: bold;
+    font-style: italic;
+}
diff --git a/docs/_spec/public/stylesheets/print.css b/docs/_spec/public/stylesheets/print.css
new file mode 100644
index 000000000000..f0efff28b203
--- /dev/null
+++ b/docs/_spec/public/stylesheets/print.css
@@ -0,0 +1,42 @@
+/* This removes a few things from screen.css for printing */
+
+body {
+  padding: 0px;
+  margin: 0px; 
+}
+
+.anchor, #navigation, .to_top, .version-notice, .hidden-print {
+  display: none !important;
+}
+
+.print-only {
+  display: block;
+}
+
+#content-container {
+  width: 100%;
+  float: none;
+}
+
+/* no scrollbars, jump to next row.. */
+.highlight pre code {
+  overflow: hidden;
+  white-space: pre-wrap;
+}
+
+main {
+  position: relative;
+  top: 32px;
+  margin: 0 0 0 0;
+  padding: 0px 32px;
+  max-width: none;
+  min-width: none;
+  min-height: none;
+  background-color: #FFF;
+}
+
+/* Avoid clipped headings https://github.com/pdfkit/pdfkit/issues/113#issuecomment-7027798 */
+h2, h3, h4, h5, h6 {
+  padding: 0px;
+  margin: 0px;
+}
diff --git a/docs/_spec/public/stylesheets/screen-small.css b/docs/_spec/public/stylesheets/screen-small.css
new file mode 100644
index 000000000000..674db7c49000
--- /dev/null
+++ b/docs/_spec/public/stylesheets/screen-small.css
@@ -0,0 +1,57 @@
+body {
+  padding: 0px;
+  margin: 0px;
+}
+aside.left {
+  position: relative;
+  margin: 0px auto;
+  overflow: visible;
+  height: inherit;
+  margin-bottom: 40px;
+  background-color: #073642;
+}
+header {
+  position: relative;
+  height: inherit;
+  min-height: 32px;
+}
+main {
+    max-width: 1000px;
+    min-width: 600px;
+    margin: 0 auto;
+}
+
+#chapters a {
+  font-size: 14px;
+  max-height: 32px;
+  padding: 4px 8px;
+  white-space: nowrap;
+  display: inline-block;
+}
+#chapters > #github {
+  padding: 14px;
+}
+
+#toc {
+  overflow: visible;
+}
+#toc .toc-active {
+  background: inherit;
+}
+#toc .toc-h1 {
+  display: inherit;
+}
+#toc .toc-h1 a {
+  padding-left: 10px;
+  color: #FFFFFF;
+  background: #72D0EB;
+}
+#toc .toc-h2 a {
+  padding-left: 30px;
+}
+#toc .toc-h3 a {
+  padding-left: 50px;
+}
+#toc a {
+  font-size: 14px;
+}
diff --git a/docs/_spec/public/stylesheets/screen-toc.css b/docs/_spec/public/stylesheets/screen-toc.css
new file mode 100644
index 000000000000..7a04bd00f96c
--- /dev/null
+++ b/docs/_spec/public/stylesheets/screen-toc.css
@@ -0,0 +1,37 @@
+body {
+  padding: 0px;
+  margin: 0px;
+}
+header {
+  height: 96px;
+  padding: 0px;
+  width: 100%;
+  position: relative;
+  color: #FFFFFF;
+}
+#header-main {
+  height: 68px;
+  line-height: 1.2;
+  font-size: 32px;
+}
+#header-sub {
+  padding-left: 64px;
+  height: 28px;
+  background-color:#72D0EB;
+  vertical-align: middle;
+}
+#scala-logo {
+  padding: 10px;
+}
+#title {
+  vertical-align: middle;
+}
+#github {
+  height: 40px;
+  padding: 14px;
+  float: right;
+  font-size: 0px;
+}
+li {
+  margin: 5px;
+}
diff --git a/docs/_spec/public/stylesheets/screen.css b/docs/_spec/public/stylesheets/screen.css
new file mode 100644
index 000000000000..2073613eaea7
--- /dev/null
+++ b/docs/_spec/public/stylesheets/screen.css
@@ -0,0 +1,521 @@
+/* from https://gist.github.com/andyferra/2554919 */
+
+body {
+  font-family:Heuristica,Georgia,serif;
+  color: #222222;
+  line-height: 1.6;
+
+  padding-bottom: 10px;
+  background-color: white;
+  padding-left: 30px;
+}
+
+#content-container > *:first-child {
+  margin-top: 0 !important;
+}
+#content-container > *:last-child {
+  margin-bottom: 0 !important;
+}
+
+a {
+  color: #08C;
+  text-decoration: none;
+}
+a:hover, a:focus {
+
+}
+a.absent {
+  color: #cc0000;
+}
+a.anchor {
+  display: block;
+  margin-left: -35px;
+  padding-left: 10px;
+  cursor: pointer;
+  position: absolute;
+  top: 0;
+  left: 0;
+  bottom: 0;
+  color: black;
+  width: 35px; height: 100%;
+}
+
+a.anchor span {
+  vertical-align: middle;
+}
+
+h1, h2, h3, h4, h5, h6 {
+  margin: 30px 0 0px;
+  padding: 0;
+  /* Fix anchor position due to header */
+  padding-top: 32px;
+  margin-top: -32px;
+  font-weight: bold;
+  -webkit-font-smoothing: antialiased;
+  cursor: text;
+  position: relative;
+  pointer-events: none;
+}
+
+h1, h2 {
+  font-weight: normal;
+}
+
+h1:hover a.anchor, h2:hover a.anchor, h3:hover a.anchor, h4:hover a.anchor, h5:hover a.anchor, h6:hover a.anchor {
+  text-decoration: none;
+}
+
+h1:hover a.anchor span, h2:hover a.anchor span, h3:hover a.anchor span, h4:hover a.anchor span, h5:hover a.anchor span, h6:hover a.anchor span {
+  display: inline-block;
+}
+
+h1 a.anchor span, h2 a.anchor span, h3 a.anchor span, h4 a.anchor span, h5 a.anchor span, h6 a.anchor span {
+  display: none;
+}
+
+h1 a.anchor:hover span, h2 a.anchor:hover span, h3 a.anchor:hover span, h4 a.anchor:hover span, h5 a.anchor:hover span, h6 a.anchor:hover span {
+  display: inline-block;
+}
+
+h1 tt, h1 code {
+  font-size: inherit;
+}
+
+h2 tt, h2 code {
+  font-size: inherit;
+}
+
+h3 tt, h3 code {
+  font-size: inherit;
+}
+
+h4 tt, h4 code {
+  font-size: inherit;
+}
+
+h5 tt, h5 code {
+  font-size: inherit;
+}
+
+h6 tt, h6 code {
+  font-size: inherit;
+}
+
+h1 {
+  font-size: 28px;
+  color: black;
+}
+
+h2 {
+  font-size: 24px;
+  color: black;
+}
+
+h3 {
+  font-size: 18px;
+}
+
+h4 {
+  font-size: 16px;
+}
+
+h5 {
+  font-size: 14px;
+}
+
+h6 {
+  color: #777777;
+  font-size: 14px;
+}
+
+p, blockquote, ul, ol, dl, li, table, pre {
+  margin: 5px 0 15px;
+  -moz-font-feature-settings: "onum";
+  -ms-font-feature-settings: "onum";
+  -webkit-font-feature-settings: "onum";
+  font-feature-settings: "onum";
+}
+
+hr {
+  background: transparent repeat-x 0 0;
+  border: 0 none;
+  color: #cccccc;
+  height: 4px;
+  padding: 0;
+}
+
+body > h2:first-child {
+  margin-top: 0;
+  padding-top: 0;
+}
+body > h1:first-child {
+  margin-top: 0;
+  padding-top: 0;
+}
+body > h1:first-child + h2 {
+  margin-top: 0;
+  padding-top: 0;
+}
+body > h3:first-child, body > h4:first-child, body > h5:first-child, body > h6:first-child {
+  margin-top: 0;
+  padding-top: 0;
+}
+
+a:first-child h1, a:first-child h2, a:first-child h3, a:first-child h4, a:first-child h5, a:first-child h6 {
+  margin-top: 0;
+  padding-top: 0;
+}
+
+h1 p, h2 p, h3 p, h4 p, h5 p, h6 p {
+  margin-top: 0;
+}
+
+li p.first {
+  display: inline-block;
+}
+
+ul, ol {
+  padding-left: 30px;
+}
+
+ul :first-child, ol :first-child {
+  margin-top: 0;
+}
+
+ul :last-child, ol :last-child {
+  margin-bottom: 0;
+}
+
+dl {
+  padding: 0;
+}
+dl dt {
+  font-size: 14px;
+  font-weight: bold;
+  font-style: italic;
+  padding: 0;
+  margin: 15px 0 5px;
+}
+dl dt:first-child {
+  padding: 0;
+}
+dl dt > :first-child {
+  margin-top: 0;
+}
+dl dt > :last-child {
+  margin-bottom: 0;
+}
+dl dd {
+  margin: 0 0 15px;
+  padding: 0 15px;
+}
+dl dd > :first-child {
+  margin-top: 0;
+}
+dl dd > :last-child {
+  margin-bottom: 0;
+}
+
+blockquote {
+  border-left: 4px solid #dddddd;
+  padding: 0 15px;
+  color: #222222;
+}
+blockquote > :first-child {
+  margin-top: 0;
+}
+blockquote > :last-child {
+  margin-bottom: 0;
+}
+blockquote:before {
+    content: "Example";
+    color: #777777;
+    font-size: 14px;
+    font-weight: bold;
+}
+
+table {
+  padding: 0;
+  margin: 0;
+  border: none;
+  border-collapse: collapse;
+}
+table tr {
+  background-color: white;
+}
+table tr:nth-child(2n) {
+  background-color: #f8f8f8;
+}
+table tr th {
+  background-color: #EAEAEA;
+  font-weight: bold;
+  text-align: left;
+  padding: 5px 13px;
+}
+table tr td {
+  text-align: left;
+  padding: 5px 13px;
+}
+table tr th :first-child, table tr td :first-child {
+  margin-top: 0;
+}
+table tr th :last-child, table tr td :last-child {
+  margin-bottom: 0;
+}
+
+img {
+  max-width: 100%;
+}
+
+span.frame {
+  display: block;
+  overflow: hidden;
+}
+span.frame > span {
+  border: 1px solid #dddddd;
+  display: block;
+  float: left;
+  overflow: hidden;
+  margin: 13px 0 0;
+  padding: 7px;
+  width: auto;
+}
+span.frame span img {
+  display: block;
+  float: left;
+}
+span.frame span span {
+  clear: both;
+  color: #333333;
+  display: block;
+  padding: 5px 0 0;
+}
+span.align-center {
+  display: block;
+  overflow: hidden;
+  clear: both;
+}
+span.align-center > span {
+  display: block;
+  overflow: hidden;
+  margin: 13px auto 0;
+  text-align: center;
+}
+span.align-center span img {
+  margin: 0 auto;
+  text-align: center;
+}
+span.align-right {
+  display: block;
+  overflow: hidden;
+  clear: both;
+}
+span.align-right > span {
+  display: block;
+  overflow: hidden;
+  margin: 13px 0 0;
+  text-align: right;
+}
+span.align-right span img {
+  margin: 0;
+  text-align: right;
+}
+span.float-left {
+  display: block;
+  margin-right: 13px;
+  overflow: hidden;
+  float: left;
+}
+span.float-left span {
+  margin: 13px 0 0;
+}
+span.float-right {
+  display: block;
+  margin-left: 13px;
+  overflow: hidden;
+  float: right;
+}
+span.float-right > span {
+  display: block;
+  overflow: hidden;
+  margin: 13px auto 0;
+  text-align: right;
+}
+
+pre, code, tt {
+  font:14px "Luxi Mono", 'andale mono', 'lucida console', monospace;
+  line-height:1.5;
+}
+
+.highlight pre {
+  background-color: #F8F8F8;
+  border-radius: 3px;
+  overflow: auto;
+  padding: 6px 10px;
+  white-space: nowrap;
+}
+
+code {
+  background-color: transparent;
+  border: none;
+  margin: 0;
+  padding: 0;
+  white-space: pre;
+}
+
+aside.left {
+    height: 100%;
+    position: fixed;
+    direction: rtl;
+    overflow: auto;
+    left: 0px;
+    width: 320px;
+    bottom: -32px;
+    font-family: "Luxi Sans", serif;
+    background-color: #073642;
+}
+
+aside.left > nav {
+    direction: ltr;
+    top: 32px;
+    padding-bottom: 32px;
+}
+
+article, aside, details, figcaption, figure, footer, header, hgroup, main, nav, section, summary {
+    display: block;
+}
+
+audio, canvas, img, svg, video {
+    vertical-align: middle;
+}
+
+audio, canvas, progress, video {
+    display: inline-block;
+    vertical-align: baseline;
+}
+
+main {
+    position: relative;
+    top: 32px;
+    margin: 0 0 0 320px;
+    padding: 0px 32px;
+    max-width: 800px;
+    min-width: 800px;
+    min-height: 580px;
+    background-color: #FFF;
+}
+
+header {
+    position: fixed;
+    top: 0px;
+    left: 0px;
+    height: 32px;
+    width: 100%;
+    background-color: #002B36;
+    margin: 0px 0px;
+    padding: 0px 0px;
+    font-family: "Luxi Sans", serif;
+    font-weight: bold;
+    z-index: 10;
+    overflow: hidden;
+    text-shadow: 1px 1px 0px rgba(0, 43, 54, 0.15);
+}
+
+#chapters a {
+    color: #FFFFFF;
+    text-decoration: none;
+    font-size: 0.63vw;
+    padding: 100% 5px;
+}
+
+#chapters a:hover, #chapters a:focus, #github:hover, #github:focus {
+  background: #DC322F;
+  -webkit-transition: background .2s ease-in;
+  -moz-transition: background .2s ease-in;
+  -ms-transition: background .2s ease-in;
+  -o-transition: background .2s ease-in;
+  transition: background .2s ease-in;
+}
+
+#chapters a.chapter-active {
+    background: #72D0EB;
+}
+
+
+#toc ul {
+    margin: 0;
+    padding: 0;
+    list-style: none;
+}
+
+#toc li {
+    margin: 0;
+    padding: 0;
+}
+
+#toc a {
+    color: #FFFFFF; /*#073642;*/
+    font-weight: bold;
+    font-size: 12px;
+    display: block;
+    text-shadow: 1px 1px 0px rgba(0, 43, 54, 0.15);
+}
+
+#toc a:hover, #toc a:focus {
+  background: #DC322F;
+  text-decoration: none;
+  -webkit-transition: background .2s ease-in;
+  -moz-transition: background .2s ease-in;
+  -ms-transition: background .2s ease-in;
+  -o-transition: background .2s ease-in;
+  transition: background .2s ease-in;
+}
+
+#toc .toc-h1 {
+    display: none;
+}
+
+#toc .toc-h2 a {
+    padding-left: 10px;
+}
+
+#toc .toc-h3 a {
+    padding-left: 30px;
+}
+
+#toc .toc-active {
+    background: #72D0EB;
+}
+
+#toc .toc-active a {
+    color: #FFFFFF;
+}
+
+#chapters > #github {
+  padding: 0px;
+  float: right;
+}
+
+.hljs{
+        background: #f8f8f8;
+}
+/* proper rendering of MathJax into highlighted code blocks */
+.fixws { white-space: pre; }
+.fixws .math { white-space: nowrap; }
+
+.version-notice {
+    background-color: #C93A3A;
+    color: #f2f2f2;
+    border:1px solid #ccc;
+    padding: 1em;
+    margin-bottom: 1em;
+}
+.version-notice a {
+    color: #f2f2f2;
+    font-weight: bold;
+    text-decoration: underline;
+}
+
+.print-only {
+  display: none;
+}
diff --git a/docs/_spec/spec-toc.xslt b/docs/_spec/spec-toc.xslt
new file mode 100644
index 000000000000..437b15e3e6f4
--- /dev/null
+++ b/docs/_spec/spec-toc.xslt
@@ -0,0 +1,64 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet version="2.0"
+                xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
+                xmlns:outline="http://wkhtmltopdf.org/outline"
+                xmlns="http://www.w3.org/1999/xhtml">
+  <xsl:output doctype-public="-//W3C//DTD XHTML 1.0 Strict//EN"
+              doctype-system="http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"
+              indent="yes" />
+  <xsl:template match="outline:outline">
+    <html>
+      <head>
+        <title>Table of Contents</title>
+        <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+        <link rel="stylesheet" type="text/css">
+          <xsl:attribute name="href">./public/stylesheets/fonts.css</xsl:attribute>
+        </link>
+        <style>
+          h1 {
+            text-align: center;
+            font-size: 20px;
+            font-family: Heuristica,Georgia,serif;
+          }
+          div {border-bottom: 1px dashed rgb(200,200,200);}
+          span {float: right;}
+          li {list-style: none;}
+          ul {
+            font-size: 20px;
+            font-family: Heuristica,Georgia,serif;
+          }
+          ul ul {font-size: 80%; }
+          ul {padding-left: 0em;}
+          ul ul {padding-left: 1em;}
+          a {text-decoration:none; color: black;}
+        </style>
+      </head>
+      <body>
+        <h1>Table of Contents</h1>
+        <ul><xsl:apply-templates select="outline:item/outline:item"/></ul>
+      </body>
+    </html>
+  </xsl:template>
+  <xsl:template match="outline:item">
+    <li>
+      <xsl:if test="@title!=''">
+        <div>
+          <a>
+            <xsl:if test="@link">
+              <xsl:attribute name="href"><xsl:value-of select="@link"/></xsl:attribute>
+            </xsl:if>
+            <xsl:if test="@backLink">
+              <xsl:attribute name="name"><xsl:value-of select="@backLink"/></xsl:attribute>
+            </xsl:if>
+            <xsl:value-of select="@title" /> 
+          </a>
+          <span> <xsl:value-of select="@page" /> </span>
+        </div>
+      </xsl:if>
+      <ul>
+        <xsl:comment>added to prevent self-closing tags in QtXmlPatterns</xsl:comment>
+        <xsl:apply-templates select="outline:item"/>
+      </ul>
+    </li>
+  </xsl:template>
+</xsl:stylesheet>

From 34b836b463410ba2f7a44a0f3fe1c72385cf4f8f Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Wed, 12 Oct 2022 13:51:03 +0200
Subject: [PATCH 101/657] Add copy of reference as TODO

reference taken from https://github.com/lampepfl/dotty/commit/7919cb375a3d1c931ed3841617774bdd8c49c62c
---
 .../changed-features/changed-features.md      |   7 +
 .../changed-features/compiler-plugins.md      | 128 +++
 .../changed-features/eta-expansion-spec.md    |  77 ++
 .../changed-features/eta-expansion.md         |  42 +
 .../implicit-conversions-spec.md              | 117 +++
 .../changed-features/implicit-conversions.md  |  65 ++
 .../changed-features/implicit-resolution.md   | 169 ++++
 .../TODOreference/changed-features/imports.md |  60 ++
 .../changed-features/interpolation-escapes.md |  14 +
 .../changed-features/lazy-vals-init.md        |  80 ++
 .../changed-features/main-functions.md        |  87 ++
 .../changed-features/match-syntax.md          |  56 ++
 .../changed-features/numeric-literals.md      |   7 +
 .../changed-features/operators.md             | 173 ++++
 .../changed-features/overload-resolution.md   | 102 +++
 .../changed-features/pattern-bindings.md      |  59 ++
 .../changed-features/pattern-matching.md      | 243 ++++++
 .../changed-features/structural-types-spec.md | 153 ++++
 .../changed-features/structural-types.md      | 191 ++++
 .../changed-features/type-checking.md         |   7 +
 .../changed-features/type-inference.md        |  10 +
 .../changed-features/vararg-splices.md        |  40 +
 .../changed-features/wildcards.md             |  50 ++
 .../contextual/by-name-context-parameters.md  |  65 ++
 .../contextual/context-bounds.md              |  53 ++
 .../contextual/context-functions-spec.md      |  79 ++
 .../contextual/context-functions.md           | 154 ++++
 .../TODOreference/contextual/contextual.md    |  83 ++
 .../TODOreference/contextual/conversions.md   |  76 ++
 .../contextual/derivation-macro.md            | 205 +++++
 .../TODOreference/contextual/derivation.md    | 425 +++++++++
 .../contextual/extension-methods.md           | 306 +++++++
 .../TODOreference/contextual/given-imports.md | 117 +++
 docs/_spec/TODOreference/contextual/givens.md | 193 ++++
 .../contextual/multiversal-equality.md        | 227 +++++
 .../contextual/relationship-implicits.md      | 206 +++++
 .../right-associative-extension-methods.md    |  52 ++
 .../TODOreference/contextual/type-classes.md  | 282 ++++++
 .../TODOreference/contextual/using-clauses.md | 153 ++++
 .../dropped-features/auto-apply.md            |  96 ++
 .../dropped-features/class-shadowing-spec.md  |  26 +
 .../dropped-features/class-shadowing.md       |  33 +
 .../dropped-features/delayed-init.md          |  32 +
 .../dropped-features/do-while.md              |  41 +
 .../dropped-features/dropped-features.md      |   7 +
 .../dropped-features/early-initializers.md    |  16 +
 .../dropped-features/existential-types.md     |  35 +
 .../TODOreference/dropped-features/limit22.md |  17 +
 .../TODOreference/dropped-features/macros.md  |  16 +
 .../dropped-features/nonlocal-returns.md      |  29 +
 .../dropped-features/package-objects.md       |  48 +
 .../dropped-features/procedure-syntax.md      |  19 +
 .../TODOreference/dropped-features/symlits.md |  24 +
 .../dropped-features/this-qualifier.md        |  33 +
 .../dropped-features/type-projection.md       |  18 +
 .../dropped-features/weak-conformance-spec.md |  54 ++
 .../dropped-features/weak-conformance.md      |  47 +
 .../dropped-features/wildcard-init.md         |  23 +
 .../TODOreference/dropped-features/xml.md     |  39 +
 docs/_spec/TODOreference/enums/adts.md        | 173 ++++
 .../_spec/TODOreference/enums/desugarEnums.md | 215 +++++
 docs/_spec/TODOreference/enums/enums-index.md |   7 +
 docs/_spec/TODOreference/enums/enums.md       | 222 +++++
 .../TODOreference/experimental/canthrow.md    | 281 ++++++
 docs/_spec/TODOreference/experimental/cc.md   | 738 ++++++++++++++++
 .../experimental/erased-defs-spec.md          |  64 ++
 .../TODOreference/experimental/erased-defs.md | 231 +++++
 .../experimental/explicit-nulls.md            | 543 ++++++++++++
 .../experimental/fewer-braces.md              |   7 +
 .../experimental/main-annotation.md           |  97 +++
 .../experimental/named-typeargs-spec.md       |  41 +
 .../experimental/named-typeargs.md            |  34 +
 .../experimental/numeric-literals.md          | 257 ++++++
 .../TODOreference/experimental/overview.md    |  29 +
 .../experimental/tupled-function.md           |  82 ++
 .../TODOreference/features-classification.md  | 199 +++++
 .../language-versions/binary-compatibility.md |  13 +
 .../language-versions/language-versions.md    |   7 +
 .../language-versions/source-compatibility.md |  43 +
 .../metaprogramming/compiletime-ops.md        | 294 +++++++
 .../TODOreference/metaprogramming/inline.md   | 390 +++++++++
 .../metaprogramming/macros-spec.md            | 254 ++++++
 .../TODOreference/metaprogramming/macros.md   | 823 ++++++++++++++++++
 .../metaprogramming/metaprogramming.md        |  47 +
 .../metaprogramming/reflection.md             | 131 +++
 .../metaprogramming/simple-smp.md             | 232 +++++
 .../TODOreference/metaprogramming/staging.md  | 121 +++
 .../metaprogramming/tasty-inspect.md          |  57 ++
 .../dependent-function-types-spec.md          | 125 +++
 .../new-types/dependent-function-types.md     |  49 ++
 .../new-types/intersection-types-spec.md      | 108 +++
 .../new-types/intersection-types.md           |  68 ++
 .../TODOreference/new-types/match-types.md    | 247 ++++++
 .../TODOreference/new-types/new-types.md      |   7 +
 .../new-types/polymorphic-function-types.md   |  94 ++
 .../new-types/type-lambdas-spec.md            | 116 +++
 .../TODOreference/new-types/type-lambdas.md   |  17 +
 .../new-types/union-types-spec.md             | 172 ++++
 .../TODOreference/new-types/union-types.md    |  46 +
 .../other-new-features/control-syntax.md      |  47 +
 .../creator-applications.md                   |  57 ++
 .../other-new-features/experimental-defs.md   | 318 +++++++
 .../other-new-features/export.md              | 234 +++++
 .../other-new-features/indentation.md         | 509 +++++++++++
 .../other-new-features/kind-polymorphism.md   |  47 +
 .../other-new-features/matchable.md           | 141 +++
 .../other-new-features/opaques-details.md     | 126 +++
 .../other-new-features/opaques.md             | 179 ++++
 .../other-new-features/open-classes.md        |  80 ++
 .../other-new-features/other-new-features.md  |   7 +
 .../parameter-untupling-spec.md               |  89 ++
 .../other-new-features/parameter-untupling.md |  77 ++
 .../other-new-features/safe-initialization.md | 343 ++++++++
 .../other-new-features/targetName.md          | 118 +++
 .../threadUnsafe-annotation.md                |  18 +
 .../other-new-features/trait-parameters.md    |  88 ++
 .../other-new-features/transparent-traits.md  |  70 ++
 .../other-new-features/type-test.md           | 181 ++++
 docs/_spec/TODOreference/overview.md          | 155 ++++
 docs/_spec/TODOreference/soft-modifier.md     |  27 +
 docs/_spec/TODOreference/syntax.md            | 472 ++++++++++
 121 files changed, 15330 insertions(+)
 create mode 100644 docs/_spec/TODOreference/changed-features/changed-features.md
 create mode 100644 docs/_spec/TODOreference/changed-features/compiler-plugins.md
 create mode 100644 docs/_spec/TODOreference/changed-features/eta-expansion-spec.md
 create mode 100644 docs/_spec/TODOreference/changed-features/eta-expansion.md
 create mode 100644 docs/_spec/TODOreference/changed-features/implicit-conversions-spec.md
 create mode 100644 docs/_spec/TODOreference/changed-features/implicit-conversions.md
 create mode 100644 docs/_spec/TODOreference/changed-features/implicit-resolution.md
 create mode 100644 docs/_spec/TODOreference/changed-features/imports.md
 create mode 100644 docs/_spec/TODOreference/changed-features/interpolation-escapes.md
 create mode 100644 docs/_spec/TODOreference/changed-features/lazy-vals-init.md
 create mode 100644 docs/_spec/TODOreference/changed-features/main-functions.md
 create mode 100644 docs/_spec/TODOreference/changed-features/match-syntax.md
 create mode 100644 docs/_spec/TODOreference/changed-features/numeric-literals.md
 create mode 100644 docs/_spec/TODOreference/changed-features/operators.md
 create mode 100644 docs/_spec/TODOreference/changed-features/overload-resolution.md
 create mode 100644 docs/_spec/TODOreference/changed-features/pattern-bindings.md
 create mode 100644 docs/_spec/TODOreference/changed-features/pattern-matching.md
 create mode 100644 docs/_spec/TODOreference/changed-features/structural-types-spec.md
 create mode 100644 docs/_spec/TODOreference/changed-features/structural-types.md
 create mode 100644 docs/_spec/TODOreference/changed-features/type-checking.md
 create mode 100644 docs/_spec/TODOreference/changed-features/type-inference.md
 create mode 100644 docs/_spec/TODOreference/changed-features/vararg-splices.md
 create mode 100644 docs/_spec/TODOreference/changed-features/wildcards.md
 create mode 100644 docs/_spec/TODOreference/contextual/by-name-context-parameters.md
 create mode 100644 docs/_spec/TODOreference/contextual/context-bounds.md
 create mode 100644 docs/_spec/TODOreference/contextual/context-functions-spec.md
 create mode 100644 docs/_spec/TODOreference/contextual/context-functions.md
 create mode 100644 docs/_spec/TODOreference/contextual/contextual.md
 create mode 100644 docs/_spec/TODOreference/contextual/conversions.md
 create mode 100644 docs/_spec/TODOreference/contextual/derivation-macro.md
 create mode 100644 docs/_spec/TODOreference/contextual/derivation.md
 create mode 100644 docs/_spec/TODOreference/contextual/extension-methods.md
 create mode 100644 docs/_spec/TODOreference/contextual/given-imports.md
 create mode 100644 docs/_spec/TODOreference/contextual/givens.md
 create mode 100644 docs/_spec/TODOreference/contextual/multiversal-equality.md
 create mode 100644 docs/_spec/TODOreference/contextual/relationship-implicits.md
 create mode 100644 docs/_spec/TODOreference/contextual/right-associative-extension-methods.md
 create mode 100644 docs/_spec/TODOreference/contextual/type-classes.md
 create mode 100644 docs/_spec/TODOreference/contextual/using-clauses.md
 create mode 100644 docs/_spec/TODOreference/dropped-features/auto-apply.md
 create mode 100644 docs/_spec/TODOreference/dropped-features/class-shadowing-spec.md
 create mode 100644 docs/_spec/TODOreference/dropped-features/class-shadowing.md
 create mode 100644 docs/_spec/TODOreference/dropped-features/delayed-init.md
 create mode 100644 docs/_spec/TODOreference/dropped-features/do-while.md
 create mode 100644 docs/_spec/TODOreference/dropped-features/dropped-features.md
 create mode 100644 docs/_spec/TODOreference/dropped-features/early-initializers.md
 create mode 100644 docs/_spec/TODOreference/dropped-features/existential-types.md
 create mode 100644 docs/_spec/TODOreference/dropped-features/limit22.md
 create mode 100644 docs/_spec/TODOreference/dropped-features/macros.md
 create mode 100644 docs/_spec/TODOreference/dropped-features/nonlocal-returns.md
 create mode 100644 docs/_spec/TODOreference/dropped-features/package-objects.md
 create mode 100644 docs/_spec/TODOreference/dropped-features/procedure-syntax.md
 create mode 100644 docs/_spec/TODOreference/dropped-features/symlits.md
 create mode 100644 docs/_spec/TODOreference/dropped-features/this-qualifier.md
 create mode 100644 docs/_spec/TODOreference/dropped-features/type-projection.md
 create mode 100644 docs/_spec/TODOreference/dropped-features/weak-conformance-spec.md
 create mode 100644 docs/_spec/TODOreference/dropped-features/weak-conformance.md
 create mode 100644 docs/_spec/TODOreference/dropped-features/wildcard-init.md
 create mode 100644 docs/_spec/TODOreference/dropped-features/xml.md
 create mode 100644 docs/_spec/TODOreference/enums/adts.md
 create mode 100644 docs/_spec/TODOreference/enums/desugarEnums.md
 create mode 100644 docs/_spec/TODOreference/enums/enums-index.md
 create mode 100644 docs/_spec/TODOreference/enums/enums.md
 create mode 100644 docs/_spec/TODOreference/experimental/canthrow.md
 create mode 100644 docs/_spec/TODOreference/experimental/cc.md
 create mode 100644 docs/_spec/TODOreference/experimental/erased-defs-spec.md
 create mode 100644 docs/_spec/TODOreference/experimental/erased-defs.md
 create mode 100644 docs/_spec/TODOreference/experimental/explicit-nulls.md
 create mode 100644 docs/_spec/TODOreference/experimental/fewer-braces.md
 create mode 100644 docs/_spec/TODOreference/experimental/main-annotation.md
 create mode 100644 docs/_spec/TODOreference/experimental/named-typeargs-spec.md
 create mode 100644 docs/_spec/TODOreference/experimental/named-typeargs.md
 create mode 100644 docs/_spec/TODOreference/experimental/numeric-literals.md
 create mode 100644 docs/_spec/TODOreference/experimental/overview.md
 create mode 100644 docs/_spec/TODOreference/experimental/tupled-function.md
 create mode 100644 docs/_spec/TODOreference/features-classification.md
 create mode 100644 docs/_spec/TODOreference/language-versions/binary-compatibility.md
 create mode 100644 docs/_spec/TODOreference/language-versions/language-versions.md
 create mode 100644 docs/_spec/TODOreference/language-versions/source-compatibility.md
 create mode 100644 docs/_spec/TODOreference/metaprogramming/compiletime-ops.md
 create mode 100644 docs/_spec/TODOreference/metaprogramming/inline.md
 create mode 100644 docs/_spec/TODOreference/metaprogramming/macros-spec.md
 create mode 100644 docs/_spec/TODOreference/metaprogramming/macros.md
 create mode 100644 docs/_spec/TODOreference/metaprogramming/metaprogramming.md
 create mode 100644 docs/_spec/TODOreference/metaprogramming/reflection.md
 create mode 100644 docs/_spec/TODOreference/metaprogramming/simple-smp.md
 create mode 100644 docs/_spec/TODOreference/metaprogramming/staging.md
 create mode 100644 docs/_spec/TODOreference/metaprogramming/tasty-inspect.md
 create mode 100644 docs/_spec/TODOreference/new-types/dependent-function-types-spec.md
 create mode 100644 docs/_spec/TODOreference/new-types/dependent-function-types.md
 create mode 100644 docs/_spec/TODOreference/new-types/intersection-types-spec.md
 create mode 100644 docs/_spec/TODOreference/new-types/intersection-types.md
 create mode 100644 docs/_spec/TODOreference/new-types/match-types.md
 create mode 100644 docs/_spec/TODOreference/new-types/new-types.md
 create mode 100644 docs/_spec/TODOreference/new-types/polymorphic-function-types.md
 create mode 100644 docs/_spec/TODOreference/new-types/type-lambdas-spec.md
 create mode 100644 docs/_spec/TODOreference/new-types/type-lambdas.md
 create mode 100644 docs/_spec/TODOreference/new-types/union-types-spec.md
 create mode 100644 docs/_spec/TODOreference/new-types/union-types.md
 create mode 100644 docs/_spec/TODOreference/other-new-features/control-syntax.md
 create mode 100644 docs/_spec/TODOreference/other-new-features/creator-applications.md
 create mode 100644 docs/_spec/TODOreference/other-new-features/experimental-defs.md
 create mode 100644 docs/_spec/TODOreference/other-new-features/export.md
 create mode 100644 docs/_spec/TODOreference/other-new-features/indentation.md
 create mode 100644 docs/_spec/TODOreference/other-new-features/kind-polymorphism.md
 create mode 100644 docs/_spec/TODOreference/other-new-features/matchable.md
 create mode 100644 docs/_spec/TODOreference/other-new-features/opaques-details.md
 create mode 100644 docs/_spec/TODOreference/other-new-features/opaques.md
 create mode 100644 docs/_spec/TODOreference/other-new-features/open-classes.md
 create mode 100644 docs/_spec/TODOreference/other-new-features/other-new-features.md
 create mode 100644 docs/_spec/TODOreference/other-new-features/parameter-untupling-spec.md
 create mode 100644 docs/_spec/TODOreference/other-new-features/parameter-untupling.md
 create mode 100644 docs/_spec/TODOreference/other-new-features/safe-initialization.md
 create mode 100644 docs/_spec/TODOreference/other-new-features/targetName.md
 create mode 100644 docs/_spec/TODOreference/other-new-features/threadUnsafe-annotation.md
 create mode 100644 docs/_spec/TODOreference/other-new-features/trait-parameters.md
 create mode 100644 docs/_spec/TODOreference/other-new-features/transparent-traits.md
 create mode 100644 docs/_spec/TODOreference/other-new-features/type-test.md
 create mode 100644 docs/_spec/TODOreference/overview.md
 create mode 100644 docs/_spec/TODOreference/soft-modifier.md
 create mode 100644 docs/_spec/TODOreference/syntax.md

diff --git a/docs/_spec/TODOreference/changed-features/changed-features.md b/docs/_spec/TODOreference/changed-features/changed-features.md
new file mode 100644
index 000000000000..cacdc2598a02
--- /dev/null
+++ b/docs/_spec/TODOreference/changed-features/changed-features.md
@@ -0,0 +1,7 @@
+---
+layout: index
+title: "Other Changed Features"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/changed-features.html
+---
+
+The following pages document the features that have changed in Scala 3, compared to Scala 2.
diff --git a/docs/_spec/TODOreference/changed-features/compiler-plugins.md b/docs/_spec/TODOreference/changed-features/compiler-plugins.md
new file mode 100644
index 000000000000..20bdb7f49836
--- /dev/null
+++ b/docs/_spec/TODOreference/changed-features/compiler-plugins.md
@@ -0,0 +1,128 @@
+---
+layout: doc-page
+title: "Changes in Compiler Plugins"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/changed-features/compiler-plugins.html
+---
+
+Compiler plugins are supported by Dotty (and Scala 3) since 0.9. There are two notable changes
+compared to `scalac`:
+
+- No support for analyzer plugins
+- Added support for research plugins
+
+[Analyzer plugins][1] in `scalac` run during type checking and may influence
+normal type checking. This is a very powerful feature but for production usages,
+a predictable and consistent type checker is more important.
+
+For experimentation and research, Scala 3 introduces _research plugin_. Research plugins
+are more powerful than `scalac` analyzer plugins as they let plugin authors customize
+the whole compiler pipeline. One can easily replace the standard typer by a custom one or
+create a parser for a domain-specific language. However, research plugins are only
+enabled for nightly or snaphot releases of Scala 3.
+
+Common plugins that add new phases to the compiler pipeline are called
+_standard plugins_ in Scala 3. In terms of features, they are similar to
+`scalac` plugins, despite minor changes in the API.
+
+## Using Compiler Plugins
+
+Both standard and research plugins can be used with `scalac` by adding the `-Xplugin:` option:
+
+```shell
+scalac -Xplugin:pluginA.jar -Xplugin:pluginB.jar Test.scala
+```
+
+The compiler will examine the jar provided, and look for a property file named
+`plugin.properties` in the root directory of the jar. The property file specifies
+the fully qualified plugin class name. The format of a property file is as follows:
+
+```properties
+pluginClass=dividezero.DivideZero
+```
+
+This is different from `scalac` plugins that required a `scalac-plugin.xml` file.
+
+Starting from 1.1.5, `sbt` also supports Scala 3 compiler plugins. Please refer to the
+[`sbt` documentation][2] for more information.
+
+## Writing a Standard Compiler Plugin
+
+Here is the source code for a simple compiler plugin that reports integer divisions by
+zero as errors.
+
+```scala
+package dividezero
+
+import dotty.tools.dotc.ast.Trees.*
+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.Decorators.*
+import dotty.tools.dotc.core.StdNames.*
+import dotty.tools.dotc.core.Symbols.*
+import dotty.tools.dotc.plugins.{PluginPhase, StandardPlugin}
+import dotty.tools.dotc.transform.{Pickler, Staging}
+
+class DivideZero extends StandardPlugin:
+  val name: String = "divideZero"
+  override val description: String = "divide zero check"
+
+  def init(options: List[String]): List[PluginPhase] =
+    (new DivideZeroPhase) :: Nil
+
+class DivideZeroPhase extends PluginPhase:
+  import tpd.*
+
+  val phaseName = "divideZero"
+
+  override val runsAfter = Set(Pickler.name)
+  override val runsBefore = Set(Staging.name)
+
+  override def transformApply(tree: Apply)(implicit ctx: Context): Tree =
+    tree match
+      case Apply(Select(rcvr, nme.DIV), List(Literal(Constant(0))))
+      if rcvr.tpe <:< defn.IntType =>
+        report.error("dividing by zero", tree.pos)
+      case _ =>
+        ()
+    tree
+end DivideZeroPhase
+```
+
+The plugin main class (`DivideZero`) must extend the trait `StandardPlugin`
+and implement the method `init` that takes the plugin's options as argument
+and returns a list of `PluginPhase`s to be inserted into the compilation pipeline.
+
+Our plugin adds one compiler phase to the pipeline. A compiler phase must extend
+the `PluginPhase` trait. In order to specify when the phase is executed, we also
+need to specify a `runsBefore` and `runsAfter` constraints that are list of phase
+names.
+
+We can now transform trees by overriding methods like `transformXXX`.
+
+## Writing a Research Compiler Plugin
+
+Here is a template for research plugins.
+
+```scala
+import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.core.Phases.Phase
+import dotty.tools.dotc.plugins.ResearchPlugin
+
+class DummyResearchPlugin extends ResearchPlugin:
+  val name: String = "dummy"
+  override val description: String = "dummy research plugin"
+
+  def init(options: List[String], phases: List[List[Phase]])(implicit ctx: Context): List[List[Phase]] =
+    phases
+end DummyResearchPlugin
+```
+
+A research plugin must extend the trait `ResearchPlugin`  and implement the
+method `init` that takes the plugin's options as argument as well as the compiler
+pipeline in the form of a list of compiler phases. The method can replace, remove
+or add any phases to the pipeline and return the updated pipeline.
+
+
+[1]: https://github.com/scala/scala/blob/2.13.x/src/compiler/scala/tools/nsc/typechecker/AnalyzerPlugins.scala
+[2]: https://www.scala-sbt.org/1.x/docs/Compiler-Plugins.html
diff --git a/docs/_spec/TODOreference/changed-features/eta-expansion-spec.md b/docs/_spec/TODOreference/changed-features/eta-expansion-spec.md
new file mode 100644
index 000000000000..a62d45df9e11
--- /dev/null
+++ b/docs/_spec/TODOreference/changed-features/eta-expansion-spec.md
@@ -0,0 +1,77 @@
+---
+layout: doc-page
+title: "Automatic Eta Expansion - More Details"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/changed-features/eta-expansion-spec.html
+---
+
+## Motivation
+
+Scala maintains a convenient distinction between _methods_ and _functions_.
+Methods are part of the definition of a class that can be invoked in objects while functions are complete objects themselves, making them first-class entities. For example, they can be assigned to variables.
+These two mechanisms are bridged in Scala by a mechanism called
+[_eta-expansion_](https://www.scala-lang.org/files/archive/spec/2.13/06-expressions.html#eta-expansion-section)
+(also called eta-abstraction), which converts a reference to a method into a function. Intuitively, a method `m` can be passed around by turning it into an object: the function `x => m(x)`.
+
+In this snippet which assigns a method to a `val`, the compiler will perform _automatic eta-expansion_, as shown in the comment:
+
+```scala
+def m(x: Int, y: String) = ???
+val f = m // becomes: val f = (x: Int, y: String) => m(x, y)
+```
+
+In Scala 2, a method reference `m` is converted to a function value only if the expected type is a function type, which means the conversion in the example above would not have been triggered, because `val f` does not have a type ascription. To still get eta-expansion, a shortcut `m _` would force the conversion.
+
+For methods with one or more parameters like in the example above, this restriction has now been dropped. The syntax `m _` is no longer needed and will be deprecated in the future.
+
+## Automatic eta-expansion and partial application
+In the following example `m` can be partially applied to the first two parameters.
+Assigning `m` to `f1` will automatically eta-expand.
+
+```scala
+def m(x: Boolean, y: String)(z: Int): List[Int]
+val f1 = m
+val f2 = m(true, "abc")
+```
+
+This creates two function values:
+
+```scala
+f1: (Boolean, String) => Int => List[Int]
+f2: Int => List[Int]
+```
+
+## Automatic eta-expansion and implicit parameter lists
+
+Methods with implicit parameter lists will always get applied to implicit arguments.
+
+```scala
+def foo(x: Int)(implicit p: Double): Float = ???
+implicit val bla: Double = 1.0
+
+val bar = foo // val bar: Int => Float = ...
+```
+
+## Automatic Eta-Expansion and query types
+
+A method with context parameters can be expanded to a value of a context type by writing the expected context type explicitly.
+
+```scala
+def foo(x: Int)(using p: Double): Float = ???
+val bar: Double ?=> Float = foo(3)
+```
+
+## Rules
+
+- If `m` has an argument list with one or more parameters, we always eta-expand
+- If `m` is has an empty argument list (i.e. has type `()R`):
+    1. If the expected type is of the form `() => T`, we eta expand.
+    2. If m is defined by Java, or overrides a Java defined method, we insert `()`.
+    3. Otherwise we issue an error of the form:
+
+Thus, an unapplied method with an empty argument list is only converted to a function when a function type is expected. It is considered best practice to either explicitly apply the method to `()`, or convert it to a function with `() => m()`.
+
+The method value syntax `m _` is deprecated.
+
+## Reference
+
+For more information, see [PR #2701](https://github.com/lampepfl/dotty/pull/2701).
diff --git a/docs/_spec/TODOreference/changed-features/eta-expansion.md b/docs/_spec/TODOreference/changed-features/eta-expansion.md
new file mode 100644
index 000000000000..c05378135e54
--- /dev/null
+++ b/docs/_spec/TODOreference/changed-features/eta-expansion.md
@@ -0,0 +1,42 @@
+---
+layout: doc-page
+title: "Automatic Eta Expansion"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/changed-features/eta-expansion.html
+---
+
+The conversion of _methods_ into _functions_ has been improved and happens automatically for methods with one or more parameters.
+
+```scala
+def m(x: Boolean, y: String)(z: Int): List[Int]
+val f1 = m
+val f2 = m(true, "abc")
+```
+
+This creates two function values:
+```scala
+f1: (Boolean, String) => Int => List[Int]
+f2: Int => List[Int]
+```
+
+The syntax `m _` is no longer needed and will be deprecated in the future.
+
+## Automatic eta-expansion and nullary methods
+
+Automatic eta expansion does not apply to "nullary" methods that take an empty parameter list.
+
+```scala
+def next(): T
+```
+
+Given a simple reference to `next` does not auto-convert to a function.
+One has to write explicitly `() => next()` to achieve that.
+Once again since the `_` is going to be deprecated it's better to write it this way
+rather than `next _`.
+
+The reason for excluding nullary methods from automatic eta expansion
+is that Scala implicitly inserts the `()` argument, which would
+conflict with eta expansion. Automatic `()` insertion is
+[limited](../dropped-features/auto-apply.md) in Scala 3, but the fundamental ambiguity
+remains.
+
+[More details](eta-expansion-spec.md)
diff --git a/docs/_spec/TODOreference/changed-features/implicit-conversions-spec.md b/docs/_spec/TODOreference/changed-features/implicit-conversions-spec.md
new file mode 100644
index 000000000000..dc19e10c8b8f
--- /dev/null
+++ b/docs/_spec/TODOreference/changed-features/implicit-conversions-spec.md
@@ -0,0 +1,117 @@
+---
+layout: doc-page
+title: "Implicit Conversions - More Details"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/changed-features/implicit-conversions-spec.html
+---
+
+## Implementation
+
+An implicit conversion, or _view_, from type `S` to type `T` is
+defined by either:
+
+- An `implicit def` which has type `S => T` or `(=> S) => T`
+- An implicit value which has type `Conversion[S, T]`
+
+The standard library defines an abstract class [`Conversion`](https://scala-lang.org/api/3.x/scala/Conversion.html):
+
+```scala
+package scala
+@java.lang.FunctionalInterface
+abstract class Conversion[-T, +U] extends Function1[T, U]:
+  def apply(x: T): U
+```
+
+Function literals are automatically converted to `Conversion` values.
+
+Views are applied in three situations:
+
+1. If an expression `e` is of type `T`, and `T` does not conform to
+   the expression's expected type `pt`. In this case, an implicit `v`
+   which is applicable to `e` and whose result type conforms to `pt`
+   is searched. The search proceeds as in the case of implicit
+   parameters, where the implicit scope is the one of `T => pt`. If
+   such a view is found, the expression `e` is converted to `v(e)`.
+1. In a selection `e.m` with `e` of type `T`, if the selector `m` does
+   not denote an accessible member of `T`. In this case, a view `v`
+   which is applicable to `e` and whose result contains an accessible
+   member named `m` is searched. The search proceeds as in the case of
+   implicit parameters, where the implicit scope is the one of `T`. If
+   such a view is found, the selection `e.m` is converted to `v(e).m`.
+1. In an application `e.m(args)` with `e` of type `T`, if the selector
+   `m` denotes some accessible member(s) of `T`, but none of these
+   members is applicable to the arguments `args`. In this case, a view
+   `v` which is applicable to `e` and whose result contains a method
+   `m` which is applicable to `args` is searched. The search proceeds
+   as in the case of implicit parameters, where the implicit scope is
+   the one of `T`. If such a view is found, the application
+   `e.m(args)` is converted to `v(e).m(args)`.
+
+# Differences with Scala 2 implicit conversions
+
+In Scala 2, views whose parameters are passed by-value take precedence
+over views whose parameters are passed by-name. This is no longer the
+case in Scala 3. A type error reporting the ambiguous conversions will
+be emitted in cases where this rule would be applied in Scala 2:
+
+```scala
+implicit def conv1(x: Int): String = x.toString
+implicit def conv2(x: => Int): String = x.toString
+
+val x: String = 0 // Compiles in Scala2 (uses `conv1`),
+                  // type error in Scala 3 because of ambiguity.
+```
+
+In Scala 2, implicit values of a function type would be considered as
+potential views. In Scala 3, these implicit value need to have type
+`Conversion`:
+
+```scala
+// Scala 2:
+def foo(x: Int)(implicit conv: Int => String): String = x
+
+// Becomes with Scala 3:
+def foo(x: Int)(implicit conv: Conversion[Int, String]): String = x
+
+// Call site is unchanged:
+foo(4)(_.toString)
+
+// Scala 2:
+implicit val myConverter: Int => String = _.toString
+
+// Becomes with Scala 3:
+implicit val myConverter: Conversion[Int, String] = _.toString
+```
+
+Note that implicit conversions are also affected by the [changes to implicit resolution](implicit-resolution.md) between Scala 2 and Scala 3.
+
+## Motivation for the changes
+
+The introduction of [`scala.Conversion`](https://scala-lang.org/api/3.x/scala/Conversion.html)
+in Scala 3 and the decision to restrict implicit values of this type to be
+considered as potential views comes from the desire to remove surprising
+behavior from the language:
+
+```scala
+implicit val m: Map[Int, String] = Map(1 -> "abc")
+
+val x: String = 1  // Scala 2: assigns "abc" to x
+                   // Scala 3: type error
+```
+
+This snippet contains a type error. The right-hand side of `val x`
+does not conform to type `String`. In Scala 2, the compiler will use
+`m` as an implicit conversion from `Int` to `String`, whereas Scala 3
+will report a type error, because `Map` isn't an instance of
+[`Conversion`](https://scala-lang.org/api/3.x/scala/Conversion.html).
+
+## Migration path
+
+Implicit values that are used as views should see their type changed to `Conversion`.
+
+For the migration of implicit conversions that are affected by the
+changes to implicit resolution, refer to the [Changes in Implicit Resolution](implicit-resolution.md) for more information.
+
+## Reference
+
+For more information about implicit resolution, see [Changes in Implicit Resolution](implicit-resolution.md).
+Other details are available in [PR #2065](https://github.com/lampepfl/dotty/pull/2065).
diff --git a/docs/_spec/TODOreference/changed-features/implicit-conversions.md b/docs/_spec/TODOreference/changed-features/implicit-conversions.md
new file mode 100644
index 000000000000..eef236f39a07
--- /dev/null
+++ b/docs/_spec/TODOreference/changed-features/implicit-conversions.md
@@ -0,0 +1,65 @@
+---
+layout: doc-page
+title: "Implicit Conversions"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/changed-features/implicit-conversions.html
+---
+
+An _implicit conversion_, also called _view_, is a conversion that
+is applied by the compiler in several situations:
+
+1. When an expression `e` of type `T` is encountered, but the compiler
+   needs an expression of type `S`.
+1. When an expression `e.m` where `e` has type `T` but `T` defines no
+   member `m` is encountered.
+
+In those cases, the compiler looks in the implicit scope for a
+conversion that can convert an expression of type `T` to an expression
+of type `S` (or to a type that defines a member `m` in the second
+case).
+
+This conversion can be either:
+
+1. An `implicit def` of type `T => S` or `(=> T) => S`
+1. An implicit value of type `scala.Conversion[T, S]`
+
+Defining an implicit conversion will emit a warning unless the import
+`scala.language.implicitConversions` is in scope, or the flag
+`-language:implicitConversions` is given to the compiler.
+
+## Examples
+
+The first example is taken from [`scala.Predef`](https://scala-lang.org/api/3.x/scala/Predef$.html).
+Thanks to this implicit conversion, it is possible to pass a
+[`scala.Int`](https://scala-lang.org/api/3.x/scala/Int.html)
+to a Java method that expects a `java.lang.Integer`
+
+```scala
+import scala.language.implicitConversions
+implicit def int2Integer(x: Int): java.lang.Integer =
+  x.asInstanceOf[java.lang.Integer]
+```
+
+The second example shows how to use `Conversion` to define an
+`Ordering` for an arbitrary type, given existing `Ordering`s for other
+types:
+
+```scala
+import scala.language.implicitConversions
+implicit def ordT[T, S](
+    implicit conv: Conversion[T, S],
+             ordS: Ordering[S]
+   ): Ordering[T] =
+   // `ordS` compares values of type `S`, but we can convert from `T` to `S`
+  (x: T, y: T) => ordS.compare(x, y)
+
+class A(val x: Int) // The type for which we want an `Ordering`
+
+// Convert `A` to a type for which an `Ordering` is available:
+implicit val AToInt: Conversion[A, Int] = _.x
+
+implicitly[Ordering[Int]] // Ok, exists in the standard library
+implicitly[Ordering[A]] // Ok, will use the implicit conversion from
+                        // `A` to `Int` and the `Ordering` for `Int`.
+```
+
+[More details](implicit-conversions-spec.md)
diff --git a/docs/_spec/TODOreference/changed-features/implicit-resolution.md b/docs/_spec/TODOreference/changed-features/implicit-resolution.md
new file mode 100644
index 000000000000..bf15baa3299c
--- /dev/null
+++ b/docs/_spec/TODOreference/changed-features/implicit-resolution.md
@@ -0,0 +1,169 @@
+---
+layout: doc-page
+title: "Changes in Implicit Resolution"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/changed-features/implicit-resolution.html
+---
+
+This section describes changes to the implicit resolution that apply both to the new `given`s and to the old-style `implicit`s in Scala 3.
+Implicit resolution uses a new algorithm which caches implicit results
+more aggressively for performance. There are also some changes that
+affect implicits on the language level.
+
+**1.** Types of implicit values and result types of implicit methods
+must be explicitly declared. Excepted are only values in local blocks
+where the type may still be inferred:
+```scala
+  class C {
+
+    val ctx: Context = ...        // ok
+
+    /*!*/ implicit val x = ...    // error: type must be given explicitly
+
+    /*!*/ implicit def y = ...    // error: type must be given explicitly
+  }
+  val y = {
+    implicit val ctx = this.ctx // ok
+    ...
+  }
+```
+**2.** Nesting is now taken into account for selecting an implicit. Consider for instance the following scenario:
+```scala
+  def f(implicit i: C) = {
+    def g(implicit j: C) = {
+      implicitly[C]
+    }
+  }
+```
+This will now resolve the `implicitly` call to `j`, because `j` is nested
+more deeply than `i`. Previously, this would have resulted in an
+ambiguity error. The previous possibility of an implicit search failure
+due to _shadowing_ (where an implicit is hidden by a nested definition)
+no longer applies.
+
+**3.** Package prefixes no longer contribute to the implicit search scope of a type. Example:
+```scala
+  package p
+
+  given a: A = A()
+
+  object o:
+    given b: B = B()
+    type C
+```
+Both `a` and `b` are visible as implicits at the point of the definition
+of `type C`. However, a reference to `p.o.C` outside of package `p` will
+have only `b` in its implicit search scope but not `a`.
+
+In more detail, here are the rules for what constitutes the implicit scope of
+a type:
+
+**Definition:** 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`.
+Opaque type aliases count as anchors only outside the scope where their alias is visible.
+
+**Definition:** The _anchors_ of a type _T_ is a set of references defined as follows:
+
+  1. If _T_ is a reference to an anchor, _T_ itself plus, if _T_ is of the form _P#A_, the anchors of _P_.
+  1. If _T_ is an alias of _U_, the anchors of _U_.
+  1. If _T_ is a reference to a type parameter, the union of the anchors of both of its bounds.
+  1. 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_.
+  1. If _T_ is the this-type _o.this_ of a static object _o_, the anchors of a term reference _o.type_ to that object.
+  1. If _T_ is some other type, the union of the anchors of each constituent type of _T_.
+
+ **Definition:** The _implicit scope_ of a type _T_ is the smallest set _S_ of term references such that
+
+  1. 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.
+  1. 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.
+  1. 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.
+  1. If _T_ is a reference to 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 given bounds.
+  1. If _T_ is a reference to an anchor of the form _p.A_ then _S_ also includes
+    all term references on the path _p_.
+  1. If _T_ is some other type, _S_ includes the implicit scopes of all anchors of _T_.
+
+
+**4.** The treatment of ambiguity errors has changed. If an ambiguity is encountered in some recursive step of an implicit search, the ambiguity is propagated to the caller.
+
+Example: Say you have the following definitions:
+```scala
+  class A
+  class B extends C
+  class C
+  implicit def a1: A
+  implicit def a2: A
+  implicit def b(implicit a: A): B
+  implicit def c: C
+```
+and the query `implicitly[C]`.
+
+This query would now be classified as ambiguous. This makes sense, after all
+there are two possible solutions, `b(a1)` and `b(a2)`, neither of which is better
+than the other and both of which are better than the third solution, `c`.
+By contrast, Scala 2 would have rejected the search for `A` as
+ambiguous, and subsequently have classified the query `b(implicitly[A])` as a normal fail,
+which means that the alternative `c` would be chosen as solution!
+
+Scala 2's somewhat puzzling behavior with respect to ambiguity has been exploited to implement
+the analogue of a "negated" search in implicit resolution, where a query `Q1` fails if some
+other query `Q2` succeeds and `Q1` succeeds if `Q2` fails. With the new cleaned up behavior
+these techniques no longer work. But there is now a new special type [`scala.util.NotGiven`](https://scala-lang.org/api/3.x/scala/util/NotGiven.html)
+which implements negation directly. For any query type `Q`, `NotGiven[Q]` succeeds if and only if
+the implicit search for `Q` fails.
+
+**5.** The treatment of divergence errors has also changed. A divergent implicit is treated as a normal failure, after which alternatives are still tried. This also makes sense: Encountering a divergent implicit means that we assume that no finite solution can be found on the corresponding path, but another path can still be tried. By contrast,
+most (but not all) divergence errors in Scala 2 would terminate the implicit search as a whole.
+
+**6.** Scala 2 gives a lower level of priority to implicit conversions with call-by-name parameters relative to implicit conversions with call-by-value parameters. Scala 3 drops this distinction. So the following code snippet would be ambiguous in Scala 3:
+
+```scala
+  implicit def conv1(x: Int): A = new A(x)
+  implicit def conv2(x: => Int): A = new A(x)
+  def buzz(y: A) = ???
+  buzz(1)   // error: ambiguous
+```
+**7.** The rule for picking a _most specific_ alternative among a set of overloaded or implicit alternatives is refined to take context parameters into account. All else being equal, an alternative that takes some context parameters is taken to be less specific than an alternative that takes none. If both alternatives take context parameters, we try to choose between them as if they were methods with regular parameters. The following paragraph in the [SLS §6.26.3](https://scala-lang.org/files/archive/spec/2.13/06-expressions.html#overloading-resolution) is affected by this change:
+
+_Original version:_
+
+> An alternative A is _more specific_ than an alternative B if the relative weight of A over B is greater than the relative weight of B over A.
+
+_Modified version:_
+
+An alternative A is _more specific_ than an alternative B if
+
+ - the relative weight of A over B is greater than the relative weight of B over A, or
+ - the relative weights are the same, and A takes no implicit parameters but B does, or
+ - the relative weights are the same, both A and B take implicit parameters, and A is more specific than B if all implicit parameters in either alternative are replaced by regular parameters.
+
+**8.** The previous disambiguation of implicits based on inheritance depth is refined to make it transitive. Transitivity is important to guarantee that search outcomes are compilation-order independent. Here's a scenario where the previous rules violated transitivity:
+```scala
+  class A extends B
+  object A { given a ... }
+  class B
+  object B extends C { given b ... }
+  class C { given c }
+```
+ Here `a` is more specific than `b` since the companion class `A` is a subclass of the companion class `B`. Also, `b` is more specific than `c`
+   since `object B` extends class `C`. But `a` is not more specific than `c`. This means if `a, b, c` are all applicable implicits, it makes
+   a difference in what order they are compared. If we compare `b` and `c`
+   first, we keep `b` and drop `c`. Then, comparing `a` with `b` we keep `a`. But if we compare `a` with `c` first, we fail with an ambiguity error.
+
+The new rules are as follows: An implicit `a` defined in `A` is more specific than an implicit `b` defined in `B` if
+
+ - `A` extends `B`, or
+ - `A` is an object and the companion class of `A` extends `B`, or
+ - `A` and `B` are objects,
+    `B` does not inherit any implicit members from base classes (*),
+    and the companion class of `A` extends the companion class of `B`.
+
+Condition (*) is new. It is necessary to ensure that the defined relation is transitive.
+
+
+
+
+
+[//]: # todo: expand with precise rules
diff --git a/docs/_spec/TODOreference/changed-features/imports.md b/docs/_spec/TODOreference/changed-features/imports.md
new file mode 100644
index 000000000000..2058ef08b7db
--- /dev/null
+++ b/docs/_spec/TODOreference/changed-features/imports.md
@@ -0,0 +1,60 @@
+---
+layout: doc-page
+title: "Imports"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/changed-features/imports.html
+---
+
+The syntax of wildcard and renaming imports (and exports) has changed.
+
+## Wildcard Imports
+
+Wildcard imports are now expressed with `*` instead of underscore. Example:
+```scala
+import scala.annotation.*  // imports everything in the annotation package
+```
+
+If you want to import a member named `*` specifically, you can use backticks around it.
+
+```scala
+object A:
+  def * = ...
+  def min = ...
+
+object B:
+  import A.`*`   // imports just `*`
+
+object C:
+  import A.*     // imports everything in A
+```
+
+## Renaming Imports
+
+To rename or exclude an import, we now use `as` instead of `=>`. A single renaming import no longer needs to be enclosed in braces. Examples:
+
+```scala
+import A.{min as minimum, `*` as multiply}
+import Predef.{augmentString as _, *}     // imports everything except augmentString
+import scala.annotation as ann
+import java as j
+```
+
+## Migration
+
+To support cross-building, Scala 3.0 supports the old import syntax with `_` for wildcards and `=>` for renamings in addition to the new one. The old syntax
+will be dropped in a future versions. Automatic rewritings from old to new syntax
+are offered under settings `-source 3.1-migration -rewrite`.
+
+## Syntax
+
+```
+Import            ::=  ‘import’ ImportExpr {‘,’ ImportExpr}
+ImportExpr        ::= SimpleRef {‘.’ id} ‘.’ ImportSpec
+                    | SimpleRef `as` id
+ImportSpec        ::=  NamedSelector
+                    |  WildcardSelector
+                    | ‘{’ ImportSelectors) ‘}’
+NamedSelector     ::=  id [‘as’ (id | ‘_’)]
+WildCardSelector  ::=  ‘*' | ‘given’ [InfixType]
+ImportSelectors   ::=  NamedSelector [‘,’ ImportSelectors]
+                    |  WildCardSelector {‘,’ WildCardSelector}
+```
diff --git a/docs/_spec/TODOreference/changed-features/interpolation-escapes.md b/docs/_spec/TODOreference/changed-features/interpolation-escapes.md
new file mode 100644
index 000000000000..594e7671c5ab
--- /dev/null
+++ b/docs/_spec/TODOreference/changed-features/interpolation-escapes.md
@@ -0,0 +1,14 @@
+---
+layout: doc-page
+title: "Escapes in interpolations"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/changed-features/interpolation-escapes.html
+---
+
+In Scala 2 there is no straightforward way to represent a single quote character `"` in a single quoted interpolation. A `\` character can't be used for that because interpolators themselves decide how to handle escaping, so the parser doesn't know whether the `"` character should be escaped or used as a terminator.
+
+In Scala 3, we can use the `$` meta character of interpolations to escape a `"` character. Example:
+
+```scala
+  val inventor = "Thomas Edison"
+  val interpolation = s"as $inventor said: $"The three great essentials to achieve anything worth while are: Hard work, Stick-to-itiveness, and Common sense.$""
+```
diff --git a/docs/_spec/TODOreference/changed-features/lazy-vals-init.md b/docs/_spec/TODOreference/changed-features/lazy-vals-init.md
new file mode 100644
index 000000000000..131ac6ad7bb2
--- /dev/null
+++ b/docs/_spec/TODOreference/changed-features/lazy-vals-init.md
@@ -0,0 +1,80 @@
+---
+layout: doc-page
+title: Lazy Vals Initialization
+nightlyOf: https://docs.scala-lang.org/scala3/reference/changed-features/lazy-vals-init.html
+---
+
+Scala 3 implements [Version 6](https://docs.scala-lang.org/sips/improved-lazy-val-initialization.html#version-6---no-synchronization-on-this-and-concurrent-initialization-of-fields)
+of the [SIP-20] improved lazy vals initialization proposal.
+
+## Motivation
+
+The newly proposed lazy val initialization mechanism aims to eliminate the acquisition of resources
+during the execution of the lazy val initializer block, thus reducing the possibility of a deadlock.
+The concrete deadlock scenarios that the new lazy val initialization scheme eliminates are
+summarized in the [SIP-20] document.
+
+## Implementation
+
+Given a lazy field of the form:
+
+```scala
+class Foo {
+  lazy val bar = <RHS>
+}
+```
+
+The Scala 3 compiler will generate code equivalent to:
+
+```scala
+class Foo {
+  import scala.runtime.LazyVals
+  var value_0: Int = _
+  var bitmap: Long = 0L
+  val bitmap_offset: Long = LazyVals.getOffset(classOf[LazyCell], "bitmap")
+
+  def bar(): 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
+            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>)
+      }
+    }
+  }
+}
+```
+
+The state of the lazy val `<state-i>` is represented with 4 values: 0, 1, 2 and 3. The state 0
+represents a non-initialized lazy val. The state 1 represents a lazy val that is currently being
+initialized by some thread. The state 2 denotes that there are concurrent readers of the lazy val.
+The state 3 represents a lazy val that has been initialized. `<field-id>` is the id of the lazy
+val. This id grows with the number of volatile lazy vals defined in the class.
+
+## Note on recursive lazy vals
+
+Ideally recursive lazy vals should be flagged as an error. The current behavior for
+recursive lazy vals is undefined (initialization may result in a deadlock).
+
+## Reference
+
+* [SIP-20]
+
+[SIP-20]: https://docs.scala-lang.org/sips/improved-lazy-val-initialization.html
diff --git a/docs/_spec/TODOreference/changed-features/main-functions.md b/docs/_spec/TODOreference/changed-features/main-functions.md
new file mode 100644
index 000000000000..4460300d003e
--- /dev/null
+++ b/docs/_spec/TODOreference/changed-features/main-functions.md
@@ -0,0 +1,87 @@
+---
+layout: doc-page
+title: "Main Methods"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/changed-features/main-functions.html
+---
+
+Scala 3 offers a new way to define programs that can be invoked from the command line:
+A [`@main`](https://scala-lang.org/api/3.x/scala/main.html) annotation on a method turns this method into an executable program.
+Example:
+
+```scala
+@main def happyBirthday(age: Int, name: String, others: String*) =
+  val suffix =
+    age % 100 match
+    case 11 | 12 | 13 => "th"
+    case _ =>
+      age % 10 match
+        case 1 => "st"
+        case 2 => "nd"
+        case 3 => "rd"
+        case _ => "th"
+  val bldr = new StringBuilder(s"Happy $age$suffix birthday, $name")
+  for other <- others do bldr.append(" and ").append(other)
+  bldr.toString
+```
+
+This would generate a main program `happyBirthday` that could be called like this
+
+```
+> scala happyBirthday 23 Lisa Peter
+Happy 23rd birthday, Lisa and Peter
+```
+
+A [`@main`](https://scala-lang.org/api/3.x/scala/main.html) annotated method can be written either at the top-level or in a statically accessible object. The name of the program is in each case the name of the method, without any object prefixes. The [`@main`](https://scala-lang.org/api/3.x/scala/main.html) method can have an arbitrary number of parameters.
+For each parameter type there must be an instance of the [`scala.util.CommandLineParser.FromString[T]`](https://scala-lang.org/api/3.x/scala/util/CommandLineParser$$FromString.html) type class that is used to convert an argument string to the required parameter type `T`.
+The parameter list of a main method can end in a repeated parameter that then takes all remaining arguments given on the command line.
+
+The program implemented from a [`@main`](https://scala-lang.org/api/3.x/scala/main.html) method checks that there are enough arguments on
+the command line to fill in all parameters, and that argument strings are convertible to
+the required types. If a check fails, the program is terminated with an error message.
+
+Examples:
+
+```
+> scala happyBirthday 22
+Illegal command line after first argument: more arguments expected
+
+> scala happyBirthday sixty Fred
+Illegal command line: java.lang.NumberFormatException: For input string: "sixty"
+```
+
+The Scala compiler generates a program from a [`@main`](https://scala-lang.org/api/3.x/scala/main.html) method `f` as follows:
+
+ - It creates a class named `f` in the package where the [`@main`](https://scala-lang.org/api/3.x/scala/main.html) method was found
+ - The class has a static method `main` with the usual signature. It takes an `Array[String]`
+   as argument and returns [`Unit`](https://scala-lang.org/api/3.x/scala/Unit.html).
+ - The generated `main` method calls method `f` with arguments converted using
+   methods in the [`scala.util.CommandLineParser`](https://scala-lang.org/api/3.x/scala/util/CommandLineParser$.html) object.
+
+For instance, the `happyBirthDay` method above would generate additional code equivalent to the following class:
+
+```scala
+final class happyBirthday:
+  import scala.util.CommandLineParser as CLP
+  <static> def main(args: Array[String]): Unit =
+    try
+      happyBirthday(
+        CLP.parseArgument[Int](args, 0),
+        CLP.parseArgument[String](args, 1),
+        CLP.parseRemainingArguments[String](args, 2))
+    catch
+      case error: CLP.ParseError => CLP.showError(error)
+```
+
+**Note**: The `<static>` modifier above expresses that the `main` method is generated
+as a static method of class `happyBirthDay`. It is not available for user programs in Scala. Regular "static" members are generated in Scala using objects instead.
+
+[`@main`](https://scala-lang.org/api/3.x/scala/main.html) methods are the recommended scheme to generate programs that can be invoked from the command line in Scala 3. They replace the previous scheme to write program as objects with a special `App` parent class. In Scala 2, `happyBirthday` could be written also like this:
+
+```scala
+object happyBirthday extends App:
+  // needs by-hand parsing of arguments vector
+  ...
+```
+
+The previous functionality of [`App`](https://www.scala-lang.org/api/3.x/scala/App.html), which relied on the "magic" [`DelayedInit`](../dropped-features/delayed-init.md) trait, is no longer available. [`App`](https://scala-lang.org/api/3.x/scala/App.html) still exists in limited form for now, but it does not support command line arguments and will be deprecated in the future. If programs need to cross-build
+between Scala 2 and Scala 3, it is recommended to use an explicit `main` method with an `Array[String]` argument instead.
diff --git a/docs/_spec/TODOreference/changed-features/match-syntax.md b/docs/_spec/TODOreference/changed-features/match-syntax.md
new file mode 100644
index 000000000000..dba50e9beb6a
--- /dev/null
+++ b/docs/_spec/TODOreference/changed-features/match-syntax.md
@@ -0,0 +1,56 @@
+---
+layout: doc-page
+title: "Match Expressions"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/changed-features/match-syntax.html
+---
+
+The syntactical precedence of match expressions has been changed.
+`match` is still a keyword, but it is used like an alphabetical operator. This has several consequences:
+
+ 1. `match` expressions can be chained:
+
+    ```scala
+    xs match {
+      case Nil => "empty"
+      case _   => "nonempty"
+    } match {
+      case "empty"    => 0
+      case "nonempty" => 1
+    }
+    ```
+
+    (or, dropping the optional braces)
+
+    ```scala
+    xs match
+      case Nil => "empty"
+      case _   => "nonempty"
+    match
+      case "empty" => 0
+      case "nonempty" => 1
+    ```
+
+ 2. `match` may follow a period:
+
+     ```scala
+     if xs.match
+       case Nil => false
+       case _   => true
+     then "nonempty"
+     else "empty"
+     ```
+
+ 3. The scrutinee of a match expression must be an `InfixExpr`. Previously the scrutinee could be followed by a type ascription `: T`, but this is no longer supported. So `x : T match { ... }` now has to be
+ written `(x: T) match { ... }`.
+
+## Syntax
+
+The new syntax of match expressions is as follows.
+
+```
+InfixExpr    ::=  ...
+               |  InfixExpr MatchClause
+SimpleExpr   ::=  ...
+               |  SimpleExpr ‘.’ MatchClause
+MatchClause  ::=  ‘match’ ‘{’ CaseClauses ‘}’
+```
diff --git a/docs/_spec/TODOreference/changed-features/numeric-literals.md b/docs/_spec/TODOreference/changed-features/numeric-literals.md
new file mode 100644
index 000000000000..bba837dbf67d
--- /dev/null
+++ b/docs/_spec/TODOreference/changed-features/numeric-literals.md
@@ -0,0 +1,7 @@
+---
+layout: doc-page
+title: "Numeric Literals"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/changed-features/numeric-literals.html
+---
+
+[Document was moved](../experimental/numeric-literals.md)
diff --git a/docs/_spec/TODOreference/changed-features/operators.md b/docs/_spec/TODOreference/changed-features/operators.md
new file mode 100644
index 000000000000..0cf25d77bc11
--- /dev/null
+++ b/docs/_spec/TODOreference/changed-features/operators.md
@@ -0,0 +1,173 @@
+---
+layout: doc-page
+title: "Rules for Operators"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/changed-features/operators.html
+---
+
+The rules for infix operators have changed in some parts:
+
+First, an alphanumeric method can be used as an infix operator only if its definition carries an `infix` modifier.
+
+Second, it is recommended (but not enforced) to augment definitions of symbolic operators
+with [`@targetName` annotations](../other-new-features/targetName.md).
+
+Finally, a syntax change allows infix operators to be written on the left in a multi-line expression.
+
+## The `infix` Modifier
+
+An `infix` modifier on a method definition allows using the method as an infix operation. Example:
+
+```scala
+import scala.annotation.targetName
+
+trait MultiSet[T]:
+
+  infix def union(other: MultiSet[T]): MultiSet[T]
+
+  def difference(other: MultiSet[T]): MultiSet[T]
+
+  @targetName("intersection")
+  def *(other: MultiSet[T]): MultiSet[T]
+
+end MultiSet
+
+val s1, s2: MultiSet[Int]
+
+s1 union s2         // OK
+s1 `union` s2       // also OK but unusual
+s1.union(s2)        // also OK
+
+s1.difference(s2)   // OK
+s1 `difference` s2  // OK
+s1 difference s2    // gives a deprecation warning
+
+s1 * s2             // OK
+s1 `*` s2           // also OK, but unusual
+s1.*(s2)            // also OK, but unusual
+```
+
+Infix operations involving alphanumeric operators are deprecated, unless
+one of the following conditions holds:
+
+ - the operator definition carries an `infix` modifier, or
+ - the operator was compiled with Scala 2, or
+ - the operator is followed by an opening brace.
+
+An alphanumeric operator is an operator consisting entirely of letters, digits, the `$` and `_` characters, or
+any Unicode character `c` for which `java.lang.Character.isIdentifierPart(c)` returns `true`.
+
+Infix operations involving symbolic operators are always allowed, so `infix` is redundant for methods with symbolic names.
+
+The `infix` modifier can also be given to a type:
+
+```scala
+infix type or[X, Y]
+val x: String or Int = ...
+```
+
+### Motivation
+
+The purpose of the `infix` modifier is to achieve consistency across a code base in how a method or type is applied. The idea is that the author of a method decides whether that method should be applied as an infix operator or in a regular application. Use sites then implement that decision consistently.
+
+### Details
+
+ 1. `infix` is a soft modifier. It is treated as a normal identifier except when in modifier position.
+
+ 2. If a method overrides another, their infix annotations must agree. Either both are annotated with `infix`, or none of them are.
+
+ 3. `infix` modifiers can be given to method definitions. The first non-receiver parameter list of an `infix` method must define exactly one parameter. Examples:
+
+    ```scala
+    infix def op1(x: S): R             // ok
+    infix def op2[T](x: T)(y: S): R    // ok
+    infix def op3[T](x: T, y: S): R    // error: two parameters
+
+    extension (x: A)
+      infix def op4(y: B): R          // ok
+      infix def op5(y1: B, y2: B): R  // error: two parameters
+    ```
+
+ 4. `infix` modifiers can also be given to type, trait or class definitions that have exactly two type parameters. An infix type like
+
+    ```scala
+    infix type op[X, Y]
+    ```
+
+    can be applied using infix syntax, i.e. `A op B`.
+
+ 5. To smooth migration to Scala 3.0, alphanumeric operators will only be deprecated from Scala 3.1 onwards,
+or if the `-source future` option is given in Dotty/Scala 3.
+
+## The `@targetName` Annotation
+
+It is recommended that definitions of symbolic operators carry a [`@targetName` annotation](../other-new-features/targetName.md) that provides an encoding of the operator with an alphanumeric name. This has several benefits:
+
+ - It helps interoperability between Scala and other languages. One can call
+   a Scala-defined symbolic operator from another language using its target name,
+   which avoids having to remember the low-level encoding of the symbolic name.
+ - It helps legibility of stacktraces and other runtime diagnostics, where the
+   user-defined alphanumeric name will be shown instead of the low-level encoding.
+ - It serves as a documentation tool by providing an alternative regular name
+   as an alias of a symbolic operator. This makes the definition also easier
+   to find in a search.
+
+## Syntax Change
+
+Infix operators can now appear at the start of lines in a multi-line expression. Examples:
+
+```scala
+val str = "hello"
+  ++ " world"
+  ++ "!"
+
+def condition =
+  x > 0
+  ||
+  xs.exists(_ > 0)
+  || xs.isEmpty
+```
+
+Previously, those expressions would have been rejected, since the compiler's semicolon inference
+would have treated the continuations `++ " world"` or `|| xs.isEmpty` as separate statements.
+
+To make this syntax work, the rules are modified to not infer semicolons in front of leading infix operators.
+A _leading infix operator_ is
+ - a symbolic identifier such as `+`, or `approx_==`, or an identifier in backticks that
+ - starts a new line, and
+ - is not following a blank line, and
+ - is followed by at least one whitespace character and a token that can start an expression.
+ - Furthermore, if the operator appears on its own line, the next line must have at least
+   the same indentation width as the operator.
+
+Example:
+
+```scala
+    freezing
+  | boiling
+```
+
+This is recognized as a single infix operation. Compare with:
+
+```scala
+    freezing
+  !boiling
+```
+
+This is seen as two statements, `freezing` and `!boiling`. The difference is that only the operator in the first example
+is followed by a space.
+
+Another example:
+
+```scala
+  println("hello")
+  ???
+  ??? match { case 0 => 1 }
+```
+
+This code is recognized as three different statements. `???` is syntactically a symbolic identifier, but
+neither of its occurrences is followed by a space and a token that can start an expression.
+
+## Unary operators
+
+A unary operator must not have explicit parameter lists even if they are empty.
+A unary operator is a method named "unary_`op`" where `op` is one of `+`, `-`, `!`, or `~`.
diff --git a/docs/_spec/TODOreference/changed-features/overload-resolution.md b/docs/_spec/TODOreference/changed-features/overload-resolution.md
new file mode 100644
index 000000000000..bd7782ded520
--- /dev/null
+++ b/docs/_spec/TODOreference/changed-features/overload-resolution.md
@@ -0,0 +1,102 @@
+---
+layout: doc-page
+title: "Changes in Overload Resolution"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/changed-features/overload-resolution.html
+---
+
+Overload resolution in Scala 3 improves on Scala 2 in three ways.
+First, it takes all argument lists into account instead of
+just the first argument list.
+Second, it can infer parameter types of function values even if they
+are in the first argument list.
+Third, default arguments are no longer relevant for prioritization.
+
+## Looking Beyond the First Argument List
+
+Overloading resolution now can take argument lists into account when
+choosing among a set of overloaded alternatives.
+For example, the following code compiles in Scala 3, while it results in an
+ambiguous overload error in Scala 2:
+
+```scala
+def f(x: Int)(y: String): Int = 0
+def f(x: Int)(y: Int): Int = 0
+
+f(3)("")     // ok
+```
+
+The following code compiles as well:
+
+```scala
+def g(x: Int)(y: Int)(z: Int): Int = 0
+def g(x: Int)(y: Int)(z: String): Int = 0
+
+g(2)(3)(4)     // ok
+g(2)(3)("")    // ok
+```
+
+To make this work, the rules for overloading resolution in [SLS §6.26.3](https://www.scala-lang.org/files/archive/spec/2.13/06-expressions.html#overloading-resolution) are augmented
+as follows:
+
+> In a situation where a function is applied to more than one argument list, if overloading
+resolution yields several competing alternatives when `n >= 1` parameter lists are taken
+into account, then resolution re-tried using `n + 1` argument lists.
+
+This change is motivated by the new language feature
+[extension methods](../contextual/extension-methods.md), where emerges the need to do
+overload resolution based on additional argument blocks.
+
+## Parameter Types of Function Values
+
+The handling of function values with missing parameter types has been improved. We can now
+pass such values in the first argument list of an overloaded application, provided
+that the remaining parameters suffice for picking a variant of the overloaded function.
+For example, the following code compiles in Scala 3, while it results in a
+missing parameter type error in Scala2:
+
+```scala
+def f(x: Int, f2: Int => Int) = f2(x)
+def f(x: String, f2: String => String) = f2(x)
+f("a", _.toUpperCase)
+f(2, _ * 2)
+```
+
+To make this work, the rules for overloading resolution in [SLS §6.26.3](https://www.scala-lang.org/files/archive/spec/2.13/06-expressions.html#overloading-resolution) are modified
+as follows:
+
+Replace the sentence
+
+> Otherwise, let `S1,…,Sm` be the vector of types obtained by typing each argument with an undefined expected type.
+
+with the following paragraph:
+
+> Otherwise, let `S1,…,Sm` be the vector of known types of all argument types, where the _known type_ of an argument `E`
+is determined as followed:
+
+ - If `E` is a function value `(p_1, ..., p_n) => B` that misses some parameter types, the known type
+   of `E` is `(S_1, ..., S_n) => ?`, where each `S_i` is the type of parameter `p_i` if it is given, or `?`
+   otherwise. Here `?` stands for a _wildcard type_ that is compatible with every other type.
+ - Otherwise the known type of `E` is the result of typing `E` with an undefined expected type.
+
+A pattern matching closure
+
+```scala
+{ case P1 => B1 ... case P_n => B_n }
+````
+
+is treated as if it was expanded to the function value
+
+```scala
+x => x match { case P1 => B1 ... case P_n => B_n }
+```
+
+and is therefore also approximated with a `? => ?` type.
+
+## Default Arguments Are No longer Relevant for Prioritization
+
+In Scala 2 if among several applicative alternatives one alternative had default arguments, that alternative was dropped from consideration. This has the unfortunate
+side effect that adding a default to a parameter of a method can render this method
+invisible in overloaded calls.
+
+Scala 3 drops this distinction. Methods with default parameters are not treated
+to have lower priority than other methods.
diff --git a/docs/_spec/TODOreference/changed-features/pattern-bindings.md b/docs/_spec/TODOreference/changed-features/pattern-bindings.md
new file mode 100644
index 000000000000..2de338fc1dde
--- /dev/null
+++ b/docs/_spec/TODOreference/changed-features/pattern-bindings.md
@@ -0,0 +1,59 @@
+---
+layout: doc-page
+title: "Pattern Bindings"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/changed-features/pattern-bindings.html
+---
+
+In Scala 2, pattern bindings in `val` definitions and `for` expressions are
+loosely typed. Potentially failing matches are still accepted at compile-time,
+but may influence the program's runtime behavior.
+From Scala 3.2 on, type checking rules will be tightened so that warnings are reported at compile-time instead.
+
+## Bindings in Pattern Definitions
+
+```scala
+val xs: List[Any] = List(1, 2, 3)
+val (x: String) :: _ = xs   // error: pattern's type String is more specialized
+                            // than the right-hand side expression's type Any
+```
+This code gives a compile-time warning in Scala 3.2 (and also earlier Scala 3.x under the `-source future` setting) whereas it will fail at runtime with a `ClassCastException` in Scala 2. In Scala 3.2, a pattern binding is only allowed if the pattern is _irrefutable_, that is, if the right-hand side's type conforms to the pattern's type. For instance, the following is OK:
+```scala
+val pair = (1, true)
+val (x, y) = pair
+```
+Sometimes one wants to decompose data anyway, even though the pattern is refutable. For instance, if at some point one knows that a list `elems` is non-empty one might want to decompose it like this:
+```scala
+val first :: rest = elems   // error
+```
+This works in Scala 2. In fact it is a typical use case for Scala 2's rules. But in Scala 3.2 it will give a warning. One can avoid the warning by marking the right-hand side with an [`@unchecked`](https://scala-lang.org/api/3.x/scala/unchecked.html) annotation:
+```scala
+val first :: rest = elems: @unchecked   // OK
+```
+This will make the compiler accept the pattern binding. It might give an error at runtime instead, if the underlying assumption that `elems` can never be empty is wrong.
+
+## Pattern Bindings in `for` Expressions
+
+Analogous changes apply to patterns in `for` expressions. For instance:
+
+```scala
+val elems: List[Any] = List((1, 2), "hello", (3, 4))
+for (x, y) <- elems yield (y, x) // error: pattern's type (Any, Any) is more specialized
+                                 // than the right-hand side expression's type Any
+```
+This code gives a compile-time warning in Scala 3.2 whereas in Scala 2 the list `elems`
+is filtered to retain only the elements of tuple type that match the pattern `(x, y)`.
+The filtering functionality can be obtained in Scala 3 by prefixing the pattern with `case`:
+```scala
+for case (x, y) <- elems yield (y, x)  // returns List((2, 1), (4, 3))
+```
+
+## Syntax Changes
+
+Generators in for expressions may be prefixed with `case`.
+```
+Generator      ::=  [‘case’] Pattern1 ‘<-’ Expr
+```
+
+## Migration
+
+The new syntax is supported in Scala 3.0. However, to enable smooth cross compilation between Scala 2 and Scala 3, the changed behavior and additional type checks are only enabled under the `-source future` setting. They will be enabled by default in version 3.2 of the language.
diff --git a/docs/_spec/TODOreference/changed-features/pattern-matching.md b/docs/_spec/TODOreference/changed-features/pattern-matching.md
new file mode 100644
index 000000000000..30ae5d9dc104
--- /dev/null
+++ b/docs/_spec/TODOreference/changed-features/pattern-matching.md
@@ -0,0 +1,243 @@
+---
+layout: doc-page
+title: "Option-less pattern matching"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/changed-features/pattern-matching.html
+---
+
+The implementation of pattern matching in Scala 3 was greatly simplified compared to Scala 2. From a user perspective, this means that Scala 3 generated patterns are a _lot_ easier to debug, as variables all show up in debug modes and positions are correctly preserved.
+
+Scala 3 supports a superset of Scala 2 [extractors](https://www.scala-lang.org/files/archive/spec/2.13/08-pattern-matching.html#extractor-patterns).
+
+## Extractors
+
+Extractors are objects that expose a method `unapply` or `unapplySeq`:
+
+```scala
+def unapply[A](x: T)(implicit x: B): U
+def unapplySeq[A](x: T)(implicit x: B): U
+```
+
+Extractors that expose the method `unapply` are called fixed-arity extractors, which
+work with patterns of fixed arity. Extractors that expose the method `unapplySeq` are
+called variadic extractors, which enables variadic patterns.
+
+### Fixed-Arity Extractors
+
+Fixed-arity extractors expose the following signature:
+
+```scala
+def unapply[A](x: T)(implicit x: B): U
+```
+
+The type `U` conforms to one of the following matches:
+
+- Boolean match
+- Product match
+
+Or `U` conforms to the type `R`:
+
+```scala
+type R = {
+  def isEmpty: Boolean
+  def get: S
+}
+```
+
+and `S` conforms to one of the following matches:
+
+- single match
+- name-based match
+
+The former form of `unapply` has higher precedence, and _single match_ has higher
+precedence over _name-based match_.
+
+A usage of a fixed-arity extractor is irrefutable if one of the following condition holds:
+
+- `U = true`
+- the extractor is used as a product match
+- `U = Some[T]` (for Scala 2 compatibility)
+- `U <: R` and `U <: { def isEmpty: false }`
+
+### Variadic Extractors
+
+Variadic extractors expose the following signature:
+
+```scala
+def unapplySeq[A](x: T)(implicit x: B): U
+```
+
+The type `U` conforms to one of the following matches:
+
+- sequence match
+- product-sequence match
+
+Or `U` conforms to the type `R`:
+
+```scala
+type R = {
+  def isEmpty: Boolean
+  def get: S
+}
+```
+
+and `S` conforms to one of the two matches above.
+
+The former form of `unapplySeq` has higher priority, and _sequence match_ has higher
+precedence over _product-sequence match_.
+
+A usage of a variadic extractor is irrefutable if one of the following conditions holds:
+
+- the extractor is used directly as a sequence match or product-sequence match
+- `U = Some[T]` (for Scala 2 compatibility)
+- `U <: R` and `U <: { def isEmpty: false }`
+
+## Boolean Match
+
+- `U =:= Boolean`
+- Pattern-matching on exactly `0` patterns
+
+For example:
+
+<!-- To be kept in sync with tests/new/patmat-spec.scala -->
+
+```scala
+object Even:
+  def unapply(s: String): Boolean = s.size % 2 == 0
+
+"even" match
+  case s @ Even() => println(s"$s has an even number of characters")
+  case s          => println(s"$s has an odd number of characters")
+
+// even has an even number of characters
+```
+
+## Product Match
+
+- `U <: Product`
+- `N > 0` is the maximum number of consecutive (parameterless `def` or `val`) `_1: P1` ... `_N: PN` members in `U`
+- Pattern-matching on exactly `N` patterns with types `P1, P2, ..., PN`
+
+For example:
+
+<!-- To be kept in sync with tests/new/patmat-spec.scala -->
+
+```scala
+class FirstChars(s: String) extends Product:
+  def _1 = s.charAt(0)
+  def _2 = s.charAt(1)
+
+   // Not used by pattern matching: Product is only used as a marker trait.
+  def canEqual(that: Any): Boolean = ???
+  def productArity: Int = ???
+  def productElement(n: Int): Any = ???
+
+object FirstChars:
+  def unapply(s: String): FirstChars = new FirstChars(s)
+
+"Hi!" match
+  case FirstChars(char1, char2) =>
+    println(s"First: $char1; Second: $char2")
+
+// First: H; Second: i
+```
+
+## Single Match
+
+- If there is exactly `1` pattern, pattern-matching on `1` pattern with type `U`
+
+<!-- To be kept in sync with tests/new/patmat-spec.scala -->
+
+```scala
+class Nat(val x: Int):
+  def get: Int = x
+  def isEmpty = x < 0
+
+object Nat:
+  def unapply(x: Int): Nat = new Nat(x)
+
+5 match
+  case Nat(n) => println(s"$n is a natural number")
+  case _      => ()
+
+// 5 is a natural number
+```
+
+## Name-based Match
+
+- `N > 1` is the maximum number of consecutive (parameterless `def` or `val`) `_1: P1 ... _N: PN` members in `U`
+- Pattern-matching on exactly `N` patterns with types `P1, P2, ..., PN`
+
+```scala
+object ProdEmpty:
+  def _1: Int = ???
+  def _2: String = ???
+  def isEmpty = true
+  def unapply(s: String): this.type = this
+  def get = this
+
+"" match
+  case ProdEmpty(_, _) => ???
+  case _ => ()
+```
+
+## Sequence Match
+
+- `U <: X`, `T2` and `T3` conform to `T1`
+
+```scala
+type X = {
+  def lengthCompare(len: Int): Int // or, `def length: Int`
+  def apply(i: Int): T1
+  def drop(n: Int): scala.Seq[T2]
+  def toSeq: scala.Seq[T3]
+}
+```
+
+- Pattern-matching on _exactly_ `N` simple patterns with types `T1, T1, ..., T1`, where `N` is the runtime size of the sequence, or
+- Pattern-matching on `>= N` simple patterns and _a vararg pattern_ (e.g., `xs: _*`) with types `T1, T1, ..., T1, Seq[T1]`, where `N` is the minimum size of the sequence.
+
+<!-- To be kept in sync with tests/new/patmat-spec.scala -->
+
+```scala
+object CharList:
+  def unapplySeq(s: String): Option[Seq[Char]] = Some(s.toList)
+
+"example" match
+  case CharList(c1, c2, c3, c4, _, _, _) =>
+    println(s"$c1,$c2,$c3,$c4")
+  case _ =>
+    println("Expected *exactly* 7 characters!")
+
+// e,x,a,m
+```
+
+## Product-Sequence Match
+
+- `U <: Product`
+- `N > 0` is the maximum number of consecutive (parameterless `def` or `val`) `_1: P1` ... `_N: PN` members in `U`
+- `PN` conforms to the signature `X` defined in Seq Pattern
+- Pattern-matching on exactly `>= N` patterns, the first `N - 1` patterns have types `P1, P2, ... P(N-1)`,
+  the type of the remaining patterns are determined as in Seq Pattern.
+
+```scala
+class Foo(val name: String, val children: Int*)
+object Foo:
+  def unapplySeq(f: Foo): Option[(String, Seq[Int])] =
+    Some((f.name, f.children))
+
+def foo(f: Foo) = f match
+  case Foo(name, x, y, ns*) => ">= two children."
+  case Foo(name, ns*) =>    => "< two children."
+```
+
+There are plans for further simplification, in particular to factor out _product match_
+and _name-based match_ into a single type of extractor.
+
+## Type testing
+
+Abstract type testing with `ClassTag` is replaced with `TypeTest` or the alias `Typeable`.
+
+- pattern `_: X` for an abstract type requires a `TypeTest` in scope
+- pattern `x @ X()` for an unapply that takes an abstract type requires a `TypeTest` in scope
+
+[More details on `TypeTest`](../other-new-features/type-test.md)
diff --git a/docs/_spec/TODOreference/changed-features/structural-types-spec.md b/docs/_spec/TODOreference/changed-features/structural-types-spec.md
new file mode 100644
index 000000000000..d456932649fb
--- /dev/null
+++ b/docs/_spec/TODOreference/changed-features/structural-types-spec.md
@@ -0,0 +1,153 @@
+---
+layout: doc-page
+title: "Programmatic Structural Types - More Details"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/changed-features/structural-types-spec.html
+---
+
+## Syntax
+
+```
+SimpleType    ::= ... | Refinement
+Refinement    ::= ‘{’ RefineStatSeq ‘}’
+RefineStatSeq ::=  RefineStat {semi RefineStat}
+RefineStat    ::= ‘val’ VarDcl | ‘def’ DefDcl | ‘type’ {nl} TypeDcl
+```
+
+## Implementation of Structural Types
+
+The standard library defines a universal marker trait
+[`scala.Selectable`](https://github.com/lampepfl/dotty/blob/main/library/src/scala/Selectable.scala):
+
+```scala
+trait Selectable extends Any
+```
+
+An implementation of `Selectable` that relies on [Java reflection](https://www.oracle.com/technical-resources/articles/java/javareflection.html) is
+available in the standard library: `scala.reflect.Selectable`. Other
+implementations can be envisioned for platforms where Java reflection
+is not available.
+
+Implementations of `Selectable` have to make available one or both of
+the methods `selectDynamic` and `applyDynamic`. The methods could be members of the `Selectable` implementation or they could be extension methods.
+
+The `selectDynamic` method takes a field name and returns the value associated with that name in the `Selectable`.
+It should have a signature of the form:
+
+```scala
+def selectDynamic(name: String): T
+```
+
+Often, the return type `T` is `Any`.
+
+Unlike `scala.Dynamic`, there is no special meaning for an `updateDynamic` method.
+However, we reserve the right to give it meaning in the future.
+Consequently, it is recommended not to define any member called `updateDynamic` in `Selectable`s.
+
+The `applyDynamic` method is used for selections that are applied to arguments. It takes a method name and possibly `Class`es representing its parameters types as well as the arguments to pass to the function.
+Its signature should be of one of the two following forms:
+
+```scala
+def applyDynamic(name: String)(args: Any*): T
+def applyDynamic(name: String, ctags: Class[?]*)(args: Any*): T
+```
+
+Both versions are passed the actual arguments in the `args` parameter. The second version takes in addition a vararg argument of `java.lang.Class`es that identify the method's parameter classes. Such an argument is needed
+if `applyDynamic` is implemented using Java reflection, but it could be
+useful in other cases as well. `selectDynamic` and `applyDynamic` can also take additional context parameters in using clauses. These are resolved in the normal way at the callsite.
+
+Given a value `v` of type `C { Rs }`, where `C` is a class reference
+and `Rs` are structural refinement declarations, and given `v.a` of type `U`, we consider three distinct cases:
+
+- If `U` is a value type, we map `v.a` to:
+  ```scala
+  v.selectDynamic("a").asInstanceOf[U]
+  ```
+
+- If `U` is a method type `(T11, ..., T1n)...(TN1, ..., TNn): R` and it is not a dependent method type, we map `v.a(a11, ..., a1n)...(aN1, ..., aNn)` to:
+  ```scala
+  v.applyDynamic("a")(a11, ..., a1n, ..., aN1, ..., aNn)
+    .asInstanceOf[R]
+  ```
+  If this call resolves to an `applyDynamic` method of the second form that takes a `Class[?]*` argument, we further rewrite this call to
+  ```scala
+  v.applyDynamic("a", c11, ..., c1n, ..., cN1, ... cNn)(
+    a11, ..., a1n, ..., aN1, ..., aNn)
+    .asInstanceOf[R]
+  ```
+   where each `c_ij` is the literal `java.lang.Class[?]` of the type of the formal parameter `Tij`, i.e., `classOf[Tij]`.
+
+- If `U` is neither a value nor a method type, or a dependent method
+  type, an error is emitted.
+
+Note that `v`'s static type does not necessarily have to conform to `Selectable`, nor does it need to have `selectDynamic` and `applyDynamic` as members. It suffices that there is an implicit
+conversion that can turn `v` into a `Selectable`, and the selection methods could also be available as
+[extension methods](../contextual/extension-methods.md).
+
+## Limitations of Structural Types
+
+- Dependent methods cannot be called via structural call.
+
+- Refinements may not introduce overloads: If a refinement specifies the signature
+  of a method `m`, and `m` is also defined in the parent type of the refinement, then
+  the new signature must properly override the existing one.
+
+- Subtyping of structural refinements must preserve erased parameter types: Assume
+  we want to prove `S <: T { def m(x: A): B }`. Then, as usual, `S` must have a member method `m` that can take an argument of type `A`. Furthermore, if `m` is not a member of `T` (i.e. the refinement is structural), an additional condition applies. In this case, the member _definition_ `m` of `S` will have a parameter
+  with type `A'` say. The additional condition is that the erasure of `A'` and `A` is the same. Here is an example:
+
+  ```scala
+  class Sink[A] { def put(x: A): Unit = {} }
+  val a = Sink[String]()
+  val b: { def put(x: String): Unit } = a  // error
+  b.put("abc") // looks for a method with a `String` parameter
+  ```
+  The second to last line is not well-typed,
+  since the erasure of the parameter type of `put` in class `Sink` is `Object`,
+  but the erasure of `put`'s parameter in the type of `b` is `String`.
+  This additional condition is necessary, since we will have to resort
+  to some (as yet unknown) form of reflection to call a structural member
+  like `put` in the type of `b` above. The condition ensures that the statically
+  known parameter types of the refinement correspond up to erasure to the
+  parameter types of the selected call target at runtime.
+
+  Most reflection dispatch algorithms need to know exact erased parameter types. For instance, if the example above would typecheck, the call
+  `b.put("abc")` on the last line would look for a method `put` in the runtime type of `b` that takes a `String` parameter. But the `put` method is the one from class `Sink`, which takes an `Object` parameter. Hence the call would fail at runtime with a `NoSuchMethodException`.
+
+  One might hope for a "more intelligent" reflexive dispatch algorithm that does not require exact parameter type matching. Unfortunately, this can always run into ambiguities, as long as overloading is a possibility. For instance, continuing the example above, we might introduce a new subclass `Sink1` of `Sink` and change the definition of `a` as follows:
+
+  ```scala
+  class Sink1[A] extends Sink[A] { def put(x: "123") = ??? }
+  val a: Sink[String] = Sink1[String]()
+  ```
+
+  Now there are two `put` methods in the runtime type of `b` with erased parameter
+  types `Object` and `String`, respectively. Yet dynamic dispatch still needs to go
+  to the first `put` method, even though the second looks like a better match.
+
+  For the cases where we can in fact implement reflection without knowing precise parameter types (for instance if static overloading is replaced by dynamically dispatched multi-methods), there is an escape hatch. For types that extend `scala.Selectable.WithoutPreciseParameterTypes` the signature check is omitted. Example:
+
+  ```scala
+  trait MultiMethodSelectable extends Selectable.WithoutPreciseParameterTypes:
+    // Assume this version of `applyDynamic` can be implemented without knowing
+    // precise parameter types `paramTypes`:
+    def applyDynamic(name: String, paramTypes: Class[_]*)(args: Any*): Any = ???
+
+  class Sink[A] extends MultiMethodSelectable:
+    def put(x: A): Unit = {}
+
+  val a = new Sink[String]
+  val b: MultiMethodSelectable { def put(x: String): Unit } = a  // OK
+  ```
+## Differences with Scala 2 Structural Types
+
+- Scala 2 supports structural types by means of Java reflection. Unlike
+  Scala 3, structural calls do not rely on a mechanism such as
+  `Selectable`, and reflection cannot be avoided.
+- In Scala 2, refinements can introduce overloads.
+- In Scala 2, mutable `var`s are allowed in refinements. In Scala 3,
+  they are no longer allowed.
+- Scala 2 does not impose the "same-erasure" restriction on subtyping of structural types. It allows some calls to fail at runtime instead.
+
+## Context
+
+For more information, see [Rethink Structural Types](https://github.com/lampepfl/dotty/issues/1886).
diff --git a/docs/_spec/TODOreference/changed-features/structural-types.md b/docs/_spec/TODOreference/changed-features/structural-types.md
new file mode 100644
index 000000000000..37e583332cf1
--- /dev/null
+++ b/docs/_spec/TODOreference/changed-features/structural-types.md
@@ -0,0 +1,191 @@
+---
+layout: doc-page
+title: "Programmatic Structural Types"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/changed-features/structural-types.html
+---
+
+## Motivation
+
+Some usecases, such as modelling database access, are more awkward in
+statically typed languages than in dynamically typed languages: With
+dynamically typed languages, it's quite natural to model a row as a
+record or object, and to select entries with simple dot notation (e.g.
+`row.columnName`).
+
+Achieving the same experience in statically typed
+language requires defining a class for every possible row arising from
+database manipulation (including rows arising from joins and
+projections) and setting up a scheme to map between a row and the
+class representing it.
+
+This requires a large amount of boilerplate, which leads developers to
+trade the advantages of static typing for simpler schemes where colum
+names are represented as strings and passed to other operators (e.g.
+`row.select("columnName")`). This approach forgoes the advantages of
+static typing, and is still not as natural as the dynamically typed
+version.
+
+Structural types help in situations where we would like to support
+simple dot notation in dynamic contexts without losing the advantages
+of static typing. They allow developers to use dot notation and
+configure how fields and methods should be resolved.
+
+## Example
+
+Here's an example of a structural type `Person`:
+
+```scala
+  class Record(elems: (String, Any)*) extends Selectable:
+    private val fields = elems.toMap
+    def selectDynamic(name: String): Any = fields(name)
+
+  type Person = Record { val name: String; val age: Int }
+ ```
+
+The type `Person` adds a _refinement_ to its parent type `Record` that defines the two fields `name` and `age`. We say the refinement is _structural_ since  `name` and `age` are not defined in the parent type. But they exist nevertheless as members of class `Person`. For instance, the following
+program would print  "Emma is 42 years old.":
+
+```scala
+  val person = Record("name" -> "Emma", "age" -> 42).asInstanceOf[Person]
+  println(s"${person.name} is ${person.age} years old.")
+```
+
+The parent type `Record` in this example is a generic class that can represent arbitrary records in its `elems` argument. This argument is a
+sequence of pairs of labels of type `String` and values of type `Any`.
+When we create a `Person` as a `Record` we have to assert with a typecast
+that the record defines the right fields of the right types. `Record`
+itself is too weakly typed so the compiler cannot know this without
+help from the user. In practice, the connection between a structural type
+and its underlying generic representation would most likely be done by
+a database layer, and therefore would not be a concern of the end user.
+
+`Record` extends the marker trait [`scala.Selectable`](https://scala-lang.org/api/3.x/scala/Selectable.html) and defines
+a method `selectDynamic`, which maps a field name to its value.
+Selecting a structural type member is done by calling this method.
+The `person.name` and `person.age` selections are translated by
+the Scala compiler to:
+
+```scala
+  person.selectDynamic("name").asInstanceOf[String]
+  person.selectDynamic("age").asInstanceOf[Int]
+```
+
+Besides `selectDynamic`, a `Selectable` class sometimes also defines a method `applyDynamic`. This can then be used to translate function calls of structural members. So, if `a` is an instance of `Selectable`, a structural call like `a.f(b, c)` would translate to
+
+```scala
+  a.applyDynamic("f")(b, c)
+```
+
+## Using Java Reflection
+
+Structural types can also be accessed using [Java reflection](https://www.oracle.com/technical-resources/articles/java/javareflection.html). Example:
+
+```scala
+  type Closeable = { def close(): Unit }
+
+  class FileInputStream:
+    def close(): Unit
+
+  class Channel:
+    def close(): Unit
+```
+
+Here, we define a structural type `Closeable` that defines a `close` method. There are various classes that have `close` methods, we just list [`FileInputStream`](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/FileInputStream.html#%3Cinit%3E(java.io.File)) and [`Channel`](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/nio/channels/Channel.html) as two examples. It would be easiest if the two classes shared a common interface that factors out the `close` method. But such factorings are often not possible if different libraries are combined in one application. Yet, we can still have methods that work on
+all classes with a `close` method by using the `Closeable` type. For instance,
+
+```scala
+  import scala.reflect.Selectable.reflectiveSelectable
+
+  def autoClose(f: Closeable)(op: Closeable => Unit): Unit =
+    try op(f) finally f.close()
+```
+
+The call `f.close()` has to use Java reflection to identify and call the `close` method in the receiver `f`. This needs to be enabled by an import
+of `reflectiveSelectable` shown above. What happens "under the hood" is then the following:
+
+ - The import makes available an implicit conversion that turns any type into a
+   `Selectable`. `f` is wrapped in this conversion.
+
+ - The compiler then transforms the `close` call on the wrapped `f`
+   to an `applyDynamic` call. The end result is:
+
+   ```scala
+     reflectiveSelectable(f).applyDynamic("close")()
+   ```
+ - The implementation of `applyDynamic` in `reflectiveSelectable`'s result
+uses Java reflection to find and call a method `close` with zero parameters in the value referenced by `f` at runtime.
+
+Structural calls like this tend to be much slower than normal method calls. The mandatory import of `reflectiveSelectable` serves as a signpost that something inefficient is going on.
+
+**Note:** In Scala 2, Java reflection is the only mechanism available for structural types and it is automatically enabled without needing the
+`reflectiveSelectable` conversion. However, to warn against inefficient
+dispatch, Scala 2 requires a language import `import scala.language.reflectiveCalls`.
+
+Before resorting to structural calls with Java reflection one should consider alternatives. For instance, sometimes a more modular _and_ efficient architecture can be obtained using type classes.
+
+## Extensibility
+
+New instances of `Selectable` can be defined to support means of
+access other than Java reflection, which would enable usages such as
+the database access example given at the beginning of this document.
+
+## Local Selectable Instances
+
+Local and anonymous classes that extend `Selectable` get more refined types
+than other classes. Here is an example:
+
+```scala
+trait Vehicle extends reflect.Selectable:
+  val wheels: Int
+
+val i3 = new Vehicle: // i3: Vehicle { val range: Int }
+  val wheels = 4
+  val range = 240
+
+i3.range
+```
+
+The type of `i3` in this example is `Vehicle { val range: Int }`. Hence,
+`i3.range` is well-formed. Since the base class `Vehicle` does not define a `range` field or method, we need structural dispatch to access the `range` field of the anonymous class that initializes `id3`. Structural dispatch
+is implemented by the base trait [`reflect.Selectable`](https://scala-lang.org/api/3.x/scala/reflect/Selectable.html) of `Vehicle`, which defines the necessary `selectDynamic` member.
+
+`Vehicle` could also extend some other subclass of [`scala.Selectable`](https://scala-lang.org/api/3.x/scala/Selectable.html) that implements `selectDynamic` and `applyDynamic` differently. But if it does not extend a `Selectable` at all, the code would no longer typecheck:
+
+```scala
+trait Vehicle:
+  val wheels: Int
+
+val i3 = new Vehicle: // i3: Vehicle
+  val wheels = 4
+  val range = 240
+
+i3.range // error: range is not a member of `Vehicle`
+```
+
+The difference is that the type of an anonymous class that does not extend `Selectable` is just formed from the parent type(s) of the class, without
+adding any refinements. Hence, `i3` now has just type `Vehicle` and the selection `i3.range` gives a "member not found" error.
+
+Note that in Scala 2 all local and anonymous classes could produce values with refined types. But
+members defined by such refinements could be selected only with the language import
+[`reflectiveCalls`](https://scala-lang.org/api/3.x/scala/languageFeature$$reflectiveCalls$.html).
+
+## Relation with `scala.Dynamic`
+
+There are clearly some connections with [`scala.Dynamic`](https://scala-lang.org/api/3.x/scala/Dynamic.html) here, since
+both select members programmatically. But there are also some
+differences.
+
+- Fully dynamic selection is not typesafe, but structural selection
+  is, as long as the correspondence of the structural type with the
+  underlying value is as stated.
+
+- [`Dynamic`](https://scala-lang.org/api/3.x/scala/Dynamic.html) is just a marker trait, which gives more leeway where and
+  how to define reflective access operations. By contrast
+  `Selectable` is a trait which declares the access operations.
+
+- Two access operations, `selectDynamic` and `applyDynamic` are shared
+  between both approaches. In `Selectable`, `applyDynamic` also may also take
+  [`java.lang.Class`](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Class.html) arguments indicating the method's formal parameter types.
+  [`Dynamic`](https://scala-lang.org/api/3.x/scala/Dynamic.html) comes with `updateDynamic`.
+
+[More details](structural-types-spec.md)
diff --git a/docs/_spec/TODOreference/changed-features/type-checking.md b/docs/_spec/TODOreference/changed-features/type-checking.md
new file mode 100644
index 000000000000..6f59b1a1c1c6
--- /dev/null
+++ b/docs/_spec/TODOreference/changed-features/type-checking.md
@@ -0,0 +1,7 @@
+---
+layout: doc-page
+title: "Changes in Type Checking"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/changed-features/type-checking.html
+---
+
+*** **TO BE FILLED IN** ***
diff --git a/docs/_spec/TODOreference/changed-features/type-inference.md b/docs/_spec/TODOreference/changed-features/type-inference.md
new file mode 100644
index 000000000000..00d0e959f5ed
--- /dev/null
+++ b/docs/_spec/TODOreference/changed-features/type-inference.md
@@ -0,0 +1,10 @@
+---
+layout: doc-page
+title: "Changes in Type Inference"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/changed-features/type-inference.html
+---
+
+For more information, see the two presentations
+
+* [Scala 3, Type inference and You!](https://www.youtube.com/watch?v=lMvOykNQ4zs) by Guillaume Martres (September 2019)
+* [GADTs in Dotty](https://www.youtube.com/watch?v=VV9lPg3fNl8) by Aleksander Boruch-Gruszecki (July 2019).
diff --git a/docs/_spec/TODOreference/changed-features/vararg-splices.md b/docs/_spec/TODOreference/changed-features/vararg-splices.md
new file mode 100644
index 000000000000..43c4acc5f880
--- /dev/null
+++ b/docs/_spec/TODOreference/changed-features/vararg-splices.md
@@ -0,0 +1,40 @@
+---
+layout: doc-page
+title: "Vararg Splices"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/changed-features/vararg-splices.html
+---
+
+The syntax of vararg splices in patterns and function arguments has changed. The new syntax uses a postfix `*`,  analogously to how a vararg parameter is declared.
+
+```scala
+val arr = Array(0, 1, 2, 3)
+val lst = List(arr*)                   // vararg splice argument
+lst match
+  case List(0, 1, xs*) => println(xs)  // binds xs to Seq(2, 3)
+  case List(1, _*) =>                  // wildcard pattern
+```
+
+The old syntax for splice arguments will be phased out.
+
+```scala
+/*!*/ val lst = List(arr: _*)      // syntax error
+      lst match
+        case List(0, 1, xs @ _*)  // ok, equivalent to `xs*`
+```
+
+## Syntax
+
+```
+ArgumentPatterns  ::=  ‘(’ [Patterns] ‘)’
+                    |  ‘(’ [Patterns ‘,’] Pattern2 ‘*’ ‘)’
+
+ParArgumentExprs  ::=  ‘(’ [‘using’] ExprsInParens ‘)’
+                    |  ‘(’ [ExprsInParens ‘,’] PostfixExpr ‘*’ ‘)’
+```
+
+## Compatibility considerations
+
+To enable cross compilation between Scala 2 and Scala 3, the compiler will
+accept both the old and the new syntax. Under the `-source future` setting, an error
+will be emitted when the old syntax is encountered. An automatic rewrite from old
+to new syntax is offered under `-source future-migration`.
diff --git a/docs/_spec/TODOreference/changed-features/wildcards.md b/docs/_spec/TODOreference/changed-features/wildcards.md
new file mode 100644
index 000000000000..0d3e13c3d7e0
--- /dev/null
+++ b/docs/_spec/TODOreference/changed-features/wildcards.md
@@ -0,0 +1,50 @@
+---
+layout: doc-page
+title: Wildcard Arguments in Types
+nightlyOf: https://docs.scala-lang.org/scala3/reference/changed-features/wildcards.html
+---
+
+The syntax of wildcard arguments in types has changed from `_` to `?`. Example:
+```scala
+List[?]
+Map[? <: AnyRef, ? >: Null]
+```
+
+## Motivation
+
+We would like to use the underscore syntax `_` to stand for an anonymous type parameter, aligning it with its meaning in
+value parameter lists. So, just as `f(_)` is a shorthand for the lambda `x => f(x)`, in the future `C[_]` will be a shorthand
+for the type lambda `[X] =>> C[X]`. This makes higher-kinded types easier to use. It also removes the wart that, used as a type
+parameter, `F[_]` means `F` is a type constructor whereas used as a type, `F[_]` means it is a wildcard (i.e. existential) type.
+In the future, `F[_]` will mean the same thing, no matter where it is used.
+
+We pick `?` as a replacement syntax for wildcard types, since it aligns with
+[Java's syntax](https://docs.oracle.com/javase/tutorial/java/generics/wildcardGuidelines.html).
+
+## Migration Strategy
+
+The migration to the new scheme is complicated, in particular since the [kind projector](https://github.com/typelevel/kind-projector)
+compiler plugin still uses the reverse convention, with `?` meaning parameter placeholder instead of wildcard. Fortunately, kind projector has added `*` as an alternative syntax for `?`.
+
+A step-by-step migration is made possible with the following measures:
+
+ 1. In Scala 3.0, both `_` and `?` are legal names for wildcards.
+ 2. In Scala 3.1, `_` is deprecated in favor of `?` as a name for a wildcard. A `-rewrite` option is
+    available to rewrite one to the other.
+ 3. In Scala 3.2, the meaning of `_` changes from wildcard to placeholder for type parameter.
+ 4. The Scala 3.1 behavior is already available today under the `-source future` setting.
+
+To smooth the transition for codebases that use kind-projector, we adopt the following measures under the command line
+option `-Ykind-projector`:
+
+ 1. In Scala 3.0, `*` is available as a type parameter placeholder.
+ 2. In Scala 3.2, `*` is deprecated in favor of `_`. A `-rewrite` option is
+    available to rewrite one to the other.
+ 3. In Scala 3.3, `*` is removed again, and all type parameter placeholders will be expressed with `_`.
+
+These rules make it possible to cross build between Scala 2 using the kind projector plugin and Scala 3.0 - 3.2 using the compiler option `-Ykind-projector`.
+
+There is also a migration path for users that want a one-time transition to syntax with `_` as a type parameter placeholder.
+With option `-Ykind-projector:underscores` Scala 3 will regard `_` as a type parameter placeholder, leaving `?` as the only syntax for wildcards.
+
+To cross-compile with old Scala 2 sources, while using `_` a placeholder, you must use options `-Xsource:3 -P:kind-projector:underscore-placeholders` together with a recent version of kind-projector (`0.13` and higher) and most recent versions of Scala 2 (`2.13.5` and higher and `2.12.14` and higher)
diff --git a/docs/_spec/TODOreference/contextual/by-name-context-parameters.md b/docs/_spec/TODOreference/contextual/by-name-context-parameters.md
new file mode 100644
index 000000000000..3004bfb2c4c2
--- /dev/null
+++ b/docs/_spec/TODOreference/contextual/by-name-context-parameters.md
@@ -0,0 +1,65 @@
+---
+layout: doc-page
+title: "By-Name Context Parameters"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/contextual/by-name-context-parameters.html
+---
+
+Context parameters can be declared by-name to avoid a divergent inferred expansion. Example:
+
+```scala
+trait Codec[T]:
+  def write(x: T): Unit
+
+given intCodec: Codec[Int] = ???
+
+given optionCodec[T](using ev: => Codec[T]): Codec[Option[T]] with
+  def write(xo: Option[T]) = xo match
+    case Some(x) => ev.write(x)
+    case None =>
+
+val s = summon[Codec[Option[Int]]]
+
+s.write(Some(33))
+s.write(None)
+```
+As is the case for a normal by-name parameter, the argument for the context parameter `ev`
+is evaluated on demand. In the example above, if the option value `x` is `None`, it is
+not evaluated at all.
+
+The synthesized argument for a context parameter is backed by a local val
+if this is necessary to prevent an otherwise diverging expansion.
+
+The precise steps for synthesizing an argument for a by-name context parameter of type `=> T` are as follows.
+
+ 1. Create a new given of type `T`:
+
+    ```scala
+    given lv: T = ???
+    ```
+
+    where `lv` is an arbitrary fresh name.
+
+ 1. This given is not immediately available as candidate for argument inference (making it immediately available could result in a loop in the synthesized computation). But it becomes available in all nested contexts that look again for an argument to a by-name context parameter.
+
+ 1. If this search succeeds with expression `E`, and `E` contains references to `lv`, replace `E` by
+
+    ```scala
+    { given lv: T = E; lv }
+    ```
+
+    Otherwise, return `E` unchanged.
+
+In the example above, the definition of `s` would be expanded as follows.
+
+```scala
+val s = summon[Test.Codec[Option[Int]]](
+  optionCodec[Int](using intCodec)
+)
+```
+
+No local given instance was generated because the synthesized argument is not recursive.
+
+## Reference
+
+For more information, see [Issue #1998](https://github.com/lampepfl/dotty/issues/1998)
+and the associated [Scala SIP](https://docs.scala-lang.org/sips/byname-implicits.html).
diff --git a/docs/_spec/TODOreference/contextual/context-bounds.md b/docs/_spec/TODOreference/contextual/context-bounds.md
new file mode 100644
index 000000000000..42479d6802b3
--- /dev/null
+++ b/docs/_spec/TODOreference/contextual/context-bounds.md
@@ -0,0 +1,53 @@
+---
+layout: doc-page
+title: "Context Bounds"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/contextual/context-bounds.html
+---
+
+A context bound is a shorthand for expressing the common pattern of a context parameter that depends on a type parameter. Using a context bound, the `maximum` function of the last section can be written like this:
+
+```scala
+def maximum[T: Ord](xs: List[T]): T = xs.reduceLeft(max)
+```
+
+A bound like `: Ord` on a type parameter `T` of a method or class indicates a context parameter `using Ord[T]`. The context parameter(s) generated from context bounds
+are added as follows:
+
+ - If the method parameters end in an implicit parameter list or using clause,
+   context parameters are added in front of that list.
+ - Otherwise they are added as a separate parameter clause at the end.
+
+Example:
+
+```scala
+def f[T: C1 : C2, U: C3](x: T)(using y: U, z: V): R
+```
+
+would expand to
+
+```scala
+def f[T, U](x: T)(using _: C1[T], _: C2[T], _: C3[U], y: U, z: V): R
+```
+
+Context bounds can be combined with subtype bounds. If both are present, subtype bounds come first, e.g.
+
+```scala
+def g[T <: B : C](x: T): R = ...
+```
+
+## Migration
+
+To ease migration, context bounds in Dotty map in Scala 3.0 to old-style implicit parameters
+for which arguments can be passed either with a `(using ...)` clause or with a normal application. From Scala 3.1 on, they will map to context parameters instead, as is described above.
+
+If the source version is `future-migration`, any pairing of an evidence
+context parameter stemming from a context bound with a normal argument will give a migration
+warning. The warning indicates that a `(using ...)` clause is needed instead. The rewrite can be
+done automatically under `-rewrite`.
+
+## Syntax
+
+```
+TypeParamBounds   ::=  [SubtypeBounds] {ContextBound}
+ContextBound      ::=  ‘:’ Type
+```
diff --git a/docs/_spec/TODOreference/contextual/context-functions-spec.md b/docs/_spec/TODOreference/contextual/context-functions-spec.md
new file mode 100644
index 000000000000..109513e9da86
--- /dev/null
+++ b/docs/_spec/TODOreference/contextual/context-functions-spec.md
@@ -0,0 +1,79 @@
+---
+layout: doc-page
+title: "Context Functions - More Details"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/contextual/context-functions-spec.html
+---
+
+## Syntax
+
+```
+Type              ::=  ...
+                    |  FunArgTypes ‘?=>’ Type
+Expr              ::=  ...
+                    |  FunParams ‘?=>’ Expr
+```
+
+Context function types associate to the right, e.g.
+`S ?=> T ?=> U` is the same as `S ?=> (T ?=> U)`.
+
+## Implementation
+
+Context function types are shorthands for class types that define `apply`
+methods with context parameters. Specifically, the `N`-ary function type
+
+`T1, ..., TN ?=> R` is a shorthand for the class type
+`ContextFunctionN[T1, ..., TN, R]`. Such class types are assumed to have the following definitions, for any value of `N >= 1`:
+
+```scala
+package scala
+trait ContextFunctionN[-T1, ..., -TN, +R]:
+  def apply(using x1: T1, ..., xN: TN): R
+```
+
+Context function types erase to normal function types, so these classes are
+generated on the fly for typechecking, but not realized in actual code.
+
+Context function literals `(x1: T1, ..., xn: Tn) ?=> e` map
+context parameters `xi` of types `Ti` to the result of evaluating the expression `e`.
+The scope of each context parameter `xi` is `e`. The parameters must have pairwise distinct names.
+
+If the expected type of the context function literal is of the form
+`scala.ContextFunctionN[S1, ..., Sn, R]`, the expected type of `e` is `R` and
+the type `Ti` of any of the parameters `xi` can be omitted, in which case `Ti
+= Si` is assumed. If the expected type of the context function literal is
+some other type, all context parameter types must be explicitly given, and the expected type of `e` is undefined.
+The type of the context function literal is `scala.ContextFunctionN[S1, ...,Sn, T]`, where `T` is the widened
+type of `e`. `T` must be equivalent to a type which does not refer to any of
+the context parameters `xi`.
+
+The context function literal is evaluated as the instance creation expression
+
+```scala
+new scala.ContextFunctionN[T1, ..., Tn, T]:
+  def apply(using x1: T1, ..., xn: Tn): T = e
+```
+
+A context parameter may also be a wildcard represented by an underscore `_`. In that case, a fresh name for the parameter is chosen arbitrarily.
+
+**Note:** The closing paragraph of the
+[Anonymous Functions section](https://www.scala-lang.org/files/archive/spec/2.13/06-expressions.html#anonymous-functions)
+of Scala 2.13 is subsumed by context function types and should be removed.
+
+Context function literals `(x1: T1, ..., xn: Tn) ?=> e` are
+automatically created for any expression `e` whose expected type is
+`scala.ContextFunctionN[T1, ..., Tn, R]`, unless `e` is
+itself a context function literal. This is analogous to the automatic
+insertion of [`scala.Function0`](https://scala-lang.org/api/3.x/scala/Function0.html) around expressions in by-name argument position.
+
+Context function types generalize to `N > 22` in the same way that function types do, see [the corresponding
+documentation](../dropped-features/limit22.md).
+
+## Examples
+
+See the section on Expressiveness from [Simplicitly: foundations and
+applications of implicit function
+types](https://dl.acm.org/citation.cfm?id=3158130).
+
+## Type Checking
+
+After desugaring no additional typing rules are required for context function types.
diff --git a/docs/_spec/TODOreference/contextual/context-functions.md b/docs/_spec/TODOreference/contextual/context-functions.md
new file mode 100644
index 000000000000..0ad3c8757782
--- /dev/null
+++ b/docs/_spec/TODOreference/contextual/context-functions.md
@@ -0,0 +1,154 @@
+---
+layout: doc-page
+title: "Context Functions"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/contextual/context-functions.html
+---
+
+_Context functions_ are functions with (only) context parameters.
+Their types are _context function types_. Here is an example of a context function type:
+
+```scala
+type Executable[T] = ExecutionContext ?=> T
+```
+Context functions are written using `?=>` as the "arrow" sign.
+They are applied to synthesized arguments, in
+the same way methods with context parameters are applied. For instance:
+```scala
+  given ec: ExecutionContext = ...
+
+  def f(x: Int): ExecutionContext ?=> Int = ...
+
+  // could be written as follows with the type alias from above
+  // def f(x: Int): Executable[Int] = ...
+
+  f(2)(using ec)   // explicit argument
+  f(2)             // argument is inferred
+```
+Conversely, if the expected type of an expression `E` is a context function type
+`(T_1, ..., T_n) ?=> U` and `E` is not already an
+context function literal, `E` is converted to a context function literal by rewriting it to
+```scala
+  (x_1: T1, ..., x_n: Tn) ?=> E
+```
+where the names `x_1`, ..., `x_n` are arbitrary. This expansion is performed
+before the expression `E` is typechecked, which means that `x_1`, ..., `x_n`
+are available as givens in `E`.
+
+Like their types, context function literals are written using `?=>` as the arrow between parameters and results. They differ from normal function literals in that their types are context function types.
+
+For example, continuing with the previous definitions,
+```scala
+  def g(arg: Executable[Int]) = ...
+
+  g(22)      // is expanded to g((ev: ExecutionContext) ?=> 22)
+
+  g(f(2))    // is expanded to g((ev: ExecutionContext) ?=> f(2)(using ev))
+
+  g((ctx: ExecutionContext) ?=> f(3))  // is expanded to g((ctx: ExecutionContext) ?=> f(3)(using ctx))
+  g((ctx: ExecutionContext) ?=> f(3)(using ctx)) // is left as it is
+```
+
+## Example: Builder Pattern
+
+Context function types have considerable expressive power. For
+instance, here is how they can support the "builder pattern", where
+the aim is to construct tables like this:
+```scala
+  table {
+    row {
+      cell("top left")
+      cell("top right")
+    }
+    row {
+      cell("bottom left")
+      cell("bottom right")
+    }
+  }
+```
+The idea is to define classes for `Table` and `Row` that allow the
+addition of elements via `add`:
+```scala
+  class Table:
+    val rows = new ArrayBuffer[Row]
+    def add(r: Row): Unit = rows += r
+    override def toString = rows.mkString("Table(", ", ", ")")
+
+  class Row:
+    val cells = new ArrayBuffer[Cell]
+    def add(c: Cell): Unit = cells += c
+    override def toString = cells.mkString("Row(", ", ", ")")
+
+  case class Cell(elem: String)
+```
+Then, the `table`, `row` and `cell` constructor methods can be defined
+with context function types as parameters to avoid the plumbing boilerplate
+that would otherwise be necessary.
+```scala
+  def table(init: Table ?=> Unit) =
+    given t: Table = Table()
+    init
+    t
+
+  def row(init: Row ?=> Unit)(using t: Table) =
+     given r: Row = Row()
+     init
+     t.add(r)
+
+  def cell(str: String)(using r: Row) =
+     r.add(new Cell(str))
+```
+With that setup, the table construction code above compiles and expands to:
+```scala
+  table { ($t: Table) ?=>
+
+    row { ($r: Row) ?=>
+      cell("top left")(using $r)
+      cell("top right")(using $r)
+    }(using $t)
+
+    row { ($r: Row) ?=>
+      cell("bottom left")(using $r)
+      cell("bottom right")(using $r)
+    }(using $t)
+  }
+```
+## Example: Postconditions
+
+As a larger example, here is a way to define constructs for checking arbitrary postconditions using an extension method `ensuring` so that the checked result can be referred to simply by `result`. The example combines opaque type aliases, context function types, and extension methods to provide a zero-overhead abstraction.
+
+```scala
+object PostConditions:
+  opaque type WrappedResult[T] = T
+
+  def result[T](using r: WrappedResult[T]): T = r
+
+  extension [T](x: T)
+    def ensuring(condition: WrappedResult[T] ?=> Boolean): T =
+      assert(condition(using x))
+      x
+end PostConditions
+import PostConditions.{ensuring, result}
+
+val s = List(1, 2, 3).sum.ensuring(result == 6)
+```
+**Explanations**: We use a context function type `WrappedResult[T] ?=> Boolean`
+as the type of the condition of `ensuring`. An argument to `ensuring` such as
+`(result == 6)` will therefore have a given of type `WrappedResult[T]` in
+scope to pass along to the `result` method. `WrappedResult` is a fresh type, to make sure
+that we do not get unwanted givens in scope (this is good practice in all cases
+where context parameters are involved). Since `WrappedResult` is an opaque type alias, its
+values need not be boxed, and since `ensuring` is added as an extension method, its argument
+does not need boxing either. Hence, the implementation of `ensuring` is close in efficiency to the best possible code one could write by hand:
+
+```scala
+val s =
+  val result = List(1, 2, 3).sum
+  assert(result == 6)
+  result
+```
+## Reference
+
+For more information, see the [blog article](https://www.scala-lang.org/blog/2016/12/07/implicit-function-types.html),
+(which uses a different syntax that has been superseded).
+
+[More details](./context-functions-spec.md)
diff --git a/docs/_spec/TODOreference/contextual/contextual.md b/docs/_spec/TODOreference/contextual/contextual.md
new file mode 100644
index 000000000000..fda63397f8f9
--- /dev/null
+++ b/docs/_spec/TODOreference/contextual/contextual.md
@@ -0,0 +1,83 @@
+---
+layout: index
+title: "Contextual Abstractions"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/contextual.html
+---
+
+## Critique of the Status Quo
+
+Scala's implicits are its most distinguished feature. They are _the_ fundamental way to abstract over context. They represent a unified paradigm with a great variety of use cases, among them: implementing type classes, establishing context, dependency injection, expressing capabilities, computing new types and proving relationships between them.
+
+Following Haskell, Scala was the second popular language to have some form of implicits. Other languages have followed suit. E.g [Rust's traits](https://doc.rust-lang.org/rust-by-example/trait.html) or [Swift's protocol extensions](https://docs.swift.org/swift-book/LanguageGuide/Protocols.html#ID521). Design proposals are also on the table for Kotlin as [compile time dependency resolution](https://github.com/Kotlin/KEEP/blob/e863b25f8b3f2e9b9aaac361c6ee52be31453ee0/proposals/compile-time-dependency-resolution.md), for C# as [Shapes and Extensions](https://github.com/dotnet/csharplang/issues/164)
+or for F# as [Traits](https://github.com/MattWindsor91/visualfsharp/blob/hackathon-vs/examples/fsconcepts.md). Implicits are also a common feature of theorem provers such as [Coq](https://coq.inria.fr/refman/language/extensions/implicit-arguments.html) or [Agda](https://agda.readthedocs.io/en/latest/language/implicit-arguments.html).
+
+Even though these designs use widely different terminology, they are all variants of the core idea of _term inference_. Given a type, the compiler synthesizes a "canonical" term that has that type. Scala embodies the idea in a purer form than most other languages: An implicit parameter directly leads to an inferred argument term that could also be written down explicitly. By contrast, type class based designs are less direct since they hide term inference behind some form of type classification and do not offer the option of writing the inferred quantities (typically, dictionaries) explicitly.
+
+Given that term inference is where the industry is heading, and given that Scala has it in a very pure form, how come implicits are not more popular? In fact, it's fair to say that implicits are at the same time Scala's most distinguished and most controversial feature. I believe this is due to a number of aspects that together make implicits harder to learn than necessary and also make it harder to prevent abuses.
+
+Particular criticisms are:
+
+1. Being very powerful, implicits are easily over-used and mis-used. This observation holds in almost all cases when we talk about _implicit conversions_, which, even though conceptually different, share the same syntax with other implicit definitions. For instance, regarding the two definitions
+
+    ```scala
+    implicit def i1(implicit x: T): C[T] = ...
+    implicit def i2(x: T): C[T] = ...
+    ```
+
+   the first of these is a conditional implicit _value_, the second an implicit _conversion_. Conditional implicit values are a cornerstone for expressing type classes, whereas most applications of implicit conversions have turned out to be of dubious value. The problem is that many newcomers to the language start with defining implicit conversions since they are easy to understand and seem powerful and convenient. Scala 3 will put under a language flag both definitions and applications of "undisciplined" implicit conversions between types defined elsewhere. This is a useful step to push back against overuse of implicit conversions. But the problem remains that syntactically, conversions and values just look too similar for comfort.
+
+2. Another widespread abuse is over-reliance on implicit imports. This often leads to inscrutable type errors that go away with the right import incantation, leaving a feeling of frustration. Conversely, it is hard to see what implicits a program uses since implicits can hide anywhere in a long list of imports.
+
+3. The syntax of implicit definitions is too minimal. It consists of a single modifier, `implicit`, that can be attached to a large number of language constructs. A problem with this for newcomers is that it conveys mechanism instead of intent. For instance, a type class instance is an implicit object or val if unconditional and an implicit def with implicit parameters referring to some class if conditional. This describes precisely what the implicit definitions translate to -- just drop the `implicit` modifier, and that's it! But the cues that define intent are rather indirect and can be easily misread, as demonstrated by the definitions of `i1` and `i2` above.
+
+4. The syntax of implicit parameters also has shortcomings. While implicit _parameters_ are designated specifically, arguments are not. Passing an argument to an implicit parameter looks like a regular application `f(arg)`. This is problematic because it means there can be confusion regarding what parameter gets instantiated in a call. For instance, in
+
+   ```scala
+   def currentMap(implicit ctx: Context): Map[String, Int]
+   ```
+
+   one cannot write `currentMap("abc")` since the string `"abc"` is taken as explicit argument to the implicit `ctx` parameter. One has to write `currentMap.apply("abc")` instead, which is awkward and irregular. For the same reason, a method definition can only have one implicit parameter section and it must always come last. This restriction not only reduces orthogonality, but also prevents some useful program constructs, such as a method with a regular parameter whose type depends on an implicit value. Finally, it's also a bit annoying that implicit parameters must have a name, even though in many cases that name is never referenced.
+
+5. Implicits pose challenges for tooling. The set of available implicits depends on context, so command completion has to take context into account. This is feasible in an IDE but tools like [Scaladoc](https://docs.scala-lang.org/overviews/scaladoc/overview.html) that are based on static web pages can only provide an approximation. Another problem is that failed implicit searches often give very unspecific error messages, in particular if some deeply recursive implicit search has failed. Note that the Scala 3 compiler has already made a lot of progress in the error diagnostics area. If a recursive search fails some levels down, it shows what was constructed and what is missing. Also, it suggests imports that can bring missing implicits in scope.
+
+None of the shortcomings is fatal, after all implicits are very widely used, and many libraries and applications rely on them. But together, they make code using implicits a lot more cumbersome and less clear than it could be.
+
+Historically, many of these shortcomings come from the way implicits were gradually "discovered" in Scala. Scala originally had only implicit conversions with the intended use case of "extending" a class or trait after it was defined, i.e. what is expressed by implicit classes in later versions of Scala. Implicit parameters and instance definitions came later in 2006 and we picked similar syntax since it seemed convenient. For the same reason, no effort was made to distinguish implicit imports or arguments from normal ones.
+
+Existing Scala programmers by and large have gotten used to the status quo and see little need for change. But for newcomers this status quo presents a big hurdle. I believe if we want to overcome that hurdle, we should take a step back and allow ourselves to consider a radically new design.
+
+## The New Design
+
+The following pages introduce a redesign of contextual abstractions in Scala. They introduce four fundamental changes:
+
+1. [Given Instances](./givens.md) are a new way to define basic terms that can be synthesized.  They replace implicit definitions. The core principle of the proposal is that, rather than mixing the `implicit` modifier with a large number of features, we have a single way to define terms that can be synthesized for types.
+
+2. [Using Clauses](./using-clauses.md) are a new syntax for implicit _parameters_ and their _arguments_. It unambiguously aligns parameters and arguments, solving a number of language warts. It also allows us to have several `using` clauses in a definition.
+
+3. ["Given" Imports](./given-imports.md) are a new class of import selectors that specifically import
+   givens and nothing else.
+
+4. [Implicit Conversions](./conversions.md) are now expressed as given instances of a standard `Conversion` class. All other forms of implicit conversions will be phased out.
+
+This section also contains pages describing other language features that are related to context abstraction. These are:
+
+- [Context Bounds](./context-bounds.md), which carry over unchanged.
+- [Extension Methods](./extension-methods.md) replace implicit classes in a way that integrates better with type classes.
+- [Implementing Type Classes](./type-classes.md) demonstrates how some common type classes can be implemented using the new constructs.
+- [Type Class Derivation](./derivation.md) introduces constructs to automatically derive type class instances for ADTs.
+- [Multiversal Equality](./multiversal-equality.md) introduces a special type class to support type safe equality.
+- [Context Functions](./context-functions.md) provide a way to abstract over context parameters.
+- [By-Name Context Parameters](./by-name-context-parameters.md) are an essential tool to define recursive synthesized values without looping.
+- [Relationship with Scala 2 Implicits](./relationship-implicits.md) discusses the relationship between old-style implicits and new-style givens and how to migrate from one to the other.
+
+Overall, the new design achieves a better separation of term inference from the rest of the language: There is a single way to define givens instead of a multitude of forms all taking an `implicit` modifier. There is a single way to introduce implicit parameters and arguments instead of conflating implicit with normal arguments. There is a separate way to import givens that does not allow them to hide in a sea of normal imports. And there is a single way to define an implicit conversion which is clearly marked as such and does not require special syntax.
+
+This design thus avoids feature interactions and makes the language more consistent and orthogonal. It will make implicits easier to learn and harder to abuse. It will greatly improve the clarity of the 95% of Scala programs that use implicits. It has thus the potential to fulfil the promise of term inference in a principled way that is also accessible and friendly.
+
+Could we achieve the same goals by tweaking existing implicits? After having tried for a long time, I believe now that this is impossible.
+
+- First, some of the problems are clearly syntactic and require different syntax to solve them.
+- Second, there is the problem how to migrate. We cannot change the rules in mid-flight. At some stage of language evolution we need to accommodate both the new and the old rules. With a syntax change, this is easy: Introduce the new syntax with new rules, support the old syntax for a while to facilitate cross compilation, deprecate and phase out the old syntax at some later time. Keeping the same syntax does not offer this path, and in fact does not seem to offer any viable path for evolution
+- Third, even if we would somehow succeed with migration, we still have the problem
+  how to teach this. We cannot make existing tutorials go away. Almost all existing tutorials start with implicit conversions, which will go away; they use normal imports, which will go away, and they explain calls to methods with implicit parameters by expanding them to plain applications, which will also go away. This means that we'd have
+  to add modifications and qualifications to all existing literature and courseware, likely causing more confusion with beginners instead of less. By contrast, with a new syntax there is a clear criterion: Any book or courseware that mentions `implicit` is outdated and should be updated.
diff --git a/docs/_spec/TODOreference/contextual/conversions.md b/docs/_spec/TODOreference/contextual/conversions.md
new file mode 100644
index 000000000000..1ce8d42074e7
--- /dev/null
+++ b/docs/_spec/TODOreference/contextual/conversions.md
@@ -0,0 +1,76 @@
+---
+layout: doc-page
+title: "Implicit Conversions"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/contextual/conversions.html
+---
+
+Implicit conversions are defined by given instances of the `scala.Conversion` class.
+This class is defined in package `scala` as follows:
+```scala
+abstract class Conversion[-T, +U] extends (T => U):
+  def apply (x: T): U
+```
+For example, here is an implicit conversion from `String` to `Token`:
+```scala
+given Conversion[String, Token] with
+  def apply(str: String): Token = new KeyWord(str)
+```
+Using an alias this can be expressed more concisely as:
+```scala
+given Conversion[String, Token] = new KeyWord(_)
+```
+An implicit conversion is applied automatically by the compiler in three situations:
+
+1. If an expression `e` has type `T`, and `T` does not conform to the expression's expected type `S`.
+2. In a selection `e.m` with `e` of type `T`, but `T` defines no member `m`.
+3. In an application `e.m(args)` with `e` of type `T`, if `T` does define
+   some member(s) named `m`, but none of these members can be applied to the arguments `args`.
+
+In the first case, the compiler looks for a given `scala.Conversion` instance that maps
+an argument of type `T` to type `S`. In the second and third
+case, it looks for a given `scala.Conversion` instance that maps an argument of type `T`
+to a type that defines a member `m` which can be applied to `args` if present.
+If such an instance `C` is found, the expression `e` is replaced by `C.apply(e)`.
+
+## Examples
+
+1. The `Predef` package contains "auto-boxing" conversions that map
+primitive number types to subclasses of `java.lang.Number`. For instance, the
+conversion from `Int` to `java.lang.Integer` can be defined as follows:
+   ```scala
+   given int2Integer: Conversion[Int, java.lang.Integer] =
+     java.lang.Integer.valueOf(_)
+   ```
+
+2. The "magnet" pattern is sometimes used to express many variants of a method. Instead of defining overloaded versions of the method, one can also let the method take one or more arguments of specially defined "magnet" types, into which various argument types can be converted. Example:
+   ```scala
+   object Completions:
+
+     // The argument "magnet" type
+     enum CompletionArg:
+       case Error(s: String)
+       case Response(f: Future[HttpResponse])
+       case Status(code: Future[StatusCode])
+
+     object CompletionArg:
+
+       // conversions defining the possible arguments to pass to `complete`
+       // these always come with CompletionArg
+       // They can be invoked explicitly, e.g.
+       //
+       //   CompletionArg.fromStatusCode(statusCode)
+
+       given fromString    : Conversion[String, CompletionArg]               = Error(_)
+       given fromFuture    : Conversion[Future[HttpResponse], CompletionArg] = Response(_)
+       given fromStatusCode: Conversion[Future[StatusCode], CompletionArg]   = Status(_)
+     end CompletionArg
+     import CompletionArg.*
+
+     def complete[T](arg: CompletionArg) = arg match
+       case Error(s) => ...
+       case Response(f) => ...
+       case Status(code) => ...
+
+   end Completions
+   ```
+This setup is more complicated than simple overloading of `complete`, but it can still be useful if normal overloading is not available (as in the case above, since we cannot have two overloaded methods that take `Future[...]` arguments), or if normal overloading would lead to a combinatorial explosion of variants.
diff --git a/docs/_spec/TODOreference/contextual/derivation-macro.md b/docs/_spec/TODOreference/contextual/derivation-macro.md
new file mode 100644
index 000000000000..be7565616913
--- /dev/null
+++ b/docs/_spec/TODOreference/contextual/derivation-macro.md
@@ -0,0 +1,205 @@
+---
+layout: doc-page
+title: "How to write a type class `derived` method using macros"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/contextual/derivation-macro.html
+---
+
+In the main [derivation](./derivation.md) documentation page, we explained the
+details behind `Mirror`s and type class derivation. Here we demonstrate how to
+implement a type class `derived` method using macros only. We follow the same
+example of deriving `Eq` instances and for simplicity we support a `Product`
+type e.g., a case class `Person`. The low-level method we will use to implement
+the `derived` method exploits quotes, splices of both expressions and types and
+the `scala.quoted.Expr.summon` method which is the equivalent of
+`summonFrom`. The former is suitable for use in a quote context, used within
+macros.
+
+As in the original code, the type class definition is the same:
+
+```scala
+trait Eq[T]:
+  def eqv(x: T, y: T): Boolean
+```
+
+we need to implement a method `Eq.derived` on the companion object of `Eq` that
+produces a quoted instance for `Eq[T]`. Here is a possible signature,
+
+```scala
+given derived[T: Type](using Quotes): Expr[Eq[T]]
+```
+
+and for comparison reasons we give the same signature we had with `inline`:
+
+```scala
+inline given derived[T](using Mirror.Of[T]): Eq[T] = ???
+```
+
+Note, that since a type is used in a subsequent stage it will need to be lifted
+to a `Type` by using the corresponding context bound. Also, note that we can
+summon the quoted `Mirror` inside the body of the `derived` thus we can omit it
+from the signature. The body of the `derived` method is shown below:
+
+
+```scala
+given derived[T: Type](using Quotes): Expr[Eq[T]] =
+  import quotes.reflect.*
+
+  val ev: Expr[Mirror.Of[T]] = Expr.summon[Mirror.Of[T]].get
+
+  ev match
+    case '{ $m: Mirror.ProductOf[T] { type MirroredElemTypes = elementTypes }} =>
+      val elemInstances = summonAll[elementTypes]
+      def eqProductBody(x: Expr[Product], y: Expr[Product])(using Quotes): Expr[Boolean] = {
+        elemInstances.zipWithIndex.foldLeft(Expr(true)) {
+          case (acc, ('{ $elem: Eq[t] }, index)) =>
+            val indexExpr = Expr(index)
+            val e1 = '{ $x.productElement($indexExpr).asInstanceOf[t] }
+            val e2 = '{ $y.productElement($indexExpr).asInstanceOf[t] }
+            '{ $acc && $elem.eqv($e1, $e2) }
+         }
+      }
+      '{ eqProduct((x: T, y: T) => ${eqProductBody('x.asExprOf[Product], 'y.asExprOf[Product])}) }
+
+  // case for Mirror.ProductOf[T]
+  // ...
+```
+
+Note, that in the `inline` case we can merely write
+`summonAll[m.MirroredElemTypes]` inside the inline method but here, since
+`Expr.summon` is required, we can extract the element types in a macro fashion.
+Being inside a macro, our first reaction would be to write the code below. Since
+the path inside the type argument is not stable this cannot be used:
+
+```scala
+'{
+  summonAll[$m.MirroredElemTypes]
+}
+```
+
+Instead we extract the tuple-type for element types using pattern matching over
+quotes and more specifically of the refined type:
+
+```scala
+   case '{ $m: Mirror.ProductOf[T] { type MirroredElemTypes = elementTypes }} => ...
+```
+
+Shown below is the implementation of `summonAll` as a macro. We assume that
+given instances for our primitive types exist.
+
+```scala
+def summonAll[T: Type](using Quotes): List[Expr[Eq[_]]] =
+   Type.of[T] match
+      case '[String *: tpes] => '{ summon[Eq[String]] } :: summonAll[tpes]
+      case '[Int *: tpes]    => '{ summon[Eq[Int]] }    :: summonAll[tpes]
+      case '[tpe *: tpes]    => derived[tpe] :: summonAll[tpes]
+      case '[EmptyTuple]     => Nil
+```
+
+One additional difference with the body of `derived` here as opposed to the one
+with `inline` is that with macros we need to synthesize the body of the code during the
+macro-expansion time. That is the rationale behind the `eqProductBody` function.
+Assuming that we calculate the equality of two `Person`s defined with a case
+class that holds a name of type [`String`](https://scala-lang.org/api/3.x/scala/Predef$.html#String-0)
+and an age of type `Int`, the equality check we want to generate is the following:
+
+```scala
+   true
+   && Eq[String].eqv(x.productElement(0),y.productElement(0))
+   && Eq[Int].eqv(x.productElement(1), y.productElement(1))
+```
+
+## Calling the derived method inside the macro
+
+Following the rules in [Macros](../metaprogramming/metaprogramming.md) we create two methods.
+One that hosts the top-level splice `eqv` and one that is the implementation.
+Alternatively and what is shown below is that we can call the `eqv` method
+directly. The `eqGen` can trigger the derivation.
+
+```scala
+extension [T](inline x: T)
+   inline def === (inline y: T)(using eq: Eq[T]): Boolean = eq.eqv(x, y)
+
+inline given eqGen[T]: Eq[T] = ${ Eq.derived[T] }
+```
+
+Note, that we use inline method syntax and we can compare instance such as
+`Sm(Person("Test", 23)) === Sm(Person("Test", 24))` for e.g., the following two
+types:
+
+```scala
+case class Person(name: String, age: Int)
+
+enum Opt[+T]:
+   case Sm(t: T)
+   case Nn
+```
+
+The full code is shown below:
+
+```scala
+import scala.deriving.*
+import scala.quoted.*
+
+
+trait Eq[T]:
+   def eqv(x: T, y: T): Boolean
+
+object Eq:
+   given Eq[String] with
+      def eqv(x: String, y: String) = x == y
+
+   given Eq[Int] with
+      def eqv(x: Int, y: Int) = x == y
+
+   def eqProduct[T](body: (T, T) => Boolean): Eq[T] =
+      new Eq[T]:
+         def eqv(x: T, y: T): Boolean = body(x, y)
+
+   def eqSum[T](body: (T, T) => Boolean): Eq[T] =
+      new Eq[T]:
+         def eqv(x: T, y: T): Boolean = body(x, y)
+
+   def summonAll[T: Type](using Quotes): List[Expr[Eq[_]]] =
+      Type.of[T] match
+         case '[String *: tpes] => '{ summon[Eq[String]] } :: summonAll[tpes]
+         case '[Int *: tpes]    => '{ summon[Eq[Int]] }    :: summonAll[tpes]
+         case '[tpe *: tpes]    => derived[tpe] :: summonAll[tpes]
+         case '[EmptyTuple]     => Nil
+
+   given derived[T: Type](using q: Quotes): Expr[Eq[T]] =
+      import quotes.reflect.*
+
+      val ev: Expr[Mirror.Of[T]] = Expr.summon[Mirror.Of[T]].get
+
+      ev match
+         case '{ $m: Mirror.ProductOf[T] { type MirroredElemTypes = elementTypes }} =>
+            val elemInstances = summonAll[elementTypes]
+            val eqProductBody: (Expr[T], Expr[T]) => Expr[Boolean] = (x, y) =>
+               elemInstances.zipWithIndex.foldLeft(Expr(true: Boolean)) {
+                  case (acc, (elem, index)) =>
+                     val e1 = '{$x.asInstanceOf[Product].productElement(${Expr(index)})}
+                     val e2 = '{$y.asInstanceOf[Product].productElement(${Expr(index)})}
+
+                     '{ $acc && $elem.asInstanceOf[Eq[Any]].eqv($e1, $e2) }
+               }
+            '{ eqProduct((x: T, y: T) => ${eqProductBody('x, 'y)}) }
+
+         case '{ $m: Mirror.SumOf[T] { type MirroredElemTypes = elementTypes }} =>
+            val elemInstances = summonAll[elementTypes]
+            val eqSumBody: (Expr[T], Expr[T]) => Expr[Boolean] = (x, y) =>
+               val ordx = '{ $m.ordinal($x) }
+               val ordy = '{ $m.ordinal($y) }
+
+               val elements = Expr.ofList(elemInstances)
+               '{ $ordx == $ordy && $elements($ordx).asInstanceOf[Eq[Any]].eqv($x, $y) }
+
+         '{ eqSum((x: T, y: T) => ${eqSumBody('x, 'y)}) }
+   end derived
+end Eq
+
+object Macro3:
+   extension [T](inline x: T)
+      inline def === (inline y: T)(using eq: Eq[T]): Boolean = eq.eqv(x, y)
+
+   inline given eqGen[T]: Eq[T] = ${ Eq.derived[T] }
+```
diff --git a/docs/_spec/TODOreference/contextual/derivation.md b/docs/_spec/TODOreference/contextual/derivation.md
new file mode 100644
index 000000000000..bad47dcb0096
--- /dev/null
+++ b/docs/_spec/TODOreference/contextual/derivation.md
@@ -0,0 +1,425 @@
+---
+layout: doc-page
+title: "Type Class Derivation"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/contextual/derivation.html
+---
+
+Type class derivation is a way to automatically generate given instances for type classes which satisfy some simple
+conditions. A type class in this sense is any trait or class with a type parameter determining the type being operated
+on. Common examples are `Eq`, `Ordering`, or `Show`. For example, given the following `Tree` algebraic data type
+(ADT),
+
+```scala
+enum Tree[T] derives Eq, Ordering, Show:
+  case Branch(left: Tree[T], right: Tree[T])
+  case Leaf(elem: T)
+```
+
+The `derives` clause generates the following given instances for the `Eq`, `Ordering` and `Show` type classes in the
+companion object of `Tree`,
+
+```scala
+given [T: Eq]       : Eq[Tree[T]]       = Eq.derived
+given [T: Ordering] : Ordering[Tree[T]] = Ordering.derived
+given [T: Show]     : Show[Tree[T]]     = Show.derived
+```
+
+We say that `Tree` is the _deriving type_ and that the `Eq`, `Ordering` and `Show` instances are _derived instances_.
+
+## Types supporting `derives` clauses
+
+All data types can have a `derives` clause. This document focuses primarily on data types which also have a given instance
+of the `Mirror` type class available.
+
+`Mirror` type class instances provide information at the type level about the components and labelling of the type.
+They also provide minimal term level infrastructure to allow higher level libraries to provide comprehensive
+derivation support.
+
+Instances of the `Mirror` type class are generated automatically by the compiler
+unconditionally for:
+- enums and enum cases,
+- case objects.
+
+Instances for `Mirror` are also generated conditionally for:
+- case classes where the constructor is visible at the callsite (always true if the companion is not a case object)
+- sealed classes and sealed traits where:
+  - there exists at least one child case,
+  - each child case is reachable from the parent's definition,
+  - if the sealed trait/class has no companion, then each child case is reachable from the callsite through the prefix of the type being mirrored,
+  - and where the compiler can generate a `Mirror` type class instance for each child case.
+
+
+The `Mirror` type class definition is as follows:
+
+```scala
+sealed trait Mirror:
+
+  /** the type being mirrored */
+  type MirroredType
+
+  /** the type of the elements of the mirrored type */
+  type MirroredElemTypes
+
+  /** The mirrored *-type */
+  type MirroredMonoType
+
+  /** The name of the type */
+  type MirroredLabel <: String
+
+  /** The names of the elements of the type */
+  type MirroredElemLabels <: Tuple
+
+object Mirror:
+
+  /** The Mirror for a product type */
+  trait Product extends Mirror:
+
+    /** Create a new instance of type `T` with elements
+     *  taken from product `p`.
+     */
+    def fromProduct(p: scala.Product): MirroredMonoType
+
+  trait Sum extends Mirror:
+
+    /** The ordinal number of the case class of `x`.
+     *  For enums, `ordinal(x) == x.ordinal`
+     */
+    def ordinal(x: MirroredMonoType): Int
+
+end Mirror
+```
+
+Product types (i.e. case classes and objects, and enum cases) have mirrors which are subtypes of `Mirror.Product`. Sum
+types (i.e. sealed class or traits with product children, and enums) have mirrors which are subtypes of `Mirror.Sum`.
+
+For the `Tree` ADT from above the following `Mirror` instances will be automatically provided by the compiler,
+
+```scala
+// Mirror for Tree
+new Mirror.Sum:
+  type MirroredType = Tree
+  type MirroredElemTypes[T] = (Branch[T], Leaf[T])
+  type MirroredMonoType = Tree[_]
+  type MirroredLabel = "Tree"
+  type MirroredElemLabels = ("Branch", "Leaf")
+
+  def ordinal(x: MirroredMonoType): Int = x match
+    case _: Branch[_] => 0
+    case _: Leaf[_] => 1
+
+// Mirror for Branch
+new Mirror.Product:
+  type MirroredType = Branch
+  type MirroredElemTypes[T] = (Tree[T], Tree[T])
+  type MirroredMonoType = Branch[_]
+  type MirroredLabel = "Branch"
+  type MirroredElemLabels = ("left", "right")
+
+  def fromProduct(p: Product): MirroredMonoType =
+    new Branch(...)
+
+// Mirror for Leaf
+new Mirror.Product:
+  type MirroredType = Leaf
+  type MirroredElemTypes[T] = Tuple1[T]
+  type MirroredMonoType = Leaf[_]
+  type MirroredLabel = "Leaf"
+  type MirroredElemLabels = Tuple1["elem"]
+
+  def fromProduct(p: Product): MirroredMonoType =
+    new Leaf(...)
+```
+
+If a Mirror cannot be generated automatically for a given type, an error will appear explaining why it is neither a supported
+sum type nor a product type. For example, if `A` is a trait that is not sealed,
+
+```
+No given instance of type deriving.Mirror.Of[A] was found for parameter x of method summon in object Predef. Failed to synthesize an instance of type deriving.Mirror.Of[A]:
+     * trait A is not a generic product because it is not a case class
+     * trait A is not a generic sum because it is not a sealed trait
+```
+
+
+Note the following properties of `Mirror` types,
+
++ Properties are encoded using types rather than terms. This means that they have no runtime footprint unless used and
+  also that they are a compile time feature for use with Scala 3's metaprogramming facilities.
++ There is no restriction against the mirrored type being a local or inner class.
++ The kinds of `MirroredType` and `MirroredElemTypes` match the kind of the data type the mirror is an instance for.
+  This allows `Mirror`s to support ADTs of all kinds.
++ There is no distinct representation type for sums or products (ie. there is no `HList` or `Coproduct` type as in
+  Scala 2 versions of Shapeless). Instead the collection of child types of a data type is represented by an ordinary,
+  possibly parameterized, tuple type. Scala 3's metaprogramming facilities can be used to work with these tuple types
+  as-is, and higher level libraries can be built on top of them.
++ For both product and sum types, the elements of `MirroredElemTypes` are arranged in definition order (i.e. `Branch[T]`
+  precedes `Leaf[T]` in `MirroredElemTypes` for `Tree` because `Branch` is defined before `Leaf` in the source file).
+  This means that `Mirror.Sum` differs in this respect from Shapeless's generic representation for ADTs in Scala 2,
+  where the constructors are ordered alphabetically by name.
++ The methods `ordinal` and `fromProduct` are defined in terms of `MirroredMonoType` which is the type of kind-`*`
+  which is obtained from `MirroredType` by wildcarding its type parameters.
+
+## Type classes supporting automatic deriving
+
+A trait or class can appear in a `derives` clause if its companion object defines a method named `derived`. The
+signature and implementation of a `derived` method for a type class `TC[_]` are arbitrary but it is typically of the
+following form,
+
+```scala
+import scala.deriving.Mirror
+
+inline def derived[T](using Mirror.Of[T]): TC[T] = ...
+```
+
+That is, the `derived` method takes a context parameter of (some subtype of) type `Mirror` which defines the shape of
+the deriving type `T`, and computes the type class implementation according to that shape. This is all that the
+provider of an ADT with a `derives` clause has to know about the derivation of a type class instance.
+
+Note that `derived` methods may have context `Mirror` parameters indirectly (e.g. by having a context argument which in turn
+has a context `Mirror` parameter, or not at all (e.g. they might use some completely different user-provided mechanism, for
+instance using Scala 3 macros or runtime reflection). We expect that (direct or indirect) `Mirror` based implementations
+will be the most common and that is what this document emphasises.
+
+Type class authors will most likely use higher level derivation or generic programming libraries to implement
+`derived` methods. An example of how a `derived` method might be implemented using _only_ the low level facilities
+described above and Scala 3's general metaprogramming features is provided below. It is not anticipated that type class
+authors would normally implement a `derived` method in this way, however this walkthrough can be taken as a guide for
+authors of the higher level derivation libraries that we expect typical type class authors will use (for a fully
+worked out example of such a library, see [Shapeless 3](https://github.com/milessabin/shapeless/tree/shapeless-3)).
+
+## How to write a type class `derived` method using low level mechanisms
+
+The low-level method we will use to implement a type class `derived` method in this example exploits three new
+type-level constructs in Scala 3: inline methods, inline matches, and implicit searches via  `summonInline` or `summonFrom`. Given this definition of the
+`Eq` type class,
+
+```scala
+trait Eq[T]:
+  def eqv(x: T, y: T): Boolean
+```
+
+we need to implement a method `Eq.derived` on the companion object of `Eq` that produces a given instance for `Eq[T]` given
+a `Mirror[T]`. Here is a possible implementation,
+
+```scala
+import scala.deriving.Mirror
+
+inline given derived[T](using m: Mirror.Of[T]): Eq[T] =
+  val elemInstances = summonAll[m.MirroredElemTypes]           // (1)
+  inline m match                                               // (2)
+    case s: Mirror.SumOf[T]     => eqSum(s, elemInstances)
+    case p: Mirror.ProductOf[T] => eqProduct(p, elemInstances)
+```
+
+Note that `derived` is defined as an `inline` given. This means that the method will be expanded at
+call sites (for instance the compiler generated instance definitions in the companion objects of ADTs which have a
+`derived Eq` clause), and also that it can be used recursively if necessary, to compute instances for children.
+
+The body of this method (1) first materializes the `Eq` instances for all the child types of type the instance is
+being derived for. This is either all the branches of a sum type or all the fields of a product type. The
+implementation of `summonAll` is `inline` and uses Scala 3's `summonInline` construct to collect the instances as a
+`List`,
+
+```scala
+inline def summonAll[T <: Tuple]: List[Eq[_]] =
+  inline erasedValue[T] match
+    case _: EmptyTuple => Nil
+    case _: (t *: ts) => summonInline[Eq[t]] :: summonAll[ts]
+```
+
+with the instances for children in hand the `derived` method uses an `inline match` to dispatch to methods which can
+construct instances for either sums or products (2). Note that because `derived` is `inline` the match will be
+resolved at compile-time and only the left-hand side of the matching case will be inlined into the generated code with
+types refined as revealed by the match.
+
+In the sum case, `eqSum`, we use the runtime `ordinal` values of the arguments to `eqv` to first check if the two
+values are of the same subtype of the ADT (3) and then, if they are, to further test for equality based on the `Eq`
+instance for the appropriate ADT subtype using the auxiliary method `check` (4).
+
+```scala
+import scala.deriving.Mirror
+
+def eqSum[T](s: Mirror.SumOf[T], elems: List[Eq[_]]): Eq[T] =
+  new Eq[T]:
+    def eqv(x: T, y: T): Boolean =
+      val ordx = s.ordinal(x)                            // (3)
+      (s.ordinal(y) == ordx) && check(elems(ordx))(x, y) // (4)
+```
+
+In the product case, `eqProduct` we test the runtime values of the arguments to `eqv` for equality as products based
+on the `Eq` instances for the fields of the data type (5),
+
+```scala
+import scala.deriving.Mirror
+
+def eqProduct[T](p: Mirror.ProductOf[T], elems: List[Eq[_]]): Eq[T] =
+  new Eq[T]:
+    def eqv(x: T, y: T): Boolean =
+      iterator(x).zip(iterator(y)).zip(elems.iterator).forall {  // (5)
+        case ((x, y), elem) => check(elem)(x, y)
+      }
+```
+
+Pulling this all together we have the following complete implementation,
+
+```scala
+import scala.deriving.*
+import scala.compiletime.{erasedValue, summonInline}
+
+inline def summonAll[T <: Tuple]: List[Eq[_]] =
+  inline erasedValue[T] match
+    case _: EmptyTuple => Nil
+    case _: (t *: ts) => summonInline[Eq[t]] :: summonAll[ts]
+
+trait Eq[T]:
+  def eqv(x: T, y: T): Boolean
+
+object Eq:
+  given Eq[Int] with
+    def eqv(x: Int, y: Int) = x == y
+
+  def check(elem: Eq[_])(x: Any, y: Any): Boolean =
+    elem.asInstanceOf[Eq[Any]].eqv(x, y)
+
+  def iterator[T](p: T) = p.asInstanceOf[Product].productIterator
+
+  def eqSum[T](s: Mirror.SumOf[T], elems: => List[Eq[_]]): Eq[T] =
+    new Eq[T]:
+      def eqv(x: T, y: T): Boolean =
+        val ordx = s.ordinal(x)
+        (s.ordinal(y) == ordx) && check(elems(ordx))(x, y)
+
+  def eqProduct[T](p: Mirror.ProductOf[T], elems: => List[Eq[_]]): Eq[T] =
+    new Eq[T]:
+      def eqv(x: T, y: T): Boolean =
+        iterator(x).zip(iterator(y)).zip(elems.iterator).forall {
+          case ((x, y), elem) => check(elem)(x, y)
+        }
+
+  inline given derived[T](using m: Mirror.Of[T]): Eq[T] =
+    lazy val elemInstances = summonAll[m.MirroredElemTypes]
+    inline m match
+      case s: Mirror.SumOf[T]     => eqSum(s, elemInstances)
+      case p: Mirror.ProductOf[T] => eqProduct(p, elemInstances)
+end Eq
+```
+
+we can test this relative to a simple ADT like so,
+
+```scala
+enum Opt[+T] derives Eq:
+  case Sm(t: T)
+  case Nn
+
+@main def test(): Unit =
+  import Opt.*
+  val eqoi = summon[Eq[Opt[Int]]]
+  assert(eqoi.eqv(Sm(23), Sm(23)))
+  assert(!eqoi.eqv(Sm(23), Sm(13)))
+  assert(!eqoi.eqv(Sm(23), Nn))
+```
+
+In this case the code that is generated by the inline expansion for the derived `Eq` instance for `Opt` looks like the
+following, after a little polishing,
+
+```scala
+given derived$Eq[T](using eqT: Eq[T]): Eq[Opt[T]] =
+  eqSum(
+    summon[Mirror[Opt[T]]],
+    List(
+      eqProduct(summon[Mirror[Sm[T]]], List(summon[Eq[T]])),
+      eqProduct(summon[Mirror[Nn.type]], Nil)
+    )
+  )
+```
+
+Alternative approaches can be taken to the way that `derived` methods can be defined. For example, more aggressively
+inlined variants using Scala 3 macros, whilst being more involved for type class authors to write than the example
+above, can produce code for type classes like `Eq` which eliminate all the abstraction artefacts (eg. the `Lists` of
+child instances in the above) and generate code which is indistinguishable from what a programmer might write by hand.
+As a third example, using a higher level library such as Shapeless the type class author could define an equivalent
+`derived` method as,
+
+```scala
+given eqSum[A](using inst: => K0.CoproductInstances[Eq, A]): Eq[A] with
+  def eqv(x: A, y: A): Boolean = inst.fold2(x, y)(false)(
+    [t] => (eqt: Eq[t], t0: t, t1: t) => eqt.eqv(t0, t1)
+  )
+
+given eqProduct[A](using inst: K0.ProductInstances[Eq, A]): Eq[A] with
+  def eqv(x: A, y: A): Boolean = inst.foldLeft2(x, y)(true: Boolean)(
+    [t] => (acc: Boolean, eqt: Eq[t], t0: t, t1: t) =>
+      Complete(!eqt.eqv(t0, t1))(false)(true)
+  )
+
+inline def derived[A](using gen: K0.Generic[A]): Eq[A] =
+  gen.derive(eqProduct, eqSum)
+```
+
+The framework described here enables all three of these approaches without mandating any of them.
+
+For a brief discussion on how to use macros to write a type class `derived`
+method please read more at [How to write a type class `derived` method using macros](./derivation-macro.md).
+
+## Deriving instances elsewhere
+
+Sometimes one would like to derive a type class instance for an ADT after the ADT is defined, without being able to
+change the code of the ADT itself.  To do this, simply define an instance using the `derived` method of the type class
+as right-hand side. E.g, to implement `Ordering` for `Option` define,
+
+```scala
+given [T: Ordering]: Ordering[Option[T]] = Ordering.derived
+```
+
+Assuming the `Ordering.derived` method has a context parameter of type `Mirror[T]` it will be satisfied by the
+compiler generated `Mirror` instance for `Option` and the derivation of the instance will be expanded on the right
+hand side of this definition in the same way as an instance defined in ADT companion objects.
+
+## Syntax
+
+```
+Template          ::=  InheritClauses [TemplateBody]
+EnumDef           ::=  id ClassConstr InheritClauses EnumBody
+InheritClauses    ::=  [‘extends’ ConstrApps] [‘derives’ QualId {‘,’ QualId}]
+ConstrApps        ::=  ConstrApp {‘with’ ConstrApp}
+                    |  ConstrApp {‘,’ ConstrApp}
+```
+
+**Note:** To align `extends` clauses and `derives` clauses, Scala 3 also allows multiple
+extended types to be separated by commas. So the following is now legal:
+
+```scala
+class A extends B, C { ... }
+```
+
+It is equivalent to the old form
+
+```scala
+class A extends B with C { ... }
+```
+
+## Discussion
+
+This type class derivation framework is intentionally very small and low-level. There are essentially two pieces of
+infrastructure in compiler-generated `Mirror` instances,
+
++ type members encoding properties of the mirrored types.
++ a minimal value level mechanism for working generically with terms of the mirrored types.
+
+The `Mirror` infrastructure can be seen as an extension of the existing `Product` infrastructure for case classes:
+typically `Mirror` types will be implemented by the ADTs companion object, hence the type members and the `ordinal` or
+`fromProduct` methods will be members of that object. The primary motivation for this design decision, and the
+decision to encode properties via types rather than terms was to keep the bytecode and runtime footprint of the
+feature small enough to make it possible to provide `Mirror` instances _unconditionally_.
+
+Whilst `Mirrors` encode properties precisely via type members, the value level `ordinal` and `fromProduct` are
+somewhat weakly typed (because they are defined in terms of `MirroredMonoType`) just like the members of `Product`.
+This means that code for generic type classes has to ensure that type exploration and value selection proceed in
+lockstep and it has to assert this conformance in some places using casts. If generic type classes are correctly
+written these casts will never fail.
+
+As mentioned, however, the compiler-provided mechanism is intentionally very low level and it is anticipated that
+higher level type class derivation and generic programming libraries will build on this and Scala 3's other
+metaprogramming facilities to hide these low-level details from type class authors and general users. Type class
+derivation in the style of both Shapeless and Magnolia are possible (a prototype of Shapeless 3, which combines
+aspects of both Shapeless 2 and Magnolia has been developed alongside this language feature) as is a more aggressively
+inlined style, supported by Scala 3's new quote/splice macro and inlining facilities.
diff --git a/docs/_spec/TODOreference/contextual/extension-methods.md b/docs/_spec/TODOreference/contextual/extension-methods.md
new file mode 100644
index 000000000000..d23cadf513d7
--- /dev/null
+++ b/docs/_spec/TODOreference/contextual/extension-methods.md
@@ -0,0 +1,306 @@
+---
+layout: doc-page
+title: "Extension Methods"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/contextual/extension-methods.html
+---
+
+Extension methods allow one to add methods to a type after the type is defined. Example:
+
+```scala
+case class Circle(x: Double, y: Double, radius: Double)
+
+extension (c: Circle)
+  def circumference: Double = c.radius * math.Pi * 2
+```
+
+Like regular methods, extension methods can be invoked with infix `.`:
+
+```scala
+val circle = Circle(0, 0, 1)
+circle.circumference
+```
+
+## Translation of Extension Methods
+
+An extension method translates to a specially labelled method that takes the leading parameter section as its first argument list. The label, expressed
+as `<extension>` here, is compiler-internal. So, the definition of `circumference` above translates to the following method, and can also be invoked as such:
+
+```
+<extension> def circumference(c: Circle): Double = c.radius * math.Pi * 2
+
+assert(circle.circumference == circumference(circle))
+```
+
+## Operators
+
+The extension method syntax can also be used to define operators. Examples:
+
+```scala
+extension (x: String)
+  def < (y: String): Boolean = ...
+extension (x: Elem)
+  def +: (xs: Seq[Elem]): Seq[Elem] = ...
+extension (x: Number)
+  infix def min (y: Number): Number = ...
+
+"ab" < "c"
+1 +: List(2, 3)
+x min 3
+```
+
+The three definitions above translate to
+
+```
+<extension> def < (x: String)(y: String): Boolean = ...
+<extension> def +: (xs: Seq[Elem])(x: Elem): Seq[Elem] = ...
+<extension> infix def min(x: Number)(y: Number): Number = ...
+```
+
+Note the swap of the two parameters `x` and `xs` when translating
+the right-associative operator `+:` to an extension method. This is analogous
+to the implementation of right binding operators as normal methods. The Scala
+compiler preprocesses an infix operation `x +: xs` to `xs.+:(x)`, so the extension
+method ends up being applied to the sequence as first argument (in other words, the
+two swaps cancel each other out). See [here for details](./right-associative-extension-methods.md).
+
+## Generic Extensions
+
+It is also possible to extend generic types by adding type parameters to an extension. For instance:
+
+```scala
+extension [T](xs: List[T])
+  def second = xs.tail.head
+
+extension [T: Numeric](x: T)
+  def + (y: T): T = summon[Numeric[T]].plus(x, y)
+```
+
+Type parameters on extensions can also be combined with type parameters on the methods
+themselves:
+
+```scala
+extension [T](xs: List[T])
+  def sumBy[U: Numeric](f: T => U): U = ...
+```
+
+Type arguments matching method type parameters are passed as usual:
+
+```scala
+List("a", "bb", "ccc").sumBy[Int](_.length)
+```
+
+By contrast, type arguments matching type parameters following `extension` can be passed
+only if the method is referenced as a non-extension method:
+
+```scala
+sumBy[String](List("a", "bb", "ccc"))(_.length)
+```
+
+Or, when passing both type arguments:
+
+```scala
+sumBy[String](List("a", "bb", "ccc"))[Int](_.length)
+```
+
+Extensions can also take using clauses. For instance, the `+` extension above could equivalently be written with a using clause:
+
+```scala
+extension [T](x: T)(using n: Numeric[T])
+  def + (y: T): T = n.plus(x, y)
+```
+
+## Collective Extensions
+
+Sometimes, one wants to define several extension methods that share the same
+left-hand parameter type. In this case one can "pull out" the common parameters into
+a single extension and enclose all methods in braces or an indented region.
+Example:
+
+```scala
+extension (ss: Seq[String])
+
+  def longestStrings: Seq[String] =
+    val maxLength = ss.map(_.length).max
+    ss.filter(_.length == maxLength)
+
+  def longestString: String = longestStrings.head
+```
+
+The same can be written with braces as follows (note that indented regions can still be used inside braces):
+
+```scala
+extension (ss: Seq[String]) {
+
+  def longestStrings: Seq[String] = {
+    val maxLength = ss.map(_.length).max
+    ss.filter(_.length == maxLength)
+  }
+
+  def longestString: String = longestStrings.head
+}
+```
+
+Note the right-hand side of `longestString`: it calls `longestStrings` directly, implicitly
+assuming the common extended value `ss` as receiver.
+
+Collective extensions like these are a shorthand for individual extensions
+where each method is defined separately. For instance, the first extension above expands to:
+
+```scala
+extension (ss: Seq[String])
+  def longestStrings: Seq[String] =
+    val maxLength = ss.map(_.length).max
+    ss.filter(_.length == maxLength)
+
+extension (ss: Seq[String])
+  def longestString: String = ss.longestStrings.head
+```
+
+Collective extensions also can take type parameters and have using clauses. Example:
+
+```scala
+extension [T](xs: List[T])(using Ordering[T])
+  def smallest(n: Int): List[T] = xs.sorted.take(n)
+  def smallestIndices(n: Int): List[Int] =
+    val limit = smallest(n).max
+    xs.zipWithIndex.collect { case (x, i) if x <= limit => i }
+```
+
+## Translation of Calls to Extension Methods
+
+To convert a reference to an extension method, the compiler has to know about the extension
+method. We say in this case that the extension method is _applicable_ at the point of reference.
+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.
+ 2. The extension method is a member of some given
+    instance that is visible at the point of the reference.
+ 3. The reference is of the form `r.m` and the extension method
+    is defined in the implicit scope of the type of `r`.
+ 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`.
+
+Here is an example for the first rule:
+
+```scala
+trait IntOps:
+  extension (i: Int) def isZero: Boolean = i == 0
+
+  extension (i: Int) def safeMod(x: Int): Option[Int] =
+    // extension method defined in same scope IntOps
+    if x.isZero then None
+    else Some(i % x)
+
+object IntOpsEx extends IntOps:
+  extension (i: Int) def safeDiv(x: Int): Option[Int] =
+    // extension method brought into scope via inheritance from IntOps
+    if x.isZero then None
+    else Some(i / x)
+
+trait SafeDiv:
+  import IntOpsEx.* // brings safeDiv and safeMod into scope
+
+  extension (i: Int) def divide(d: Int): Option[(Int, Int)] =
+    // extension methods imported and thus in scope
+    (i.safeDiv(d), i.safeMod(d)) match
+      case (Some(d), Some(r)) => Some((d, r))
+      case _ => None
+```
+
+By the second rule, an extension method can be made available by defining a given instance containing it, like this:
+
+```scala
+given ops1: IntOps()  // brings safeMod into scope
+
+1.safeMod(2)
+```
+
+By the third and fourth rule, an extension method is available if it is in the implicit scope of the receiver type or in a given instance in that scope. Example:
+
+```scala
+class List[T]:
+  ...
+object List:
+  ...
+  extension [T](xs: List[List[T]])
+    def flatten: List[T] = xs.foldLeft(List.empty[T])(_ ++ _)
+
+  given [T: Ordering]: Ordering[List[T]] with
+    extension (xs: List[T])
+      def < (ys: List[T]): Boolean = ...
+end List
+
+// extension method available since it is in the implicit scope
+// of List[List[Int]]
+List(List(1, 2), List(3, 4)).flatten
+
+// extension method available since it is in the given Ordering[List[T]],
+// which is itself in the implicit scope of List[Int]
+List(1, 2) < List(3)
+```
+
+The precise rules for resolving a selection to an extension method are as follows.
+
+Assume a selection `e.m[Ts]` where `m` is not a member of `e`, where the type arguments `[Ts]` are optional, and where `T` is the expected type.
+The following two rewritings are tried in order:
+
+ 1. The selection is rewritten to `m[Ts](e)`.
+ 2. If the first rewriting does not typecheck with expected type `T`,
+    and there is an extension method `m` in some eligible object `o`, the selection is rewritten to `o.m[Ts](e)`. An object `o` is _eligible_ if
+
+    - `o` forms part of the implicit scope of `T`, or
+    - `o` is a given instance that is visible at the point of the application, or
+    - `o` is a given instance in the implicit scope of `T`.
+
+    This second rewriting is attempted at the time where the compiler also tries an implicit conversion
+    from `T` to a type containing `m`. If there is more than one way of rewriting, an ambiguity error results.
+
+An extension method can also be referenced using a simple identifier without a preceding expression. If an identifier `g` appears in the body of an extension method `f` and refers to an extension method `g` that is defined in the same collective extension
+
+```scala
+extension (x: T)
+  def f ... = ... g ...
+  def g ...
+```
+
+the identifier is rewritten to `x.g`. This is also the case if `f` and `g` are the same method. Example:
+
+```scala
+extension (s: String)
+  def position(ch: Char, n: Int): Int =
+    if n < s.length && s(n) != ch then position(ch, n + 1)
+    else n
+```
+
+The recursive call `position(ch, n + 1)` expands to `s.position(ch, n + 1)` in this case. The whole extension method rewrites to
+
+```scala
+def position(s: String)(ch: Char, n: Int): Int =
+  if n < s.length && s(n) != ch then position(s)(ch, n + 1)
+  else n
+```
+
+## Syntax
+
+Here are the syntax changes for extension methods and collective extensions relative
+to the [current syntax](../syntax.md).
+
+```
+BlockStat         ::=  ... | Extension
+TemplateStat      ::=  ... | Extension
+TopStat           ::=  ... | Extension
+Extension         ::=  ‘extension’ [DefTypeParamClause] {UsingParamClause}
+                       ‘(’ DefParam ‘)’ {UsingParamClause} ExtMethods
+ExtMethods        ::=  ExtMethod | [nl] <<< ExtMethod {semi ExtMethod} >>>
+ExtMethod         ::=  {Annotation [nl]} {Modifier} ‘def’ DefDef
+```
+
+In the above the notation `<<< ts >>>` in the production rule `ExtMethods` is defined as follows :
+
+```
+<<< ts >>>        ::=  ‘{’ ts ‘}’ | indent ts outdent
+```
+
+`extension` is a soft keyword. It is recognized as a keyword only if it appears
+at the start of a statement and is followed by `[` or `(`. In all other cases
+it is treated as an identifier.
diff --git a/docs/_spec/TODOreference/contextual/given-imports.md b/docs/_spec/TODOreference/contextual/given-imports.md
new file mode 100644
index 000000000000..6a55368979b1
--- /dev/null
+++ b/docs/_spec/TODOreference/contextual/given-imports.md
@@ -0,0 +1,117 @@
+---
+layout: doc-page
+title: "Importing Givens"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/contextual/given-imports.html
+---
+
+A special form of import wildcard selector is used to import given instances. Example:
+
+```scala
+object A:
+  class TC
+  given tc: TC = ???
+  def f(using TC) = ???
+
+object B:
+  import A.*
+  import A.given
+  ...
+```
+
+In the code above, the `import A.*` clause in object `B` imports all members
+of `A` _except_ the given instance `tc`. Conversely, the second import `import A.given` will import _only_ that given instance.
+The two import clauses can also be merged into one:
+
+```scala
+object B:
+  import A.{given, *}
+   ...
+```
+
+Generally, a normal wildcard selector `*` brings all definitions other than givens or extensions into scope
+whereas a `given` selector brings all givens (including those resulting from extensions) into scope.
+
+There are two main benefits arising from these rules:
+
+- It is made clearer where givens in scope are coming from.
+  In particular, it is not possible to hide imported givens in a long list of regular wildcard imports.
+- It enables importing all givens
+  without importing anything else. This is particularly important since givens
+  can be anonymous, so the usual recourse of using named imports is not
+  practical.
+
+## Importing By Type
+
+Since givens can be anonymous it is not always practical to import them by their name, and wildcard imports are typically used instead. By-type imports provide a more specific alternative to wildcard imports, which makes it clearer what is imported. Example:
+
+```scala
+import A.given TC
+```
+
+This imports any given in `A` that has a type which conforms to `TC`. Importing givens of several types `T1,...,Tn`
+is expressed by multiple `given` selectors.
+
+```scala
+import A.{given T1, ..., given Tn}
+```
+
+Importing all given instances of a parameterized type is expressed by wildcard arguments.
+For instance, assuming the object
+
+```scala
+object Instances:
+  given intOrd: Ordering[Int] = ...
+  given listOrd[T: Ordering]: Ordering[List[T]] = ...
+  given ec: ExecutionContext = ...
+  given im: Monoid[Int] = ...
+```
+
+the import clause
+
+```scala
+import Instances.{given Ordering[?], given ExecutionContext}
+```
+
+would import the `intOrd`, `listOrd`, and `ec` instances but leave out the `im` instance, since it fits none of the specified bounds.
+
+By-type imports can be mixed with by-name imports. If both are present in an import clause, by-type imports come last. For instance, the import clause
+
+```scala
+import Instances.{im, given Ordering[?]}
+```
+
+would import `im`, `intOrd`, and `listOrd` but leave out `ec`.
+
+## Migration
+
+The rules for imports stated above have the consequence that a library
+would have to migrate in lockstep with all its users from old style implicits and
+normal imports to givens and given imports.
+
+The following modifications avoid this hurdle to migration.
+
+ 1. A `given` import selector also brings old style implicits into scope. So, in Scala 3.0
+    an old-style implicit definition can be brought into scope either by a `*` or a `given` wildcard selector.
+
+ 2. In Scala 3.1, old-style implicits accessed through a `*` wildcard import will give a deprecation warning.
+
+ 3. In some version after 3.1, old-style implicits accessed through a `*` wildcard import will give a compiler error.
+
+These rules mean that library users can use `given` selectors to access old-style implicits in Scala 3.0,
+and will be gently nudged and then forced to do so in later versions. Libraries can then switch to
+given instances once their user base has migrated.
+
+## Syntax
+
+```
+Import            ::=  ‘import’ ImportExpr {‘,’ ImportExpr}
+Export            ::=  ‘export’ ImportExpr {‘,’ ImportExpr}
+ImportExpr        ::=  SimpleRef {‘.’ id} ‘.’ ImportSpec
+ImportSpec        ::=  NamedSelector
+                    |  WildcardSelector
+                    | ‘{’ ImportSelectors) ‘}’
+NamedSelector     ::=  id [‘as’ (id | ‘_’)]
+WildCardSelector  ::=  ‘*' | ‘given’ [InfixType]
+ImportSelectors   ::=  NamedSelector [‘,’ ImportSelectors]
+                    |  WildCardSelector {‘,’ WildCardSelector}
+```
diff --git a/docs/_spec/TODOreference/contextual/givens.md b/docs/_spec/TODOreference/contextual/givens.md
new file mode 100644
index 000000000000..411d50ba63ea
--- /dev/null
+++ b/docs/_spec/TODOreference/contextual/givens.md
@@ -0,0 +1,193 @@
+---
+layout: doc-page
+title: "Given Instances"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/contextual/givens.html
+---
+
+Given instances (or, simply, "givens") define "canonical" values of certain types
+that serve for synthesizing arguments to [context parameters](./using-clauses.md). Example:
+
+```scala
+trait Ord[T]:
+  def compare(x: T, y: T): Int
+  extension (x: T) def < (y: T) = compare(x, y) < 0
+  extension (x: T) def > (y: T) = compare(x, y) > 0
+
+given intOrd: Ord[Int] with
+  def compare(x: Int, y: Int) =
+    if x < y then -1 else if x > y then +1 else 0
+
+given listOrd[T](using ord: Ord[T]): Ord[List[T]] with
+
+  def compare(xs: List[T], ys: List[T]): Int = (xs, ys) match
+    case (Nil, Nil) => 0
+    case (Nil, _) => -1
+    case (_, Nil) => +1
+    case (x :: xs1, y :: ys1) =>
+      val fst = ord.compare(x, y)
+      if fst != 0 then fst else compare(xs1, ys1)
+
+```
+
+This code defines a trait `Ord` with two given instances. `intOrd` defines
+a given for the type `Ord[Int]` whereas `listOrd[T]` defines givens
+for `Ord[List[T]]` for all types `T` that come with a given instance for `Ord[T]`
+themselves. The `using` clause in `listOrd` defines a condition: There must be a
+given of type `Ord[T]` for a given of type `Ord[List[T]]` to exist.
+Such conditions are expanded by the compiler to [context parameters](./using-clauses.md).
+
+## Anonymous Givens
+
+The name of a given can be left out. So the definitions
+of the last section can also be expressed like this:
+
+```scala
+given Ord[Int] with
+  ...
+given [T](using Ord[T]): Ord[List[T]] with
+  ...
+```
+
+If the name of a given is missing, the compiler will synthesize a name from
+the implemented type(s).
+
+**Note** The name synthesized by the compiler is chosen to be readable and reasonably concise. For instance, the two instances above would get the names:
+
+```scala
+given_Ord_Int
+given_Ord_List
+```
+
+The precise rules for synthesizing names are found [here](./relationship-implicits.html#anonymous-given-instances). These rules do not guarantee absence of name conflicts between
+given instances of types that are "too similar". To avoid conflicts one can
+use named instances.
+
+**Note** To ensure robust binary compatibility, publicly available libraries should prefer named instances.
+
+## Alias Givens
+
+An alias can be used to define a given instance that is equal to some expression. Example:
+
+```scala
+given global: ExecutionContext = ForkJoinPool()
+```
+
+This creates a given `global` of type `ExecutionContext` that resolves to the right
+hand side `ForkJoinPool()`.
+The first time `global` is accessed, a new `ForkJoinPool` is created, which is then
+returned for this and all subsequent accesses to `global`. This operation is thread-safe.
+
+Alias givens can be anonymous as well, e.g.
+
+```scala
+given Position = enclosingTree.position
+given (using config: Config): Factory = MemoizingFactory(config)
+```
+
+An alias given can have type parameters and context parameters just like any other given,
+but it can only implement a single type.
+
+## Given Macros
+
+Given aliases can have the `inline` and `transparent` modifiers.
+Example:
+
+```scala
+transparent inline given mkAnnotations[A, T]: Annotations[A, T] = ${
+  // code producing a value of a subtype of Annotations
+}
+```
+
+Since `mkAnnotations` is `transparent`, the type of an application is the type of its right-hand side, which can be a proper subtype of the declared result type `Annotations[A, T]`.
+
+Given instances can have the `inline` but not `transparent` modifiers as their type is already known from the signature.
+Example:
+
+```scala
+trait Show[T] {
+  inline def show(x: T): String
+}
+
+inline given Show[Foo] with {
+  /*transparent*/ inline def show(x: Foo): String = ${ ... }
+}
+
+def app =
+  // inlines `show` method call and removes the call to `given Show[Foo]`
+  summon[Show[Foo]].show(foo)
+```
+Note that the inline methods within the given instances may be `transparent`.
+
+The inlining of given instances will not inline/duplicate the implementation of the given, it will just inline the instantiation of that instance.
+This is used to help dead code elimination of the given instances that are not used after inlining.
+
+
+## Pattern-Bound Given Instances
+
+Given instances can also appear in patterns. Example:
+
+```scala
+for given Context <- applicationContexts do
+
+pair match
+  case (ctx @ given Context, y) => ...
+```
+
+In the first fragment above, anonymous given instances for class `Context` are established by enumerating over `applicationContexts`. In the second fragment, a given `Context`
+instance named `ctx` is established by matching against the first half of the `pair` selector.
+
+In each case, a pattern-bound given instance consists of `given` and a type `T`. The pattern matches exactly the same selectors as the type ascription pattern `_: T`.
+
+## Negated Givens
+
+Scala 2's somewhat puzzling behavior with respect to ambiguity has been exploited to implement the analogue of a "negated" search in implicit resolution,
+where a query Q1 fails if some other query Q2 succeeds and Q1 succeeds if Q2 fails. With the new cleaned up behavior these techniques no longer work.
+But the new special type [`scala.util.NotGiven`](https://scala-lang.org/api/3.x/scala/util/NotGiven.html) now implements negation directly.
+
+For any query type `Q`, [`NotGiven[Q]`](https://scala-lang.org/api/3.x/scala/util/NotGiven.html) succeeds if and only if the implicit
+search for `Q` fails, for example:
+
+```scala
+import scala.util.NotGiven
+
+trait Tagged[A]
+
+case class Foo[A](value: Boolean)
+object Foo:
+  given fooTagged[A](using Tagged[A]): Foo[A] = Foo(true)
+  given fooNotTagged[A](using NotGiven[Tagged[A]]): Foo[A] = Foo(false)
+
+@main def test(): Unit =
+  given Tagged[Int]()
+  assert(summon[Foo[Int]].value) // fooTagged is found
+  assert(!summon[Foo[String]].value) // fooNotTagged is found
+```
+
+## Given Instance Initialization
+
+A given instance without type or context parameters is initialized on-demand, the first
+time it is accessed. If a given has type or context parameters, a fresh instance
+is created for each reference.
+
+## Syntax
+
+Here is the syntax for given instances:
+
+```
+TmplDef             ::=  ...
+                     |   ‘given’ GivenDef
+GivenDef            ::=  [GivenSig] StructuralInstance
+                     |   [GivenSig] AnnotType ‘=’ Expr
+                     |   [GivenSig] AnnotType
+GivenSig            ::=  [id] [DefTypeParamClause] {UsingParamClause} ‘:’
+StructuralInstance  ::=  ConstrApp {‘with’ ConstrApp} ‘with’ TemplateBody
+```
+
+A given instance starts with the reserved word `given` and an optional _signature_. The signature
+defines a name and/or parameters for the instance. It is followed by `:`. There are three kinds
+of given instances:
+
+- A _structural instance_ contains one or more types or constructor applications,
+  followed by `with` and a template body that contains member definitions of the instance.
+- An _alias instance_ contains a type, followed by `=` and a right-hand side expression.
+- An _abstract instance_ contains just the type, which is not followed by anything.
diff --git a/docs/_spec/TODOreference/contextual/multiversal-equality.md b/docs/_spec/TODOreference/contextual/multiversal-equality.md
new file mode 100644
index 000000000000..e9a81b95f472
--- /dev/null
+++ b/docs/_spec/TODOreference/contextual/multiversal-equality.md
@@ -0,0 +1,227 @@
+---
+layout: doc-page
+title: "Multiversal Equality"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/contextual/multiversal-equality.html
+---
+
+Previously, Scala had universal equality: Two values of any types
+could be compared with each other with `==` and `!=`. This came from
+the fact that `==` and `!=` are implemented in terms of Java's
+`equals` method, which can also compare values of any two reference
+types.
+
+Universal equality is convenient. But it is also dangerous since it
+undermines type safety. For instance, let's assume one is left after some refactoring
+with an erroneous program where a value `y` has type `S` instead of the correct type `T`.
+
+```scala
+val x = ... // of type T
+val y = ... // of type S, but should be T
+x == y      // typechecks, will always yield false
+```
+
+If `y` gets compared to other values of type `T`,
+the program will still typecheck, since values of all types can be compared with each other.
+But it will probably give unexpected results and fail at runtime.
+
+Multiversal equality is an opt-in way to make universal equality safer.
+It uses a binary type class [`scala.CanEqual`](https://github.com/lampepfl/dotty/blob/main/library/src/scala/CanEqual.scala)
+to indicate that values of two given types can be compared with each other.
+The example above would not typecheck if `S` or `T` was a class
+that derives `CanEqual`, e.g.
+
+```scala
+class T derives CanEqual
+```
+
+Alternatively, one can also provide a `CanEqual` given instance directly, like this:
+
+```scala
+given CanEqual[T, T] = CanEqual.derived
+```
+
+This definition effectively says that values of type `T` can (only) be
+compared to other values of type `T` when using `==` or `!=`. The definition
+affects type checking but it has no significance for runtime
+behavior, since `==` always maps to `equals` and `!=` always maps to
+the negation of `equals`. The right-hand side `CanEqual.derived` of the definition
+is a value that has any `CanEqual` instance as its type. Here is the definition of class
+`CanEqual` and its companion object:
+
+```scala
+package scala
+import annotation.implicitNotFound
+
+@implicitNotFound("Values of types ${L} and ${R} cannot be compared with == or !=")
+sealed trait CanEqual[-L, -R]
+
+object CanEqual:
+  object derived extends CanEqual[Any, Any]
+```
+
+One can have several `CanEqual` given instances for a type. For example, the four
+definitions below make values of type `A` and type `B` comparable with
+each other, but not comparable to anything else:
+
+```scala
+given CanEqual[A, A] = CanEqual.derived
+given CanEqual[B, B] = CanEqual.derived
+given CanEqual[A, B] = CanEqual.derived
+given CanEqual[B, A] = CanEqual.derived
+```
+
+The [`scala.CanEqual`](https://github.com/lampepfl/dotty/blob/main/library/src/scala/CanEqual.scala)
+object defines a number of `CanEqual` given instances that together
+define a rule book for what standard types can be compared (more details below).
+
+There is also a "fallback" instance named `canEqualAny` that allows comparisons
+over all types that do not themselves have a `CanEqual` given.  `canEqualAny` is defined as follows:
+
+```scala
+def canEqualAny[L, R]: CanEqual[L, R] = CanEqual.derived
+```
+
+Even though `canEqualAny` is not declared as `given`, the compiler will still
+construct an `canEqualAny` instance as answer to an implicit search for the
+type `CanEqual[L, R]`, unless `L` or `R` have `CanEqual` instances
+defined on them, or the language feature `strictEquality` is enabled.
+
+The primary motivation for having `canEqualAny` is backwards compatibility.
+If this is of no concern, one can disable `canEqualAny` by enabling the language
+feature `strictEquality`. As for all language features this can be either
+done with an import
+
+```scala
+import scala.language.strictEquality
+```
+or with a command line option `-language:strictEquality`.
+
+## Deriving CanEqual Instances
+
+Instead of defining `CanEqual` instances directly, it is often more convenient to derive them. Example:
+
+```scala
+class Box[T](x: T) derives CanEqual
+```
+
+By the usual rules of [type class derivation](./derivation.md),
+this generates the following `CanEqual` instance in the companion object of `Box`:
+
+```scala
+given [T, U](using CanEqual[T, U]): CanEqual[Box[T], Box[U]] =
+  CanEqual.derived
+```
+
+That is, two boxes are comparable with `==` or `!=` if their elements are. Examples:
+
+```scala
+new Box(1) == new Box(1L)   // ok since there is an instance for `CanEqual[Int, Long]`
+new Box(1) == new Box("a")  // error: can't compare
+new Box(1) == 1             // error: can't compare
+```
+
+## Precise Rules for Equality Checking
+
+The precise rules for equality checking are as follows.
+
+If the `strictEquality` feature is enabled then
+a comparison using `x == y` or `x != y` between values `x: T` and `y: U`
+is legal if there is a `given` of type `CanEqual[T, U]`.
+
+In the default case where the `strictEquality` feature is not enabled the comparison is
+also legal if
+
+ 1. `T` and `U` are the same, or
+ 2. one of `T`, `U` is a subtype of the _lifted_ version of the other type, or
+ 3. neither `T` nor `U` have a _reflexive_ `CanEqual` instance.
+
+Explanations:
+
+ - _lifting_ a type `S` means replacing all references to abstract types
+   in covariant positions of `S` by their upper bound, and replacing
+   all refinement types in covariant positions of `S` by their parent.
+ - a type `T` has a _reflexive_ `CanEqual` instance if the implicit search for `CanEqual[T, T]`
+   succeeds.
+
+## Predefined CanEqual Instances
+
+The `CanEqual` object defines instances for comparing
+ - the primitive types `Byte`, `Short`, `Char`, `Int`, `Long`, `Float`, `Double`, `Boolean`,  and `Unit`,
+ - `java.lang.Number`, `java.lang.Boolean`, and `java.lang.Character`,
+ - `scala.collection.Seq`, and `scala.collection.Set`.
+
+Instances are defined so that every one of these types has a _reflexive_ `CanEqual` instance, and the following holds:
+
+ - Primitive numeric types can be compared with each other.
+ - Primitive numeric types can be compared with subtypes of `java.lang.Number` (and _vice versa_).
+ - `Boolean` can be compared with `java.lang.Boolean` (and _vice versa_).
+ - `Char` can be compared with `java.lang.Character` (and _vice versa_).
+ - Two sequences (of arbitrary subtypes of `scala.collection.Seq`) can be compared
+   with each other if their element types can be compared. The two sequence types
+   need not be the same.
+ - Two sets (of arbitrary subtypes of `scala.collection.Set`) can be compared
+   with each other if their element types can be compared. The two set types
+   need not be the same.
+ - Any subtype of `AnyRef` can be compared with `Null` (and _vice versa_).
+
+## Why Two Type Parameters?
+
+One particular feature of the `CanEqual` type is that it takes _two_ type parameters, representing the types of the two items to be compared. By contrast, conventional
+implementations of an equality type class take only a single type parameter which represents the common type of _both_ operands.
+One type parameter is simpler than two, so why go through the additional complication? The reason has to do with the fact that, rather than coming up with a type class where no operation existed before,
+we are dealing with a refinement of pre-existing, universal equality. It is best illustrated through an example.
+
+Say you want to come up with a safe version of the `contains` method on `List[T]`. The original definition of `contains` in the standard library was:
+```scala
+class List[+T]:
+  ...
+  def contains(x: Any): Boolean
+```
+That uses universal equality in an unsafe way since it permits arguments of any type to be compared with the list's elements. The "obvious" alternative definition
+```scala
+  def contains(x: T): Boolean
+```
+does not work, since it refers to the covariant parameter `T` in a nonvariant context. The only variance-correct way to use the type parameter `T` in `contains` is as a lower bound:
+```scala
+  def contains[U >: T](x: U): Boolean
+```
+This generic version of `contains` is the one used in the current (Scala 2.13) version of `List`.
+It looks different but it admits exactly the same applications as the `contains(x: Any)` definition we started with.
+However, we can make it more useful (i.e. restrictive) by adding a `CanEqual` parameter:
+```scala
+  def contains[U >: T](x: U)(using CanEqual[T, U]): Boolean // (1)
+```
+This version of `contains` is equality-safe! More precisely, given
+`x: T`, `xs: List[T]` and `y: U`, then `xs.contains(y)` is type-correct if and only if
+`x == y` is type-correct.
+
+Unfortunately, the crucial ability to "lift" equality type checking from simple equality and pattern matching to arbitrary user-defined operations gets lost if we restrict ourselves to an equality class with a single type parameter. Consider the following signature of `contains` with a hypothetical `CanEqual1[T]` type class:
+```scala
+  def contains[U >: T](x: U)(using CanEqual1[U]): Boolean   // (2)
+```
+This version could be applied just as widely as the original `contains(x: Any)` method,
+since the `CanEqual1[Any]` fallback is always available! So we have gained nothing. What got lost in the transition to a single parameter type class was the original rule that `CanEqual[A, B]` is available only if neither `A` nor `B` have a reflexive `CanEqual` instance. That rule simply cannot be expressed if there is a single type parameter for `CanEqual`.
+
+The situation is different under `-language:strictEquality`. In that case,
+the `CanEqual[Any, Any]` or `CanEqual1[Any]` instances would never be available, and the
+single and two-parameter versions would indeed coincide for most practical purposes.
+
+But assuming `-language:strictEquality` immediately and everywhere poses migration problems which might well be unsurmountable. Consider again `contains`, which is in the standard library. Parameterizing it with the `CanEqual` type class as in (1) is an immediate win since it rules out non-sensical applications while still allowing all sensible ones.
+So it can be done almost at any time, modulo binary compatibility concerns.
+On the other hand, parameterizing `contains` with `CanEqual1` as in (2) would make `contains`
+unusable for all types that have not yet declared a `CanEqual1` instance, including all
+types coming from Java. This is clearly unacceptable. It would lead to a situation where,
+rather than migrating existing libraries to use safe equality, the only upgrade path is to have parallel libraries, with the new version only catering to types deriving `CanEqual1` and the old version dealing with everything else. Such a split of the ecosystem would be very problematic, which means the cure is likely to be worse than the disease.
+
+For these reasons, it looks like a two-parameter type class is the only way forward because it can take the existing ecosystem where it is and migrate it towards a future where more and more code uses safe equality.
+
+In applications where `-language:strictEquality` is the default one could also introduce a one-parameter type alias such as
+```scala
+type Eq[-T] = CanEqual[T, T]
+```
+Operations needing safe equality could then use this alias instead of the two-parameter `CanEqual` class. But it would only
+work under `-language:strictEquality`, since otherwise the universal `Eq[Any]` instance would be available everywhere.
+
+
+More on multiversal equality is found in a [blog post](http://www.scala-lang.org/blog/2016/05/06/multiversal-equality.html)
+and a [GitHub issue](https://github.com/lampepfl/dotty/issues/1247).
diff --git a/docs/_spec/TODOreference/contextual/relationship-implicits.md b/docs/_spec/TODOreference/contextual/relationship-implicits.md
new file mode 100644
index 000000000000..fce07f51151a
--- /dev/null
+++ b/docs/_spec/TODOreference/contextual/relationship-implicits.md
@@ -0,0 +1,206 @@
+---
+layout: doc-page
+title: "Relationship with Scala 2 Implicits"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/contextual/relationship-implicits.html
+---
+
+Many, but not all, of the new contextual abstraction features in Scala 3 can be mapped to Scala 2's implicits. This page gives a rundown on the relationships between new and old features.
+
+## Simulating Scala 3 Contextual Abstraction Concepts with Scala 2 Implicits
+
+### Given Instances
+
+Given instances can be mapped to combinations of implicit objects, classes and implicit methods.
+
+ 1. Given instances without parameters are mapped to implicit objects. For instance,
+
+    ```scala
+    given intOrd: Ord[Int] with { ... }
+    ```
+
+    maps to
+
+    ```scala
+    implicit object intOrd extends Ord[Int] { ... }
+    ```
+
+ 2. Parameterized givens are mapped to combinations of classes and implicit methods. For instance,
+
+    ```scala
+    given listOrd[T](using ord: Ord[T]): Ord[List[T]] with { ... }
+    ```
+
+    maps to
+
+    ```scala
+    class listOrd[T](implicit ord: Ord[T]) extends Ord[List[T]] { ... }
+    final implicit def listOrd[T](implicit ord: Ord[T]): listOrd[T] =
+     new listOrd[T]
+    ```
+
+ 3. Alias givens map to implicit methods or implicit lazy vals. If an alias has neither type nor context parameters,
+    it is treated as a lazy val, unless the right-hand side is a simple reference, in which case we can use a forwarder to
+    that reference without caching it.
+
+Examples:
+
+```scala
+given global: ExecutionContext = new ForkJoinContext()
+
+val ctx: Context
+given Context = ctx
+```
+
+would map to
+
+```scala
+final implicit lazy val global: ExecutionContext = new ForkJoinContext()
+final implicit def given_Context = ctx
+```
+
+### Anonymous Given Instances
+
+Anonymous given instances get compiler synthesized names, which are generated in a reproducible way from the implemented type(s). For example, if the names of the `IntOrd` and `ListOrd` givens above were left out, the following names would be synthesized instead:
+
+```scala
+given given_Ord_Int: Ord[Int] with { ... }
+given given_Ord_List[T](using ord: Ord[T]): Ord[List[T]] with { ... }
+```
+
+The synthesized type names are formed from
+
+1. the prefix `given_`,
+2. the simple name(s) of the implemented type(s), leaving out any prefixes,
+3. the simple name(s) of the top-level argument type constructors to these types.
+
+Tuples are treated as transparent, i.e. a type `F[(X, Y)]` would get the synthesized name
+`F_X_Y`. Directly implemented function types `A => B` are represented as `A_to_B`. Function types used as arguments to other type constructors are represented as `Function`.
+
+### Using Clauses
+
+Using clauses correspond largely to Scala 2's implicit parameter clauses. E.g.
+
+```scala
+def max[T](x: T, y: T)(using ord: Ord[T]): T
+```
+
+would be written
+
+```scala
+def max[T](x: T, y: T)(implicit ord: Ord[T]): T
+```
+
+in Scala 2. The main difference concerns applications of such parameters.
+Explicit arguments to parameters of using clauses _must_ be written using `(using ...)`,
+mirroring the definition syntax. E.g, `max(2, 3)(using IntOrd)`.
+Scala 2 uses normal applications `max(2, 3)(IntOrd)` instead. The Scala 2 syntax has some inherent ambiguities and restrictions which are overcome by the new syntax. For instance, multiple implicit parameter lists are not available in the old syntax, even though they can be simulated using auxiliary objects in the "Aux" pattern.
+
+The `summon` method corresponds to `implicitly` in Scala 2.
+It is precisely the same as the `the` method in [Shapeless](https://github.com/milessabin/shapeless).
+The difference between `summon` (or `the`) and `implicitly` is
+that `summon` can return a more precise type than the type that was
+asked for.
+
+### Context Bounds
+
+Context bounds are the same in both language versions. They expand to the respective forms of implicit parameters.
+
+**Note:** To ease migration, context bounds in Scala 3 map for a limited time to old-style implicit parameters for which arguments can be passed either in a using clause or
+in a normal argument list. Once old-style implicits are deprecated, context bounds
+will map to using clauses instead.
+
+### Extension Methods
+
+Extension methods have no direct counterpart in Scala 2, but they can be simulated with implicit classes. For instance, the extension method
+
+```scala
+extension (c: Circle)
+  def circumference: Double = c.radius * math.Pi * 2
+```
+
+could be simulated to some degree by
+
+```scala
+implicit class CircleDecorator(c: Circle) extends AnyVal {
+  def circumference: Double = c.radius * math.Pi * 2
+}
+```
+
+Abstract extension methods in traits that are implemented in given instances have no direct counterpart in Scala 2. The only way to simulate these is to make implicit classes available through imports. The Simulacrum macro library can automate this process in some cases.
+
+### Type Class Derivation
+
+Type class derivation has no direct counterpart in the Scala 2 language. Comparable functionality can be achieved by macro-based libraries such as [Shapeless](https://github.com/milessabin/shapeless), [Magnolia](https://propensive.com/opensource/magnolia), or [scalaz-deriving](https://github.com/scalaz/scalaz-deriving).
+
+### Context Function Types
+
+Context function types have no analogue in Scala 2.
+
+### Implicit By-Name Parameters
+
+Implicit by-name parameters are not supported in Scala 2, but can be emulated to some degree by the `Lazy` type in Shapeless.
+
+## Simulating Scala 2 Implicits in Scala 3
+
+### Implicit Conversions
+
+Implicit conversion methods in Scala 2 can be expressed as given instances of the `scala.Conversion` class in Scala 3. For instance, instead of
+
+```scala
+implicit def stringToToken(str: String): Token = new Keyword(str)
+```
+
+one can write
+
+```scala
+given stringToToken: Conversion[String, Token] with
+  def apply(str: String): Token = KeyWord(str)
+```
+
+or
+
+```scala
+given stringToToken: Conversion[String, Token] = KeyWord(_)
+```
+
+### Implicit Classes
+
+Implicit classes in Scala 2 are often used to define extension methods, which are directly supported in Scala 3. Other uses of implicit classes can be simulated by a pair of a regular class and a given `Conversion` instance.
+
+### Implicit Values
+
+Implicit `val` definitions in Scala 2 can be expressed in Scala 3 using a regular `val` definition and an alias given.
+For instance, Scala 2's
+
+```scala
+lazy implicit val pos: Position = tree.sourcePos
+```
+
+can be expressed in Scala 3 as
+
+```scala
+lazy val pos: Position = tree.sourcePos
+given Position = pos
+```
+
+### Abstract Implicits
+
+An abstract implicit `val` or `def` in Scala 2 can be expressed in Scala 3 using a regular abstract definition and an alias given. For instance, Scala 2's
+
+```scala
+implicit def symDecorator: SymDecorator
+```
+
+can be expressed in Scala 3 as
+
+```scala
+def symDecorator: SymDecorator
+given SymDecorator = symDecorator
+```
+
+## Implementation Status and Timeline
+
+The Scala 3 implementation implements both Scala 2's implicits and the new abstractions. In fact, support for Scala 2's implicits is an essential part of the common language subset between 2.13 and Scala 3.
+Migration to the new abstractions will be supported by making automatic rewritings available.
+
+Depending on adoption patterns, old style implicits might start to be deprecated in a version following Scala 3.0.
diff --git a/docs/_spec/TODOreference/contextual/right-associative-extension-methods.md b/docs/_spec/TODOreference/contextual/right-associative-extension-methods.md
new file mode 100644
index 000000000000..068123df8cd2
--- /dev/null
+++ b/docs/_spec/TODOreference/contextual/right-associative-extension-methods.md
@@ -0,0 +1,52 @@
+---
+layout: doc-page
+title: "Right-Associative Extension Methods: Details"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/contextual/right-associative-extension-methods.html
+---
+
+The most general form of leading parameters of an extension method is as follows:
+
+  - A possibly empty list of using clauses `leadingUsing`
+  - A single parameter `extensionParam`
+  - A possibly empty list of using clauses `trailingUsing`
+
+This is then followed by `def`, the method name, and possibly further parameters
+`otherParams`. An example is:
+
+```scala
+  extension (using a: A, b: B)(using c: C)    // <-- leadingUsing
+            (x: X)                            // <-- extensionParam
+            (using d: D)                      // <-- trailingUsing
+    def +:: (y: Y)(using e: E)(z: Z)          // <-- otherParams
+```
+
+An extension method is treated as a right-associative operator
+(as in [SLS §6.12.3](https://www.scala-lang.org/files/archive/spec/2.13/06-expressions.html#infix-operations))
+if it has a name ending in `:` and is immediately followed by a
+single parameter. In the example above, that parameter is `(y: Y)`.
+
+The Scala compiler pre-processes a right-associative infix operation such as `x +: xs`
+to `xs.+:(x)` if `x` is a pure expression or a call-by-name parameter and to `val y = x; xs.+:(y)` otherwise. This is necessary since a regular right-associative infix method
+is defined in the class of its right operand. To make up for this swap,
+the expansion of right-associative extension methods performs an analogous parameter swap. More precisely, if `otherParams` consists of a single parameter
+`rightParam` followed by `remaining`, the total parameter sequence
+of the extension method's expansion is:
+
+```
+    leadingUsing  rightParam  trailingUsing  extensionParam  remaining
+```
+
+For instance, the `+::` method above would become
+
+```scala
+  <extension> def +:: (using a: A, b: B)(using c: C)
+                      (y: Y)
+                      (using d: D)
+                      (x: X)
+                      (using e: E)(z: Z)
+```
+
+This expansion has to be kept in mind when writing right-associative extension
+methods with inter-parameter dependencies.
+
+An overall simpler design could be obtained if right-associative operators could _only_ be defined as extension methods, and would be disallowed as normal methods. In that case neither arguments nor parameters would have to be swapped. Future versions of Scala should strive to achieve this simplification.
diff --git a/docs/_spec/TODOreference/contextual/type-classes.md b/docs/_spec/TODOreference/contextual/type-classes.md
new file mode 100644
index 000000000000..9fc0d2eec864
--- /dev/null
+++ b/docs/_spec/TODOreference/contextual/type-classes.md
@@ -0,0 +1,282 @@
+---
+layout: doc-page
+title: "Implementing Type classes"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/contextual/type-classes.html
+---
+
+A _type class_ is an abstract, parameterized type that lets you add new behavior to any closed data type without using sub-typing. This can be useful in multiple use-cases, for example:
+
+* expressing how a type you don't own (from the standard or 3rd-party library) conforms to such behavior
+* expressing such a behavior for multiple types without involving sub-typing relationships (one `extends` another) between those types (see: [ad hoc polymorphism](https://en.wikipedia.org/wiki/Ad_hoc_polymorphism) for instance)
+
+Therefore in Scala 3, _type classes_ are just _traits_ with one or more parameters whose implementations are not defined through the `extends` keyword, but by **given instances**.
+Here are some examples of common type classes:
+
+## Semigroups and monoids
+
+Here's the `Monoid` type class definition:
+
+```scala
+trait SemiGroup[T]:
+  extension (x: T) def combine (y: T): T
+
+trait Monoid[T] extends SemiGroup[T]:
+  def unit: T
+```
+
+An implementation of this `Monoid` type class for the type `String` can be the following:
+
+```scala
+given Monoid[String] with
+  extension (x: String) def combine (y: String): String = x.concat(y)
+  def unit: String = ""
+```
+
+Whereas for the type `Int` one could write the following:
+
+```scala
+given Monoid[Int] with
+  extension (x: Int) def combine (y: Int): Int = x + y
+  def unit: Int = 0
+```
+
+This monoid can now be used as _context bound_ in the following `combineAll` method:
+
+```scala
+def combineAll[T: Monoid](xs: List[T]): T =
+  xs.foldLeft(summon[Monoid[T]].unit)(_.combine(_))
+```
+
+To get rid of the `summon[...]` we can define a `Monoid` object as follows:
+
+```scala
+object Monoid:
+  def apply[T](using m: Monoid[T]) = m
+```
+
+Which would allow to re-write the `combineAll` method this way:
+
+```scala
+def combineAll[T: Monoid](xs: List[T]): T =
+  xs.foldLeft(Monoid[T].unit)(_.combine(_))
+```
+
+## Functors
+
+A `Functor` for a type provides the ability for its values to be "mapped over", i.e. apply a function that transforms inside a value while remembering its shape. For example, to modify every element of a collection without dropping or adding elements.
+We can represent all types that can be "mapped over" with `F`. It's a type constructor: the type of its values becomes concrete when provided a type argument.
+Therefore we write it `F[_]`, hinting that the type `F` takes another type as argument.
+The definition of a generic `Functor` would thus be written as:
+
+```scala
+trait Functor[F[_]]:
+  def map[A, B](x: F[A], f: A => B): F[B]
+```
+
+Which could read as follows: "A `Functor` for the type constructor `F[_]` represents the ability to transform `F[A]` to `F[B]` through the application of function `f` with type `A => B`". We call the `Functor` definition here a _type class_.
+This way, we could define an instance of `Functor` for the `List` type:
+
+```scala
+given Functor[List] with
+  def map[A, B](x: List[A], f: A => B): List[B] =
+    x.map(f) // List already has a `map` method
+```
+
+With this `given` instance in scope, everywhere a `Functor` is expected, the compiler will accept a `List` to be used.
+
+For instance, we may write such a testing method:
+
+```scala
+def assertTransformation[F[_]: Functor, A, B](expected: F[B], original: F[A], mapping: A => B): Unit =
+  assert(expected == summon[Functor[F]].map(original, mapping))
+```
+
+And use it this way, for example:
+
+```scala
+assertTransformation(List("a1", "b1"), List("a", "b"), elt => s"${elt}1")
+```
+
+That's a first step, but in practice we probably would like the `map` function to be a method directly accessible on the type `F`. So that we can call `map` directly on instances of `F`, and get rid of the `summon[Functor[F]]` part.
+As in the previous example of Monoids, [`extension` methods](extension-methods.md) help achieving that. Let's re-define the `Functor` type class with extension methods.
+
+```scala
+trait Functor[F[_]]:
+  extension [A](x: F[A])
+    def map[B](f: A => B): F[B]
+```
+
+The instance of `Functor` for `List` now becomes:
+
+```scala
+given Functor[List] with
+  extension [A](xs: List[A])
+    def map[B](f: A => B): List[B] =
+      xs.map(f) // List already has a `map` method
+
+```
+
+It simplifies the `assertTransformation` method:
+
+```scala
+def assertTransformation[F[_]: Functor, A, B](expected: F[B], original: F[A], mapping: A => B): Unit =
+  assert(expected == original.map(mapping))
+```
+
+The `map` method is now directly used on `original`. It is available as an extension method
+since `original`'s type is `F[A]` and a given instance for `Functor[F[A]]` which defines `map`
+is in scope.
+
+## Monads
+
+Applying `map` in `Functor[List]` to a mapping function of type `A => B` results in a `List[B]`. So applying it to a mapping function of type `A => List[B]` results in a `List[List[B]]`. To avoid managing lists of lists, we may want to "flatten" the values in a single list.
+
+That's where `Monad` comes in. A `Monad` for type `F[_]` is a `Functor[F]` with two more operations:
+
+* `flatMap`, which turns an `F[A]` into an `F[B]` when given a function of type `A => F[B]`,
+* `pure`, which creates an `F[A]` from a single value `A`.
+
+Here is the translation of this definition in Scala 3:
+
+```scala
+trait Monad[F[_]] extends Functor[F]:
+
+  /** The unit value for a monad */
+  def pure[A](x: A): F[A]
+
+  extension [A](x: F[A])
+    /** The fundamental composition operation */
+    def flatMap[B](f: A => F[B]): F[B]
+
+    /** The `map` operation can now be defined in terms of `flatMap` */
+    def map[B](f: A => B) = x.flatMap(f.andThen(pure))
+
+end Monad
+```
+
+### List
+
+A `List` can be turned into a monad via this `given` instance:
+
+```scala
+given listMonad: Monad[List] with
+  def pure[A](x: A): List[A] =
+    List(x)
+  extension [A](xs: List[A])
+    def flatMap[B](f: A => List[B]): List[B] =
+      xs.flatMap(f) // rely on the existing `flatMap` method of `List`
+```
+
+Since `Monad` is a subtype of `Functor`, `List` is also a functor. The Functor's `map`
+operation is already provided by the `Monad` trait, so the instance does not need to define
+it explicitly.
+
+### Option
+
+`Option` is an other type having the same kind of behaviour:
+
+```scala
+given optionMonad: Monad[Option] with
+  def pure[A](x: A): Option[A] =
+    Option(x)
+  extension [A](xo: Option[A])
+    def flatMap[B](f: A => Option[B]): Option[B] = xo match
+      case Some(x) => f(x)
+      case None => None
+```
+
+### Reader
+
+Another example of a `Monad` is the _Reader_ Monad, which acts on functions instead of
+data types like `List` or `Option`. It can be used to combine multiple functions
+that all need the same parameter. For instance multiple functions needing access to some configuration, context, environment variables, etc.
+
+Let's define a `Config` type, and two functions using it:
+
+```scala
+trait Config
+// ...
+def compute(i: Int)(config: Config): String = ???
+def show(str: String)(config: Config): Unit = ???
+```
+
+We may want to combine `compute` and `show` into a single function, accepting a `Config` as parameter, and showing the result of the computation, and we'd like to use
+a monad to avoid passing the parameter explicitly multiple times. So postulating
+the right `flatMap` operation, we could write:
+
+```scala
+def computeAndShow(i: Int): Config => Unit = compute(i).flatMap(show)
+```
+
+instead of
+
+```scala
+show(compute(i)(config))(config)
+```
+
+Let's define this m then. First, we are going to define a type named `ConfigDependent` representing a function that when passed a `Config` produces a `Result`.
+
+```scala
+type ConfigDependent[Result] = Config => Result
+```
+
+The monad instance will look like this:
+
+```scala
+given configDependentMonad: Monad[ConfigDependent] with
+
+  def pure[A](x: A): ConfigDependent[A] =
+    config => x
+
+  extension [A](x: ConfigDependent[A])
+    def flatMap[B](f: A => ConfigDependent[B]): ConfigDependent[B] =
+      config => f(x(config))(config)
+
+end configDependentMonad
+```
+
+The type `ConfigDependent` can be written using [type lambdas](../new-types/type-lambdas.md):
+
+```scala
+type ConfigDependent = [Result] =>> Config => Result
+```
+
+Using this syntax would turn the previous `configDependentMonad` into:
+
+```scala
+given configDependentMonad: Monad[[Result] =>> Config => Result] with
+
+  def pure[A](x: A): Config => A =
+    config => x
+
+  extension [A](x: Config => A)
+    def flatMap[B](f: A => Config => B): Config => B =
+      config => f(x(config))(config)
+
+end configDependentMonad
+```
+
+It is likely that we would like to use this pattern with other kinds of environments than our `Config` trait. The Reader monad allows us to abstract away `Config` as a type _parameter_, named `Ctx` in the following definition:
+
+```scala
+given readerMonad[Ctx]: Monad[[X] =>> Ctx => X] with
+
+  def pure[A](x: A): Ctx => A =
+    ctx => x
+
+  extension [A](x: Ctx => A)
+    def flatMap[B](f: A => Ctx => B): Ctx => B =
+      ctx => f(x(ctx))(ctx)
+
+end readerMonad
+```
+
+## Summary
+
+The definition of a _type class_ is expressed with a parameterised type with abstract members, such as a `trait`.
+The main difference between subtype polymorphism and ad-hoc polymorphism with _type classes_ is how the definition of the _type class_ is implemented, in relation to the type it acts upon.
+In the case of a _type class_, its implementation for a concrete type is expressed through a `given` instance definition, which is supplied as an implicit argument alongside the value it acts upon. With subtype polymorphism, the implementation is mixed into the parents of a class, and only a single term is required to perform a polymorphic operation. The type class solution
+takes more effort to set up, but is more extensible: Adding a new interface to a
+class requires changing the source code of that class. But contrast, instances for type classes can be defined anywhere.
+
+To conclude, we have seen that traits and given instances, combined with other constructs like extension methods, context bounds and type lambdas allow a concise and natural expression of _type classes_.
diff --git a/docs/_spec/TODOreference/contextual/using-clauses.md b/docs/_spec/TODOreference/contextual/using-clauses.md
new file mode 100644
index 000000000000..9187e1916e7d
--- /dev/null
+++ b/docs/_spec/TODOreference/contextual/using-clauses.md
@@ -0,0 +1,153 @@
+---
+layout: doc-page
+title: "Using Clauses"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/contextual/using-clauses.html
+---
+
+Functional programming tends to express most dependencies as simple function parameterization.
+This is clean and powerful, but it sometimes leads to functions that take many parameters where the same value is passed over and over again in long call chains to many
+functions. Context parameters can help here since they enable the compiler to synthesize
+repetitive arguments instead of the programmer having to write them explicitly.
+
+For example, with the [given instances](./givens.md) defined previously,
+a `max` function that works for any arguments for which an ordering exists can be defined as follows:
+
+```scala
+def max[T](x: T, y: T)(using ord: Ord[T]): T =
+  if ord.compare(x, y) < 0 then y else x
+```
+
+Here, `ord` is a _context parameter_ introduced with a `using` clause.
+The `max` function can be applied as follows:
+
+```scala
+max(2, 3)(using intOrd)
+```
+
+The `(using intOrd)` part passes `intOrd` as an argument for the `ord` parameter. But the point of context parameters is that this argument can also be left out (and it usually is). So the following applications are equally valid:
+
+```scala
+max(2, 3)
+max(List(1, 2, 3), Nil)
+```
+
+## Anonymous Context Parameters
+
+In many situations, the name of a context parameter need not be
+mentioned explicitly at all, since it is used only in synthesized arguments for
+other context parameters. In that case one can avoid defining a parameter name
+and just provide its type. Example:
+
+```scala
+def maximum[T](xs: List[T])(using Ord[T]): T =
+  xs.reduceLeft(max)
+```
+
+`maximum` takes a context parameter of type `Ord[T]` only to pass it on as an
+inferred argument to `max`. The name of the parameter is left out.
+
+Generally, context parameters may be defined either as a full parameter list `(p_1: T_1, ..., p_n: T_n)` or just as a sequence of types `T_1, ..., T_n`. Vararg parameters are not supported in `using` clauses.
+
+## Class Context Parameters
+
+If a class context parameter is made a member by adding a `val` or `var` modifier,
+then that member is available as a given instance.
+
+Compare the following examples, where the attempt to supply an explicit `given` member induces an ambiguity:
+
+```scala
+class GivenIntBox(using val givenInt: Int):
+  def n = summon[Int]
+
+class GivenIntBox2(using givenInt: Int):
+  given Int = givenInt
+  //def n = summon[Int]     // ambiguous
+```
+
+The `given` member is importable as explained in the section on [importing `given`s](./given-imports.md):
+
+```scala
+val b = GivenIntBox(using 23)
+import b.given
+summon[Int]  // 23
+
+import b.*
+//givenInt   // Not found
+```
+
+## Inferring Complex Arguments
+
+Here are two other methods that have a context parameter of type `Ord[T]`:
+
+```scala
+def descending[T](using asc: Ord[T]): Ord[T] = new Ord[T]:
+  def compare(x: T, y: T) = asc.compare(y, x)
+
+def minimum[T](xs: List[T])(using Ord[T]) =
+  maximum(xs)(using descending)
+```
+
+The `minimum` method's right-hand side passes `descending` as an explicit argument to `maximum(xs)`.
+With this setup, the following calls are all well-formed, and they all normalize to the last one:
+
+```scala
+minimum(xs)
+maximum(xs)(using descending)
+maximum(xs)(using descending(using listOrd))
+maximum(xs)(using descending(using listOrd(using intOrd)))
+```
+
+## Multiple `using` Clauses
+
+There can be several `using` clauses in a definition and `using` clauses can be freely mixed with normal parameter clauses. Example:
+
+```scala
+def f(u: Universe)(using ctx: u.Context)(using s: ctx.Symbol, k: ctx.Kind) = ...
+```
+
+Multiple `using` clauses are matched left-to-right in applications. Example:
+
+```scala
+object global extends Universe { type Context = ... }
+given ctx : global.Context with { type Symbol = ...; type Kind = ... }
+given sym : ctx.Symbol
+given kind: ctx.Kind
+
+```
+Then the following calls are all valid (and normalize to the last one)
+
+```scala
+f(global)
+f(global)(using ctx)
+f(global)(using ctx)(using sym, kind)
+```
+
+But `f(global)(using sym, kind)` would give a type error.
+
+
+## Summoning Instances
+
+The method `summon` in `Predef` returns the given of a specific type. For example,
+the given instance for `Ord[List[Int]]` is produced by
+
+```scala
+summon[Ord[List[Int]]]  // reduces to listOrd(using intOrd)
+```
+
+The `summon` method is simply defined as the (non-widening) identity function over a context parameter.
+
+```scala
+def summon[T](using x: T): x.type = x
+```
+
+## Syntax
+
+Here is the new syntax of parameters and arguments seen as a delta from the [standard context free syntax of Scala 3](../syntax.md). `using` is a soft keyword, recognized only at the start of a parameter or argument list. It can be used as a normal identifier everywhere else.
+
+```
+ClsParamClause      ::=  ... | UsingClsParamClause
+DefParamClauses     ::=  ... | UsingParamClause
+UsingClsParamClause ::=  ‘(’ ‘using’ (ClsParams | Types) ‘)’
+UsingParamClause    ::=  ‘(’ ‘using’ (DefParams | Types) ‘)’
+ParArgumentExprs    ::=  ... | ‘(’ ‘using’ ExprsInParens ‘)’
+```
diff --git a/docs/_spec/TODOreference/dropped-features/auto-apply.md b/docs/_spec/TODOreference/dropped-features/auto-apply.md
new file mode 100644
index 000000000000..eadfe2f429ea
--- /dev/null
+++ b/docs/_spec/TODOreference/dropped-features/auto-apply.md
@@ -0,0 +1,96 @@
+---
+layout: doc-page
+title: "Dropped: Auto-Application"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/dropped-features/auto-apply.html
+---
+
+Previously an empty argument list `()` was implicitly inserted when
+calling a nullary method without arguments. Example:
+
+```scala
+def next(): T = ...
+next     // is expanded to next()
+```
+
+In Scala 3, this idiom is an error.
+
+```scala
+next
+^
+missing arguments for method next
+```
+
+In Scala 3, 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. The reason for being more
+lenient with such methods is that otherwise everyone would have to
+write
+
+```scala
+xs.toString().length()
+```
+
+instead of
+
+```scala
+xs.toString.length
+```
+
+The latter is idiomatic Scala because it conforms to the _uniform
+access principle_. This principle states that one should be able to
+change an object member from a field to a non-side-effecting method
+and back without affecting clients that access the
+member. Consequently, Scala encourages to define such "property"
+methods without a `()` parameter list whereas side-effecting methods
+should be defined with it. Methods defined in Java cannot make this
+distinction; for them a `()` is always mandatory. So Scala fixes the
+problem on the client side, by allowing the parameterless references.
+But where Scala allows that freedom for all method references, Scala 3
+restricts it to references of external methods that are not defined
+themselves in Scala 3.
+
+For reasons of backwards compatibility, Scala 3 for the moment also
+auto-inserts `()` for nullary methods that are defined in Scala 2, or
+that override a method defined in Scala 2. It turns out that, because
+the correspondence between definition and call was not enforced in
+Scala so far, there are quite a few method definitions in Scala 2
+libraries that use `()` in an inconsistent way. For instance, we
+find in `scala.math.Numeric`
+
+```scala
+def toInt(): Int
+```
+
+whereas `toInt` is written without parameters everywhere
+else. Enforcing strict parameter correspondence for references to
+such methods would project the inconsistencies to client code, which
+is undesirable. So Scala 3 opts for more leniency when type-checking
+references to such methods until most core libraries in Scala 2 have
+been cleaned up.
+
+Stricter conformance rules also apply to overriding of nullary
+methods.  It is no longer allowed to override a parameterless method
+by a nullary method or _vice versa_. Instead, both methods must agree
+exactly in their parameter lists.
+
+```scala
+class A:
+  def next(): Int
+
+class B extends A:
+  def next: Int // overriding error: incompatible type
+```
+
+Methods overriding Java or Scala 2 methods are again exempted from this
+requirement.
+
+## Migrating code
+
+Existing Scala code with inconsistent parameters can still be compiled
+in Scala 3 under `-source 3.0-migration`. When paired with the `-rewrite`
+option, the code will be automatically rewritten to conform to Scala 3's
+stricter checking.
+
+## Reference
+
+For more information, see [Issue #2570](https://github.com/lampepfl/dotty/issues/2570) and [PR #2716](https://github.com/lampepfl/dotty/pull/2716).
diff --git a/docs/_spec/TODOreference/dropped-features/class-shadowing-spec.md b/docs/_spec/TODOreference/dropped-features/class-shadowing-spec.md
new file mode 100644
index 000000000000..6c81087408c6
--- /dev/null
+++ b/docs/_spec/TODOreference/dropped-features/class-shadowing-spec.md
@@ -0,0 +1,26 @@
+---
+layout: doc-page
+title: "Dropped: Class Shadowing - More Details"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/dropped-features/class-shadowing-spec.html
+---
+
+Spec diff: in section [5.1.4 Overriding](https://www.scala-lang.org/files/archive/spec/2.13/05-classes-and-objects.html#Overriding), add *M' must not be a class*.
+
+> Why do we want to make this change to the language?
+
+Class shadowing is irregular compared to other types of overrides. Indeed, inner classes are not actually overridden but simply shadowed.
+
+
+> How much existing code is going to be affected?
+
+From all the code compiled so far with Scala 3 the only instance of this I could find is in the stdlib. Looking at [this commit](https://github.com/lampepfl/scala/commit/68f13bf39979b631ed211ec1751934306ceb5d6c#diff-7aa508b70e055b47c823764e3e5646b8) it seems like the usage of class shadowing was accidental.
+
+
+> How exactly is existing code going to be affected?
+
+Code that relies on overridden inner classes will stop compiling.
+
+
+> Is this change going to be migratable automatically?
+
+No.
diff --git a/docs/_spec/TODOreference/dropped-features/class-shadowing.md b/docs/_spec/TODOreference/dropped-features/class-shadowing.md
new file mode 100644
index 000000000000..8bfdb1eb196c
--- /dev/null
+++ b/docs/_spec/TODOreference/dropped-features/class-shadowing.md
@@ -0,0 +1,33 @@
+---
+layout: doc-page
+title: "Dropped: Class Shadowing"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/dropped-features/class-shadowing.html
+---
+
+Scala 2 so far allowed patterns like this:
+
+```scala
+class Base {
+  class Ops { ... }
+}
+
+class Sub extends Base {
+  class Ops { ... }
+}
+```
+
+Scala 3 rejects this with the error message:
+
+```scala
+6 |      class Ops {  }
+  |            ^
+  |class Ops cannot have the same name as class Ops in class Base
+  | -- class definitions cannot be overridden
+```
+
+The issue is that the two `Ops` classes _look_ like one overrides the
+other, but classes in Scala 2 cannot be overridden. To keep things clean
+(and its internal operations consistent) the Scala 3 compiler forces you
+to rename the inner classes so that their names are different.
+
+[More details](./class-shadowing-spec.md)
diff --git a/docs/_spec/TODOreference/dropped-features/delayed-init.md b/docs/_spec/TODOreference/dropped-features/delayed-init.md
new file mode 100644
index 000000000000..5d4f614ce951
--- /dev/null
+++ b/docs/_spec/TODOreference/dropped-features/delayed-init.md
@@ -0,0 +1,32 @@
+---
+layout: doc-page
+title: "Dropped: DelayedInit"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/dropped-features/delayed-init.html
+---
+
+The special handling of the [`DelayedInit`](https://scala-lang.org/api/3.x/scala/DelayedInit.html)
+trait is no longer supported.
+
+One consequence is that the [`App`](https://scala-lang.org/api/3.x/scala/App.html) class,
+which used [`DelayedInit`](https://scala-lang.org/api/3.x/scala/DelayedInit.html) is
+now partially broken. You can still use `App` as a simple way to set up a main program. Example:
+
+```scala
+object HelloWorld extends App {
+  println("Hello, world!")
+}
+```
+
+However, the code is now run in the initializer of the object, which on
+some JVM's means that it will only be interpreted. So, better not use it
+for benchmarking! Also, if you want to access the command line arguments,
+you need to use an explicit `main` method for that.
+
+```scala
+object Hello:
+  def main(args: Array[String]) =
+    println(s"Hello, ${args(0)}")
+```
+
+On the other hand, Scala 3 offers a convenient alternative to such "program" objects
+with [`@main` methods](../changed-features/main-functions.md).
diff --git a/docs/_spec/TODOreference/dropped-features/do-while.md b/docs/_spec/TODOreference/dropped-features/do-while.md
new file mode 100644
index 000000000000..08a730b8b5a7
--- /dev/null
+++ b/docs/_spec/TODOreference/dropped-features/do-while.md
@@ -0,0 +1,41 @@
+---
+layout: doc-page
+title: "Dropped: Do-While"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/dropped-features/do-while.html
+---
+
+The syntax construct
+```scala
+do <body> while <cond>
+```
+is no longer supported. Instead, it is recommended to use the equivalent `while` loop
+below:
+```scala
+while ({ <body> ; <cond> }) ()
+```
+For instance, instead of
+```scala
+do
+  i += 1
+while (f(i) == 0)
+```
+one writes
+```scala
+while
+  i += 1
+  f(i) == 0
+do ()
+```
+The idea to use a block as the condition of a while also gives a solution
+to the "loop-and-a-half" problem. Here is another example:
+```scala
+while
+  val x: Int = iterator.next
+  x >= 0
+do print(".")
+```
+
+## Why Drop The Construct?
+
+ - `do-while` is used relatively rarely and it can be expressed faithfully using just `while`. So there seems to be little point in having it as a separate syntax construct.
+ - Under the [new syntax rules](../other-new-features/control-syntax.md) `do` is used as a statement continuation, which would clash with its meaning as a statement introduction.
diff --git a/docs/_spec/TODOreference/dropped-features/dropped-features.md b/docs/_spec/TODOreference/dropped-features/dropped-features.md
new file mode 100644
index 000000000000..f6a13d9fa5da
--- /dev/null
+++ b/docs/_spec/TODOreference/dropped-features/dropped-features.md
@@ -0,0 +1,7 @@
+---
+layout: index
+title: "Dropped Features"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/dropped-features.html
+---
+
+The following pages document the features of Scala 2 that have been dropped in Scala 3.
diff --git a/docs/_spec/TODOreference/dropped-features/early-initializers.md b/docs/_spec/TODOreference/dropped-features/early-initializers.md
new file mode 100644
index 000000000000..6f7c59c4f031
--- /dev/null
+++ b/docs/_spec/TODOreference/dropped-features/early-initializers.md
@@ -0,0 +1,16 @@
+---
+layout: doc-page
+title: "Dropped: Early Initializers"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/dropped-features/early-initializers.html
+---
+
+Early initializers of the form
+
+```scala
+class C extends { ... } with SuperClass ...
+```
+
+have been dropped. They were rarely used, and mostly to compensate for the lack of
+[trait parameters](../other-new-features/trait-parameters.md), which are now directly supported in Scala 3.
+
+For more information, see [SLS §5.1.6](https://www.scala-lang.org/files/archive/spec/2.13/05-classes-and-objects.html#early-definitions).
diff --git a/docs/_spec/TODOreference/dropped-features/existential-types.md b/docs/_spec/TODOreference/dropped-features/existential-types.md
new file mode 100644
index 000000000000..6ef815152cd0
--- /dev/null
+++ b/docs/_spec/TODOreference/dropped-features/existential-types.md
@@ -0,0 +1,35 @@
+---
+layout: doc-page
+title: "Dropped: Existential Types"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/dropped-features/existential-types.html
+---
+
+Existential types using `forSome` (as in
+[SLS §3.2.12](https://www.scala-lang.org/files/archive/spec/2.13/03-types.html#existential-types))
+have been dropped. The reasons for dropping them are:
+
+ - Existential types violate a type soundness principle on which DOT
+   and Scala 3 are constructed. That principle says that every
+   prefix (`p`, respectvely `S`) of a type selection `p.T` or `S#T`
+   must either come from a value constructed at runtime or refer to a
+   type that is known to have only good bounds.
+
+ - Existential types create many difficult feature interactions
+   with other Scala constructs.
+
+ - Existential types largely overlap with path-dependent types,
+   so the gain of having them is relatively minor.
+
+Existential types that can be expressed using only wildcards (but not
+`forSome`) are still supported, but are treated as refined types.
+For instance, the type
+```scala
+Map[_ <: AnyRef, Int]
+```
+is treated as the type `Map`, where the first type parameter
+is upper-bounded by `AnyRef` and the second type parameter is an alias
+of `Int`.
+
+When reading class files compiled with Scala 2, Scala 3 will do a best
+effort to approximate existential types with its own types. It will
+issue a warning that a precise emulation is not possible.
diff --git a/docs/_spec/TODOreference/dropped-features/limit22.md b/docs/_spec/TODOreference/dropped-features/limit22.md
new file mode 100644
index 000000000000..e72aeadbe2ca
--- /dev/null
+++ b/docs/_spec/TODOreference/dropped-features/limit22.md
@@ -0,0 +1,17 @@
+---
+layout: doc-page
+title: "Dropped: Limit 22"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/dropped-features/limit22.html
+---
+
+The limits of 22 for the maximal number of parameters of function types and the
+maximal number of fields in tuple types have been dropped.
+
+* Functions can now have an arbitrary number of parameters. Functions beyond
+  [`scala.Function22`](https://www.scala-lang.org/api/current/scala/Function22.html) are erased to a new trait [`scala.runtime.FunctionXXL`](https://scala-lang.org/api/3.x/scala/runtime/FunctionXXL.html).
+
+* Tuples can also have an arbitrary number of fields. Tuples beyond [`scala.Tuple22`](https://www.scala-lang.org/api/current/scala/Tuple22.html)
+  are erased to a new class [`scala.runtime.TupleXXL`](https://scala-lang.org/api/3.x/scala/runtime/TupleXXL.html) (which extends the trait [`scala.Product`](https://scala-lang.org/api/3.x/scala/Product.md)). Furthermore, they support generic
+  operation such as concatenation and indexing.
+
+Both of these are implemented using arrays.
diff --git a/docs/_spec/TODOreference/dropped-features/macros.md b/docs/_spec/TODOreference/dropped-features/macros.md
new file mode 100644
index 000000000000..7ffe9043d0cd
--- /dev/null
+++ b/docs/_spec/TODOreference/dropped-features/macros.md
@@ -0,0 +1,16 @@
+---
+layout: doc-page
+title: "Dropped: Scala 2 Macros"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/dropped-features/macros.html
+---
+
+The previous, experimental macro system has been dropped.
+
+Instead, there is a cleaner, more restricted system based on two complementary concepts: `inline` and `'{ ... }`/`${ ... }` code generation.
+`'{ ... }` delays the compilation of the code and produces an object containing the code, dually `${ ... }` evaluates an expression which produces code and inserts it in the surrounding `${ ... }`.
+In this setting, a definition marked as inlined containing a `${ ... }` is a macro, the code inside the `${ ... }` is executed at compile-time and produces code in the form of `'{ ... }`.
+Additionally, the contents of code can be inspected and created with a more complex reflection API as an extension of `'{ ... }`/`${ ... }` framework.
+
+* `inline` has been [implemented](../metaprogramming/inline.md) in Scala 3.
+* Quotes `'{ ... }` and splices `${ ... }` has been [implemented](../metaprogramming/macros.md) in Scala 3.
+* [TASTy reflect](../metaprogramming/reflection.md) provides more complex tree based APIs to inspect or create quoted code.
diff --git a/docs/_spec/TODOreference/dropped-features/nonlocal-returns.md b/docs/_spec/TODOreference/dropped-features/nonlocal-returns.md
new file mode 100644
index 000000000000..17b86f77ee56
--- /dev/null
+++ b/docs/_spec/TODOreference/dropped-features/nonlocal-returns.md
@@ -0,0 +1,29 @@
+---
+layout: doc-page
+title: "Deprecated: Nonlocal Returns"
+
+nightlyOf: https://docs.scala-lang.org/scala3/reference/dropped-features/nonlocal-returns.html
+---
+
+Returning from nested anonymous functions has been deprecated, and will produce a warning from version `3.2`.
+
+Nonlocal returns are implemented by throwing and catching `scala.runtime.NonLocalReturnException`-s. This is rarely what is intended by the programmer. It can be problematic because of the hidden performance cost of throwing and catching exceptions. Furthermore, it is a leaky implementation: a catch-all exception handler can intercept a `NonLocalReturnException`.
+
+A drop-in library replacement is provided in [`scala.util.control.NonLocalReturns`](https://scala-lang.org/api/3.x/scala/util/control/NonLocalReturns$.html). Example:
+
+```scala
+import scala.util.control.NonLocalReturns.*
+
+extension [T](xs: List[T])
+  def has(elem: T): Boolean = returning {
+    for x <- xs do
+      if x == elem then throwReturn(true)
+    false
+  }
+
+@main def test(): Unit =
+  val xs = List(1, 2, 3, 4, 5)
+  assert(xs.has(2) == xs.contains(2))
+```
+
+Note: compiler produces deprecation error on nonlocal returns only with `-source:future` option.
diff --git a/docs/_spec/TODOreference/dropped-features/package-objects.md b/docs/_spec/TODOreference/dropped-features/package-objects.md
new file mode 100644
index 000000000000..d8149e460bf5
--- /dev/null
+++ b/docs/_spec/TODOreference/dropped-features/package-objects.md
@@ -0,0 +1,48 @@
+---
+layout: doc-page
+title: "Dropped: Package Objects"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/dropped-features/package-objects.html
+---
+
+Package objects
+```scala
+package object p {
+  val a = ...
+  def b = ...
+}
+```
+will be dropped. They are still available in Scala 3.0 and 3.1, but will be deprecated and removed afterwards.
+
+Package objects are no longer needed since all kinds of definitions can now be written at the top-level. Example:
+```scala
+package p
+type Labelled[T] = (String, T)
+val a: Labelled[Int] = ("count", 1)
+def b = a._2
+
+case class C()
+
+extension (x: C) def pair(y: C) = (x, y)
+```
+There may be several source files in a package containing such top-level definitions, and source files can freely mix top-level value, method, and type definitions with classes and objects.
+
+The compiler generates synthetic objects that wrap top-level definitions falling into one of the following categories:
+
+ - all pattern, value, method, and type definitions,
+ - implicit classes and objects,
+ - companion objects of opaque type aliases.
+
+If a source file `src.scala` contains such top-level definitions, they will be put in a synthetic object named `src$package`. The wrapping is transparent, however. The definitions in `src` can still be accessed as members of the enclosing package. The synthetic object will be placed last in the file,
+after any other package clauses, imports, or object and class definitions.
+
+**Note:** This means that
+1. The name of a source file containing wrapped top-level definitions is relevant for binary compatibility. If the name changes, so does the name of the generated object and its class.
+
+2. A top-level main method `def main(args: Array[String]): Unit = ...` is wrapped as any other method. If it appears
+in a source file `src.scala`, it could be invoked from the command line using a command like `scala src$package`. Since the
+"program name" is mangled it is recommended to always put `main` methods in explicitly named objects.
+
+3. The notion of `private` is independent of whether a definition is wrapped or not. A `private` top-level definition is always visible from everywhere in the enclosing package.
+
+4. If several top-level definitions are overloaded variants with the same name,
+they must all come from the same source file.
diff --git a/docs/_spec/TODOreference/dropped-features/procedure-syntax.md b/docs/_spec/TODOreference/dropped-features/procedure-syntax.md
new file mode 100644
index 000000000000..de76fbb32af2
--- /dev/null
+++ b/docs/_spec/TODOreference/dropped-features/procedure-syntax.md
@@ -0,0 +1,19 @@
+---
+layout: doc-page
+title: "Dropped: Procedure Syntax"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/dropped-features/procedure-syntax.html
+---
+
+Procedure syntax
+```scala
+def f() { ... }
+```
+has been dropped. You need to write one of the following instead:
+```scala
+def f() = { ... }
+def f(): Unit = { ... }
+```
+Scala 3 accepts the old syntax under the `-source:3.0-migration` option.
+If the `-migration` option is set, it can even rewrite old syntax to new.
+The [Scalafix](https://scalacenter.github.io/scalafix/) tool also
+can rewrite procedure syntax to make it Scala 3 compatible.
diff --git a/docs/_spec/TODOreference/dropped-features/symlits.md b/docs/_spec/TODOreference/dropped-features/symlits.md
new file mode 100644
index 000000000000..d3c0180b16e6
--- /dev/null
+++ b/docs/_spec/TODOreference/dropped-features/symlits.md
@@ -0,0 +1,24 @@
+---
+layout: doc-page
+title: "Dropped: Symbol Literals"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/dropped-features/symlits.html
+---
+
+Symbol literals are no longer supported.
+
+The [`scala.Symbol`](https://scala-lang.org/api/3.x/scala/Symbol.html) class still exists, so a literal translation of the symbol literal `'xyz` is `Symbol("xyz")`. However, it is recommended to use a plain string literal `"xyz"` instead. (The `Symbol` class will be deprecated and removed in the future). Example:
+
+
+```
+scalac Test.scala
+-- Error: Test.scala:1:25 ------------------------------------------------------------------------------------------------
+
+1 |@main def test = println('abc)
+  |                         ^
+  |                         symbol literal 'abc is no longer supported,
+  |                         use a string literal "abc" or an application Symbol("abc") instead,
+  |                         or enclose in braces '{abc} 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.
+1 error found
+```
diff --git a/docs/_spec/TODOreference/dropped-features/this-qualifier.md b/docs/_spec/TODOreference/dropped-features/this-qualifier.md
new file mode 100644
index 000000000000..4fcadff8fae3
--- /dev/null
+++ b/docs/_spec/TODOreference/dropped-features/this-qualifier.md
@@ -0,0 +1,33 @@
+---
+layout: doc-page
+title: "Dropped: private[this] and protected[this]"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/dropped-features/this-qualifier.html
+---
+
+The `private[this]` and `protected[this]` access modifiers are deprecated and will be phased out.
+
+Previously, these modifiers were needed for
+
+ - avoiding the generation of getters and setters
+ - excluding code under a `private[this]` from variance checks. (Scala 2 also excludes `protected[this]` but this was found to be unsound and was therefore removed).
+ - avoiding the generation of fields, if a `private[this] val` is not accessed
+ by a class method.
+
+The compiler now infers for `private` members the fact that they are only accessed via `this`. Such members are treated as if they had been declared `private[this]`. `protected[this]` is dropped without a replacement.
+
+This change can in some cases change the semantics of a Scala program, since a
+`private` val is no longer guaranteed to generate a field. The field
+is omitted if
+
+ - the `val` is only accessed via `this`, and
+ - the `val` is not accessed from a method in the current class.
+
+This can cause problems if a program tries to access the missing private field via reflection. The recommended fix is to declare the field instead to be qualified private with the enclosing class as qualifier. Example:
+```scala
+  class C(x: Int):
+    private[C] val field = x + 1
+      // [C] needed if `field` is to be accessed through reflection
+    val retained = field * field
+```
+
+
diff --git a/docs/_spec/TODOreference/dropped-features/type-projection.md b/docs/_spec/TODOreference/dropped-features/type-projection.md
new file mode 100644
index 000000000000..08b5ffb34eca
--- /dev/null
+++ b/docs/_spec/TODOreference/dropped-features/type-projection.md
@@ -0,0 +1,18 @@
+---
+layout: doc-page
+title: "Dropped: General Type Projection"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/dropped-features/type-projection.html
+---
+
+Scala so far allowed general type projection `T#A` where `T` is an arbitrary type
+and `A` names a type member of `T`.
+
+Scala 3 disallows this if `T` is an abstract type (class types and type aliases
+are fine). This change was made because unrestricted type projection
+is [unsound](https://github.com/lampepfl/dotty/issues/1050).
+
+This restriction rules out the [type-level encoding of a combinator
+calculus](https://michid.wordpress.com/2010/01/29/scala-type-level-encoding-of-the-ski-calculus/).
+
+To rewrite code using type projections on abstract types, consider using
+path-dependent types or implicit parameters.
diff --git a/docs/_spec/TODOreference/dropped-features/weak-conformance-spec.md b/docs/_spec/TODOreference/dropped-features/weak-conformance-spec.md
new file mode 100644
index 000000000000..07625dcfe885
--- /dev/null
+++ b/docs/_spec/TODOreference/dropped-features/weak-conformance-spec.md
@@ -0,0 +1,54 @@
+---
+layout: doc-page
+title: "Dropped: Weak Conformance - More Details"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/dropped-features/weak-conformance-spec.html
+---
+
+To simplify the underlying type theory, Scala 3 drops the notion of
+[*weak conformance*](https://www.scala-lang.org/files/archive/spec/2.13/03-types.html#weak-conformance)
+altogether. Instead, it provides more flexibility when
+assigning a type to a constant expression. The new rule is:
+
+ - *If* a list of expressions `Es` appears as one of
+
+     - the elements of a vararg parameter, or
+     - the alternatives of an if-then-else or match expression, or
+     - the body and catch results of a try expression,
+
+- *and* all expressions have primitive numeric types, but they do not
+   all have the same type,
+
+- *then* the following is attempted:
+
+     - the expressions `Es` are partitioned into `Int` constants on the
+       one hand, and all other expressions on the other hand,
+     - if all the other expressions have the same numeric type `T`
+       (which can be one of `Byte`, `Short`, `Char`, `Int`, `Long`, `Float`,
+       `Double`), possibly after widening, and if none of the `Int`
+       literals would incur a loss of precision when converted to `T`,
+       then they are thus converted (the other expressions are left
+       unchanged regardless),
+     - otherwise, the expressions `Es` are used unchanged.
+
+    A loss of precision occurs for
+    - an `Int -> Float` conversion of a constant
+    `c` if `c.toFloat.toInt != c`
+    - an `Int -> Byte` conversion of a constant
+    `c` if `c.toByte.toInt != c`,
+    - an `Int -> Short` conversion of a constant
+    `c` if `c.toShort.toInt != c`.
+
+## Examples
+
+```scala
+inline val b = 33
+def f(): Int = b + 1
+Array(b, 33, 5.5)      : Array[Double] // b is an inline val
+Array(f(), 33, 5.5)    : Array[AnyVal] // f() is not a constant
+Array(5, 11L)          : Array[Long]
+Array(5, 11L, 5.5)     : Array[AnyVal] // Long and Double found
+Array(1.0f, 2)         : Array[Float]
+Array(1.0f, 1234567890): Array[AnyVal] // loss of precision
+Array(b, 33, 'a')      : Array[Char]
+Array(5.toByte, 11)    : Array[Byte]
+```
diff --git a/docs/_spec/TODOreference/dropped-features/weak-conformance.md b/docs/_spec/TODOreference/dropped-features/weak-conformance.md
new file mode 100644
index 000000000000..b1478326b2c9
--- /dev/null
+++ b/docs/_spec/TODOreference/dropped-features/weak-conformance.md
@@ -0,0 +1,47 @@
+---
+layout: doc-page
+title: "Dropped: Weak Conformance"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/dropped-features/weak-conformance.html
+---
+
+In some situations, Scala used a _weak conformance_ relation when
+testing type compatibility or computing the least upper bound of a set
+of types.  The principal motivation behind weak conformance was to
+make an expression like this have type `List[Double]`:
+
+```scala
+List(1.0, math.sqrt(3.0), 0, -3.3) // : List[Double]
+```
+
+It's "obvious" that this should be a `List[Double]`. However, without
+some special provision, the least upper bound of the lists's element
+types `(Double, Double, Int, Double)` would be `AnyVal`, hence the list
+expression would be given type `List[AnyVal]`.
+
+A less obvious example is the following one, which was also typed as a
+`List[Double]`, using the weak conformance relation.
+
+```scala
+val n: Int = 3
+val c: Char = 'X'
+val d: Double = math.sqrt(3.0)
+List(n, c, d) // used to be: List[Double], now: List[AnyVal]
+```
+
+Here, it is less clear why the type should be widened to
+`List[Double]`, a `List[AnyVal]` seems to be an equally valid -- and
+more principled -- choice.
+
+Weak conformance applies to all "numeric" types (including `Char`), and
+independently of whether the expressions are literals or not. However,
+in hindsight, the only intended use case is for *integer literals* to
+be adapted to the type of the other expressions. Other types of numerics
+have an explicit type annotation embedded in their syntax (`f`, `d`,
+`.`, `L` or `'` for `Char`s) which ensures that their author really
+meant them to have that specific type).
+
+Therefore, Scala 3 drops the general notion of weak conformance, and
+instead keeps one rule: `Int` literals are adapted to other numeric
+types if necessary.
+
+[More details](weak-conformance-spec.md)
diff --git a/docs/_spec/TODOreference/dropped-features/wildcard-init.md b/docs/_spec/TODOreference/dropped-features/wildcard-init.md
new file mode 100644
index 000000000000..e42854079cf9
--- /dev/null
+++ b/docs/_spec/TODOreference/dropped-features/wildcard-init.md
@@ -0,0 +1,23 @@
+---
+layout: doc-page
+title: "Dropped: Wildcard Initializer"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/dropped-features/wildcard-init.html
+---
+
+The syntax
+
+```scala
+  var x: A = _
+```
+
+that was used to indicate an uninitialized field, has been dropped.
+At its place there is a special value `uninitialized` in the `scala.compiletime` package.
+To get an uninitialized field, you now write
+
+```scala
+import scala.compiletime.uninitialized
+
+var x: A = uninitialized
+```
+
+To enable cross-compilation, `_` is still supported, but it will be dropped in a future 3.x version.
diff --git a/docs/_spec/TODOreference/dropped-features/xml.md b/docs/_spec/TODOreference/dropped-features/xml.md
new file mode 100644
index 000000000000..458a347a66c4
--- /dev/null
+++ b/docs/_spec/TODOreference/dropped-features/xml.md
@@ -0,0 +1,39 @@
+---
+layout: doc-page
+title: "Dropped: XML Literals"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/dropped-features/xml.html
+---
+
+XML Literals are still supported, but will be dropped in the near future, to
+be replaced with [XML string interpolation](https://github.com/lampepfl/xml-interpolator):
+
+```scala
+import dotty.xml.interpolator.*
+
+case class Person(name: String) { override def toString = name }
+
+@main def test: Unit =
+  val bill = Person("Bill")
+  val john = Person("John")
+  val mike = Person("Mike")
+  val todoList = List(
+    (bill, john, "Meeting", "Room 203, 11:00am"),
+    (john, mike, "Holiday", "March 22-24")
+  )
+  // XML literals (to be dropped)
+  val mails1 = for (from, to, heading, body) <- todoList yield
+    <message>
+      <from>{from}</from><to>{to}</to>
+      <heading>{heading}</heading><body>{body}</body>
+    </message>
+  println(mails1)
+  // XML string interpolation
+  val mails2 = for (from, to, heading, body) <- todoList yield xml"""
+    <message>
+      <from>${from}</from><to>${to}</to>
+      <heading>${heading}</heading><body>${body}</body>
+    </message>"""
+  println(mails2)
+```
+
+For more information, see the semester project [XML String Interpolator for Dotty](https://infoscience.epfl.ch/record/267527) by Yassin Kammoun (2019).
diff --git a/docs/_spec/TODOreference/enums/adts.md b/docs/_spec/TODOreference/enums/adts.md
new file mode 100644
index 000000000000..3ab8c9f3b45b
--- /dev/null
+++ b/docs/_spec/TODOreference/enums/adts.md
@@ -0,0 +1,173 @@
+---
+layout: doc-page
+title: "Algebraic Data Types"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/enums/adts.html
+---
+
+The [`enum` concept](./enums.md) is general enough to also support algebraic data
+types (ADTs) and their generalized version (GADTs). Here is an example
+how an `Option` type can be represented as an ADT:
+
+```scala
+enum Option[+T]:
+  case Some(x: T)
+  case None
+```
+
+This example introduces an `Option` enum with a covariant type
+parameter `T` consisting of two cases, `Some` and `None`. `Some` is
+parameterized with a value parameter `x`. It is a shorthand for writing a
+case class that extends `Option`. Since `None` is not parameterized, it
+is treated as a normal enum value.
+
+The `extends` clauses that were omitted in the example above can also
+be given explicitly:
+
+```scala
+enum Option[+T]:
+  case Some(x: T) extends Option[T]
+  case None       extends Option[Nothing]
+```
+
+Note that the parent type of the `None` value is inferred as
+`Option[Nothing]`. Generally, all covariant type parameters of the enum
+class are minimized in a compiler-generated `extends` clause whereas all
+contravariant type parameters are maximized. If `Option` was non-variant,
+you would need to give the extends clause of `None` explicitly.
+
+As for normal enum values, the cases of an `enum` are all defined in
+the `enum`s companion object. So it's `Option.Some` and `Option.None`
+unless the definitions are "pulled out" with an import:
+
+```scala
+scala> Option.Some("hello")
+val res1: t2.Option[String] = Some(hello)
+
+scala> Option.None
+val res2: t2.Option[Nothing] = None
+```
+
+Note that the type of the expressions above is always `Option`. Generally, the type of a enum case constructor application will be widened to the underlying enum type, unless a more specific type is expected. This is a subtle difference with respect to normal case classes. The classes making up the cases do exist, and can be unveiled, either by constructing them directly with a `new`, or by explicitly providing an expected type.
+
+```scala
+scala> new Option.Some(2)
+val res3: Option.Some[Int] = Some(2)
+scala> val x: Option.Some[Int] = Option.Some(3)
+val res4: Option.Some[Int] = Some(3)
+```
+
+As all other enums, ADTs can define methods. For instance, here is `Option` again, with an
+`isDefined` method and an `Option(...)` constructor in its companion object.
+
+```scala
+enum Option[+T]:
+  case Some(x: T)
+  case None
+
+  def isDefined: Boolean = this match
+    case None => false
+    case _    => true
+
+object Option:
+
+  def apply[T >: Null](x: T): Option[T] =
+    if x == null then None else Some(x)
+
+end Option
+```
+
+Enumerations and ADTs have been presented as two different
+concepts. But since they share the same syntactic construct, they can
+be seen simply as two ends of a spectrum and it is perfectly possible
+to construct hybrids. For instance, the code below gives an
+implementation of `Color` either with three enum values or with a
+parameterized case that takes an RGB value.
+
+```scala
+enum Color(val rgb: Int):
+  case Red   extends Color(0xFF0000)
+  case Green extends Color(0x00FF00)
+  case Blue  extends Color(0x0000FF)
+  case Mix(mix: Int) extends Color(mix)
+```
+
+## Parameter Variance of Enums
+
+By default, parameterized cases of enums with type parameters will copy the type parameters of their parent, along
+with any variance notations. As usual, it is important to use type parameters carefully when they are variant, as shown
+below:
+
+The following `View` enum has a contravariant type parameter `T` and a single case `Refl`, representing a function
+mapping a type `T` to itself:
+
+```scala
+enum View[-T]:
+  case Refl(f: T => T)
+```
+
+The definition of `Refl` is incorrect, as it uses contravariant type `T` in the covariant result position of a
+function type, leading to the following error:
+
+```scala
+-- Error: View.scala:2:12 --------
+2 |   case Refl(f: T => T)
+  |             ^^^^^^^^^
+  |contravariant type T occurs in covariant position in type T => T of value f
+  |enum case Refl requires explicit declaration of type T to resolve this issue.
+```
+
+Because `Refl` does not declare explicit parameters, it looks to the compiler like the following:
+
+```scala
+enum View[-T]:
+  case Refl[/*synthetic*/-T1](f: T1 => T1) extends View[T1]
+```
+
+The compiler has inferred for `Refl` the contravariant type parameter `T1`, following `T` in `View`.
+We can now clearly see that `Refl` needs to declare its own non-variant type parameter to correctly type `f`,
+and can remedy the error by the following change to `Refl`:
+
+```diff
+enum View[-T]:
+-  case Refl(f: T => T)
++  case Refl[R](f: R => R) extends View[R]
+```
+
+Above, type `R` is chosen as the parameter for `Refl` to highlight that it has a different meaning to
+type `T` in `View`, but any name will do.
+
+After some further changes, a more complete implementation of `View` can be given as follows and be used
+as the function type `T => U`:
+
+```scala
+enum View[-T, +U] extends (T => U):
+  case Refl[R](f: R => R) extends View[R, R]
+
+  final def apply(t: T): U = this match
+    case refl: Refl[r] => refl.f(t)
+```
+
+## Syntax of Enums
+
+Changes to the syntax fall in two categories: enum definitions and cases inside enums.
+The changes are specified below as deltas with respect to the Scala syntax given [here](../syntax.md)
+
+ 1. Enum definitions are defined as follows:
+
+    ```
+    TmplDef   ::=  `enum' EnumDef
+    EnumDef   ::=  id ClassConstr [`extends' [ConstrApps]] EnumBody
+    EnumBody  ::=  [nl] ‘{’ [SelfType] EnumStat {semi EnumStat} ‘}’
+    EnumStat  ::=  TemplateStat
+                |  {Annotation [nl]} {Modifier} EnumCase
+    ```
+
+ 2. Cases of enums are defined as follows:
+
+    ```
+    EnumCase  ::=  `case' (id ClassConstr [`extends' ConstrApps]] | ids)
+    ```
+
+## Reference
+
+For more information, see [Issue #1970](https://github.com/lampepfl/dotty/issues/1970).
diff --git a/docs/_spec/TODOreference/enums/desugarEnums.md b/docs/_spec/TODOreference/enums/desugarEnums.md
new file mode 100644
index 000000000000..477653d670bb
--- /dev/null
+++ b/docs/_spec/TODOreference/enums/desugarEnums.md
@@ -0,0 +1,215 @@
+---
+layout: doc-page
+title: "Translation of Enums and ADTs"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/enums/desugarEnums.html
+---
+
+The compiler expands enums and their cases to code that only uses
+Scala's other language features. As such, enums in Scala are
+convenient _syntactic sugar_, but they are not essential to understand
+Scala's core.
+
+We now explain the expansion of enums in detail. First,
+some terminology and notational conventions:
+
+ - We use `E` as a name of an enum, and `C` as a name of a case that appears in `E`.
+ - We use `<...>` for syntactic constructs that in some circumstances might be empty. For instance,
+   `<value-params>` represents one or more parameter lists `(...)` or nothing at all.
+
+ - Enum cases fall into three categories:
+
+   - _Class cases_ are those cases that are parameterized, either with a type parameter section `[...]` or with one or more (possibly empty) parameter sections `(...)`.
+   - _Simple cases_ are cases of a non-generic enum that have neither parameters nor an extends clause or body. That is, they consist of a name only.
+   - _Value cases_ are all cases that do not have a parameter section but that do have a (possibly generated) `extends` clause and/or a body.
+
+  Simple cases and value cases are collectively called _singleton cases_.
+
+The desugaring rules imply that class cases are mapped to case classes, and singleton cases are mapped to `val` definitions.
+
+There are nine desugaring rules. Rule (1) desugars enum definitions. Rules
+(2) and (3) desugar simple cases. Rules (4) to (6) define `extends` clauses for cases that
+are missing them. Rules (7) to (9) define how such cases with `extends` clauses
+map into `case class`es or `val`s.
+
+1. An `enum` definition
+   ```scala
+   enum E ... { <defs> <cases> }
+   ```
+   expands to a `sealed abstract` class that extends the `scala.reflect.Enum` trait and
+   an associated companion object that contains the defined cases, expanded according
+   to rules (2 - 8). The enum class starts with a compiler-generated import that imports
+   the names `<caseIds>` of all cases so that they can be used without prefix in the class.
+   ```scala
+   sealed abstract class E ... extends <parents> with scala.reflect.Enum {
+     import E.{ <caseIds> }
+     <defs>
+   }
+   object E { <cases> }
+   ```
+
+2. A simple case consisting of a comma-separated list of enum names
+   ```scala
+   case C_1, ..., C_n
+   ```
+   expands to
+   ```scala
+   case C_1; ...; case C_n
+   ```
+   Any modifiers or annotations on the original case extend to all expanded
+   cases.
+
+3. A simple case
+   ```scala
+   case C
+   ```
+   of an enum `E` that does not take type parameters expands to
+   ```scala
+   val C = $new(n, "C")
+   ```
+   Here, `$new` is a private method that creates an instance of `E` (see
+   below).
+
+4. If `E` is an enum with type parameters
+   ```scala
+   V1 T1 >: L1 <: U1 ,   ... ,    Vn Tn >: Ln <: Un      (n > 0)
+   ```
+   where each of the variances `Vi` is either `'+'` or `'-'`, then a simple case
+   ```scala
+   case C
+   ```
+   expands to
+   ```scala
+   case C extends E[B1, ..., Bn]
+   ```
+   where `Bi` is `Li` if `Vi = '+'` and `Ui` if `Vi = '-'`. This result is then further
+   rewritten with rule (8). Simple cases of enums with non-variant type
+   parameters are not permitted (however value cases with explicit `extends` clause are)
+
+5. A class case without an extends clause
+   ```scala
+   case C <type-params> <value-params>
+   ```
+   of an enum `E` that does not take type parameters expands to
+   ```scala
+   case C <type-params> <value-params> extends E
+   ```
+   This result is then further rewritten with rule (9).
+
+6. If `E` is an enum with type parameters `Ts`, a class case with neither type parameters nor an extends clause
+   ```scala
+   case C <value-params>
+   ```
+   expands to
+   ```scala
+   case C[Ts] <value-params> extends E[Ts]
+   ```
+   This result is then further rewritten with rule (9). For class cases that have type parameters themselves, an extends clause needs to be given explicitly.
+
+7. If `E` is an enum with type parameters `Ts`, a class case without type parameters but with an extends clause
+   ```scala
+   case C <value-params> extends <parents>
+   ```
+   expands to
+   ```scala
+   case C[Ts] <value-params> extends <parents>
+   ```
+   provided at least one of the parameters `Ts` is mentioned in a parameter type in
+   `<value-params>` or in a type argument in `<parents>`.
+
+8. A value case
+   ```scala
+   case C extends <parents>
+   ```
+   expands to a value definition in `E`'s companion object:
+   ```scala
+   val C = new <parents> { <body>; def ordinal = n }
+   ```
+   where `n` is the ordinal number of the case in the companion object,
+   starting from 0. The anonymous class also
+   implements the abstract `Product` methods that it inherits from `Enum`.
+
+   It is an error if a value case refers to a type parameter of the enclosing `enum`
+   in a type argument of `<parents>`.
+
+9. A class case
+   ```scala
+   case C <params> extends <parents>
+   ```
+   expands analogous to a final case class in `E`'s companion object:
+   ```scala
+   final case class C <params> extends <parents>
+   ```
+   The enum case defines an `ordinal` method of the form
+   ```scala
+   def ordinal = n
+   ```
+   where `n` is the ordinal number of the case in the companion object,
+   starting from 0.
+
+   It is an error if a value case refers to a type parameter of the enclosing `enum`
+   in a parameter type in `<params>` or in a type argument of `<parents>`, unless that parameter is already
+   a type parameter of the case, i.e. the parameter name is defined in `<params>`.
+
+   The compiler-generated `apply` and `copy` methods of an enum case
+   ```scala
+   case C(ps) extends P1, ..., Pn
+   ```
+   are treated specially. A call `C(ts)` of the apply method is ascribed the underlying type
+   `P1 & ... & Pn` (dropping any [transparent traits](../other-new-features/transparent-traits.md))
+   as long as that type is still compatible with the expected type at the point of application.
+   A call `t.copy(ts)` of `C`'s `copy` method is treated in the same way.
+
+## Translation of Enums with Singleton Cases
+
+An enum `E` (possibly generic) that defines one or more singleton cases
+will define the following additional synthetic members in its companion object (where `E'` denotes `E` with
+any type parameters replaced by wildcards):
+
+   - A method `valueOf(name: String): E'`. It returns the singleton case value whose identifier is `name`.
+   - A method `values` which returns an `Array[E']` of all singleton case
+     values defined by `E`, in the order of their definitions.
+
+If `E` contains at least one simple case, its companion object will define in addition:
+
+   - A private method `$new` which defines a new simple case value with given
+     ordinal number and name. This method can be thought as being defined as
+     follows.
+
+     ```scala
+     private def $new(_$ordinal: Int, $name: String) =
+       new E with runtime.EnumValue:
+         def ordinal = _$ordinal
+         override def productPrefix = $name // if not overridden in `E`
+         override def toString = $name      // if not overridden in `E`
+     ```
+
+The anonymous class also implements the abstract `Product` methods that it inherits from `Enum`.
+The `ordinal` method is only generated if the enum does not extend from `java.lang.Enum` (as Scala enums do not extend
+`java.lang.Enum`s unless explicitly specified). In case it does, there is no need to generate `ordinal` as
+`java.lang.Enum` defines it. Similarly there is no need to override `toString` as that is defined in terms of `name` in
+`java.lang.Enum`. Finally, `productPrefix` will call `this.name` when `E` extends `java.lang.Enum`.
+
+## Scopes for Enum Cases
+
+A case in an `enum` is treated similarly to a secondary constructor. It can access neither the enclosing `enum` using `this`, nor its value parameters or instance members using simple
+identifiers.
+
+Even though translated enum cases are located in the enum's companion object, referencing
+this object or its members via `this` or a simple identifier is also illegal. The compiler typechecks enum cases in the scope of the enclosing companion object but flags any such illegal accesses as errors.
+
+## Translation of Java-compatible enums
+
+A Java-compatible enum is an enum that extends `java.lang.Enum`. The translation rules are the same as above, with the reservations defined in this section.
+
+It is a compile-time error for a Java-compatible enum to have class cases.
+
+Cases such as `case C` expand to a `@static val` as opposed to a `val`. This allows them to be generated as static fields of the enum type, thus ensuring they are represented the same way as Java enums.
+
+## Other Rules
+
+- A normal case class which is not produced from an enum case is not allowed to extend
+  `scala.reflect.Enum`. This ensures that the only cases of an enum are the ones that are
+  explicitly declared in it.
+
+- If an enum case has an `extends` clause, the enum class must be one of the
+  classes that's extended.
diff --git a/docs/_spec/TODOreference/enums/enums-index.md b/docs/_spec/TODOreference/enums/enums-index.md
new file mode 100644
index 000000000000..80d703c3e897
--- /dev/null
+++ b/docs/_spec/TODOreference/enums/enums-index.md
@@ -0,0 +1,7 @@
+---
+layout: index
+title: "Enums"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/enums/index.html
+---
+
+This chapter documents enums in Scala 3.
diff --git a/docs/_spec/TODOreference/enums/enums.md b/docs/_spec/TODOreference/enums/enums.md
new file mode 100644
index 000000000000..65051bdfb39f
--- /dev/null
+++ b/docs/_spec/TODOreference/enums/enums.md
@@ -0,0 +1,222 @@
+---
+layout: doc-page
+title: "Enumerations"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/enums/enums.html
+---
+
+An enumeration is used to define a type consisting of a set of named values.
+
+```scala
+enum Color:
+  case Red, Green, Blue
+```
+
+This defines a new `sealed` class, `Color`, with three values, `Color.Red`,
+`Color.Green`, `Color.Blue`.  The color values are members of `Color`s
+companion object.
+
+## Parameterized enums
+
+Enums can be parameterized.
+
+```scala
+enum Color(val rgb: Int):
+  case Red   extends Color(0xFF0000)
+  case Green extends Color(0x00FF00)
+  case Blue  extends Color(0x0000FF)
+```
+
+As the example shows, you can define the parameter value by using an
+explicit extends clause.
+
+## Methods defined for enums
+
+The values of an enum correspond to unique integers. The integer
+associated with an enum value is returned by its `ordinal` method:
+
+```scala
+scala> val red = Color.Red
+val red: Color = Red
+scala> red.ordinal
+val res0: Int = 0
+```
+
+The companion object of an enum also defines three utility methods.
+The `valueOf` method obtains an enum value
+by its name. The `values` method returns all enum values
+defined in an enumeration in an `Array`. The `fromOrdinal`
+method obtains an enum value from its ordinal (`Int`) value.
+
+```scala
+scala> Color.valueOf("Blue")
+val res0: Color = Blue
+scala> Color.values
+val res1: Array[Color] = Array(Red, Green, Blue)
+scala> Color.fromOrdinal(0)
+val res2: Color = Red
+```
+
+## User-defined members of enums
+
+It is possible to add your own definitions to an enum. Example:
+
+```scala
+enum Planet(mass: Double, radius: Double):
+  private final val G = 6.67300E-11
+  def surfaceGravity = G * mass / (radius * radius)
+  def surfaceWeight(otherMass: Double) = otherMass * surfaceGravity
+
+  case Mercury extends Planet(3.303e+23, 2.4397e6)
+  case Venus   extends Planet(4.869e+24, 6.0518e6)
+  case Earth   extends Planet(5.976e+24, 6.37814e6)
+  case Mars    extends Planet(6.421e+23, 3.3972e6)
+  case Jupiter extends Planet(1.9e+27,   7.1492e7)
+  case Saturn  extends Planet(5.688e+26, 6.0268e7)
+  case Uranus  extends Planet(8.686e+25, 2.5559e7)
+  case Neptune extends Planet(1.024e+26, 2.4746e7)
+end Planet
+```
+
+## User-defined companion object of enums
+It is also possible to define an explicit companion object for an enum:
+
+```scala
+object Planet:
+  def main(args: Array[String]) =
+    val earthWeight = args(0).toDouble
+    val mass = earthWeight / Earth.surfaceGravity
+    for p <- values do
+      println(s"Your weight on $p is ${p.surfaceWeight(mass)}")
+end Planet
+```
+
+## Restrictions on Enum Cases
+
+Enum case declarations are similar to secondary constructors:
+they are scoped outside of the enum template, despite being declared within it.
+This means that enum case declarations cannot access inner members of the
+enum class.
+
+Similarly, enum case declarations may not directly reference members of the enum's companion object,
+even if they are imported (directly, or by renaming). For example:
+
+```scala
+import Planet.*
+enum Planet(mass: Double, radius: Double):
+  private final val (mercuryMass, mercuryRadius) = (3.303e+23, 2.4397e6)
+
+  case Mercury extends Planet(mercuryMass, mercuryRadius)             // Not found
+  case Venus   extends Planet(venusMass, venusRadius)                 // illegal reference
+  case Earth   extends Planet(Planet.earthMass, Planet.earthRadius)   // ok
+object Planet:
+  private final val (venusMass, venusRadius) = (4.869e+24, 6.0518e6)
+  private final val (earthMass, earthRadius) = (5.976e+24, 6.37814e6)
+end Planet
+```
+The fields referenced by `Mercury` are not visible, and the fields referenced by `Venus` may not
+be referenced directly (using `import Planet.*`). You must use an indirect reference,
+such as demonstrated with `Earth`.
+
+## Deprecation of Enum Cases
+
+As a library author, you may want to signal that an enum case is no longer intended for use. However you could still want to gracefully handle the removal of a case from your public API, such as special casing deprecated cases.
+
+To illustrate, say that the `Planet` enum originally had an additional case:
+
+```diff
+ enum Planet(mass: Double, radius: Double):
+   ...
+   case Neptune extends Planet(1.024e+26, 2.4746e7)
++  case Pluto   extends Planet(1.309e+22, 1.1883e3)
+ end Planet
+```
+
+We now want to deprecate the `Pluto` case. First we add the `scala.deprecated` annotation to `Pluto`:
+
+```diff
+ enum Planet(mass: Double, radius: Double):
+   ...
+   case Neptune extends Planet(1.024e+26, 2.4746e7)
+-  case Pluto   extends Planet(1.309e+22, 1.1883e3)
++
++  @deprecated("refer to IAU definition of planet")
++  case Pluto extends Planet(1.309e+22, 1.1883e3)
+ end Planet
+```
+
+Outside the lexical scopes of `enum Planet` or `object Planet`, references to `Planet.Pluto` will produce a deprecation warning, but within those scopes we can still reference it to implement introspection over the deprecated cases:
+
+```scala
+trait Deprecations[T <: reflect.Enum] {
+  extension (t: T) def isDeprecatedCase: Boolean
+}
+
+object Planet {
+  given Deprecations[Planet] with {
+    extension (p: Planet)
+      def isDeprecatedCase = p == Pluto
+  }
+}
+```
+
+We could imagine that a library may use [type class derivation](../contextual/derivation.md) to automatically provide an instance for `Deprecations`.
+
+## Compatibility with Java Enums
+
+If you want to use the Scala-defined enums as [Java enums](https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html), you can do so by extending
+the class `java.lang.Enum`, which is imported by default, as follows:
+
+```scala
+enum Color extends Enum[Color] { case Red, Green, Blue }
+```
+
+The type parameter comes from the Java enum [definition](https://docs.oracle.com/javase/8/docs/api/index.html?java/lang/Enum.html) and should be the same as the type of the enum.
+There is no need to provide constructor arguments (as defined in the Java API docs) to `java.lang.Enum` when extending it – the compiler will generate them automatically.
+
+After defining `Color` like that, you can use it like you would a Java enum:
+
+```scala
+scala> Color.Red.compareTo(Color.Green)
+val res15: Int = -1
+```
+
+For a more in-depth example of using Scala 3 enums from Java, see [this test](https://github.com/lampepfl/dotty/tree/main/tests/run/enum-java). In the test, the enums are defined in the `MainScala.scala` file and used from a Java source, `Test.java`.
+
+## Implementation
+
+Enums are represented as `sealed` classes that extend the `scala.reflect.Enum` trait.
+This trait defines a single public method, `ordinal`:
+
+```scala
+package scala.reflect
+
+/** A base trait of all Scala enum definitions */
+transparent trait Enum extends Any, Product, Serializable:
+
+  /** A number uniquely identifying a case of an enum */
+  def ordinal: Int
+```
+
+Enum values with `extends` clauses get expanded to anonymous class instances.
+For instance, the `Venus` value above would be defined like this:
+
+```scala
+val Venus: Planet = new Planet(4.869E24, 6051800.0):
+  def ordinal: Int = 1
+  override def productPrefix: String = "Venus"
+  override def toString: String = "Venus"
+```
+
+Enum values without `extends` clauses all share a single implementation
+that can be instantiated using a private method that takes a tag and a name as arguments.
+For instance, the first
+definition of value `Color.Red` above would expand to:
+
+```scala
+val Red: Color = $new(0, "Red")
+```
+
+## Reference
+
+For more information, see [Issue #1970](https://github.com/lampepfl/dotty/issues/1970) and
+[PR #4003](https://github.com/lampepfl/dotty/pull/4003).
diff --git a/docs/_spec/TODOreference/experimental/canthrow.md b/docs/_spec/TODOreference/experimental/canthrow.md
new file mode 100644
index 000000000000..025a0ed1c686
--- /dev/null
+++ b/docs/_spec/TODOreference/experimental/canthrow.md
@@ -0,0 +1,281 @@
+---
+layout: doc-page
+title: "CanThrow Capabilities"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/experimental/canthrow.html
+---
+
+This page describes experimental support for exception checking in Scala 3. It is enabled by the language import
+```scala
+import language.experimental.saferExceptions
+```
+The reason for publishing this extension now is to get feedback on its usability. We are working on more advanced type systems that build on the general ideas put forward in the extension. Those type systems have application areas beyond checked exceptions. Exception checking is a useful starting point since exceptions are familiar to all Scala programmers and their current treatment leaves room for improvement.
+
+## Why Exceptions?
+
+Exceptions are an ideal mechanism for error handling in many situations. They serve the intended purpose of propagating error conditions with a minimum of boilerplate. They cause zero overhead for the "happy path", which means they are very efficient as long as errors arise infrequently. Exceptions are also debug friendly, since they produce stack traces that can be inspected at the handler site. So one never has to guess where an erroneous condition originated.
+
+## Why Not Exceptions?
+
+However, exceptions in current Scala and many other languages are not reflected in the type system. This means that an essential part of the contract of a function - i.e. what exceptions can it produce? - is not statically checked. Most people acknowledge that this is a problem, but that so far the alternative of checked exceptions was just too painful to be considered. A good example are Java checked exceptions, which do the right thing in principle, but are widely regarded as a mistake since they are so difficult to deal with. So far, none of the successor languages that are modeled after Java or that build on the JVM has copied this feature. See for example Anders Hejlsberg's [statement on why C# does not have checked exceptions](https://www.artima.com/articles/the-trouble-with-checked-exceptions).
+
+## The Problem With Java's Checked Exceptions
+
+The main problem with [Java's checked exception model](https://docs.oracle.com/javase/specs/jls/se8/html/jls-11.html#jls-11.2) is its inflexibility, which is due to lack of polymorphism. Consider for instance the `map` function which is declared on `List[A]` like this:
+```scala
+  def map[B](f: A => B): List[B]
+```
+In the Java model, function `f` is not allowed to throw a checked exception. So the following call would be invalid:
+```scala
+  xs.map(x => if x < limit then x * x else throw LimitExceeded())
+```
+The only way around this would be to wrap the checked exception `LimitExceeded` in an unchecked [`java.lang.RuntimeException`](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/RuntimeException.html) that is caught at the callsite and unwrapped again. Something like this:
+```scala
+  try
+    xs.map(x => if x < limit then x * x else throw Wrapper(LimitExceeded()))
+  catch case Wrapper(ex) => throw ex
+```
+Ugh! No wonder checked exceptions in Java are not very popular.
+
+## Monadic Effects
+
+So the dilemma is that exceptions are easy to use only as long as we forget static type checking. This has caused many people working with Scala to abandon exceptions altogether and to use an error monad like [`Either`](https://scala-lang.org/api/3.x/scala/util/Either.html) instead. This can work in many situations but is not without its downsides either. It makes code a lot more complicated and harder to refactor. It means one is quickly confronted with the problem how to work with several monads. In general, dealing with one monad at a time in Scala is straightforward but dealing with several monads together is much less pleasant since monads don't compose. A great number of techniques have been proposed, implemented, and promoted to deal with this, from monad transformers, to free monads, to tagless final. But none of these techniques is universally liked;  each introduces a complicated DSL that's hard to understand for non-experts, introduces runtime overheads, and makes debugging difficult. In the end, quite a few developers prefer to work instead with a single "super-monad" like [`ZIO`](https://zio.dev/version-1.x/datatypes/core/zio) that has error propagation built in alongside other aspects. This one-size fits all approach can work very nicely, even though (or is it because?) it represents an all-encompassing framework.
+
+However, a programming language is not a framework; it has to cater also for those applications that do not fit the framework's use cases. So there's still a strong motivation for getting exception checking right.
+
+## From Effects To Capabilities
+
+Why does `map` work so poorly with Java's checked exception model? It's because
+`map`'s signature limits function arguments to not throw checked exceptions. We could try to come up with a more polymorphic formulation of `map`. For instance, it could look like this:
+```scala
+  def map[B, E](f: A => B throws E): List[B] throws E
+```
+This assumes a type `A throws E` to indicate computations of type `A` that can throw an exception of type `E`. But in practice the overhead of the additional type parameters makes this approach unappealing as well. Note in particular that we'd have to parameterize _every method_ that takes a function argument that way, so the added overhead of declaring all these exception types looks just like a sort of ceremony we would like to avoid.
+
+But there is a way to avoid the ceremony. Instead of concentrating on possible _effects_ such as "this code might throw an exception", concentrate on _capabilities_ such as "this code needs the capability to throw an exception". From a standpoint of expressiveness this is quite similar. But capabilities can be expressed as parameters whereas traditionally effects are expressed as some addition to result values. It turns out that this can make a big difference!
+
+## The `CanThrow` Capability
+
+In the _effects as capabilities_ model, an effect is expressed as an (implicit) parameter of a certain type. For exceptions we would expect parameters of type
+[`CanThrow[E]`](https://scala-lang.org/api/3.x/scala/CanThrow.html) where `E` stands for the exception that can be thrown. Here is the definition of `CanThrow`:
+```scala
+erased class CanThrow[-E <: Exception]
+```
+This shows another experimental Scala feature: [erased definitions](./erased-defs.md). Roughly speaking, values of an erased class do not generate runtime code; they are erased before code generation. This means that all `CanThrow` capabilities are compile-time only artifacts; they do not have a runtime footprint.
+
+Now, if the compiler sees a `throw Exc()` construct where `Exc` is a checked exception, it will check that there is a capability of type `CanThrow[Exc]` that can be summoned as a given. It's a compile-time error if that's not the case.
+
+How can the capability be produced? There are several possibilities:
+
+Most often, the capability is produced by having a using clause `(using CanThrow[Exc])` in some enclosing scope. This roughly corresponds to a [`throws`](https://docs.oracle.com/javase/specs/jls/se7/html/jls-8.html#jls-8.4.6) clause in Java. The analogy is even stronger since alongside [`CanThrow`](https://scala-lang.org/api/3.x/scala/CanThrow.html) there is also the following type alias defined in the [`scala`](https://scala-lang.org/api/3.x/scala.html) package:
+```scala
+infix type A = Int
+```
+```scala
+infix type $throws[R, +E <: Exception] = CanThrow[E] ?=> R
+```
+That is, [`R $throws E`](https://scala-lang.org/api/3.x/scala/runtime.html#$throws-0) is a context function type that takes an implicit `CanThrow[E]` parameter and that returns a value of type `R`. What's more, the compiler will translate an infix types with `throws` as the operator to `$throws` applications according to the rules
+```
+                A throws E  -->  A $throws E
+    A throws E₁ | ... | Eᵢ  -->  A $throws E₁ ... $throws Eᵢ
+```
+Therefore, a method written like this:
+```scala
+def m(x: T)(using CanThrow[E]): U
+```
+can alternatively be expressed like this:
+```scala
+def m(x: T): U throws E
+```
+Also the capability to throw multiple types of exceptions can be expressed in a few ways as shown in the examples below:
+```scala
+def m(x: T): U throws E1 | E2
+def m(x: T): U throws E1 throws E2
+def m(x: T)(using CanThrow[E1], CanThrow[E2]): U
+def m(x: T)(using CanThrow[E1])(using CanThrow[E2]): U
+def m(x: T)(using CanThrow[E1]): U throws E2
+```
+
+**Note 1:** A signature like
+```scala
+def m(x: T)(using CanThrow[E1 | E2]): U
+```
+would also allow throwing `E1` or `E2` inside the method's body but might cause problems when someone tried to call this method
+from another method declaring its `CanThrow` capabilities like in the earlier examples.
+This is because `CanThrow` has a contravariant type parameter so `CanThrow[E1 | E2]` is a subtype of both `CanThrow[E1]` and `CanThrow[E2]`.
+Hence the presence of a given instance of `CanThrow[E1 | E2]` in scope satisfies the requirement for `CanThrow[E1]` and `CanThrow[E2]`
+but given instances of `CanThrow[E1]` and `CanThrow[E2]` cannot be combined to provide and instance of `CanThrow[E1 | E2]`.
+
+**Note 2:** One should keep in mind that `|` binds its left and right arguments more tightly than `throws` so `A | B throws E1 | E2` means `(A | B) throws (Ex1 | Ex2)`, not `A | (B throws E1) | E2`.
+
+The `CanThrow`/`throws` combo essentially propagates the `CanThrow` requirement outwards. But where are these capabilities created in the first place? That's in the `try` expression. Given a `try` like this:
+
+```scala
+try
+  body
+catch
+  case ex1: Ex1 => handler1
+  ...
+  case exN: ExN => handlerN
+```
+the compiler generates an accumulated capability of type `CanThrow[Ex1 | ... | Ex2]` that is available as a given in the scope of `body`. It does this by augmenting the `try` roughly as follows:
+```scala
+try
+  erased given CanThrow[Ex1 | ... | ExN] = compiletime.erasedValue
+  body
+catch ...
+```
+Note that the right-hand side of the synthesized given is `???` (undefined). This is OK since
+this given is erased; it will not be executed at runtime.
+
+**Note 1:** The [`saferExceptions`](https://scala-lang.org/api/3.x/scala/runtime/stdLibPatches/language$$experimental$$saferExceptions$.html) feature is designed to work only with checked exceptions. An exception type is _checked_ if it is a subtype of
+`Exception` but not of `RuntimeException`. The signature of `CanThrow` still admits `RuntimeException`s since `RuntimeException` is a proper subtype of its bound, `Exception`. But no capabilities will be generated for `RuntimeException`s. Furthermore, `throws` clauses
+also may not refer to `RuntimeException`s.
+
+**Note 2:** To keep things simple, the compiler will currently only generate capabilities
+for catch clauses of the form
+```scala
+  case ex: Ex =>
+```
+where `ex` is an arbitrary variable name (`_` is also allowed), and `Ex` is an arbitrary
+checked exception type. Constructor patterns such as `Ex(...)` or patterns with guards
+are not allowed. The compiler will issue an error if one of these is used to catch
+a checked exception and `saferExceptions` is enabled.
+
+## Example
+
+That's it. Let's see it in action in an example. First, add an import
+```scala
+import language.experimental.saferExceptions
+```
+to enable exception checking. Now, define an exception `LimitExceeded` and
+a function `f` like this:
+```scala
+val limit = 10e9
+class LimitExceeded extends Exception
+def f(x: Double): Double =
+  if x < limit then x * x else throw LimitExceeded()
+```
+You'll get this error message:
+```
+  if x < limit then x * x else throw LimitExceeded()
+                               ^^^^^^^^^^^^^^^^^^^^^
+The capability to throw exception LimitExceeded is missing.
+```
+The capability can be provided by one of the following:
+
+ - Adding a using clause `(using CanThrow[LimitExceeded])` to the definition of the enclosing method
+ - Adding `throws LimitExceeded` clause after the result type of the enclosing method
+ - Wrapping this piece of code with a `try` block that catches `LimitExceeded`
+
+The following import might fix the problem:
+```scala
+  import unsafeExceptions.canThrowAny
+```
+As the error message implies, you have to declare that `f` needs the capability to throw a `LimitExceeded` exception. The most concise way to do so is to add a `throws` clause:
+```scala
+def f(x: Double): Double throws LimitExceeded =
+  if x < limit then x * x else throw LimitExceeded()
+```
+Now put a call to `f` in a `try` that catches `LimitExceeded`:
+```scala
+@main def test(xs: Double*) =
+  try println(xs.map(f).sum)
+  catch case ex: LimitExceeded => println("too large")
+```
+Run the program with some inputs:
+```
+> scala test 1 2 3
+14.0
+> scala test
+0.0
+> scala test 1 2 3 100000000000
+too large
+```
+Everything typechecks and works as expected. But wait - we have called `map` without any ceremony! How did that work? Here's how the compiler expands the `test` function:
+```scala
+// compiler-generated code
+@main def test(xs: Double*) =
+  try
+    erased given ctl: CanThrow[LimitExceeded] = compiletime.erasedValue
+    println(xs.map(x => f(x)(using ctl)).sum)
+  catch case ex: LimitExceeded => println("too large")
+```
+The `CanThrow[LimitExceeded]` capability is passed in a synthesized `using` clause to `f`, since `f` requires it. Then the resulting closure is passed to `map`. The signature of `map` does not have to account for effects. It takes a closure as always, but that
+closure may refer to capabilities in its free variables. This means that `map` is
+already effect polymorphic even though we did not change its signature at all.
+So the takeaway is that the effects as capabilities model naturally provides for effect polymorphism whereas this is something that other approaches struggle with.
+
+## Gradual Typing Via Imports
+
+Another advantage is that the model allows a gradual migration from current unchecked exceptions to safer exceptions. Imagine for a moment that [`experimental.saferExceptions`](https://scala-lang.org/api/3.x/scala/runtime/stdLibPatches/language$$experimental$$saferExceptions$.html) is turned on everywhere. There would be lots of code that breaks since functions have not yet been properly annotated with `throws`. But it's easy to create an escape hatch that lets us ignore the breakages for a while: simply add the import
+```scala
+import scala.unsafeExceptions.canThrowAny
+```
+This will provide the [`CanThrow`](https://scala-lang.org/api/3.x/scala/CanThrow.html) capability for any exception, and thereby allow
+all throws and all other calls, no matter what the current state of `throws` declarations is. Here's the
+definition of [`canThrowAny`](https://scala-lang.org/api/3.x/scala/unsafeExceptions$.html#canThrowAny-0):
+```scala
+package scala
+object unsafeExceptions:
+  given canThrowAny: CanThrow[Exception] = ???
+```
+Of course, defining a global capability like this amounts to cheating. But the cheating is useful for gradual typing. The import could be used to migrate existing code, or to
+enable more fluid explorations of code without regard for complete exception safety. At the end of these migrations or explorations the import should be removed.
+
+## Scope Of the Extension
+
+To summarize, the extension for safer exception checking consists of the following elements:
+
+ - It adds to the standard library the class `scala.CanThrow`, the type `scala.$throws`, and the [`scala.unsafeExceptions`](https://scala-lang.org/api/3.x/scala/unsafeExceptions$.html) object, as they were described above.
+ - It adds some desugaring rules ro rewrite `throws` types to cascaded `$throws` types.
+ - It augments the type checking of `throw` by _demanding_ a `CanThrow` capability or the thrown exception.
+ - It augments the type checking of `try` by _providing_ `CanThrow` capabilities for every caught exception.
+
+That's all. It's quite remarkable that one can do exception checking in this way without any special additions to the type system. We just need regular givens and context functions. Any runtime overhead is eliminated using `erased`.
+
+## Caveats
+
+Our capability model allows to declare and check the thrown exceptions of first-order code. But as it stands, it does not give us enough mechanism to enforce the _absence_ of
+capabilities for arguments to higher-order functions. Consider a variant `pureMap`
+of `map` that should enforce that its argument does not throw exceptions or have any other effects (maybe because wants to reorder computations transparently). Right now
+we cannot enforce that since the function argument to `pureMap` can capture arbitrary
+capabilities in its free variables without them showing up in its type. One possible way to
+address this would be to introduce a pure function type (maybe written `A -> B`). Pure functions are not allowed to close over capabilities. Then `pureMap` could be written
+like this:
+```scala
+  def pureMap(f: A -> B): List[B]
+```
+Another area where the lack of purity requirements shows up is when capabilities escape from bounded scopes. Consider the following function
+```scala
+def escaped(xs: Double*): () => Int =
+  try () => xs.map(f).sum
+  catch case ex: LimitExceeded => -1
+```
+With the system presented here, this function typechecks, with expansion
+```scala
+// compiler-generated code
+def escaped(xs: Double*): () => Int =
+  try
+    given ctl: CanThrow[LimitExceeded] = ???
+    () => xs.map(x => f(x)(using ctl)).sum
+  catch case ex: LimitExceeded => -1
+```
+But if you try to call `escaped` like this
+```scala
+val g = escaped(1, 2, 1000000000)
+g()
+```
+the result will be a `LimitExceeded` exception thrown at the second line where `g` is called. What's missing is that `try` should enforce that the capabilities it generates do not escape as free variables in the result of its body. It makes sense to describe such scoped effects as _ephemeral capabilities_ - they have lifetimes that cannot be extended to delayed code in a lambda.
+
+
+## Outlook
+
+We are working on a new class of type system that supports ephemeral capabilities by tracking the free variables of values. Once that research matures, it will hopefully be possible to augment the Scala language so that we can enforce the missing properties.
+
+And it would have many other applications besides: Exceptions are a special case of _algebraic effects_, which has been a very active research area over the last 20 years and is finding its way into programming languages (e.g. [Koka](https://koka-lang.github.io/koka/doc/book.html#why-handlers), [Eff](https://www.eff-lang.org/learn/), [Multicore OCaml](https://discuss.ocaml.org/t/multicore-ocaml-september-2021-effect-handlers-will-be-in-ocaml-5-0/8554), [Unison](https://www.unisonweb.org/docs/language-reference/#abilities-and-ability-handlers)). In fact, algebraic effects have been characterized as being equivalent to exceptions with an additional _resume_ operation. The techniques developed here for exceptions can probably be generalized to other classes of algebraic effects.
+
+But even without these additional mechanisms, exception checking is already useful as it is. It gives a clear path forward to make code that uses exceptions safer, better documented, and easier to refactor. The only loophole arises for scoped capabilities - here we have to verify manually that these capabilities do not escape. Specifically, a `try` always has to be placed in the same computation stage as the throws that it enables.
+
+Put another way: If the status quo is 0% static checking since 100% is too painful, then an alternative that gives you 95% static checking with great ergonomics looks like a win. And we might still get to 100% in the future.
+
+For more info, see also our [paper at the ACM Scala Symposium 2021](https://infoscience.epfl.ch/record/290885).
diff --git a/docs/_spec/TODOreference/experimental/cc.md b/docs/_spec/TODOreference/experimental/cc.md
new file mode 100644
index 000000000000..878bc0a64ed6
--- /dev/null
+++ b/docs/_spec/TODOreference/experimental/cc.md
@@ -0,0 +1,738 @@
+---
+layout: doc-page
+title: "Capture Checking"
+---
+
+Capture checking is a research project that modifies the Scala type system to track references to capabilities in values. It can be enabled with a `-Ycc` compiler option.
+At present, capture checking is still highly experimental and unstable.
+
+To get an idea what capture checking can do, let's start with a small example:
+```scala
+def usingLogFile[T](op: FileOutputStream => T): T =
+  val logFile = FileOutputStream("log")
+  val result = op(logFile)
+  logFile.close()
+  result
+```
+The `usingLogFile` method invokes a given operation with a fresh log file as parameter. Once the operation has ended, the log file is closed and the
+operation's result is returned. This is a typical _try-with-resources_ pattern, similar to many other such patterns which are often supported by special language constructs in other languages.
+
+The problem is that `usingLogFile`'s implementation is not entirely safe. One can
+undermine it by passing an operation that performs the logging at some later point
+after it has terminated. For instance:
+```scala
+val later = usingLogFile { file => () => file.write(0) }
+later() // crash
+```
+When `later` is executed it tries to write to a file that is already closed, which
+results in an uncaught `IOException`.
+
+Capture checking gives us the mechanism to prevent such errors _statically_. To
+prevent unsafe usages of `usingLogFile`, we can declare it like this:
+```scala
+def usingLogFile[T](op: ({*} FileOutputStream) => T): T =
+  // same body as before
+```
+The only thing that's changed is that the `FileOutputStream` parameter of `op` is now
+tagged with `{*}`. We'll see that this turns the parameter into a _capability_ whose lifetime is tracked.
+
+If we now try to define the problematic value `later`, we get a static error:
+```
+   |  val later = usingLogFile { f => () => f.write(0) }
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |The expression's type {*} () -> Unit is not allowed to capture the root capability `*`.
+   |This usually means that a capability persists longer than its allowed lifetime.
+```
+In this case, it was easy to see that the `logFile` capability escapes in the closure passed to `usingLogFile`. But capture checking also works for more complex cases.
+For instance, capture checking is able to distinguish between the following safe code:
+```scala
+val xs = usingLogFile { f =>
+  List(1, 2, 3).map { x => f.write(x); x * x }
+}
+```
+and the following unsafe one:
+```scala
+val xs = usingLogFile { f =>
+  LazyList(1, 2, 3).map { x => f.write(x); x * x }
+}
+```
+An error would be issued in the second case, but not the first one (this assumes a capture-aware
+formulation of `LazyList` which we will present later in this page).
+
+It turns out that capture checking has very broad applications. Besides the various
+try-with-resources patterns, it can also be a key part to the solutions of many other long standing problems in programming languages. Among them:
+
+ - How to have a simple and flexible system for checked exceptions. We show later
+   how capture checking enables a clean and fully safe system for checked exceptions in Scala.
+ - How to address the problem of effect polymorphism in general.
+ - How to solve the "what color is your function?" problem of mixing synchronous
+   and asynchronous computations.
+ - How to do region-based allocation, safely,
+ - How to reason about capabilities associated with memory locations.
+
+The following sections explain in detail how capture checking works in Scala 3.
+
+
+## Overview
+
+The capture checker extension introduces a new kind of types and it enforces some rules for working with these types.
+
+Capture checking is enabled by the compiler option `-Ycc`. If the option is not given, the new
+type forms can still be written but they are not checked for consistency, because they are
+treated simply as certain uninterpreted annotated types.
+
+## Capabilities and Capturing Types
+
+Capture checking is done in terms of _capturing types_ of the form
+`{c₁, ..., cᵢ} T`. Here `T` is a type, and `{c₁, ..., cᵢ}` is a _capture set_ consisting of references to capabilities `c₁, ..., cᵢ`.
+
+A _capability_ is syntactically a method- or class-parameter, a local variable, or the `this` of an enclosing class. The type of a capability
+must be a capturing type with a non-empty capture set. We also say that
+variables that are capabilities are _tracked_.
+
+In a sense, every
+capability gets its authority from some other, more sweeping capability which it captures. The most sweeping capability, from which ultimately all others are derived is written `*`. We call it the _universal capability_.
+
+Here is an example:
+```scala
+class FileSystem
+
+class Logger(fs: {*} FileSystem):
+  def log(s: String): Unit = ... // Write to a log file, using `fs`
+
+def test(fs: {*} FileSystem) =
+  val l: {fs} Logger = Logger(fs)
+  l.log("hello world!")
+  val xs: {l} LazyList[Int] =
+    LazyList.from(1)
+      .map { i =>
+        l.log(s"computing elem # $i")
+        i * i
+      }
+  xs
+```
+Here, the `test` method takes a `FileSystem` as a parameter. `fs` is a capability since its type has a non-empty capture set. The capability is passed to the `Logger` constructor
+and retained as a field in class `Logger`. Hence, the local variable `l` has type
+`{fs} Logger`: it is a `Logger` which retains the `fs` capability.
+
+The second variable defined in `test` is `xs`, a lazy list that is obtained from
+`LazyList.from(1)` by logging and mapping consecutive numbers. Since the list is lazy,
+it needs to retain the reference to the logger `l` for its computations. Hence, the
+type of the list is `{l} LazyList[Int]`. On the other hand, since `xs` only logs but does
+not do other file operations, it retains the `fs` capability only indirectly. That's why
+`fs` does not show up in the capture set of `xs`.
+
+Capturing types come with a subtype relation where types with "smaller" capture sets are subtypes of types with larger sets (the _subcapturing_ relation is defined in more detail below). If a type `T` does not have a capture set, it is called _pure_, and is a subtype of
+any capturing type that adds a capture set to `T`.
+
+## Function Types
+
+The usual function type `A => B` now stands for a function that can capture arbitrary capabilities. We call such functions
+_impure_. By contrast, the new single arrow function type `A -> B` stands for a function that cannot capture any capabilities, or otherwise said, is _pure_. One can add a capture set in front of an otherwise pure function.
+For instance, `{c, d} A -> B` would be a function that can capture capabilities `c` and `d`, but no others.
+
+The impure function type `A => B` is treated as an alias for `{*} A -> B`. That is, impure functions are functions that can capture anything.
+
+Function types and captures both associate to the right, so
+```scala
+{c} A -> {d} B -> C
+```
+is the same as
+```scala
+{c} (A -> {d} (B -> C))
+```
+Contrast with
+```scala
+({c} A) -> ({d} B) -> C
+```
+which is a curried pure function over argument types that can capture `c` and `d`, respectively.
+
+Analogous conventions apply to context function types. `A ?=> B` is an impure context function, with `A ?-> B` as its pure complement.
+
+**Note 1:** The identifiers `->` and `?->` are now treated as soft keywords when used as infix type operators. They are
+still available as regular identifiers for terms. For instance, the mapping syntax `Map("x" -> 1, "y" -> 2)` is still supported since it only applies to terms.
+
+**Note 2:** The distinctions between pure vs impure function types do not apply to methods. In fact, since methods are not values they never capture anything directly. References to
+capabilities in a method are instead counted in the capture set of the enclosing object.
+
+## By-Name Parameter Types
+
+A convention analogous to function types also extends to by-name parameters. In
+```scala
+def f(x: => Int): Int
+```
+the actual argument can refer to arbitrary capabilities. So the following would be OK:
+```scala
+f(if p(y) then throw Ex() else 1)
+```
+On the other hand, if `f` was defined like this
+```scala
+def f(x: -> Int): Int
+```
+the actual argument to `f` could not refer to any capabilities, so the call above would be rejected.
+One can also allow specific capabilities like this:
+```scala
+def f(x: {c}-> Int): Int
+```
+Here, the actual argument to `f` is allowed to use the `c` capability but no others.
+
+**Note**: It is strongly recommended to write the capability set and the arrow `->` without intervening spaces,
+as otherwise the notation would look confusingly like a function type.
+
+## Subtyping and Subcapturing
+
+Capturing influences subtyping. As usual we write `T₁ <: T₂` to express that the type
+`T₁` is a subtype of the type `T₂`, or equivalently, that `T₁` conforms to `T₂`. An
+analogous _subcapturing_ relation applies to capture sets. If `C₁` and `C₂` are capture sets, we write `C₁ <: C₂` to express that `C₁` _is covered by_ `C₂`, or, swapping the operands, that `C₂` _covers_ `C₁`.
+
+Subtyping extends as follows to capturing types:
+
+ - Pure types are subtypes of capturing types. That is, `T <: C T`, for any type `T`, capturing set `C`.
+ - For capturing types, smaller capturing sets produce subtypes: `C₁ T₁ <: C₂ T₂` if
+   `C₁ <: C₂` and `T₁ <: T₂`.
+
+A subcapturing relation `C₁ <: C₂` holds if `C₂` _accounts for_ every element `c` in `C₁`. This means one of the following three conditions must be true:
+
+ - `c ∈ C₂`,
+ - `c` refers to a parameter of some class `Cls` and `C₂` contains `Cls.this`,
+ - `c`'s type has capturing set `C` and `C₂` accounts for every element of `C` (that is, `C <: C₂`).
+
+
+**Example 1.** Given
+```scala
+fs: {*} FileSystem
+ct: {*} CanThrow[Exception]
+l : {fs} Logger
+```
+we have
+```
+{l}  <: {fs}     <: {*}
+{fs} <: {fs, ct} <: {*}
+{ct} <: {fs, ct} <: {*}
+```
+The set consisting of the root capability `{*}` covers every other capture set. This is
+a consequence of the fact that, ultimately, every capability is created from `*`.
+
+**Example 2.** Consider again the FileSystem/Logger example from before. `LazyList[Int]` is a proper subtype of `{l} LazyList[Int]`. So if the `test` method in that example
+was declared with a result type `LazyList[Int]`, we'd get a type error. Here is the error message:
+```
+11 |def test(using fs: {*} FileSystem): LazyList[Int] = {
+   |                                                    ^
+   |                                            Found:    {fs} LazyList[Int]
+   |                                            Required: LazyList[Int]
+```
+Why does it say `{fs} LazyList[Int]` and not `{l} LazyList[Int]`, which is, after all, the type of the returned value `xs`? The reason is that `l` is a local variable in the body of `test`, so it cannot be referred to in a type outside that body. What happens instead is that the type is _widened_ to the smallest supertype that does not mention `l`. Since `l` has capture set `fs`, we have that `{fs}` covers `{l}`, and `{fs}` is acceptable in a result type of `test`, so `{fs}` is the result of that widening.
+This widening is called _avoidance_; it is not specific to capture checking but applies to all variable references in Scala types.
+
+## Capability Classes
+
+Classes like `CanThrow` or `FileSystem` have the property that their values are always intended to be capabilities. We can make this intention explicit and save boilerplate by declaring these classes with a `@capability` annotation.
+
+The capture set of a capability class type is always `{*}`. This means we could equivalently express the `FileSystem` and `Logger` classes as follows:
+```scala
+import annotation.capability
+
+@capability class FileSystem
+
+class Logger(using FileSystem):
+  def log(s: String): Unit = ???
+
+def test(using fs: FileSystem) =
+  val l: {fs} Logger = Logger()
+  ...
+```
+In this version, `FileSystem` is a capability class, which means that the `{*}` capture set is implied on the parameters of `Logger` and `test`. Writing the capture set explicitly produces a warning:
+```scala
+class Logger(using {*} FileSystem):
+                   ^^^^^^^^^^^^^^
+             redundant capture: FileSystem already accounts for *
+```
+Another, unrelated change in the version of the last example here is that the `FileSystem` capability is now passed as an implicit parameter. It is quite natural to model capabilities with implicit parameters since it greatly reduces the wiring overhead once multiple capabilities are in play.
+
+## Capture Checking of Closures
+
+If a closure refers to capabilities in its body, it captures these capabilities in its type. For instance, consider:
+```scala
+def test(fs: FileSystem): {fs} String -> Unit =
+  (x: String) => Logger(fs).log(x)
+```
+Here, the body of `test` is a lambda that refers to the capability `fs`, which means that `fs` is retained in the lambda.
+Consequently, the type of the lambda is `{fs} String -> Unit`.
+
+**Note:** Function values are always written with `=>` (or `?=>` for context functions). There is no syntactic
+distinction for pure _vs_ impure function values. The distinction is only made in their types.
+
+A closure also captures all capabilities that are captured by the functions
+it calls. For instance, in
+```scala
+def test(fs: FileSystem) =
+  def f() = g()
+  def g() = (x: String) => Logger(fs).log(x)
+  f
+```
+the result of `test` has type `{fs} String -> Unit` even though function `f` itself does not refer to `fs`.
+
+## Capture Checking of Classes
+
+The principles for capture checking closures also apply to classes. For instance, consider:
+```scala
+class Logger(using fs: FileSystem):
+  def log(s: String): Unit = ... summon[FileSystem] ...
+
+def test(xfs: FileSystem): {xfs} Logger =
+  Logger(xfs)
+```
+Here, class `Logger` retains the capability `fs` as a (private) field. Hence, the result
+of `test` is of type `{xfs} Logger`
+
+Sometimes, a tracked capability is meant to be used only in the constructor of a class, but
+is not intended to be retained as a field. This fact can be communicated to the capture
+checker by declaring the parameter as `@constructorOnly`. Example:
+```scala
+import annotation.constructorOnly
+
+class NullLogger(using @constructorOnly fs: FileSystem):
+  ...
+def test2(using fs: FileSystem): NullLogger = NullLogger() // OK
+```
+
+The captured references of a class include _local capabilities_ and _argument capabilities_. Local capabilities are capabilities defined outside the class and referenced from its body. Argument capabilities are passed as parameters to the primary constructor of the class. Local capabilities are inherited:
+the local capabilities of a superclass are also local capabilities of its subclasses. Example:
+
+```scala
+@capability class Cap
+
+def test(a: Cap, b: Cap, c: Cap) =
+  class Super(y: Cap):
+    def f = a
+  class Sub(x: Cap) extends Super(x)
+    def g = b
+  Sub(c)
+```
+Here class `Super` has local capability `a`, which gets inherited by class
+`Sub` and is combined with `Sub`'s own local capability `b`. Class `Sub` also has an argument capability corresponding to its parameter `x`. This capability gets instantiated to `c` in the final constructor call `Sub(c)`. Hence,
+the capture set of that call is `{a, b, c}`.
+
+The capture set of the type of `this` of a class is inferred by the capture checker, unless the type is explicitly declared with a self type annotation like this one:
+```scala
+class C:
+  self: {a, b} D => ...
+```
+The inference observes the following constraints:
+
+ - The type of `this` of a class `C` includes all captured references of `C`.
+ - The type of `this` of a class `C` is a subtype of the type of `this`
+   of each parent class of `C`.
+ - The type of `this` must observe all constraints where `this` is used.
+
+For instance, in
+```scala
+@capability class Cap
+def test(c: Cap) =
+  class A:
+    val x: A = this
+    def f = println(c)  // error
+```
+we know that the type of `this` must be pure, since `this` is the right hand side of a `val` with type `A`. However, in the last line we find that the capture set of the class, and with it the capture set of `this`, would include `c`. This leads to a contradiction, and hence to a checking error:
+```
+16 |    def f = println(c)  // error
+   |                    ^
+   |(c : Cap) cannot be referenced here; it is not included in the allowed capture set {}
+```
+
+## Capture Tunnelling
+
+Consider the following simple definition of a `Pair` class:
+```scala
+class Pair[+A, +B](x: A, y: B):
+  def fst: A = x
+  def snd: B = y
+```
+What happens if `Pair` is instantiated like this (assuming `ct` and `fs` are two capabilities in scope)?
+```scala
+def x: {ct} Int -> String
+def y: {fs} Logger
+def p = Pair(x, y)
+```
+The last line will be typed as follows:
+```scala
+def p: Pair[{ct} Int -> String, {fs} Logger] = Pair(x, y)
+```
+This might seem surprising. The `Pair(x, y)` value does capture capabilities `ct` and `fs`. Why don't they show up in its type at the outside?
+
+The answer is capture tunnelling. Once a type variable is instantiated to a capturing type, the
+capture is not propagated beyond this point. On the other hand, if the type variable is instantiated
+again on access, the capture information "pops out" again. For instance, even though `p` is technically pure because its capture set is empty, writing `p.fst` would record a reference to the captured capability `ct`. So if this access was put in a closure, the capability would again form part of the outer capture set. E.g.
+```scala
+() => p.fst : {ct} () -> {ct} Int -> String
+```
+In other words, references to capabilities "tunnel through" in generic instantiations from creation to access; they do not affect the capture set of the enclosing generic data constructor applications.
+This principle plays an important part in making capture checking concise and practical.
+
+## Escape Checking
+
+The universal capability `*` should be conceptually available only as a parameter to the main program. Indeed, if it was available everywhere, capability checking would be undermined since one could mint new capabilities
+at will. In line with this reasoning, some capture sets are restricted so that
+they are not allowed to contain the universal capability.
+
+Specifically, if a capturing type is an instance of a type variable, that capturing type
+is not allowed to carry the universal capability `{*}`. There's a connection to tunnelling here.
+The capture set of a type has to be present in the environment when a type is instantiated from
+a type variable. But `*` is not itself available as a global entity in the environment. Hence,
+an error should result.
+
+We can now reconstruct how this principle produced the error in the introductory example, where
+`usingLogFile` was declared like this:
+```scala
+def usingLogFile[T](op: ({*} FileOutputStream) => T): T = ...
+```
+The error message was:
+```
+   |  val later = usingLogFile { f => () => f.write(0) }
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |The expression's type {*} () -> Unit is not allowed to capture the root capability `*`.
+   |This usually means that a capability persists longer than its allowed lifetime.
+```
+This error message was produced by the following logic:
+
+ - The `f` parameter has type `{*} FileOutputStream`, which makes it a capability.
+ - Therefore, the type of the expression `() => f.write(0)` is `{f} () -> Unit`.
+ - This makes the type of the whole closure passed to `usingLogFile` the dependent function type
+   `(f: {*} FileOutputStream) -> {f} () -> Unit`.
+ - The expected type of the closure is a simple, parametric, impure function type `({*} FileOutputStream) => T`,
+   for some instantiation of the type variable `T`.
+ - The smallest supertype of the closure's dependent function type that is a parametric function type is
+   `({*} FileOutputStream) => {*} () -> Unit`
+ - Hence, the type variable `T` is instantiated to `* () -> Unit`, which causes the error.
+
+An analogous restriction applies to the type of a mutable variable.
+Another way one could try to undermine capture checking would be to
+assign a closure with a local capability to a global variable. Maybe
+like this:
+```scala
+var loophole: {*} () -> Unit = () => ()
+usingLogFile { f =>
+  loophole = () => f.write(0)
+}
+loophole()
+```
+But this will not compile either, since mutable variables cannot have universal capture sets.
+
+One also needs to prevent returning or assigning a closure with a local capability in an argument of a parametric type. For instance, here is a
+slightly more refined attack:
+```scala
+class Cell[+A](x: A)
+val sneaky = usingLogFile { f => Cell(() => f.write(0)) }
+sneaky.x()
+```
+At the point where the `Cell` is created, the capture set of the argument is `f`, which
+is OK. But at the point of use, it is `*` (because `f` is no longer in scope), which causes again an error:
+```
+   |  sneaky.x()
+   |  ^^^^^^^^
+   |The expression's type {*} () -> Unit is not allowed to capture the root capability `*`.
+   |This usually means that a capability persists longer than its allowed lifetime.
+```
+
+Looking at object graphs, we observe a monotonicity property: The capture set of an object `x` covers the capture sets of all objects reachable through `x`. This property is reflected in the type system by the following _monotonicity rule_:
+
+ - In a class `C` with a field `f`, the capture set `{this}` covers the capture set `{this.f}` as well as the capture set of any application of `this.f` to pure arguments.
+
+## Checked Exceptions
+
+Scala enables checked exceptions through a language import. Here is an example,
+taken from the [safer exceptions page](./canthrow.md), and also described in a
+[paper](https://infoscience.epfl.ch/record/290885) presented at the
+ 2021 Scala Symposium.
+```scala
+import language.experimental.saferExceptions
+
+class LimitExceeded extends Exception
+
+val limit = 10e+10
+def f(x: Double): Double throws LimitExceeded =
+  if x < limit then x * x else throw LimitExceeded()
+```
+The new `throws` clause expands into an implicit parameter that provides
+a `CanThrow` capability. Hence, function `f` could equivalently be written
+like this:
+```scala
+def f(x: Double)(using CanThrow[LimitExceeded]): Double = ...
+```
+If the implicit parameter is missing, an error is reported. For instance, the  function definition
+```scala
+def g(x: Double): Double =
+  if x < limit then x * x else throw LimitExceeded()
+```
+is rejected with this error message:
+```
+  |  if x < limit then x * x else throw LimitExceeded()
+  |                               ^^^^^^^^^^^^^^^^^^^^^
+  |The capability to throw exception LimitExceeded is missing.
+  |The capability can be provided by one of the following:
+  | - Adding a using clause `(using CanThrow[LimitExceeded])` to the definition of the enclosing method
+  | - Adding `throws LimitExceeded` clause after the result type of the enclosing method
+  | - Wrapping this piece of code with a `try` block that catches LimitExceeded
+```
+`CanThrow` capabilities are required by `throw` expressions and are created
+by `try` expressions. For instance, the expression
+```scala
+try xs.map(f).sum
+catch case ex: LimitExceeded => -1
+```
+would be expanded by the compiler to something like the following:
+```scala
+try
+  erased given ctl: CanThrow[LimitExceeded] = compiletime.erasedValue
+  xs.map(f).sum
+catch case ex: LimitExceeded => -1
+```
+(The `ctl` capability is only used for type checking but need not show up in the generated code, so it can be declared as
+erased.)
+
+As with other capability based schemes, one needs to guard against capabilities
+that are captured in results. For instance, here is a problematic use case:
+```scala
+def escaped(xs: Double*): (() => Double) throws LimitExceeded =
+  try () => xs.map(f).sum
+  catch case ex: LimitExceeded => () => -1
+val crasher = escaped(1, 2, 10e+11)
+crasher()
+```
+This code needs to be rejected since otherwise the call to `crasher()` would cause
+an unhandled `LimitExceeded` exception to be thrown.
+
+Under `-Ycc`, the code is indeed rejected
+```
+14 |  try () => xs.map(f).sum
+   |  ^
+   |The expression's type {*} () -> Double is not allowed to capture the root capability `*`.
+   |This usually means that a capability persists longer than its allowed lifetime.
+15 |  catch case ex: LimitExceeded => () => -1
+```
+To integrate exception and capture checking, only two changes are needed:
+
+ - `CanThrow` is declared as a `@capability` class, so all references to `CanThrow` instances are tracked.
+ - Escape checking is extended to `try` expressions. The result type of a `try` is not allowed to
+   capture the universal capability.
+
+## A Larger Example
+
+As a larger example, we present an implementation of lazy lists and some use cases. For simplicity,
+our lists are lazy only in their tail part. This corresponds to what the Scala-2 type `Stream` did, whereas Scala 3's `LazyList` type computes strictly less since it is also lazy in the first argument.
+
+Here is the base trait `LzyList` for our version of lazy lists:
+```scala
+trait LzyList[+A]:
+  def isEmpty: Boolean
+  def head: A
+  def tail: {this} LzyList[A]
+```
+Note that `tail` carries a capture annotation. It says that the tail of a lazy list can
+potentially capture the same references as the lazy list as a whole.
+
+The empty case of a `LzyList` is written as usual:
+```scala
+object LzyNil extends LzyList[Nothing]:
+  def isEmpty = true
+  def head = ???
+  def tail = ???
+```
+Here is a formulation of the class for lazy cons nodes:
+```scala
+import scala.compiletime.uninitialized
+
+final class LzyCons[+A](hd: A, tl: () => {*} LzyList[A]) extends LzyList[A]:
+  private var forced = false
+  private var cache: {this} LzyList[A] = uninitialized
+  private def force =
+    if !forced then { cache = tl(); forced = true }
+    cache
+
+  def isEmpty = false
+  def head = hd
+  def tail: {this} LzyList[A] = force
+end LzyCons
+```
+The `LzyCons` class takes two parameters: A head `hd` and a tail `tl`, which is a function
+returning a `LzyList`. Both the function and its result can capture arbitrary capabilities.
+The result of applying the function is memoized after the first dereference of `tail` in
+the private mutable field `cache`. Note that the typing of the assignment `cache = tl()` relies on the monotonicity rule for `{this}` capture sets.
+
+Here is an extension method to define an infix cons operator `#:` for lazy lists. It is analogous
+to `::` but instead of a strict list it produces a lazy list without evaluating its right operand.
+```scala
+extension [A](x: A)
+  def #:(xs1: => {*} LzyList[A]): {xs1} LzyList[A] =
+    LzyCons(x, () => xs1)
+```
+Note that `#:` takes an impure call-by-name parameter `xs1` as its right argument. The result
+of `#:` is a lazy list that captures that argument.
+
+As an example usage of `#:`, here is a method `tabulate` that creates a lazy list
+of given length with a generator function `gen`. The generator function is allowed
+to have side effects.
+```scala
+def tabulate[A](n: Int)(gen: Int => A) =
+  def recur(i: Int): {gen} LzyList[A] =
+    if i == n then LzyNil
+    else gen(i) #: recur(i + 1)
+  recur(0)
+```
+Here is a use of `tabulate`:
+```scala
+class LimitExceeded extends Exception
+def squares(n: Int)(using ct: CanThrow[LimitExceeded]) =
+  tabulate(10) { i =>
+    if i > 9 then throw LimitExceeded()
+    i * i
+  }
+```
+The inferred result type of `squares` is `{ct} LzyList[Int]`, i.e it is a lazy list of
+`Int`s that can throw the `LimitExceeded` exception when it is elaborated by calling `tail`
+one or more times.
+
+Here are some further extension methods for mapping, filtering, and concatenating lazy lists:
+```scala
+extension [A](xs: {*} LzyList[A])
+  def map[B](f: A => B): {xs, f} LzyList[B] =
+    if xs.isEmpty then LzyNil
+    else f(xs.head) #: xs.tail.map(f)
+
+  def filter(p: A => Boolean): {xs, p} LzyList[A] =
+    if xs.isEmpty then LzyNil
+    else if p(xs.head) then xs.head #: xs.tail.filter(p)
+    else xs.tail.filter(p)
+
+  def concat(ys: {*} LzyList[A]): {xs, ys} LzyList[A] =
+    if xs.isEmpty then ys
+    else xs.head #: xs.tail.concat(ys)
+
+  def drop(n: Int): {xs} LzyList[A] =
+    if n == 0 then xs else xs.tail.drop(n - 1)
+```
+Their capture annotations are all as one would expect:
+
+ - Mapping a lazy list produces a lazy list that captures the original list as well
+   as the (possibly impure) mapping function.
+ - Filtering a lazy list produces a lazy list that captures the original list as well
+   as the (possibly impure) filtering predicate.
+ - Concatenating two lazy lists produces a lazy list that captures both arguments.
+ - Dropping elements from a lazy list gives a safe approximation where the original list is captured in the result. In fact, it's only some suffix of the list that is retained at run time, but our modelling identifies lazy lists and their suffixes, so this additional knowledge would not be useful.
+
+Of course the function passed to `map` or `filter` could also be pure. After all, `A -> B` is a subtype of `{*} A -> B` which is the same as `A => B`. In that case, the pure function
+argument will _not_ show up in the result type of `map` or `filter`. For instance:
+```scala
+val xs = squares(10)
+val ys: {xs} LzyList[Int] = xs.map(_ + 1)
+```
+The type of the mapped list `ys` has only `xs` in its capture set. The actual function
+argument does not show up since it is pure. Likewise, if the lazy list
+`xs` was pure, it would not show up in any of the method results.
+This demonstrates that capability-based
+effect systems with capture checking are naturally _effect polymorphic_.
+
+This concludes our example. It's worth mentioning that an equivalent program defining and using standard, strict lists would require no capture annotations whatsoever. It would compile exactly as written now in standard Scala 3, yet one gets the capture checking for free. Essentially, `=>` already means "can capture anything" and since in a strict list side effecting operations are not retained in the result, there are no additional captures to record. A strict list could of course capture side-effecting closures in its elements but then tunnelling applies, since
+these elements are represented by a type variable. This means we don't need to annotate anything there either.
+
+Another possibility would be a variant of lazy lists that requires all functions passed to `map`, `filter` and other operations like it to be pure. E.g. `map` on such a list would be defined like this:
+```scala
+extension [A](xs: LzyList[A])
+  def map[B](f: A -> B): LzyList[B] = ...
+```
+That variant would not require any capture annotations either.
+
+To summarize, there are two "sweet spots" of data structure design: strict lists in
+side-effecting or resource-aware code and lazy lists in purely functional code.
+Both are already correctly capture-typed without requiring any explicit annotations. Capture annotations only come into play where the semantics gets more complicated because we deal with delayed effects such as in impure lazy lists or side-effecting iterators over strict lists. This property is probably one of the greatest plus points of our approach to capture checking compared to previous techniques which tend to be more noisy.
+
+## Function Type Shorthands
+
+TBD
+
+## Compilation Options
+
+The following options are relevant for capture checking.
+
+ - **-Ycc** Enables capture checking.
+ - **-Xprint:cc** Prints the program with capturing types as inferred by capture checking.
+ - **-Ycc-debug** Gives more detailed, implementation-oriented information about capture checking, as described in the next section.
+
+ The implementation supporting capture checking with these options is currently in branch `cc-experiment` on dotty.epfl.ch.
+
+## Capture Checking Internals
+
+The capture checker is architected as a propagation constraint solver, which runs as a separate phase after type-checking and some initial transformations.
+
+Constraint variables stand for unknown capture sets. A constraint variable is introduced
+
+ - for every part of a previously inferred type,
+ - for the accessed references of every method, class, anonymous function, or by-name argument,
+ - for the parameters passed in a class constructor call.
+
+Capture sets in explicitly written types are treated as constants (before capture checking, such sets are simply ignored).
+
+The capture checker essentially rechecks the program with the usual typing rules. Every time a subtype requirement between capturing types is checked, this translates to a subcapturing test on capture sets. If the two sets are constant, this is simply a yes/no question, where a no will produce an error message.
+
+If the lower set `C₁` of a comparison `C₁ <: C₂` is a variable, the set `C₂` is recorded
+as a _superset_ of `C₁`. If the upper set `C₂` is a variable, the elements of `C₁` are _propagated_ to `C₂`. Propagation of an element `x` to a set `C` means that `x` is included as an element in `C`, and it is also propagated
+to all known supersets of `C`. If such a superset is a constant, it is checked that `x` is included in it. If that's not the case, the original comparison `C₁ <: C₂` has no solution and an error is reported.
+
+The type checker also performs various maps on types, for instance when substituting actual argument types for formal parameter types in dependent functions, or mapping
+member types with "as-seen-from" in a selection. Maps keep track of the variance
+of positions in a type. The variance is initially covariant, it flips to
+contravariant in function parameter positions, and can be either covariant,
+contravariant, or nonvariant in type arguments, depending on the variance of
+the type parameter.
+
+When capture checking, the same maps are also performed on capture sets. If a capture set is a constant, its elements (which are capabilities) are mapped as regular types. If the result of such a map is not a capability, the result is approximated according to the variance of the type. A covariant approximation replaces a type by its capture set.
+A contravariant approximation replaces it with the empty capture set. A nonvariant
+approximation replaces the enclosing capturing type with a range of possible types
+that gets propagated and resolved further out.
+
+When a mapping `m` is performed on a capture set variable `C`, a new variable `Cm` is created that contains the mapped elements and that is linked with `C`. If `C` subsequently acquires further elements through propagation, these are also propagated to `Cm` after being transformed by the `m` mapping. `Cm` also gets the same supersets as `C`, mapped again using `m`.
+
+One interesting aspect of the capture checker concerns the implementation of capture tunnelling. The [foundational theory](https://infoscience.epfl.ch/record/290885) on which capture checking is based makes tunnelling explicit through so-called _box_ and
+_unbox_ operations. Boxing hides a capture set and unboxing recovers it. The capture checker inserts virtual box and unbox operations based on actual and expected types similar to the way the type checker inserts implicit conversions. When capture set variables are first introduced, any capture set in a capturing type that is an instance of a type parameter instance is marked as "boxed". A boxing operation is
+inserted if the expected type of an expression is a capturing type with
+a boxed capture set variable. The effect of the insertion is that any references
+to capabilities in the boxed expression are forgotten, which means that capture
+propagation is stopped. Dually, if the actual type of an expression has
+a boxed variable as capture set, an unbox operation is inserted, which adds all
+elements of the capture set to the environment.
+
+Boxing and unboxing has no runtime effect, so the insertion of these operations is  only simulated; the only visible effect is the retraction and insertion
+of variables in the capture sets representing the environment of the currently checked expression.
+
+The `-Ycc-debug` option provides some insight into the workings of the capture checker.
+When it is turned on, boxed sets are marked explicitly and capture set variables are printed with an ID and some information about their provenance. For instance, the string `{f, xs}33M5V` indicates a capture set
+variable that is known to hold elements `f` and `xs`. The variable's ID is `33`. The `M`
+indicates that the variable was created through a mapping from a variable with ID `5`. The latter is a regular variable, as indicated
+ by `V`.
+
+Generally, the string following the capture set consists of alternating numbers and letters where each number gives a variable ID and each letter gives the provenance of the variable. Possible letters are
+
+ - `V` : a regular variable,
+ - `M` : a variable resulting from a _mapping_ of the variable indicated by the string to the right,
+ - `B` : similar to `M` but where the mapping is a _bijection_,
+ - `F` : a variable resulting from _filtering_ the elements of the variable indicated by the string to the right,
+ - `I` : a variable resulting from an _intersection_ of two capture sets,
+ - `D` : a variable resulting from the set _difference_ of two capture sets.
+
+At the end of a compilation run, `-Ycc-debug` will print all variable dependencies of variables referred to in previous output. Here is an example:
+```
+Capture set dependencies:
+  {}2V                 ::
+  {}3V                 ::
+  {}4V                 ::
+  {f, xs}5V            :: {f, xs}31M5V, {f, xs}32M5V
+  {f, xs}31M5V         :: {xs, f}
+  {f, xs}32M5V         ::
+```
+This section lists all variables that appeared in previous diagnostics and their dependencies, recursively. For instance, we learn that
+
+ - variables 2, 3, 4 are empty and have no dependencies,
+ - variable `5` has two dependencies: variables `31` and `32` which both result from mapping variable `5`,
+ - variable `31` has a constant fixed superset `{xs, f}`
+ - variable `32` has no dependencies.
+
diff --git a/docs/_spec/TODOreference/experimental/erased-defs-spec.md b/docs/_spec/TODOreference/experimental/erased-defs-spec.md
new file mode 100644
index 000000000000..5395a8468399
--- /dev/null
+++ b/docs/_spec/TODOreference/experimental/erased-defs-spec.md
@@ -0,0 +1,64 @@
+---
+layout: doc-page
+title: "Erased Definitions - More Details"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/experimental/erased-defs-spec.html
+---
+
+TODO: complete
+## Rules
+
+1. `erased` is a soft modifier. It can appear:
+   * At the start of a parameter block of a method, function or class
+   * In a method definition
+   * In a `val` definition (but not `lazy val` or `var`)
+   * In a `class` or `trait` definition
+
+    ```scala
+    erased val x = ...
+    erased def f = ...
+
+    def g(erased x: Int) = ...
+
+    (erased x: Int) => ...
+    def h(x: (erased Int) => Int) = ...
+
+    class K(erased x: Int) { ... }
+    erased class E {}
+    ```
+
+
+2. A reference to an `erased` val or def can only be used
+   * Inside the expression of argument to an `erased` parameter
+   * Inside the body of an `erased` `val` or `def`
+
+
+3. Functions
+   * `(erased x1: T1, x2: T2, ..., xN: TN) => y : (erased T1, T2, ..., TN) => R`
+   * `(given erased x1: T1, x2: T2, ..., xN: TN) => y: (given erased T1, T2, ..., TN) => R`
+   * `(given erased T1) => R  <:<  erased T1 => R`
+   * `(given erased T1, T2) => R  <:< (erased T1, T2) => R`
+   *  ...
+
+   Note that there is no subtype relation between `(erased T) => R` and `T => R` (or `(given erased T) => R` and `(given T) => R`)
+
+
+4. Eta expansion
+
+   if `def f(erased x: T): U` then `f: (erased T) => U`.
+
+
+5. Erasure semantics
+   * All `erased` parameters are removed from the function
+   * All argument to `erased` parameters are not passed to the function
+   * All `erased` definitions are removed
+   * All `(erased T1, T2, ..., TN) => R` and `(given erased T1, T2, ..., TN) => R` become `() => R`
+
+
+6. Overloading
+
+   Method with `erased` parameters will follow the normal overloading constraints after erasure.
+
+
+7. Overriding
+   * Member definitions overriding each other must both be `erased` or not be `erased`
+   * `def foo(x: T): U` cannot be overridden by `def foo(erased x: T): U` and vice-versa
diff --git a/docs/_spec/TODOreference/experimental/erased-defs.md b/docs/_spec/TODOreference/experimental/erased-defs.md
new file mode 100644
index 000000000000..28455f26cdc0
--- /dev/null
+++ b/docs/_spec/TODOreference/experimental/erased-defs.md
@@ -0,0 +1,231 @@
+---
+layout: doc-page
+title: "Erased Definitions"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/experimental/erased-defs.html
+---
+
+`erased` is a modifier that expresses that some definition or expression is erased by the compiler instead of being represented in the compiled output. It is not yet part of the Scala language standard. To enable `erased`, turn on the language feature
+[`experimental.erasedDefinitions`](https://scala-lang.org/api/3.x/scala/runtime/stdLibPatches/language$$experimental$$erasedDefinitions$.html). This can be done with a language import
+```scala
+import scala.language.experimental.erasedDefinitions
+```
+or by setting the command line option `-language:experimental.erasedDefinitions`.
+Erased definitions must be in an experimental scope (see [Experimental definitions](../other-new-features/experimental-defs.md)).
+
+## Why erased terms?
+
+Let's describe the motivation behind erased terms with an example. In the
+following we show a simple state machine which can be in a state `On` or `Off`.
+The machine can change state from `Off` to `On` with `turnedOn` only if it is
+currently `Off`. This last constraint is captured with the `IsOff[S]` contextual
+evidence which only exists for `IsOff[Off]`. For example, not allowing calling
+`turnedOn` on in an `On` state as we would require an evidence of type
+`IsOff[On]` that will not be found.
+
+```scala
+sealed trait State
+final class On extends State
+final class Off extends State
+
+@implicitNotFound("State must be Off")
+class IsOff[S <: State]
+object IsOff:
+  given isOff: IsOff[Off] = new IsOff[Off]
+
+class Machine[S <: State]:
+  def turnedOn(using IsOff[S]): Machine[On] = new Machine[On]
+
+val m = new Machine[Off]
+m.turnedOn
+m.turnedOn.turnedOn // ERROR
+//                 ^
+//                  State must be Off
+```
+
+Note that in the code above the actual context arguments for `IsOff` are never
+used at runtime; they serve only to establish the right constraints at compile
+time. As these terms are never used at runtime there is not real need to have
+them around, but they still need to be present in some form in the generated
+code to be able to do separate compilation and retain binary compatibility. We
+introduce _erased terms_ to overcome this limitation: we are able to enforce the
+right constrains on terms at compile time. These terms have no run time
+semantics and they are completely erased.
+
+## How to define erased terms?
+
+Parameters of methods and functions can be declared as erased, placing `erased`
+in front of a parameter list (like `given`).
+
+```scala
+def methodWithErasedEv(erased ev: Ev): Int = 42
+
+val lambdaWithErasedEv: erased Ev => Int =
+  (erased ev: Ev) => 42
+```
+
+`erased` parameters will not be usable for computations, though they can be used
+as arguments to other `erased` parameters.
+
+```scala
+def methodWithErasedInt1(erased i: Int): Int =
+  i + 42 // ERROR: can not use i
+
+def methodWithErasedInt2(erased i: Int): Int =
+  methodWithErasedInt1(i) // OK
+```
+
+Not only parameters can be marked as erased, `val` and `def` can also be marked
+with `erased`. These will also only be usable as arguments to `erased`
+parameters.
+
+```scala
+erased val erasedEvidence: Ev = ...
+methodWithErasedEv(erasedEvidence)
+```
+
+## What happens with erased values at runtime?
+
+As `erased` are guaranteed not to be used in computations, they can and will be
+erased.
+
+```scala
+// becomes def methodWithErasedEv(): Int at runtime
+def methodWithErasedEv(erased ev: Ev): Int = ...
+
+def evidence1: Ev = ...
+erased def erasedEvidence2: Ev = ... // does not exist at runtime
+erased val erasedEvidence3: Ev = ... // does not exist at runtime
+
+// evidence1 is not evaluated and no value is passed to methodWithErasedEv
+methodWithErasedEv(evidence1)
+```
+
+## State machine with erased evidence example
+
+The following example is an extended implementation of a simple state machine
+which can be in a state `On` or `Off`. The machine can change state from `Off`
+to `On` with `turnedOn` only if it is currently `Off`, conversely from `On` to
+`Off` with `turnedOff` only if it is currently `On`. These last constraint are
+captured with the `IsOff[S]` and `IsOn[S]` given evidence only exist for
+`IsOff[Off]` and `IsOn[On]`. For example, not allowing calling `turnedOff` on in
+an `Off` state as we would require an evidence `IsOn[Off]` that will not be
+found.
+
+As the given evidences of `turnedOn` and `turnedOff` are not used in the
+bodies of those functions we can mark them as `erased`. This will remove the
+evidence parameters at runtime, but we would still evaluate the `isOn` and
+`isOff` givens that were found as arguments. As `isOn` and `isOff` are not
+used except as `erased` arguments, we can mark them as `erased`, hence removing
+the evaluation of the `isOn` and `isOff` evidences.
+
+```scala
+import scala.annotation.implicitNotFound
+
+sealed trait State
+final class On extends State
+final class Off extends State
+
+@implicitNotFound("State must be Off")
+class IsOff[S <: State]
+object IsOff:
+  // will not be called at runtime for turnedOn, the
+  // compiler will only require that this evidence exists
+  given IsOff[Off] = new IsOff[Off]
+
+@implicitNotFound("State must be On")
+class IsOn[S <: State]
+object IsOn:
+  // will not exist at runtime, the compiler will only
+  // require that this evidence exists at compile time
+  erased given IsOn[On] = new IsOn[On]
+
+class Machine[S <: State] private ():
+  // ev will disappear from both functions
+  def turnedOn(using erased ev: IsOff[S]): Machine[On] = new Machine[On]
+  def turnedOff(using erased ev: IsOn[S]): Machine[Off] = new Machine[Off]
+
+object Machine:
+  def newMachine(): Machine[Off] = new Machine[Off]
+
+@main def test =
+  val m = Machine.newMachine()
+  m.turnedOn
+  m.turnedOn.turnedOff
+
+  // m.turnedOff
+  //            ^
+  //            State must be On
+
+  // m.turnedOn.turnedOn
+  //                    ^
+  //                    State must be Off
+```
+
+Note that in [Inline](../metaprogramming/inline.md) we discussed `erasedValue` and inline
+matches. `erasedValue` is implemented with `erased`, so the state machine above
+can be encoded as follows:
+
+```scala
+import scala.compiletime.*
+
+sealed trait State
+final class On extends State
+final class Off extends State
+
+class Machine[S <: State]:
+  transparent inline def turnOn(): Machine[On] =
+    inline erasedValue[S] match
+      case _: Off => new Machine[On]
+      case _: On  => error("Turning on an already turned on machine")
+
+  transparent inline def turnOff(): Machine[Off] =
+    inline erasedValue[S] match
+      case _: On  => new Machine[Off]
+      case _: Off => error("Turning off an already turned off machine")
+
+object Machine:
+  def newMachine(): Machine[Off] =
+    println("newMachine")
+    new Machine[Off]
+end Machine
+
+@main def test =
+  val m = Machine.newMachine()
+  m.turnOn()
+  m.turnOn().turnOff()
+  m.turnOn().turnOn() // error: Turning on an already turned on machine
+```
+
+## Erased Classes
+
+`erased` can also be used as a modifier for a class. An erased class is intended to be used only in erased definitions. If the type of a val definition or parameter is
+a (possibly aliased, refined, or instantiated) erased class, the definition is assumed to be `erased` itself. Likewise, a method with an erased class return type is assumed to be `erased` itself. Since given instances expand to vals and defs, they are also assumed to be erased if the type they produce is an erased class. Finally
+function types with erased classes as arguments turn into erased function types.
+
+Example:
+```scala
+erased class CanRead
+
+val x: CanRead = ...        // `x` is turned into an erased val
+val y: CanRead => Int = ... // the function is turned into an erased function
+def f(x: CanRead) = ...     // `f` takes an erased parameter
+def g(): CanRead = ...      // `g` is turned into an erased def
+given CanRead = ...         // the anonymous given is assumed to be erased
+```
+The code above expands to
+```scala
+erased class CanRead
+
+erased val x: CanRead = ...
+val y: (erased CanRead) => Int = ...
+def f(erased x: CanRead) = ...
+erased def g(): CanRead = ...
+erased given CanRead = ...
+```
+After erasure, it is checked that no references to values of erased classes remain and that no instances of erased classes are created. So the following would be an error:
+```scala
+val err: Any = CanRead() // error: illegal reference to erased class CanRead
+```
+Here, the type of `err` is `Any`, so `err` is not considered erased. Yet its initializing value is a reference to the erased class `CanRead`.
+
+[More Details](./erased-defs-spec.md)
diff --git a/docs/_spec/TODOreference/experimental/explicit-nulls.md b/docs/_spec/TODOreference/experimental/explicit-nulls.md
new file mode 100644
index 000000000000..b3fa53429cfe
--- /dev/null
+++ b/docs/_spec/TODOreference/experimental/explicit-nulls.md
@@ -0,0 +1,543 @@
+---
+layout: doc-page
+title: "Explicit Nulls"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/other-new-features/explicit-nulls.html
+---
+
+Explicit nulls is an opt-in feature that modifies the Scala type system, which makes reference types
+(anything that extends [`AnyRef`](https://scala-lang.org/api/3.x/scala/AnyRef.html)) _non-nullable_.
+
+This means the following code will no longer typecheck:
+
+```scala
+val x: String = null // error: found `Null`, but required `String`
+```
+
+Instead, to mark a type as nullable we use a [union type](../new-types/union-types.md)
+
+```scala
+val x: String | Null = null // ok
+```
+
+A nullable type could have null value during runtime; hence, it is not safe to select a member without checking its nullity.
+
+```scala
+x.trim // error: trim is not member of String | Null
+```
+
+Explicit nulls are enabled via a `-Yexplicit-nulls` flag.
+
+Read on for details.
+
+## New Type Hierarchy
+
+Originally, `Null` is a subtype of all reference types.
+
+!["Original Type Hierarchy"](images/explicit-nulls/scalaHierarchyWithMatchable.png)
+
+When explicit nulls is enabled, the type hierarchy changes so that `Null` is only
+a subtype of `Any` and `Matchable`, as opposed to every reference type,
+which means `null` is no longer a value of `AnyRef` and its subtypes.
+
+This is the new type hierarchy:
+
+!["Type Hierarchy for Explicit Nulls"](images/explicit-nulls/scalaHierarchyWithMatchableAndSafeNull.png)
+
+After erasure, `Null` remains a subtype of all reference types (as forced by the JVM).
+
+## Working with `Null`
+
+To make working with nullable values easier, we propose adding a few utilities to the standard library.
+So far, we have found the following useful:
+
+- An extension method `.nn` to "cast away" nullability
+
+  ```scala
+   extension [T](x: T | Null)
+     inline def nn: T =
+       assert(x != null)
+       x.asInstanceOf[T]
+  ```
+
+  This means that given `x: String | Null`, `x.nn` has type `String`, so we can call all the
+  usual methods on it. Of course, `x.nn` will throw a NPE if `x` is `null`.
+
+  Don't use `.nn` on mutable variables directly, because it may introduce an unknown type into the type of the variable.
+
+- An [`unsafeNulls`](https://scala-lang.org/api/3.x/scala/runtime/stdLibPatches/language$$unsafeNulls$.html) language feature.
+
+  When imported, `T | Null` can be used as `T`, similar to regular Scala (without explicit nulls).
+
+  See [UnsafeNulls](#unsafenulls) section for more details.
+
+## Unsoundness
+
+The new type system is unsound with respect to `null`. This means there are still instances where an expression has a non-nullable type like `String`, but its value is actually `null`.
+
+The unsoundness happens because uninitialized fields in a class start out as `null`:
+
+```scala
+class C:
+  val f: String = foo(f)
+  def foo(f2: String): String = f2
+
+val c = new C()
+// c.f == "field is null"
+```
+
+The unsoundness above can be caught by the compiler with the option `-Ysafe-init`.
+More details can be found in [safe initialization](../other-new-features/safe-initialization.md).
+
+## Equality
+
+We don't allow the double-equal (`==` and `!=`) and reference (`eq` and `ne`) comparison between
+`AnyRef` and `Null` anymore, since a variable with a non-nullable type cannot have `null` as value.
+`null` can only be compared with `Null`, nullable union (`T | Null`), or `Any` type.
+
+For some reason, if we really want to compare `null` with non-null values, we have to provide a type hint (e.g. `: Any`).
+
+```scala
+val x: String = ???
+val y: String | Null = ???
+
+x == null       // error: Values of types String and Null cannot be compared with == or !=
+x eq null       // error
+"hello" == null // error
+
+y == null       // ok
+y == x          // ok
+
+(x: String | Null) == null  // ok
+(x: Any) == null            // ok
+```
+
+## Java Interoperability
+
+The Scala compiler can load Java classes in two ways: from source or from bytecode. In either case,
+when a Java class is loaded, we "patch" the type of its members to reflect that Java types
+remain implicitly nullable.
+
+Specifically, we patch
+
+- the type of fields
+
+- the argument type and return type of methods
+
+We illustrate the rules with following examples:
+
+- The first two rules are easy: we nullify reference types but not value types.
+
+  ```java
+  class C {
+    String s;
+    int x;
+  }
+  ```
+
+  ==>
+
+  ```scala
+  class C:
+    val s: String | Null
+    val x: Int
+  ```
+
+- We nullify type parameters because in Java a type parameter is always nullable, so the following code compiles.
+
+  ```java
+  class C<T> { T foo() { return null; } }
+  ```
+
+  ==>
+
+  ```scala
+  class C[T] { def foo(): T | Null }
+  ```
+
+  Notice this is rule is sometimes too conservative, as witnessed by
+
+  ```scala
+  class InScala:
+    val c: C[Bool] = ???  // C as above
+    val b: Bool = c.foo() // no longer typechecks, since foo now returns Bool | Null
+  ```
+
+- We can reduce the number of redundant nullable types we need to add. Consider
+
+  ```java
+  class Box<T> { T get(); }
+  class BoxFactory<T> { Box<T> makeBox(); }
+  ```
+
+  ==>
+
+  ```scala
+  class Box[T] { def get(): T | Null }
+  class BoxFactory[T] { def makeBox(): Box[T] | Null }
+  ```
+
+  Suppose we have a `BoxFactory[String]`. Notice that calling `makeBox()` on it returns a
+  `Box[String] | Null`, not a `Box[String | Null] | Null`. This seems at first
+  glance unsound ("What if the box itself has `null` inside?"), but is sound because calling
+  `get()` on a `Box[String]` returns a `String | Null`.
+
+  Notice that we need to patch _all_ Java-defined classes that transitively appear in the
+  argument or return type of a field or method accessible from the Scala code being compiled.
+  Absent crazy reflection magic, we think that all such Java classes _must_ be visible to
+  the Typer in the first place, so they will be patched.
+
+- We will append `Null` to the type arguments if the generic class is defined in Scala.
+
+  ```java
+  class BoxFactory<T> {
+    Box<T> makeBox(); // Box is Scala-defined
+    List<Box<List<T>>> makeCrazyBoxes(); // List is Java-defined
+  }
+  ```
+
+  ==>
+
+  ```scala
+  class BoxFactory[T]:
+    def makeBox(): Box[T | Null] | Null
+    def makeCrazyBoxes(): java.util.List[Box[java.util.List[T] | Null]] | Null
+  ```
+
+  In this case, since `Box` is Scala-defined, we will get `Box[T | Null] | Null`.
+  This is needed because our nullability function is only applied (modularly) to the Java
+  classes, but not to the Scala ones, so we need a way to tell `Box` that it contains a
+  nullable value.
+
+  The `List` is Java-defined, so we don't append `Null` to its type argument. But we
+  still need to nullify its inside.
+
+- We don't nullify _simple_ literal constant (`final`) fields, since they are known to be non-null
+
+  ```java
+  class Constants {
+    final String NAME = "name";
+    final int AGE = 0;
+    final char CHAR = 'a';
+
+    final String NAME_GENERATED = getNewName();
+  }
+  ```
+
+  ==>
+
+  ```scala
+  class Constants:
+    val NAME: String("name") = "name"
+    val AGE: Int(0) = 0
+    val CHAR: Char('a') = 'a'
+
+    val NAME_GENERATED: String | Null = getNewName()
+  ```
+
+- We don't append `Null` to a field nor to a return type of a method which is annotated with a
+  `NotNull` annotation.
+
+  ```java
+  class C {
+    @NotNull String name;
+    @NotNull List<String> getNames(String prefix); // List is Java-defined
+    @NotNull Box<String> getBoxedName(); // Box is Scala-defined
+  }
+  ```
+
+  ==>
+
+  ```scala
+  class C:
+    val name: String
+    def getNames(prefix: String | Null): java.util.List[String] // we still need to nullify the paramter types
+    def getBoxedName(): Box[String | Null] // we don't append `Null` to the outmost level, but we still need to nullify inside
+  ```
+
+  The annotation must be from the list below to be recognized as `NotNull` by the compiler.
+  Check `Definitions.scala` for an updated list.
+
+  ```scala
+  // 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] = ctx.getClassesIfDefined(
+    "javax.annotation.Nonnull" ::
+    "edu.umd.cs.findbugs.annotations.NonNull" ::
+    "androidx.annotation.NonNull" ::
+    "android.support.annotation.NonNull" ::
+    "android.annotation.NonNull" ::
+    "com.android.annotations.NonNull" ::
+    "org.eclipse.jdt.annotation.NonNull" ::
+    "org.checkerframework.checker.nullness.qual.NonNull" ::
+    "org.checkerframework.checker.nullness.compatqual.NonNullDecl" ::
+    "org.jetbrains.annotations.NotNull" ::
+    "lombok.NonNull" ::
+    "io.reactivex.annotations.NonNull" :: Nil map PreNamedString)
+  ```
+
+### Override check
+
+When we check overriding between Scala classes and Java classes, the rules are relaxed for [`Null`](https://scala-lang.org/api/3.x/scala/Null.html) type with this feature, in order to help users to working with Java libraries.
+
+Suppose we have Java method `String f(String x)`, we can override this method in Scala in any of the following forms:
+
+```scala
+def f(x: String | Null): String | Null
+
+def f(x: String): String | Null
+
+def f(x: String | Null): String
+
+def f(x: String): String
+```
+
+Note that some of the definitions could cause unsoundness. For example, the return type is not nullable, but a `null` value is actually returned.
+
+## Flow Typing
+
+We added a simple form of flow-sensitive type inference. The idea is that if `p` is a
+stable path or a trackable variable, then we can know that `p` is non-null if it's compared
+with `null`. This information can then be propagated to the `then` and `else` branches
+of an if-statement (among other places).
+
+Example:
+
+```scala
+val s: String | Null = ???
+if s != null then
+  // s: String
+
+// s: String | Null
+
+assert(s != null)
+// s: String
+```
+
+A similar inference can be made for the `else` case if the test is `p == null`
+
+```scala
+if s == null then
+  // s: String | Null
+else
+  // s: String
+```
+
+`==` and `!=` is considered a comparison for the purposes of the flow inference.
+
+### Logical Operators
+
+We also support logical operators (`&&`, `||`, and `!`):
+
+```scala
+val s: String | Null = ???
+val s2: String | Null = ???
+if s != null && s2 != null then
+  // s: String
+  // s2: String
+
+if s == null || s2 == null then
+  // s: String | Null
+  // s2: String | Null
+else
+  // s: String
+  // s2: String
+```
+
+### Inside Conditions
+
+We also support type specialization _within_ the condition, taking into account that `&&` and `||` are short-circuiting:
+
+```scala
+val s: String | Null = ???
+
+if s != null && s.length > 0 then // s: String in `s.length > 0`
+  // s: String
+
+if s == null || s.length > 0 then // s: String in `s.length > 0`
+  // s: String | Null
+else
+  // s: String
+```
+
+### Match Case
+
+The non-null cases can be detected in match statements.
+
+```scala
+val s: String | Null = ???
+
+s match
+  case _: String => // s: String
+  case _ =>
+```
+
+### Mutable Variable
+
+We are able to detect the nullability of some local mutable variables. A simple example is:
+
+```scala
+class C(val x: Int, val next: C | Null)
+
+var xs: C | Null = C(1, C(2, null))
+// xs is trackable, since all assignments are in the same method
+while xs != null do
+  // xs: C
+  val xsx: Int = xs.x
+  val xscpy: C = xs
+  xs = xscpy // since xscpy is non-null, xs still has type C after this line
+  // xs: C
+  xs = xs.next // after this assignment, xs can be null again
+  // xs: C | Null
+```
+
+When dealing with local mutable variables, there are two questions:
+
+1. Whether to track a local mutable variable during flow typing.
+   We track a local mutable variable if 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 then
+      // y can be called here, which would break the fact
+      val a: String = x // error: x is captured and mutated by the closure, not trackable
+   ```
+
+2. 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, 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 then
+       // 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 then
+     val a: String = x // ok to use the fact here
+     x = null
+   ```
+
+See [more examples](https://github.com/lampepfl/dotty/blob/main/tests/explicit-nulls/neg/flow-varref-in-closure.scala).
+
+Currently, we are unable to track paths with a mutable variable prefix.
+For example, `x.a` if `x` is mutable.
+
+### Unsupported Idioms
+
+We don't support:
+
+- flow facts not related to nullability (`if x == 0 then { // x: 0.type not inferred }`)
+- tracking aliasing between non-nullable paths
+
+  ```scala
+  val s: String | Null = ???
+  val s2: String | Null = ???
+  if s != null && s == s2 then
+    // s:  String inferred
+    // s2: String not inferred
+  ```
+
+### UnsafeNulls
+
+It is difficult to work with many nullable values, we introduce a language feature [`unsafeNulls`](https://scala-lang.org/api/3.x/scala/runtime/stdLibPatches/language$$unsafeNulls$.html).
+Inside this "unsafe" scope, all `T | Null` values can be used as `T`.
+
+Users can import [`scala.language.unsafeNulls`](https://scala-lang.org/api/3.x/scala/runtime/stdLibPatches/language$$unsafeNulls$.html) to create such scopes, or use `-language:unsafeNulls` to enable this feature globally (for migration purpose only).
+
+Assume `T` is a reference type (a subtype of `AnyRef`), the following unsafe operation rules are
+applied in this unsafe-nulls scope:
+
+1. the members of `T` can be found on `T | Null`
+
+2. a value with type `T` can be compared with `T | Null` and `Null`
+
+3. suppose `T1` is not a subtype of `T2` using explicit-nulls subtyping (where `Null` is a direct
+subtype of Any), extension methods and implicit conversions designed for `T2` can be used for
+`T1` if `T1` is a subtype of `T2` using regular subtyping rules (where `Null` is a subtype of every
+reference type)
+
+4. suppose `T1` is not a subtype of `T2` using explicit-nulls subtyping, a value with type `T1`
+can be used as `T2` if `T1` is a subtype of `T2` using regular subtyping rules
+
+Addtionally, `null` can be used as `AnyRef` (`Object`), which means you can select `.eq` or `.toString` on it.
+
+The program in [`unsafeNulls`](https://scala-lang.org/api/3.x/scala/runtime/stdLibPatches/language$$unsafeNulls$.html) will have a **similar** semantic as regular Scala, but not **equivalent**.
+
+For example, the following code cannot be compiled even using unsafe nulls. Because of the
+Java interoperation, the type of the get method becomes `T | Null`.
+
+```scala
+def head[T](xs: java.util.List[T]): T = xs.get(0) // error
+```
+
+Since the compiler doesn’t know whether `T` is a reference type, it is unable to cast `T | Null`
+to `T`. A `.nn` need to be inserted after `xs.get(0)` by user manually to fix the error, which
+strips the `Null` from its type.
+
+The intention of this [`unsafeNulls`](https://scala-lang.org/api/3.x/scala/runtime/stdLibPatches/language$$unsafeNulls$.html) is to give users a better migration path for explicit nulls.
+Projects for Scala 2 or regular Scala 3 can try this by adding `-Yexplicit-nulls -language:unsafeNulls`
+to the compile options. A small number of manual modifications are expected. To migrate to the full
+explicit nulls feature in the future, `-language:unsafeNulls` can be dropped and add
+`import scala.language.unsafeNulls` only when needed.
+
+```scala
+def f(x: String): String = ???
+def nullOf[T >: Null]: T = null
+
+import scala.language.unsafeNulls
+
+val s: String | Null = ???
+val a: String = s // unsafely convert String | Null to String
+
+val b1 = s.trim // call .trim on String | Null unsafely
+val b2 = b1.length
+
+f(s).trim // pass String | Null as an argument of type String unsafely
+
+val c: String = null // Null to String
+
+val d1: Array[String] = ???
+val d2: Array[String | Null] = d1 // unsafely convert Array[String] to Array[String | Null]
+val d3: Array[String] = Array(null) // unsafe
+
+class C[T >: Null <: String] // define a type bound with unsafe conflict bound
+
+val n = nullOf[String] // apply a type bound unsafely
+```
+
+Without the [`unsafeNulls`](https://scala-lang.org/api/3.x/scala/runtime/stdLibPatches/language$$unsafeNulls$.html), all these unsafe operations will not be type-checked.
+
+[`unsafeNulls`](https://scala-lang.org/api/3.x/scala/runtime/stdLibPatches/language$$unsafeNulls$.html) also works for extension methods and implicit search.
+
+```scala
+import scala.language.unsafeNulls
+
+val x = "hello, world!".split(" ").map(_.length)
+
+given Conversion[String, Array[String]] = _ => ???
+
+val y: String | Null = ???
+val z: Array[String | Null] = y
+```
+
+## Binary Compatibility
+
+Our strategy for binary compatibility with Scala binaries that predate explicit nulls
+and new libraries compiled without `-Yexplicit-nulls` is to leave the types unchanged
+and be compatible but unsound.
+
+[More details](https://dotty.epfl.ch/docs/internals/explicit-nulls.html)
diff --git a/docs/_spec/TODOreference/experimental/fewer-braces.md b/docs/_spec/TODOreference/experimental/fewer-braces.md
new file mode 100644
index 000000000000..eb454886ad03
--- /dev/null
+++ b/docs/_spec/TODOreference/experimental/fewer-braces.md
@@ -0,0 +1,7 @@
+---
+layout: doc-page
+title: "Fewer Braces"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/experimental/fewer-braces.html
+---
+
+The documentation contained in this file is now part of [./indentation.html].
\ No newline at end of file
diff --git a/docs/_spec/TODOreference/experimental/main-annotation.md b/docs/_spec/TODOreference/experimental/main-annotation.md
new file mode 100644
index 000000000000..0c60e1050b87
--- /dev/null
+++ b/docs/_spec/TODOreference/experimental/main-annotation.md
@@ -0,0 +1,97 @@
+---
+layout: doc-page
+title: "MainAnnotation"
+---
+
+`MainAnnotation` provides a generic way to define main annotations such as `@main`.
+
+When a users annotates a method with an annotation that extends `MainAnnotation` a class with a `main` method will be generated. The main method will contain the code needed to parse the command line arguments and run the application.
+
+```scala
+/** Sum all the numbers
+ *
+ *  @param first Fist number to sum
+ *  @param rest The rest of the numbers to sum
+ */
+@myMain def sum(first: Int, second: Int = 0, rest: Int*): Int = first + second + rest.sum
+```
+
+```scala
+object foo {
+  def main(args: Array[String]): Unit = {
+    val mainAnnot = new myMain()
+    val info = new Info(
+      name = "foo.main",
+      documentation = "Sum all the numbers",
+      parameters = Seq(
+        new Parameter("first", "scala.Int", hasDefault=false, isVarargs=false, "Fist number to sum", Seq()),
+        new Parameter("second", "scala.Int", hasDefault=true, isVarargs=false, "", Seq()),
+        new Parameter("rest", "scala.Int" , hasDefault=false, isVarargs=true, "The rest of the numbers to sum", Seq())
+      )
+    )
+    val mainArgsOpt = mainAnnot.command(info, args)
+    if mainArgsOpt.isDefined then
+      val mainArgs = mainArgsOpt.get
+      val args0 = mainAnnot.argGetter[Int](info.parameters(0), mainArgs(0), None) // using a parser of Int
+      val args1 = mainAnnot.argGetter[Int](info.parameters(1), mainArgs(1), Some(() => sum$default$1())) // using a parser of Int
+      val args2 = mainAnnot.varargGetter[Int](info.parameters(2), mainArgs.drop(2)) // using a parser of Int
+      mainAnnot.run(() => sum(args0(), args1(), args2()*))
+  }
+}
+```
+
+The implementation of the `main` method first instantiates the annotation and then call `command`.
+When calling the `command`, the arguments can be checked and preprocessed.
+Then it defines a series of argument getters calling `argGetter` for each parameter and `varargGetter` for the last one if it is a varargs. `argGetter` gets an optional lambda that computes the default argument.
+Finally, the `run` method is called to run the application. It receives a by-name argument that contains the call the annotated method with the instantiations arguments (using the lambdas from `argGetter`/`varargGetter`).
+
+
+Example of implementation of `myMain` that takes all arguments positionally. It used `util.CommandLineParser.FromString` and expects no default arguments. For simplicity, any errors in preprocessing or parsing results in crash.
+
+```scala
+// Parser used to parse command line arguments
+import scala.util.CommandLineParser.FromString[T]
+
+// Result type of the annotated method is Int and arguments are parsed using FromString
+@experimental class myMain extends MainAnnotation[FromString, Int]:
+  import MainAnnotation.{ Info, Parameter }
+
+  def command(info: Info, args: Seq[String]): Option[Seq[String]] =
+    if args.contains("--help") then
+      println(info.documentation)
+      None // do not parse or run the program
+    else if info.parameters.exists(_.hasDefault) then
+      println("Default arguments are not supported")
+      None
+    else if info.hasVarargs then
+      val numPlainArgs = info.parameters.length - 1
+      if numPlainArgs > args.length then
+        println("Not enough arguments")
+        None
+      else
+        Some(args)
+    else
+      if info.parameters.length > args.length then
+        println("Not enough arguments")
+        None
+      else if info.parameters.length < args.length then
+        println("Too many arguments")
+        None
+      else
+        Some(args)
+
+  def argGetter[T](param: Parameter, arg: String, defaultArgument: Option[() => T])(using parser: FromString[T]): () => T =
+    () => parser.fromString(arg)
+
+  def varargGetter[T](param: Parameter, args: Seq[String])(using parser: FromString[T]): () => Seq[T] =
+    () => args.map(arg => parser.fromString(arg))
+
+  def run(program: () => Int): Unit =
+    println("executing program")
+
+    val result = program()
+    println("result: " + result)
+    println("executed program")
+    
+end myMain
+```
diff --git a/docs/_spec/TODOreference/experimental/named-typeargs-spec.md b/docs/_spec/TODOreference/experimental/named-typeargs-spec.md
new file mode 100644
index 000000000000..9e1113bbac86
--- /dev/null
+++ b/docs/_spec/TODOreference/experimental/named-typeargs-spec.md
@@ -0,0 +1,41 @@
+---
+layout: doc-page
+title: "Named Type Arguments - More Details"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/experimental/named-typeargs-spec.html
+---
+
+In this section we give more details about the [named type arguments](named-typeargs.md) (*experimental*).
+
+## Syntax
+
+The addition to the grammar is:
+
+```
+SimpleExpr1       ::=  ...
+                    |  SimpleExpr (TypeArgs | NamedTypeArgs)
+NamedTypeArgs     ::=  ‘[’ NamedTypeArg {‘,’ NamedTypeArg} ‘]’
+NamedTypeArg      ::=  id ‘=’ Type
+```
+
+Note in particular that named arguments cannot be passed to type constructors:
+
+``` scala
+class C[T]
+
+val x: C[T = Int] = // error
+  new C[T = Int] // error
+
+class E extends C[T = Int] // error
+```
+
+## Compatibility considerations
+
+Named type arguments do not have an impact on binary compatibility, but they
+have an impact on source compatibility: if the name of a method type parameter
+is changed, any existing named reference to this parameter will break. This
+means that the names of method type parameters are now part of the public API
+of a library.
+
+(Unimplemented proposal: to mitigate this,
+[`scala.deprecatedName`](https://www.scala-lang.org/api/current/scala/deprecatedName.html)
+could be extended to also be applicable on method type parameters.)
diff --git a/docs/_spec/TODOreference/experimental/named-typeargs.md b/docs/_spec/TODOreference/experimental/named-typeargs.md
new file mode 100644
index 000000000000..4928a40f8a6a
--- /dev/null
+++ b/docs/_spec/TODOreference/experimental/named-typeargs.md
@@ -0,0 +1,34 @@
+---
+layout: doc-page
+title: "Named Type Arguments"
+redirectFrom: /docs/reference/other-new-features/named-typeargs.html
+nightlyOf: https://docs.scala-lang.org/scala3/reference/experimental/named-typeargs.html
+---
+
+**Note:** This feature is implemented in Scala 3, but is not expected to be part of Scala 3.0.
+
+Type arguments of methods can now be specified by name as well as by position. Example:
+
+``` scala
+def construct[Elem, Coll[_]](xs: Elem*): Coll[Elem] = ???
+
+val xs1 = construct[Coll = List, Elem = Int](1, 2, 3)
+val xs2 = construct[Coll = List](1, 2, 3)
+```
+
+Similar to a named value argument `(x = e)`, a named type argument
+`[X = T]` instantiates the type parameter `X` to the type `T`.
+Named type arguments do not have to be in order (see `xs1` above) and
+unspecified arguments are inferred by the compiler (see `xs2` above).
+Type arguments must be all named or un-named, mixtures of named and
+positional type arguments are not supported.
+
+## Motivation
+
+The main benefit of named type arguments is that unlike positional arguments,
+you are allowed to omit passing arguments for some parameters, like in the
+definition of `xs2` above. A missing type argument is inferred as usual by
+local type inference. This is particularly useful in situations where some type
+arguments can be easily inferred from others.
+
+[More details](./named-typeargs-spec.md)
diff --git a/docs/_spec/TODOreference/experimental/numeric-literals.md b/docs/_spec/TODOreference/experimental/numeric-literals.md
new file mode 100644
index 000000000000..f493ef459265
--- /dev/null
+++ b/docs/_spec/TODOreference/experimental/numeric-literals.md
@@ -0,0 +1,257 @@
+---
+layout: doc-page
+title: "Numeric Literals"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/experimental/numeric-literals.html
+---
+
+**Note**: This feature is not yet part of the Scala 3 language definition. It can be made available by a language import:
+
+```scala
+import scala.language.experimental.genericNumberLiterals
+```
+
+In Scala 2, numeric literals were confined to the primitive numeric types `Int`, `Long`, `Float`, and `Double`. Scala 3 allows to write numeric literals also for user-defined types. Example:
+
+```scala
+val x: Long = -10_000_000_000
+val y: BigInt = 0x123_abc_789_def_345_678_901
+val z: BigDecimal = 110_222_799_799.99
+
+(y: BigInt) match
+  case 123_456_789_012_345_678_901 =>
+```
+
+The syntax of numeric literals is the same as before, except there are no pre-set limits
+how large they can be.
+
+## Meaning of Numeric Literals
+
+The meaning of a numeric literal is determined as follows:
+
+- If the literal ends with `l` or `L`, it is a `Long` integer (and must fit in its legal range).
+- If the literal ends with `f` or `F`, it is a single precision floating point number of type `Float`.
+- If the literal ends with `d` or `D`, it is a double precision floating point number of type `Double`.
+
+In each of these cases the conversion to a number is exactly as in Scala 2 or in Java. If a numeric literal does _not_ end in one of these suffixes, its meaning is determined by the expected type:
+
+1. If the expected type is `Int`, `Long`, `Float`, or `Double`, the literal is
+   treated as a standard literal of that type.
+2. If the expected type is a fully defined type `T` that has a given instance of type
+   [`scala.util.FromDigits[T]`](https://scala-lang.org/api/3.x/scala/util/FromDigits.html), the literal is converted to a value of type `T` by passing it as an argument to
+   the `fromDigits` method of that instance (more details below).
+3. Otherwise, the literal is treated as a `Double` literal (if it has a decimal point or an
+   exponent), or as an `Int` literal (if not). (This last possibility is again as in Scala 2 or Java.)
+
+With these rules, the definition
+
+```scala
+val x: Long = -10_000_000_000
+```
+
+is legal by rule (1), since the expected type is `Long`. The definitions
+
+```scala
+val y: BigInt = 0x123_abc_789_def_345_678_901
+val z: BigDecimal = 111222333444.55
+```
+
+are legal by rule (2), since both `BigInt` and `BigDecimal` have [`FromDigits`](https://scala-lang.org/api/3.x/scala/util/FromDigits.html) instances (which implement the `FromDigits` subclasses [`FromDigits.WithRadix`](https://scala-lang.org/api/3.x/scala/util/FromDigits$$WithRadix.html) and [`FromDigits.Decimal`](https://scala-lang.org/api/3.x/scala/util/FromDigits$$Decimal.html), respectively). On the other hand,
+
+```scala
+val x = -10_000_000_000
+```
+
+gives a type error, since without an expected type `-10_000_000_000` is treated by rule (3) as an `Int` literal, but it is too large for that type.
+
+## The `FromDigits` Trait
+
+To allow numeric literals, a type simply has to define a `given` instance of the
+[`scala.util.FromDigits`](https://scala-lang.org/api/3.x/scala/util/FromDigits.html) type class, or one of its subclasses. `FromDigits` is defined as follows:
+
+```scala
+trait FromDigits[T]:
+  def fromDigits(digits: String): T
+```
+
+Implementations of `fromDigits` convert strings of digits to the values of the
+implementation type `T`.
+The `digits` string consists of digits between `0` and `9`, possibly preceded by a
+sign ("+" or "-"). Number separator characters `_` are filtered out before
+the string is passed to `fromDigits`.
+
+The companion object [`FromDigits`](https://scala-lang.org/api/3.x/scala/util/FromDigits$.html) also defines subclasses of `FromDigits` for whole numbers with a given radix, for numbers with a decimal point, and for numbers that can have both a decimal point and an exponent:
+
+```scala
+object FromDigits:
+
+  /** A subclass of `FromDigits` that also allows to convert whole
+   *  number literals with a radix other than 10
+   */
+  trait WithRadix[T] extends FromDigits[T]:
+    def fromDigits(digits: String): T = fromDigits(digits, 10)
+    def fromDigits(digits: String, radix: Int): T
+
+  /** A subclass of `FromDigits` that also allows to convert number
+   *  literals containing a decimal point ".".
+   */
+  trait Decimal[T] extends FromDigits[T]
+
+  /** A subclass of `FromDigits`that allows also to convert number
+   *  literals containing a decimal point "." or an
+   *  exponent `('e' | 'E')['+' | '-']digit digit*`.
+   */
+  trait Floating[T] extends Decimal[T]
+```
+
+A user-defined number type can implement one of those, which signals to the compiler
+that hexadecimal numbers, decimal points, or exponents are also accepted in literals
+for this type.
+
+## Error Handling
+
+`FromDigits` implementations can signal errors by throwing exceptions of some subtype
+of [`FromDigitsException`](https://scala-lang.org/api/3.x/scala/util/FromDigits$$FromDigitsException.html). `FromDigitsException` is defined with three subclasses in the
+`FromDigits` object as follows:
+
+```scala
+abstract class FromDigitsException(msg: String) extends NumberFormatException(msg)
+
+class NumberTooLarge (msg: String = "number too large")         extends FromDigitsException(msg)
+class NumberTooSmall (msg: String = "number too small")         extends FromDigitsException(msg)
+class MalformedNumber(msg: String = "malformed number literal") extends FromDigitsException(msg)
+```
+
+## Example
+
+As a fully worked out example, here is an implementation of a new numeric class, `BigFloat`, that accepts numeric literals. `BigFloat` is defined in terms of a `BigInt` mantissa and an `Int` exponent:
+
+```scala
+case class BigFloat(mantissa: BigInt, exponent: Int):
+  override def toString = s"${mantissa}e${exponent}"
+```
+
+`BigFloat` literals can have a decimal point as well as an exponent. E.g. the following expression
+should produce the `BigFloat` number `BigFloat(-123, 997)`:
+
+```scala
+-0.123E+1000: BigFloat
+```
+
+The companion object of `BigFloat` defines an `apply` constructor method to construct a `BigFloat`
+from a `digits` string. Here is a possible implementation:
+
+```scala
+object BigFloat:
+  import scala.util.FromDigits
+
+  def apply(digits: String): BigFloat =
+    val (mantissaDigits, givenExponent) =
+      digits.toUpperCase.split('E') match
+        case Array(mantissaDigits, edigits) =>
+          val expo =
+            try FromDigits.intFromDigits(edigits)
+            catch case ex: FromDigits.NumberTooLarge =>
+              throw FromDigits.NumberTooLarge(s"exponent too large: $edigits")
+          (mantissaDigits, expo)
+        case Array(mantissaDigits) =>
+          (mantissaDigits, 0)
+    val (intPart, exponent) =
+      mantissaDigits.split('.') match
+        case Array(intPart, decimalPart) =>
+          (intPart ++ decimalPart, givenExponent - decimalPart.length)
+        case Array(intPart) =>
+          (intPart, givenExponent)
+    BigFloat(BigInt(intPart), exponent)
+```
+
+To accept `BigFloat` literals, all that's needed in addition is a `given` instance of type
+`FromDigits.Floating[BigFloat]`:
+
+```scala
+  given FromDigits: FromDigits.Floating[BigFloat] with
+    def fromDigits(digits: String) = apply(digits)
+end BigFloat
+```
+
+Note that the `apply` method does not check the format of the `digits` argument. It is
+assumed that only valid arguments are passed. For calls coming from the compiler
+that assumption is valid, since the compiler will first check whether a numeric
+literal has the correct format before it gets passed on to a conversion method.
+
+## Compile-Time Errors
+
+With the setup of the previous section, a literal like
+
+```scala
+1e10_0000_000_000: BigFloat
+```
+
+would be expanded by the compiler to
+
+```scala
+BigFloat.FromDigits.fromDigits("1e100000000000")
+```
+
+Evaluating this expression throws a [`NumberTooLarge`](https://scala-lang.org/api/3.x/scala/util/FromDigits$$NumberTooLarge.html) exception at run time. We would like it to
+produce a compile-time error instead. We can achieve this by tweaking the `BigFloat` class
+with a small dose of metaprogramming. The idea is to turn the `fromDigits` method
+into a macro, i.e. make it an inline method with a splice as right-hand side.
+To do this, replace the `FromDigits` instance in the `BigFloat` object by the following two definitions:
+
+```scala
+object BigFloat:
+  ...
+
+  class FromDigits extends FromDigits.Floating[BigFloat]:
+    def fromDigits(digits: String) = apply(digits)
+
+  given FromDigits with
+    override inline def fromDigits(digits: String) = ${
+      fromDigitsImpl('digits)
+    }
+```
+
+Note that an inline method cannot directly fill in for an abstract method, since it produces
+no code that can be executed at runtime. That is why we define an intermediary class
+`FromDigits` that contains a fallback implementation which is then overridden by the inline
+method in the `FromDigits` given instance. That method is defined in terms of a macro
+implementation method `fromDigitsImpl`. Here is its definition:
+
+```scala
+  private def fromDigitsImpl(digits: Expr[String])(using ctx: Quotes): Expr[BigFloat] =
+    digits.value match
+      case Some(ds) =>
+        try
+          val BigFloat(m, e) = apply(ds)
+          '{BigFloat(${Expr(m)}, ${Expr(e)})}
+        catch case ex: FromDigits.FromDigitsException =>
+          ctx.error(ex.getMessage)
+          '{BigFloat(0, 0)}
+      case None =>
+        '{apply($digits)}
+end BigFloat
+```
+
+The macro implementation takes an argument of type `Expr[String]` and yields
+a result of type `Expr[BigFloat]`. It tests whether its argument is a constant
+string. If that is the case, it converts the string using the `apply` method
+and lifts the resulting `BigFloat` back to `Expr` level. For non-constant
+strings `fromDigitsImpl(digits)` is simply `apply(digits)`, i.e. everything is
+evaluated at runtime in this case.
+
+The interesting part is the `catch` part of the case where `digits` is constant.
+If the `apply` method throws a `FromDigitsException`, the exception's message is issued as a compile time error in the `ctx.error(ex.getMessage)` call.
+
+With this new implementation, a definition like
+
+```scala
+val x: BigFloat = 1234.45e3333333333
+```
+
+would give a compile time error message:
+
+```scala
+3 |  val x: BigFloat = 1234.45e3333333333
+  |                    ^^^^^^^^^^^^^^^^^^
+  |                    exponent too large: 3333333333
+```
diff --git a/docs/_spec/TODOreference/experimental/overview.md b/docs/_spec/TODOreference/experimental/overview.md
new file mode 100644
index 000000000000..254f103896e4
--- /dev/null
+++ b/docs/_spec/TODOreference/experimental/overview.md
@@ -0,0 +1,29 @@
+---
+layout: doc-page
+title: "Experimental"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/experimental/overview.html
+redirectFrom: overview.html
+---
+
+## Experimental language features
+
+All experimental language features can be found under the `scala.language.experimental` package.
+They are enabled by importing the feature or using the `-language` compiler flag.
+
+* [`erasedDefinitions`](./erased-defs.md): Enable support for `erased` modifier.
+* `fewerBraces`: Enable support for using indentation for arguments.
+* [`genericNumberLiterals`](./numeric-literals.md): Enable support for generic number literals.
+* [`namedTypeArguments`](./named-typeargs.md): Enable support for named type arguments
+* [`saferExceptions`](./canthrow.md): Enable support for checked exceptions.
+
+## Experimental language imports
+
+In general, experimental language features can be imported in an experimental scope (see [experimental definitions](../other-new-features/experimental-defs.md)).
+They can be imported at the top-level if all top-level definitions are `@experimental`.
+
+## Experimental language features supported by special compiler options
+
+Some experimental language features that are still in research and development can be enabled with special compiler options. These include
+
+* [`-Yexplicit-nulls`](./explicit-nulls.md). Enable support for tracking null references in the type system.
+* [`-Ycc`](./cc.md). Enable support for capture checking.
diff --git a/docs/_spec/TODOreference/experimental/tupled-function.md b/docs/_spec/TODOreference/experimental/tupled-function.md
new file mode 100644
index 000000000000..da108fc832ad
--- /dev/null
+++ b/docs/_spec/TODOreference/experimental/tupled-function.md
@@ -0,0 +1,82 @@
+---
+layout: doc-page
+title: "Tupled Function"
+---
+
+Tupled Function
+----------------------
+
+With functions bounded to arities up to 22 it was possible to generalize some operation on all function types using overloading.
+Now that we have functions and tuples generalized to [arities above 22](../dropped-features/limit22.md) overloading is not an option anymore.
+The type class `TupleFunction` provides a way to abstract directly over a function of any arity converting it to an equivalent function that receives all arguments in a single tuple.
+
+```scala
+/** Type class relating a `FunctionN[..., R]` with an equivalent tupled function `Function1[TupleN[...], R]`
+ *
+ *  @tparam F a function type
+ *  @tparam G a tupled function type (function of arity 1 receiving a tuple as argument)
+ */
+@implicitNotFound("${F} cannot be tupled as ${G}")
+sealed trait TupledFunction[F, G] {
+  def tupled(f: F): G
+  def untupled(g: G): F
+}
+```
+
+The compiler will synthesize an instance of `TupledFunction[F, G]` if:
+
+* `F` is a function type of arity `N`
+* `G` is a function with a single tuple argument of size `N` and its types are equal to the arguments of `F`
+* The return type of `F` is equal to the return type of `G`
+* `F` and `G` are the same sort of function (both are `(...) => R` or both are `(...) ?=> R`)
+* If only one of `F` or `G` is instantiated the second one is inferred.
+
+Examples
+--------
+`TupledFunction` can be used to generalize the `Function1.tupled`, ... `Function22.tupled` methods to functions of any arities.
+The following defines `tupled` as [extension method](../contextual/extension-methods.html) ([full example](https://github.com/lampepfl/dotty/blob/main/tests/run/tupled-function-tupled.scala)).
+
+```scala
+/** Creates a tupled version of this function: instead of N arguments,
+ *  it accepts a single [[scala.Tuple]] with N elements as argument.
+ *
+ *  @tparam F the function type
+ *  @tparam Args the tuple type with the same types as the function arguments of F
+ *  @tparam R the return type of F
+ */
+extension [F, Args <: Tuple, R](f: F)
+  def tupled(using tf: TupledFunction[F, Args => R]): Args => R = tf.tupled(f)
+```
+
+`TupledFunction` can be used to generalize the `Function.untupled` to a function of any arities ([full example](https://github.com/lampepfl/dotty/blob/main/tests/run/tupled-function-untupled.scala))
+
+```scala
+/** Creates an untupled version of this function: instead of a single argument of type [[scala.Tuple]] with N elements,
+ *  it accepts N arguments.
+ *
+ *  This is a generalization of [[scala.Function.untupled]] that work on functions of any arity
+ *
+ *  @tparam F the function type
+ *  @tparam Args the tuple type with the same types as the function arguments of F
+ *  @tparam R the return type of F
+ */
+extension [F, Args <: Tuple, R](f: Args => R)
+  def untupled(using tf: TupledFunction[F, Args => R]): F = tf.untupled(f)
+```
+
+`TupledFunction` can also be used to generalize the [`Tuple1.compose`](https://github.com/lampepfl/dotty/blob/main/tests/run/tupled-function-compose.scala) and [`Tuple1.andThen`](https://github.com/lampepfl/dotty/blob/main/tests/run/tupled-function-andThen.scala) methods to compose functions of larger arities and with functions that return tuples.
+
+```scala
+/** Composes two instances of TupledFunction into a new TupledFunction, with this function applied last.
+ *
+ *  @tparam F a function type
+ *  @tparam G a function type
+ *  @tparam FArgs the tuple type with the same types as the function arguments of F and return type of G
+ *  @tparam GArgs the tuple type with the same types as the function arguments of G
+ *  @tparam R the return type of F
+ */
+extension [F, G, FArgs <: Tuple, GArgs <: Tuple, R](f: F)
+  def compose(g: G)(using tg: TupledFunction[G, GArgs => FArgs], tf: TupledFunction[F, FArgs => R]): GArgs => R = {
+  (x: GArgs) => tf.tupled(f)(tg.tupled(g)(x))
+}
+```
diff --git a/docs/_spec/TODOreference/features-classification.md b/docs/_spec/TODOreference/features-classification.md
new file mode 100644
index 000000000000..36cea3b9e72d
--- /dev/null
+++ b/docs/_spec/TODOreference/features-classification.md
@@ -0,0 +1,199 @@
+---
+layout: doc-page
+title: "A Classification of Proposed Language Features"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/features-classification.html
+---
+
+This document provides an overview of the constructs proposed for Scala 3 with the aim to facilitate the discussion what to include and when to include it. It classifies features into eight groups: (1) essential foundations, (2) simplifications, (3) restrictions, (4) dropped features, (5) changed features, (6) new features, (7) features oriented towards metaprogramming with the aim to replace existing macros, and (8) changes to type checking and inference.
+
+Each group contains sections classifying the status (i.e. relative importance to be a part of Scala 3, and relative urgency when to decide this) and the migration cost
+of the constructs in it.
+
+The current document reflects the state of things as of April, 2019. It will be updated to reflect any future changes in that status.
+
+## Essential Foundations
+
+These new constructs directly model core features of [DOT](https://www.scala-lang.org/blog/2016/02/03/essence-of-scala.html), higher-kinded types, and the [SI calculus for implicit resolution](https://infoscience.epfl.ch/record/229878/files/simplicitly_1.pdf).
+
+ - [Intersection types](new-types/intersection-types.md), replacing compound types,
+ - [Union types](new-types/union-types.md),
+ - [Type lambdas](new-types/type-lambdas.md),
+ replacing encodings using structural types and type projection.
+ - [Context functions](contextual/context-functions.md) offering abstraction over given parameters.
+
+**Status: essential**
+
+These are essential core features of Scala 3. Without them, Scala 3 would be a completely different language, with different foundations.
+
+**Migration cost: none to low**
+
+Since these are additions, there's generally no migration cost for old code. An exception are intersection types which replace compound types with slightly cleaned-up semantics. But few programs would be affected by this change.
+
+## Simplifications
+
+These constructs replace existing constructs with the aim of making the language safer and simpler to use, and to promote uniformity in code style.
+
+ - [Trait parameters](other-new-features/trait-parameters.md) replace [early initializers](dropped-features/early-initializers.md) with a more generally useful construct.
+ - [Given instances](contextual/givens.md)
+   replace implicit objects and defs, focussing on intent over mechanism.
+ - [Using clauses](contextual/using-clauses.md) replace implicit parameters, avoiding their ambiguities.
+ - [Extension methods](contextual/extension-methods.md) replace implicit classes with a clearer and simpler mechanism.
+ - [Opaque type aliases](other-new-features/opaques.md) replace most uses
+   of value classes while guaranteeing absence of boxing.
+ - [Top-level definitions](dropped-features/package-objects.md) replace package objects, dropping syntactic boilerplate.
+ - [Export clauses](other-new-features/export.md)
+ provide a simple and general way to express aggregation, which can replace the
+ previous facade pattern of package objects inheriting from classes.
+ - [Vararg splices](changed-features/vararg-splices.md) now use the form `*` instead of `@ _*`, mirroring vararg expressions,
+ - [Creator applications](other-new-features/creator-applications.md) allow using simple function call syntax
+ instead of `new` expressions. `new` expressions stay around as a fallback for
+ the cases where creator applications cannot be used.
+
+With the exception of early initializers and old-style vararg splices, all superseded constructs continue to be available in Scala 3.0. The plan is to deprecate and phase them out later.
+
+Value classes (superseded by opaque type aliases) are a special case. There are currently no deprecation plans for value classes, since we might bring them back in a more general form if they are supported natively by the JVM as is planned by project Valhalla.
+
+**Status: bimodal: now or never / can delay**
+
+These are essential simplifications. If we decide to adopt them, we should do it for 3.0. Otherwise we are faced with the awkward situation that the Scala 3 documentation has to describe an old feature that will be replaced or superseded by a simpler one in the future.
+
+On the other hand, we need to decide now only about the new features in this list. The decision to drop the superseded features can be delayed. Of course, adopting a new feature without deciding to drop the superseded feature will make the language larger.
+
+**Migration cost: moderate**
+
+For the next several versions, old features will remain available and deprecation and rewrite techniques can make any migration effort low and gradual.
+
+
+## Restrictions
+
+These constructs are restricted to make the language safer.
+
+ - [Implicit Conversions](contextual/conversions.md): there is only one way to define implicit conversions instead of many, and potentially surprising implicit conversions require a language import.
+ - [Given Imports](contextual/given-imports.md): implicits now require a special form of import, to make the import clearly visible.
+ - [Type Projection](dropped-features/type-projection.md): only classes can be used as prefix `C` of a type projection `C#A`. Type projection on abstract types is no longer supported since it is unsound.
+ - [Multiversal equality](contextual/multiversal-equality.md) implements an "opt-in" scheme to rule out nonsensical comparisons with `==` and `!=`.
+ - [infix](https://github.com/lampepfl/dotty/pull/5975)
+ makes method application syntax uniform across code bases.
+
+Unrestricted implicit conversions continue to be available in Scala 3.0, but will be deprecated and removed later. Unrestricted versions of the other constructs in the list above are available only under `-source 3.0-migration`.
+
+**Status: now or never**
+
+These are essential restrictions. If we decide to adopt them, we should do it for 3.0. Otherwise we are faced with the awkward situation that the Scala 3 documentation has to describe a feature that will be restricted in the future.
+
+**Migration cost: low to high**
+
+ - _low_: multiversal equality rules out code that is nonsensical, so any rewrites required by its adoption should be classified as bug fixes.
+ - _moderate_: Restrictions to implicits can be accommodated by straightforward rewriting.
+ - _high_: Unrestricted type projection cannot always rewritten directly since it is unsound in general.
+
+## Dropped Constructs
+
+These constructs are proposed to be dropped without a new construct replacing them. The motivation for dropping these constructs is to simplify the language and its implementation.
+
+ - [DelayedInit](dropped-features/delayed-init.md),
+ - [Existential types](dropped-features/existential-types.md),
+ - [Procedure syntax](dropped-features/procedure-syntax.md),
+ - [Class shadowing](dropped-features/class-shadowing.md),
+ - [XML literals](dropped-features/xml.md),
+ - [Symbol literals](dropped-features/symlits.md),
+ - [Auto application](dropped-features/auto-apply.md),
+ - [Weak conformance](dropped-features/weak-conformance.md),
+ - [Compound types](new-types/intersection-types.md),
+ - [Auto tupling](https://github.com/lampepfl/dotty/pull/4311) (implemented, but not merged).
+
+The date when these constructs are dropped varies. The current status is:
+
+ - Not implemented at all:
+   - DelayedInit, existential types, weak conformance.
+ - Supported under `-source 3.0-migration`:
+   - procedure syntax, class shadowing, symbol literals, auto application, auto tupling in a restricted form.
+ - Supported in 3.0, to be deprecated and phased out later:
+   - XML literals, compound types.
+
+**Status: mixed**
+
+Currently unimplemented features would require considerable implementation effort which would in most cases make the compiler more buggy and fragile and harder to understand. If we do not decide to drop them, they will probably show up as "not yet implemented" in the Scala 3.0 release.
+
+Currently implemented features could stay around indefinitely. Updated docs may simply ignore them, in the expectation that they might go away eventually. So the decision about their removal can be delayed.
+
+**Migration cost: moderate to high**
+
+Dropped features require rewrites to avoid their use in programs. These rewrites can sometimes be automatic (e.g. for procedure syntax, symbol literals, auto application)
+and sometimes need to be manual (e.g. class shadowing, auto tupling). Sometimes the rewrites would have to be non-local, affecting use sites as well as definition sites (e.g., in the case of `DelayedInit`, unless we find a solution).
+
+## Changes
+
+These constructs have undergone changes to make them more regular and useful.
+
+ - [Structural Types](changed-features/structural-types.md): They now allow pluggable implementations, which greatly increases their usefulness. Some usage patterns are restricted compared to the status quo.
+ - [Name-based pattern matching](changed-features/pattern-matching.md): The existing undocumented Scala 2 implementation has been codified in a slightly simplified form.
+ - [Eta expansion](changed-features/eta-expansion.md) is now performed universally also in the absence of an expected type. The postfix `_` operator is thus made redundant. It will be deprecated and dropped after Scala 3.0.
+ - [Implicit Resolution](changed-features/implicit-resolution.md): The implicit resolution rules have been cleaned up to make them more useful and less surprising. Implicit scope is restricted to no longer include package prefixes.
+
+Most aspects of old-style implicit resolution are still available under `-source 3.0-migration`. The other changes in this list are applied unconditionally.
+
+**Status: strongly advisable**
+
+The features have been implemented in their new form in Scala 3.0's compiler. They provide clear improvements in simplicity and functionality compared to the status quo. Going back would require significant implementation effort for a net loss of functionality.
+
+**Migration cost: low to high**
+
+Only a few programs should require changes, but some necessary changes might be non-local (as in the case of restrictions to implicit scope).
+
+## New Constructs
+
+These are additions to the language that make it more powerful or pleasant to use.
+
+ - [Enums](enums/enums.md) provide concise syntax for enumerations and [algebraic data types](enums/adts.md).
+ - [Parameter untupling](other-new-features/parameter-untupling.md) avoids having to use `case` for tupled parameter destructuring.
+ - [Dependent function types](new-types/dependent-function-types.md) generalize dependent methods to dependent function values and types.
+ - [Polymorphic function types](https://github.com/lampepfl/dotty/pull/4672) generalize polymorphic methods to dependent function values and types. _Current status_: There is a proposal, and a prototype implementation, but the implementation has not been finalized or merged yet.
+ - [Kind polymorphism](other-new-features/kind-polymorphism.md) allows the definition of operators working equally on types and type constructors.
+
+**Status: mixed**
+
+Enums offer an essential simplification of fundamental use patterns, so they should be adopted for Scala 3.0. Auto-parameter tupling is a very small change that removes some awkwardness, so it might as well be adopted now. The other features constitute more specialized functionality which could be introduced in later versions. On the other hand, except for polymorphic function types they are all fully implemented, so if the Scala 3.0 spec does not include them, they might be still made available under a language flag.
+
+**Migration cost: none**
+
+Being new features, existing code migrates without changes. To be sure, sometimes it would be attractive to rewrite code to make use of the new features in order to increase clarity and conciseness.
+
+## Metaprogramming
+
+The following constructs together aim to put metaprogramming in Scala on a new basis. So far, metaprogramming was achieved by a combination of macros and libraries such as [Shapeless](https://github.com/milessabin/shapeless) that were in turn based on some key macros. Current Scala 2 macro mechanisms are a thin veneer on top the current Scala 2 compiler, which makes them fragile and in many cases impossible to port to Scala 3.
+
+It's worth noting that macros were never included in the [Scala 2 language specification](https://scala-lang.org/files/archive/spec/2.13/) and were so far made available only under an `-experimental` flag. This has not prevented their widespread usage.
+
+To enable porting most uses of macros, we are experimenting with the advanced language constructs listed below. These designs are more provisional than the rest of the proposed language constructs for Scala 3.0. There might still be some changes until the final release. Stabilizing the feature set needed for metaprogramming is our first priority.
+
+- [Match types](new-types/match-types.md) allow computation on types.
+- [Inline](metaprogramming/inline.md) provides
+by itself a straightforward implementation of some simple macros and is at the same time an essential building block for the implementation of complex macros.
+- [Quotes and splices](metaprogramming/macros.md) provide a principled way to express macros and staging with a unified set of abstractions.
+- [Type class derivation](contextual/derivation.md) provides an in-language implementation of the `Gen` macro in Shapeless and other foundational libraries. The new implementation is more robust, efficient and easier to use than the macro.
+- [Implicit by-name parameters](contextual/by-name-context-parameters.md) provide a more robust in-language implementation of the `Lazy` macro in Shapeless.
+
+**Status: not yet settled**
+
+We know we need a practical replacement for current macros. The features listed above are very promising in that respect, but we need more complete implementations and more use cases to reach a final verdict.
+
+**Migration cost: very high**
+
+Existing macro libraries will have to be rewritten from the ground up. In many cases the rewritten libraries will turn out to be simpler and more robust than the old ones, but that does not relieve one of the cost of the rewrites. It's currently unclear to what degree users of macro libraries will be affected. We aim to provide sufficient functionality so that core macros can be re-implemented fully, but given the vast feature set of the various macro extensions to Scala 2 it is difficult to arrive at a workable limitation of scope.
+
+## Changes to Type Checking and Inference
+
+The Scala 3 compiler uses a new algorithm for type inference, which relies on a general subtype constraint solver. The new algorithm often [works better than the old](https://contributors.scala-lang.org/t/better-type-inference-for-scala-send-us-your-problematic-cases/2410), but there are inevitably situations where the results of both algorithms differ, leading to errors diagnosed by Scala 3 for programs that the Scala 2 compiler accepts.
+
+**Status: essential**
+
+The new type-checking and inference algorithms are the essential core of the new compiler. They cannot be reverted without dropping the whole implementation of Scala 3.
+
+**Migration cost: high**
+
+Some existing programs will break and, given the complex nature of type inference, it will not always be clear what change caused the breakage and how to fix it.
+
+In our experience, macros and changes in type and implicit argument inference together cause the large majority of problems encountered when porting existing code to Scala 3. The latter source of problems could be addressed systematically by a tool that added all inferred types and implicit arguments to a Scala 2 source code file. Most likely such a tool would be implemented as a [Scala 2 compiler plugin](https://docs.scala-lang.org/overviews/plugins/index.html). The resulting code would have a greatly increased likelihood to compile under Scala 3, but would often be bulky to the point of being unreadable. A second part of the rewriting tool should then selectively and iteratively remove type and implicit annotations that were synthesized by the first part as long as they compile under Scala 3. This second part could be implemented as a program that invokes the Scala 3 compiler `scalac` programmatically.
+
+Several people have proposed such a tool for some time now. I believe it is time we find the will and the resources to actually implement it.
diff --git a/docs/_spec/TODOreference/language-versions/binary-compatibility.md b/docs/_spec/TODOreference/language-versions/binary-compatibility.md
new file mode 100644
index 000000000000..df1c19f97868
--- /dev/null
+++ b/docs/_spec/TODOreference/language-versions/binary-compatibility.md
@@ -0,0 +1,13 @@
+---
+layout: doc-page
+title: "Binary Compatibility"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/language-versions/binary-compatibility.html
+---
+
+In Scala 2 different minor versions of the compiler were free to change the way how they encode different language features in JVM bytecode so each bump of the compiler's minor version resulted in breaking binary compatibility and if a project had any Scala dependencies they all needed to be (cross-)compiled to the same minor Scala version that was used in that project itself. On the contrary, Scala 3 has a stable encoding into JVM bytecode.
+
+In addition to classfiles the compilation process in Scala 3 also produces files with `.tasty` extension. The [TASTy](https://docs.scala-lang.org/scala3/guides/tasty-overview.html) format is an intermediate representation of Scala code containing full information about sources together with information provided by the typer. Some of this information is lost during generation of bytecode so Scala 3 compilers read TASTy files during compilation in addition to classfiles to know the exact types of values, methods, etc. in already compiled classes (although compilation from TASTy files only is also possible). TASTy files are also typically distributed together with classfiles in published artifacts.
+
+TASTy format is extensible but it preserves backward compatibility and the evolution happens between minor releases of the language. This means a Scala compiler in version `3.x1.y1` is able to read TASTy files produced by another compiler in version `3.x2.y2` if `x1 >= x2` (assuming two stable versions of the compiler are considered - `SNAPSHOT` or `NIGHTLY` compiler versions can read TASTy in an older stable format but their TASTY versions are not compatible between each other even if the compilers have the same minor version; also compilers in stable versions cannot read TASTy generated by an unstable version).
+
+TASTy version number has the format of `<major_version>.<minor_version>-<experimental_version>` and the numbering changes in parallel to language releases in such a way that a bump in language minor version corresponds to a bump in TASTy minor version (e.g. for Scala `3.0.0` the TASTy version is `28.0-0`). Experimental version set to 0 signifies a stable version while others are considered unstable/experimental. TASTy version is not strictly bound to the data format itself - any changes to the API of the standard library also require a change in TASTy minor version.
diff --git a/docs/_spec/TODOreference/language-versions/language-versions.md b/docs/_spec/TODOreference/language-versions/language-versions.md
new file mode 100644
index 000000000000..2dfd04857cab
--- /dev/null
+++ b/docs/_spec/TODOreference/language-versions/language-versions.md
@@ -0,0 +1,7 @@
+---
+layout: index
+title: "Language Versions"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/language-versions/index.html
+---
+
+Additional information on interoperability and migration between Scala 2 and 3 can be found [here](https://docs.scala-lang.org/scala3/guides/migration/compatibility-intro.html).
diff --git a/docs/_spec/TODOreference/language-versions/source-compatibility.md b/docs/_spec/TODOreference/language-versions/source-compatibility.md
new file mode 100644
index 000000000000..4d5b468ac8f2
--- /dev/null
+++ b/docs/_spec/TODOreference/language-versions/source-compatibility.md
@@ -0,0 +1,43 @@
+---
+layout: doc-page
+title: "Source Compatibility"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/language-versions/source-compatibility.html
+---
+
+Scala 3 does NOT guarantee source compatibility between different minor language versions (e.g. some syntax valid in 3.x might get deprecated and then phased out in 3.y for y > x). There are also some syntax structures that were valid in Scala 2 but are not anymore in Scala 3. However the compiler provides a possibility to specify the desired version of syntax used in a particular file or globally for a run of the compiler to make migration between versions easier.
+
+The default Scala language syntax version currently supported by the Dotty compiler is [`3.2`](https://scala-lang.org/api/3.x/scala/runtime/stdLibPatches/language$$3/2$.html). There are also other language versions that can be specified instead:
+
+- [`3.0-migration`](https://scala-lang.org/api/3.x/scala/runtime/stdLibPatches/language$$3/0-migration$.html): Same as
+`3.0` and `3.1`, but with a Scala 2 compatibility mode that helps moving Scala 2.13 sources over to Scala 3. In particular, it
+
+    - flags some Scala 2 constructs that are disallowed in Scala 3 as migration warnings instead of hard errors,
+    - changes some rules to be more lenient and backwards compatible with Scala 2.13
+    - gives some additional warnings where the semantics has changed between Scala 2.13 and 3.0
+    - in conjunction with `-rewrite`, offer code rewrites from Scala 2.13 to 3.0.
+
+- [`3.0`](https://scala-lang.org/api/3.x/scala/runtime/stdLibPatches/language$$3/0$.html), [`3.1`](https://scala-lang.org/api/3.x/scala/runtime/stdLibPatches/language$$3/1$.html): the default set of features included in scala versions `3.0.0` to `3.1.3`.
+- [`3.2`](https://scala-lang.org/api/3.x/scala/runtime/stdLibPatches/language$$3/2$.html): the same as `3.0` and `3.1`, but in addition:
+  - [stricter pattern bindings](https://docs.scala-lang.org/scala3/reference/changed-features/pattern-bindings.html) are now enabled (part of `future` in earlier `3.x` releases), producing warnings for refutable patterns. These warnings can be silenced to achieve the same runtime behavior, but in `future` they become errors and refutable patterns will not compile.
+  - [Nonlocal returns](https://docs.scala-lang.org/scala3/reference/dropped-features/nonlocal-returns.html) now produce a warning upon usage (they are still an error under `future`).
+- [`3.2-migration`](https://scala-lang.org/api/3.x/scala/runtime/stdLibPatches/language$$3/2-migration$.html): the same as `3.2`, but in conjunction with `-rewrite`, offer code rewrites from Scala `3.0/3.1` to `3.2`.
+- [`future`](https://scala-lang.org/api/3.x/scala/runtime/stdLibPatches/language$$future$.html): A preview of changes that will be introduced in `3.x` versions after `3.2`.
+Some Scala 2 specific idioms are dropped in this version. The feature set supported by this version may grow over time as features become stabilised for preview.
+
+- [`future-migration`](https://scala-lang.org/api/3.x/scala/runtime/stdLibPatches/language$$future-migration$.html): Same as `future` but with additional helpers to migrate from `3.2`. Similarly to the helpers available under `3.0-migration`, these include migration warnings and optional rewrites.
+
+There are two ways to specify a language version :
+
+- with a `-source` command line setting, e.g. `-source 3.0-migration`.
+- with a `scala.language` import at the top of a source file, e.g:
+
+```scala
+package p
+import scala.language.`future-migration`
+
+class C { ... }
+```
+
+Language imports supersede command-line settings in the source files where they are specified. Only one language import specifying a source version is allowed in a source file, and it must come before any definitions in that file.
+
+**Note**: The [Scala 3 Migration Guide](https://docs.scala-lang.org/scala3/guides/migration/compatibility-intro.html) gives further information to help the Scala programmer moving from Scala 2.13 to Scala 3.
diff --git a/docs/_spec/TODOreference/metaprogramming/compiletime-ops.md b/docs/_spec/TODOreference/metaprogramming/compiletime-ops.md
new file mode 100644
index 000000000000..a43c941ae943
--- /dev/null
+++ b/docs/_spec/TODOreference/metaprogramming/compiletime-ops.md
@@ -0,0 +1,294 @@
+---
+layout: doc-page
+title: "Compile-time operations"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/metaprogramming/compiletime-ops.html
+---
+
+## The `scala.compiletime` Package
+
+The [`scala.compiletime`](https://scala-lang.org/api/3.x/scala/compiletime.html) package contains helper definitions that provide support for compile-time operations over values. They are described in the following.
+
+### `constValue` and `constValueOpt`
+
+`constValue` is a function that produces the constant value represented by a
+type.
+
+```scala
+import scala.compiletime.constValue
+import scala.compiletime.ops.int.S
+
+transparent inline def toIntC[N]: Int =
+  inline constValue[N] match
+    case 0        => 0
+    case _: S[n1] => 1 + toIntC[n1]
+
+inline val ctwo = toIntC[2]
+```
+
+`constValueOpt` is the same as `constValue`, however returning an `Option[T]`
+enabling us to handle situations where a value is not present. Note that `S` is
+the type of the successor of some singleton type. For example the type `S[1]` is
+the singleton type `2`.
+
+### `erasedValue`
+
+So far we have seen inline methods that take terms (tuples and integers) as
+parameters. What if we want to base case distinctions on types instead? For
+instance, one would like to be able to write a function `defaultValue`, that,
+given a type `T`, returns optionally the default value of `T`, if it exists.
+We can already express this using rewrite match expressions and a simple
+helper function, `scala.compiletime.erasedValue`, which is defined as follows:
+
+```scala
+def erasedValue[T]: T
+```
+
+The `erasedValue` function _pretends_ to return a value of its type argument `T`.
+Calling this function will always result in a compile-time error unless the call
+is removed from the code while inlining.
+
+Using `erasedValue`, we can then define `defaultValue` as follows:
+
+```scala
+import scala.compiletime.erasedValue
+
+transparent inline def defaultValue[T] =
+  inline erasedValue[T] match
+    case _: Byte    => Some(0: Byte)
+    case _: Char    => Some(0: Char)
+    case _: Short   => Some(0: Short)
+    case _: Int     => Some(0)
+    case _: Long    => Some(0L)
+    case _: Float   => Some(0.0f)
+    case _: Double  => Some(0.0d)
+    case _: Boolean => Some(false)
+    case _: Unit    => Some(())
+    case _          => None
+```
+
+Then:
+
+```scala
+val dInt: Some[Int] = defaultValue[Int]
+val dDouble: Some[Double] = defaultValue[Double]
+val dBoolean: Some[Boolean] = defaultValue[Boolean]
+val dAny: None.type = defaultValue[Any]
+```
+
+As another example, consider the type-level version of `toInt` below:
+given a _type_ representing a Peano number,
+return the integer _value_ corresponding to it.
+Consider the definitions of numbers as in the _Inline
+Match_ section above. Here is how `toIntT` can be defined:
+
+```scala
+transparent inline def toIntT[N <: Nat]: Int =
+  inline scala.compiletime.erasedValue[N] match
+    case _: Zero.type => 0
+    case _: Succ[n] => toIntT[n] + 1
+
+inline val two = toIntT[Succ[Succ[Zero.type]]]
+```
+
+`erasedValue` is an `erased` method so it cannot be used and has no runtime
+behavior. Since `toIntT` performs static checks over the static type of `N` we
+can safely use it to scrutinize its return type (`S[S[Z]]` in this case).
+
+### `error`
+
+The `error` method is used to produce user-defined compile errors during inline expansion.
+It has the following signature:
+
+```scala
+inline def error(inline msg: String): Nothing
+```
+
+If an inline expansion results in a call `error(msgStr)` the compiler
+produces an error message containing the given `msgStr`.
+
+```scala
+import scala.compiletime.{error, codeOf}
+
+inline def fail() =
+  error("failed for a reason")
+
+fail() // error: failed for a reason
+```
+
+or
+
+```scala
+inline def fail(inline p1: Any) =
+  error("failed on: " + codeOf(p1))
+
+fail(identity("foo")) // error: failed on: identity[String]("foo")
+```
+
+### The `scala.compiletime.ops` package
+
+The [`scala.compiletime.ops`](https://scala-lang.org/api/3.x/scala/compiletime/ops.html) package contains types that provide support for
+primitive operations on singleton types. For example,
+`scala.compiletime.ops.int.*` provides support for multiplying two singleton
+`Int` types, and `scala.compiletime.ops.boolean.&&` for the conjunction of two
+`Boolean` types. When all arguments to a type in `scala.compiletime.ops` are
+singleton types, the compiler can evaluate the result of the operation.
+
+```scala
+import scala.compiletime.ops.int.*
+import scala.compiletime.ops.boolean.*
+
+val conjunction: true && true = true
+val multiplication: 3 * 5 = 15
+```
+
+Many of these singleton operation types are meant to be used infix (as in [SLS §3.2.10](https://www.scala-lang.org/files/archive/spec/2.13/03-types.html#infix-types)).
+
+Since type aliases have the same precedence rules as their term-level
+equivalents, the operations compose with the expected precedence rules:
+
+```scala
+import scala.compiletime.ops.int.*
+val x: 1 + 2 * 3 = 7
+```
+
+The operation types are located in packages named after the type of the
+left-hand side parameter: for instance, `scala.compiletime.ops.int.+` represents
+addition of two numbers, while `scala.compiletime.ops.string.+` represents string
+concatenation. To use both and distinguish the two types from each other, a
+match type can dispatch to the correct implementation:
+
+```scala
+import scala.compiletime.ops.*
+
+import scala.annotation.infix
+
+type +[X <: Int | String, Y <: Int | String] = (X, Y) match
+  case (Int, Int) => int.+[X, Y]
+  case (String, String) => string.+[X, Y]
+
+val concat: "a" + "b" = "ab"
+val addition: 1 + 1 = 2
+```
+
+## Summoning Implicits Selectively
+
+It is foreseen that many areas of typelevel programming can be done with rewrite
+methods instead of implicits. But sometimes implicits are unavoidable. The
+problem so far was that the Prolog-like programming style of implicit search
+becomes viral: Once some construct depends on implicit search it has to be
+written as a logic program itself. Consider for instance the problem of creating
+a `TreeSet[T]` or a `HashSet[T]` depending on whether `T` has an `Ordering` or
+not. We can create a set of implicit definitions like this:
+
+```scala
+trait SetFor[T, S <: Set[T]]
+
+class LowPriority:
+  implicit def hashSetFor[T]: SetFor[T, HashSet[T]] = ...
+
+object SetsFor extends LowPriority:
+  implicit def treeSetFor[T: Ordering]: SetFor[T, TreeSet[T]] = ...
+```
+
+Clearly, this is not pretty. Besides all the usual indirection of implicit
+search, we face the problem of rule prioritization where we have to ensure that
+`treeSetFor` takes priority over `hashSetFor` if the element type has an
+ordering. This is solved (clumsily) by putting `hashSetFor` in a superclass
+`LowPriority` of the object `SetsFor` where `treeSetFor` is defined. Maybe the
+boilerplate would still be acceptable if the crufty code could be contained.
+However, this is not the case. Every user of the abstraction has to be
+parameterized itself with a `SetFor` implicit. Considering the simple task _"I
+want a `TreeSet[T]` if `T` has an ordering and a `HashSet[T]` otherwise"_, this
+seems like a lot of ceremony.
+
+There are some proposals to improve the situation in specific areas, for
+instance by allowing more elaborate schemes to specify priorities. But they all
+keep the viral nature of implicit search programs based on logic programming.
+
+By contrast, the new `summonFrom` construct makes implicit search available
+in a functional context. To solve the problem of creating the right set, one
+would use it as follows:
+
+```scala
+import scala.compiletime.summonFrom
+
+inline def setFor[T]: Set[T] = summonFrom {
+  case ord: Ordering[T] => new TreeSet[T]()(using ord)
+  case _                => new HashSet[T]
+}
+```
+
+A `summonFrom` call takes a pattern matching closure as argument. All patterns
+in the closure are type ascriptions of the form `identifier : Type`.
+
+Patterns are tried in sequence. The first case with a pattern `x: T` such that an implicit value of type `T` can be summoned is chosen.
+
+Alternatively, one can also use a pattern-bound given instance, which avoids the explicit using clause. For instance, `setFor` could also be formulated as follows:
+
+```scala
+import scala.compiletime.summonFrom
+
+inline def setFor[T]: Set[T] = summonFrom {
+  case given Ordering[T] => new TreeSet[T]
+  case _                 => new HashSet[T]
+}
+```
+
+`summonFrom` applications must be reduced at compile time.
+
+Consequently, if we summon an `Ordering[String]` the code above will return a
+new instance of `TreeSet[String]`.
+
+```scala
+summon[Ordering[String]]
+
+println(setFor[String].getClass) // prints class scala.collection.immutable.TreeSet
+```
+
+**Note** `summonFrom` applications can raise ambiguity errors. Consider the following
+code with two givens in scope of type `A`. The pattern match in `f` will raise
+an ambiguity error of `f` is applied.
+
+```scala
+class A
+given a1: A = new A
+given a2: A = new A
+
+inline def f: Any = summonFrom {
+  case given _: A => ???  // error: ambiguous givens
+}
+```
+
+## `summonInline`
+
+The shorthand `summonInline` provides a simple way to write a `summon` that is delayed until the call is inlined.
+Unlike `summonFrom`, `summonInline` also yields the implicit-not-found error, if a given instance of the summoned
+type is not found.
+```scala
+import scala.compiletime.summonInline
+import scala.annotation.implicitNotFound
+
+@implicitNotFound("Missing One")
+trait Missing1
+
+@implicitNotFound("Missing Two")
+trait Missing2
+
+trait NotMissing
+given NotMissing = ???
+
+transparent inline def summonInlineCheck[T <: Int](inline t : T) : Any =
+  inline t match
+    case 1 => summonInline[Missing1]
+    case 2 => summonInline[Missing2]
+    case _ => summonInline[NotMissing]
+
+val missing1 = summonInlineCheck(1) // error: Missing One
+val missing2 = summonInlineCheck(2) // error: Missing Two
+val notMissing : NotMissing = summonInlineCheck(3)
+```
+
+## Reference
+
+For more information about compile-time operations, see [PR #4768](https://github.com/lampepfl/dotty/pull/4768),
+which explains how `summonFrom`'s predecessor (implicit matches) can be used for typelevel programming and code specialization and [PR #7201](https://github.com/lampepfl/dotty/pull/7201) which explains the new `summonFrom` syntax.
diff --git a/docs/_spec/TODOreference/metaprogramming/inline.md b/docs/_spec/TODOreference/metaprogramming/inline.md
new file mode 100644
index 000000000000..0c4800069bad
--- /dev/null
+++ b/docs/_spec/TODOreference/metaprogramming/inline.md
@@ -0,0 +1,390 @@
+---
+layout: doc-page
+title: Inline
+nightlyOf: https://docs.scala-lang.org/scala3/reference/metaprogramming/inline.html
+---
+
+## Inline Definitions
+
+`inline` is a new [soft modifier](../soft-modifier.md) that guarantees that a
+definition will be inlined at the point of use. Example:
+
+```scala
+object Config:
+  inline val logging = false
+
+object Logger:
+
+  private var indent = 0
+
+  inline def log[T](msg: String, indentMargin: =>Int)(op: => T): T =
+    if Config.logging then
+      println(s"${"  " * indent}start $msg")
+      indent += indentMargin
+      val result = op
+      indent -= indentMargin
+      println(s"${"  " * indent}$msg = $result")
+      result
+    else op
+end Logger
+```
+
+The `Config` object contains a definition of the **inline value** `logging`.
+This means that `logging` is treated as a _constant value_, equivalent to its
+right-hand side `false`. The right-hand side of such an `inline val` must itself
+be a [constant expression](https://scala-lang.org/files/archive/spec/2.13/06-expressions.html#constant-expressions).
+Used in this way, `inline` is equivalent to Java and Scala 2's `final`. Note that `final`, meaning
+_inlined constant_, is still supported in Scala 3, but will be phased out.
+
+The `Logger` object contains a definition of the **inline method** `log`. This
+method will always be inlined at the point of call.
+
+In the inlined code, an `if-then-else` with a constant condition will be rewritten
+to its `then`- or `else`-part. Consequently, in the `log` method above the
+`if Config.logging` with `Config.logging == true` will get rewritten into its
+`then`-part.
+
+Here's an example:
+
+```scala
+var indentSetting = 2
+
+def factorial(n: BigInt): BigInt =
+  log(s"factorial($n)", indentSetting) {
+    if n == 0 then 1
+    else n * factorial(n - 1)
+  }
+```
+
+If `Config.logging == false`, this will be rewritten (simplified) to:
+
+```scala
+def factorial(n: BigInt): BigInt =
+  if n == 0 then 1
+  else n * factorial(n - 1)
+```
+
+As you notice, since neither `msg` or `indentMargin` were used, they do not
+appear in the generated code for `factorial`. Also note the body of our `log`
+method: the `else-` part reduces to just an `op`. In the generated code we do
+not generate any closures because we only refer to a by-name parameter *once*.
+Consequently, the code was inlined directly and the call was beta-reduced.
+
+In the `true` case the code will be rewritten to:
+
+```scala
+def factorial(n: BigInt): BigInt =
+  val msg = s"factorial($n)"
+  println(s"${"  " * indent}start $msg")
+  Logger.inline$indent_=(indent.+(indentSetting))
+  val result =
+    if n == 0 then 1
+    else n * factorial(n - 1)
+  Logger.inline$indent_=(indent.-(indentSetting))
+  println(s"${"  " * indent}$msg = $result")
+  result
+```
+
+Note that the by-value parameter `msg` is evaluated only once, per the usual Scala
+semantics, by binding the value and reusing the `msg` through the body of
+`factorial`. Also, note the special handling of the assignment to the private var
+`indent`. It is achieved by generating a setter method `def inline$indent_=` and calling it instead.
+
+Inline methods always have to be fully applied. For instance, a call to
+```scala
+Logger.log[String]("some op", indentSetting)
+```
+would be ill-formed and the compiler would complain that arguments are missing.
+However, it is possible to pass wildcard arguments instead. For instance,
+```scala
+Logger.log[String]("some op", indentSetting)(_)
+```
+would typecheck.
+
+### Recursive Inline Methods
+
+Inline methods can be recursive. For instance, when called with a constant
+exponent `n`, the following method for `power` will be implemented by
+straight inline code without any loop or recursion.
+
+```scala
+inline def power(x: Double, n: Int): Double =
+  if n == 0 then 1.0
+  else if n == 1 then x
+  else
+    val y = power(x, n / 2)
+    if n % 2 == 0 then y * y else y * y * x
+
+power(expr, 10)
+// translates to
+//
+//   val x = expr
+//   val y1 = x * x   // ^2
+//   val y2 = y1 * y1 // ^4
+//   val y3 = y2 * x  // ^5
+//   y3 * y3          // ^10
+```
+
+Parameters of inline methods can have an `inline` modifier as well. This means
+that actual arguments to these parameters will be inlined in the body of the
+`inline def`. `inline` parameters have call semantics equivalent to by-name parameters
+but allow for duplication of the code in the argument. It is usually useful when constant
+values need to be propagated to allow further optimizations/reductions.
+
+The following example shows the difference in translation between by-value, by-name and `inline`
+parameters:
+
+```scala
+inline def funkyAssertEquals(actual: Double, expected: =>Double, inline delta: Double): Unit =
+  if (actual - expected).abs > delta then
+    throw new AssertionError(s"difference between ${expected} and ${actual} was larger than ${delta}")
+
+funkyAssertEquals(computeActual(), computeExpected(), computeDelta())
+// translates to
+//
+//   val actual = computeActual()
+//   def expected = computeExpected()
+//   if (actual - expected).abs > computeDelta() then
+//     throw new AssertionError(s"difference between ${expected} and ${actual} was larger than ${computeDelta()}")
+```
+
+### Rules for Overriding
+
+Inline methods can override other non-inline methods. The rules are as follows:
+
+1. If an inline method `f` implements or overrides another, non-inline method, the inline method can also be invoked at runtime. For instance, consider the scenario:
+
+    ```scala
+    abstract class A:
+      def f: Int
+      def g: Int = f
+
+    class B extends A:
+      inline def f = 22
+      override inline def g = f + 11
+
+    val b = new B
+    val a: A = b
+    // inlined invocatons
+    assert(b.f == 22)
+    assert(b.g == 33)
+    // dynamic invocations
+    assert(a.f == 22)
+    assert(a.g == 33)
+    ```
+
+    The inlined invocations and the dynamically dispatched invocations give the same results.
+
+2. Inline methods are effectively final.
+
+3. Inline methods can also be abstract. An abstract inline method can be implemented only by other inline methods. It cannot be invoked directly:
+
+    ```scala
+    abstract class A:
+      inline def f: Int
+
+    object B extends A:
+      inline def f: Int = 22
+
+    B.f         // OK
+    val a: A = B
+    a.f         // error: cannot inline f in A.
+    ```
+
+### Relationship to `@inline`
+
+Scala 2 also defines a `@inline` annotation which is used as a hint for the
+backend to inline code. The `inline` modifier is a more powerful option:
+
+- expansion is guaranteed instead of best effort,
+- expansion happens in the frontend instead of in the backend and
+- expansion also applies to recursive methods.
+
+<!--- (Commented out since the docs and implementation differ)
+
+### Evaluation Rules
+
+As you noticed by the examples above a lambda of the form
+
+`((x_1, ..., x_n) => B)(E_1, ..., E_n)` is rewritten to:
+
+```
+{ val/def x_1 = E_1
+  ...
+  val/def x_n = E_n
+  B
+}
+```
+
+where vals are used for value parameter bindings and defs are used for by-name
+parameter bindings. If an argument `E_i` is a simple variable reference `y`, the
+corresponding binding is omitted and `y` is used instead of `x_i` in `B`.
+
+If a `inline` modifier is given for parameters, corresponding arguments must be
+pure expressions of constant type.
+-->
+
+### The definition of constant expression
+
+Right-hand sides of inline values and of arguments for inline parameters must be
+constant expressions in the sense defined by the [SLS §6.24](https://www.scala-lang.org/files/archive/spec/2.13/06-expressions.html#constant-expressions),
+including _platform-specific_ extensions such as constant folding of pure
+numeric computations.
+
+An inline value must have a literal type such as `1` or `true`.
+
+```scala
+inline val four = 4
+// equivalent to
+inline val four: 4 = 4
+```
+
+It is also possible to have inline vals of types that do not have a syntax, such as `Short(4)`.
+
+```scala
+trait InlineConstants:
+  inline val myShort: Short
+
+object Constants extends InlineConstants:
+  inline val myShort/*: Short(4)*/ = 4
+```
+
+## Transparent Inline Methods
+
+Inline methods can additionally be declared `transparent`.
+This means that the return type of the inline method can be
+specialized to a more precise type upon expansion. Example:
+
+```scala
+class A
+class B extends A:
+  def m = true
+
+transparent inline def choose(b: Boolean): A =
+  if b then new A else new B
+
+val obj1 = choose(true)  // static type is A
+val obj2 = choose(false) // static type is B
+
+// obj1.m // compile-time error: `m` is not defined on `A`
+obj2.m    // OK
+```
+
+Here, the inline method `choose` returns an instance of either of the two types `A` or `B`.
+If `choose` had not been declared to be `transparent`, the result
+of its expansion would always be of type `A`, even though the computed value might be of the subtype `B`.
+The inline method is a "blackbox" in the sense that details of its implementation do not leak out.
+But if a `transparent` modifier is given, the expansion is the type of the expanded body. If the argument `b`
+is `true`, that type is `A`, otherwise it is `B`. Consequently, calling `m` on `obj2`
+type-checks since `obj2` has the same type as the expansion of `choose(false)`, which is `B`.
+Transparent inline methods are "whitebox" in the sense that the type
+of an application of such a method can be more specialized than its declared
+return type, depending on how the method expands.
+
+In the following example, we see how the return type of `zero` is specialized to
+the singleton type `0` permitting the addition to be ascribed with the correct
+type `1`.
+
+```scala
+transparent inline def zero: Int = 0
+
+val one: 1 = zero + 1
+```
+
+### Transparent vs. non-transparent inline
+
+As we already discussed, transparent inline methods may influence type checking at call site.
+Technically this implies that transparent inline methods must be expanded during type checking of the program.
+Other inline methods are inlined later after the program is fully typed.
+
+For example, the following two functions will be typed the same way but will be inlined at different times.
+
+```scala
+inline def f1: T = ...
+transparent inline def f2: T = (...): T
+```
+
+A noteworthy difference is the behavior of `transparent inline given`.
+If there is an error reported when inlining that definition, it will be considered as an implicit search mismatch and the search will continue.
+A `transparent inline given` can add a type ascription in its RHS (as in `f2` from the previous example) to avoid the precise type but keep the search behavior.
+On the other hand, an `inline given` is taken as an implicit and then inlined after typing.
+Any error will be emitted as usual.
+
+## Inline Conditionals
+
+An if-then-else expression whose condition is a constant expression can be simplified to
+the selected branch. Prefixing an if-then-else expression with `inline` enforces that
+the condition has to be a constant expression, and thus guarantees that the conditional will always
+simplify.
+
+Example:
+
+```scala
+inline def update(delta: Int) =
+  inline if delta >= 0 then increaseBy(delta)
+  else decreaseBy(-delta)
+```
+
+A call `update(22)` would rewrite to `increaseBy(22)`. But if `update` was called with
+a value that was not a compile-time constant, we would get a compile time error like the one
+below:
+
+```scala
+  |  inline if delta >= 0 then ???
+  |  ^
+  |  cannot reduce inline if
+  |   its condition
+  |     delta >= 0
+  |   is not a constant value
+  | This location is in code that was inlined at ...
+```
+
+In a transparent inline, an `inline if` will force the inlining of any inline definition in its condition during type checking.
+
+## Inline Matches
+
+A `match` expression in the body of an `inline` method definition may be
+prefixed by the `inline` modifier. If there is enough type information
+at compile time to select a branch, the expression is reduced to that branch and the
+type of the expression is the type of the right-hand side of that result.
+If not, a compile-time error is raised that reports that the match cannot be reduced.
+
+The example below defines an inline method with a
+single inline match expression that picks a case based on its static type:
+
+```scala
+transparent inline def g(x: Any): Any =
+  inline x match
+    case x: String => (x, x) // Tuple2[String, String](x, x)
+    case x: Double => x
+
+g(1.0d) // Has type 1.0d which is a subtype of Double
+g("test") // Has type (String, String)
+```
+
+The scrutinee `x` is examined statically and the inline match is reduced
+accordingly returning the corresponding value (with the type specialized because `g` is declared `transparent`).
+This example performs a simple type test over the scrutinee.
+The type can have a richer structure like the simple ADT below.
+`toInt` matches the structure of a number in [Church-encoding](https://en.wikipedia.org/wiki/Church_encoding)
+and _computes_ the corresponding integer.
+
+```scala
+trait Nat
+case object Zero extends Nat
+case class Succ[N <: Nat](n: N) extends Nat
+
+transparent inline def toInt(n: Nat): Int =
+  inline n match
+    case Zero     => 0
+    case Succ(n1) => toInt(n1) + 1
+
+inline val natTwo = toInt(Succ(Succ(Zero)))
+val intTwo: 2 = natTwo
+```
+
+`natTwo` is inferred to have the singleton type 2.
+
+## Reference
+
+For more information about the semantics of `inline`, see the [Scala 2020: Semantics-preserving inlining for metaprogramming](https://dl.acm.org/doi/10.1145/3426426.3428486) paper.
diff --git a/docs/_spec/TODOreference/metaprogramming/macros-spec.md b/docs/_spec/TODOreference/metaprogramming/macros-spec.md
new file mode 100644
index 000000000000..aa8f94a9a1f7
--- /dev/null
+++ b/docs/_spec/TODOreference/metaprogramming/macros-spec.md
@@ -0,0 +1,254 @@
+---
+layout: doc-page
+title: "Macros Spec"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/metaprogramming/macros-spec.html
+---
+
+## Implementation
+
+### Syntax
+
+Compared to the [Scala 3 reference grammar](../syntax.md)
+there are the following syntax changes:
+```
+SimpleExpr      ::=  ...
+                  |  ‘'’ ‘{’ Block ‘}’
+                  |  ‘'’ ‘[’ Type ‘]’
+                  |  ‘$’ ‘{’ Block ‘}’
+SimpleType      ::=  ...
+                  |  ‘$’ ‘{’ Block ‘}’
+```
+In addition, an identifier `$x` starting with a `$` that appears inside
+a quoted expression or type is treated as a splice `${x}` and a quoted identifier
+`'x` that appears inside a splice is treated as a quote `'{x}`
+
+### Implementation in `scalac`
+
+Quotes and splices are primitive forms in the generated abstract syntax trees.
+Top-level splices are eliminated during macro expansion while typing. On the
+other hand, top-level quotes are eliminated in an expansion phase `PickleQuotes`
+phase (after typing and pickling). PCP checking occurs while preparing the RHS
+of an inline method for top-level splices and in the `Staging` phase (after
+typing and before pickling).
+
+Macro-expansion works outside-in. If the outermost scope is a splice,
+the spliced AST will be evaluated in an interpreter. A call to a
+previously compiled method can be implemented as a reflective call to
+that method. With the restrictions on splices that are currently in
+place that’s all that’s needed. We might allow more interpretation in
+splices in the future, which would allow us to loosen the
+restriction.  Quotes in spliced, interpreted code are kept as they
+are, after splices nested in the quotes are expanded.
+
+If the outermost scope is a quote, we need to generate code that
+constructs the quoted tree at run-time. We implement this by
+serializing the tree as a TASTy structure, which is stored
+in a string literal. At runtime, an unpickler method is called to
+deserialize the string into a tree.
+
+Splices inside quoted code insert the spliced tree as is, after
+expanding any quotes in the spliced code recursively.
+
+## Formalization
+
+The phase consistency principle can be formalized in a calculus that
+extends simply-typed lambda calculus with quotes and splices.
+
+### Syntax
+
+The syntax of terms, values, and types is given as follows:
+```
+Terms         t  ::=  x                 variable
+                      (x: T) => t       lambda
+                      t t               application
+                      't                quote
+                      $t                splice
+
+Values        v  ::=  (x: T) => t       lambda
+                      'u                quote
+
+Simple terms  u  ::=  x  |  (x: T) => u  |  u u  |  't
+
+Types         T  ::=  A                 base type
+                      T -> T            function type
+                      expr T            quoted
+```
+Typing rules are formulated using a stack of environments
+`Es`. Individual environments `E` consist as usual of variable
+bindings `x: T`. Environments can be combined using the two
+combinators `'` and `$`.
+```
+Environment   E  ::=  ()                empty
+                      E, x: T
+
+Env. stack    Es ::=  ()                empty
+                      E                 simple
+                      Es * Es           combined
+
+Separator     *  ::=  '
+                      $
+```
+The two environment combinators are both associative with left and
+right identity `()`.
+
+### Operational semantics
+
+We define a small step reduction relation `-->` with the following rules:
+```
+          ((x: T) => t) v  -->  [x := v]t
+
+                    ${'u}  -->  u
+
+                       t1  -->  t2
+                    -----------------
+                    e[t1]  -->  e[t2]
+```
+The first rule is standard call-by-value beta-reduction. The second
+rule says that splice and quotes cancel each other out. The third rule
+is a context rule; it says that reduction is allowed in the hole `[ ]`
+position of an evaluation context.  Evaluation contexts `e` and
+splice evaluation context `e_s` are defined syntactically as follows:
+```
+Eval context    e    ::=  [ ]  |  e t  |  v e  |  'e_s[${e}]
+Splice context  e_s  ::=  [ ]  |  (x: T) => e_s  |  e_s t  |  u e_s
+```
+
+### Typing rules
+
+Typing judgments are of the form `Es |- t: T`. There are two
+substructural rules which express the fact that quotes and splices
+cancel each other out:
+```
+                    Es1 * Es2 |- t: T
+               ---------------------------
+               Es1 $ E1 ' E2 * Es2 |- t: T
+
+
+                    Es1 * Es2 |- t: T
+               ---------------------------
+               Es1 ' E1 $ E2 * Es2 |- t: T
+```
+The lambda calculus fragment of the rules is standard, except that we
+use a stack of environments. The rules only interact with the topmost
+environment of the stack.
+```
+                          x: T in E
+                        --------------
+                        Es * E |- x: T
+
+
+                    Es * E, x: T1 |- t: T2
+                -------------------------------
+                Es * E |- (x: T1) => t: T -> T2
+
+
+               Es |- t1: T2 -> T    Es |- t2: T2
+               ---------------------------------
+                      Es |- t1 t2: T
+```
+The rules for quotes and splices map between `expr T` and `T` by trading `'` and `$` between
+environments and terms.
+```
+                     Es $ () |- t: expr T
+                     --------------------
+                         Es |- $t: T
+
+
+                       Es ' () |- t: T
+                       ----------------
+                       Es |- 't: expr T
+```
+The meta theory of a slightly simplified 2-stage variant of this calculus
+is studied [separately](./simple-smp.md).
+
+## Going Further
+
+The metaprogramming framework as presented and currently implemented is quite restrictive
+in that it does not allow for the inspection of quoted expressions and
+types. It’s possible to work around this by providing all necessary
+information as normal, unquoted inline parameters. But we would gain
+more flexibility by allowing for the inspection of quoted code with
+pattern matching. This opens new possibilities.
+
+For instance, here is a version of `power` that generates the multiplications
+directly if the exponent is statically known and falls back to the dynamic
+implementation of `power` otherwise.
+```scala
+import scala.quoted.*
+
+inline def power(x: Double, n: Int): Double =
+  ${ powerExpr('x, 'n) }
+
+private def powerExpr(x: Expr[Double], n: Expr[Int])
+                     (using Quotes): Expr[Double] =
+  n.value match
+    case Some(m) => powerExpr(x, m)
+    case _ => '{ dynamicPower($x, $n) }
+
+private def powerExpr(x: Expr[Double], n: Int)
+                     (using Quotes): Expr[Double] =
+  if n == 0 then '{ 1.0 }
+  else if n == 1 then x
+  else if n % 2 == 0 then '{ val y = $x * $x; ${ powerExpr('y, n / 2) } }
+  else '{ $x * ${ powerExpr(x, n - 1) } }
+
+private def dynamicPower(x: Double, n: Int): Double =
+  if n == 0 then 1.0
+  else if n % 2 == 0 then dynamicPower(x * x, n / 2)
+  else x * dynamicPower(x, n - 1)
+```
+
+In the above, the method `.value` maps a constant expression of the type
+`Expr[T]` to its value of the type `T`.
+
+With the right extractors, the "AsFunction" conversion
+that maps expressions over functions to functions over expressions can
+be implemented in user code:
+```scala
+given AsFunction1[T, U]: Conversion[Expr[T => U], Expr[T] => Expr[U]] with
+  def apply(f: Expr[T => U]): Expr[T] => Expr[U] =
+    (x: Expr[T]) => f match
+      case Lambda(g) => g(x)
+      case _ => '{ ($f)($x) }
+```
+This assumes an extractor
+```scala
+object Lambda:
+  def unapply[T, U](x: Expr[T => U]): Option[Expr[T] => Expr[U]]
+```
+Once we allow inspection of code via extractors, it’s tempting to also
+add constructors that create typed trees directly without going
+through quotes. Most likely, those constructors would work over `Expr`
+types which lack a known type argument. For instance, an `Apply`
+constructor could be typed as follows:
+```scala
+def Apply(fn: Expr[Any], args: List[Expr[Any]]): Expr[Any]
+```
+This would allow constructing applications from lists of arguments
+without having to match the arguments one-by-one with the
+corresponding formal parameter types of the function. We then need "at
+the end" a method to convert an `Expr[Any]` to an `Expr[T]` where `T` is
+given from the outside. For instance, if `code` yields a `Expr[Any]`, then
+`code.atType[T]` yields an `Expr[T]`. The `atType` method has to be
+implemented as a primitive; it would check that the computed type
+structure of `Expr` is a subtype of the type structure representing
+`T`.
+
+Before going down that route, we should evaluate in detail the tradeoffs it
+presents. Constructing trees that are only verified _a posteriori_
+to be type correct loses a lot of guidance for constructing the right
+trees.  So we should wait with this addition until we have more
+use-cases that help us decide whether the loss in type-safety is worth
+the gain in flexibility. In this context, it seems that deconstructing types is
+less error-prone than deconstructing terms, so one might also
+envisage a solution that allows the former but not the latter.
+
+## Conclusion
+
+Metaprogramming has a reputation of being difficult and confusing.
+But with explicit `Expr/Type` types and quotes and splices it can become
+downright pleasant. A simple strategy first defines the underlying quoted or unquoted
+values using `Expr` and `Type` and then inserts quotes and splices to make the types
+line up. Phase consistency is at the same time a great guideline
+where to insert a splice or a quote and a vital sanity check that
+the result makes sense.
diff --git a/docs/_spec/TODOreference/metaprogramming/macros.md b/docs/_spec/TODOreference/metaprogramming/macros.md
new file mode 100644
index 000000000000..8045794d1143
--- /dev/null
+++ b/docs/_spec/TODOreference/metaprogramming/macros.md
@@ -0,0 +1,823 @@
+---
+layout: doc-page
+title: "Macros"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/metaprogramming/macros.html
+---
+
+> When developing macros enable `-Xcheck-macros` scalac option flag to have extra runtime checks.
+
+## Macros: Quotes and Splices
+
+Macros are built on two well-known fundamental operations: quotation and splicing.
+Quotation is expressed as `'{...}` for expressions and splicing is expressed as `${ ... }`.
+Additionally, within a quote or a splice we can quote or splice identifiers directly (i.e. `'e` and `$e`).
+Readers may notice the resemblance of the two aforementioned syntactic
+schemes with the familiar string interpolation syntax.
+
+```scala
+println(s"Hello, $name, here is the result of 1 + 1 = ${1 + 1}")
+```
+
+In string interpolation we _quoted_ a string and then we _spliced_ into it, two others. The first, `name`, is a reference to a value of type [`String`](https://scala-lang.org/api/3.x/scala/Predef$.html#String-0), and the second is an arithmetic expression that will be _evaluated_ followed by the splicing of its string representation.
+
+Quotes and splices in this section allow us to treat code in a similar way,
+effectively supporting macros. The entry point for macros is an inline method
+with a top-level splice. We call it a top-level because it is the only occasion
+where we encounter a splice outside a quote (consider as a quote the
+compilation-unit at the call-site). For example, the code below presents an
+`inline` method `assert` which calls at compile-time a method `assertImpl` with
+a boolean expression tree as argument. `assertImpl` evaluates the expression and
+prints it again in an error message if it evaluates to `false`.
+
+```scala
+import scala.quoted.*
+
+inline def assert(inline expr: Boolean): Unit =
+  ${ assertImpl('expr) }
+
+def assertImpl(expr: Expr[Boolean])(using Quotes) = '{
+  if !$expr then
+    throw AssertionError(s"failed assertion: ${${ showExpr(expr) }}")
+}
+
+def showExpr(expr: Expr[Boolean])(using Quotes): Expr[String] =
+  '{ [actual implementation later in this document] }
+```
+
+If `e` is an expression, then `'{e}` represents the typed
+abstract syntax tree representing `e`. If `T` is a type, then `Type.of[T]`
+represents the type structure representing `T`.  The precise
+definitions of "typed abstract syntax tree" or "type-structure" do not
+matter for now, the terms are used only to give some
+intuition. Conversely, `${e}` evaluates the expression `e`, which must
+yield a typed abstract syntax tree or type structure, and embeds the
+result as an expression (respectively, type) in the enclosing program.
+
+Quotations can have spliced parts in them; in this case the embedded
+splices are evaluated and embedded as part of the formation of the
+quotation.
+
+Quotes and splices can also be applied directly to identifiers. An identifier
+`$x` starting with a `$` that appears inside a quoted expression or type is treated as a
+splice `${x}`. Analogously, an quoted identifier `'x` that appears inside a splice
+is treated as a quote `'{x}`. See the Syntax section below for details.
+
+Quotes and splices are duals of each other.
+For arbitrary expressions `e` we have:
+
+```scala
+${'{e}} = e
+'{${e}} = e
+```
+
+## Types for Quotations
+
+The type signatures of quotes and splices can be described using
+two fundamental types:
+
+- `Expr[T]`: abstract syntax trees representing expressions of type `T`
+- `Type[T]`: non erased representation of type `T`.
+
+Quoting takes expressions of type `T` to expressions of type `Expr[T]`
+and it takes types `T` to expressions of type `Type[T]`. Splicing
+takes expressions of type `Expr[T]` to expressions of type `T` and it
+takes expressions of type `Type[T]` to types `T`.
+
+The two types can be defined in package [`scala.quoted`](https://scala-lang.org/api/3.x/scala/quoted.html) as follows:
+
+```scala
+package scala.quoted
+
+sealed trait Expr[+T]
+sealed trait Type[T]
+```
+
+Both `Expr` and `Type` are abstract and sealed, so all constructors for
+these types are provided by the system. One way to construct values of
+these types is by quoting, the other is by type-specific lifting
+operations that will be discussed later on.
+
+## The Phase Consistency Principle
+
+A fundamental *phase consistency principle* (PCP) regulates accesses
+to free variables in quoted and spliced code:
+
+- _For any free variable reference `x`, the number of quoted scopes and the number of spliced scopes between the reference to `x` and the definition of `x` must be equal_.
+
+Here, `this`-references count as free variables. On the other
+hand, we assume that all imports are fully expanded and that `_root_` is
+not a free variable. So references to global definitions are
+allowed everywhere.
+
+The phase consistency principle can be motivated as follows: First,
+suppose the result of a program `P` is some quoted text `'{ ... x
+... }` that refers to a free variable `x` in `P`. This can be
+represented only by referring to the original variable `x`. Hence, the
+result of the program will need to persist the program state itself as
+one of its parts. We don’t want to do this, hence this situation
+should be made illegal. Dually, suppose a top-level part of a program
+is a spliced text `${ ... x ... }` that refers to a free variable `x`
+in `P`.  This would mean that we refer during _construction_ of `P` to
+a value that is available only during _execution_ of `P`. This is of
+course impossible and therefore needs to be ruled out.  Now, the
+small-step evaluation of a program will reduce quotes and splices in
+equal measure using the cancellation rules above. But it will neither
+create nor remove quotes or splices individually. So the PCP ensures
+that program elaboration will lead to neither of the two unwanted
+situations described above.
+
+In what concerns the range of features it covers, this form of macros introduces
+a principled metaprogramming framework that is quite close to the MetaML family of
+languages. One difference is that MetaML does not have an equivalent of the PCP -
+quoted code in MetaML _can_ access variables in its immediately enclosing
+environment, with some restrictions and caveats since such accesses involve
+serialization. However, this does not constitute a fundamental gain in
+expressiveness.
+
+## From `Expr`s to Functions and Back
+
+It is possible to convert any `Expr[T => R]` into `Expr[T] => Expr[R]` and back.
+These conversions can be implemented as follows:
+
+```scala
+def to[T: Type, R: Type](f: Expr[T] => Expr[R])(using Quotes): Expr[T => R] =
+  '{ (x: T) => ${ f('x) } }
+
+def from[T: Type, R: Type](f: Expr[T => R])(using Quotes): Expr[T] => Expr[R] =
+  (x: Expr[T]) => '{ $f($x) }
+```
+
+Note how the fundamental phase consistency principle works in two
+different directions here for `f` and `x`.  In the method `to`,  the reference to `f` is
+legal because it is quoted, then spliced, whereas the reference to `x`
+is legal because it is spliced, then quoted.
+
+They can be used as follows:
+
+```scala
+val f1: Expr[Int => String] =
+  to((x: Expr[Int]) => '{ $x.toString }) // '{ (x: Int) => x.toString }
+
+val f2: Expr[Int] => Expr[String] =
+  from('{ (x: Int) => x.toString }) // (x: Expr[Int]) => '{ ((x: Int) => x.toString)($x) }
+f2('{2}) // '{ ((x: Int) => x.toString)(2) }
+```
+
+One limitation of `from` is that it does not β-reduce when a lambda is called immediately, as evidenced in the code `{ ((x: Int) => x.toString)(2) }`.
+In some cases we want to remove the lambda from the code, for this we provide the method `Expr.betaReduce` that turns a tree
+describing a function into a function mapping trees to trees.
+
+```scala
+object Expr:
+  ...
+  def betaReduce[...](...)(...): ... = ...
+```
+
+The definition of `Expr.betaReduce(f)(x)` is assumed to be functionally the same as
+`'{($f)($x)}`, however it should optimize this call by returning the
+result of beta-reducing `f(x)` if `f` is a known lambda expression.
+`Expr.betaReduce` distributes applications of `Expr` over function arrows:
+
+```scala
+Expr.betaReduce(_): Expr[(T1, ..., Tn) => R] => ((Expr[T1], ..., Expr[Tn]) => Expr[R])
+```
+
+## Lifting Types
+
+Types are not directly affected by the phase consistency principle.
+It is possible to use types defined at any level in any other level.
+But, if a type is used in a subsequent stage it will need to be lifted to a `Type`.
+Indeed, the definition of `to` above uses `T` in the next stage, there is a
+quote but no splice between the parameter binding of `T` and its
+usage. But the code can be rewritten by adding an explicit binding of a `Type[T]`:
+
+```scala
+def to[T, R](f: Expr[T] => Expr[R])(using t: Type[T])(using Type[R], Quotes): Expr[T => R] =
+  '{ (x: t.Underlying) => ${ f('x) } }
+```
+
+In this version of `to`, the type of `x` is now the result of
+inserting the type `Type[T]` and selecting its `Underlying`.
+
+To avoid clutter, the compiler converts any type reference to
+a type `T` in subsequent phases to `summon[Type[T]].Underlying`.
+
+And to avoid duplication it does it once per type, and creates
+an alias for that type at the start of the quote.
+
+For instance, the user-level definition of `to`:
+
+```scala
+def to[T, R](f: Expr[T] => Expr[R])(using t: Type[T], r: Type[R])(using Quotes): Expr[T => R] =
+  '{ (x: T) => ${ f('x) } }
+```
+
+would be rewritten to
+
+```scala
+def to[T, R](f: Expr[T] => Expr[R])(using t: Type[T], r: Type[R])(using Quotes): Expr[T => R] =
+  '{
+    type T = t.Underlying
+    (x: T) => ${ f('x) }
+  }
+```
+
+The `summon` query succeeds because there is a given instance of
+type `Type[T]` available (namely the given parameter corresponding
+to the context bound `: Type`), and the reference to that value is
+phase-correct. If that was not the case, the phase inconsistency for
+`T` would be reported as an error.
+
+## Lifting Expressions
+
+Consider the following implementation of a staged interpreter that implements
+a compiler through staging.
+
+```scala
+import scala.quoted.*
+
+enum Exp:
+  case Num(n: Int)
+  case Plus(e1: Exp, e2: Exp)
+  case Var(x: String)
+  case Let(x: String, e: Exp, in: Exp)
+
+import Exp.*
+```
+
+The interpreted language consists of numbers `Num`, addition `Plus`, and variables
+`Var` which are bound by `Let`. Here are two sample expressions in the language:
+
+```scala
+val exp = Plus(Plus(Num(2), Var("x")), Num(4))
+val letExp = Let("x", Num(3), exp)
+```
+
+Here’s a compiler that maps an expression given in the interpreted
+language to quoted Scala code of type `Expr[Int]`.
+The compiler takes an environment that maps variable names to Scala `Expr`s.
+
+```scala
+import scala.quoted.*
+
+def compile(e: Exp, env: Map[String, Expr[Int]])(using Quotes): Expr[Int] =
+  e match
+    case Num(n) =>
+      Expr(n)
+    case Plus(e1, e2) =>
+      '{ ${ compile(e1, env) } + ${ compile(e2, env) } }
+    case Var(x) =>
+      env(x)
+    case Let(x, e, body) =>
+      '{ val y = ${ compile(e, env) }; ${ compile(body, env + (x -> 'y)) } }
+```
+
+Running `compile(letExp, Map())` would yield the following Scala code:
+
+```scala
+'{ val y = 3; (2 + y) + 4 }
+```
+
+The body of the first clause, `case Num(n) => Expr(n)`, looks suspicious. `n`
+is declared as an `Int`, yet it is converted to an `Expr[Int]` with `Expr()`.
+Shouldn’t `n` be quoted? In fact this would not
+work since replacing `n` by `'n` in the clause would not be phase
+correct.
+
+The `Expr.apply` method is defined in package `quoted`:
+
+```scala
+package quoted
+
+object Expr:
+  ...
+  def apply[T: ToExpr](x: T)(using Quotes): Expr[T] =
+    summon[ToExpr[T]].toExpr(x)
+```
+
+This method says that values of types implementing the `ToExpr` type class can be
+converted to `Expr` values using `Expr.apply`.
+
+Scala 3 comes with given instances of `ToExpr` for
+several types including `Boolean`, `String`, and all primitive number
+types. For example, `Int` values can be converted to `Expr[Int]`
+values by wrapping the value in a `Literal` tree node. This makes use
+of the underlying tree representation in the compiler for
+efficiency. But the `ToExpr` instances are nevertheless not _magic_
+in the sense that they could all be defined in a user program without
+knowing anything about the representation of `Expr` trees. For
+instance, here is a possible instance of `ToExpr[Boolean]`:
+
+```scala
+given ToExpr[Boolean] with
+  def toExpr(b: Boolean) =
+    if b then '{ true } else '{ false }
+```
+
+Once we can lift bits, we can work our way up. For instance, here is a
+possible implementation of `ToExpr[Int]` that does not use the underlying
+tree machinery:
+
+```scala
+given ToExpr[Int] with
+  def toExpr(n: Int) = n match
+    case Int.MinValue    => '{ Int.MinValue }
+    case _ if n < 0      => '{ - ${ toExpr(-n) } }
+    case 0               => '{ 0 }
+    case _ if n % 2 == 0 => '{ ${ toExpr(n / 2) } * 2 }
+    case _               => '{ ${ toExpr(n / 2) } * 2 + 1 }
+```
+
+Since `ToExpr` is a type class, its instances can be conditional. For example,
+a `List` is liftable if its element type is:
+
+```scala
+given [T: ToExpr : Type]: ToExpr[List[T]] with
+  def toExpr(xs: List[T]) = xs match
+    case head :: tail => '{ ${ Expr(head) } :: ${ toExpr(tail) } }
+    case Nil          => '{ Nil: List[T] }
+```
+
+In the end, `ToExpr` resembles very much a serialization
+framework. Like the latter it can be derived systematically for all
+collections, case classes and enums. Note also that the synthesis
+of _type-tag_ values of type `Type[T]` is essentially the type-level
+analogue of lifting.
+
+Using lifting, we can now give the missing definition of `showExpr` in the introductory example:
+
+```scala
+def showExpr[T](expr: Expr[T])(using Quotes): Expr[String] =
+  val code: String = expr.show
+  Expr(code)
+```
+
+That is, the `showExpr` method converts its `Expr` argument to a string (`code`), and lifts
+the result back to an `Expr[String]` using `Expr.apply`.
+
+## Lifting Types
+
+The previous section has shown that the metaprogramming framework has
+to be able to take a type `T` and convert it to a type tree of type
+`Type[T]` that can be reified. This means that all free variables of
+the type tree refer to types and values defined in the current stage.
+
+For a reference to a global class, this is easy: Just issue the fully
+qualified name of the class. Members of reifiable types are handled by
+just reifying the containing type together with the member name. But
+what to do for references to type parameters or local type definitions
+that are not defined in the current stage? Here, we cannot construct
+the `Type[T]` tree directly, so we need to get it from a recursive
+implicit search. For instance, to implement
+
+```scala
+summon[Type[List[T]]]
+```
+
+where `T` is not defined in the current stage, we construct the type constructor
+of `List` applied to the splice of the result of searching for a given instance for `Type[T]`:
+
+```scala
+Type.of[ List[ summon[Type[T]].Underlying ] ]
+```
+
+This is exactly the algorithm that Scala 2 uses to search for type tags.
+In fact Scala 2's type tag feature can be understood as a more ad-hoc version of
+`quoted.Type`. As was the case for type tags, the implicit search for a `quoted.Type`
+is handled by the compiler, using the algorithm sketched above.
+
+## Relationship with `inline`
+
+Seen by itself, principled metaprogramming looks more like a framework for
+runtime metaprogramming than one for compile-time metaprogramming with macros.
+But combined with Scala 3’s `inline` feature it can be turned into a compile-time
+system. The idea is that macro elaboration can be understood as a combination of
+a macro library and a quoted program. For instance, here’s the `assert` macro
+again together with a program that calls `assert`.
+
+```scala
+object Macros:
+
+  inline def assert(inline expr: Boolean): Unit =
+    ${ assertImpl('expr) }
+
+  def assertImpl(expr: Expr[Boolean])(using Quotes) =
+    val failMsg: Expr[String] = Expr("failed assertion: " + expr.show)
+    '{ if !($expr) then throw new AssertionError($failMsg) }
+
+@main def program =
+  val x = 1
+  Macros.assert(x != 0)
+```
+
+Inlining the `assert` function would give the following program:
+
+```scala
+@main def program =
+  val x = 1
+  ${ Macros.assertImpl('{ x != 0}) }
+```
+
+The example is only phase correct because `Macros` is a global value and
+as such not subject to phase consistency checking. Conceptually that’s
+a bit unsatisfactory. If the PCP is so fundamental, it should be
+applicable without the global value exception. But in the example as
+given this does not hold since both `assert` and `program` call
+`assertImpl` with a splice but no quote.
+
+However, one could argue that the example is really missing
+an important aspect: The macro library has to be compiled in a phase
+prior to the program using it, but in the code above, macro
+and program are defined together. A more accurate view of
+macros would be to have the user program be in a phase after the macro
+definitions, reflecting the fact that macros have to be defined and
+compiled before they are used. Hence, conceptually the program part
+should be treated by the compiler as if it was quoted:
+
+```scala
+@main def program = '{
+  val x = 1
+  ${ Macros.assertImpl('{ x != 0 }) }
+}
+```
+
+If `program` is treated as a quoted expression, the call to
+`Macro.assertImpl` becomes phase correct even if macro library and
+program are conceptualized as local definitions.
+
+But what about the call from `assert` to `assertImpl`? Here, we need a
+tweak of the typing rules. An inline function such as `assert` that
+contains a splice operation outside an enclosing quote is called a
+_macro_. Macros are supposed to be expanded in a subsequent phase,
+i.e. in a quoted context. Therefore, they are also type checked as if
+they were in a quoted context. For instance, the definition of
+`assert` is typechecked as if it appeared inside quotes.  This makes
+the call from `assert` to `assertImpl` phase-correct, even if we
+assume that both definitions are local.
+
+The `inline` modifier is used to declare a `val` that is
+either a constant or is a parameter that will be a constant when instantiated. This
+aspect is also important for macro expansion.
+
+To get values out of expressions containing constants `Expr` provides the method
+`value` (or `valueOrError`). This will convert the `Expr[T]` into a `Some[T]` (or `T`) when the
+expression contains value. Otherwise it will return `None` (or emit an error).
+To avoid having incidental val bindings generated by the inlining of the `def`
+it is recommended to use an inline parameter. To illustrate this, consider an
+implementation of the `power` function that makes use of a statically known exponent:
+
+```scala
+inline def power(x: Double, inline n: Int) = ${ powerCode('x, 'n) }
+
+private def powerCode(x: Expr[Double], n: Expr[Int])(using Quotes): Expr[Double] =
+  n.value match
+    case Some(m) => powerCode(x, m)
+    case None => '{ Math.pow($x, $n.toDouble) }
+
+private def powerCode(x: Expr[Double], n: Int)(using Quotes): Expr[Double] =
+  if n == 0 then '{ 1.0 }
+  else if n == 1 then x
+  else if n % 2 == 0 then '{ val y = $x * $x; ${ powerCode('y, n / 2) } }
+  else '{ $x * ${ powerCode(x, n - 1) } }
+```
+
+## Scope Extrusion
+
+Quotes and splices are duals as far as the PCP is concerned. But there is an
+additional restriction that needs to be imposed on splices to guarantee
+soundness: code in splices must be free of side effects. The restriction
+prevents code like this:
+
+```scala
+var x: Expr[T] = ...
+'{ (y: T) => ${ x = 'y; 1 } }
+```
+
+This code, if it was accepted, would _extrude_ a reference to a quoted variable
+`y` from its scope. This would subsequently allow access to a variable outside the
+scope where it is defined, which is likely problematic. The code is clearly
+phase consistent, so we cannot use PCP to rule it out. Instead, we postulate a
+future effect system that can guarantee that splices are pure. In the absence of
+such a system we simply demand that spliced expressions are pure by convention,
+and allow for undefined compiler behavior if they are not. This is analogous to
+the status of pattern guards in Scala, which are also required, but not
+verified, to be pure.
+
+[Multi-Stage Programming](./staging.md) introduces one additional method where
+you can expand code at runtime with a method `run`. There is also a problem with
+that invocation of `run` in splices. Consider the following expression:
+
+```scala
+'{ (x: Int) => ${ run('x); 1 } }
+```
+
+This is again phase correct, but will lead us into trouble. Indeed, evaluating
+the splice will reduce the expression `run('x)` to `x`. But then the result
+
+```scala
+'{ (x: Int) => ${ x; 1 } }
+```
+
+is no longer phase correct. To prevent this soundness hole it seems easiest to
+classify `run` as a side-effecting operation. It would thus be prevented from
+appearing in splices. In a base language with side effects we would have to do this
+anyway: Since `run` runs arbitrary code it can always produce a side effect if
+the code it runs produces one.
+
+## Example Expansion
+
+Assume we have two methods, one `map` that takes an `Expr[Array[T]]` and a
+function `f` and one `sum` that performs a sum by delegating to `map`.
+
+```scala
+object Macros:
+
+  def map[T](arr: Expr[Array[T]], f: Expr[T] => Expr[Unit])
+            (using Type[T], Quotes): Expr[Unit] = '{
+    var i: Int = 0
+    while i < ($arr).length do
+      val element: T = ($arr)(i)
+      ${f('element)}
+      i += 1
+  }
+
+  def sum(arr: Expr[Array[Int]])(using Quotes): Expr[Int] = '{
+    var sum = 0
+    ${ map(arr, x => '{sum += $x}) }
+    sum
+  }
+
+  inline def sum_m(arr: Array[Int]): Int = ${sum('arr)}
+
+end Macros
+```
+
+A call to `sum_m(Array(1,2,3))` will first inline `sum_m`:
+
+```scala
+val arr: Array[Int] = Array.apply(1, [2,3 : Int]:Int*)
+${_root_.Macros.sum('arr)}
+```
+
+then it will splice `sum`:
+
+```scala
+val arr: Array[Int] = Array.apply(1, [2,3 : Int]:Int*)
+
+var sum = 0
+${ map('arr, x => '{sum += $x}) }
+sum
+```
+
+then it will inline `map`:
+
+```scala
+val arr: Array[Int] = Array.apply(1, [2,3 : Int]:Int*)
+
+var sum = 0
+val f = x => '{sum += $x}
+${ _root_.Macros.map('arr, 'f)(Type.of[Int])}
+sum
+```
+
+then it will expand and splice inside quotes `map`:
+
+```scala
+val arr: Array[Int] = Array.apply(1, [2,3 : Int]:Int*)
+
+var sum = 0
+val f = x => '{sum += $x}
+var i: Int = 0
+while i < arr.length do
+  val element: Int = (arr)(i)
+  sum += element
+  i += 1
+sum
+```
+
+Finally cleanups and dead code elimination:
+
+```scala
+val arr: Array[Int] = Array.apply(1, [2,3 : Int]:Int*)
+var sum = 0
+var i: Int = 0
+while i < arr.length do
+  val element: Int = arr(i)
+  sum += element
+  i += 1
+sum
+```
+
+## Find implicits within a macro
+
+Similarly to the `summonFrom` construct, it is possible to make implicit search available
+in a quote context. For this we simply provide `scala.quoted.Expr.summon`:
+
+```scala
+import scala.collection.immutable.{ TreeSet, HashSet }
+inline def setFor[T]: Set[T] = ${ setForExpr[T] }
+
+def setForExpr[T: Type](using Quotes): Expr[Set[T]] =
+  Expr.summon[Ordering[T]] match
+    case Some(ord) => '{ new TreeSet[T]()($ord) }
+    case _ => '{ new HashSet[T] }
+```
+
+## Relationship with Transparent Inline
+
+[Inline](./inline.md) documents inlining. The code below introduces a transparent
+inline method that can calculate either a value of type `Int` or a value of type
+`String`.
+
+```scala
+transparent inline def defaultOf(inline str: String) =
+  ${ defaultOfImpl('str) }
+
+def defaultOfImpl(strExpr: Expr[String])(using Quotes): Expr[Any] =
+  strExpr.valueOrError match
+    case "int" => '{1}
+    case "string" => '{"a"}
+
+// in a separate file
+val a: Int = defaultOf("int")
+val b: String = defaultOf("string")
+
+```
+
+## Defining a macro and using it in a single project
+
+It is possible to define macros and use them in the same project as long as the implementation
+of the macros does not have run-time dependencies on code in the file where it is used.
+It might still have compile-time dependencies on types and quoted code that refers to the use-site file.
+
+To provide this functionality Scala 3 provides a transparent compilation mode where files that
+try to expand a macro but fail because the macro has not been compiled yet are suspended.
+If there are any suspended files when the compilation ends, the compiler will automatically restart
+compilation of the suspended files using the output of the previous (partial) compilation as macro classpath.
+In case all files are suspended due to cyclic dependencies the compilation will fail with an error.
+
+## Pattern matching on quoted expressions
+
+It is possible to deconstruct or extract values out of `Expr` using pattern matching.
+
+`scala.quoted` contains objects that can help extracting values from `Expr`.
+
+- `scala.quoted.Expr`/`scala.quoted.Exprs`: matches an expression of a value (or list of values) and returns the value (or list of values).
+- `scala.quoted.Const`/`scala.quoted.Consts`: Same as `Expr`/`Exprs` but only works on primitive values.
+- `scala.quoted.Varargs`: matches an explicit sequence of expressions and returns them. These sequences are useful to get individual `Expr[T]` out of a varargs expression of type `Expr[Seq[T]]`.
+
+These could be used in the following way to optimize any call to `sum` that has statically known values.
+
+```scala
+inline def sum(inline args: Int*): Int = ${ sumExpr('args) }
+private def sumExpr(argsExpr: Expr[Seq[Int]])(using Quotes): Expr[Int] =
+  argsExpr match
+    case Varargs(args @ Exprs(argValues)) =>
+      // args is of type Seq[Expr[Int]]
+      // argValues is of type Seq[Int]
+      Expr(argValues.sum) // precompute result of sum
+    case Varargs(argExprs) => // argExprs is of type Seq[Expr[Int]]
+      val staticSum: Int = argExprs.map(_.value.getOrElse(0)).sum
+      val dynamicSum: Seq[Expr[Int]] = argExprs.filter(_.value.isEmpty)
+      dynamicSum.foldLeft(Expr(staticSum))((acc, arg) => '{ $acc + $arg })
+    case _ =>
+      '{ $argsExpr.sum }
+```
+
+### Quoted patterns
+
+Quoted pattens allow deconstructing complex code that contains a precise structure, types or methods.
+Patterns `'{ ... }` can be placed in any location where Scala expects a pattern.
+
+For example
+
+```scala
+optimize {
+   sum(sum(1, a, 2), 3, b)
+} // should be optimized to 6 + a + b
+```
+
+```scala
+def sum(args: Int*): Int = args.sum
+inline def optimize(inline arg: Int): Int = ${ optimizeExpr('arg) }
+private def optimizeExpr(body: Expr[Int])(using Quotes): Expr[Int] =
+  body match
+    // Match a call to sum without any arguments
+    case '{ sum() } => Expr(0)
+    // Match a call to sum with an argument $n of type Int.
+    // n will be the Expr[Int] representing the argument.
+    case '{ sum($n) } => n
+    // Match a call to sum and extracts all its args in an `Expr[Seq[Int]]`
+    case '{ sum(${Varargs(args)}: _*) } => sumExpr(args)
+    case body => body
+
+private def sumExpr(args1: Seq[Expr[Int]])(using Quotes): Expr[Int] =
+  def flatSumArgs(arg: Expr[Int]): Seq[Expr[Int]] = arg match
+    case '{ sum(${Varargs(subArgs)}: _*) } => subArgs.flatMap(flatSumArgs)
+    case arg => Seq(arg)
+  val args2 = args1.flatMap(flatSumArgs)
+  val staticSum: Int = args2.map(_.value.getOrElse(0)).sum
+  val dynamicSum: Seq[Expr[Int]] = args2.filter(_.value.isEmpty)
+  dynamicSum.foldLeft(Expr(staticSum))((acc, arg) => '{ $acc + $arg })
+```
+
+### Recovering precise types using patterns
+
+Sometimes it is necessary to get a more precise type for an expression. This can be achieved using the following pattern match.
+
+```scala
+def f(expr: Expr[Any])(using Quotes) = expr match
+  case '{ $x: t } =>
+    // If the pattern match succeeds, then there is
+    // some type `t` such that
+    // - `x` is bound to a variable of type `Expr[t]`
+    // - `t` is bound to a new type `t` and a given
+    //   instance `Type[t]` is provided for it
+    // That is, we have `x: Expr[t]` and `given Type[t]`,
+    // for some (unknown) type `t`.
+```
+
+This might be used to then perform an implicit search as in:
+
+```scala
+extension (inline sc: StringContext)
+  inline def showMe(inline args: Any*): String = ${ showMeExpr('sc, 'args) }
+
+private def showMeExpr(sc: Expr[StringContext], argsExpr: Expr[Seq[Any]])(using Quotes): Expr[String] =
+  import quotes.reflect.report
+  argsExpr match
+    case Varargs(argExprs) =>
+      val argShowedExprs = argExprs.map {
+        case '{ $arg: tp } =>
+          Expr.summon[Show[tp]] match
+            case Some(showExpr) =>
+              '{ $showExpr.show($arg) }
+            case None =>
+              report.error(s"could not find implicit for ${Type.show[Show[tp]]}", arg); '{???}
+      }
+      val newArgsExpr = Varargs(argShowedExprs)
+      '{ $sc.s($newArgsExpr: _*) }
+    case _ =>
+      // `new StringContext(...).showMeExpr(args: _*)` not an explicit `showMeExpr"..."`
+      report.error(s"Args must be explicit", argsExpr)
+      '{???}
+
+trait Show[-T]:
+  def show(x: T): String
+
+// in a different file
+given Show[Boolean] with
+  def show(b: Boolean) = "boolean!"
+
+println(showMe"${true}")
+```
+
+### Open code patterns
+
+Quoted pattern matching also provides higher-order patterns to match open terms. If a quoted term contains a definition,
+then the rest of the quote can refer to this definition.
+
+```scala
+'{
+  val x: Int = 4
+  x * x
+}
+```
+
+To match such a term we need to match the definition and the rest of the code, but we need to explicitly state that the rest of the code may refer to this definition.
+
+```scala
+case '{ val y: Int = $x; $body(y): Int } =>
+```
+
+Here `$x` will match any closed expression while `$body(y)` will match an expression that is closed under `y`. Then
+the subexpression of type `Expr[Int]` is bound to `body` as an `Expr[Int => Int]`. The extra argument represents the references to `y`. Usually this expression is used in combination with `Expr.betaReduce` to replace the extra argument.
+
+```scala
+inline def eval(inline e: Int): Int = ${ evalExpr('e) }
+
+private def evalExpr(e: Expr[Int])(using Quotes): Expr[Int] = e match
+  case '{ val y: Int = $x; $body(y): Int } =>
+    // body: Expr[Int => Int] where the argument represents
+    // references to y
+    evalExpr(Expr.betaReduce('{$body(${evalExpr(x)})}))
+  case '{ ($x: Int) * ($y: Int) } =>
+    (x.value, y.value) match
+      case (Some(a), Some(b)) => Expr(a * b)
+      case _ => e
+  case _ => e
+```
+
+```scala
+eval { // expands to the code: (16: Int)
+  val x: Int = 4
+  x * x
+}
+```
+
+We can also close over several bindings using `$b(a1, a2, ..., an)`.
+To match an actual application we can use braces on the function part `${b}(a1, a2, ..., an)`.
+
+## More details
+
+[More details](./macros-spec.md)
diff --git a/docs/_spec/TODOreference/metaprogramming/metaprogramming.md b/docs/_spec/TODOreference/metaprogramming/metaprogramming.md
new file mode 100644
index 000000000000..3bce2d7c922e
--- /dev/null
+++ b/docs/_spec/TODOreference/metaprogramming/metaprogramming.md
@@ -0,0 +1,47 @@
+---
+layout: index
+title: "Metaprogramming"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/metaprogramming.html
+---
+
+The following pages introduce the redesign of metaprogramming in Scala. They
+introduce the following fundamental facilities:
+
+1. [`inline`](./inline.md) is a new modifier that guarantees that
+   a definition will be inlined at the point of use. The primary motivation
+   behind inline is to reduce the overhead behind function calls and access to
+   values. The expansion will be performed by the Scala compiler during the
+   `Typer` compiler phase. As opposed to inlining in some other ecosystems,
+   inlining in Scala is not merely a request to the compiler but is a
+   _command_. The reason is that inlining in Scala can drive other compile-time
+   operations, like inline pattern matching (enabling type-level
+   programming), macros (enabling compile-time, generative, metaprogramming) and
+   runtime code generation (multi-stage programming).
+
+2. [Compile-time ops](./compiletime-ops.md) are helper definitions in the
+   standard library that provide support for compile-time operations over values and types.
+
+3. [Macros](./macros.md) are built on two well-known fundamental
+   operations: quotation and splicing.  Quotation converts program code to
+   data, specifically, a (tree-like) representation of this code. It is
+   expressed as `'{...}` for expressions and as `'[...]` for types. Splicing,
+   expressed as `${ ... }`, goes the other way: it converts a program's representation
+   to program code. Together with `inline`, these two abstractions allow
+   to construct program code programmatically.
+
+4. [Runtime Staging](./staging.md) Where macros construct code at _compile-time_,
+   staging lets programs construct new code at _runtime_. That way,
+   code generation can depend not only on static data but also on data available at runtime. This splits the evaluation of the program in two or more phases or ...
+   stages. Consequently, this method of generative programming is called "Multi-Stage Programming". Staging is built on the same foundations as macros. It uses
+   quotes and splices, but leaves out `inline`.
+
+5. [Reflection](./reflection.md) Quotations are a "black-box"
+   representation of code. They can be parameterized and composed using
+   splices, but their structure cannot be analyzed from the outside. TASTy
+   reflection gives a way to analyze code structure by partly revealing the representation type of a piece of code in a standard API. The representation
+   type is a form of typed abstract syntax tree, which gives rise to the `TASTy`
+   moniker.
+
+6. [TASTy Inspection](./tasty-inspect.md) Typed abstract syntax trees are serialized
+   in a custom compressed binary format stored in `.tasty` files. TASTy inspection allows
+   to load these files and analyze their content's tree structure.
diff --git a/docs/_spec/TODOreference/metaprogramming/reflection.md b/docs/_spec/TODOreference/metaprogramming/reflection.md
new file mode 100644
index 000000000000..b2d492657a4e
--- /dev/null
+++ b/docs/_spec/TODOreference/metaprogramming/reflection.md
@@ -0,0 +1,131 @@
+---
+layout: doc-page
+title: "Reflection"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/metaprogramming/reflection.html
+---
+
+Reflection enables inspection and construction of Typed Abstract Syntax Trees
+(Typed-AST). It may be used on quoted expressions (`quoted.Expr`) and quoted
+types (`quoted.Type`) from [Macros](./macros.md) or on full TASTy files.
+
+If you are writing macros, please first read [Macros](./macros.md).
+You may find all you need without using quote reflection.
+
+## API: From quotes and splices to TASTy reflect trees and back
+
+With `quoted.Expr` and `quoted.Type` we can compute code but also analyze code
+by inspecting the ASTs. [Macros](./macros.md) provide the guarantee that the
+generation of code will be type-correct. Using quote reflection will break these
+guarantees and may fail at macro expansion time, hence additional explicit
+checks must be done.
+
+To provide reflection capabilities in macros we need to add an implicit parameter
+of type `scala.quoted.Quotes` and import `quotes.reflect.*` from it in the scope
+where it is used.
+
+```scala
+import scala.quoted.*
+
+inline def natConst(inline x: Int): Int = ${natConstImpl('{x})}
+
+def natConstImpl(x: Expr[Int])(using Quotes): Expr[Int] =
+  import quotes.reflect.*
+  ...
+```
+
+### Extractors
+
+`import quotes.reflect.*` will provide all extractors and methods on `quotes.reflect.Tree`s.
+For example the `Literal(_)` extractor used below.
+
+```scala
+def natConstImpl(x: Expr[Int])(using Quotes): Expr[Int] =
+  import quotes.reflect.*
+  val tree: Term = x.asTerm
+  tree match
+    case Inlined(_, _, Literal(IntConstant(n))) =>
+      if n <= 0 then
+        report.error("Parameter must be natural number")
+        '{0}
+      else
+        tree.asExprOf[Int]
+    case _ =>
+      report.error("Parameter must be a known constant")
+      '{0}
+```
+
+We can easily know which extractors are needed using `Printer.TreeStructure.show`,
+which returns the string representation the structure of the tree. Other printers
+can also be found in the `Printer` module.
+
+```scala
+tree.show(using Printer.TreeStructure)
+// or
+Printer.TreeStructure.show(tree)
+```
+
+The methods `quotes.reflect.Term.{asExpr, asExprOf}` provide a way to go back to
+a `quoted.Expr`. Note that `asExpr` returns a `Expr[Any]`. On the other hand
+`asExprOf[T]` returns a `Expr[T]`, if the type does not conform to it an exception
+will be thrown at runtime.
+
+### Positions
+
+The `Position` in the context provides an `ofMacroExpansion` value. It corresponds
+to the expansion site for macros. The macro authors can obtain various information
+about that expansion site. The example below shows how we can obtain position
+information such as the start line, the end line or even the source code at the
+expansion point.
+
+```scala
+def macroImpl()(quotes: Quotes): Expr[Unit] =
+  import quotes.reflect.*
+  val pos = Position.ofMacroExpansion
+
+  val path = pos.sourceFile.jpath.toString
+  val start = pos.start
+  val end = pos.end
+  val startLine = pos.startLine
+  val endLine = pos.endLine
+  val startColumn = pos.startColumn
+  val endColumn = pos.endColumn
+  val sourceCode = pos.sourceCode
+  ...
+```
+
+### Tree Utilities
+
+`quotes.reflect` contains three facilities for tree traversal and
+transformation.
+
+`TreeAccumulator` ties the knot of a traversal. By calling `foldOver(x, tree)(owner)`
+we can dive into the `tree` node and start accumulating values of type `X` (e.g.,
+of type `List[Symbol]` if we want to collect symbols). The code below, for
+example, collects the `val` definitions in the tree.
+
+```scala
+def collectPatternVariables(tree: Tree)(using ctx: Context): List[Symbol] =
+  val acc = new TreeAccumulator[List[Symbol]]:
+    def foldTree(syms: List[Symbol], tree: Tree)(owner: Symbol): List[Symbol] = tree match
+      case ValDef(_, _, rhs) =>
+        val newSyms = tree.symbol :: syms
+        foldTree(newSyms, body)(tree.symbol)
+      case _ =>
+        foldOverTree(syms, tree)(owner)
+  acc(Nil, tree)
+```
+
+A `TreeTraverser` extends a `TreeAccumulator` and performs the same traversal
+but without returning any value. Finally, a `TreeMap` performs a transformation.
+
+#### ValDef.let
+
+`quotes.reflect.ValDef` also offers a method `let` that allows us to bind the `rhs` (right-hand side) to a `val` and use it in `body`.
+Additionally, `lets` binds the given `terms` to names and allows to use them in the `body`.
+Their type definitions are shown below:
+
+```scala
+def let(rhs: Term)(body: Ident => Term): Term = ...
+
+def lets(terms: List[Term])(body: List[Term] => Term): Term = ...
+```
diff --git a/docs/_spec/TODOreference/metaprogramming/simple-smp.md b/docs/_spec/TODOreference/metaprogramming/simple-smp.md
new file mode 100644
index 000000000000..2ba0155ad329
--- /dev/null
+++ b/docs/_spec/TODOreference/metaprogramming/simple-smp.md
@@ -0,0 +1,232 @@
+---
+layout: doc-page
+title: "The Meta-theory of Symmetric Metaprogramming"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/metaprogramming/simple-smp.html
+---
+
+This note presents a simplified variant of
+[principled metaprogramming](./macros.md)
+and sketches its soundness proof. The variant treats only dialogues
+between two stages. A program can have quotes which can contain
+splices (which can contain quotes, which can contain splices, and so
+on). Or the program could start with a splice with embedded
+quotes. The essential restriction is that (1) a term can contain top-level
+quotes or top-level splices, but not both, and (2) quotes cannot appear
+directly inside quotes and splices cannot appear directly inside
+splices. In other words, the universe is restricted to two phases
+only.
+
+Under this restriction we can simplify the typing rules so that there are
+always exactly two environments instead of having a stack of environments.
+The variant presented here differs from the full calculus also in that we
+replace evaluation contexts with contextual typing rules. While this
+is more verbose, it makes it easier to set up the meta theory.
+
+## Syntax
+```
+Terms         t  ::=  x                 variable
+                      (x: T) => t       lambda
+                      t t               application
+                      ’t                quote
+                      ~t                splice
+
+Simple terms  u  ::=  x  |  (x: T) => u  |  u u
+
+Values        v  ::=  (x: T) => t       lambda
+                      ’u                quoted value
+
+Types         T  ::=  A                 base type
+                      T -> T            function type
+                      ’T                quoted type
+```
+## Operational semantics
+
+### Evaluation
+```
+            ((x: T) => t) v  -->  [x := v]t
+
+                         t1  -->  t2
+                       ---------------
+                       t1 t  -->  t2 t
+
+                         t1  -->  t2
+                       ---------------
+                       v t1  -->  v t2
+
+                         t1  ==>  t2
+                        -------------
+                        ’t1  -->  ’t2
+```
+
+### Splicing
+```
+                        ~’u  ==>  u
+
+                         t1  ==>  t2
+               -------------------------------
+               (x: T) => t1  ==>  (x: T) => t2
+
+                         t1  ==>  t2
+                       ---------------
+                       t1 t  ==>  t2 t
+
+                         t1  ==>  t2
+                       ---------------
+                       u t1  ==>  u t2
+
+                         t1  -->  t2
+                        -------------
+                        ~t1  ==>  ~t2
+
+```
+## Typing Rules
+
+Typing judgments are of the form  `E1 * E2 |- t: T` where `E1, E2` are environments and
+`*` is one of `~` and `’`.
+```
+                          x: T in E2
+                       ---------------
+                       E1 * E2 |- x: T
+
+
+                   E1 * E2, x: T1 |- t: T2
+               --------------------------------
+               E1 * E2 |- (x: T1) => t: T -> T2
+
+
+         E1 * E2 |- t1: T2 -> T    E1 * E2 |- t2: T2
+         -------------------------------------------
+                     E1 * E2 |- t1 t2: T
+
+
+                       E2 ’ E1 |- t: T
+                      -----------------
+                      E1 ~ E2 |- ’t: ’T
+
+
+                       E2 ~ E1 |- t: ’T
+                       ----------------
+                       E1 ’ E2 |- ~t: T
+```
+
+(Curiously, this looks a bit like a Christmas tree).
+
+## Soundness
+
+The meta-theory typically requires mutual inductions over two judgments.
+
+### Progress Theorem
+
+ 1. If `E1 ~  |- t: T` then either `t = v` for some value `v` or `t --> t2` for some term `t2`.
+ 2. If ` ’ E2 |- t: T` then either `t = u` for some simple term `u` or `t ==> t2` for some term `t2`.
+
+Proof by structural induction over terms.
+
+To prove (1):
+
+ - the cases for variables, lambdas and applications are as in [STLC](https://en.wikipedia.org/wiki/Simply_typed_lambda_calculus).
+ - If `t = ’t2`, then by inversion we have ` ’ E1 |- t2: T2` for some type `T2`.
+   By the second [induction hypothesis](https://en.wikipedia.org/wiki/Mathematical_induction) (I.H.), we have one of:
+   - `t2 = u`, hence `’t2` is a value,
+   - `t2 ==> t3`, hence `’t2 --> ’t3`.
+ - The case `t = ~t2` is not typable.
+
+To prove (2):
+
+ - If `t = x` then `t` is a simple term.
+ - If `t = (x: T) => t2`, then either `t2` is a simple term, in which case `t` is as well.
+   Or by the second I.H. `t2 ==> t3`, in which case `t ==> (x: T) => t3`.
+ - If `t = t1 t2` then one of three cases applies:
+
+   - `t1` and `t2` are a simple term, then `t` is as well a simple term.
+   - `t1` is not a simple term. Then by the second I.H., `t1 ==> t12`, hence `t ==> t12 t2`.
+   - `t1` is a simple term but `t2` is not. Then by the second I.H. `t2 ==> t22`, hence `t ==> t1 t22`.
+
+ - The case `t = ’t2` is not typable.
+ - If `t = ~t2` then by inversion we have `E2 ~  |- t2: ’T2`, for some type `T2`.
+   By the first I.H., we have one of
+
+   - `t2 = v`. Since `t2: ’T2`, we must have `v = ’u`, for some simple term `u`, hence `t = ~’u`.
+     By quote-splice reduction, `t ==> u`.
+   - `t2 --> t3`. Then by the context rule for `’t`, `t ==> ’t3`.
+
+
+### Substitution Lemma
+
+ 1. If `E1 ~ E2 |- s: S` and `E1 ~ E2, x: S |- t: T` then `E1 ~ E2 |- [x := s]t: T`.
+ 2. If `E1 ~ E2 |- s: S` and `E2, x: S ’ E1 |- t: T` then `E2 ’ E1 |- [x := s]t: T`.
+
+The proofs are by induction on typing derivations for `t`, analogous
+to the proof for STL (with (2) a bit simpler than (1) since we do not
+need to swap lambda bindings with the bound variable `x`). The
+arguments that link the two hypotheses are as follows.
+
+To prove (1), let `t = ’t1`. Then `T = ’T1` for some type `T1` and the last typing rule is
+```
+                    E2, x: S ’ E1 |- t1: T1
+                   -------------------------
+                   E1 ~ E2, x: S |- ’t1: ’T1
+```
+By the second I.H. `E2 ’ E1 |- [x := s]t1: T1`.  By typing, `E1 ~ E2 |- ’[x := s]t1: ’T1`.
+Since `[x := s]t = [x := s](’t1) = ’[x := s]t1` we get `[x := s]t: ’T1`.
+
+To prove (2), let `t = ~t1`. Then the last typing rule is
+```
+                    E1 ~ E2, x: S |- t1: ’T
+                    -----------------------
+                    E2, x: S ’ E1 |- ~t1: T
+```
+By the first I.H., `E1 ~ E2 |- [x := s]t1: ’T`. By typing, `E2 ’ E1 |- ~[x := s]t1: T`.
+Since `[x := s]t = [x := s](~t1) = ~[x := s]t1` we get `[x := s]t: T`.
+
+
+### Preservation Theorem
+
+ 1. If `E1 ~ E2 |- t1: T` and `t1 --> t2` then `E1 ~ E2 |- t2: T`.
+ 2. If `E1 ’ E2 |- t1: T` and `t1 ==> t2` then `E1 ’ E2 |- t2: T`.
+
+The proof is by structural induction on evaluation derivations. The proof of (1) is analogous
+to the proof for STL, using the substitution lemma for the beta reduction case, with the addition of reduction of quoted terms, which goes as follows:
+
+ - Assume the last rule was
+   ```
+                       t1  ==>  t2
+                      -------------
+                      ’t1  -->  ’t2
+   ```
+   By inversion of typing rules, we must have `T = ’T1` for some type `T1` such that `t1: T1`.
+   By the second I.H., `t2: T1`, hence `’t2: `T1`.
+
+
+To prove (2):
+
+ - Assume the last rule was `~’u ==> u`. The typing proof of `~’u` must have the form
+
+    ```
+                      E1 ’ E2 |- u: T
+                     -----------------
+                     E1 ~ E2 |- ’u: ’T
+                     -----------------
+                     E1 ’ E2 |- ~’u: T
+    ```
+    Hence, `E1 ’ E2 |- u: T`.
+
+ - Assume the last rule was
+   ```
+                         t1  ==>  t2
+               -------------------------------
+               (x: S) => t1  ==>  (x: T) => t2
+   ```
+   By typing inversion, `E1 ' E2, x: S |- t1: T1` for some type `T1` such that `T = S -> T1`.
+   By the I.H, `t2: T1`. By the typing rule for lambdas the result follows.
+
+ - The context rules for applications are equally straightforward.
+
+ - Assume the last rule was
+   ```
+                         t1  ==>  t2
+                        -------------
+                        ~t1  ==>  ~t2
+   ```
+   By inversion of typing rules, we must have `t1: ’T`.
+   By the first I.H., `t2: ’T`, hence `~t2: T`.
diff --git a/docs/_spec/TODOreference/metaprogramming/staging.md b/docs/_spec/TODOreference/metaprogramming/staging.md
new file mode 100644
index 000000000000..e74d491402b5
--- /dev/null
+++ b/docs/_spec/TODOreference/metaprogramming/staging.md
@@ -0,0 +1,121 @@
+---
+layout: doc-page
+title: "Runtime Multi-Stage Programming"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/metaprogramming/staging.html
+---
+
+The framework expresses at the same time compile-time metaprogramming and
+multi-stage programming. We can think of compile-time metaprogramming as a
+two stage compilation process: one that we write the code in top-level splices,
+that will be used for code generation (macros) and one that will perform all
+necessary evaluations at compile-time and an object program that we will run
+as usual. What if we could synthesize code at run-time and offer one extra stage
+to the programmer? Then we can have a value of type `Expr[T]` at run-time that we
+can essentially treat as a typed-syntax tree that we can either _show_ as a
+string (pretty-print) or compile and run. If the number of quotes exceeds the
+number of splices by more than one (effectively handling at run-time values of type
+`Expr[Expr[T]]`, `Expr[Expr[Expr[T]]]`, ...) then we talk about Multi-Stage
+Programming.
+
+The motivation behind this _paradigm_ is to let runtime information affect or
+guide code-generation.
+
+Intuition: The phase in which code is run is determined by the difference
+between the number of splice scopes and quote scopes in which it is embedded.
+
+ - If there are more splices than quotes, the code is run at compile-time i.e.
+   as a macro. In the general case, this means running an interpreter that
+   evaluates the code, which is represented as a typed abstract syntax tree. The
+   interpreter can fall back to reflective calls when evaluating an application
+   of a previously compiled method. If the splice excess is more than one, it
+   would mean that a macro’s implementation code (as opposed to the code it
+   expands to) invokes other macros. If macros are realized by interpretation,
+   this would lead to towers of interpreters, where the first interpreter would
+   itself interpret an interpreter code that possibly interprets another
+   interpreter and so on.
+
+ - If the number of splices equals the number of quotes, the code is compiled
+   and run as usual.
+
+ - If the number of quotes exceeds the number of splices, the code is staged.
+   That is, it produces a typed abstract syntax tree or type structure at
+   run-time. A quote excess of more than one corresponds to multi-staged
+   programming.
+
+Providing an interpreter for the full language is quite difficult, and it is
+even more difficult to make that interpreter run efficiently. So we currently
+impose the following restrictions on the use of splices.
+
+ 1. A top-level splice must appear in an inline method (turning that method
+    into a macro)
+
+ 2. The splice must call a previously compiled
+    method passing quoted arguments, constant arguments or inline arguments.
+
+ 3. Splices inside splices (but no intervening quotes) are not allowed.
+
+
+## API
+
+The framework as discussed so far allows code to be staged, i.e. be prepared
+to be executed at a later stage. To run that code, there is another method
+in class `Expr` called `run`. Note that `$` and `run` both map from `Expr[T]`
+to `T` but only `$` is subject to the [PCP](./macros.md#the-phase-consistency-principle), whereas `run` is just a normal method.
+`scala.quoted.staging.run` provides a `Quotes` that can be used to show the expression in its scope.
+On the other hand `scala.quoted.staging.withQuotes` provides a `Quotes` without evaluating the expression.
+
+```scala
+package scala.quoted.staging
+
+def run[T](expr: Quotes ?=> Expr[T])(using Compiler): T = ...
+
+def withQuotes[T](thunk: Quotes ?=> T)(using Compiler): T = ...
+```
+
+## Create a new Scala 3 project with staging enabled
+
+```shell
+sbt new scala/scala3-staging.g8
+```
+
+From [`scala/scala3-staging.g8`](https://github.com/scala/scala3-staging.g8).
+
+It will create a project with the necessary dependencies and some examples.
+
+In case you prefer to create the project on your own, make sure to define the following dependency in your [`build.sbt` build definition](https://www.scala-sbt.org/1.x/docs/Basic-Def.html)
+
+```scala
+libraryDependencies += "org.scala-lang" %% "scala3-staging" % scalaVersion.value
+```
+
+and in case you use `scalac`/`scala` directly, then use the `-with-compiler` flag for both:
+
+```shell
+scalac -with-compiler -d out Test.scala
+scala -with-compiler -classpath out Test
+```
+
+## Example
+
+Now take exactly the same example as in [Macros](./macros.md). Assume that we
+do not want to pass an array statically but generate code at run-time and pass
+the value, also at run-time. Note, how we make a future-stage function of type
+`Expr[Array[Int] => Int]` in line 6 below. Using `staging.run { ... }` we can evaluate an
+expression at runtime. Within the scope of `staging.run` we can also invoke `show` on an expression
+to get a source-like representation of the expression.
+
+```scala
+import scala.quoted.*
+
+// make available the necessary compiler for runtime code generation
+given staging.Compiler = staging.Compiler.make(getClass.getClassLoader)
+
+val f: Array[Int] => Int = staging.run {
+  val stagedSum: Expr[Array[Int] => Int] =
+    '{ (arr: Array[Int]) => ${sum('arr)}}
+  println(stagedSum.show) // Prints "(arr: Array[Int]) => { var sum = 0; ... }"
+  stagedSum
+}
+
+f.apply(Array(1, 2, 3)) // Returns 6
+```
diff --git a/docs/_spec/TODOreference/metaprogramming/tasty-inspect.md b/docs/_spec/TODOreference/metaprogramming/tasty-inspect.md
new file mode 100644
index 000000000000..e643775243e0
--- /dev/null
+++ b/docs/_spec/TODOreference/metaprogramming/tasty-inspect.md
@@ -0,0 +1,57 @@
+---
+layout: doc-page
+title: "TASTy Inspection"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/metaprogramming/tasty-inspect.html
+---
+
+```scala
+libraryDependencies += "org.scala-lang" %% "scala3-tasty-inspector" % scalaVersion.value
+```
+
+TASTy files contain the full typed tree of a class including source positions
+and documentation. This is ideal for tools that analyze or extract semantic
+information from the code. To avoid the hassle of working directly with the TASTy
+file we provide the `Inspector` which loads the contents and exposes it
+through the TASTy reflect API.
+
+## Inspecting TASTy files
+
+To inspect the trees of a TASTy file a consumer can be defined in the following way.
+
+```scala
+import scala.quoted.*
+import scala.tasty.inspector.*
+
+class MyInspector extends Inspector:
+   def inspect(using Quotes)(tastys: List[Tasty[quotes.type]]): Unit =
+      import quotes.reflect.*
+      for tasty <- tastys do
+         val tree = tasty.ast
+         // Do something with the tree
+```
+
+Then the consumer can be instantiated with the following code to get the tree of the `foo/Bar.tasty` file.
+
+```scala
+object Test:
+   def main(args: Array[String]): Unit =
+      val tastyFiles = List("foo/Bar.tasty")
+      TastyInspector.inspectTastyFiles(tastyFiles)(new MyInspector)
+```
+
+Note that if we need to run the main (in the example below defined in an object called `Test`) after compilation we need to make the compiler available to the runtime:
+
+```shell
+scalac -d out Test.scala
+scala -with-compiler -classpath out Test
+```
+
+## Template project
+
+Using sbt version `1.1.5+`, do:
+
+```shell
+sbt new scala/scala3-tasty-inspector.g8
+```
+
+in the folder where you want to clone the template.
diff --git a/docs/_spec/TODOreference/new-types/dependent-function-types-spec.md b/docs/_spec/TODOreference/new-types/dependent-function-types-spec.md
new file mode 100644
index 000000000000..f3237ddf7b9a
--- /dev/null
+++ b/docs/_spec/TODOreference/new-types/dependent-function-types-spec.md
@@ -0,0 +1,125 @@
+---
+layout: doc-page
+title: "Dependent Function Types - More Details"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/new-types/dependent-function-types-spec.html
+---
+
+Initial implementation in [PR #3464](https://github.com/lampepfl/dotty/pull/3464).
+
+## Syntax
+
+```
+FunArgTypes       ::=  InfixType
+                    |  ‘(’ [ FunArgType {',' FunArgType } ] ‘)’
+                    |  ‘(’ TypedFunParam {',' TypedFunParam } ‘)’
+TypedFunParam     ::=  id ‘:’ Type
+```
+
+Dependent function types associate to the right, e.g.
+`(s: S) => (t: T) => U` is the same as `(s: S) => ((t: T) => U)`.
+
+## Implementation
+
+Dependent function types are shorthands for class types that define `apply`
+methods with a dependent result type. Dependent function types desugar to
+refinement types of `scala.FunctionN`. A dependent function type
+`(x1: K1, ..., xN: KN) => R` of arity `N` translates to:
+
+```scala
+FunctionN[K1, ..., Kn, R']:
+  def apply(x1: K1, ..., xN: KN): R
+```
+
+where the result type parameter `R'` is the least upper approximation of the
+precise result type `R` without any reference to value parameters `x1, ..., xN`.
+
+The syntax and semantics of anonymous dependent functions is identical to the
+one of regular functions. Eta expansion is naturally generalized to produce
+dependent function types for methods with dependent result types.
+
+Dependent functions can be implicit, and generalize to arity `N > 22` in the
+same way that other functions do, see
+[the corresponding documentation](../dropped-features/limit22.md).
+
+## Examples
+
+The example below defines a trait `C` and the two dependent function types
+`DF` and `IDF` and prints the results of the respective function applications:
+
+[depfuntype.scala]: https://github.com/lampepfl/dotty/blob/main/tests/pos/depfuntype.scala
+
+```scala
+trait C { type M; val m: M }
+
+type DF = (x: C) => x.M
+
+type IDF = (x: C) ?=> x.M
+
+@main def test =
+  val c = new C { type M = Int; val m = 3 }
+
+  val depfun: DF = (x: C) => x.m
+  val t = depfun(c)
+  println(s"t=$t")   // prints "t=3"
+
+  val idepfun: IDF = summon[C].m
+  val u = idepfun(using c)
+  println(s"u=$u")   // prints "u=3"
+
+```
+
+In the following example the depend type `f.Eff` refers to the effect type `CanThrow`:
+
+[eff-dependent.scala]: https://github.com/lampepfl/dotty/blob/main/tests/run/eff-dependent.scala
+
+```scala
+trait Effect
+
+// Type X => Y
+abstract class Fun[-X, +Y]:
+  type Eff <: Effect
+  def apply(x: X): Eff ?=> Y
+
+class CanThrow extends Effect
+class CanIO extends Effect
+
+given ct: CanThrow = new CanThrow
+given ci: CanIO = new CanIO
+
+class I2S extends Fun[Int, String]:
+  type Eff = CanThrow
+  def apply(x: Int) = x.toString
+
+class S2I extends Fun[String, Int]:
+  type Eff = CanIO
+  def apply(x: String) = x.length
+
+// def map(f: A => B)(xs: List[A]): List[B]
+def map[A, B](f: Fun[A, B])(xs: List[A]): f.Eff ?=> List[B] =
+  xs.map(f.apply)
+
+// def mapFn[A, B]: (A => B) -> List[A] -> List[B]
+def mapFn[A, B]: (f: Fun[A, B]) => List[A] => f.Eff ?=> List[B] =
+  f => xs => map(f)(xs)
+
+// def compose(f: A => B)(g: B => C)(x: A): C
+def compose[A, B, C](f: Fun[A, B])(g: Fun[B, C])(x: A):
+  f.Eff ?=> g.Eff ?=> C =
+  g(f(x))
+
+// def composeFn: (A => B) -> (B => C) -> A -> C
+def composeFn[A, B, C]:
+  (f: Fun[A, B]) => (g: Fun[B, C]) => A => f.Eff ?=> g.Eff ?=> C =
+  f => g => x => compose(f)(g)(x)
+
+@main def test =
+  val i2s = new I2S
+  val s2i = new S2I
+
+  assert(mapFn(i2s)(List(1, 2, 3)).mkString == "123")
+  assert(composeFn(i2s)(s2i)(22) == 2)
+```
+
+## Type Checking
+
+After desugaring no additional typing rules are required for dependent function types.
diff --git a/docs/_spec/TODOreference/new-types/dependent-function-types.md b/docs/_spec/TODOreference/new-types/dependent-function-types.md
new file mode 100644
index 000000000000..adbee1d8b3c8
--- /dev/null
+++ b/docs/_spec/TODOreference/new-types/dependent-function-types.md
@@ -0,0 +1,49 @@
+---
+layout: doc-page
+title: "Dependent Function Types"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/new-types/dependent-function-types.html
+---
+
+A dependent function type is a function type whose result depends
+on the function's parameters. For example:
+
+```scala
+trait Entry { type Key; val key: Key }
+
+def extractKey(e: Entry): e.Key = e.key          // a dependent method
+
+val extractor: (e: Entry) => e.Key = extractKey  // a dependent function value
+//             ^^^^^^^^^^^^^^^^^^^
+//             a dependent function type
+```
+
+Scala already has _dependent methods_, i.e. methods where the result
+type refers to some of the parameters of the method. Method
+`extractKey` is an example. Its result type, `e.Key` refers to its
+parameter `e` (we also say, `e.Key` _depends_ on `e`). But so far it
+was not possible to turn such methods into function values, so that
+they can be passed as parameters to other functions, or returned as
+results. Dependent methods could not be turned into functions simply
+because there was no type that could describe them.
+
+In Scala 3 this is now possible. The type of the `extractor` value above is
+
+```scala
+(e: Entry) => e.Key
+```
+
+This type describes function values that take any argument `e` of type
+`Entry` and return a result of type `e.Key`.
+
+Recall that a normal function type `A => B` is represented as an
+instance of the [`Function1` trait](https://scala-lang.org/api/3.x/scala/Function1.html)
+(i.e. `Function1[A, B]`) and analogously for functions with more parameters. Dependent functions
+are also represented as instances of these traits, but they get an additional
+refinement. In fact, the dependent function type above is just syntactic sugar for
+
+```scala
+Function1[Entry, Entry#Key]:
+  def apply(e: Entry): e.Key
+```
+
+[More details](./dependent-function-types-spec.md)
diff --git a/docs/_spec/TODOreference/new-types/intersection-types-spec.md b/docs/_spec/TODOreference/new-types/intersection-types-spec.md
new file mode 100644
index 000000000000..346c57c004f0
--- /dev/null
+++ b/docs/_spec/TODOreference/new-types/intersection-types-spec.md
@@ -0,0 +1,108 @@
+---
+layout: doc-page
+title: "Intersection Types - More Details"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/new-types/intersection-types-spec.html
+---
+
+## Syntax
+
+Syntactically, the type `S & T` is an infix type, where the infix operator is `&`.
+The operator `&` is a normal identifier
+with the usual precedence and subject to usual resolving rules.
+Unless shadowed by another definition, it resolves to the type `scala.&`,
+which acts as a type alias to an internal representation of intersection types.
+
+```
+Type              ::=  ...| InfixType
+InfixType         ::=  RefinedType {id [nl] RefinedType}
+```
+
+## Subtyping Rules
+
+```
+T <: A    T <: B
+----------------
+  T <: A & B
+
+    A <: T
+----------------
+    A & B <: T
+
+    B <: T
+----------------
+    A & B <: T
+```
+
+From the rules above, we can show that `&` is _commutative_: `A & B <: B & A` for any type `A` and `B`.
+
+```
+   B <: B           A <: A
+----------       -----------
+A & B <: B       A & B <: A
+---------------------------
+       A & B  <:  B & A
+```
+
+In another word, `A & B` is the same type as `B & A`, in the sense that the two types
+have the same values and are subtypes of each other.
+
+If `C` is a type constructor, then `C[A] & C[B]` can be simplified using the following three rules:
+
+- If `C` is covariant, `C[A] & C[B] ~> C[A & B]`
+- If `C` is contravariant, `C[A] & C[B] ~> C[A | B]`
+- If `C` is non-variant, emit a compile error
+
+When `C` is covariant, `C[A & B] <: C[A] & C[B]` can be derived:
+
+```
+    A <: A                  B <: B
+  ----------               ---------
+  A & B <: A               A & B <: B
+---------------         -----------------
+C[A & B] <: C[A]          C[A & B] <: C[B]
+------------------------------------------
+      C[A & B] <: C[A] & C[B]
+```
+
+When `C` is contravariant, `C[A | B] <: C[A] & C[B]` can be derived:
+
+```
+    A <: A                        B <: B
+  ----------                     ---------
+  A <: A | B                     B <: A | B
+-------------------           ----------------
+C[A | B] <: C[A]              C[A | B] <: C[B]
+--------------------------------------------------
+            C[A | B] <: C[A] & C[B]
+```
+
+## Erasure
+
+The erased type for `S & T` is the erased _glb_ (greatest lower bound) of the
+erased type of `S` and `T`. The rules for erasure of intersection types are given
+below in pseudocode:
+
+```
+|S & T| = glb(|S|, |T|)
+
+glb(JArray(A), JArray(B)) = JArray(glb(A, B))
+glb(JArray(T), _)         = JArray(T)
+glb(_, JArray(T))         = JArray(T)
+glb(A, B)                 = A                     if A extends B
+glb(A, B)                 = B                     if B extends A
+glb(A, _)                 = A                     if A is not a trait
+glb(_, B)                 = B                     if B is not a trait
+glb(A, _)                 = A                     // use first
+```
+
+In the above, `|T|` means the erased type of `T`, `JArray` refers to
+the type of Java Array.
+
+See also: [`TypeErasure#erasedGlb`](https://github.com/lampepfl/dotty/blob/main/compiler/src/dotty/tools/dotc/core/TypeErasure.scala#L289).
+
+## Relationship with Compound Type (`with`)
+
+Intersection types `A & B` replace compound types `A with B` in Scala 2. For the
+moment, the syntax `A with B` is still allowed and interpreted as `A & B`, but
+its usage as a type (as opposed to in a `new` or `extends` clause) will be
+deprecated and removed in the future.
diff --git a/docs/_spec/TODOreference/new-types/intersection-types.md b/docs/_spec/TODOreference/new-types/intersection-types.md
new file mode 100644
index 000000000000..a4eedeb000f6
--- /dev/null
+++ b/docs/_spec/TODOreference/new-types/intersection-types.md
@@ -0,0 +1,68 @@
+---
+layout: doc-page
+title: "Intersection Types"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/new-types/intersection-types.html
+---
+
+Used on types, the `&` operator creates an intersection type.
+
+## Type Checking
+
+The type `S & T` represents values that are of the type `S` and `T` at the same time.
+
+```scala
+trait Resettable:
+  def reset(): Unit
+
+trait Growable[T]:
+  def add(t: T): Unit
+
+def f(x: Resettable & Growable[String]) =
+  x.reset()
+  x.add("first")
+```
+
+The parameter `x` is required to be _both_ a `Resettable` and a
+`Growable[String]`.
+
+The members of an intersection type `A & B` are all the members of `A` and all
+the members of `B`.  For instance `Resettable & Growable[String]`
+has member methods `reset` and `add`.
+
+`&` is _commutative_: `A & B` is the same type as `B & A`.
+
+If a member appears in both `A` and `B`, its type in `A & B` is the intersection
+of its type in `A` and its type in `B`. For instance, assume the definitions:
+
+```scala
+trait A:
+  def children: List[A]
+
+trait B:
+  def children: List[B]
+
+val x: A & B = new C
+val ys: List[A & B] = x.children
+```
+
+The type of `children` in `A & B` is the intersection of `children`'s
+type in `A` and its type in `B`, which is `List[A] & List[B]`. This
+can be further simplified to `List[A & B]` because `List` is
+covariant.
+
+One might wonder how the compiler could come up with a definition for
+`children` of type `List[A & B]` since what is given are `children`
+definitions of type `List[A]` and `List[B]`. The answer is the compiler does not
+need to. `A & B` is just a type that represents a set of requirements for
+values of the type. At the point where a value is _constructed_, one
+must make sure that all inherited members are correctly defined.
+So if one defines a class `C` that inherits `A` and `B`, one needs
+to give at that point a definition of a `children` method with the required type.
+
+```scala
+class C extends A, B:
+  def children: List[A & B] = ???
+```
+
+
+[More details](./intersection-types-spec.md)
diff --git a/docs/_spec/TODOreference/new-types/match-types.md b/docs/_spec/TODOreference/new-types/match-types.md
new file mode 100644
index 000000000000..d646dd11880b
--- /dev/null
+++ b/docs/_spec/TODOreference/new-types/match-types.md
@@ -0,0 +1,247 @@
+---
+layout: doc-page
+title: "Match Types"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/new-types/match-types.html
+---
+
+A match type reduces to one of its right-hand sides, depending on the type of
+its scrutinee. For example:
+
+```scala
+type Elem[X] = X match
+  case String => Char
+  case Array[t] => t
+  case Iterable[t] => t
+```
+
+This defines a type that reduces as follows:
+
+```scala
+Elem[String]       =:=  Char
+Elem[Array[Int]]   =:=  Int
+Elem[List[Float]]  =:=  Float
+Elem[Nil.type]     =:=  Nothing
+```
+
+Here `=:=` is understood to mean that left and right-hand sides are mutually
+subtypes of each other.
+
+In general, a match type is of the form
+
+```scala
+S match { P1 => T1 ... Pn => Tn }
+```
+
+where `S`, `T1`, ..., `Tn` are types and `P1`, ..., `Pn` are type patterns. Type
+variables in patterns start with a lower case letter, as usual.
+
+Match types can form part of recursive type definitions. Example:
+
+```scala
+type LeafElem[X] = X match
+  case String => Char
+  case Array[t] => LeafElem[t]
+  case Iterable[t] => LeafElem[t]
+  case AnyVal => X
+```
+
+Recursive match type definitions can also be given an upper bound, like this:
+
+```scala
+type Concat[Xs <: Tuple, +Ys <: Tuple] <: Tuple = Xs match
+  case EmptyTuple => Ys
+  case x *: xs => x *: Concat[xs, Ys]
+```
+
+In this definition, every instance of `Concat[A, B]`, whether reducible or not,
+is known to be a subtype of `Tuple`. This is necessary to make the recursive
+invocation `x *: Concat[xs, Ys]` type check, since `*:` demands a `Tuple` as its
+right operand.
+
+## Dependent Typing
+
+Match types can be used to define dependently typed methods. For instance, here
+is the value level counterpart to the `LeafElem` type defined above (note the
+use of the match type as the return type):
+
+```scala
+def leafElem[X](x: X): LeafElem[X] = x match
+  case x: String      => x.charAt(0)
+  case x: Array[t]    => leafElem(x(0))
+  case x: Iterable[t] => leafElem(x.head)
+  case x: AnyVal      => x
+```
+
+This special mode of typing for match expressions is only used when the
+following conditions are met:
+
+1. The match expression patterns do not have guards
+2. The match expression scrutinee's type is a subtype of the match type
+   scrutinee's type
+3. The match expression and the match type have the same number of cases
+4. The match expression patterns are all [Typed Patterns](https://scala-lang.org/files/archive/spec/2.13/08-pattern-matching.html#typed-patterns),
+   and these types are `=:=` to their corresponding type patterns in the match
+   type
+
+So you know, while the case body will be expected to have the type on the right-hand
+side of the corresponding match type case, that doesn't imply the match type argument
+is constrained.  Using the example, the last case body must conform to X, but that
+doesn't constrain X to be AnyVal, and therefore a LeafElem[X] inside the body wouldn't
+reduce; it would remain stuck, and as such just an abstract type. 
+
+## Representation of Match Types
+
+The internal representation of a match type
+```
+S match { P1 => T1 ... Pn => Tn }
+```
+is `Match(S, C1, ..., Cn) <: B` where each case `Ci` is of the form
+```
+[Xs] =>> P => T
+```
+
+Here, `[Xs]` is a type parameter clause of the variables bound in pattern `Pi`.
+If there are no bound type variables in a case, the type parameter clause is
+omitted and only the function type `P => T` is kept. So each case is either a
+unary function type or a type lambda over a unary function type.
+
+`B` is the declared upper bound of the match type, or `Any` if no such bound is
+given.  We will leave it out in places where it does not matter for the
+discussion. The scrutinee, bound, and pattern types must all be first-order
+types.
+
+## Match Type Reduction
+
+Match type reduction follows the semantics of match expressions, that is, a
+match type of the form `S match { P1 => T1 ... Pn => Tn }` reduces to `Ti` if
+and only if `s: S match { _: P1 => T1 ... _: Pn => Tn }` evaluates to a value of
+type `Ti` for all `s: S`.
+
+The compiler implements the following reduction algorithm:
+
+- If the scrutinee type `S` is an empty set of values (such as `Nothing` or
+  `String & Int`), do not reduce.
+- Sequentially consider each pattern `Pi`
+    - If `S <: Pi` reduce to `Ti`.
+    - Otherwise, try constructing a proof that `S` and `Pi` are disjoint, or, in
+      other words, that no value `s` of type `S` is also of type `Pi`.
+    - If such proof is found, proceed to the next case (`Pi+1`), otherwise, do
+      not reduce.
+
+Disjointness proofs rely on the following properties of Scala types:
+
+1. Single inheritance of classes
+2. Final classes cannot be extended
+3. Constant types with distinct values are nonintersecting
+4. Singleton paths to distinct values are nonintersecting, such as `object` definitions or singleton enum cases.
+
+Type parameters in patterns are minimally instantiated when computing `S <: Pi`.
+An instantiation `Is` is _minimal_ for `Xs` if all type variables in `Xs` that
+appear covariantly and nonvariantly in `Is` are as small as possible and all
+type variables in `Xs` that appear contravariantly in `Is` are as large as
+possible.  Here, "small" and "large" are understood with respect to  `<:`.
+
+For simplicity, we have omitted constraint handling so far. The full formulation
+of subtyping tests describes them as a function from a constraint and a pair of
+types to either _success_ and a new constraint or _failure_. In the context of
+reduction, the subtyping test `S <: [Xs := Is] P` is understood to leave the
+bounds of all variables in the input constraint unchanged, i.e. existing
+variables in the constraint cannot be instantiated by matching the scrutinee
+against the patterns.
+
+## Subtyping Rules for Match Types
+
+The following rules apply to match types. For simplicity, we omit environments
+and constraints.
+
+1. The first rule is a structural comparison between two match types:
+
+   ```
+   S match { P1 => T1 ... Pm => Tm }  <:  T match { Q1 => U1 ... Qn => Un }
+   ```
+
+   if
+
+   ```
+   S =:= T,  m >= n,  Pi =:= Qi and Ti <: Ui for i in 1..n
+   ```
+
+   I.e. scrutinees and patterns must be equal and the corresponding bodies must
+   be subtypes. No case re-ordering is allowed, but the subtype can have more
+   cases than the supertype.
+
+2. The second rule states that a match type and its redux are mutual subtypes.
+
+   ```
+   S match { P1 => T1 ... Pn => Tn }  <:  U
+   U  <:  S match { P1 => T1 ... Pn => Tn }
+   ```
+
+   if
+
+   `S match { P1 => T1 ... Pn => Tn }` reduces to `U`
+
+3. The third rule states that a match type conforms to its upper bound:
+
+   ```
+   (S match { P1 => T1 ... Pn => Tn } <: B)  <:  B
+   ```
+
+## Termination
+
+Match type definitions can be recursive, which means that it's possible to run
+into an infinite loop while reducing match types.
+
+Since reduction is linked to subtyping, we already have a cycle detection
+mechanism in place. As a result, the following will already give a reasonable
+error message:
+
+```scala
+type L[X] = X match
+  case Int => L[X]
+
+def g[X]: L[X] = ???
+```
+
+```scala
+   |  val x: Int = g[Int]
+   |                ^
+   |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.
+   |A recurring operation is (inner to outer):
+   |
+   |  subtype LazyRef(Test.L[Int]) <:< Int
+```
+
+Internally, the Scala compiler detects these cycles by turning selected stack overflows into
+type errors. If there is a stack overflow during subtyping, the exception will
+be caught and turned into a compile-time error that indicates a trace of the
+subtype tests that caused the overflow without showing a full stack trace.
+
+
+## Match Types Variance
+
+All type positions in a match type (scrutinee, patterns, bodies) are considered invariant.
+
+## Related Work
+
+Match types have similarities with
+[closed type families](https://wiki.haskell.org/GHC/Type_families) in Haskell.
+Some differences are:
+
+- Subtyping instead of type equalities.
+- Match type reduction does not tighten the underlying constraint, whereas type
+  family reduction does unify. This difference in approach mirrors the
+  difference between local type inference in Scala and global type inference in
+  Haskell.
+
+Match types are also similar to Typescript's
+[conditional types](https://github.com/Microsoft/TypeScript/pull/21316). The
+main differences here are:
+
+ - Conditional types only reduce if both the scrutinee and pattern are ground,
+   whereas match types also work for type parameters and abstract types.
+ - Match types support direct recursion.
+ - Conditional types distribute through union types.
diff --git a/docs/_spec/TODOreference/new-types/new-types.md b/docs/_spec/TODOreference/new-types/new-types.md
new file mode 100644
index 000000000000..84c157495d6f
--- /dev/null
+++ b/docs/_spec/TODOreference/new-types/new-types.md
@@ -0,0 +1,7 @@
+---
+layout: index
+title: "New Types"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/new-types/index.html
+---
+
+This chapter documents the new types introduced in Scala 3.
diff --git a/docs/_spec/TODOreference/new-types/polymorphic-function-types.md b/docs/_spec/TODOreference/new-types/polymorphic-function-types.md
new file mode 100644
index 000000000000..1754bf844831
--- /dev/null
+++ b/docs/_spec/TODOreference/new-types/polymorphic-function-types.md
@@ -0,0 +1,94 @@
+---
+layout: doc-page
+title: "Polymorphic Function Types"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/new-types/polymorphic-function-types.html
+---
+
+A polymorphic function type is a function type which accepts type parameters.
+For example:
+
+```scala
+// A polymorphic method:
+def foo[A](xs: List[A]): List[A] = xs.reverse
+
+// A polymorphic function value:
+val bar: [A] => List[A] => List[A]
+//       ^^^^^^^^^^^^^^^^^^^^^^^^^
+//       a polymorphic function type
+       = [A] => (xs: List[A]) => foo[A](xs)
+```
+
+Scala already has _polymorphic methods_, i.e. methods which accepts type parameters.
+Method `foo` above is an example, accepting a type parameter `A`.
+So far, it
+was not possible to turn such methods into polymorphic function values like `bar` above,
+which can be passed as parameters to other functions, or returned as results.
+
+In Scala 3 this is now possible. The type of the `bar` value above is
+
+```scala
+[A] => List[A] => List[A]
+```
+
+This type describes function values which take a type `A` as a parameter,
+then take a list of type `List[A]`, and return a list of the same type `List[A]`.
+
+[More details](https://github.com/lampepfl/dotty/pull/4672)
+
+
+## Example Usage
+
+Polymorphic function type are particularly useful
+when callers of a method are required to provide a
+function which has to be polymorphic,
+meaning that it should accept arbitrary types as part of its inputs.
+
+For instance, consider the situation where we have
+a data type to represent the expressions of a simple language
+(consisting only of variables and function applications)
+in a strongly-typed way:
+
+```scala
+enum Expr[A]:
+  case Var(name: String)
+  case Apply[A, B](fun: Expr[B => A], arg: Expr[B]) extends Expr[A]
+```
+
+We would like to provide a way for users to map a function
+over all immediate subexpressions of a given `Expr`.
+This requires the given function to be polymorphic,
+since each subexpression may have a different type.
+Here is how to implement this using polymorphic function types:
+
+```scala
+def mapSubexpressions[A](e: Expr[A])(f: [B] => Expr[B] => Expr[B]): Expr[A] =
+  e match
+    case Apply(fun, arg) => Apply(f(fun), f(arg))
+    case Var(n) => Var(n)
+```
+
+And here is how to use this function to _wrap_ each subexpression
+in a given expression with a call to some `wrap` function,
+defined as a variable:
+
+```scala
+val e0 = Apply(Var("f"), Var("a"))
+val e1 = mapSubexpressions(e0)(
+  [B] => (se: Expr[B]) => Apply(Var[B => B]("wrap"), se))
+println(e1) // Apply(Apply(Var(wrap),Var(f)),Apply(Var(wrap),Var(a)))
+```
+
+## Relationship With Type Lambdas
+
+Polymorphic function types are not to be confused with
+[_type lambdas_](type-lambdas.md).
+While the former describes the _type_ of a polymorphic _value_,
+the latter is an actual function value _at the type level_.
+
+A good way of understanding the difference is to notice that
+**_type lambdas are applied in types,
+whereas polymorphic functions are applied in terms_**:
+One would call the function `bar` above
+by passing it a type argument `bar[Int]` _within a method body_.
+On the other hand, given a type lambda such as `type F = [A] =>> List[A]`,
+one would call `F` _within a type expression_, as in `type Bar = F[Int]`.
diff --git a/docs/_spec/TODOreference/new-types/type-lambdas-spec.md b/docs/_spec/TODOreference/new-types/type-lambdas-spec.md
new file mode 100644
index 000000000000..52f88dab4217
--- /dev/null
+++ b/docs/_spec/TODOreference/new-types/type-lambdas-spec.md
@@ -0,0 +1,116 @@
+---
+layout: doc-page
+title: "Type Lambdas - More Details"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/new-types/type-lambdas-spec.html
+---
+
+## Syntax
+
+```
+Type            ::=  ... |  TypeParamClause ‘=>>’ Type
+TypeParamClause ::=  ‘[’ TypeParam {‘,’ TypeParam} ‘]’
+TypeParam       ::=  {Annotation} (id [HkTypeParamClause] | ‘_’) TypeBounds
+TypeBounds      ::=  [‘>:’ Type] [‘<:’ Type]
+```
+
+## Type Checking
+
+A type lambda such as `[X] =>> F[X]` defines a function from types to types. The parameter(s) may carry bounds.
+If a parameter is bounded, as in `[X >: L <: U] =>> F[X]` it is checked that arguments to the parameters conform to the bounds `L` and `U`.
+Only the upper bound `U` can be F-bounded, i.e. `X` can appear in it.
+
+## Subtyping Rules
+
+Assume two type lambdas
+```scala
+type TL1  =  [X >: L1 <: U1] =>> R1
+type TL2  =  [X >: L2 <: U2] =>> R2
+```
+Then `TL1 <: TL2`, if
+
+ - the type interval `L2..U2` is contained in the type interval `L1..U1` (i.e.
+`L1 <: L2` and `U2 <: U1`),
+ - `R1 <: R2`
+
+Here we have relied on [alpha renaming](https://en.wikipedia.org/wiki/Lambda_calculus#%CE%B1-conversion) to match the two bound types `X`.
+
+A partially applied type constructor such as `List` is assumed to be equivalent to
+its eta expansion. I.e, `List = [X] =>> List[X]`. This allows type constructors to be compared with type lambdas.
+
+## Relationship with Parameterized Type Definitions
+
+A parameterized type definition
+```scala
+type T[X] = R
+```
+is regarded as a shorthand for an unparameterized definition with a type lambda as right-hand side:
+```scala
+type T = [X] =>> R
+```
+If the type definition carries `+` or `-` variance annotations,
+it is checked that the variance annotations are satisfied by the type lambda.
+For instance,
+```scala
+type F2[A, +B] = A => B
+```
+expands to
+```scala
+type F2 = [A, B] =>> A => B
+```
+and at the same time it is checked that the parameter `B` appears covariantly in `A => B`.
+
+A parameterized abstract type
+```scala
+type T[X] >: L <: U
+```
+is regarded as shorthand for an unparameterized abstract type with type lambdas as bounds.
+```scala
+type T >: ([X] =>> L) <: ([X] =>> U)
+```
+However, if `L` is `Nothing` it is not parameterized, since `Nothing` is treated as a bottom type for all kinds. For instance,
+```scala
+type T[X] <: X => X
+```
+is expanded to
+```scala
+type T >: Nothing <: ([X] =>> X => X)
+```
+instead of
+```scala
+type T >: ([X] =>> Nothing) <: ([X] =>> X => X)
+```
+
+The same expansions apply to type parameters. For instance,
+```scala
+[F[X] <: Coll[X]]
+```
+is treated as a shorthand for
+```scala
+[F >: Nothing <: [X] =>> Coll[X]]
+```
+Abstract types and opaque type aliases remember the variances they were created with. So the type
+```scala
+type F2[-A, +B]
+```
+is known to be contravariant in `A` and covariant in `B` and can be instantiated only
+with types that satisfy these constraints. Likewise
+```scala
+opaque type O[X] = List[X]
+```
+`O` is known to be invariant (and not covariant, as its right-hand side would suggest). On the other hand, a transparent alias
+```scala
+type O2[X] = List[X]
+```
+would be treated as covariant, `X` is used covariantly on its right-hand side.
+
+**Note**: The decision to treat `Nothing` as universal bottom type is provisional, and might be changed after further discussion.
+
+**Note**: Scala 2 and 3 differ in that Scala 2 also treats `Any` as universal top-type. This is not done in Scala 3. See also the discussion on [kind polymorphism](../other-new-features/kind-polymorphism.md)
+
+## Curried Type Parameters
+
+The body of a type lambda can again be a type lambda. Example:
+```scala
+type TL = [X] =>> [Y] =>> (X, Y)
+```
+Currently, no special provision is made to infer type arguments to such curried type lambdas. This is left for future work.
diff --git a/docs/_spec/TODOreference/new-types/type-lambdas.md b/docs/_spec/TODOreference/new-types/type-lambdas.md
new file mode 100644
index 000000000000..ba88e28f5d56
--- /dev/null
+++ b/docs/_spec/TODOreference/new-types/type-lambdas.md
@@ -0,0 +1,17 @@
+---
+layout: doc-page
+title: "Type Lambdas"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/new-types/type-lambdas.html
+---
+
+A _type lambda_ lets one express a higher-kinded type directly, without
+a type definition.
+
+```scala
+[X, Y] =>> Map[Y, X]
+```
+
+For instance, the type above defines a binary type constructor, which maps arguments `X` and `Y` to `Map[Y, X]`.
+Type parameters of type lambdas can have bounds, but they cannot carry `+` or `-` variance annotations.
+
+[More details](./type-lambdas-spec.md)
diff --git a/docs/_spec/TODOreference/new-types/union-types-spec.md b/docs/_spec/TODOreference/new-types/union-types-spec.md
new file mode 100644
index 000000000000..d250d3f11713
--- /dev/null
+++ b/docs/_spec/TODOreference/new-types/union-types-spec.md
@@ -0,0 +1,172 @@
+---
+layout: doc-page
+title: "Union Types - More Details"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/new-types/union-types-spec.html
+---
+
+## Syntax
+
+Syntactically, unions follow the same rules as intersections, but have a lower precedence, see
+[Intersection Types - More Details](./intersection-types-spec.md).
+
+### Interaction with pattern matching syntax
+`|` is also used in pattern matching to separate pattern alternatives and has
+lower precedence than `:` as used in typed patterns, this means that:
+
+```scala
+case _: A | B => ...
+```
+
+is still equivalent to:
+
+```scala
+case (_: A) | B => ...
+```
+
+and not to:
+
+```scala
+case _: (A | B) => ...
+```
+
+## Subtyping Rules
+
+- `A` is always a subtype of `A | B` for all `A`, `B`.
+- If `A <: C` and `B <: C` then `A | B <: C`
+- Like `&`, `|` is commutative and associative:
+
+  ```scala
+  A | B =:= B | A
+  A | (B | C) =:= (A | B) | C
+  ```
+
+- `&` is distributive over `|`:
+
+  ```scala
+  A & (B | C) =:= A & B | A & C
+  ```
+
+From these rules it follows that the _least upper bound_ (LUB) of a set of types
+is the union of these types. This replaces the
+[definition of least upper bound in the Scala 2 specification](https://www.scala-lang.org/files/archive/spec/2.13/03-types.html#least-upper-bounds-and-greatest-lower-bounds).
+
+## Motivation
+
+The primary reason for introducing union types in Scala is that they allow us to
+guarantee that for every set of types, we can always form a finite LUB. This is
+both useful in practice (infinite LUBs in Scala 2 were approximated in an ad-hoc
+way, resulting in imprecise and sometimes incredibly long types) and in theory
+(the type system of Scala 3 is based on the
+[DOT calculus](https://infoscience.epfl.ch/record/227176/files/soundness_oopsla16.pdf),
+which has union types).
+
+Additionally, union types are a useful construct when trying to give types to existing
+dynamically typed APIs, this is why they're [an integral part of TypeScript](https://www.typescriptlang.org/docs/handbook/advanced-types.html#union-types)
+and have even been [partially implemented in Scala.js](https://github.com/scala-js/scala-js/blob/master/library/src/main/scala/scala/scalajs/js/Union.scala).
+
+## Join of a union type
+
+In some situation described below, a union type might need to be widened to
+a non-union type, for this purpose we define the _join_ of a union type `T1 |
+... | Tn` as the smallest intersection type of base class instances of
+`T1`,...,`Tn`. Note that union types might still appear as type arguments in the
+resulting type, this guarantees that the join is always finite.
+
+### Example
+
+Given
+
+```scala
+trait C[+T]
+trait D
+trait E
+class A extends C[A] with D
+class B extends C[B] with D with E
+```
+
+The join of `A | B` is `C[A | B] & D`
+
+## Type inference
+
+When inferring the result type of a definition (`val`, `var`, or `def`) and the
+type we are about to infer is a union type, then we replace it by its join.
+Similarly, when instantiating a type argument, if the corresponding type
+parameter is not upper-bounded by a union type and the type we are about to
+instantiate is a union type, we replace it by its join. This mirrors the
+treatment of singleton types which are also widened to their underlying type
+unless explicitly specified. The motivation is the same: inferring types
+which are "too precise" can lead to unintuitive typechecking issues later on.
+
+**Note:** Since this behavior limits the usability of union types, it might
+be changed in the future. For example by not widening unions that have been
+explicitly written down by the user and not inferred, or by not widening a type
+argument when the corresponding type parameter is covariant.
+
+See [PR #2330](https://github.com/lampepfl/dotty/pull/2330) and
+[Issue #4867](https://github.com/lampepfl/dotty/issues/4867) for further discussions.
+
+### Example
+
+```scala
+import scala.collection.mutable.ListBuffer
+val x = ListBuffer(Right("foo"), Left(0))
+val y: ListBuffer[Either[Int, String]] = x
+```
+
+This code typechecks because the inferred type argument to `ListBuffer` in the
+right-hand side of `x` was `Left[Int, Nothing] | Right[Nothing, String]` which
+was widened to `Either[Int, String]`. If the compiler hadn't done this widening,
+the last line wouldn't typecheck because `ListBuffer` is invariant in its
+argument.
+
+
+## Members
+
+The members of a union type are the members of its join.
+
+### Example
+
+The following code does not typecheck, because method `hello` is not a member of
+`AnyRef` which is the join of `A | B`.
+
+```scala
+trait A { def hello: String }
+trait B { def hello: String }
+
+def test(x: A | B) = x.hello // error: value `hello` is not a member of A | B
+```
+
+On the other hand, the following would be allowed
+
+```scala
+trait C { def hello: String }
+trait A extends C with D
+trait B extends C with E
+
+def test(x: A | B) = x.hello // ok as `hello` is a member of the join of A | B which is C
+```
+
+## Exhaustivity checking
+
+If the selector of a pattern match is a union type, the match is considered
+exhaustive if all parts of the union are covered.
+
+## Erasure
+
+The erased type for `A | B` is the _erased least upper bound_ of the erased
+types of `A` and `B`. Quoting from the documentation of `TypeErasure#erasedLub`,
+the erased LUB 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`](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html)
+- if one argument is an array, [`Object`](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html)
+- 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 `|A|`
+                  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.
diff --git a/docs/_spec/TODOreference/new-types/union-types.md b/docs/_spec/TODOreference/new-types/union-types.md
new file mode 100644
index 000000000000..ebc4565e36fb
--- /dev/null
+++ b/docs/_spec/TODOreference/new-types/union-types.md
@@ -0,0 +1,46 @@
+---
+layout: doc-page
+title: "Union Types"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/new-types/union-types.html
+---
+
+A union type `A | B` has as values all values of type `A` and also all values of type `B`.
+
+
+```scala
+case class UserName(name: String)
+case class Password(hash: Hash)
+
+def help(id: UserName | Password) =
+  val user = id match
+    case UserName(name) => lookupName(name)
+    case Password(hash) => lookupPassword(hash)
+  ...
+```
+
+Union types are duals of intersection types. `|` is _commutative_:
+`A | B` is the same type as `B | A`.
+
+The compiler will assign a union type to an expression only if such a
+type is explicitly given. This can be seen in the following [REPL](https://docs.scala-lang.org/overviews/repl/overview.html) transcript:
+
+```scala
+scala> val password = Password(123)
+val password: Password = Password(123)
+
+scala> val name = UserName("Eve")
+val name: UserName = UserName(Eve)
+
+scala> if true then name else password
+val res2: Object = UserName(Eve)
+
+scala> val either: Password | UserName = if true then name else password
+val either: Password | UserName = UserName(Eve)
+```
+
+The type of `res2` is `Object & Product`, which is a supertype of
+`UserName` and `Password`, but not the least supertype `Password |
+UserName`.  If we want the least supertype, we have to give it
+explicitly, as is done for the type of `either`.
+
+[More details](./union-types-spec.md)
diff --git a/docs/_spec/TODOreference/other-new-features/control-syntax.md b/docs/_spec/TODOreference/other-new-features/control-syntax.md
new file mode 100644
index 000000000000..92204690f0b7
--- /dev/null
+++ b/docs/_spec/TODOreference/other-new-features/control-syntax.md
@@ -0,0 +1,47 @@
+---
+layout: doc-page
+title: New Control Syntax
+nightlyOf: https://docs.scala-lang.org/scala3/reference/other-new-features/control-syntax.html
+---
+
+Scala 3 has a new "quiet" syntax for control expressions that does not rely on
+enclosing the condition in parentheses, and also allows to drop parentheses or braces
+around the generators of a `for`-expression. Examples:
+```scala
+if x < 0 then
+  "negative"
+else if x == 0 then
+  "zero"
+else
+  "positive"
+
+if x < 0 then -x else x
+
+while x >= 0 do x = f(x)
+
+for x <- xs if x > 0
+yield x * x
+
+for
+  x <- xs
+  y <- ys
+do
+  println(x + y)
+
+try body
+catch case ex: IOException => handle
+```
+
+The rules in detail are:
+
+ - The condition of an `if`-expression can be written without enclosing parentheses if it is followed by a `then`.
+ - The condition of a `while`-loop can be written without enclosing parentheses if it is followed by a `do`.
+ - The enumerators of a `for`-expression can be written without enclosing parentheses or braces if they are followed by a `yield` or `do`.
+ - A `do` in a `for`-expression expresses a `for`-loop.
+ - A `catch` can be followed by a single case on the same line.
+   If there are multiple cases, these have to appear within braces (just like in Scala 2)
+   or an indented block.
+## Rewrites
+
+The Scala 3 compiler can rewrite source code from old syntax to new syntax and back.
+When invoked with options `-rewrite -new-syntax` it will rewrite from old to new syntax, dropping parentheses and braces in conditions and enumerators. When invoked with options `-rewrite -old-syntax` it will rewrite in the reverse direction, inserting parentheses and braces as needed.
diff --git a/docs/_spec/TODOreference/other-new-features/creator-applications.md b/docs/_spec/TODOreference/other-new-features/creator-applications.md
new file mode 100644
index 000000000000..81f09d897955
--- /dev/null
+++ b/docs/_spec/TODOreference/other-new-features/creator-applications.md
@@ -0,0 +1,57 @@
+---
+layout: doc-page
+title: "Universal Apply Methods"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/other-new-features/creator-applications.html
+---
+
+Scala case classes generate apply methods, so that values of case classes can be created using simple
+function application, without needing to write `new`.
+
+Scala 3 generalizes this scheme to all concrete classes. Example:
+
+```scala
+class StringBuilder(s: String):
+  def this() = this("")
+
+StringBuilder("abc")  // old: new StringBuilder("abc")
+StringBuilder()       // old: new StringBuilder()
+```
+
+This works since a companion object with two `apply` methods
+is generated together with the class. The object looks like this:
+
+```scala
+object StringBuilder:
+  inline def apply(s: String): StringBuilder = new StringBuilder(s)
+  inline def apply(): StringBuilder = new StringBuilder()
+```
+
+The synthetic object `StringBuilder` and its `apply` methods are called _constructor proxies_.
+Constructor proxies are generated even for Java classes and classes coming from Scala 2.
+The precise rules are as follows:
+
+ 1. A constructor proxy companion object `object C` is created for a concrete class `C`,
+    provided the class does not have already a companion, and there is also no other value
+    or method named `C` defined or inherited in the scope where `C` is defined.
+
+ 2. Constructor proxy `apply` methods are generated for a concrete class provided
+
+    - the class has a companion object (which might have been generated in step 1), and
+    - that companion object does not already define a member named `apply`.
+
+    Each generated `apply` method forwards to one constructor of the class. It has the
+    same type and value parameters as the constructor.
+
+Constructor proxy companions cannot be used as values by themselves. A proxy companion object must
+be selected with `apply` (or be applied to arguments, in which case the `apply` is implicitly
+inserted).
+
+Constructor proxies are also not allowed to shadow normal definitions. That is,
+if an identifier resolves to a constructor proxy, and the same identifier is also
+defined or imported in some other scope, an ambiguity is reported.
+
+## Motivation
+
+Leaving out `new` hides an implementation detail and makes code more pleasant to read. Even though
+it requires a new rule, it will likely increase the perceived regularity of the language, since case
+classes already provide function call creation syntax (and are often defined for this reason alone).
diff --git a/docs/_spec/TODOreference/other-new-features/experimental-defs.md b/docs/_spec/TODOreference/other-new-features/experimental-defs.md
new file mode 100644
index 000000000000..225b61161652
--- /dev/null
+++ b/docs/_spec/TODOreference/other-new-features/experimental-defs.md
@@ -0,0 +1,318 @@
+---
+layout: doc-page
+title: "Experimental Definitions"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/other-new-features/experimental-defs.html
+---
+
+The [`@experimental`](https://scala-lang.org/api/3.x/scala/annotation/experimental.html) annotation allows the definition of an API that is not guaranteed backward binary or source compatibility.
+This annotation can be placed on term or type definitions.
+
+## References to experimental definitions
+
+Experimental definitions can only be referenced in an experimental scope. Experimental scopes are defined as follows:
+
+1. The RHS of an experimental `def`, `val`, `var`, `given` or `type` is an experimental scope. Examples:
+
+   <details>
+   <summary>Example 1</summary>
+
+   ```scala
+   import scala.annotation.experimental
+
+   @experimental
+   def x = ()
+
+   def d1 = x // error: value x is marked @experimental and therefore ...
+   @experimental def d2 = x
+
+   val v1 = x // error: value x is marked @experimental and therefore ...
+   @experimental val v2 = x
+
+   var vr1 = x // error: value x is marked @experimental and therefore ...
+   @experimental var vr2 = x
+
+   lazy val lv1 = x // error: value x is marked @experimental and therefore ...
+   @experimental lazy val lv2 = x
+   ```
+   </details>
+
+   <details>
+   <summary>Example 2</summary>
+
+   ```scala
+   import scala.annotation.experimental
+
+   @experimental
+   val x = ()
+
+   @experimental
+   def f() = ()
+
+   @experimental
+   object X:
+     def fx() = 1
+
+   def test1: Unit =
+     f() // error: def f is marked @experimental and therefore ...
+     x // error: value x is marked @experimental and therefore ...
+     X.fx() // error: object X is marked @experimental and therefore ...
+     import X.fx
+     fx() // error: object X is marked @experimental and therefore ...
+
+   @experimental
+   def test2: Unit =
+     // references to f, x and X are ok because `test2` is experimental
+     f()
+     x
+     X.fx()
+     import X.fx
+     fx()
+   ```
+   </details>
+
+   <details>
+   <summary>Example 3</summary>
+
+   ```scala
+   import scala.annotation.experimental
+
+   @experimental type E
+
+   type A = E // error type E is marked @experimental and therefore ...
+   @experimental type B = E
+   ```
+   </details>
+
+   <details>
+   <summary>Example 4</summary>
+
+   ```scala
+   import scala.annotation.experimental
+
+   @experimental class A
+   @experimental type X
+   @experimental type Y = Int
+   @experimental opaque type Z = Int
+
+   def test: Unit =
+     new A // error: class A is marked @experimental and therefore ...
+     val i0: A = ??? // error: class A is marked @experimental and therefore ...
+     val i1: X = ??? // error: type X is marked @experimental and therefore ...
+     val i2: Y = ??? // error: type Y is marked @experimental and therefore ...
+     val i2: Z = ??? // error: type Y is marked @experimental and therefore ...
+     ()
+   ```
+   </details>
+
+   <details>
+   <summary>Example 5</summary>
+
+   ```scala
+   @experimental
+   trait ExpSAM {
+     def foo(x: Int): Int
+   }
+   def bar(f: ExpSAM): Unit = {} // error: error form rule 2
+
+   def test: Unit =
+     bar(x => x) // error: reference to experimental SAM
+     ()
+   ```
+   </details>
+
+2. The signatures of an experimental `def`, `val`, `var`, `given` and `type`, or constructors of `class` and `trait` are experimental scopes. Examples:
+
+   <details>
+   <summary>Example 1</summary>
+
+   ```scala
+   import scala.annotation.experimental
+
+   @experimental def x = 2
+   @experimental class A
+   @experimental type X
+   @experimental type Y = Int
+   @experimental opaque type Z = Int
+
+   def test1(
+     p1: A, // error: class A is marked @experimental and therefore ...
+     p2: List[A], // error: class A is marked @experimental and therefore ...
+     p3: X, // error: type X is marked @experimental and therefore ...
+     p4: Y, // error: type Y is marked @experimental and therefore ...
+     p5: Z, // error: type Z is marked @experimental and therefore ...
+     p6: Any = x // error: def x is marked @experimental and therefore ...
+   ): A = ??? // error: class A is marked @experimental and therefore ...
+
+   @experimental def test2(
+     p1: A,
+     p2: List[A],
+     p3: X,
+     p4: Y,
+     p5: Z,
+     p6: Any = x
+   ): A = ???
+
+   class Test1(
+     p1: A, // error
+     p2: List[A], // error
+     p3: X, // error
+     p4: Y, // error
+     p5: Z, // error
+     p6: Any = x // error
+   ) {}
+
+   @experimental class Test2(
+     p1: A,
+     p2: List[A],
+     p3: X,
+     p4: Y,
+     p5: Z,
+     p6: Any = x
+   ) {}
+
+   trait Test1(
+     p1: A, // error
+     p2: List[A], // error
+     p3: X, // error
+     p4: Y, // error
+     p5: Z, // error
+     p6: Any = x // error
+   ) {}
+
+   @experimental trait Test2(
+     p1: A,
+     p2: List[A],
+     p3: X,
+     p4: Y,
+     p5: Z,
+     p6: Any = x
+   ) {}
+   ```
+   </details>
+
+3. The `extends` clause of an experimental `class`, `trait` or `object` is an experimental scope. Examples:
+
+   <details>
+   <summary>Example 1</summary>
+
+   ```scala
+   import scala.annotation.experimental
+
+   @experimental def x = 2
+
+   @experimental class A1(x: Any)
+   class A2(x: Any)
+
+
+   @experimental class B1 extends A1(1)
+   class B2 extends A1(1) // error: class A1 is marked @experimental and therefore marked @experimental and therefore ...
+
+   @experimental class C1 extends A2(x)
+   class C2 extends A2(x) // error def x is marked @experimental and therefore
+   ```
+   </details>
+
+4. The body of an experimental `class`, `trait` or `object` is an experimental scope. Examples:
+
+   <details>
+   <summary>Example 1</summary>
+   
+   ```scala
+   import scala.annotation.experimental
+
+   @experimental def x = 2
+
+   @experimental class A {
+     def f = x // ok because A is experimental
+   }
+
+   @experimental class B {
+     def f = x // ok because A is experimental
+   }
+
+   @experimental object C {
+     def f = x // ok because A is experimental
+   }
+
+   @experimental class D {
+     def f = {
+       object B {
+         x // ok because A is experimental
+       }
+     }
+   }
+   ```
+   
+   </details>
+
+5. Annotations of an experimental definition are in experimental scopes. Examples:
+
+   <details>
+   <summary>Example 1</summary>
+
+   ```scala
+   import scala.annotation.experimental
+
+   @experimental class myExperimentalAnnot extends scala.annotation.Annotation
+
+   @myExperimentalAnnot // error
+   def test: Unit = ()
+
+   @experimental
+   @myExperimentalAnnot
+   def test: Unit = ()
+   ```
+
+   </details>
+
+6. Any code compiled using a [_Nightly_](https://search.maven.org/artifact/org.scala-lang/scala3-compiler_3) or _Snapshot_ version of the compiler is considered to be in an experimental scope.
+Can use the `-Yno-experimental` compiler flag to disable it and run as a proper release.
+
+In any other situation, a reference to an experimental definition will cause a compilation error.
+
+## Experimental inheritance
+
+All subclasses of an experimental `class` or `trait` must be marked as [`@experimental`](https://scala-lang.org/api/3.x/scala/annotation/experimental.html) even if they are in an experimental scope.
+Anonymous classes and SAMs of experimental classes are considered experimental.
+
+We require explicit annotations to make sure we do not have completion or cycles issues with nested classes. This restriction could be relaxed in the future.
+
+## Experimental overriding
+
+For an overriding member `M` and overridden member `O`, if `O` is non-experimental then `M` must be non-experimental.
+
+This makes sure that we cannot have accidental binary incompatibilities such as the following change.
+```diff
+class A:
+  def f: Any = 1
+class B extends A:
+-  @experimental def f: Int = 2
+```
+
+## Test frameworks
+
+Tests can be defined as experimental. Tests frameworks can execute tests using reflection even if they are in an experimental class, object or method. Examples:
+
+<details>
+<summary>Example 1</summary>
+
+Test that touch experimental APIs can be written as follows
+
+```scala
+import scala.annotation.experimental
+
+@experimental def x = 2
+
+class MyTests {
+  /*@Test*/ def test1 = x // error
+  @experimental /*@Test*/ def test2 = x
+}
+
+@experimental
+class MyExperimentalTests {
+  /*@Test*/ def test1 = x
+  /*@Test*/ def test2 = x
+}
+```
+
+</details>
diff --git a/docs/_spec/TODOreference/other-new-features/export.md b/docs/_spec/TODOreference/other-new-features/export.md
new file mode 100644
index 000000000000..40e2ad9df248
--- /dev/null
+++ b/docs/_spec/TODOreference/other-new-features/export.md
@@ -0,0 +1,234 @@
+---
+layout: doc-page
+title: "Export Clauses"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/other-new-features/export.html
+---
+
+An export clause defines aliases for selected members of an object. Example:
+
+```scala
+class BitMap
+class InkJet
+
+class Printer:
+  type PrinterType
+  def print(bits: BitMap): Unit = ???
+  def status: List[String] = ???
+
+class Scanner:
+  def scan(): BitMap = ???
+  def status: List[String] = ???
+
+class Copier:
+  private val printUnit = new Printer { type PrinterType = InkJet }
+  private val scanUnit = new Scanner
+
+  export scanUnit.scan
+  export printUnit.{status as _, *}
+
+  def status: List[String] = printUnit.status ++ scanUnit.status
+```
+
+The two `export` clauses define the following _export aliases_ in class `Copier`:
+
+```scala
+final def scan(): BitMap            = scanUnit.scan()
+final def print(bits: BitMap): Unit = printUnit.print(bits)
+final type PrinterType              = printUnit.PrinterType
+```
+
+They can be accessed inside `Copier` as well as from outside:
+
+```scala
+val copier = new Copier
+copier.print(copier.scan())
+```
+
+An `export` clause has the same format as an import clause. Its general form is:
+
+```scala
+export path . { sel_1, ..., sel_n }
+```
+
+It consists of a qualifier expression `path`, which must be a stable identifier, followed by
+one or more selectors `sel_i` that identify what gets an alias. Selectors can be
+of one of the following forms:
+
+ - A _simple selector_ `x` creates aliases for all eligible members of `path` that are named `x`.
+ - A _renaming selector_ `x as y` creates aliases for all eligible members of `path` that are named `x`, but the alias is named `y` instead of `x`.
+ - An _omitting selector_ `x as _` prevents `x` from being aliased by a subsequent
+   wildcard selector.
+ - A _given selector_ `given x` has an optional type bound `x`. It creates aliases for all eligible given instances that conform to either `x`, or `Any` if `x` is omitted, except for members that are named by a previous simple, renaming, or omitting selector.
+ - A _wildcard selector_ `*` creates aliases for all eligible members of `path` except for given instances,
+   synthetic members generated by the compiler and those members that are named by a previous simple, renaming, or omitting selector.
+   \
+   Notes:
+   - eligible construtor proxies are also included, even though they are synthetic members.
+   - members created by an export are also included. They are created by the compiler, but are not considered synthetic.
+
+A member is _eligible_ if all of the following holds:
+
+ - its owner is not a base class of the class[(\*)](#note_class) containing the export clause,
+ - the member does not override a concrete definition that has as owner
+   a base class of the class containing the export clause.
+ - it is accessible at the export clause,
+ - it is not a constructor, nor the (synthetic) class part of an object,
+ - it is a given instance (declared with `given`) if and only if the export is from a _given selector_.
+
+It is a compile-time error if a simple or renaming selector does not identify
+any eligible members.
+
+It is a compile-time error if a simple or renaming selector does not identify any eligible members.
+
+Type members are aliased by type definitions, and term members are aliased by method definitions. For instance:
+```scala
+object O:
+  class C(val x: Int)
+  def m(c: C): Int = c.x + 1
+export O.*
+  // generates
+  //   type C = O.C
+  //   def m(c: O.C): Int = O.m(c)
+```
+
+Export aliases copy the type and value parameters of the members they refer to.
+Export aliases are always `final`. Aliases of given instances are again defined as givens (and aliases of old-style implicits are `implicit`). Aliases of extensions are again defined as extensions. Aliases of inline methods or values are again defined `inline`. There are no other modifiers that can be given to an alias. This has the following consequences for overriding:
+
+ - Export aliases cannot be overridden, since they are final.
+ - Export aliases cannot override concrete members in base classes, since they are
+   not marked `override`.
+ - However, export aliases can implement deferred members of base classes.
+
+Export aliases for public value definitions that are accessed without
+referring to private values in the qualifier path
+are marked by the compiler as "stable" and their result types are the singleton types of the aliased definitions. This means that they can be used as parts of stable identifier paths, even though they are technically methods. For instance, the following is OK:
+```scala
+class C { type T }
+object O { val c: C = ... }
+export O.c
+def f: c.T = ...
+```
+
+
+**Restrictions:**
+
+ 1. Export clauses can appear in classes or they can appear at the top-level. An   export clause cannot appear as a statement in a block.
+ 1. If an export clause contains a wildcard or given selector, it is forbidden for its qualifier path to refer to a package. This is because it is not yet known how to safely track wildcard dependencies to a package for the purposes of incremental compilation.
+ 1. An export renaming hides un-renamed exports matching the target name. For instance, the following
+    clause would be invalid since `B` is hidden by the renaming `A as B`.
+    ```scala
+    export {A as B, B}        // error: B is hidden
+    ```
+
+ 1. Renamings in an export clause must have pairwise different target names. For instance, the following clause would be invalid:
+    ```scala
+    export {A as C, B as C}   // error: duplicate renaming
+
+ 1. Simple renaming exports like
+    ```scala
+    export status as stat
+    ```
+    are not supported yet. They would run afoul of the restriction that the
+    exported `a` cannot be already a member of the object containing the export.
+    This restriction might be lifted in the future.
+
+<a id="note_class"></a>
+(\*) **Note:** Unless otherwise stated, the term "class" in this discussion also includes object and trait definitions.
+
+## Motivation
+
+It is a standard recommendation to prefer composition over inheritance. This is really an application of the principle of least power: Composition treats components as blackboxes whereas inheritance can affect the internal workings of components through overriding. Sometimes the close coupling implied by inheritance is the best solution for a problem, but where this is not necessary the looser coupling of composition is better.
+
+So far, object-oriented languages including Scala made it much easier to use inheritance than composition. Inheritance only requires an `extends` clause whereas composition required a verbose elaboration of a sequence of forwarders. So in that sense, object-oriented languages are pushing
+programmers to a solution that is often too powerful. Export clauses redress the balance. They make composition relationships as concise and easy to express as inheritance relationships. Export clauses also offer more flexibility than extends clauses since members can be renamed or omitted.
+
+Export clauses also fill a gap opened by the shift from package objects to top-level definitions. One occasionally useful idiom that gets lost in this shift is a package object inheriting from some class. The idiom is often used in a facade like pattern, to make members
+of internal compositions available to users of a package. Top-level definitions are not wrapped in a user-defined object, so they can't inherit anything. However, top-level definitions can be export clauses, which supports the facade design pattern in a safer and
+more flexible way.
+
+## Export Clauses in Extensions
+
+An export clause may also appear in an extension.
+
+Example:
+```scala
+class StringOps(x: String):
+  def *(n: Int): String = ...
+  def capitalize: String = ...
+
+extension (x: String)
+  def take(n: Int): String = x.substring(0, n)
+  def drop(n: Int): String = x.substring(n)
+  private def moreOps = new StringOps(x)
+  export moreOps.*
+```
+In this case the qualifier expression must be an identifier that refers to a unique parameterless extension method in the same extension clause. The export will create
+extension methods for all accessible term members
+in the result of the qualifier path. For instance, the extension above would be expanded to
+```scala
+extension (x: String)
+  def take(n: Int): String = x.substring(0, n)
+  def drop(n: Int): String = x.substring(n)
+  private def moreOps = StringOps(x)
+  def *(n: Int): String = moreOps.*(n)
+  def capitalize: String = moreOps.capitalize
+```
+
+## Syntax changes:
+
+```
+TemplateStat      ::=  ...
+                    |  Export
+TopStat           ::=  ...
+                    |  Export
+ExtMethod         ::=  ...
+                    |  Export
+Export            ::=  ‘export’ ImportExpr {‘,’ ImportExpr}
+ImportExpr        ::=  SimpleRef {‘.’ id} ‘.’ ImportSpec
+ImportSpec        ::=  NamedSelector
+                    |  WildcardSelector
+                    | ‘{’ ImportSelectors) ‘}’
+NamedSelector     ::=  id [‘as’ (id | ‘_’)]
+WildCardSelector  ::=  ‘*’ | ‘given’ [InfixType]
+ImportSelectors   ::=  NamedSelector [‘,’ ImportSelectors]
+                    |  WildCardSelector {‘,’ WildCardSelector}
+```
+
+## Elaboration of Export Clauses
+
+Export clauses raise questions about the order of elaboration during type checking.
+Consider the following example:
+
+```scala
+class B { val c: Int }
+object a { val b = new B }
+export a.*
+export b.*
+```
+
+Is the `export b.*` clause legal? If yes, what does it export? Is it equivalent to `export a.b.*`? What about if we swap the last two clauses?
+
+```
+export b.*
+export a.*
+```
+
+To avoid tricky questions like these, we fix the elaboration order of exports as follows.
+
+Export clauses are processed when the type information of the enclosing object or class is completed. Completion so far consisted of the following steps:
+
+ 1. Elaborate any annotations of the class.
+ 2. Elaborate the parameters of the class.
+ 3. Elaborate the self type of the class, if one is given.
+ 4. Enter all definitions of the class as class members, with types to be completed
+    on demand.
+ 5. Determine the types of all parents of the class.
+
+    With export clauses, the following steps are added:
+
+ 6. Compute the types of all paths in export clauses.
+ 7. Enter export aliases for the eligible members of all paths in export clauses.
+
+It is important that steps 6 and 7 are done in sequence: We first compute the types of _all_
+paths in export clauses and only after this is done we enter any export aliases as class members. This means that a path of an export clause cannot refer to an alias made available
+by another export clause of the same class.
diff --git a/docs/_spec/TODOreference/other-new-features/indentation.md b/docs/_spec/TODOreference/other-new-features/indentation.md
new file mode 100644
index 000000000000..e931030ab696
--- /dev/null
+++ b/docs/_spec/TODOreference/other-new-features/indentation.md
@@ -0,0 +1,509 @@
+---
+layout: doc-page
+title: "Optional Braces"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/other-new-features/indentation.html
+---
+
+Scala 3 enforces some rules on indentation and allows some occurrences of braces `{...}` to be optional:
+
+- First, some badly indented programs are flagged with warnings.
+- Second, some occurrences of braces `{...}` are made optional. Generally, the rule
+  is that adding a pair of optional braces will not change the meaning of a well-indented program.
+
+These changes can be turned off with the compiler flag `-no-indent`.
+
+## Indentation Rules
+
+The compiler enforces two rules for well-indented programs, flagging violations as warnings.
+
+ 1. In a brace-delimited region, no statement is allowed to start to the left
+    of the first statement after the opening brace that starts a new line.
+
+    This rule is helpful for finding missing closing braces. It prevents errors like:
+
+    ```scala
+    if (x < 0) {
+      println(1)
+      println(2)
+
+    println("done")  // error: indented too far to the left
+    ```
+
+ 2. If significant indentation is turned off (i.e. under Scala 2 mode or under `-no-indent`) and we are at the  start of an indented sub-part of an expression, and the indented part ends in a newline, the next statement must start at an indentation width less than the sub-part. This prevents errors where an opening brace was forgotten, as in
+
+    ```scala
+    if (x < 0)
+      println(1)
+      println(2)   // error: missing `{`
+    ```
+
+These rules still leave a lot of leeway how programs should be indented. For instance, they do not impose
+any restrictions on indentation within expressions, nor do they require that all statements of an indentation block line up exactly.
+
+The rules are generally helpful in pinpointing the root cause of errors related to missing opening or closing braces. These errors are often quite hard to diagnose, in particular in large programs.
+
+## Optional Braces
+
+The compiler will insert `<indent>` or `<outdent>`
+tokens at certain line breaks. Grammatically, pairs of `<indent>` and `<outdent>` tokens have the same effect as pairs of braces `{` and `}`.
+
+The algorithm makes use of a stack `IW` of previously encountered indentation widths. The stack initially holds a single element with a zero indentation width. The _current indentation width_ is the indentation width of the top of the stack.
+
+There are two rules:
+
+ 1. An `<indent>` is inserted at a line break, if
+
+     - An indentation region can start at the current position in the source, and
+     - the first token on the next line has an indentation width strictly greater
+       than the current indentation width
+
+    An indentation region can start
+
+     - after the leading parameters of an `extension`, or
+     - after a `with` in a given instance, or
+     - after a `:` at the start of a template body (see discussion of `<colon>` below), or
+     - after one of the following tokens:
+
+       ```
+       =  =>  ?=>  <-  catch  do  else  finally  for
+       if  match  return  then  throw  try  while  yield
+       ```
+
+     - after the closing `)` of a condition in an old-style `if` or `while`.
+     - after the closing `)` or `}` of the enumerations of an old-style `for` loop without a `do`.
+
+    If an `<indent>` is inserted, the indentation width of the token on the next line
+    is pushed onto `IW`, which makes it the new current indentation width.
+
+ 2. An `<outdent>` is inserted at a line break, if
+
+    - the first token on the next line has an indentation width strictly less
+        than the current indentation width, and
+    - the last token on the previous line is not one of the following tokens
+      which indicate that the previous statement continues:
+      ```
+      then  else  do  catch  finally  yield  match
+      ```
+    - if the first token on the next line is a
+        [leading infix operator](../changed-features/operators.md).
+      then its indentation width is less then the current indentation width,
+      and it either matches a previous indentation width or is also less
+      than the enclosing indentation width.
+
+    If an `<outdent>` is inserted, the top element is popped from `IW`.
+    If the indentation width of the token on the next line is still less than the new current indentation width, step (2) repeats. Therefore, several `<outdent>` tokens
+    may be inserted in a row.
+
+    The following two additional rules support parsing of legacy code with ad-hoc layout. They might be withdrawn in future language versions:
+
+     - An `<outdent>` is also inserted if the next token following a statement sequence starting with an `<indent>` closes an indentation region, i.e. is one of `then`, `else`, `do`, `catch`, `finally`, `yield`, `}`, `)`, `]` or `case`.
+
+     - An `<outdent>` is finally inserted in front of a comma that follows a statement sequence starting with an `<indent>` if the indented region is itself enclosed in parentheses.
+
+It is an error if the indentation width of the token following an `<outdent>` does not match the indentation of some previous line in the enclosing indentation region. For instance, the following would be rejected.
+
+```scala
+if x < 0 then
+    -x
+  else   // error: `else` does not align correctly
+    x
+```
+
+Indentation tokens are only inserted in regions where newline statement separators are also inferred:
+at the top-level, inside braces `{...}`, but not inside parentheses `(...)`, patterns or types.
+
+**Note:** The rules for leading infix operators above are there to make sure that
+```scala
+  one
+  + two.match
+      case 1 => b
+      case 2 => c
+  + three
+```
+is parsed as `one + (two.match ...) + three`. Also, that
+```scala
+if x then
+    a
+  + b
+  + c
+else d
+```
+is parsed as `if x then a + b + c else d`.
+
+## Optional Braces Around Template Bodies
+
+The Scala grammar uses the term _template body_ for the definitions of a class, trait, or object that are normally enclosed in braces. The braces around a template body can also be omitted by means of the following rule.
+
+A template body can alternatively consist of a colon followed by one or more indented statements. To this purpose we introduce a new `<colon>` token that reads as
+the standard colon "`:`" but is generated instead of it where `<colon>`
+is legal according to the context free syntax, but only if the previous token
+is an alphanumeric identifier, a backticked identifier, or one of the tokens `this`, `super`, "`)`", and "`]`".
+
+An indentation region can start after a `<colon>`. A template body may be either enclosed in braces, or it may start with
+`<colon> <indent>` and end with `<outdent>`.
+Analogous rules apply for enum bodies, type refinements, and local packages containing nested definitions.
+
+With these new rules, the following constructs are all valid:
+
+```scala
+trait A:
+  def f: Int
+
+class C(x: Int) extends A:
+  def f = x
+
+object O:
+  def f = 3
+
+enum Color:
+  case Red, Green, Blue
+
+new A:
+  def f = 3
+
+package p:
+  def a = 1
+
+package q:
+  def b = 2
+```
+
+In each case, the `:` at the end of line can be replaced without change of meaning by a pair of braces that enclose the following indented definition(s).
+
+The syntax changes allowing this are as follows:
+
+Define for an arbitrary sequence of tokens or non-terminals `TS`:
+
+```
+:<<< TS >>>   ::=   ‘{’ TS ‘}’
+                |   <colon> <indent" TS <outdent>
+```
+Then the grammar changes as follows:
+```
+TemplateBody      ::=  :<<< [SelfType] TemplateStat {semi TemplateStat} >>>
+EnumBody          ::=  :<<< [SelfType] EnumStat {semi EnumStat} >>>
+Refinement        ::=  :<<< [RefineDcl] {semi [RefineDcl]} >>>
+Packaging         ::=  ‘package’ QualId :<<< TopStats >>>
+```
+
+## Spaces vs Tabs
+
+Indentation prefixes can consist of spaces and/or tabs. Indentation widths are the indentation prefixes themselves, ordered by the string prefix relation. So, so for instance "2 tabs, followed by 4 spaces" is strictly less than "2 tabs, followed by 5 spaces", but "2 tabs, followed by 4 spaces" is incomparable to "6 tabs" or to "4 spaces, followed by 2 tabs". It is an error if the indentation width of some line is incomparable with the indentation width of the region that's current at that point. To avoid such errors, it is a good idea not to mix spaces and tabs in the same source file.
+
+## Indentation and Braces
+
+Indentation can be mixed freely with braces `{...}`, as well as brackets `[...]` and parentheses `(...)`. For interpreting indentation inside such regions, the following rules apply.
+
+ 1. The assumed indentation width of a multiline region enclosed in braces is the
+    indentation width of the first token that starts a new line after the opening brace.
+
+ 2. The assumed indentation width of a multiline region inside brackets or parentheses is:
+
+     - if the opening bracket or parenthesis is at the end of a line, the indentation width of token following it,
+     - otherwise, the indentation width of the enclosing region.
+
+ 3. On encountering a closing brace `}`, bracket `]` or parenthesis `)`, as many `<outdent>` tokens as necessary are inserted to close all open nested indentation regions.
+
+For instance, consider:
+```scala
+{
+  val x = f(x: Int, y =>
+    x * (
+      y + 1
+    ) +
+    (x +
+    x)
+  )
+}
+```
+ - Here, the indentation width of the region enclosed by the braces is 3 (i.e. the indentation width of the
+statement starting with `val`).
+ - The indentation width of the region in parentheses that follows `f` is also 3, since the opening
+   parenthesis is not at the end of a line.
+ - The indentation width of the region in parentheses around `y + 1` is 9
+   (i.e. the indentation width of `y + 1`).
+ - Finally, the indentation width of the last region in parentheses starting with `(x` is 6 (i.e. the indentation width of the indented region following the `=>`.
+
+## Special Treatment of Case Clauses
+
+The indentation rules for `match` expressions and `catch` clauses are refined as follows:
+
+- An indentation region is opened after a `match` or `catch` also if the following `case`
+  appears at the indentation width that's current for the `match` itself.
+- In that case, the indentation region closes at the first token at that
+  same indentation width that is not a `case`, or at any token with a smaller
+  indentation width, whichever comes first.
+
+The rules allow to write `match` expressions where cases are not indented themselves, as in the example below:
+
+```scala
+x match
+case 1 => print("I")
+case 2 => print("II")
+case 3 => print("III")
+case 4 => print("IV")
+case 5 => print("V")
+
+println(".")
+```
+
+## Using Indentation to Signal Statement Continuation
+
+Indentation is used in some situations to decide whether to insert a virtual semicolon between
+two consecutive lines or to treat them as one statement. Virtual semicolon insertion is
+suppressed if the second line is indented more relative to the first one, and either the second line
+starts with "`(`", "`[`", or "`{`" or the first line ends with `return`. Examples:
+
+```scala
+f(x + 1)
+  (2, 3)        // equivalent to  `f(x + 1)(2, 3)`
+
+g(x + 1)
+(2, 3)          // equivalent to  `g(x + 1); (2, 3)`
+
+h(x + 1)
+  {}            // equivalent to  `h(x + 1){}`
+
+i(x + 1)
+{}              // equivalent to  `i(x + 1); {}`
+
+if x < 0 then return
+  a + b         // equivalent to  `if x < 0 then return a + b`
+
+if x < 0 then return
+println(a + b)  // equivalent to  `if x < 0 then return; println(a + b)`
+```
+In Scala 2, a line starting with "`{`" always continues the function call on the preceding line,
+irrespective of indentation, whereas a virtual semicolon is inserted in all other cases.
+The Scala-2 behavior is retained under source `-no-indent` or `-source 3.0-migration`.
+
+
+
+## The End Marker
+
+Indentation-based syntax has many advantages over other conventions. But one possible problem is that it makes it hard to discern when a large indentation region ends, since there is no specific token that delineates the end. Braces are not much better since a brace by itself also contains no information about what region is closed.
+
+To solve this problem, Scala 3 offers an optional `end` marker. Example:
+
+```scala
+def largeMethod(...) =
+  ...
+  if ... then ...
+  else
+    ... // a large block
+  end if
+  ... // more code
+end largeMethod
+```
+
+An `end` marker consists of the identifier `end` and a follow-on specifier token that together constitute all the tokes of a line. Possible specifier tokens are
+identifiers or one of the following keywords
+
+```scala
+if   while    for    match    try    new    this    val   given
+```
+
+End markers are allowed in statement sequences. The specifier token `s` of an end marker must correspond to the statement that precedes it. This means:
+
+- If the statement defines a member `x` then `s` must be the same identifier `x`.
+- If the statement defines a constructor then `s` must be `this`.
+- If the statement defines an anonymous given, then `s` must be `given`.
+- If the statement defines an anonymous extension, then `s` must be `extension`.
+- If the statement defines an anonymous class, then `s` must be `new`.
+- If the statement is a `val` definition binding a pattern, then `s` must be `val`.
+- If the statement is a package clause that refers to package `p`, then `s` must be the same identifier `p`.
+- If the statement is an `if`, `while`, `for`, `try`, or `match` statement, then `s` must be that same token.
+
+For instance, the following end markers are all legal:
+
+```scala
+package p1.p2:
+
+  abstract class C():
+
+    def this(x: Int) =
+      this()
+      if x > 0 then
+        val a :: b =
+          x :: Nil
+        end val
+        var y =
+          x
+        end y
+        while y > 0 do
+          println(y)
+          y -= 1
+        end while
+        try
+          x match
+            case 0 => println("0")
+            case _ =>
+          end match
+        finally
+          println("done")
+        end try
+      end if
+    end this
+
+    def f: String
+  end C
+
+  object C:
+    given C =
+      new C:
+        def f = "!"
+        end f
+      end new
+    end given
+  end C
+
+  extension (x: C)
+    def ff: String = x.f ++ x.f
+  end extension
+
+end p2
+```
+
+### When to Use End Markers
+
+It is recommended that `end` markers are used for code where the extent of an indentation region is not immediately apparent "at a glance". People will have different preferences what this means, but one can nevertheless give some guidelines that stem from experience. An end marker makes sense if
+
+- the construct contains blank lines, or
+- the construct is long, say 15-20 lines or more,
+- the construct ends heavily indented, say 4 indentation levels or more.
+
+If none of these criteria apply, it's often better to not use an end marker since the code will be just as clear and more concise. If there are several ending regions that satisfy one of the criteria above, we usually need an end marker only for the outermost closed region. So cascades of end markers as in the example above are usually better avoided.
+
+### Syntax
+
+```
+EndMarker         ::=  ‘end’ EndMarkerTag    -- when followed by EOL
+EndMarkerTag      ::=  id | ‘if’ | ‘while’ | ‘for’ | ‘match’ | ‘try’
+                    |  ‘new’ | ‘this’ | ‘given’ | ‘extension’ | ‘val’
+BlockStat         ::=  ... | EndMarker
+TemplateStat      ::=  ... | EndMarker
+TopStat           ::=  ... | EndMarker
+```
+
+## Example
+
+Here is a (somewhat meta-circular) example of code using indentation. It provides a concrete representation of indentation widths as defined above together with efficient operations for constructing and comparing indentation widths.
+
+```scala
+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)
+
+  override def toString: String =
+    this match
+      case Run(ch, n) =>
+        val kind = ch match
+          case ' '  => "space"
+          case '\t' => "tab"
+          case _    => s"'$ch'-character"
+        val suffix = if n == 1 then "" else "s"
+        s"$n $kind$suffix"
+      case Conc(l, r) =>
+        s"$l, $r"
+
+object IndentWidth:
+  private inline val MaxCached = 40
+
+  private val spaces = IArray.tabulate(MaxCached + 1)(new Run(' ', _))
+  private val tabs = IArray.tabulate(MaxCached + 1)(new Run('\t', _))
+
+  def Run(ch: Char, n: Int): Run =
+    if n <= MaxCached && ch == ' ' then
+      spaces(n)
+    else if n <= MaxCached && ch == '\t' then
+      tabs(n)
+    else
+      new Run(ch, n)
+  end Run
+
+  val Zero = Run(' ', 0)
+end IndentWidth
+```
+
+## Settings and Rewrites
+
+Significant indentation is enabled by default. It can be turned off by giving any of the options `-no-indent`, `-old-syntax` and `-source 3.0-migration`. If indentation is turned off, it is nevertheless checked that indentation conforms to the logical program structure as defined by braces. If that is not the case, the compiler issues a warning.
+
+The Scala 3 compiler can rewrite source code to indented code and back.
+When invoked with options `-rewrite -indent` it will rewrite braces to
+indented regions where possible. When invoked with options `-rewrite -no-indent` it will rewrite in the reverse direction, inserting braces for indentation regions.
+The `-indent` option only works on [new-style syntax](./control-syntax.md). So to go from old-style syntax to new-style indented code one has to invoke the compiler twice, first with options `-rewrite -new-syntax`, then again with options
+`-rewrite -indent`. To go in the opposite direction, from indented code to old-style syntax, it's `-rewrite -no-indent`, followed by `-rewrite -old-syntax`.
+
+## Variant: Indentation Marker `:` for Arguments
+
+Generally, the possible indentation regions coincide with those regions where braces `{...}` are also legal, no matter whether the braces enclose an expression or a set of definitions. There is one exception, though: Arguments to functions can be enclosed in braces but they cannot be simply indented instead. Making indentation always significant for function arguments would be too restrictive and fragile.
+
+To allow such arguments to be written without braces, a variant of the indentation scheme is implemented under language import
+```scala
+import language.experimental.fewerBraces
+```
+In this variant, a `<colon>` token is also recognized where function argument would be expected. Examples:
+
+```scala
+times(10):
+  println("ah")
+  println("ha")
+```
+
+or
+
+```scala
+credentials `++`:
+  val file = Path.userHome / ".credentials"
+  if file.exists
+  then Seq(Credentials(file))
+  else Seq()
+```
+
+or
+
+```scala
+xs.map:
+  x =>
+    val y = x - 1
+    y * y
+```
+What's more, a `:` in these settings can also be followed on the same line by the parameter part and arrow of a lambda. So the last example could be compressed to this:
+
+```scala
+xs.map: x =>
+  val y = x - 1
+  y * y
+```
+and the following would also be legal:
+```scala
+xs.foldLeft(0): (x, y) =>
+  x + y
+```
+
+The grammar changes for this variant are as follows.
+
+```
+SimpleExpr       ::=  ...
+                   |  SimpleExpr ColonArgument
+InfixExpr        ::=  ...
+                   |  InfixExpr id ColonArgument
+ColonArgument    ::=  colon [LambdaStart]
+                      indent (CaseClauses | Block) outdent
+LambdaStart      ::=  FunParams (‘=>’ | ‘?=>’)
+                   |  HkTypeParamClause ‘=>’
+```
\ No newline at end of file
diff --git a/docs/_spec/TODOreference/other-new-features/kind-polymorphism.md b/docs/_spec/TODOreference/other-new-features/kind-polymorphism.md
new file mode 100644
index 000000000000..8f0172c4c04b
--- /dev/null
+++ b/docs/_spec/TODOreference/other-new-features/kind-polymorphism.md
@@ -0,0 +1,47 @@
+---
+layout: doc-page
+title: "Kind Polymorphism"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/other-new-features/kind-polymorphism.html
+---
+
+Normally type parameters in Scala are partitioned into _kinds_. First-level types are types of values. Higher-kinded types are type constructors
+such as `List` or `Map`. The kind of a type is indicated by the top type of which it is a subtype. Normal types are subtypes of `Any`,
+covariant single argument type constructors such as `List` are subtypes of `[+X] =>> Any`, and the `Map` type constructor is
+a subtype of `[X, +Y] =>> Any`.
+
+A type can be used only as prescribed by its kind. Subtypes of `Any` cannot be applied to type arguments whereas subtypes of `[X] =>> Any`
+_must_ be applied to a type argument, unless they are passed to type parameters of the same kind.
+
+Sometimes we would like to have type parameters that can have more than one kind, for instance to define an implicit
+value that works for parameters of any kind. This is now possible through a form of (_subtype_) kind polymorphism.
+Kind polymorphism relies on the special type [`scala.AnyKind`](https://scala-lang.org/api/3.x/scala/AnyKind.html) that can be used as an upper bound of a type.
+
+```scala
+def f[T <: AnyKind] = ...
+```
+
+The actual type arguments of `f` can then be types of arbitrary kinds. So the following would all be legal:
+
+```scala
+f[Int]
+f[List]
+f[Map]
+f[[X] =>> String]
+```
+
+We call type parameters and abstract types with an `AnyKind` upper bound _any-kinded types_.
+Since the actual kind of an any-kinded type is unknown, its usage must be heavily restricted: An any-kinded type
+can be neither the type of a value, nor can it be instantiated with type parameters. So about the only
+thing one can do with an any-kinded type is to pass it to another any-kinded type argument.
+Nevertheless, this is enough to achieve some interesting generalizations that work across kinds, typically
+through advanced uses of implicits.
+
+(todo: insert good concise example)
+
+Some technical details: [`AnyKind`](https://scala-lang.org/api/3.x/scala/AnyKind.html) is a synthesized class just like `Any`, but without any members. It extends no other class.
+It is declared `abstract` and `final`, so it can be neither instantiated nor extended.
+
+`AnyKind` plays a special role in Scala's subtype system: It is a supertype of all other types no matter what their kind is. It is also assumed to be kind-compatible with all other types. Furthermore, `AnyKind` is treated as a higher-kinded type (so it cannot be used as a type of values), but at the same time it has no type parameters (so it cannot be instantiated).
+
+**Note**: This feature is considered experimental but stable and it can be disabled under compiler flag
+(i.e. `-Yno-kind-polymorphism`).
diff --git a/docs/_spec/TODOreference/other-new-features/matchable.md b/docs/_spec/TODOreference/other-new-features/matchable.md
new file mode 100644
index 000000000000..234fdf03220c
--- /dev/null
+++ b/docs/_spec/TODOreference/other-new-features/matchable.md
@@ -0,0 +1,141 @@
+---
+layout: doc-page
+title: "The Matchable Trait"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/other-new-features/matchable.html
+---
+
+A new trait [`Matchable`](https://scala-lang.org/api/3.x/scala/Matchable.html) controls the ability to pattern match.
+
+## The Problem
+
+The Scala 3 standard library has a type [`IArray`](https://scala-lang.org/api/3.x/scala.html#IArray-0) for immutable
+arrays that is defined like this:
+
+```scala
+  opaque type IArray[+T] = Array[_ <: T]
+```
+
+The `IArray` type offers extension methods for `length` and `apply`, but not for `update`; hence it seems values of type `IArray` cannot be updated.
+
+However, there is a potential hole due to pattern matching. Consider:
+
+```scala
+val imm: IArray[Int] = ...
+imm match
+  case a: Array[Int] => a(0) = 1
+```
+
+The test will succeed at runtime since [`IArray`](https://scala-lang.org/api/3.x/scala.html#IArray-0)s _are_ represented as
+`Array`s at runtime. But if we allowed it, it would break the fundamental abstraction of immutable arrays.
+
+__Aside:__ One could also achieve the same by casting:
+
+```scala
+imm.asInstanceOf[Array[Int]](0) = 1
+```
+
+But that is not as much of a problem since in Scala `asInstanceOf` is understood to be low-level and unsafe. By contrast, a pattern match that compiles without warning or error should not break abstractions.
+
+Note also that the problem is not tied to [opaque types](opaques.md) as match selectors. The following slight variant with a value of parametric
+type `T` as match selector leads to the same problem:
+
+```scala
+def f[T](x: T) = x match
+  case a: Array[Int] => a(0) = 0
+f(imm)
+```
+
+Finally, note that the problem is not linked to just [opaque types](opaques.md). No unbounded type parameter or abstract type should be decomposable with a pattern match.
+
+## The Solution
+
+There is a new type [`scala.Matchable`](https://scala-lang.org/api/3.x/scala/Matchable.html) that controls pattern matching. When typing a pattern match of a constructor pattern `C(...)` or
+a type pattern `_: C` it is required that the selector type conforms
+to `Matchable`. If that's not the case a warning is issued. For instance when compiling the example at the start of this section we get:
+
+```
+> sc ../new/test.scala -source future
+-- Warning: ../new/test.scala:4:12 ---------------------------------------------
+4 |    case a: Array[Int] => a(0) = 0
+  |            ^^^^^^^^^^
+  |            pattern selector should be an instance of Matchable,
+  |            but it has unmatchable type IArray[Int] instead
+```
+
+To allow migration from Scala 2 and cross-compiling
+between Scala 2 and 3 the warning is turned on only for `-source future-migration` or higher.
+
+[`Matchable`](https://scala-lang.org/api/3.x/scala/Matchable.html) is a universal trait with `Any` as its parent class. It is extended by both [`AnyVal`](https://scala-lang.org/api/3.x/scala/AnyVal.html) and [`AnyRef`](https://scala-lang.org/api/3.x/scala/AnyRef.html). Since `Matchable` is a supertype of every concrete value or reference class it means that instances of such classes can be matched as before. However, match selectors of the following types will produce a warning:
+
+- Type `Any`: if pattern matching is required one should use `Matchable` instead.
+- Unbounded type parameters and abstract types: If pattern matching is required they should have an upper bound `Matchable`.
+- Type parameters and abstract types that are only bounded by some
+  universal trait: Again, `Matchable` should be added as a bound.
+
+Here is the hierarchy of top-level classes and traits with their defined methods:
+
+```scala
+abstract class Any:
+  def getClass
+  def isInstanceOf
+  def asInstanceOf
+  def ==
+  def !=
+  def ##
+  def equals
+  def hashCode
+  def toString
+
+trait Matchable extends Any
+
+class AnyVal extends Any, Matchable
+class Object extends Any, Matchable
+```
+
+[`Matchable`](https://scala-lang.org/api/3.x/scala/Matchable.html) is currently a marker trait without any methods. Over time
+we might migrate methods `getClass` and `isInstanceOf` to it, since these are closely related to pattern-matching.
+
+## `Matchable` and Universal Equality
+
+Methods that pattern-match on selectors of type `Any` will need a cast once the
+Matchable warning is turned on. The most common such method is the universal
+`equals` method. It will have to be written as in the following example:
+
+```scala
+class C(val x: String):
+
+  override def equals(that: Any): Boolean =
+    that.asInstanceOf[Matchable] match
+      case that: C => this.x == that.x
+      case _ => false
+```
+
+The cast of `that` to [`Matchable`](https://scala-lang.org/api/3.x/scala/Matchable.html) serves as an indication that universal equality
+is unsafe in the presence of abstract types and opaque types since it cannot properly distinguish the meaning of a type from its representation. The cast
+is guaranteed to succeed at run-time since `Any` and [`Matchable`](https://scala-lang.org/api/3.x/scala/Matchable.html) both erase to
+`Object`.
+
+For instance, consider the definitions
+
+```scala
+opaque type Meter = Double
+def Meter(x: Double): Meter = x
+
+opaque type Second = Double
+def Second(x: Double): Second = x
+```
+
+Here, universal `equals` will return true for
+
+```scala
+  Meter(10).equals(Second(10))
+```
+
+even though this is clearly false mathematically. With [multiversal equality](../contextual/multiversal-equality.md) one can mitigate that problem somewhat by turning
+
+```scala
+  import scala.language.strictEquality
+  Meter(10) == Second(10)
+```
+
+into a type error.
diff --git a/docs/_spec/TODOreference/other-new-features/opaques-details.md b/docs/_spec/TODOreference/other-new-features/opaques-details.md
new file mode 100644
index 000000000000..d7305a249089
--- /dev/null
+++ b/docs/_spec/TODOreference/other-new-features/opaques-details.md
@@ -0,0 +1,126 @@
+---
+layout: doc-page
+title: "Opaque Type Aliases: More Details"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/other-new-features/opaques-details.html
+---
+
+## Syntax
+
+```
+Modifier          ::=  ...
+                    |  ‘opaque’
+```
+
+`opaque` is a [soft modifier](../soft-modifier.md). It can still be used as a normal identifier when it is not in front of a definition keyword.
+
+Opaque type aliases must be members of classes, traits, or objects, or they are defined
+at the top-level. They cannot be defined in local blocks.
+
+## Type Checking
+
+The general form of a (monomorphic) opaque type alias is
+
+```scala
+opaque type T >: L <: U = R
+```
+
+where the lower bound `L` and the upper bound `U` may be missing, in which case they are assumed to be [`scala.Nothing`](https://scala-lang.org/api/3.x/scala/Nothing.html) and [`scala.Any`](https://scala-lang.org/api/3.x/scala/Any.html), respectively. If bounds are given, it is checked that the right-hand side `R` conforms to them, i.e. `L <: R` and `R <: U`. F-bounds are not supported for opaque type aliases: `T` is not allowed to appear in `L` or `U`.
+
+Inside the scope of the alias definition, the alias is transparent: `T` is treated
+as a normal alias of `R`. Outside its scope, the alias is treated as the abstract type
+```scala
+type T >: L <: U
+```
+A special case arises if the opaque type alias is defined in an object. Example:
+
+```scala
+object o:
+  opaque type T = R
+```
+
+In this case we have inside the object (also for non-opaque types) that `o.T` is equal to
+`T` or its expanded form `o.this.T`. Equality is understood here as mutual subtyping, i.e.
+`o.T <: o.this.T` and `o.this.T <: T`. Furthermore, we have by the rules of opaque type aliases
+that `o.this.T` equals `R`. The two equalities compose. That is, inside `o`, it is
+also known that `o.T` is equal to `R`. This means the following code type-checks:
+
+```scala
+object o:
+  opaque type T = Int
+  val x: Int = id(2)
+def id(x: o.T): o.T = x
+```
+
+Opaque type aliases cannot be `private` and cannot be overridden in subclasses.
+Opaque type aliases cannot have a context function type as right-hand side.
+
+## Type Parameters of Opaque Types
+
+Opaque type aliases can have a single type parameter list. The following aliases
+are well-formed
+```scala
+opaque type F[T] = (T, T)
+opaque type G = [T] =>> List[T]
+```
+but the following are not:
+```scala
+opaque type BadF[T] = [U] =>> (T, U)
+opaque type BadG = [T] =>> [U] => (T, U)
+```
+
+## Translation of Equality
+
+Comparing two values of opaque type with `==` or `!=` normally uses universal equality,
+unless another overloaded `==` or `!=` operator is defined for the type. To avoid
+boxing, the operation is mapped after type checking to the (in-)equality operator
+defined on the underlying type. For instance,
+```scala
+  opaque type T = Int
+
+  ...
+  val x: T
+  val y: T
+  x == y    // uses Int equality for the comparison.
+```
+
+## Top-level Opaque Types
+
+An opaque type alias on the top-level is transparent in all other top-level definitions in the sourcefile where it appears, but is opaque in nested
+objects and classes and in all other source files. Example:
+```scala
+// in test1.scala
+opaque type A = String
+val x: A = "abc"
+
+object obj:
+  val y: A = "abc"  // error: found: "abc", required: A
+
+// in test2.scala
+def z: String = x   // error: found: A, required: String
+```
+This behavior becomes clear if one recalls that top-level definitions are placed in their own synthetic object. For instance, the code in `test1.scala` would expand to
+```scala
+object test1$package:
+  opaque type A = String
+  val x: A = "abc"
+
+object obj:
+  val y: A = "abc"  // error: cannot assign "abc" to opaque type alias A
+```
+The opaque type alias `A` is transparent in its scope, which includes the definition of `x`, but not the definitions of `obj` and `y`.
+
+
+## Relationship to SIP 35
+
+Opaque types in Scala 3 are an evolution from what is described in
+[Scala SIP 35](https://docs.scala-lang.org/sips/opaque-types.html).
+
+The differences compared to the state described in this SIP are:
+
+ 1. Opaque type aliases cannot be defined anymore in local statement sequences.
+ 2. The scope where an opaque type alias is visible is now the whole scope where
+    it is defined, instead of just a companion object.
+ 3. The notion of a companion object for opaque type aliases has been dropped.
+ 4. Opaque type aliases can have bounds.
+ 5. The notion of type equality involving opaque type aliases has been clarified. It was
+    strengthened with respect to the previous implementation of SIP 35.
diff --git a/docs/_spec/TODOreference/other-new-features/opaques.md b/docs/_spec/TODOreference/other-new-features/opaques.md
new file mode 100644
index 000000000000..d8c4d37bcb3b
--- /dev/null
+++ b/docs/_spec/TODOreference/other-new-features/opaques.md
@@ -0,0 +1,179 @@
+---
+layout: doc-page
+title: "Opaque Type Aliases"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/other-new-features/opaques.html
+---
+
+Opaque types aliases provide type abstraction without any overhead. Example:
+
+```scala
+object MyMath:
+
+  opaque type Logarithm = Double
+
+  object Logarithm:
+
+    // These are the two ways to lift to the Logarithm type
+
+    def apply(d: Double): Logarithm = math.log(d)
+
+    def safe(d: Double): Option[Logarithm] =
+      if d > 0.0 then Some(math.log(d)) else None
+
+  end Logarithm
+
+  // Extension methods define opaque types' public APIs
+  extension (x: Logarithm)
+    def toDouble: Double = math.exp(x)
+    def + (y: Logarithm): Logarithm = Logarithm(math.exp(x) + math.exp(y))
+    def * (y: Logarithm): Logarithm = x + y
+
+end MyMath
+```
+
+This introduces `Logarithm` as a new abstract type, which is implemented as `Double`.
+The fact that `Logarithm` is the same as `Double` is only known in the scope where
+`Logarithm` is defined, which in the above example corresponds to the object `MyMath`.
+Or in other words, within the scope, it is treated as a type alias, but this is opaque to the outside world
+where, in consequence, `Logarithm` is seen as an abstract type that has nothing to do with `Double`.
+
+The public API of `Logarithm` consists of the `apply` and `safe` methods defined in the companion object.
+They convert from `Double`s to `Logarithm` values. Moreover, an operation `toDouble` that converts the other way, and operations `+` and `*` are defined as extension methods on `Logarithm` values.
+The following operations would be valid because they use functionality implemented in the `MyMath` object.
+
+```scala
+import MyMath.Logarithm
+
+val l = Logarithm(1.0)
+val l2 = Logarithm(2.0)
+val l3 = l * l2
+val l4 = l + l2
+```
+
+But the following operations would lead to type errors:
+
+```scala
+val d: Double = l       // error: found: Logarithm, required: Double
+val l2: Logarithm = 1.0 // error: found: Double, required: Logarithm
+l * 2                   // error: found: Int(2), required: Logarithm
+l / l2                  // error: `/` is not a member of Logarithm
+```
+
+## Bounds For Opaque Type Aliases
+
+Opaque type aliases can also come with bounds. Example:
+
+```scala
+object Access:
+
+  opaque type Permissions = Int
+  opaque type PermissionChoice = Int
+  opaque type Permission <: Permissions & PermissionChoice = Int
+
+  extension (x: PermissionChoice)
+    def | (y: PermissionChoice): PermissionChoice = x | y
+  extension (x: Permissions)
+    def & (y: Permissions): Permissions = x | y
+  extension (granted: Permissions)
+    def is(required: Permissions) = (granted & required) == required
+    def isOneOf(required: PermissionChoice) = (granted & required) != 0
+
+  val NoPermission: Permission = 0
+  val Read: Permission = 1
+  val Write: Permission = 2
+  val ReadWrite: Permissions = Read | Write
+  val ReadOrWrite: PermissionChoice = Read | Write
+
+end Access
+```
+
+The `Access` object defines three opaque type aliases:
+
+- `Permission`, representing a single permission,
+- `Permissions`, representing a set of permissions with the meaning "all of these permissions granted",
+- `PermissionChoice`, representing a set of permissions with the meaning "at least one of these permissions granted".
+
+Outside the `Access` object, values of type `Permissions` may be combined using the `&` operator,
+where `x & y` means "all permissions in `x` *and* in `y` granted".
+Values of type `PermissionChoice` may be combined using the `|` operator,
+where `x | y` means "a permission in `x` *or* in `y` granted".
+
+Note that inside the `Access` object, the `&` and `|` operators always resolve to the corresponding methods of `Int`,
+because members always take precedence over extension methods.
+For that reason, the `|` extension method in `Access` does not cause infinite recursion.
+
+In particular, the definition of `ReadWrite` must use `|`, the bitwise operator for `Int`,
+even though client code outside `Access` would use `&`, the extension method on `Permissions`.
+The internal representations of `ReadWrite` and `ReadOrWrite` are identical, but this is not visible to the client,
+which is interested only in the semantics of `Permissions`, as in the example below.
+
+All three opaque type aliases have the same underlying representation type `Int`. The
+`Permission` type has an upper bound `Permissions & PermissionChoice`. This makes
+it known outside the `Access` object that `Permission` is a subtype of the other
+two types.  Hence, the following usage scenario type-checks.
+
+```scala
+object User:
+  import Access.*
+
+  case class Item(rights: Permissions)
+  extension (item: Item)
+    def +(other: Item): Item = Item(item.rights & other.rights)
+
+  val roItem = Item(Read)  // OK, since Permission <: Permissions
+  val woItem = Item(Write)
+  val rwItem = Item(ReadWrite)
+  val noItem = Item(NoPermission)
+
+  assert(!roItem.rights.is(ReadWrite))
+  assert(roItem.rights.isOneOf(ReadOrWrite))
+
+  assert(rwItem.rights.is(ReadWrite))
+  assert(rwItem.rights.isOneOf(ReadOrWrite))
+
+  assert(!noItem.rights.is(ReadWrite))
+  assert(!noItem.rights.isOneOf(ReadOrWrite))
+
+  assert((roItem + woItem).rights.is(ReadWrite))
+end User
+```
+On the other hand, the call `roItem.rights.isOneOf(ReadWrite)` would give a type error:
+```scala
+  assert(roItem.rights.isOneOf(ReadWrite))
+                               ^^^^^^^^^
+                               Found:    (Access.ReadWrite : Access.Permissions)
+                               Required: Access.PermissionChoice
+```
+`Permissions` and `PermissionChoice` are different, unrelated types outside `Access`.
+
+
+## Opaque Type Members on Classes
+While typically, opaque types are used together with objects to hide implementation details of a module, they can also be used with classes.
+
+For example, we can redefine the above example of Logarithms as a class.
+```scala
+class Logarithms:
+
+  opaque type Logarithm = Double
+
+  def apply(d: Double): Logarithm = math.log(d)
+
+  def safe(d: Double): Option[Logarithm] =
+    if d > 0.0 then Some(math.log(d)) else None
+
+  def mul(x: Logarithm, y: Logarithm) = x + y
+```
+
+Opaque type members of different instances are treated as different:
+```scala
+val l1 = new Logarithms
+val l2 = new Logarithms
+val x = l1(1.5)
+val y = l1(2.6)
+val z = l2(3.1)
+l1.mul(x, y) // type checks
+l1.mul(x, z) // error: found l2.Logarithm, required l1.Logarithm
+```
+In general, one can think of an opaque type as being only transparent in the scope of `private[this]`.
+
+[More details](opaques-details.md)
diff --git a/docs/_spec/TODOreference/other-new-features/open-classes.md b/docs/_spec/TODOreference/other-new-features/open-classes.md
new file mode 100644
index 000000000000..764c234df599
--- /dev/null
+++ b/docs/_spec/TODOreference/other-new-features/open-classes.md
@@ -0,0 +1,80 @@
+---
+layout: doc-page
+title: "Open Classes"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/other-new-features/open-classes.html
+---
+
+An `open` modifier on a class signals that the class is planned for extensions. Example:
+```scala
+// File Writer.scala
+package p
+
+open class Writer[T]:
+
+  /** Sends to stdout, can be overridden */
+  def send(x: T) = println(x)
+
+  /** Sends all arguments using `send` */
+  def sendAll(xs: T*) = xs.foreach(send)
+end Writer
+
+// File EncryptedWriter.scala
+package p
+
+class EncryptedWriter[T: Encryptable] extends Writer[T]:
+  override def send(x: T) = super.send(encrypt(x))
+```
+An open class typically comes with some documentation that describes
+the internal calling patterns between methods of the class as well as hooks that can be overridden. We call this the _extension contract_ of the class. It is different from the _external contract_ between a class and its users.
+
+Classes that are not open can still be extended, but only if at least one of two alternative conditions is met:
+
+ - The extending class is in the same source file as the extended class. In this case, the extension is usually an internal implementation matter.
+
+ - The language feature [`adhocExtensions`](https://scala-lang.org/api/3.x/scala/runtime/stdLibPatches/language$$adhocExtensions$.html) is enabled for the extending class. This is typically enabled by an import clause in the source file of the extension:
+   ```scala
+   import scala.language.adhocExtensions
+   ```
+   Alternatively, the feature can be enabled by the compiler option `-language:adhocExtensions`.
+   If the feature is not enabled, the compiler will issue a "feature" warning. For instance, if the `open` modifier on class `Writer` is dropped, compiling `EncryptedWriter` would produce a warning:
+   ```
+   -- Feature Warning: EncryptedWriter.scala:6:14 ----
+     |class EncryptedWriter[T: Encryptable] extends Writer[T]
+     |                                              ^
+     |Unless class Writer is declared 'open', its extension
+     | in a separate file should be enabled
+     |by adding the import clause 'import scala.language.adhocExtensions'
+     |or by setting the compiler option -language:adhocExtensions.
+   ```
+
+## Motivation
+
+When writing a class, there are three possible expectations of extensibility:
+
+1. The class is intended to allow extensions. This means one should expect
+a carefully worked out and documented extension contract for the class.
+
+2. Extensions of the class are forbidden, for instance to make correctness or security guarantees.
+
+3. There is no firm decision either way. The class is not _a priori_ intended for extensions, but if others find it useful to extend on an _ad-hoc_ basis, let them go ahead. However, they are on their own in this case. There is no documented extension contract, and future versions of the class might break the extensions (by rearranging internal call patterns, for instance).
+
+The three cases are clearly distinguished by using `open` for (1), `final` for (2) and no modifier for (3).
+
+It is good practice to avoid _ad-hoc_ extensions in a code base, since they tend to lead to fragile systems that are hard to evolve. But there
+are still some situations where these extensions are useful: for instance,
+to mock classes in tests, or to apply temporary patches that add features or fix bugs in library classes. That's why _ad-hoc_ extensions are permitted, but only if there is an explicit opt-in via a language feature import.
+
+## Details
+
+ - `open` is a soft modifier. It is treated as a normal identifier
+   unless it is in modifier position.
+ - An `open` class cannot be `final` or `sealed`.
+ - Traits or `abstract` classes are always `open`, so `open` is redundant for them.
+
+## Relationship with `sealed`
+
+A class that is neither `abstract` nor `open` is similar to a `sealed` class: it can still be extended, but only in the same source file. The difference is what happens if an extension of the class is attempted in another source file. For a `sealed` class, this is an error, whereas for a simple non-open class, this is still permitted provided the [`adhocExtensions`](https://scala-lang.org/api/3.x/scala/runtime/stdLibPatches/language$$adhocExtensions$.html) feature is enabled, and it gives a warning otherwise.
+
+## Migration
+
+`open` is a new modifier in Scala 3. To allow cross compilation between Scala 2.13 and Scala 3.0 without warnings, the feature warning for ad-hoc extensions is produced only under `-source future`. It will be produced by default from Scala 3.1 on.
diff --git a/docs/_spec/TODOreference/other-new-features/other-new-features.md b/docs/_spec/TODOreference/other-new-features/other-new-features.md
new file mode 100644
index 000000000000..974a8548cb68
--- /dev/null
+++ b/docs/_spec/TODOreference/other-new-features/other-new-features.md
@@ -0,0 +1,7 @@
+---
+layout: index
+title: "Other New Features"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/other-new-features.html
+---
+
+The following pages document new features of Scala 3.
diff --git a/docs/_spec/TODOreference/other-new-features/parameter-untupling-spec.md b/docs/_spec/TODOreference/other-new-features/parameter-untupling-spec.md
new file mode 100644
index 000000000000..e5165550fc0d
--- /dev/null
+++ b/docs/_spec/TODOreference/other-new-features/parameter-untupling-spec.md
@@ -0,0 +1,89 @@
+---
+layout: doc-page
+title: "Parameter Untupling - More Details"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/other-new-features/parameter-untupling-spec.html
+---
+
+## Motivation
+
+Say you have a list of pairs
+
+```scala
+val xs: List[(Int, Int)]
+```
+
+and you want to map `xs` to a list of `Int`s so that each pair of numbers is mapped to their sum.
+Previously, the best way to do this was with a pattern-matching decomposition:
+
+```scala
+xs.map {
+  case (x, y) => x + y
+}
+```
+While correct, this is inconvenient. Instead, we propose to write it the following way:
+
+```scala
+xs.map {
+  (x, y) => x + y
+}
+```
+
+or, equivalently:
+
+```scala
+xs.map(_ + _)
+```
+
+Generally, a function value with `n > 1` parameters can be converted to a function with tupled arguments if the expected type is a unary function type of the form `((T_1, ..., T_n)) => U`.
+
+## Type Checking
+
+The type checking happens in two steps:
+
+1. Check whether parameter untupling is feasible
+2. Adapt the function and type check it
+
+### Feasibility Check
+
+Suppose a function `f` of the form `(p1, ..., pn) => e` (where `n > 1`), with `p1, ..., pn` as parameters and `e` as function body.
+
+If the expected type for checking `f` is a fully defined function type of the form `TupleN[T1, ..., Tn] => R` (or an equivalent SAM-type), where each type `Ti` fits the corresponding parameter `pi`. Then `f` is feasible for parameter untupling with the expected type `TupleN[T1, ..., Tn] => R`.
+
+A type `Ti` fits a parameter `pi` if one of the following two cases is `true`:
+
+* `pi` comes without a type, i.e. it is a simple identifier or `_`.
+* `pi` is of the form `x: Ui` or `_: Ui` and `Ti <: Ui`.
+
+Parameter untupling composes with eta-expansion. That is, an n-ary function generated by eta-expansion can in turn be adapted to the expected type with parameter untupling.
+
+### Term adaptation
+
+If the function
+
+```scala
+(p1, ..., pn) => e
+```
+
+is feasible for parameter untupling with the expected type `TupleN[T1, ..., Tn] => Te`, then continue to type check the following adapted function
+
+```scala
+(x: TupleN[T1, ..., Tn]) =>
+  def p1: T1 = x._1
+  ...
+  def pn: Tn = x._n
+  e
+```
+
+with the same expected type.
+## Migration
+
+Code like this could not be written before, hence the new notation is not ambiguous after adoption.
+
+It is possible that someone has written an implicit conversion from `(T1, ..., Tn) => R` to `TupleN[T1, ..., Tn] => R` for some `n`.
+Such a conversion is now only useful for general conversions of function values, when parameter untupling is not applicable.
+Some care is required to implement the conversion efficiently.
+Obsolete conversions could be detected and fixed by [`Scalafix`](https://scalacenter.github.io/scalafix/).
+
+## Reference
+
+For more information, see [Issue #897](https://github.com/lampepfl/dotty/issues/897).
diff --git a/docs/_spec/TODOreference/other-new-features/parameter-untupling.md b/docs/_spec/TODOreference/other-new-features/parameter-untupling.md
new file mode 100644
index 000000000000..fcc1fa11d519
--- /dev/null
+++ b/docs/_spec/TODOreference/other-new-features/parameter-untupling.md
@@ -0,0 +1,77 @@
+---
+layout: doc-page
+title: "Parameter Untupling"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/other-new-features/parameter-untupling.html
+---
+
+Say you have a list of pairs
+
+```scala
+val xs: List[(Int, Int)]
+```
+
+and you want to map `xs` to a list of `Int`s so that each pair of numbers is mapped to
+their sum. Previously, the best way to do this was with a pattern-matching decomposition:
+
+```scala
+xs map {
+  case (x, y) => x + y
+}
+```
+
+While correct, this is also inconvenient and confusing, since the `case`
+suggests that the pattern match could fail. As a shorter and clearer alternative Scala 3 now allows
+
+```scala
+xs.map {
+  (x, y) => x + y
+}
+```
+
+or, equivalently:
+
+```scala
+xs.map(_ + _)
+```
+and
+```scala
+def combine(i: Int, j: Int) = i + j
+xs.map(combine)
+```
+
+Generally, a function value with `n > 1` parameters is wrapped in a
+function type of the form `((T_1, ..., T_n)) => U` if that is the expected type.
+The tuple parameter is decomposed and its elements are passed directly to the underlying function.
+
+More specifically, the adaptation is applied to the mismatching formal
+parameter list. In particular, the adaptation is not a conversion
+between function types. That is why the following is not accepted:
+
+```scala
+val combiner: (Int, Int) => Int = _ + _
+xs.map(combiner)     // Type Mismatch
+```
+
+The function value must be explicitly tupled, rather than the parameters untupled:
+```scala
+xs.map(combiner.tupled)
+```
+
+A conversion may be provided in user code:
+
+```scala
+import scala.language.implicitConversions
+transparent inline implicit def `fallback untupling`(f: (Int, Int) => Int): ((Int, Int)) => Int =
+  p => f(p._1, p._2)     // use specialized apply instead of unspecialized `tupled`
+xs.map(combiner)
+```
+
+Parameter untupling is attempted before conversions are applied, so that a conversion in scope
+cannot subvert untupling.
+
+## Reference
+
+For more information see:
+
+* [More details](./parameter-untupling-spec.md)
+* [Issue #897](https://github.com/lampepfl/dotty/issues/897).
diff --git a/docs/_spec/TODOreference/other-new-features/safe-initialization.md b/docs/_spec/TODOreference/other-new-features/safe-initialization.md
new file mode 100644
index 000000000000..757038eac786
--- /dev/null
+++ b/docs/_spec/TODOreference/other-new-features/safe-initialization.md
@@ -0,0 +1,343 @@
+---
+layout: doc-page
+title: "Safe Initialization"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/other-new-features/safe-initialization.html
+---
+
+Scala 3 implements experimental safe initialization check, which can be enabled by the compiler option `-Ysafe-init`.
+
+The design and implementation of the initialization checker is described in the
+paper _Safe object initialization, abstractly_ [3].
+
+## A Quick Glance
+
+To get a feel of how it works, we first show several examples below.
+
+### Parent-Child Interaction
+
+Given the following code snippet:
+
+``` scala
+abstract class AbstractFile:
+  def name: String
+  val extension: String = name.substring(4)
+
+class RemoteFile(url: String) extends AbstractFile:
+  val localFile: String = s"${url.##}.tmp"  // error: usage of `localFile` before it's initialized
+  def name: String = localFile
+```
+
+The checker will report:
+
+``` scala
+-- Warning: tests/init/neg/AbstractFile.scala:7:4 ------------------------------
+7 |	val localFile: String = s"${url.##}.tmp"  // error: usage of `localFile` before it's initialized
+  |	    ^
+  |    Access non-initialized field value localFile. Calling trace:
+  |     -> val extension: String = name.substring(4)	[ AbstractFile.scala:3 ]
+  |      -> def name: String = localFile            	[ AbstractFile.scala:8 ]
+```
+
+### Inner-Outer Interaction
+
+Given the code below:
+
+``` scala
+object Trees:
+  class ValDef { counter += 1 }
+  class EmptyValDef extends ValDef
+  val theEmptyValDef = new EmptyValDef
+  private var counter = 0  // error
+```
+
+The checker will report:
+
+``` scala
+-- Warning: tests/init/neg/trees.scala:5:14 ------------------------------------
+5 |  private var counter = 0  // error
+  |              ^
+  |             Access non-initialized field variable counter. Calling trace:
+  |              -> val theEmptyValDef = new EmptyValDef    [ trees.scala:4 ]
+  |               -> class EmptyValDef extends ValDef       [ trees.scala:3 ]
+  |                -> class ValDef { counter += 1 }	     [ trees.scala:2 ]
+```
+
+### Functions
+
+Given the code below:
+
+``` scala
+abstract class Parent:
+  val f: () => String = () => this.message
+  def message: String
+
+class Child extends Parent:
+  val a = f()
+  val b = "hello"           // error
+  def message: String = b
+```
+
+The checker reports:
+
+``` scala
+-- Warning: tests/init/neg/features-high-order.scala:7:6 -----------------------
+7 |  val b = "hello"           // error
+  |      ^
+  |Access non-initialized field value b. Calling trace:
+  | -> val a = f()                              	[ features-high-order.scala:6 ]
+  |   -> val f: () => String = () => this.message	[ features-high-order.scala:2 ]
+  |    -> def message: String = b	                [ features-high-order.scala:8 ]
+```
+## Design Goals
+
+We establish the following design goals:
+
+- __Sound__: checking always terminates, and is sound for common and reasonable usage (over-approximation)
+- __Expressive__: support common and reasonable initialization patterns
+- __Friendly__: simple rules, minimal syntactic overhead, informative error messages
+- __Modular__: modular checking, no analysis beyond project boundary
+- __Fast__: instant feedback
+- __Simple__: no changes to core type system, explainable by a simple theory
+
+By _reasonable usage_, we include the following use cases (but not restricted to them):
+
+- Access fields on `this` and outer `this` during initialization
+- Call methods on `this` and outer `this` during initialization
+- Instantiate inner class and call methods on such instances during initialization
+- Capture fields in functions
+
+## Principles
+
+To achieve the goals, we uphold the following fundamental principles:
+_stackability_, _monotonicity_, _scopability_ and _authority_.
+
+Stackability means that all fields of a class are initialized at the end of the
+class body. Scala enforces this property in syntax by demanding that all fields
+are initialized at the end of the primary constructor, except for the language
+feature below:
+
+``` scala
+var x: T = _
+```
+
+Control effects such as exceptions may break this property, as the
+following example shows:
+
+``` scala
+class MyException(val b: B) extends Exception("")
+class A:
+  val b = try { new B } catch { case myEx: MyException => myEx.b }
+  println(b.a)
+
+class B:
+  throw new MyException(this)
+  val a: Int = 1
+```
+
+In the code above, the control effect teleport the uninitialized value
+wrapped in an exception. In the implementation, we avoid the problem
+by ensuring that the values that are thrown must be transitively initialized.
+
+Monotonicity means that the initialization status of an object should
+not go backward: initialized fields continue to be initialized, a
+field points to an initialized object may not later point to an
+object under initialization. As an example, the following code will be rejected:
+
+``` scala
+trait Reporter:
+  def report(msg: String): Unit
+
+class FileReporter(ctx: Context) extends Reporter:
+  ctx.typer.reporter = this                // ctx now reaches an uninitialized object
+  val file: File = new File("report.txt")
+  def report(msg: String) = file.write(msg)
+```
+
+In the code above, suppose `ctx` points to a transitively initialized
+object. Now the assignment at line 3 makes `this`, which is not fully
+initialized, reachable from `ctx`. This makes field usage dangerous,
+as it may indirectly reach uninitialized fields.
+
+Monotonicity is based on a well-known technique called _heap monotonic
+typestate_ to ensure soundness in the presence of aliasing
+[1]. Roughly speaking, it means initialization state should not go backwards.
+
+Scopability means that there are no side channels to access to partially
+constructed objects. Control effects like coroutines, delimited
+control, resumable exceptions may break the property, as they can transport a
+value upper in the stack (not in scope) to be reachable from the current scope.
+Static fields can also serve as a teleport thus breaks this property.  In the
+implementation, we need to enforce that teleported values are transitively
+initialized.
+
+The three principles above contribute to _local reasoning about initialization_,
+which means:
+
+> An initialized environment can only produce initialized values.
+
+For example, if the arguments to an `new`-expression are transitively
+initialized, so is the result. If the receiver and arguments in a method call
+are transitively initialized, so is the result.
+
+Local reasoning about initialization gives rise to a fast initialization
+checker, as it avoids whole-program analysis.
+
+The principle of authority goes hand-in-hand with monotonicity: the principle
+of monotonicity stipulates that initialization states cannot go backwards, while
+the principle of authority stipulates that the initialization states may not
+go forward at arbitrary locations due to aliasing. In Scala, we may only
+advance initialization states of objects in the class body when a field is
+defined with a mandatory initializer or at local reasoning points when the object
+becomes transitively initialized.
+
+## Abstract Values
+
+There are three fundamental abstractions for initialization states of objects:
+
+- __Cold__: A cold object may have uninitialized fields.
+- __Warm__: A warm object has all its fields initialized but may reach _cold_ objects.
+- __Hot__: A hot object is transitively initialized, i.e., it only reaches warm objects.
+
+In the initialization checker, the abstraction `Warm` is refined to handle inner
+classes and multiple constructors:
+
+- __Warm[C] { outer = V, ctor, args = Vs }__: A warm object of class `C`, where the immediate outer of `C` is `V`, the constructor is `ctor` and constructor arguments are `Vs`.
+
+The initialization checker checks each concrete class separately. The abstraction `ThisRef`
+represents the current object under initialization:
+
+- __ThisRef[C]__: The current object of class `C` under initialization.
+
+The initialization state of the current object is stored in the abstract heap as an
+abstract object. The abstract heap also serves as a cache for the field values
+of warm objects. `Warm` and `ThisRef` are "addresses" of the abstract objects stored
+in the abstract heap.
+
+Two more abstractions are introduced to support functions and conditional
+expressions:
+
+- __Fun(e, V, C)__: An abstract function value where `e` is the code, `V` is the
+  abstract value for `this` inside the function body and the function is located
+  inside the class `C`.
+
+- __Refset(Vs)__: A set of abstract values `Vs`.
+
+A value `v` is _effectively hot_ if any of the following is true:
+
+- `v` is `Hot`.
+- `v` is `ThisRef` and all fields of the underlying object are assigned.
+- `v` is `Warm[C] { ... }` and
+  1. `C` does not contain inner classes; and
+  2. Calling any method on `v` encounters no initialization errors and the method return value is _effectively hot_; and
+  3. Each field of `v` is _effectively hot_.
+- `v` is `Fun(e, V, C)` and calling the function encounters no errors and the
+  function return value is _effectively hot_.
+- The root object (refered by `ThisRef`) is _effectively hot_.
+
+An effectively hot value can be regarded as transitively initialized thus can
+be safely leaked via method arguments or as RHS of reassignment.
+The initialization checker tries to promote non-hot values to effectively hot
+whenenver possible.
+
+## Rules
+
+With the established principles and design goals, the following rules are imposed:
+
+1. The field access `e.f` or method call `e.m()` is illegal if `e` is _cold_.
+
+   A cold value should not be used.
+
+2. The field access `e.f` is invalid if `e` has the value `ThisRef` and `f` is not initialized.
+
+3. In an assignment `o.x = e`, the expression `e` must be _effectively hot_.
+
+   This is how monotonicity is enforced in the system. Note that in an
+   initialization `val f: T = e`, the expression `e` may point to a non-hot
+   value.
+
+4. Arguments to method calls must be _effectively hot_.
+
+   Escape of `this` in the constructor is commonly regarded as an anti-pattern.
+
+   However, passing non-hot values as argument to another constructor is allowed, to support
+   creation of cyclic data structures. The checker will ensure that the escaped
+   non-initialized object is not used, i.e. calling methods or accessing fields
+   on the escaped object is not allowed.
+
+   An exception is for calling synthetic `apply`s of case classes. For example,
+   the method call `Some.apply(e)` will be interpreted as `new Some(e)`, thus
+   is valid even if `e` is not hot.
+
+   Another exception to this rule is parametric method calls. For example, in
+   `List.apply(e)`, the argument `e` may be non-hot. If that is the case, the
+   result value of the parametric method call is taken as _cold_.
+
+5. Method calls on hot values with effectively hot arguments produce hot results.
+
+   This rule is assured by local reasoning about initialization.
+
+6. Method calls on `ThisRef` and warm values will be resolved statically and the
+   corresponding method bodies are checked.
+
+7. In a new expression `new p.C(args)`, if the values of `p` and `args` are
+   effectively hot, then the result value is also hot.
+
+   This is assured by local reasoning about initialization.
+
+8. In a new expression `new p.C(args)`, if any value of `p` and `args` is not
+   effectively hot, then the result value takes the form `Warm[C] { outer = Vp, args = Vargs }`. The initialization code for the class `C` is checked again to make
+   sure the non-hot values are used properly.
+
+   In the above, `Vp` is the widened value of `p` --- the widening happens if `p`
+   is a warm value `Warm[D] { outer = V, args }` and we widen it to
+   `Warm[D] { outer = Cold, args }`.
+
+   The variable `Vargs` represents values of `args` with non-hot values widened
+   to `Cold`.
+
+   The motivation for the widening is to finitize the abstract domain and ensure
+   termination of the initialization check.
+
+9. The scrutinee in a pattern match and the values in return and throw statements must be _effectively hot_.
+
+## Modularity
+
+The analysis takes the primary constructor of concrete classes as entry points.
+It follows the constructors of super classes, which might be defined in another project.
+The analysis takes advantage of TASTy for analyzing super classes defined in another project.
+
+The crossing of project boundary raises a concern about modularity. It is
+well-known in object-oriented programming that superclass and subclass are
+tightly coupled. For example, adding a method in the superclass requires
+recompiling the child class for checking safe overriding.
+
+Initialization is no exception in this respect. The initialization of an object
+essentially involves close interaction between subclass and superclass. If the
+superclass is defined in another project, the crossing of project boundary
+cannot be avoided for soundness of the analysis.
+
+Meanwhile, inheritance across project boundary has been under scrutiny and the
+introduction of [open classes](./open-classes.md) mitigate the concern here.
+For example, the initialization check could enforce that the constructors of
+open classes may not contain method calls on `this` or introduce annotations as
+a contract.
+
+The feedback from the community on the topic is welcome.
+
+## Back Doors
+
+Occasionally you may want to suppress warnings reported by the
+checker.  You can either write `e: @unchecked` to tell the checker to
+skip checking for the expression `e`, or you may use the old trick:
+mark some fields as lazy.
+
+## Caveats
+
+- The system cannot provide safety guarantee when extending Java or Scala 2 classes.
+- Safe initialization of global objects is only partially checked.
+
+## References
+
+1. Fähndrich, M. and Leino, K.R.M., 2003, July. [_Heap monotonic typestates_](https://www.microsoft.com/en-us/research/publication/heap-monotonic-typestate/). In International Workshop on Aliasing, Confinement and Ownership in object-oriented programming (IWACO).
+2. Fengyun Liu, Ondřej Lhoták, Aggelos Biboudis, Paolo G. Giarrusso, and Martin Odersky. [_A type-and-effect system for object initialization_](https://dl.acm.org/doi/10.1145/3428243). OOPSLA, 2020.
+3. Fengyun Liu, Ondřej Lhoták, Enze Xing, Nguyen Cao Pham. [_Safe object initialization, abstractly_](https://dl.acm.org/doi/10.1145/3486610.3486895). Scala 2021.
diff --git a/docs/_spec/TODOreference/other-new-features/targetName.md b/docs/_spec/TODOreference/other-new-features/targetName.md
new file mode 100644
index 000000000000..63c4cf1ec0df
--- /dev/null
+++ b/docs/_spec/TODOreference/other-new-features/targetName.md
@@ -0,0 +1,118 @@
+---
+layout: doc-page
+title: "The @targetName annotation"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/other-new-features/targetName.html
+---
+
+A [`@targetName`](https://scala-lang.org/api/3.x/scala/annotation/targetName.html) annotation on a definition defines an alternate name for the implementation of that definition. Example:
+
+```scala
+import scala.annotation.targetName
+
+object VecOps:
+  extension [T](xs: Vec[T])
+    @targetName("append")
+    def ++= [T] (ys: Vec[T]): Vec[T] = ...
+```
+
+Here, the `++=` operation is implemented (in Byte code or native code) under the name `append`. The implementation name affects the code that is generated, and is the name under which code from other languages can call the method. For instance, `++=` could be invoked from Java like this:
+
+```java
+VecOps.append(vec1, vec2)
+```
+
+The [`@targetName`](https://scala-lang.org/api/3.x/scala/annotation/targetName.html) annotation has no bearing on Scala usages. Any application of that method in Scala has to use `++=`, not `append`.
+
+## Details
+
+ 1. `@targetName` is defined in package `scala.annotation`. It takes a single argument
+    of type `String`. That string is called the _external name_ of the definition
+    that's annotated.
+
+ 2. A `@targetName` annotation can be given for all kinds of definitions except a top-level `class`, `trait`, or `object`.
+
+ 3. The name given in a [`@targetName`](https://scala-lang.org/api/3.x/scala/annotation/targetName.html) annotation must be a legal name
+    for the defined entities on the host platform.
+
+ 4. It is recommended that definitions with symbolic names have a [`@targetName`](https://scala-lang.org/api/3.x/scala/annotation/targetName.html) annotation. This will establish an alternate name that is easier to search for and
+ will avoid cryptic encodings in runtime diagnostics.
+
+ 5. Definitions with names in backticks that are not legal host platform names
+    should also have a [`@targetName`](https://scala-lang.org/api/3.x/scala/annotation/targetName.html) annotation.
+
+## Relationship with Overriding
+
+[`@targetName`](https://scala-lang.org/api/3.x/scala/annotation/targetName.html) annotations are significant for matching two method definitions to decide whether they conflict or override each other. Two method definitions match if they have the same name, signature, and erased name. Here,
+
+- The _signature_ of a definition consists of the names of the erased types of all (value-) parameters and the method's result type.
+- The _erased name_ of a method definition is its target name if a [`@targetName`](https://scala-lang.org/api/3.x/scala/annotation/targetName.html) annotation is given and its defined name otherwise.
+
+This means that `@targetName` annotations can be used to disambiguate two method definitions that would otherwise clash. For instance.
+
+```scala
+def f(x: => String): Int = x.length
+def f(x: => Int): Int = x + 1  // error: double definition
+```
+
+The two definitions above clash since their erased parameter types are both [`Function0`](https://scala-lang.org/api/3.x/scala/Function0.html), which is the type of the translation of a by-name-parameter. Hence they have the same names and signatures. But we can avoid the clash by adding a [`@targetName`](https://scala-lang.org/api/3.x/scala/annotation/targetName.html) annotation to either method or to both of them. Example:
+
+```scala
+@targetName("f_string")
+def f(x: => String): Int = x.length
+def f(x: => Int): Int = x + 1  // OK
+```
+
+This will produce methods `f_string` and `f` in the generated code.
+
+However, [`@targetName`](https://scala-lang.org/api/3.x/scala/annotation/targetName.html) annotations are not allowed to break overriding relationships
+between two definitions that have otherwise the same names and types. So the following would be in error:
+
+```scala
+import annotation.targetName
+class A:
+  def f(): Int = 1
+class B extends A:
+  @targetName("g") def f(): Int = 2
+```
+
+The compiler reports here:
+
+```
+-- Error: test.scala:6:23 ------------------------------------------------------
+6 |  @targetName("g") def f(): Int = 2
+  |                       ^
+  |error overriding method f in class A of type (): Int;
+  |  method f of type (): Int should not have a @targetName
+  |  annotation since the overridden member hasn't one either
+```
+
+The relevant overriding rules can be summarized as follows:
+
+- Two members can override each other if their names and signatures are the same,
+  and they either have the same erased names or the same types.
+- If two members override, then both their erased names and their types must be the same.
+
+As usual, any overriding relationship in the generated code must also
+be present in the original code. So the following example would also be in error:
+
+```scala
+import annotation.targetName
+class A:
+  def f(): Int = 1
+class B extends A:
+  @targetName("f") def g(): Int = 2
+```
+
+Here, the original methods `g` and `f` do not override each other since they have
+different names. But once we switch to target names, there is a clash that is reported by the compiler:
+
+```
+-- [E120] Naming Error: test.scala:4:6 -----------------------------------------
+4 |class B extends A:
+  |      ^
+  |      Name clash between defined and inherited member:
+  |      def f(): Int in class A at line 3 and
+  |      def g(): Int in class B at line 5
+  |      have the same name and type after erasure.
+1 error found
+```
diff --git a/docs/_spec/TODOreference/other-new-features/threadUnsafe-annotation.md b/docs/_spec/TODOreference/other-new-features/threadUnsafe-annotation.md
new file mode 100644
index 000000000000..ae1af1e4b671
--- /dev/null
+++ b/docs/_spec/TODOreference/other-new-features/threadUnsafe-annotation.md
@@ -0,0 +1,18 @@
+---
+layout: doc-page
+title: "The @threadUnsafe annotation"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/other-new-features/threadUnsafe-annotation.html
+---
+
+A new annotation [`@threadUnsafe`](https://scala-lang.org/api/3.x/scala/annotation/threadUnsafe.html) can be used on a field which defines
+a `lazy val`. When this annotation is used, the initialization of the
+[`lazy val`](../changed-features/lazy-vals-init.md) will use a faster mechanism which is not thread-safe.
+
+## Example
+
+```scala
+import scala.annotation.threadUnsafe
+
+class Hello:
+   @threadUnsafe lazy val x: Int = 1
+```
diff --git a/docs/_spec/TODOreference/other-new-features/trait-parameters.md b/docs/_spec/TODOreference/other-new-features/trait-parameters.md
new file mode 100644
index 000000000000..c704e73ce9b8
--- /dev/null
+++ b/docs/_spec/TODOreference/other-new-features/trait-parameters.md
@@ -0,0 +1,88 @@
+---
+layout: doc-page
+title: "Trait Parameters"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/other-new-features/trait-parameters.html
+---
+
+Scala 3 allows traits to have parameters, just like classes have parameters.
+
+```scala
+trait Greeting(val name: String):
+  def msg = s"How are you, $name"
+
+class C extends Greeting("Bob"):
+  println(msg)
+```
+
+Arguments to a trait are evaluated immediately before the trait is initialized.
+
+One potential issue with trait parameters is how to prevent
+ambiguities. For instance, you might try to extend `Greeting` twice,
+with different parameters.
+
+```scala
+class D extends C, Greeting("Bill") // error: parameter passed twice
+```
+
+Should this print "Bob" or "Bill"? In fact this program is illegal,
+because it violates the second rule of the following for trait parameters:
+
+ 1. If a class `C` extends a parameterized trait `T`, and its superclass does not, `C` _must_ pass arguments to `T`.
+
+ 2. If a class `C` extends a parameterized trait `T`, and its superclass does as well, `C` _must not_  pass arguments to `T`.
+
+ 3. Traits must never pass arguments to parent traits.
+
+Here's a trait extending the parameterized trait `Greeting`.
+
+```scala
+trait FormalGreeting extends Greeting:
+  override def msg = s"How do you do, $name"
+```
+As is required, no arguments are passed to `Greeting`. However, this poses an issue
+when defining a class that extends `FormalGreeting`:
+
+```scala
+class E extends FormalGreeting // error: missing arguments for `Greeting`.
+```
+
+The correct way to write `E` is to extend both `Greeting` and
+`FormalGreeting` (in either order):
+
+```scala
+class E extends Greeting("Bob"), FormalGreeting
+```
+
+## Traits With Context Parameters
+
+This "explicit extension required" rule is relaxed if the missing trait contains only
+[context parameters](../contextual/using-clauses.md). In that case the trait reference is
+implicitly inserted as an additional parent with inferred arguments. For instance,
+here's a variant of greetings where the addressee is a context parameter of type
+`ImpliedName`:
+
+```scala
+case class ImpliedName(name: String):
+  override def toString = name
+
+trait ImpliedGreeting(using val iname: ImpliedName):
+  def msg = s"How are you, $iname"
+
+trait ImpliedFormalGreeting extends ImpliedGreeting:
+  override def msg = s"How do you do, $iname"
+
+class F(using iname: ImpliedName) extends ImpliedFormalGreeting
+```
+
+The definition of `F` in the last line is implicitly expanded to
+```scala
+class F(using iname: ImpliedName) extends
+  Object,
+  ImpliedGreeting(using iname),
+  ImpliedFormalGreeting(using iname)
+```
+Note the inserted reference to the super trait `ImpliedGreeting`, which was not mentioned explicitly.
+
+## Reference
+
+For more information, see [Scala SIP 25](http://docs.scala-lang.org/sips/pending/trait-parameters.html).
diff --git a/docs/_spec/TODOreference/other-new-features/transparent-traits.md b/docs/_spec/TODOreference/other-new-features/transparent-traits.md
new file mode 100644
index 000000000000..699ce0b9ddd8
--- /dev/null
+++ b/docs/_spec/TODOreference/other-new-features/transparent-traits.md
@@ -0,0 +1,70 @@
+---
+layout: doc-page
+title: "Transparent Traits"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/other-new-features/transparent-traits.html
+---
+
+Traits are used in two roles:
+
+ 1. As mixins for other classes and traits
+ 2. As types of vals, defs, or parameters
+
+Some traits are used primarily in the first role, and we usually do not want to see them in inferred types. An example is the [`Product`](https://scala-lang.org/api/3.x/scala/Product.html) trait that the compiler adds as a mixin trait to every case class or case object. In Scala 2, this parent trait sometimes makes inferred types more complicated than they should be. Example:
+
+```scala
+trait Kind
+case object Var extends Kind
+case object Val extends Kind
+val x = Set(if condition then Val else Var)
+```
+
+Here, the inferred type of `x` is `Set[Kind & Product & Serializable]` whereas one would have hoped it to be `Set[Kind]`. The reasoning for this particular type to be inferred is as follows:
+
+- The type of the conditional above is the [union type](../new-types/union-types.md) `Val | Var`.
+- A union type is widened in type inference to the least supertype that is not a union type.
+  In the example, this type is `Kind & Product & Serializable` since all three traits are traits of both `Val` and `Var`.
+  So that type becomes the inferred element type of the set.
+
+Scala 3 allows one to mark a mixin trait as `transparent`, which means that it can be suppressed in type inference. Here's an example that follows the lines of the code above, but now with a new transparent trait `S` instead of `Product`:
+
+```scala
+transparent trait S
+trait Kind
+object Var extends Kind, S
+object Val extends Kind, S
+val x = Set(if condition then Val else Var)
+```
+
+Now `x` has inferred type `Set[Kind]`. The common transparent trait `S` does not
+appear in the inferred type.
+
+## Transparent Traits
+
+The traits [`scala.Product`](https://scala-lang.org/api/3.x/scala/Product.html), [`java.io.Serializable`](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/io/Serializable.html) and [`java.lang.Comparable`](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Comparable.html)
+are treated automatically as transparent. Other traits are turned into transparent traits using the modifier `transparent`. Scala 2 traits can also be made transparent
+by adding a [`@transparentTrait`](https://scala-lang.org/api/3.x/scala/annotation/transparentTrait.html) annotation. This annotation is defined in [`scala.annotation`](https://scala-lang.org/api/3.x/scala/annotation.html). It will be deprecated and phased out once Scala 2/3 interoperability is no longer needed.
+
+Typically, transparent traits are traits
+that influence the implementation of inheriting classes and traits that are not usually used as types by themselves. Two examples from the standard collection library are:
+
+- [`IterableOps`](https://scala-lang.org/api/3.x/scala/collection/IterableOps.html), which provides method implementations for an [`Iterable`](https://scala-lang.org/api/3.x/scala/collection/Iterable.html).
+- [`StrictOptimizedSeqOps`](https://scala-lang.org/api/3.x/scala/collection/StrictOptimizedSeqOps.html), which optimises some of these implementations for sequences with efficient indexing.
+
+Generally, any trait that is extended recursively is a good candidate to be
+declared transparent.
+
+## Rules for Inference
+
+Transparent traits can be given as explicit types as usual. But they are often elided when types are inferred. Roughly, the rules for type inference say that transparent traits are dropped from intersections where possible.
+
+The precise rules are as follows:
+
+- When inferring a type of a type variable, or the type of a val, or the return type of a def,
+- where that type is not higher-kinded,
+- and where `B` is its known upper bound or `Any` if none exists:
+- If the type inferred so far is of the form `T1 & ... & Tn` where
+  `n >= 1`, replace the maximal number of transparent `Ti`s  by `Any`, while ensuring that
+  the resulting type is still a subtype of the bound `B`.
+- However, do not perform this widening if all transparent traits `Ti` can get replaced in that way.
+
+The last clause ensures that a single transparent trait instance such as [`Product`](https://scala-lang.org/api/3.x/scala/Product.html) is not widened to [`Any`](https://scala-lang.org/api/3.x/scala/Any.html). Transparent trait instances are only dropped when they appear in conjunction with some other type.
diff --git a/docs/_spec/TODOreference/other-new-features/type-test.md b/docs/_spec/TODOreference/other-new-features/type-test.md
new file mode 100644
index 000000000000..ec7a87230753
--- /dev/null
+++ b/docs/_spec/TODOreference/other-new-features/type-test.md
@@ -0,0 +1,181 @@
+---
+layout: doc-page
+title: "TypeTest"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/other-new-features/type-test.html
+---
+
+## TypeTest
+
+When pattern matching there are two situations where a runtime type test must be performed.
+The first case is an explicit type test using the ascription pattern notation.
+
+```scala
+(x: X) match
+  case y: Y =>
+```
+
+The second case is when an extractor takes an argument that is not a subtype of the scrutinee type.
+
+```scala
+(x: X) match
+  case y @ Y(n) =>
+
+object Y:
+  def unapply(x: Y): Some[Int] = ...
+```
+
+In both cases, a class test will be performed at runtime.
+But when the type test is on an abstract type (type parameter or type member), the test cannot be performed because the type is erased at runtime.
+
+A [`TypeTest`](https://scala-lang.org/api/3.x/scala/reflect/TypeTest.html) can be provided to make this test possible.
+
+```scala
+package scala.reflect
+
+trait TypeTest[-S, T]:
+  def unapply(s: S): Option[s.type & T]
+```
+
+It provides an extractor that returns its argument typed as a `T` if the argument is a `T`.
+It can be used to encode a type test.
+
+```scala
+def f[X, Y](x: X)(using tt: TypeTest[X, Y]): Option[Y] = x match
+  case tt(x @ Y(1)) => Some(x)
+  case tt(x) => Some(x)
+  case _ => None
+```
+
+To avoid the syntactic overhead the compiler will look for a type test automatically if it detects that the type test is on abstract types.
+This means that `x: Y` is transformed to `tt(x)` and `x @ Y(_)` to `tt(x @ Y(_))` if there is a contextual `TypeTest[X, Y]` in scope.
+The previous code is equivalent to
+
+```scala
+def f[X, Y](x: X)(using TypeTest[X, Y]): Option[Y] = x match
+  case x @ Y(1) => Some(x)
+  case x: Y => Some(x)
+  case _ => None
+```
+
+We could create a type test at call site where the type test can be performed with runtime class tests directly as follows
+
+```scala
+val tt: TypeTest[Any, String] =
+  new TypeTest[Any, String]:
+    def unapply(s: Any): Option[s.type & String] = s match
+      case s: String => Some(s)
+      case _ => None
+
+f[AnyRef, String]("acb")(using tt)
+```
+
+The compiler will synthesize a new instance of a type test if none is found in scope as:
+
+```scala
+new TypeTest[A, B]:
+  def unapply(s: A): Option[s.type & B] = s match
+    case s: B => Some(s)
+    case _ => None
+```
+
+If the type tests cannot be done there will be an unchecked warning that will be raised on the `case s: B =>` test.
+
+The most common [`TypeTest`](https://scala-lang.org/api/3.x/scala/reflect/TypeTest.html) instances are the ones that take any parameters (i.e. `TypeTest[Any, T]`).
+To make it possible to use such instances directly in context bounds we provide the alias
+
+```scala
+package scala.reflect
+
+type Typeable[T] = TypeTest[Any, T]
+```
+
+This alias can be used as
+
+```scala
+def f[T: Typeable]: Boolean =
+  "abc" match
+    case x: T => true
+    case _ => false
+
+f[String] // true
+f[Int] // false
+```
+
+## TypeTest and ClassTag
+
+[`TypeTest`](https://scala-lang.org/api/3.x/scala/reflect/TypeTest.html) is a replacement for functionality provided previously by `ClassTag.unapply`.
+Using [`ClassTag`](https://scala-lang.org/api/3.x/scala/reflect/ClassTag.html) instances was unsound since classtags can check only the class component of a type.
+[`TypeTest`](https://scala-lang.org/api/3.x/scala/reflect/TypeTest.html) fixes that unsoundness.
+[`ClassTag`](https://scala-lang.org/api/3.x/scala/reflect/ClassTag.html) type tests are still supported but a warning will be emitted after 3.0.
+
+
+## Example
+
+Given the following abstract definition of Peano numbers that provides two given instances of types `TypeTest[Nat, Zero]` and `TypeTest[Nat, Succ]`
+
+```scala
+import scala.reflect.*
+
+trait Peano:
+  type Nat
+  type Zero <: Nat
+  type Succ <: Nat
+
+  def safeDiv(m: Nat, n: Succ): (Nat, Nat)
+
+  val Zero: Zero
+
+  val Succ: SuccExtractor
+  trait SuccExtractor:
+    def apply(nat: Nat): Succ
+    def unapply(succ: Succ): Some[Nat]
+
+  given typeTestOfZero: TypeTest[Nat, Zero]
+  given typeTestOfSucc: TypeTest[Nat, Succ]
+```
+
+together with an implementation of Peano numbers based on type `Int`
+
+```scala
+object PeanoInt extends Peano:
+  type Nat  = Int
+  type Zero = Int
+  type Succ = Int
+
+  def safeDiv(m: Nat, n: Succ): (Nat, Nat) = (m / n, m % n)
+
+  val Zero: Zero = 0
+
+  val Succ: SuccExtractor = new:
+    def apply(nat: Nat): Succ = nat + 1
+    def unapply(succ: Succ) = Some(succ - 1)
+
+  def typeTestOfZero: TypeTest[Nat, Zero] = new:
+    def unapply(x: Nat): Option[x.type & Zero] =
+      if x == 0 then Some(x) else None
+
+  def typeTestOfSucc: TypeTest[Nat, Succ] = new:
+    def unapply(x: Nat): Option[x.type & Succ] =
+      if x > 0 then Some(x) else None
+```
+
+it is possible to write the following program
+
+```scala
+@main def test =
+  import PeanoInt.*
+
+  def divOpt(m: Nat, n: Nat): Option[(Nat, Nat)] =
+    n match
+      case Zero => None
+      case s @ Succ(_) => Some(safeDiv(m, s))
+
+  val two = Succ(Succ(Zero))
+  val five = Succ(Succ(Succ(two)))
+
+  println(divOpt(five, two))  // prints "Some((2,1))"
+  println(divOpt(two, five))  // prints "Some((0,2))"
+  println(divOpt(two, Zero))  // prints "None"
+```
+
+Note that without the `TypeTest[Nat, Succ]` the pattern `Succ.unapply(nat: Succ)` would be unchecked.
diff --git a/docs/_spec/TODOreference/overview.md b/docs/_spec/TODOreference/overview.md
new file mode 100644
index 000000000000..b1e8281dfc16
--- /dev/null
+++ b/docs/_spec/TODOreference/overview.md
@@ -0,0 +1,155 @@
+---
+layout: doc-page
+title: "Reference"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/overview.html
+redirectFrom: overview.html
+---
+
+Scala 3 implements many language changes and improvements over Scala 2.
+In this reference, we discuss design decisions and present important differences compared to Scala 2.
+
+## Goals
+
+The language redesign was guided by three main goals:
+
+- Strengthen Scala's foundations.
+  Make the full programming language compatible with the foundational work on the
+  [DOT calculus](https://infoscience.epfl.ch/record/227176/files/soundness_oopsla16.pdf)
+  and apply the lessons learned from that work.
+- Make Scala easier and safer to use.
+  Tame powerful constructs such as implicits to provide a gentler learning curve. Remove warts and puzzlers.
+- Further improve the consistency and expressiveness of Scala's language constructs.
+
+Corresponding to these goals, the language changes fall into seven categories:
+(1) Core constructs to strengthen foundations, (2) simplifications and (3) [restrictions](#restrictions), to make the language easier and safer to use, (4) [dropped constructs](#dropped-constructs) to make the language smaller and more regular, (5) [changed constructs](#changes) to remove warts, and increase consistency and usability, (6) [new constructs](#new-constructs) to fill gaps and increase expressiveness, (7) a new, principled approach to metaprogramming that replaces [Scala 2 experimental macros](https://docs.scala-lang.org/overviews/macros/overview.html).
+
+## Essential Foundations
+
+These new constructs directly model core features of DOT, higher-kinded types, and the [SI calculus for implicit resolution](https://infoscience.epfl.ch/record/229878/files/simplicitly_1.pdf).
+
+- [Intersection types](new-types/intersection-types.md), replacing compound types,
+- [Union types](new-types/union-types.md),
+- [Type lambdas](new-types/type-lambdas.md), replacing encodings using structural types and type projection.
+- [Context functions](contextual/context-functions.md), offering abstraction over given parameters.
+
+## Simplifications
+
+These constructs replace existing constructs with the aim of making the language safer and simpler to use, and to promote uniformity in code style.
+
+- [Trait parameters](other-new-features/trait-parameters.md)
+  replace [early initializers](dropped-features/early-initializers.md) with a more generally useful construct.
+- [Given instances](contextual/givens.md)
+  replace implicit objects and defs, focussing on intent over mechanism.
+- [Using clauses](contextual/using-clauses.md)
+  replace implicit parameters, avoiding their ambiguities.
+- [Extension methods](contextual/extension-methods.md)
+  replace implicit classes with a clearer and simpler mechanism.
+- [Opaque type aliases](other-new-features/opaques.md)
+  replace most uses of value classes while guaranteeing the absence of boxing.
+- [Top-level definitions](dropped-features/package-objects.md)
+  replace package objects, dropping syntactic boilerplate.
+- [Export clauses](other-new-features/export.md)
+  provide a simple and general way to express aggregation, which can replace
+  the previous facade pattern of package objects inheriting from classes.
+- [Vararg splices](changed-features/vararg-splices.md)
+  now use the form `xs*` in function arguments and patterns instead of `xs: _*` and `xs @ _*`,
+- [Universal apply methods](other-new-features/creator-applications.md)
+  allow using simple function call syntax instead of `new` expressions. `new` expressions stay around
+  as a fallback for the cases where creator applications cannot be used.
+
+With the exception of [early initializers](dropped-features/early-initializers.md) and old-style vararg patterns, all superseded constructs continue to be available in Scala 3.0. The plan is to deprecate and phase them out later.
+
+Value classes (superseded by opaque type aliases) are a special case. There are currently no deprecation plans for value classes, since we might bring them back in a more general form if they are supported natively by the JVM as is planned by [project Valhalla](https://openjdk.java.net/projects/valhalla/).
+
+## Restrictions
+
+These constructs are restricted to make the language safer.
+
+- [Implicit Conversions](contextual/conversions.md):
+  there is only one way to define implicit conversions instead of many, and potentially surprising implicit conversions require a language import.
+- [Given Imports](contextual/given-imports.md):
+  implicits now require a special form of import, to make the import clearly visible.
+- [Type Projection](dropped-features/type-projection.md):
+  only classes can be used as prefix `C` of a type projection `C#A`. Type projection on abstract types is no longer supported since it is unsound.
+- [Multiversal Equality](contextual/multiversal-equality.md):
+  implement an "opt-in" scheme to rule out nonsensical comparisons with `==` and `!=`.
+- [infix](changed-features/operators.md):
+  make method application syntax uniform across code bases.
+
+Unrestricted implicit conversions continue to be available in Scala 3.0, but will be deprecated and removed later. Unrestricted versions of the other constructs in the list above are available only under `-source 3.0-migration`.
+
+## Dropped Constructs
+
+These constructs are proposed to be dropped without a new construct replacing them. The motivation for dropping these constructs is to simplify the language and its implementation.
+
+- [DelayedInit](dropped-features/delayed-init.md),
+- [Existential types](dropped-features/existential-types.md),
+- [Procedure syntax](dropped-features/procedure-syntax.md),
+- [Class shadowing](dropped-features/class-shadowing.md),
+- [XML literals](dropped-features/xml.md),
+- [Symbol literals](dropped-features/symlits.md),
+- [Auto application](dropped-features/auto-apply.md),
+- [Weak conformance](dropped-features/weak-conformance.md),
+- Compound types (replaced by [Intersection types](new-types/intersection-types.md)),
+- [Auto tupling](https://github.com/lampepfl/dotty/pull/4311) (implemented, but not merged).
+
+The date when these constructs are dropped varies. The current status is:
+
+- Not implemented at all:
+    - DelayedInit, existential types, weak conformance.
+- Supported under `-source 3.0-migration`:
+    - procedure syntax, class shadowing, symbol literals, auto application, auto tupling in a restricted form.
+- Supported in 3.0, to be deprecated and phased out later:
+    - [XML literals](dropped-features/xml.md), compound types.
+
+## Changes
+
+These constructs have undergone changes to make them more regular and useful.
+
+- [Structural Types](changed-features/structural-types.md):
+  They now allow pluggable implementations, which greatly increases their usefulness. Some usage patterns are restricted compared to the status quo.
+- [Name-based pattern matching](changed-features/pattern-matching.md):
+  The existing undocumented Scala 2 implementation has been codified in a slightly simplified form.
+- [Automatic Eta expansion](changed-features/eta-expansion.md):
+  Eta expansion is now performed universally also in the absence of an expected type. The postfix `_` operator is thus made redundant. It will be deprecated and dropped after Scala 3.0.
+- [Implicit Resolution](changed-features/implicit-resolution.md):
+  The implicit resolution rules have been cleaned up to make them more useful and less surprising. Implicit scope is restricted to no longer include package prefixes.
+
+Most aspects of old-style implicit resolution are still available under `-source 3.0-migration`. The other changes in this list are applied unconditionally.
+
+## New Constructs
+
+These are additions to the language that make it more powerful or pleasant to use.
+
+- [Enums](enums/enums.md) provide concise syntax for enumerations and [algebraic data types](enums/adts.md).
+- [Parameter untupling](other-new-features/parameter-untupling.md) avoids having to use `case` for tupled parameter destructuring.
+- [Dependent function types](new-types/dependent-function-types.md) generalize dependent methods to dependent function values and types.
+- [Polymorphic function types](new-types/polymorphic-function-types.md) generalize polymorphic methods to polymorphic function values and types.
+  _Current status_: There is a proposal and a merged prototype implementation, but the implementation has not been finalized (it is notably missing type inference support).
+- [Kind polymorphism](other-new-features/kind-polymorphism.md) allows the definition of operators working equally on types and type constructors.
+- [`@targetName` annotations](other-new-features/targetName.md) make it easier to interoperate with code written in other languages and give more flexibility for avoiding name clashes.
+
+## Metaprogramming
+
+The following constructs together aim to put metaprogramming in Scala on a new basis. So far, metaprogramming was achieved by a combination of macros and libraries such as [Shapeless](https://github.com/milessabin/shapeless) that were in turn based on some key macros. Current Scala 2 macro mechanisms are a thin veneer on top of the current Scala 2 compiler, which makes them fragile and in many cases impossible to port to Scala 3.
+
+It's worth noting that macros were never included in the [Scala 2 language specification](https://scala-lang.org/files/archive/spec/2.13/) and were so far made available only under an `-experimental` flag. This has not prevented their widespread usage.
+
+To enable porting most uses of macros, we are experimenting with the advanced language constructs listed below. These designs are more provisional than the rest of the proposed language constructs for Scala 3.0. There might still be some changes until the final release. Stabilizing the feature set needed for metaprogramming is our first priority.
+
+- [Match Types](new-types/match-types.md)
+  allow computation on types.
+- [Inline](metaprogramming/inline.md)
+  provides by itself a straightforward implementation of some simple macros and is at the same time an essential building block for the implementation of complex macros.
+- [Quotes and Splices](metaprogramming/macros.md)
+  provide a principled way to express macros and staging with a unified set of abstractions.
+- [Type class derivation](contextual/derivation.md)
+  provides an in-language implementation of the `Gen` macro in Shapeless and other foundational libraries. The new implementation is more robust, efficient and easier to use than the macro.
+- [By-name context parameters](contextual/by-name-context-parameters.md)
+  provide a more robust in-language implementation of the `Lazy` macro in [Shapeless](https://github.com/milessabin/shapeless).
+
+## See Also
+
+[A classification of proposed language features](./features-classification.md) is
+an expanded version of this page that adds the status (i.e. relative importance to be a part of Scala 3, and relative urgency when to decide this) and expected migration cost
+of each language construct.
diff --git a/docs/_spec/TODOreference/soft-modifier.md b/docs/_spec/TODOreference/soft-modifier.md
new file mode 100644
index 000000000000..c1329ebab1f0
--- /dev/null
+++ b/docs/_spec/TODOreference/soft-modifier.md
@@ -0,0 +1,27 @@
+---
+layout: doc-page
+title: "Soft Keywords"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/soft-modifier.html
+---
+
+A soft modifier is one of the identifiers `infix`, `inline`, `opaque`, `open` and `transparent`.
+
+A soft keyword is a soft modifier, or one of `as`, `derives`, `end`, `extension`, `throws`, `using`, `|`, `+`, `-`, `*`
+
+A soft modifier is treated as potential modifier of a definition if it is followed by a hard modifier or a keyword combination starting a definition (`def`, `val`, `var`, `type`, `given`, `class`, `trait`, `object`, `enum`, `case class`, `case object`). Between the two words there may be a sequence of newline tokens and soft modifiers.
+
+Otherwise, soft keywords are treated specially in the following situations:
+
+ - `inline`, if it is followed by any token that can start an expression.
+ - `derives`, if it appears after an extension clause or after
+   the name and possibly parameters of a class, trait, object, or enum definition.
+ - `end`, if it appears at the start of a line following a statement (i.e. definition or toplevel expression)
+ - `extension`, if it appears at the start of a statement and is followed by `(` or `[`.
+ - `using`, if it appears at the start of a parameter or argument list.
+ - `as`, in a renaming import clause
+ - `|`, if it separates two patterns in an alternative.
+ - `+`, `-`, if they appear in front of a type parameter.
+ - `*`, in a wildcard import, or it follows the type of a parameter, or if it appears in
+   a vararg splice `x*`.
+
+Everywhere else a soft keyword is treated as a normal identifier.
diff --git a/docs/_spec/TODOreference/syntax.md b/docs/_spec/TODOreference/syntax.md
new file mode 100644
index 000000000000..e11629c8eaf9
--- /dev/null
+++ b/docs/_spec/TODOreference/syntax.md
@@ -0,0 +1,472 @@
+---
+layout: doc-page
+title: "Scala 3 Syntax Summary"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/syntax.html
+---
+
+<!--
+
+This page has a companion page at _docs/internals/syntax.md.
+
+!! Make sure to edit both pages in sync. !!
+
+reference/syntax.md shows the official Scala 3 syntax, without deprecated or experimental features.
+
+internals/syntax.md shows the Scala 3 syntax as supported by the parser, including
+deprecated and experimental features. It also gives some indications how
+productions map to AST nodes.
+
+-->
+
+The following description of Scala tokens uses literal characters `‘c’` when
+referring to the ASCII fragment `\u0000` – `\u007F`.
+
+_Unicode escapes_ are used to represent the [Unicode character](https://www.w3.org/International/articles/definitions-characters/) with the given
+hexadecimal code:
+
+```
+UnicodeEscape ::= ‘\’ ‘u’ {‘u’} hexDigit hexDigit hexDigit hexDigit
+hexDigit      ::= ‘0’ | … | ‘9’ | ‘A’ | … | ‘F’ | ‘a’ | … | ‘f’
+```
+
+Informal descriptions are typeset as `“some comment”`.
+
+## Lexical Syntax
+
+The lexical syntax of Scala is given by the following grammar in EBNF
+form.
+
+```
+whiteSpace       ::=  ‘\u0020’ | ‘\u0009’ | ‘\u000D’ | ‘\u000A’
+upper            ::=  ‘A’ | … | ‘Z’ | ‘\$’ | ‘_’  “… and Unicode category Lu”
+lower            ::=  ‘a’ | … | ‘z’ “… and Unicode category Ll”
+letter           ::=  upper | lower “… and Unicode categories Lo, Lt, Nl”
+digit            ::=  ‘0’ | … | ‘9’
+paren            ::=  ‘(’ | ‘)’ | ‘[’ | ‘]’ | ‘{’ | ‘}’
+delim            ::=  ‘`’ | ‘'’ | ‘"’ | ‘.’ | ‘;’ | ‘,’
+opchar           ::=  ‘!’ | ‘#’ | ‘%’ | ‘&’ | ‘*’ | ‘+’ | ‘-’ | ‘/’ | ‘:’ |
+                      ‘<’ | ‘=’ | ‘>’ | ‘?’ | ‘@’ | ‘\’ | ‘^’ | ‘|’ | ‘~’
+                      “… and Unicode categories Sm, So”
+printableChar    ::=  “all characters in [\u0020, \u007E] inclusive”
+charEscapeSeq    ::=  ‘\’ (‘b’ | ‘t’ | ‘n’ | ‘f’ | ‘r’ | ‘"’ | ‘'’ | ‘\’)
+
+op               ::=  opchar {opchar}
+varid            ::=  lower idrest
+alphaid          ::=  upper idrest
+                   |  varid
+plainid          ::=  alphaid
+                   |  op
+id               ::=  plainid
+                   |  ‘`’ { charNoBackQuoteOrNewline | UnicodeEscape | charEscapeSeq } ‘`’
+idrest           ::=  {letter | digit} [‘_’ op]
+quoteId          ::=  ‘'’ alphaid
+spliceId         ::=  ‘$’ alphaid ;
+
+integerLiteral   ::=  (decimalNumeral | hexNumeral) [‘L’ | ‘l’]
+decimalNumeral   ::=  ‘0’ | nonZeroDigit [{digit | ‘_’} digit]
+hexNumeral       ::=  ‘0’ (‘x’ | ‘X’) hexDigit [{hexDigit | ‘_’} hexDigit]
+nonZeroDigit     ::=  ‘1’ | … | ‘9’
+
+floatingPointLiteral
+                 ::=  [decimalNumeral] ‘.’ digit [{digit | ‘_’} digit] [exponentPart] [floatType]
+                   |  decimalNumeral exponentPart [floatType]
+                   |  decimalNumeral floatType
+exponentPart     ::=  (‘E’ | ‘e’) [‘+’ | ‘-’] digit [{digit | ‘_’} digit]
+floatType        ::=  ‘F’ | ‘f’ | ‘D’ | ‘d’
+
+booleanLiteral   ::=  ‘true’ | ‘false’
+
+characterLiteral ::=  ‘'’ (printableChar | charEscapeSeq) ‘'’
+
+stringLiteral    ::=  ‘"’ {stringElement} ‘"’
+                   |  ‘"""’ multiLineChars ‘"""’
+stringElement    ::=  printableChar \ (‘"’ | ‘\’)
+                   |  UnicodeEscape
+                   |  charEscapeSeq
+multiLineChars   ::=  {[‘"’] [‘"’] char \ ‘"’} {‘"’}
+processedStringLiteral
+                 ::=  alphaid ‘"’ {[‘\’] processedStringPart | ‘\\’ | ‘\"’} ‘"’
+                   |  alphaid ‘"""’ {[‘"’] [‘"’] char \ (‘"’ | ‘$’) | escape} {‘"’} ‘"""’
+processedStringPart
+                 ::= printableChar \ (‘"’ | ‘$’ | ‘\’) | escape
+escape           ::=  ‘$$’
+                   |  ‘$’ letter { letter | digit }
+                   |  ‘{’ Block  [‘;’ whiteSpace stringFormat whiteSpace] ‘}’
+stringFormat     ::=  {printableChar \ (‘"’ | ‘}’ | ‘ ’ | ‘\t’ | ‘\n’)}
+
+symbolLiteral    ::=  ‘'’ plainid // until 2.13
+
+comment          ::=  ‘/*’ “any sequence of characters; nested comments are allowed” ‘*/’
+                   |  ‘//’ “any sequence of characters up to end of line”
+
+nl               ::=  “new line character”
+semi             ::=  ‘;’ |  nl {nl}
+```
+
+## Optional Braces
+
+The lexical analyzer also inserts `indent` and `outdent` tokens that represent regions of indented code [at certain points](./other-new-features/indentation.md).
+
+In the context-free productions below we use the notation `<<< ts >>>`
+to indicate a token sequence `ts` that is either enclosed in a pair of braces `{ ts }` or that constitutes an indented region `indent ts outdent`. Analogously, the
+notation `:<<< ts >>>` indicates a token sequence `ts` that is either enclosed in a pair of braces `{ ts }` or that constitutes an indented region `indent ts outdent` that follows
+a `colon` token.
+
+A `colon` token reads as the standard colon "`:`" but is generated instead of it where `colon` is legal according to the context free syntax, but only if the previous token
+is an alphanumeric identifier, a backticked identifier, or one of the tokens `this`, `super`, `new`, "`)`", and "`]`".
+
+```
+colon         ::=  ':'    -- with side conditions explained above
+ <<< ts >>>   ::=  ‘{’ ts ‘}’
+                |  indent ts outdent
+:<<< ts >>>   ::=  [nl] ‘{’ ts ‘}’
+                |  colon indent ts outdent
+```
+
+## Keywords
+
+### Regular keywords
+
+```
+abstract  case      catch     class     def       do        else
+enum      export    extends   false     final     finally   for
+given     if        implicit  import    lazy      match     new
+null      object    override  package   private   protected return
+sealed    super     then      throw     trait     true      try
+type      val       var       while     with      yield
+:         =         <-        =>        <:        >:        #
+@         =>>       ?=>
+```
+
+### Soft keywords
+
+```
+as  derives  end  extension  infix  inline  opaque  open  transparent  using  |  *  +  -
+```
+
+See the [separate section on soft keywords](./soft-modifier.md) for additional
+details on where a soft keyword is recognized.
+
+## Context-free Syntax
+
+The context-free syntax of Scala is given by the following EBNF
+grammar:
+
+### Literals and Paths
+```
+SimpleLiteral     ::=  [‘-’] integerLiteral
+                    |  [‘-’] floatingPointLiteral
+                    |  booleanLiteral
+                    |  characterLiteral
+                    |  stringLiteral
+Literal           ::=  SimpleLiteral
+                    |  processedStringLiteral
+                    |  symbolLiteral
+                    |  ‘null’
+
+QualId            ::=  id {‘.’ id}
+ids               ::=  id {‘,’ id}
+
+SimpleRef         ::=  id
+                    |  [id ‘.’] ‘this’
+                    |  [id ‘.’] ‘super’ [ClassQualifier] ‘.’ id
+
+ClassQualifier    ::=  ‘[’ id ‘]’
+```
+
+### Types
+```
+Type              ::=  FunType
+                    |  HkTypeParamClause ‘=>>’ Type
+                    |  FunParamClause ‘=>>’ Type
+                    |  MatchType
+                    |  InfixType
+FunType           ::=  FunTypeArgs (‘=>’ | ‘?=>’) Type
+                    |  HKTypeParamClause '=>' Type
+FunTypeArgs       ::=  InfixType
+                    |  ‘(’ [ FunArgTypes ] ‘)’
+                    |  FunParamClause
+FunParamClause    ::=  ‘(’ TypedFunParam {‘,’ TypedFunParam } ‘)’
+TypedFunParam     ::=  id ‘:’ Type
+MatchType         ::=  InfixType `match` <<< TypeCaseClauses >>>
+InfixType         ::=  RefinedType {id [nl] RefinedType}
+RefinedType       ::=  AnnotType {[nl] Refinement}
+AnnotType         ::=  SimpleType {Annotation}
+
+SimpleType        ::=  SimpleLiteral
+                    |  ‘?’ TypeBounds
+                    |  id
+                    |  Singleton ‘.’ id
+                    |  Singleton ‘.’ ‘type’
+                    |  ‘(’ Types ‘)’
+                    |  Refinement
+                    |  SimpleType1 TypeArgs
+                    |  SimpleType1 ‘#’ id
+Singleton         ::=  SimpleRef
+                    |  SimpleLiteral
+                    |  Singleton ‘.’ id
+
+FunArgType        ::=  Type
+                    |  ‘=>’ Type
+FunArgTypes       ::=  FunArgType { ‘,’ FunArgType }
+ParamType         ::=  [‘=>’] ParamValueType
+ParamValueType    ::=  Type [‘*’]
+TypeArgs          ::=  ‘[’ Types ‘]’
+Refinement        ::=  :<<< [RefineDcl] {semi [RefineDcl]} >>>
+TypeBounds        ::=  [‘>:’ Type] [‘<:’ Type]
+TypeParamBounds   ::=  TypeBounds {‘:’ Type}
+Types             ::=  Type {‘,’ Type}
+```
+
+### Expressions
+```
+Expr              ::=  FunParams (‘=>’ | ‘?=>’) Expr
+                    |  HkTypeParamClause ‘=>’ Expr
+                    |  Expr1
+BlockResult       ::=  FunParams (‘=>’ | ‘?=>’) Block
+                    |  HkTypeParamClause ‘=>’ Block
+                    |  Expr1
+FunParams         ::=  Bindings
+                    |  id
+                    |  ‘_’
+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
+                    |  SimpleExpr ArgumentExprs ‘=’ Expr
+                    |  PostfixExpr [Ascription]
+                    |  ‘inline’ InfixExpr MatchClause
+Ascription        ::=  ‘:’ InfixType
+                    |  ‘:’ Annotation {Annotation}
+Catches           ::=  ‘catch’ (Expr | ExprCaseClause)
+PostfixExpr       ::=  InfixExpr [id]                                          -- only if language.postfixOperators is enabled
+InfixExpr         ::=  PrefixExpr
+                    |  InfixExpr id [nl] InfixExpr
+                    |  InfixExpr MatchClause
+MatchClause       ::=  ‘match’ <<< CaseClauses >>>
+PrefixExpr        ::=  [PrefixOperator] SimpleExpr
+PrefixOperator    ::=  ‘-’ | ‘+’ | ‘~’ | ‘!’                                    -- unless backquoted
+SimpleExpr        ::=  SimpleRef
+                    |  Literal
+                    |  ‘_’
+                    |  BlockExpr
+                    |  ExprSplice
+                    |  Quoted
+                    |  quoteId                                                  -- only inside splices
+                    |  ‘new’ ConstrApp {‘with’ ConstrApp} [TemplateBody]
+                    |  ‘new’ TemplateBody
+                    |  ‘(’ ExprsInParens ‘)’
+                    |  SimpleExpr ‘.’ id
+                    |  SimpleExpr ‘.’ MatchClause
+                    |  SimpleExpr TypeArgs
+                    |  SimpleExpr ArgumentExprs
+Quoted            ::=  ‘'’ ‘{’ Block ‘}’
+                    |  ‘'’ ‘[’ Type ‘]’
+ExprSplice        ::= spliceId                                                  -- if inside quoted block
+                    |  ‘$’ ‘{’ Block ‘}’                                        -- unless inside quoted pattern
+                    |  ‘$’ ‘{’ Pattern ‘}’                                      -- when inside quoted pattern
+ExprsInParens     ::=  ExprInParens {‘,’ ExprInParens}
+ExprInParens      ::=  PostfixExpr ‘:’ Type
+                    |  Expr
+ParArgumentExprs  ::=  ‘(’ [ExprsInParens] ‘)’
+                    |  ‘(’ ‘using’ ExprsInParens ‘)’
+                    |  ‘(’ [ExprsInParens ‘,’] PostfixExpr ‘*’ ‘)’
+ArgumentExprs     ::=  ParArgumentExprs
+                    |  BlockExpr
+BlockExpr         ::=  <<< (CaseClauses | Block) >>>
+Block             ::=  {BlockStat semi} [BlockResult]
+BlockStat         ::=  Import
+                    |  {Annotation {nl}} {LocalModifier} Def
+                    |  Extension
+                    |  Expr1
+                    |  EndMarker
+
+ForExpr           ::=  ‘for’ ‘(’ Enumerators0 ‘)’ {nl} [‘do‘ | ‘yield’] Expr
+                    |  ‘for’ ‘{’ Enumerators0 ‘}’ {nl} [‘do‘ | ‘yield’] Expr
+                    |  ‘for’     Enumerators0          (‘do‘ | ‘yield’) Expr
+Enumerators0      ::=  {nl} Enumerators [semi]
+Enumerators       ::=  Generator {semi Enumerator | Guard}
+Enumerator        ::=  Generator
+                    |  Guard {Guard}
+                    |  Pattern1 ‘=’ Expr
+Generator         ::=  [‘case’] Pattern1 ‘<-’ Expr
+Guard             ::=  ‘if’ PostfixExpr
+
+CaseClauses       ::=  CaseClause { CaseClause }
+CaseClause        ::=  ‘case’ Pattern [Guard] ‘=>’ Block
+ExprCaseClause    ::=  ‘case’ Pattern [Guard] ‘=>’ Expr
+TypeCaseClauses   ::=  TypeCaseClause { TypeCaseClause }
+TypeCaseClause    ::=  ‘case’ (InfixType | ‘_’) ‘=>’ Type [semi]
+
+Pattern           ::=  Pattern1 { ‘|’ Pattern1 }
+Pattern1          ::=  Pattern2 [‘:’ RefinedType]
+Pattern2          ::=  [id ‘@’] InfixPattern [‘*’]
+InfixPattern      ::=  SimplePattern { id [nl] SimplePattern }
+SimplePattern     ::=  PatVar
+                    |  Literal
+                    |  ‘(’ [Patterns] ‘)’
+                    |  Quoted
+                    |  SimplePattern1 [TypeArgs] [ArgumentPatterns]
+                    |  ‘given’ RefinedType
+SimplePattern1    ::=  SimpleRef
+                    |  SimplePattern1 ‘.’ id
+PatVar            ::=  varid
+                    |  ‘_’
+Patterns          ::=  Pattern {‘,’ Pattern}
+ArgumentPatterns  ::=  ‘(’ [Patterns] ‘)’
+                    |  ‘(’ [Patterns ‘,’] PatVar ‘*’ ‘)’
+```
+
+### Type and Value Parameters
+```
+ClsTypeParamClause::=  ‘[’ ClsTypeParam {‘,’ ClsTypeParam} ‘]’
+ClsTypeParam      ::=  {Annotation} [‘+’ | ‘-’] id [HkTypeParamClause] TypeParamBounds
+
+DefTypeParamClause::=  ‘[’ DefTypeParam {‘,’ DefTypeParam} ‘]’
+DefTypeParam      ::=  {Annotation} id [HkTypeParamClause] TypeParamBounds
+
+TypTypeParamClause::=  ‘[’ TypTypeParam {‘,’ TypTypeParam} ‘]’
+TypTypeParam      ::=  {Annotation} id [HkTypeParamClause] TypeBounds
+
+HkTypeParamClause ::=  ‘[’ HkTypeParam {‘,’ HkTypeParam} ‘]’
+HkTypeParam       ::=  {Annotation} [‘+’ | ‘-’] (id [HkTypeParamClause] | ‘_’) TypeBounds
+
+ClsParamClauses   ::=  {ClsParamClause} [[nl] ‘(’ [‘implicit’] ClsParams ‘)’]
+ClsParamClause    ::=  [nl] ‘(’ ClsParams ‘)’
+                    |  [nl] ‘(’ ‘using’ (ClsParams | FunArgTypes) ‘)’
+ClsParams         ::=  ClsParam {‘,’ ClsParam}
+ClsParam          ::=  {Annotation} [{Modifier} (‘val’ | ‘var’) | ‘inline’] Param
+Param             ::=  id ‘:’ ParamType [‘=’ Expr]
+
+DefParamClauses   ::=  {DefParamClause} [[nl] ‘(’ [‘implicit’] DefParams ‘)’]
+DefParamClause    ::=  [nl] ‘(’ DefParams ‘)’ | UsingParamClause
+UsingParamClause  ::=  [nl] ‘(’ ‘using’ (DefParams | FunArgTypes) ‘)’
+DefParams         ::=  DefParam {‘,’ DefParam}
+DefParam          ::=  {Annotation} [‘inline’] Param
+```
+
+### Bindings and Imports
+```
+Bindings          ::=  ‘(’ [Binding {‘,’ Binding}] ‘)’
+Binding           ::=  (id | ‘_’) [‘:’ Type]
+
+Modifier          ::=  LocalModifier
+                    |  AccessModifier
+                    |  ‘override’
+                    |  ‘opaque’
+LocalModifier     ::=  ‘abstract’
+                    |  ‘final’
+                    |  ‘sealed’
+                    |  ‘open’
+                    |  ‘implicit’
+                    |  ‘lazy’
+                    |  ‘inline’
+AccessModifier    ::=  (‘private’ | ‘protected’) [AccessQualifier]
+AccessQualifier   ::=  ‘[’ id ‘]’
+
+Annotation        ::=  ‘@’ SimpleType1 {ParArgumentExprs}
+
+Import            ::=  ‘import’ ImportExpr {‘,’ ImportExpr}
+Export            ::=  ‘export’ ImportExpr {‘,’ ImportExpr}
+ImportExpr        ::=  SimpleRef {‘.’ id} ‘.’ ImportSpec
+                    |  SimpleRef ‘as’ id
+ImportSpec        ::=  NamedSelector
+                    |  WildcardSelector
+                    | ‘{’ ImportSelectors) ‘}’
+NamedSelector     ::=  id [‘as’ (id | ‘_’)]
+WildCardSelector  ::=  ‘*' | ‘given’ [InfixType]
+ImportSelectors   ::=  NamedSelector [‘,’ ImportSelectors]
+                    |  WildCardSelector {‘,’ WildCardSelector}
+
+EndMarker         ::=  ‘end’ EndMarkerTag    -- when followed by EOL
+EndMarkerTag      ::=  id | ‘if’ | ‘while’ | ‘for’ | ‘match’ | ‘try’
+                    |  ‘new’ | ‘this’ | ‘given’ | ‘extension’ | ‘val’
+```
+
+### Declarations and Definitions
+```
+RefineDcl         ::=  ‘val’ ValDcl
+                    |  ‘def’ DefDcl
+                    |  ‘type’ {nl} TypeDcl
+Dcl               ::=  RefineDcl
+                    |  ‘var’ VarDcl
+ValDcl            ::=  ids ‘:’ Type
+VarDcl            ::=  ids ‘:’ Type
+DefDcl            ::=  DefSig ‘:’ Type
+DefSig            ::=  id [DefTypeParamClause] DefParamClauses
+TypeDcl           ::=  id [TypeParamClause] {FunParamClause} TypeBounds [‘=’ Type]
+
+Def               ::=  ‘val’ PatDef
+                    |  ‘var’ PatDef
+                    |  ‘def’ DefDef
+                    |  ‘type’ {nl} TypeDcl
+                    |  TmplDef
+PatDef            ::=  ids [‘:’ Type] ‘=’ Expr
+                    |  Pattern2 [‘:’ Type] ‘=’ Expr
+DefDef            ::=  DefSig [‘:’ Type] ‘=’ Expr
+                    |  ‘this’ DefParamClause DefParamClauses ‘=’ ConstrExpr
+
+TmplDef           ::=  ([‘case’] ‘class’ | ‘trait’) ClassDef
+                    |  [‘case’] ‘object’ ObjectDef
+                    |  ‘enum’ EnumDef
+                    |  ‘given’ GivenDef
+ClassDef          ::=  id ClassConstr [Template]
+ClassConstr       ::=  [ClsTypeParamClause] [ConstrMods] ClsParamClauses
+ConstrMods        ::=  {Annotation} [AccessModifier]
+ObjectDef         ::=  id [Template]
+EnumDef           ::=  id ClassConstr InheritClauses EnumBody
+GivenDef          ::=  [GivenSig] (AnnotType [‘=’ Expr] | StructuralInstance)
+GivenSig          ::=  [id] [DefTypeParamClause] {UsingParamClause} ‘:’         -- one of `id`, `DefParamClause`, `UsingParamClause` must be present
+StructuralInstance ::=  ConstrApp {‘with’ ConstrApp} [‘with’ WithTemplateBody]
+Extension         ::=  ‘extension’ [DefTypeParamClause] {UsingParamClause}
+                       ‘(’ DefParam ‘)’ {UsingParamClause} ExtMethods
+ExtMethods        ::=  ExtMethod | [nl] <<< ExtMethod {semi ExtMethod} >>>
+ExtMethod         ::=  {Annotation [nl]} {Modifier} ‘def’ DefDef
+                    |  Export
+Template          ::=  InheritClauses [TemplateBody]
+InheritClauses    ::=  [‘extends’ ConstrApps] [‘derives’ QualId {‘,’ QualId}]
+ConstrApps        ::=  ConstrApp ({‘,’ ConstrApp} | {‘with’ ConstrApp})
+ConstrApp         ::=  SimpleType1 {Annotation} {ParArgumentExprs}
+ConstrExpr        ::=  SelfInvocation
+                    |  <<< SelfInvocation {semi BlockStat} >>>
+SelfInvocation    ::=  ‘this’ ArgumentExprs {ArgumentExprs}
+
+WithTemplateBody  ::=  <<< [SelfType] TemplateStat {semi TemplateStat} >>>
+TemplateBody      ::=  :<<< [SelfType] TemplateStat {semi TemplateStat} >>>
+TemplateStat      ::=  Import
+                    |  Export
+                    |  {Annotation [nl]} {Modifier} Def
+                    |  {Annotation [nl]} {Modifier} Dcl
+                    |  Extension
+                    |  Expr1
+                    |  EndMarker
+                    |
+SelfType          ::=  id [‘:’ InfixType] ‘=>’
+                    |  ‘this’ ‘:’ InfixType ‘=>’
+
+EnumBody          ::=  :<<< [SelfType] EnumStat {semi EnumStat} >>>
+EnumStat          ::=  TemplateStat
+                    |  {Annotation [nl]} {Modifier} EnumCase
+EnumCase          ::=  ‘case’ (id ClassConstr [‘extends’ ConstrApps]] | ids)
+
+TopStats          ::=  TopStat {semi TopStat}
+TopStat           ::=  Import
+                    |  Export
+                    |  {Annotation [nl]} {Modifier} Def
+                    |  Extension
+                    |  Packaging
+                    |  PackageObject
+                    |  EndMarker
+                    |
+Packaging         ::=  ‘package’ QualId :<<< TopStats >>>
+PackageObject     ::=  ‘package’ ‘object’ ObjectDef
+
+CompilationUnit   ::=  {‘package’ QualId semi} TopStats
+```

From 074b3b8f44f3411357b8bde68c5d9acdd2524aaf Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Thu, 13 Oct 2022 14:34:09 +0200
Subject: [PATCH 102/657] Add docker for website generation

---
 .gitignore                    |  2 ++
 docs/_spec/Dockerfile         | 24 +++++++++++++++
 docs/_spec/Gemfile            |  8 +++++
 docs/_spec/Gemfile.lock       | 57 +++++++++++++++++++++++++++++++++++
 docs/_spec/README.md          | 11 +++++++
 docs/_spec/docker-compose.yml | 11 +++++++
 6 files changed, 113 insertions(+)
 create mode 100644 docs/_spec/Dockerfile
 create mode 100644 docs/_spec/Gemfile
 create mode 100644 docs/_spec/Gemfile.lock
 create mode 100644 docs/_spec/docker-compose.yml

diff --git a/.gitignore b/.gitignore
index 4ac67ddfbb06..5240662741bb 100644
--- a/.gitignore
+++ b/.gitignore
@@ -93,3 +93,5 @@ compiler/test-coursier/run/*.jar
 # docs related
 contributors.js
 content-contributors.css
+docs/_spec/_site/
+docs/_spec/.jekyll-metadata
diff --git a/docs/_spec/Dockerfile b/docs/_spec/Dockerfile
new file mode 100644
index 000000000000..a08c5d0e7f98
--- /dev/null
+++ b/docs/_spec/Dockerfile
@@ -0,0 +1,24 @@
+FROM ruby:2.7
+
+RUN apt-get install -y curl \
+  && curl -sL https://deb.nodesource.com/setup_18.x | bash - \
+  && apt-get install -y nodejs \
+  && curl -L https://www.npmjs.com/install.sh | sh
+
+RUN gem install  bundler:1.17.2 jekyll 
+
+WORKDIR /srv/jekyll
+
+COPY Gemfile .
+COPY Gemfile.lock .
+
+
+RUN echo -n "bundle version: " && bundle --version
+RUN bundle install
+RUN mkdir /opt/npm-global
+RUN npm config set prefix '/opt/npm-global'
+RUN npm config set global true
+RUN npm install  bower
+RUN echo -n "npm version: " && npm --version
+RUN chmod u+s /bin/chown
+RUN date
diff --git a/docs/_spec/Gemfile b/docs/_spec/Gemfile
new file mode 100644
index 000000000000..bc45dc84db8c
--- /dev/null
+++ b/docs/_spec/Gemfile
@@ -0,0 +1,8 @@
+# To build the spec on Travis CI
+source "https://rubygems.org"
+
+gem "jekyll", "3.6.3"
+gem "webrick"
+gem "rouge"
+# gem 's3_website'
+gem "redcarpet", "3.5.1"
diff --git a/docs/_spec/Gemfile.lock b/docs/_spec/Gemfile.lock
new file mode 100644
index 000000000000..48efd373725e
--- /dev/null
+++ b/docs/_spec/Gemfile.lock
@@ -0,0 +1,57 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.8.1)
+      public_suffix (>= 2.0.2, < 6.0)
+    colorator (1.1.0)
+    ffi (1.15.5)
+    forwardable-extended (2.6.0)
+    jekyll (3.6.3)
+      addressable (~> 2.4)
+      colorator (~> 1.0)
+      jekyll-sass-converter (~> 1.0)
+      jekyll-watch (~> 1.1)
+      kramdown (~> 1.14)
+      liquid (~> 4.0)
+      mercenary (~> 0.3.3)
+      pathutil (~> 0.9)
+      rouge (>= 1.7, < 3)
+      safe_yaml (~> 1.0)
+    jekyll-sass-converter (1.5.2)
+      sass (~> 3.4)
+    jekyll-watch (1.5.1)
+      listen (~> 3.0)
+    kramdown (1.17.0)
+    liquid (4.0.3)
+    listen (3.7.1)
+      rb-fsevent (~> 0.10, >= 0.10.3)
+      rb-inotify (~> 0.9, >= 0.9.10)
+    mercenary (0.3.6)
+    pathutil (0.16.2)
+      forwardable-extended (~> 2.6)
+    public_suffix (5.0.0)
+    rb-fsevent (0.11.2)
+    rb-inotify (0.10.1)
+      ffi (~> 1.0)
+    redcarpet (3.5.1)
+    rouge (2.2.1)
+    safe_yaml (1.0.5)
+    sass (3.7.4)
+      sass-listen (~> 4.0.0)
+    sass-listen (4.0.0)
+      rb-fsevent (~> 0.9, >= 0.9.4)
+      rb-inotify (~> 0.9, >= 0.9.7)
+    webrick (1.7.0)
+
+PLATFORMS
+  ruby
+  x86_64-linux
+
+DEPENDENCIES
+  jekyll (= 3.6.3)
+  redcarpet (= 3.5.1)
+  rouge
+  webrick
+
+BUNDLED WITH
+   2.3.5
diff --git a/docs/_spec/README.md b/docs/_spec/README.md
index d748dddedfd2..e1c7e3497601 100644
--- a/docs/_spec/README.md
+++ b/docs/_spec/README.md
@@ -16,11 +16,22 @@ We aim to track the configuration GitHub Pages uses but differences may arise as
 
 ## Building
 
+<!-- TODO: change url to correct one -->
 Travis CI builds the spec automatically after every merged pull release and publishes to https://www.scala-lang.org/files/archive/spec/2.13/.
 
+<!-- TODO: Check nothing else is needed -->
+To preview locally, run the following commands in the docs/_spec subfolder:
+
+```
+env UID="$(id -u)" GID="$(id -g)" docker-compose up
+```
+
+and open http://0.0.0.0:4000/files/archive/spec/2.13/ to view the spec. Jekyll will rebuild as you edit the markdown, but make sure to restart it when you change `_config.yml`.
+<!-- 
 To preview locally, run the following commands in the root of your checkout scala/scala:
 `bundle install` to install Jekyll and `bundle exec jekyll serve -d build/spec/ -s spec/ -w --baseurl=""` to start it,
 and open http://0.0.0.0:4000/ to view the spec. Jekyll will rebuild as you edit the markdown, but make sure to restart it when you change `_config.yml`.
+-->
 
 ## General Advice for editors
 
diff --git a/docs/_spec/docker-compose.yml b/docs/_spec/docker-compose.yml
new file mode 100644
index 000000000000..3eadc939ed40
--- /dev/null
+++ b/docs/_spec/docker-compose.yml
@@ -0,0 +1,11 @@
+version: '2'
+
+services:
+  jekyll:
+    user: "${UID}:${GID}"
+    build: .
+    command: sh -c "chown $UID / &&   bundle exec jekyll serve --incremental --host=0.0.0.0 "
+    ports:
+      - '4000:4000'
+    volumes:
+      - .:/srv/jekyll

From d557687147e99d77fba24b98031af1ab1528ad91 Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Wed, 12 Oct 2022 14:35:16 +0200
Subject: [PATCH 103/657] Drop hypersections 14 and 15 14: Empty list of
 references (there is content in the comments however) 15: Out of date
 changelog

---
 docs/_spec/14-references.md | 207 ---------
 docs/_spec/15-changelog.md  | 847 ------------------------------------
 2 files changed, 1054 deletions(-)
 delete mode 100644 docs/_spec/14-references.md
 delete mode 100644 docs/_spec/15-changelog.md

diff --git a/docs/_spec/14-references.md b/docs/_spec/14-references.md
deleted file mode 100644
index cc088dfcae11..000000000000
--- a/docs/_spec/14-references.md
+++ /dev/null
@@ -1,207 +0,0 @@
----
-title: References
-layout: default
-chapter: 14
----
-
-# References
-
-TODO (see comments in markdown source)
-
-<!-- TODO
-
-provide a nice reading list to get up to speed with theory,...
-
-## Scala's Foundations
-[@scala-overview-tech-report;
-@odersky:scala-experiment;
-@odersky:sca;
-@odersky-et-al:ecoop03;
-@odersky-zenger:fool12]
-
-## Learning Scala
-
-## Related Work
-
-%% Article
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
-@article{milner:polymorphism,
-  author	= {Robin Milner},
-  title		= {A {T}heory of {T}ype {P}olymorphism in {P}rogramming},
-  journal	= {Journal of Computer and System Sciences},
-  year		= {1978},
-  month		= {Dec},
-  volume	= {17},
-  pages		= {348-375},
-  folder	= { 2-1}
-}
-
-@Article{wirth:ebnf,
-  author	= "Niklaus Wirth",
-  title		= "What can we do about the unnecessary diversity of notation
-for syntactic definitions?",
-  journal	= "Comm. ACM",
-  year		= 1977,
-  volume	= 20,
-  pages		= "822-823",
-  month		= nov
-}
-
-%% Book
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
-@Book{abelson-sussman:structure,
-  author	= {Harold Abelson and Gerald Jay Sussman and Julie Sussman},
-  title		= {The Structure and Interpretation of Computer Programs, 2nd
-                  edition},
-  publisher	= {MIT Press},
-  address	= {Cambridge, Massachusetts},
-  year		= {1996},
-  url		= {http://mitpress.mit.edu/sicp/full-text/sicp/book/book.html}
-}
-
-@Book{goldberg-robson:smalltalk-language,
-  author	= "Adele Goldberg and David Robson",
-  title		= "{Smalltalk-80}; The {L}anguage and Its {I}mplementation",
-  publisher	= "Addison-Wesley",
-  year		= "1983",
-  note		= "ISBN 0-201-11371-6"
-}
-
-@Book{matsumtoto:ruby,
-  author	= {Yukihiro Matsumoto},
-  title		= {Ruby in a {N}utshell},
-  publisher	= {O'Reilly \& Associates},
-  year		= "2001",
-  month		= "nov",
-  note		= "ISBN 0-596-00214-9"
-}
-
-@Book{rossum:python,
-  author	= {Guido van Rossum and Fred L. Drake},
-  title		= {The {P}ython {L}anguage {R}eference {M}anual},
-  publisher	= {Network Theory Ltd},
-  year		= "2003",
-  month		= "sep",
-  note		= {ISBN 0-954-16178-5\hspace*{\fill}\\
-                  \verb@http://www.python.org/doc/current/ref/ref.html@}
-}
-
-@Manual{odersky:scala-reference,
-  title =        {The {S}cala {L}anguage {S}pecification, Version 2.4},
-  author =       {Martin Odersky},
-  organization = {EPFL},
-  month =        feb,
-  year =         2007,
-  note =         {https://www.scala-lang.org/docu/manuals.html}
-}
-
-@Book{odersky:scala-reference,
-  ALTauthor =    {Martin Odersky},
-  ALTeditor =    {},
-  title =        {The {S}cala {L}anguage {S}pecification, Version 2.4},
-  publisher =    {},
-  year =         {},
-  OPTkey =       {},
-  OPTvolume =    {},
-  OPTnumber =    {},
-  OPTseries =    {},
-  OPTaddress =   {},
-  OPTedition =   {},
-  OPTmonth =     {},
-  OPTnote =      {},
-  OPTannote =    {}
-}
-
-%% InProceedings
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
-@InProceedings{odersky-et-al:fool10,
-  author	= {Martin Odersky and Vincent Cremet and Christine R\"ockl
-                  and Matthias Zenger},
-  title		= {A {N}ominal {T}heory of {O}bjects with {D}ependent {T}ypes},
-  booktitle	= {Proc. FOOL 10},
-  year		= 2003,
-  month		= jan,
-  note		= {\hspace*{\fill}\\
-                  \verb@https://www.cis.upenn.edu/~bcpierce/FOOL/FOOL10.html@}
-}
-
-%% Misc
-%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-
-@Misc{w3c:dom,
-  author	= {W3C},
-  title		= {Document Object Model ({DOM})},
-  howpublished	= {\hspace*{\fill}\\
-                  \verb@https://www.w3.org/DOM/@}
-}
-
-@Misc{w3c:xml,
-  author	= {W3C},
-  title		= {Extensible {M}arkup {L}anguage ({XML})},
-  howpublished	= {\hspace*{\fill}\\
-                  \verb@https://www.w3.org/TR/REC-xml@}
-}
-
-@TechReport{scala-overview-tech-report,
-  author =       {Martin Odersky and al.},
-  title =        {An {O}verview of the {S}cala {P}rogramming {L}anguage},
-  institution =  {EPFL Lausanne, Switzerland},
-  year =         2004,
-  number =       {IC/2004/64}
-}
-
-@InProceedings{odersky:sca,
-  author =       {Martin Odersky and Matthias Zenger},
-  title =        {Scalable {C}omponent {A}bstractions},
-  booktitle =    {Proc. OOPSLA},
-  year =         2005
-}
-
-@InProceedings{odersky-et-al:ecoop03,
-  author =       {Martin Odersky and Vincent Cremet and Christine R\"ockl and Matthias Zenger},
-  title =        {A {N}ominal {T}heory of {O}bjects with {D}ependent {T}ypes},
-  booktitle =    {Proc. ECOOP'03},
-  year =         2003,
-  month =        jul,
-  series =       {Springer LNCS}
-}
-
-@InCollection{cremet-odersky:pilib,
-  author =       {Vincent Cremet and Martin Odersky},
-  title =        {PiLib} - A {H}osted {L}anguage for {P}i-{C}alculus {S}tyle {C}oncurrency},
-  booktitle =    {Domain-Specific Program Generation},
-  publisher =    {Springer},
-  year =         2005,
-  volume =       3016,
-  series =       {Lecture Notes in Computer Science}
-}
-
-@InProceedings{odersky-zenger:fool12,
-  author =       {Martin Odersky and Matthias Zenger},
-  title =        {Independently {E}xtensible {S}olutions to the {E}xpression {P}roblem},
-  booktitle =    {Proc. FOOL 12},
-  year =         2005,
-  month =        jan,
-  note =         {\verb@https://homepages.inf.ed.ac.uk/wadler/fool@}
-}
-
-@InProceedings{odersky:scala-experiment,
-  author =       {Martin Odersky},
-  title =        {The {S}cala {E}xperiment - {C}an {W}e {P}rovide {B}etter {L}anguage {S}upport for {C}omponent {S}ystems?},
-  booktitle =    {Proc. ACM Symposium on Principles of Programming Languages},
-  year =         2006
-}
-
-@MISC{kennedy-pierce:decidable,
-  author = {Andrew J. Kennedy and Benjamin C. Pierce},
-  title = {On {D}ecidability of {N}ominal {S}ubtyping with {V}ariance},
-  year = {2007},
-  month = jan,
-  note = {FOOL-WOOD '07},
-  short = {https://www.cis.upenn.edu/~bcpierce/papers/variance.pdf}
-}
-
--->
diff --git a/docs/_spec/15-changelog.md b/docs/_spec/15-changelog.md
deleted file mode 100644
index 5d24511ff1cb..000000000000
--- a/docs/_spec/15-changelog.md
+++ /dev/null
@@ -1,847 +0,0 @@
----
-title: Changelog
-layout: default
-chapter: 15
----
-
-# Changelog
-
-This changelog was no longer maintained after version 2.8.0.
-
-A pull request updating this chapter to list the most significant
-changes made in more recent Scala versions would be highly welcome.
-
-Many language changes, especially larger ones, are documented in SIP
-(Scala Improvement Process) proposals.  Most proposals that were
-accepted and implemented have not merged into the main spec.  Pull
-requests that merge SIPs into the main spec are also highly welcome.
-
-To find out what has changed in Scala 2 since 2.8.0, you can consult
-the following sources:
-
-* Scala release notes (recent versions): https://github.com/scala/scala/releases
-* Scala release notes (older versions): https://scala-lang.org/blog/announcements/
-* Scala release notes (even older versions): presumably findable via search engine
-* Spec changelog in version control: https://github.com/scala/scala/commits/2.13.x/spec
-* SIPs: https://docs.scala-lang.org/sips/all.html
-
-## Changes in Version 2.8.0
-
-Trailing commas in expression, argument, type or pattern sequences are
-no longer supported.
-
-Changed visibility rules for nested packages (where done?)
-
-Changed [visibility rules](02-identifiers-names-and-scopes.html)
-so that packages are no longer treated specially.
-
-Added section on [weak conformance](03-types.html#weak-conformance).
-Relaxed type rules for conditionals,
-match expressions, try expressions to compute their result type using
-least upper bound wrt weak conformance. Relaxed type rule for local type
-inference so that argument types need only weekly conform to inferred
-formal parameter types. Added section on
-[numeric widening](06-expressions.html#numeric-widening) to support
-weak conformance.
-
-Tightened rules to avoid accidental [overrides](05-classes-and-objects.html#overriding).
-
-Removed class literals.
-
-Added section on [context bounds](07-implicits.html#context-bounds-and-view-bounds).
-
-Clarified differences between [`isInstanceOf` and pattern matches](12-the-scala-standard-library.html#root-classes).
-
-Allowed [`implicit` modifier on function literals](06-expressions.html#anonymous-functions) with a single parameter.
-
-## Changes in Version 2.7.2
-
-_(10-Nov-2008)_
-
-#### Precedence of Assignment Operators
-
-The [precedence of assignment operators](06-expressions.html#prefix,-infix,-and-postfix-operations)
-has been brought in line with. From now on `+=`, has the same precedence as `=`.
-
-#### Wildcards as function parameters
-
-A formal parameter to an anonymous function may now be a
-[wildcard represented by an underscore](06-expressions.html#placeholder-syntax-for-anonymous-functions).
-
->      _ => 7   // The function that ignores its argument
->               // and always returns 7.
-
-#### Unicode alternative for left arrow
-
-The Unicode glyph ‘´\leftarrow´’ ´`\u2190`´ is now treated as a reserved
-identifier, equivalent to the ASCII symbol ‘`<-`’.
-
-## Changes in Version 2.7.1
-
-_(09-April-2008)_
-
-#### Change in Scoping Rules for Wildcard Placeholders in Types
-
-A wildcard in a type now binds to the closest enclosing type
-application. For example `List[List[_]]` is now equivalent to this
-existential type:
-
-    List[List[t] forSome { type t }]
-
-In version 2.7.0, the type expanded instead to:
-
-    List[List[t]] forSome { type t }
-
-The new convention corresponds exactly to the way wildcards in Java are
-interpreted.
-
-#### No Contractiveness Requirement for Implicits
-
-The contractiveness requirement for
-[implicit method definitions](07-implicits.html#implicit-parameters)
-has been dropped. Instead, it is checked for each implicit expansion individually
-that the expansion does not result in a cycle or a tree of infinitely
-growing types.
-
-## Changes in Version 2.7.0
-
-_(07-Feb-2008)_
-
-#### Java Generics
-
-Scala now supports Java generic types by default:
-
--   A generic type in Java such as `ArrayList<String>` is translated to
-    a generic type in Scala: `ArrayList[String]`.
-
--   A wildcard type such as `ArrayList<? extends Number>` is translated
-    to `ArrayList[_ <: Number]`. This is itself a shorthand for the
-    existential type `ArrayList[T] forSome { type T <: Number }`.
-
--   A raw type in Java such as `ArrayList` is translated to
-    `ArrayList[_]`, which is a shorthand for
-    `ArrayList[T] forSome { type T }`.
-
-This translation works if `-target:jvm-1.5` is specified, which is the
-new default. For any other target, Java generics are not recognized. To
-ensure upgradability of Scala codebases, extraneous type parameters for
-Java classes under `-target:jvm-1.4` are simply ignored. For instance,
-when compiling with `-target:jvm-1.4`, a Scala type such as
-`ArrayList[String]` is simply treated as the unparameterized type
-`ArrayList`.
-
-#### Changes to Case Classes
-
-The Scala compiler generates a [companion extractor object for every case class]
-(05-classes-and-objects.html#case-classes) now. For instance, given the case class:
-
-      case class X(elem: String)
-
-the following companion object is generated:
-
-      object X {
-        def unapply(x: X): Some[String] = Some(x.elem)
-        def apply(s: String): X = new X(s)
-      }
-
-If the object exists already, only the `apply` and `unapply` methods are
-added to it.
-
-Three restrictions on case classes have been removed.
-
-1.  Case classes can now inherit from other case classes.
-
-2.  Case classes may now be `abstract`.
-
-3.  Case classes may now come with companion objects.
-
-## Changes in Version 2.6.1
-
-_(30-Nov-2007)_
-
-#### Mutable variables introduced by pattern binding
-
-[Mutable variables can now be introduced by a pattern matching definition]
-(04-basic-declarations-and-definitions.html#variable-declarations-and-definitions),
-just like values can. Examples:
-
-      var (x, y) = if (positive) (1, 2) else (-1, -3)
-      var hd :: tl = mylist
-
-#### Self-types
-
-Self types can now be introduced without defining an alias name for
-[`this`](05-classes-and-objects.html#templates). Example:
-
-      class C {
-        type T <: Trait
-        trait Trait { this: T => ... }
-      }
-
-## Changes in Version 2.6
-
-_(27-July-2007)_
-
-#### Existential types
-
-It is now possible to define [existential types](03-types.html#existential-types).
-An existential type has the form `T forSome {Q}` where `Q` is a sequence of value and/or
-type declarations. Given the class definitions
-
-    class Ref[T]
-    abstract class Outer { type T }
-
-one may for example write the following existential types
-
-    Ref[T] forSome { type T <: java.lang.Number }
-    Ref[x.T] forSome { val x: Outer }
-
-#### Lazy values
-
-It is now possible to define lazy value declarations using the new modifier
-[`lazy`](04-basic-declarations-and-definitions.html#value-declarations-and-definitions).
-A `lazy` value definition evaluates its right hand
-side ´e´ the first time the value is accessed. Example:
-
-    import compat.Platform._
-    val t0 = currentTime
-    lazy val t1 = currentTime
-    val t2 = currentTime
-
-    println("t0 <= t2: " + (t0 <= t2))  //true
-    println("t1 <= t2: " + (t1 <= t2))  //false (lazy evaluation of t1)
-
-#### Structural types
-
-It is now possible to declare structural types using [type refinements]
-(03-types.html#compound-types). For example:
-
-    class File(name: String) {
-      def getName(): String = name
-      def open() { /*..*/ }
-      def close() { println("close file") }
-    }
-    def test(f: { def getName(): String }) { println(f.getName) }
-
-    test(new File("test.txt"))
-    test(new java.io.File("test.txt"))
-
-There’s also a shorthand form for creating values of structural types.
-For instance,
-
-    new { def getName() = "aaron" }
-
-is a shorthand for
-
-    new AnyRef{ def getName() = "aaron" }
-
-## Changes in Version 2.5
-
-_(02-May-2007)_
-
-#### Type constructor polymorphism
-
-_Implemented by Adriaan Moors_
-
-[Type parameters](04-basic-declarations-and-definitions.html#type-parameters)
-and abstract
-[type members](04-basic-declarations-and-definitions.html#type-declarations-and-type-aliases) can now also abstract over [type constructors](03-types.html#type-constructors).
-
-This allows a more precise `Iterable` interface:
-
-    trait Iterable[+T] {
-      type MyType[+T] <: Iterable[T] // MyType is a type constructor
-
-      def filter(p: T => Boolean): MyType[T] = ...
-      def map[S](f: T => S): MyType[S] = ...
-    }
-
-    abstract class List[+T] extends Iterable[T] {
-      type MyType[+T] = List[T]
-    }
-
-This definition of `Iterable` makes explicit that mapping a function
-over a certain structure (e.g., a `List`) will yield the same structure
-(containing different elements).
-
-#### Early object initialization
-
-[Early object initialization](05-classes-and-objects.html#early-definitions)
-makes it possible to initialize some fields of an object before any
-parent constructors are called. This is particularly useful for
-traits, which do not have normal constructor parameters. Example:
-
-    trait Greeting {
-      val name: String
-      val msg = "How are you, "+name
-    }
-    class C extends {
-      val name = "Bob"
-    } with Greeting {
-      println(msg)
-    }
-
-In the code above, the field is initialized before the constructor of is
-called. Therefore, field `msg` in class is properly initialized to .
-
-#### For-comprehensions, revised
-
-The syntax of [for-comprehensions](06-expressions.html#for-comprehensions-and-for-loops)
-has changed.
-In the new syntax, generators do not start with a `val` anymore, but filters
-start with an `if` (and are called guards).
-A semicolon in front of a guard is optional. For example:
-
-    for (val x <- List(1, 2, 3); x % 2 == 0) println(x)
-
-is now written
-
-    for (x <- List(1, 2, 3) if x % 2 == 0) println(x)
-
-The old syntax is still available but will be deprecated in the future.
-
-#### Implicit anonymous functions
-
-It is now possible to define [anonymous functions using underscores]
-(06-expressions.html#placeholder-syntax-for-anonymous-functions) in
-parameter position. For instance, the expressions in the left column
-are each function values which expand to the anonymous functions on
-their right.
-
-    _ + 1                  x => x + 1
-    _ * _                  (x1, x2) => x1 * x2
-    (_: int) * 2           (x: int) => (x: int) * 2
-    if (_) x else y        z => if (z) x else y
-    _.map(f)               x => x.map(f)
-    _.map(_ + 1)           x => x.map(y => y + 1)
-
-As a special case, a [partially unapplied method](06-expressions.html#method-values)
-is now designated `m _`   instead of the previous notation  `&m`.
-
-The new notation will displace the special syntax forms `.m()` for
-abstracting over method receivers and `&m` for treating an unapplied
-method as a function value. For the time being, the old syntax forms are
-still available, but they will be deprecated in the future.
-
-#### Pattern matching anonymous functions, refined
-
-It is now possible to use [case clauses to define a function value]
-(08-pattern-matching.html#pattern-matching-anonymous-functions)
-directly for functions of arities greater than one. Previously, only
-unary functions could be defined that way. Example:
-
-    def scalarProduct(xs: Array[Double], ys: Array[Double]) =
-      (xs zip ys).foldLeft(0.0) {
-        case (a, (b, c)) => a + b * c
-      }
-
-## Changes in Version 2.4
-
-_(09-Mar-2007)_
-
-#### Object-local private and protected
-
-The `private` and `protected` modifiers now accept a
-[`[this]` qualifier](05-classes-and-objects.html#modifiers).
-A definition ´M´ which is labelled `private[this]` is private,
-and in addition can be accessed only from within the current object.
-That is, the only legal prefixes for ´M´ are `this` or `´C´.this`.
-Analogously, a definition ´M´ which is labelled `protected[this]` is
-protected, and in addition can be accessed only from within the current
-object.
-
-#### Tuples, revised
-
-The syntax for [tuples](06-expressions.html#tuples) has been changed from ´\\{…\\}´ to
-´(…)´. For any sequence of types ´T_1 , … , T_n´,
-
-´(T_1 , … , T_n)´ is a shorthand for `Tuple´n´[´T_1 , … , T_n´]`.
-
-Analogously, for any sequence of expressions or patterns ´x_1
-, … , x_n´,
-
-´(x_1 , … , x_n)´ is a shorthand for `Tuple´n´(´x_1 , … , x_n´)`.
-
-#### Access modifiers for primary constructors
-
-The primary constructor of a class can now be marked [`private` or `protected`]
-(05-classes-and-objects.html#class-definitions).
-If such an access modifier is given, it comes between the name of the class and its
-value parameters. Example:
-
-    class C[T] private (x: T) { ... }
-
-#### Annotations
-
-The support for attributes has been extended and its syntax changed.
-Attributes are now called [*annotations*](11-annotations.html). The syntax has
-been changed to follow Java’s conventions, e.g. `@attribute` instead of
-`[attribute]`. The old syntax is still available but will be deprecated
-in the future.
-
-Annotations are now serialized so that they can be read by compile-time
-or run-time tools. Class has two sub-traits which are used to indicate
-how annotations are retained. Instances of an annotation class
-inheriting from trait will be stored in the generated class files.
-Instances of an annotation class inheriting from trait will be visible
-to the Scala type-checker in every compilation unit where the annotated
-symbol is accessed.
-
-#### Decidable subtyping
-
-The implementation of subtyping has been changed to prevent infinite
-recursions.
-[Termination of subtyping](05-classes-and-objects.html#inheritance-closure)
-is now ensured by a new restriction of class graphs to be finitary.
-
-#### Case classes cannot be abstract
-
-It is now explicitly ruled out that case classes can be abstract. The
-specification was silent on this point before, but did not explain how
-abstract case classes were treated. The Scala compiler allowed the
-idiom.
-
-#### New syntax for self aliases and self types
-
-It is now possible to give an explicit alias name and/or type for the
-[self reference](05-classes-and-objects.html#templates) `this`. For instance, in
-
-    class C { self: D =>
-      ...
-    }
-
-the name `self` is introduced as an alias for `this` within `C` and the
-[self type](05-classes-and-objects.html#class-definitions) of `C` is
-assumed to be `D`. This construct is introduced now in order to replace
-eventually both the qualified this construct and the clause in Scala.
-
-#### Assignment Operators
-
-It is now possible to [combine operators with assignments]
-(06-expressions.html#assignment-operators). Example:
-
-    var x: int = 0
-    x += 1
-
-## Changes in Version 2.3.2
-
-_(23-Jan-2007)_
-
-#### Extractors
-
-It is now possible to define patterns independently of case classes, using
-`unapply` methods in [extractor objects](08-pattern-matching.html#extractor-patterns).
-Here is an example:
-
-    object Twice {
-      def apply(x:Int): int = x*2
-      def unapply(z:Int): Option[int] = if (z%2==0) Some(z/2) else None
-    }
-    val x = Twice(21)
-    x match { case Twice(n) => Console.println(n) } // prints 21
-
-In the example, `Twice` is an extractor object with two methods:
-
--   The `apply` method is used to build even numbers.
-
--   The `unapply` method is used to decompose an even number; it is in a sense
-    the reverse of `apply`. `unapply` methods return option types:
-    `Some(...)` for a match that succeeds, `None` for a match that fails.
-    Pattern variables are returned as the elements of `Some`.
-    If there are several variables, they are grouped in a tuple.
-
-In the second-to-last line, `Twice`’s method is used to construct a number `x`.
-In the last line, `x` is tested against the pattern `Twice(n)`.
-This pattern succeeds for even numbers and assigns to the variable `n` one half
-of the number that was tested.
-The pattern match makes use of the `unapply` method of object `Twice`.
-More details on extractors can be found in the paper “Matching Objects with
-Patterns” by Emir, Odersky and Williams.
-
-#### Tuples
-
-A new [lightweight syntax for tuples](06-expressions.html#tuples) has been introduced.
-For any sequence of types ´T_1 , … , T_n´,
-
-´\{T_1 , … , T_n \}´ is a shorthand for `Tuple´n´[´T_1 , … , T_n´]`.
-
-Analogously, for any sequence of expressions or patterns ´x_1, … , x_n´,
-
-´\{x_1 , … , x_n \}´ is a shorthand for `Tuple´n´(´x_1 , … , x_n´)`.
-
-#### Infix operators of greater arities
-
-It is now possible to use methods which have more than one parameter as
-[infix operators](06-expressions.html#infix-operations). In this case, all
-method arguments are written as a normal parameter list in parentheses. Example:
-
-    class C {
-      def +(x: int, y: String) = ...
-    }
-    val c = new C
-    c + (1, "abc")
-
-#### Deprecated attribute
-
-A new standard attribute [`deprecated`](11-annotations.html#deprecation-annotations)
-is available. If a member definition is marked with this attribute, any
-reference to the member will cause a “deprecated” warning message to be emitted.
-
-## Changes in Version 2.3
-
-_(23-Nov-2006)_
-
-#### Procedures
-
-A simplified syntax for [methods returning `unit`]
-(04-basic-declarations-and-definitions.html#procedures) has been introduced.
-Scala now allows the following shorthands:
-
-`def f(params)` **for** `def f(params): unit`  
-`def f(params) { ... }` **for** `def f(params): unit = { ... }`
-
-#### Type Patterns
-
-The [syntax of types in patterns](08-pattern-matching.html#type-patterns) has
-been refined.
-Scala now distinguishes between type variables (starting with a lower case
-letter) and types as type arguments in patterns.
-Type variables are bound in the pattern.
-Other type arguments are, as in previous versions, erased.
-The Scala compiler will now issue an “unchecked” warning at places where type
-erasure might compromise type-safety.
-
-#### Standard Types
-
-The recommended names for the two bottom classes in Scala’s type
-hierarchy have changed as follows:
-
-    All      ==>     Nothing
-    AllRef   ==>     Null
-
-The old names are still available as type aliases.
-
-## Changes in Version 2.1.8
-
-_(23-Aug-2006)_
-
-#### Visibility Qualifier for protected
-
-Protected members can now have a visibility qualifier, e.g.
-[`protected[<qualifier>]`](05-classes-and-objects.html#protected).
-In particular, one can now simulate package protected access as in Java writing
-
-      protected[P] def X ...
-
-where would name the package containing `X`.
-
-#### Relaxation of Private Access
-
-[Private members of a class](05-classes-and-objects.html#private) can now be
-referenced from the companion module of the class and vice versa.
-
-#### Implicit Lookup
-
-The lookup method for [implicit definitions](07-implicits.html#implicit-parameters)
-has been generalized.
-When searching for an implicit definition matching a type ´T´, now are considered
-
-1.  all identifiers accessible without prefix, and
-
-2.  all members of companion modules of classes associated with ´T´.
-
-(The second clause is more general than before). Here, a class is _associated_
-with a type ´T´ if it is referenced by some part of ´T´, or if it is a
-base class of some part of ´T´.
-For instance, to find implicit members corresponding to the type
-
-      HashSet[List[Int], String]
-
-one would now look in the companion modules (aka static parts) of `HashSet`,
-`List`, `Int`, and `String`. Before, it was just the static part of .
-
-#### Tightened Pattern Match
-
-A typed [pattern match with a singleton type `p.type`](08-pattern-matching.html#type-patterns)
-now tests whether the selector value is reference-equal to `p`. Example:
-
-      val p = List(1, 2, 3)
-      val q = List(1, 2)
-      val r = q
-      r match {
-        case _: p.type => Console.println("p")
-        case _: q.type => Console.println("q")
-      }
-
-This will match the second case and hence will print “q”. Before, the
-singleton types were erased to `List`, and therefore the first case would have
-matched, which is non-sensical.
-
-## Changes in Version 2.1.7
-
-_(19-Jul-2006)_
-
-#### Multi-Line string literals
-
-It is now possible to write [multi-line string-literals]
-(01-lexical-syntax.html#string-literals) enclosed in triple quotes. Example:
-
-    """this is a
-       multi-line
-       string literal"""
-
-No escape substitutions except for unicode escapes are performed in such
-string literals.
-
-#### Closure Syntax
-
-The syntax of [closures](06-expressions.html#anonymous-functions)
-has been slightly restricted. The form
-
-      x: T => E
-
-is valid only when enclosed in braces, i.e.  `{ x: T => E }`. The
-following is illegal, because it might be read as the value x typed with
-the type `T => E`:
-
-      val f = x: T => E
-
-Legal alternatives are:
-
-      val f = { x: T => E }
-      val f = (x: T) => E
-
-## Changes in Version 2.1.5
-
-_(24-May-2006)_
-
-#### Class Literals
-
-There is a new syntax for [class literals](06-expressions.html#literals):
-For any class type ´C´, `classOf[´C´]` designates the run-time
-representation of ´C´.
-
-## Changes in Version 2.0
-
-_(12-Mar-2006)_
-
-Scala in its second version is different in some details from the first
-version of the language. There have been several additions and some old
-idioms are no longer supported. This appendix summarizes the main
-changes.
-
-#### New Keywords
-
-The following three words are now reserved; they cannot be used as
-[identifiers](01-lexical-syntax.html#identifiers):
-
-    implicit    match     requires
-
-#### Newlines as Statement Separators
-
-[Newlines](https://www.scala-lang.org/files/archive/spec/2.11/)
-can now be used as statement separators in place of semicolons.
-
-#### Syntax Restrictions
-
-There are some other situations where old constructs no longer work:
-
-##### *Pattern matching expressions*
-
-The `match` keyword now appears only as infix operator between a
-selector expression and a number of cases, as in:
-
-      expr match {
-        case Some(x) => ...
-        case None => ...
-      }
-
-Variants such as ` expr.match {...} ` or just ` match {...} ` are no
-longer supported.
-
-##### *“With” in extends clauses*
-
-The idiom
-
-    class C with M { ... }
-
-is no longer supported. A `with` connective is only allowed following an
-`extends` clause. For instance, the line above would have to be written
-
-    class C extends AnyRef with M { ... } .
-
-However, assuming `M` is a [trait](05-classes-and-objects.html#traits),
-it is also legal to write
-
-    class C extends M { ... }
-
-The latter expression is treated as equivalent to
-
-    class C extends S with M { ... }
-
-where `S` is the superclass of `M`.
-
-##### *Regular Expression Patterns*
-
-The only form of regular expression pattern that is currently supported
-is a sequence pattern, which might end in a sequence wildcard . Example:
-
-    case List(1, 2, _*) => ... // will match all lists starting with 1, 2, ...
-
-It is at current not clear whether this is a permanent restriction. We
-are evaluating the possibility of re-introducing full regular expression
-patterns in Scala.
-
-#### Selftype Annotations
-
-The recommended syntax of selftype annotations has changed.
-
-    class C: T extends B { ... }
-
-becomes
-
-    class C requires T extends B { ... }
-
-That is, selftypes are now indicated by the new `requires` keyword. The
-old syntax is still available but is considered deprecated.
-
-#### For-comprehensions
-
-[For-comprehensions](06-expressions.html#for-comprehensions-and-for-loops)
-now admit value and pattern definitions. Example:
-
-    for {
-      val x <- List.range(1, 100)
-      val y <- List.range(1, x)
-      val z = x + y
-      isPrime(z)
-    } yield Pair(x, y)
-
-Note the definition  `val z = x + y` as the third item in the
-for-comprehension.
-
-#### Conversions
-
-The rules for [implicit conversions of methods to functions]
-(06-expressions.html#method-conversions) have been tightened.
-Previously, a parameterized method used as a value was always
-implicitly converted to a function. This could lead to unexpected
-results when method arguments where forgotten. Consider for instance the
-statement below:
-
-    show(x.toString)
-
-where `show` is defined as follows:
-
-    def show(x: String) = Console.println(x) .
-
-Most likely, the programmer forgot to supply an empty argument list `()`
-to `toString`. The previous Scala version would treat this code as a
-partially applied method, and expand it to:
-
-    show(() => x.toString())
-
-As a result, the address of a closure would be printed instead of the
-value of `s`.
-
-Scala version 2.0 will apply a conversion from partially applied method
-to function value only if the expected type of the expression is indeed
-a function type. For instance, the conversion would not be applied in
-the code above because the expected type of `show`’s parameter is
-`String`, not a function type.
-
-The new convention disallows some previously legal code. Example:
-
-    def sum(f: int => double)(a: int, b: int): double =
-      if (a > b) 0 else f(a) + sum(f)(a + 1, b)
-
-    val sumInts  =  sum(x => x)  // error: missing arguments
-
-The partial application of `sum` in the last line of the code above will
-not be converted to a function type. Instead, the compiler will produce
-an error message which states that arguments for method `sum` are
-missing. The problem can be fixed by providing an expected type for the
-partial application, for instance by annotating the definition of
-`sumInts` with its type:
-
-    val sumInts: (int, int) => double  =  sum(x => x)  // OK
-
-On the other hand, Scala version 2.0 now automatically applies methods
-with empty parameter lists to `()` argument lists when necessary. For
-instance, the `show` expression above will now be expanded to
-
-    show(x.toString()) .
-
-Scala version 2.0 also relaxes the rules of overriding with respect to
-empty parameter lists. The revised definition of
-[_matching members_](05-classes-and-objects.html#class-members)
-makes it now possible to override a method with an
-explicit, but empty parameter list `()` with a parameterless method, and
-_vice versa_. For instance, the following class definition
-is now legal:
-
-    class C {
-      override def toString: String = ...
-    }
-
-Previously this definition would have been rejected, because the
-`toString` method as inherited from `java.lang.Object` takes an empty
-parameter list.
-
-#### Class Parameters
-
-A [class parameter](05-classes-and-objects.html#class-definitions)
-may now be prefixed by `val` or `var`.
-
-#### Private Qualifiers
-
-Previously, Scala had three levels of visibility:
-<span>*private*</span>, <span>*protected*</span> and
-<span>*public*</span>. There was no way to restrict accesses to members
-of the current package, as in Java.
-
-Scala 2 now defines [access qualifiers](05-classes-and-objects.html#modifiers)
-that let one express this level of visibility, among others. In the definition
-
-    private[C] def f(...)
-
-access to `f` is restricted to all code within the class or package `C`
-(which must contain the definition of `f`).
-
-#### Changes in the Mixin Model
-
-The model which details [mixin composition of classes]
-(05-classes-and-objects.html#templates) has changed significantly.
-The main differences are:
-
-1.  We now distinguish between <span>*traits*</span> that are used as
-    mixin classes and normal classes. The syntax of traits has been
-    generalized from version 1.0, in that traits are now allowed to have
-    mutable fields. However, as in version 1.0, traits still may not
-    have constructor parameters.
-
-2.  Member resolution and super accesses are now both defined in terms
-    of a <span>*class linearization*</span>.
-
-3.  Scala’s notion of method overloading has been generalized; in
-    particular, it is now possible to have overloaded variants of the
-    same method in a subclass and in a superclass, or in several
-    different mixins. This makes method overloading in Scala
-    conceptually the same as in Java.
-
-#### Implicit Parameters
-
-Views in Scala 1.0 have been replaced by the more general concept of
-[implicit parameters](07-implicits.html#implicit-parameters).
-
-#### Flexible Typing of Pattern Matching
-
-The new version of Scala implements more flexible typing rules when it
-comes to [pattern matching over heterogeneous class hierarchies]
-(08-pattern-matching.html#pattern-matching-expressions).
-A <span>*heterogeneous class hierarchy*</span> is one where subclasses
-inherit a common superclass with different parameter types. With the new
-rules in Scala version 2.0 one can perform pattern matches over such
-hierarchies with more precise typings that keep track of the information
-gained by comparing the types of a selector and a matching pattern.
-This gives Scala capabilities analogous to guarded algebraic data types.

From 38e79aae2f11522e55948f4073e852ac90d821fb Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Fri, 14 Oct 2022 14:11:12 +0200
Subject: [PATCH 104/657] =?UTF-8?q?Replace=20=E2=80=A6=20by=20...?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 docs/_spec/01-lexical-syntax.md               |  4 +-
 docs/_spec/03-types.md                        | 56 +++++++++----------
 docs/_spec/08-pattern-matching.md             |  6 +-
 docs/_spec/13-syntax-summary.md               |  8 +--
 .../changed-features/overload-resolution.md   |  4 +-
 docs/_spec/TODOreference/syntax.md            | 14 ++---
 6 files changed, 46 insertions(+), 46 deletions(-)

diff --git a/docs/_spec/01-lexical-syntax.md b/docs/_spec/01-lexical-syntax.md
index 921384b40e20..46bd876b4077 100644
--- a/docs/_spec/01-lexical-syntax.md
+++ b/docs/_spec/01-lexical-syntax.md
@@ -19,7 +19,7 @@ classes (Unicode general category given in parentheses):
 1. Letters, which include lower case letters (`Ll`), upper case letters (`Lu`),
    title case letters (`Lt`), other letters (`Lo`), modifier letters (`Lm`), 
    letter numerals (`Nl`) and the two characters `\u0024 ‘$’` and `\u005F ‘_’`.
-1. Digits `‘0’ | … | ‘9’`.
+1. Digits `‘0’ | ... | ‘9’`.
 1. Parentheses `‘(’ | ‘)’ | ‘[’ | ‘]’ | ‘{’ | ‘}’ `.
 1. Delimiter characters ``‘`’ | ‘'’ | ‘"’ | ‘.’ | ‘;’ | ‘,’ ``.
 1. Operator characters. These consist of all printable ASCII characters
@@ -41,7 +41,7 @@ id       ::=  plainid
 idrest   ::=  {letter | digit} [‘_’ op]
 escapeSeq     ::= UnicodeEscape | charEscapeSeq
 UnicodeEscape ::= ‘\’ ‘u’ {‘u’} hexDigit hexDigit hexDigit hexDigit
-hexDigit      ::= ‘0’ | … | ‘9’ | ‘A’ | … | ‘F’ | ‘a’ | … | ‘f’
+hexDigit      ::= ‘0’ | ... | ‘9’ | ‘A’ | ... | ‘F’ | ‘a’ | ... | ‘f’
 ```
 
 There are three ways to form an identifier. First, an identifier can
diff --git a/docs/_spec/03-types.md b/docs/_spec/03-types.md
index 3c78b33e571c..cd70a4e34373 100644
--- a/docs/_spec/03-types.md
+++ b/docs/_spec/03-types.md
@@ -207,13 +207,13 @@ substitution ´[ a_1 := T_1 , \ldots , a_n := T_n ]´.
 Given the partial type definitions:
 
 ```scala
-class TreeMap[A <: Comparable[A], B] { … }
-class List[A] { … }
-class I extends Comparable[I] { … }
+class TreeMap[A <: Comparable[A], B] { ... }
+class List[A] { ... }
+class I extends Comparable[I] { ... }
 
-class F[M[_], X] { … }
-class S[K <: String] { … }
-class G[M[ Z <: I ], I] { … }
+class F[M[_], X] { ... }
+class S[K <: String] { ... }
+class G[M[ Z <: I ], I] { ... }
 ```
 
 the following parameterized types are well-formed:
@@ -255,20 +255,20 @@ A _tuple type_ ´(T_1 , \ldots , T_n)´ is an alias for the
 class `scala.Tuple´n´[´T_1´, … , ´T_n´]`, where ´n \geq 2´.
 
 Tuple classes are case classes whose fields can be accessed using
-selectors `_1` , … , `_n`. Their functionality is
+selectors `_1`, ..., `_n`. Their functionality is
 abstracted in a corresponding `Product` trait. The _n_-ary tuple
 class and product trait are defined at least as follows in the
 standard Scala library (they might also add other methods and
 implement other traits).
 
 ```scala
-case class Tuple´_n´[+´T_1´, … , +´T_n´](_1: ´T_1´, … , _n: ´T_n´)
-extends Product´_n´[´T_1´, … , ´T_n´]
+case class Tuple´_n´[+´T_1´, ..., +´T_n´](_1: ´T_1´, ..., _n: ´T_n´)
+extends Product´_n´[´T_1´, ..., ´T_n´]
 
-trait Product´_n´[+´T_1´, … , +´T_n´] {
+trait Product´_n´[+´T_1´, ..., +´T_n´] {
   override def productArity = ´n´
   def _1: ´T_1´
-  …
+  ...
   def _n: ´T_n´
 }
 ```
@@ -302,7 +302,7 @@ RefineStat      ::=  Dcl
                   |
 ```
 
-A _compound type_ ´T_1´ `with` … `with` ´T_n \\{ R \\}´
+A _compound type_ ´T_1´ `with` ... `with` ´T_n \\{ R \\}´
 represents objects with members as given in the component types
 ´T_1 , \ldots , T_n´ and the refinement ´\\{ R \\}´. A refinement
 ´\\{ R \\}´ contains declarations and type definitions.
@@ -323,7 +323,7 @@ definition within the refinement. This restriction does not apply to
 the method's result type.
 
 If no refinement is given, the empty refinement is implicitly added,
-i.e. ´T_1´ `with` … `with` ´T_n´ is a shorthand for ´T_1´ `with` … `with` ´T_n \\{\\}´.
+i.e. ´T_1´ `with` ... `with` ´T_n´ is a shorthand for ´T_1´ `with` ... `with` ´T_n \\{\\}´.
 
 A compound type may also consist of just a refinement
 ´\\{ R \\}´ with no preceding component types. Such a type is
@@ -336,12 +336,12 @@ a parameter type that contains a refinement with structural declarations.
 
 ```scala
 case class Bird (val name: String) extends Object {
-        def fly(height: Int) = …
-…
+        def fly(height: Int) = ...
+...
 }
 case class Plane (val callsign: String) extends Object {
-        def fly(height: Int) = …
-…
+        def fly(height: Int) = ...
+...
 }
 def takeoff(
             runway: Int,
@@ -415,8 +415,8 @@ types are defined in the Scala library for ´n´ between 0 and 22 as follows.
 
 ```scala
 package scala
-trait Function´_n´[-´T_1´ , … , -´T_n´, +´U´] {
-  def apply(´x_1´: ´T_1´ , … , ´x_n´: ´T_n´): ´U´
+trait Function´_n´[-´T_1´, ..., -´T_n´, +´U´] {
+  def apply(´x_1´: ´T_1´, ..., ´x_n´: ´T_n´): ´U´
   override def toString = "<function>"
 }
 ```
@@ -724,7 +724,7 @@ These notions are defined mutually recursively as follows.
    given as follows.
   - The base types of a class type ´C´ with parents ´T_1 , \ldots , T_n´ are
     ´C´ itself, as well as the base types of the compound type
-    `´T_1´ with … with ´T_n´ { ´R´ }`.
+    `´T_1´ with ... with ´T_n´ { ´R´ }`.
   - The base types of an aliased type are the base types of its alias.
   - The base types of an abstract type are the base types of its upper bound.
   - The base types of a parameterized type
@@ -861,8 +861,8 @@ The conformance relation ´(<:)´ is the smallest transitive relation that satis
 - A singleton type `´p´.type` conforms to the type of the path ´p´.
 - A singleton type `´p´.type` conforms to the type `scala.Singleton`.
 - A type projection `´T´#´t´` conforms to `´U´#´t´` if ´T´ conforms to ´U´.
-- A parameterized type `´T´[´T_1´ , … , ´T_n´]` conforms to
-  `´T´[´U_1´ , … , ´U_n´]` if
+- A parameterized type `´T´[´T_1´, ..., ´T_n´]` conforms to
+  `´T´[´U_1´, ..., ´U_n´]` if
   the following three conditions hold for ´i \in \{ 1 , \ldots , n \}´:
  1. If the ´i´'th type parameter of ´T´ is declared covariant, then
        ´T_i <: U_i´.
@@ -922,13 +922,13 @@ type ´C'´, if one of the following holds.
   subsumes a method declaration that defines ´x´ with type ´T'´, provided
   ´T <: T'´.
 - A type alias
-  `type ´t´[´T_1´ , … , ´T_n´] = ´T´` subsumes a type alias
-  `type ´t´[´T_1´ , … , ´T_n´] = ´T'´` if ´T \equiv T'´.
-- A type declaration `type ´t´[´T_1´ , … , ´T_n´] >: ´L´ <: ´U´` subsumes
-  a type declaration `type ´t´[´T_1´ , … , ´T_n´] >: ´L'´ <: ´U'´` if
+  `type ´t´[´T_1´, ..., ´T_n´] = ´T´` subsumes a type alias
+  `type ´t´[´T_1´, ..., ´T_n´] = ´T'´` if ´T \equiv T'´.
+- A type declaration `type ´t´[´T_1´, ..., ´T_n´] >: ´L´ <: ´U´` subsumes
+  a type declaration `type ´t´[´T_1´, ..., ´T_n´] >: ´L'´ <: ´U'´` if
   ´L' <: L´ and ´U <: U'´.
 - A type or class definition that binds a type name ´t´ subsumes an abstract
-  type declaration `type t[´T_1´ , … , ´T_n´] >: L <: U` if
+  type declaration `type t[´T_1´, ..., ´T_n´] >: L <: U` if
   ´L <: t <: U´.
 
 
@@ -1024,7 +1024,7 @@ A value member of a volatile type cannot appear in a [path](#paths).
 
 A type is _volatile_ if it falls into one of four categories:
 
-A compound type `´T_1´ with … with ´T_n´ {´R\,´}`
+A compound type `´T_1´ with ... with ´T_n´ {´R\,´}`
 is volatile if one of the following three conditions hold.
 
 1. One of ´T_2 , \ldots , T_n´ is a type parameter or abstract type, or
diff --git a/docs/_spec/08-pattern-matching.md b/docs/_spec/08-pattern-matching.md
index 7607b0db85e0..53dc3ffe4547 100644
--- a/docs/_spec/08-pattern-matching.md
+++ b/docs/_spec/08-pattern-matching.md
@@ -114,12 +114,12 @@ The expansion of interpolated string literals in patterns is the same as
 in expressions. If it occurs in a pattern, a interpolated string literal 
 of either of the forms
 ```
-id"text0{ pat1 }text1 … { patn }textn"
-id"""text0{ pat1 }text1 … { patn }textn"""
+id"text0{ pat1 }text1 ... { patn }textn"
+id"""text0{ pat1 }text1 ... { patn }textn"""
 ```
 is equivalent to:
 ```
-StringContext("""text0""", …, """textn""").id(pat1, …, patn)
+StringContext("""text0""", ..., """textn""").id(pat1, ..., patn)
 ```
 You could define your own `StringContext` to shadow the default one that's 
 in the `scala` package.
diff --git a/docs/_spec/13-syntax-summary.md b/docs/_spec/13-syntax-summary.md
index 6ece538e2ff1..e799a6f579b3 100644
--- a/docs/_spec/13-syntax-summary.md
+++ b/docs/_spec/13-syntax-summary.md
@@ -14,14 +14,14 @@ The lexical syntax of Scala is given by the following grammar in EBNF form:
 
 ```ebnf
 whiteSpace       ::=  ‘\u0020’ | ‘\u0009’ | ‘\u000D’ | ‘\u000A’
-upper            ::=  ‘A’ | … | ‘Z’ | ‘$’ and any character in Unicode categories Lu, Lt or Nl,
+upper            ::=  ‘A’ | ... | ‘Z’ | ‘$’ and any character in Unicode categories Lu, Lt or Nl,
                       and any character in Unicode categories Lo and Lm that doesn't have
                       contributory property Other_Lowercase
-lower            ::=  ‘a’ | … | ‘z’ | ‘_’ and any character in Unicode category Ll,
+lower            ::=  ‘a’ | ... | ‘z’ | ‘_’ and any character in Unicode category Ll,
                       and any character in Unicode categories Lo or Lm that has contributory
                       property Other_Lowercase
 letter           ::=  upper | lower
-digit            ::=  ‘0’ | … | ‘9’
+digit            ::=  ‘0’ | ... | ‘9’
 paren            ::=  ‘(’ | ‘)’ | ‘[’ | ‘]’ | ‘{’ | ‘}’
 delim            ::=  ‘`’ | ‘'’ | ‘"’ | ‘.’ | ‘;’ | ‘,’
 opchar           ::=  ‘!’ | ‘#’ | ‘%’ | ‘&’ | ‘*’ | ‘+’ | ‘-’ | ‘/’ | ‘:’ |
@@ -29,7 +29,7 @@ opchar           ::=  ‘!’ | ‘#’ | ‘%’ | ‘&’ | ‘*’ | ‘+’
                       and any character in Unicode categories Sm or So
 printableChar    ::=  all characters in [\u0020, \u007E] inclusive
 UnicodeEscape    ::=  ‘\’ ‘u’ {‘u’} hexDigit hexDigit hexDigit hexDigit
-hexDigit         ::=  ‘0’ | … | ‘9’ | ‘A’ | … | ‘F’ | ‘a’ | … | ‘f’
+hexDigit         ::=  ‘0’ | ... | ‘9’ | ‘A’ | ... | ‘F’ | ‘a’ | ... | ‘f’
 charEscapeSeq    ::=  ‘\’ (‘b’ | ‘t’ | ‘n’ | ‘f’ | ‘r’ | ‘"’ | ‘'’ | ‘\’)
 escapeSeq        ::=  UnicodeEscape | charEscapeSeq
 op               ::=  opchar {opchar}
diff --git a/docs/_spec/TODOreference/changed-features/overload-resolution.md b/docs/_spec/TODOreference/changed-features/overload-resolution.md
index bd7782ded520..621515c2a7f8 100644
--- a/docs/_spec/TODOreference/changed-features/overload-resolution.md
+++ b/docs/_spec/TODOreference/changed-features/overload-resolution.md
@@ -66,11 +66,11 @@ as follows:
 
 Replace the sentence
 
-> Otherwise, let `S1,…,Sm` be the vector of types obtained by typing each argument with an undefined expected type.
+> Otherwise, let `S1,...,Sm` be the vector of types obtained by typing each argument with an undefined expected type.
 
 with the following paragraph:
 
-> Otherwise, let `S1,…,Sm` be the vector of known types of all argument types, where the _known type_ of an argument `E`
+> Otherwise, let `S1,...,Sm` be the vector of known types of all argument types, where the _known type_ of an argument `E`
 is determined as followed:
 
  - If `E` is a function value `(p_1, ..., p_n) => B` that misses some parameter types, the known type
diff --git a/docs/_spec/TODOreference/syntax.md b/docs/_spec/TODOreference/syntax.md
index e11629c8eaf9..d3526783a5eb 100644
--- a/docs/_spec/TODOreference/syntax.md
+++ b/docs/_spec/TODOreference/syntax.md
@@ -26,7 +26,7 @@ hexadecimal code:
 
 ```
 UnicodeEscape ::= ‘\’ ‘u’ {‘u’} hexDigit hexDigit hexDigit hexDigit
-hexDigit      ::= ‘0’ | … | ‘9’ | ‘A’ | … | ‘F’ | ‘a’ | … | ‘f’
+hexDigit      ::= ‘0’ | ... | ‘9’ | ‘A’ | ... | ‘F’ | ‘a’ | ... | ‘f’
 ```
 
 Informal descriptions are typeset as `“some comment”`.
@@ -38,15 +38,15 @@ form.
 
 ```
 whiteSpace       ::=  ‘\u0020’ | ‘\u0009’ | ‘\u000D’ | ‘\u000A’
-upper            ::=  ‘A’ | … | ‘Z’ | ‘\$’ | ‘_’  “… and Unicode category Lu”
-lower            ::=  ‘a’ | … | ‘z’ “… and Unicode category Ll”
-letter           ::=  upper | lower “… and Unicode categories Lo, Lt, Nl”
-digit            ::=  ‘0’ | … | ‘9’
+upper            ::=  ‘A’ | ... | ‘Z’ | ‘\$’ | ‘_’  “... and Unicode category Lu”
+lower            ::=  ‘a’ | ... | ‘z’ “... and Unicode category Ll”
+letter           ::=  upper | lower “... and Unicode categories Lo, Lt, Nl”
+digit            ::=  ‘0’ | ... | ‘9’
 paren            ::=  ‘(’ | ‘)’ | ‘[’ | ‘]’ | ‘{’ | ‘}’
 delim            ::=  ‘`’ | ‘'’ | ‘"’ | ‘.’ | ‘;’ | ‘,’
 opchar           ::=  ‘!’ | ‘#’ | ‘%’ | ‘&’ | ‘*’ | ‘+’ | ‘-’ | ‘/’ | ‘:’ |
                       ‘<’ | ‘=’ | ‘>’ | ‘?’ | ‘@’ | ‘\’ | ‘^’ | ‘|’ | ‘~’
-                      “… and Unicode categories Sm, So”
+                      “... and Unicode categories Sm, So”
 printableChar    ::=  “all characters in [\u0020, \u007E] inclusive”
 charEscapeSeq    ::=  ‘\’ (‘b’ | ‘t’ | ‘n’ | ‘f’ | ‘r’ | ‘"’ | ‘'’ | ‘\’)
 
@@ -65,7 +65,7 @@ spliceId         ::=  ‘$’ alphaid ;
 integerLiteral   ::=  (decimalNumeral | hexNumeral) [‘L’ | ‘l’]
 decimalNumeral   ::=  ‘0’ | nonZeroDigit [{digit | ‘_’} digit]
 hexNumeral       ::=  ‘0’ (‘x’ | ‘X’) hexDigit [{hexDigit | ‘_’} hexDigit]
-nonZeroDigit     ::=  ‘1’ | … | ‘9’
+nonZeroDigit     ::=  ‘1’ | ... | ‘9’
 
 floatingPointLiteral
                  ::=  [decimalNumeral] ‘.’ digit [{digit | ‘_’} digit] [exponentPart] [floatType]

From 14a80c25027bdb7b1ddee864351761193c77a8fa Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Fri, 14 Oct 2022 14:46:14 +0200
Subject: [PATCH 105/657] replace \ldots by ...

---
 docs/_spec/03-types.md                        | 122 +++++------
 .../04-basic-declarations-and-definitions.md  |  50 ++---
 docs/_spec/05-classes-and-objects.md          |  54 ++---
 docs/_spec/06-expressions.md                  | 200 +++++++++---------
 docs/_spec/07-implicits.md                    |  32 +--
 docs/_spec/08-pattern-matching.md             | 124 +++++------
 docs/_spec/09-top-level-definitions.md        |   6 +-
 docs/_spec/11-annotations.md                  |   2 +-
 docs/_spec/12-the-scala-standard-library.md   |  52 ++---
 9 files changed, 321 insertions(+), 321 deletions(-)

diff --git a/docs/_spec/03-types.md b/docs/_spec/03-types.md
index cd70a4e34373..205af416b9c5 100644
--- a/docs/_spec/03-types.md
+++ b/docs/_spec/03-types.md
@@ -191,16 +191,16 @@ SimpleType      ::=  SimpleType TypeArgs
 TypeArgs        ::=  ‘[’ Types ‘]’
 ```
 
-A _parameterized type_ ´T[ T_1 , \ldots , T_n ]´ consists of a type
-designator ´T´ and type parameters ´T_1 , \ldots , T_n´ where
+A _parameterized type_ ´T[ T_1, ..., T_n ]´ consists of a type
+designator ´T´ and type parameters ´T_1, ..., T_n´ where
 ´n \geq 1´. ´T´ must refer to a type constructor which takes ´n´ type
-parameters ´a_1 , \ldots , a_n´.
+parameters ´a_1, ..., a_n´.
 
-Say the type parameters have lower bounds ´L_1 , \ldots , L_n´ and
-upper bounds ´U_1, \ldots, U_n´.  The parameterized type is
+Say the type parameters have lower bounds ´L_1, ..., L_n´ and
+upper bounds ´U_1, ..., U_n´.  The parameterized type is
 well-formed if each actual type parameter
 _conforms to its bounds_, i.e. ´\sigma L_i <: T_i <: \sigma U_i´ where ´\sigma´ is the
-substitution ´[ a_1 := T_1 , \ldots , a_n := T_n ]´.
+substitution ´[ a_1 := T_1, ..., a_n := T_n ]´.
 
 ###### Example Parameterized Types
 
@@ -251,8 +251,8 @@ G[S, Int]             // illegal: S constrains its parameter to
 SimpleType    ::=   ‘(’ Types ‘)’
 ```
 
-A _tuple type_ ´(T_1 , \ldots , T_n)´ is an alias for the
-class `scala.Tuple´n´[´T_1´, … , ´T_n´]`, where ´n \geq 2´.
+A _tuple type_ ´(T_1 , ... , T_n)´ is an alias for the
+class `scala.Tuple´n´[´T_1´, ... , ´T_n´]`, where ´n \geq 2´.
 
 Tuple classes are case classes whose fields can be accessed using
 selectors `_1`, ..., `_n`. Their functionality is
@@ -279,9 +279,9 @@ trait Product´_n´[+´T_1´, ..., +´T_n´] {
 AnnotType  ::=  SimpleType {Annotation}
 ```
 
-An _annotated type_ ´T´ ´a_1, \ldots, a_n´
+An _annotated type_ ´T´ ´a_1, ..., a_n´
 attaches [annotations](11-annotations.html#user-defined-annotations)
-´a_1 , \ldots , a_n´ to the type ´T´.
+´a_1, ..., a_n´ to the type ´T´.
 
 ###### Example
 
@@ -304,10 +304,10 @@ RefineStat      ::=  Dcl
 
 A _compound type_ ´T_1´ `with` ... `with` ´T_n \\{ R \\}´
 represents objects with members as given in the component types
-´T_1 , \ldots , T_n´ and the refinement ´\\{ R \\}´. A refinement
+´T_1, ..., T_n´ and the refinement ´\\{ R \\}´. A refinement
 ´\\{ R \\}´ contains declarations and type definitions.
 If a declaration or definition overrides a declaration or definition in
-one of the component types ´T_1 , \ldots , T_n´, the usual rules for
+one of the component types ´T_1, ..., T_n´, the usual rules for
 [overriding](05-classes-and-objects.html#overriding) apply; otherwise the declaration
 or definition is said to be “structural” [^2].
 
@@ -380,13 +380,13 @@ ending in a colon ‘:’ are right-associative; all other
 operators are left-associative.
 
 In a sequence of consecutive type infix operations
-´t_0 \, \mathit{op} \, t_1 \, \mathit{op_2} \, \ldots \, \mathit{op_n} \, t_n´,
-all operators ´\mathit{op}\_1 , \ldots , \mathit{op}\_n´ must have the same
+´t_0 \, \mathit{op} \, t_1 \, \mathit{op_2} \, ... \, \mathit{op_n} \, t_n´,
+all operators ´\mathit{op}\_1, ..., \mathit{op}\_n´ must have the same
 associativity. If they are all left-associative, the sequence is
 interpreted as
-´(\ldots (t_0 \mathit{op_1} t_1) \mathit{op_2} \ldots) \mathit{op_n} t_n´,
+´(... (t_0 \mathit{op_1} t_1) \mathit{op_2} ...) \mathit{op_n} t_n´,
 otherwise it is interpreted as
-´t_0 \mathit{op_1} (t_1 \mathit{op_2} ( \ldots \mathit{op_n} t_n) \ldots)´.
+´t_0 \mathit{op_1} (t_1 \mathit{op_2} ( ... \mathit{op_n} t_n) ...)´.
 
 ### Function Types
 
@@ -396,8 +396,8 @@ FunctionArgs      ::=  InfixType
                     |  ‘(’ [ ParamType {‘,’ ParamType } ] ‘)’
 ```
 
-The type ´(T_1 , \ldots , T_n) \Rightarrow U´ represents the set of function
-values that take arguments of types ´T_1 , \ldots , Tn´ and yield
+The type ´(T_1, ..., T_n) \Rightarrow U´ represents the set of function
+values that take arguments of types ´T_1, ..., Tn´ and yield
 results of type ´U´.  In the case of exactly one argument type
 ´T \Rightarrow U´ is a shorthand for ´(T) \Rightarrow U´.
 An argument type of the form ´\Rightarrow T´
@@ -589,10 +589,10 @@ report as the internal types of defined identifiers.
 ### Method Types
 
 A _method type_ is denoted internally as ´(\mathit{Ps})U´, where ´(\mathit{Ps})´
-is a sequence of parameter names and types ´(p_1:T_1 , \ldots , p_n:T_n)´
+is a sequence of parameter names and types ´(p_1:T_1, ..., p_n:T_n)´
 for some ´n \geq 0´ and ´U´ is a (value or method) type.  This type
-represents named methods that take arguments named ´p_1 , \ldots , p_n´
-of types ´T_1 , \ldots , T_n´
+represents named methods that take arguments named ´p_1, ..., p_n´
+of types ´T_1, ..., T_n´
 and that return a result of type ´U´.
 
 Method types associate to the right: ´(\mathit{Ps}\_1)(\mathit{Ps}\_2)U´ is
@@ -629,13 +629,13 @@ c: (Int) (String, String) String
 
 A polymorphic method type is denoted internally as `[´\mathit{tps}\,´]´T´` where
 `[´\mathit{tps}\,´]` is a type parameter section
-`[´a_1´ >: ´L_1´ <: ´U_1 , \ldots , a_n´ >: ´L_n´ <: ´U_n´]`
+`[´a_1´ >: ´L_1´ <: ´U_1, ..., a_n´ >: ´L_n´ <: ´U_n´]`
 for some ´n \geq 0´ and ´T´ is a
 (value or method) type.  This type represents named methods that
-take type arguments `´S_1 , \ldots , S_n´` which
+take type arguments `´S_1, ..., S_n´` which
 [conform](#parameterized-types) to the lower bounds
-`´L_1 , \ldots , L_n´` and the upper bounds
-`´U_1 , \ldots , U_n´` and that yield results of type ´T´.
+`´L_1, ..., L_n´` and the upper bounds
+`´U_1, ..., U_n´` and that yield results of type ´T´.
 
 ###### Example
 
@@ -656,7 +656,7 @@ union : [A >: Nothing <: Comparable[A]] (x: Set[A], xs: Set[A]) Set[A]
 ### Type Constructors
 
 A _type constructor_ is represented internally much like a polymorphic method type.
-`[´\pm´ ´a_1´ >: ´L_1´ <: ´U_1 , \ldots , \pm a_n´ >: ´L_n´ <: ´U_n´] ´T´`
+`[´\pm´ ´a_1´ >: ´L_1´ <: ´U_1, ..., \pm a_n´ >: ´L_n´ <: ´U_n´] ´T´`
 represents a type that is expected by a
 [type constructor parameter](04-basic-declarations-and-definitions.html#type-parameters) or an
 [abstract type constructor binding](04-basic-declarations-and-definitions.html#type-declarations-and-type-aliases) with
@@ -681,15 +681,15 @@ anonymous type `[+X] Iterable[X]`, which may be passed to the
 More than one values or methods are defined in the same scope with the
 same name, we model
 
-An overloaded type consisting of type alternatives ´T_1 \commadots T_n (n \geq 2)´ is denoted internally ´T_1 \overload \ldots \overload T_n´.
+An overloaded type consisting of type alternatives ´T_1 \commadots T_n (n \geq 2)´ is denoted internally ´T_1 \overload ... \overload T_n´.
 
 ###### Example
 ```scala
 def println(): Unit
-def println(s: String): Unit = ´\ldots´
-def println(x: Float): Unit = ´\ldots´
-def println(x: Float, width: Int): Unit = ´\ldots´
-def println[A](x: A)(tostring: A => String): Unit = ´\ldots´
+def println(s: String): Unit = ...
+def println(x: Float): Unit = ...
+def println(x: Float, width: Int): Unit = ...
+def println[A](x: A)(tostring: A => String): Unit = ...
 ```
 define a single function `println` which has an overloaded
 type.
@@ -703,7 +703,7 @@ println:  () Unit ´\overload´
 
 ###### Example
 ```scala
-def f(x: T): T = ´\ldots´
+def f(x: T): T = ...
 val f = 0
 ```
 define a function `f} which has type `(x: T)T ´\overload´ Int`.
@@ -722,25 +722,25 @@ These notions are defined mutually recursively as follows.
 
 1. The set of _base types_ of a type is a set of class types,
    given as follows.
-  - The base types of a class type ´C´ with parents ´T_1 , \ldots , T_n´ are
+  - The base types of a class type ´C´ with parents ´T_1, ..., T_n´ are
     ´C´ itself, as well as the base types of the compound type
     `´T_1´ with ... with ´T_n´ { ´R´ }`.
   - The base types of an aliased type are the base types of its alias.
   - The base types of an abstract type are the base types of its upper bound.
   - The base types of a parameterized type
-    `´C´[´T_1 , \ldots , T_n´]` are the base types
+    `´C´[´T_1, ..., T_n´]` are the base types
     of type ´C´, where every occurrence of a type parameter ´a_i´
     of ´C´ has been replaced by the corresponding parameter type ´T_i´.
   - The base types of a singleton type `´p´.type` are the base types of
     the type of ´p´.
   - The base types of a compound type
-    `´T_1´ with ´\ldots´ with ´T_n´ { ´R´ }`
+    `´T_1´ with ... with ´T_n´ { ´R´ }`
     are the _reduced union_ of the base
     classes of all ´T_i´'s. This means:
     Let the multi-set ´\mathscr{S}´ be the multi-set-union of the
     base types of all ´T_i´'s.
     If ´\mathscr{S}´ contains several type instances of the same class, say
-    `´S^i´#´C´[´T^i_1 , \ldots , T^i_n´]` ´(i \in I)´, then
+    `´S^i´#´C´[´T^i_1, ..., T^i_n´]` ´(i \in I)´, then
     all those instances
     are replaced by one of them which conforms to all
     others. It is an error if no such instance exists. It follows that the
@@ -759,15 +759,15 @@ These notions are defined mutually recursively as follows.
 1. The notion of a type ´T´ _in class ´C´ seen from some prefix type ´S´_
    makes sense only if the prefix type ´S´
    has a type instance of class ´C´ as a base type, say
-   `´S'´#´C´[´T_1 , \ldots , T_n´]`. Then we define as follows.
+   `´S'´#´C´[´T_1, ..., T_n´]`. Then we define as follows.
     - If `´S´ = ´\epsilon´.type`, then ´T´ in ´C´ seen from ´S´ is
       ´T´ itself.
     - Otherwise, if ´S´ is an existential type `´S'´ forSome { ´Q´ }`, and
       ´T´ in ´C´ seen from ´S'´ is ´T'´,
       then ´T´ in ´C´ seen from ´S´ is `´T'´ forSome {´\,Q\,´}`.
     - Otherwise, if ´T´ is the ´i´'th type parameter of some class ´D´, then
-        - If ´S´ has a base type `´D´[´U_1 , \ldots , U_n´]`, for some type
-          parameters `[´U_1 , \ldots , U_n´]`, then ´T´ in ´C´ seen from ´S´
+        - If ´S´ has a base type `´D´[´U_1, ..., U_n´]`, for some type
+          parameters `[´U_1, ..., U_n´]`, then ´T´ in ´C´ seen from ´S´
           is ´U_i´.
         - Otherwise, if ´C´ is defined in a class ´C'´, then
           ´T´ in ´C´ seen from ´S´ is the same as ´T´ in ´C'´ seen from ´S'´.
@@ -863,19 +863,19 @@ The conformance relation ´(<:)´ is the smallest transitive relation that satis
 - A type projection `´T´#´t´` conforms to `´U´#´t´` if ´T´ conforms to ´U´.
 - A parameterized type `´T´[´T_1´, ..., ´T_n´]` conforms to
   `´T´[´U_1´, ..., ´U_n´]` if
-  the following three conditions hold for ´i \in \{ 1 , \ldots , n \}´:
+  the following three conditions hold for ´i \in \{ 1, ..., n \}´:
  1. If the ´i´'th type parameter of ´T´ is declared covariant, then
        ´T_i <: U_i´.
  1. If the ´i´'th type parameter of ´T´ is declared contravariant, then
        ´U_i <: T_i´.
  1. If the ´i´'th type parameter of ´T´ is declared neither covariant
        nor contravariant, then ´U_i \equiv T_i´.
-- A compound type `´T_1´ with ´\ldots´ with ´T_n´ {´R\,´}` conforms to
+- A compound type `´T_1´ with ... with ´T_n´ {´R\,´}` conforms to
   each of its component types ´T_i´.
-- If ´T <: U_i´ for ´i \in \{ 1 , \ldots , n \}´ and for every
+- If ´T <: U_i´ for ´i \in \{ 1, ..., n \}´ and for every
   binding ´d´ of a type or value ´x´ in ´R´ there exists a member
   binding of ´x´ in ´T´ which subsumes ´d´, then ´T´ conforms to the
-  compound type `´U_1´ with ´\ldots´ with ´U_n´ {´R\,´}`.
+  compound type `´U_1´ with ... with ´U_n´ {´R\,´}`.
 - The existential type `´T´ forSome {´\,Q\,´}` conforms to
   ´U´ if its [skolemization](#existential-types)
   conforms to ´U´.
@@ -883,25 +883,25 @@ The conformance relation ´(<:)´ is the smallest transitive relation that satis
   if ´T´ conforms to one of the [type instances](#existential-types)
   of `´U´ forSome {´\,Q\,´}`.
 - If
-  ´T_i \equiv T_i'´ for ´i \in \{ 1 , \ldots , n\}´ and ´U´ conforms to ´U'´
-  then the method type ´(p_1:T_1 , \ldots , p_n:T_n) U´ conforms to
-  ´(p_1':T_1' , \ldots , p_n':T_n') U'´.
+  ´T_i \equiv T_i'´ for ´i \in \{ 1, ..., n\}´ and ´U´ conforms to ´U'´
+  then the method type ´(p_1:T_1, ..., p_n:T_n) U´ conforms to
+  ´(p_1':T_1', ..., p_n':T_n') U'´.
 - The polymorphic type
-  ´[a_1 >: L_1 <: U_1 , \ldots , a_n >: L_n <: U_n] T´ conforms to the
+  ´[a_1 >: L_1 <: U_1, ..., a_n >: L_n <: U_n] T´ conforms to the
   polymorphic type
-  ´[a_1 >: L_1' <: U_1' , \ldots , a_n >: L_n' <: U_n'] T'´ if, assuming
-  ´L_1' <: a_1 <: U_1' , \ldots , L_n' <: a_n <: U_n'´
+  ´[a_1 >: L_1' <: U_1', ..., a_n >: L_n' <: U_n'] T'´ if, assuming
+  ´L_1' <: a_1 <: U_1', ..., L_n' <: a_n <: U_n'´
   one has ´T <: T'´ and ´L_i <: L_i'´ and ´U_i' <: U_i´
-  for ´i \in \{ 1 , \ldots , n \}´.
+  for ´i \in \{ 1, ..., n \}´.
 - Type constructors ´T´ and ´T'´ follow a similar discipline. We characterize
   ´T´ and ´T'´ by their type parameter clauses
-  ´[a_1 , \ldots , a_n]´ and
-  ´[a_1' , \ldots , a_n']´, where an ´a_i´ or ´a_i'´ may include a variance
+  ´[a_1, ..., a_n]´ and
+  ´[a_1', ..., a_n']´, where an ´a_i´ or ´a_i'´ may include a variance
   annotation, a higher-order type parameter clause, and bounds. Then, ´T´
-  conforms to ´T'´ if any list ´[t_1 , \ldots , t_n]´ -- with declared
+  conforms to ´T'´ if any list ´[t_1, ..., t_n]´ -- with declared
   variances, bounds and higher-order type parameter clauses -- of valid type
   arguments for ´T'´ is also a valid list of type arguments for ´T´ and
-  ´T[t_1 , \ldots , t_n] <: T'[t_1 , \ldots , t_n]´. Note that this entails
+  ´T[t_1, ..., t_n] <: T'[t_1, ..., t_n]´. Note that this entails
   that:
     - The bounds on ´a_i´ must be weaker than the corresponding bounds declared
       for ´a'_i´.
@@ -1027,11 +1027,11 @@ A type is _volatile_ if it falls into one of four categories:
 A compound type `´T_1´ with ... with ´T_n´ {´R\,´}`
 is volatile if one of the following three conditions hold.
 
-1. One of ´T_2 , \ldots , T_n´ is a type parameter or abstract type, or
+1. One of ´T_2, ..., T_n´ is a type parameter or abstract type, or
 1. ´T_1´ is an abstract type and either the refinement ´R´
    or a type ´T_j´ for ´j > 1´ contributes an abstract member
    to the compound type, or
-1. one of ´T_1 , \ldots , T_n´ is a singleton type.
+1. one of ´T_1, ..., T_n´ is a singleton type.
 
 Here, a type ´S´ _contributes an abstract member_ to a type ´T´ if
 ´S´ contains an abstract member that is also a member of ´T´.
@@ -1059,18 +1059,18 @@ The erasure mapping is defined as follows.
 - The erasure of an abstract type is the erasure of its upper bound.
 - The erasure of the parameterized type `scala.Array´[T_1]´` is
  `scala.Array´[|T_1|]´`.
-- The erasure of every other parameterized type ´T[T_1 , \ldots , T_n]´ is ´|T|´.
+- The erasure of every other parameterized type ´T[T_1, ..., T_n]´ is ´|T|´.
 - The erasure of a singleton type `´p´.type` is the
   erasure of the type of ´p´.
 - The erasure of a type projection `´T´#´x´` is `|´T´|#´x´`.
 - The erasure of a compound type
-  `´T_1´ with ´\ldots´ with ´T_n´ {´R\,´}` is the erasure of the intersection
-  dominator of ´T_1 , \ldots , T_n´.
+  `´T_1´ with ... with ´T_n´ {´R\,´}` is the erasure of the intersection
+  dominator of ´T_1, ..., T_n´.
 - The erasure of an existential type `´T´ forSome {´\,Q\,´}` is ´|T|´.
 
-The _intersection dominator_ of a list of types ´T_1 , \ldots , T_n´ is computed
+The _intersection dominator_ of a list of types ´T_1, ..., T_n´ is computed
 as follows.
-Let ´T_{i_1} , \ldots , T_{i_m}´ be the subsequence of types ´T_i´
+Let ´T_{i_1}, ..., T_{i_m}´ be the subsequence of types ´T_i´
 which are not supertypes of some other type ´T_j´.
 If this subsequence contains a type designator ´T_c´ that refers to a class
 which is not a trait,
diff --git a/docs/_spec/04-basic-declarations-and-definitions.md b/docs/_spec/04-basic-declarations-and-definitions.md
index acaf2491d99b..0dd311e558b8 100644
--- a/docs/_spec/04-basic-declarations-and-definitions.md
+++ b/docs/_spec/04-basic-declarations-and-definitions.md
@@ -32,7 +32,7 @@ associate term names with types.
 The scope of a name introduced by a declaration or definition is the
 whole statement sequence containing the binding.  However, there is a
 restriction on forward references in blocks: In a statement sequence
-´s_1 \ldots s_n´ making up a block, if a simple name in ´s_i´ refers
+´s_1 ... s_n´ making up a block, if a simple name in ´s_i´ refers
 to an entity defined by ´s_j´ where ´j \geq i´, then for all ´s_k´
 between and including ´s_i´ and ´s_j´,
 
@@ -138,12 +138,12 @@ as left-hand side.  If ´p´ is some pattern other
 than a simple name or a name followed by a colon and a type, then the
 value definition `val ´p´ = ´e´` is expanded as follows:
 
-1. If the pattern ´p´ has bound variables ´x_1 , \ldots , x_n´, where ´n > 1´:
+1. If the pattern ´p´ has bound variables ´x_1, ..., x_n´, where ´n > 1´:
 
 ```scala
-val ´\$x´ = ´e´ match {case ´p´ => (´x_1 , \ldots , x_n´)}
+val ´\$x´ = ´e´ match {case ´p´ => (´x_1, ..., x_n´)}
 val ´x_1´ = ´\$x´._1
-´\ldots´
+...
 val ´x_n´ = ´\$x´._n
 ```
 
@@ -184,11 +184,11 @@ val xs = x´\$´._2
 
 The name of any declared or defined value may not end in `_=`.
 
-A value declaration `val ´x_1 , \ldots , x_n´: ´T´` is a shorthand for the
+A value declaration `val ´x_1, ..., x_n´: ´T´` is a shorthand for the
 sequence of value declarations `val ´x_1´: ´T´; ...; val ´x_n´: ´T´`.
-A value definition `val ´p_1 , \ldots , p_n´ = ´e´` is a shorthand for the
+A value definition `val ´p_1, ..., p_n´ = ´e´` is a shorthand for the
 sequence of value definitions `val ´p_1´ = ´e´; ...; val ´p_n´ = ´e´`.
-A value definition `val ´p_1 , \ldots , p_n: T´ = ´e´` is a shorthand for the
+A value definition `val ´p_1, ..., p_n: T´ = ´e´` is a shorthand for the
 sequence of value definitions `val ´p_1: T´ = ´e´; ...; val ´p_n: T´ = ´e´`.
 
 ## Variable Declarations and Definitions
@@ -283,11 +283,11 @@ d.hours = 8; d.minutes = 30; d.seconds = 0
 d.hours = 25                  // throws a DateError exception
 ```
 
-A variable declaration `var ´x_1 , \ldots , x_n´: ´T´` is a shorthand for the
+A variable declaration `var ´x_1, ..., x_n´: ´T´` is a shorthand for the
 sequence of variable declarations `var ´x_1´: ´T´; ...; var ´x_n´: ´T´`.
-A variable definition `var ´x_1 , \ldots , x_n´ = ´e´` is a shorthand for the
+A variable definition `var ´x_1, ..., x_n´ = ´e´` is a shorthand for the
 sequence of variable definitions `var ´x_1´ = ´e´; ...; var ´x_n´ = ´e´`.
-A variable definition `var ´x_1 , \ldots , x_n: T´ = ´e´` is a shorthand for
+A variable definition `var ´x_1, ..., x_n: T´ = ´e´` is a shorthand for
 the sequence of variable definitions
 `var ´x_1: T´ = ´e´; ...; var ´x_n: T´ = ´e´`.
 
@@ -407,7 +407,7 @@ definitions with lower bounds `>: ´L´` and upper bounds
 is deferred to [here](07-implicits.html#context-bounds-and-view-bounds).
 
 The most general form of a proper type parameter is
-`´@a_1 \ldots @a_n´ ´\pm´ ´t´ >: ´L´ <: ´U´`.
+`´@a_1 ... @a_n´ ´\pm´ ´t´ >: ´L´ <: ´U´`.
 Here, ´L´, and ´U´ are lower and upper bounds that
 constrain possible type arguments for the parameter.  It is a
 compile-time error if ´L´ does not conform to ´U´. ´\pm´ is a _variance_, i.e. an optional prefix of either `+`, or
@@ -426,7 +426,7 @@ TODO: this is a pretty awkward description of scoping and distinctness of binder
 
 The names of all type parameters must be pairwise different in their enclosing type parameter clause.  The scope of a type parameter includes in each case the whole type parameter clause. Therefore it is possible that a type parameter appears as part of its own bounds or the bounds of other type parameters in the same clause.  However, a type parameter may not be bounded directly or indirectly by itself.
 
-A type constructor parameter adds a nested type parameter clause to the type parameter. The most general form of a type constructor parameter is `´@a_1 \ldots @a_n \pm t[\mathit{tps}\,]´ >: ´L´ <: ´U´`.
+A type constructor parameter adds a nested type parameter clause to the type parameter. The most general form of a type constructor parameter is `´@a_1 ... @a_n \pm t[\mathit{tps}\,]´ >: ´L´ <: ´U´`.
 
 The above scoping restrictions are generalized to the case of nested type parameter clauses, which declare higher-order type parameters. Higher-order type parameters (the type parameters of a type parameter ´t´) are only visible in their immediately surrounding parameter clause (possibly including clauses at a deeper nesting level) and in the bounds of ´t´. Therefore, their names must only be pairwise different from the names of other visible parameters. Since the names of higher-order type parameters are thus often irrelevant, they may be denoted with a `‘_’`, which is nowhere visible.
 
@@ -491,11 +491,11 @@ changes at the following constructs.
 - The type of a mutable variable is always in invariant position.
 - The right-hand side of a type alias is always in invariant position.
 - The prefix ´S´ of a type selection `´S´#´T´` is always in invariant position.
-- For a type argument ´T´ of a type `´S´[´\ldots T \ldots´ ]`: If the
+- For a type argument ´T´ of a type `´S´[´... T ...´ ]`: If the
   corresponding type parameter is invariant, then ´T´ is in
   invariant position.  If the corresponding type parameter is
   contravariant, the variance position of ´T´ is the opposite of
-  the variance position of the enclosing type `´S´[´\ldots T \ldots´ ]`.
+  the variance position of the enclosing type `´S´[´... T ...´ ]`.
 
 <!-- TODO: handle type aliases -->
 
@@ -602,7 +602,7 @@ signature and ´T´ is its result type. A _function definition_
 i.e. an expression which defines the function's result.  A parameter
 signature consists of an optional type parameter clause `[´\mathit{tps}\,´]`,
 followed by zero or more value parameter clauses
-`(´\mathit{ps}_1´)´\ldots´(´\mathit{ps}_n´)`.  Such a declaration or definition
+`(´\mathit{ps}_1´)...(´\mathit{ps}_n´)`.  Such a declaration or definition
 introduces a value with a (possibly polymorphic) method type whose
 parameter types and result type are as given.
 
@@ -635,7 +635,7 @@ For every parameter ´p_{i,j}´ with a default argument a method named
 expression. Here, ´n´ denotes the parameter's position in the method
 declaration. These methods are parametrized by the type parameter clause
 `[´\mathit{tps}\,´]` and all value parameter clauses
-`(´\mathit{ps}_1´)´\ldots´(´\mathit{ps}_{i-1}´)` preceding ´p_{i,j}´.
+`(´\mathit{ps}_1´)...(´\mathit{ps}_{i-1}´)` preceding ´p_{i,j}´.
 The `´f\$´default´\$´n` methods are inaccessible for user programs.
 
 ###### Example
@@ -717,17 +717,17 @@ _repeated_ parameter inside the method is then the sequence type
 `scala.Seq[´T´]`.  Methods with repeated parameters
 `´T´*` take a variable number of arguments of type ´T´.
 That is, if a method ´m´ with type
-`(´p_1:T_1 , \ldots , p_n:T_n, p_s:S´*)´U´` is applied to arguments
-´(e_1 , \ldots , e_k)´ where ´k \geq n´, then ´m´ is taken in that application
-to have type ´(p_1:T_1 , \ldots , p_n:T_n, p_s:S , \ldots , p_{s'}:S)U´, with
+`(´p_1:T_1, ..., p_n:T_n, p_s:S´*)´U´` is applied to arguments
+´(e_1, ..., e_k)´ where ´k \geq n´, then ´m´ is taken in that application
+to have type ´(p_1:T_1, ..., p_n:T_n, p_s:S, ..., p_{s'}:S)U´, with
 ´k - n´ occurrences of type
 ´S´ where any parameter names beyond ´p_s´ are fresh. The only exception to
 this rule is if the last argument is
 marked to be a _sequence argument_ via a `_*` type
 annotation. If ´m´ above is applied to arguments
-`(´e_1 , \ldots , e_n, e'´: _*)`, then the type of ´m´ in
+`(´e_1, ..., e_n, e'´: _*)`, then the type of ´m´ in
 that application is taken to be
-`(´p_1:T_1, \ldots , p_n:T_n,p_{s}:´scala.Seq[´S´])`.
+`(´p_1:T_1, ... , p_n:T_n,p_{s}:´scala.Seq[´S´])`.
 
 It is not allowed to define any default arguments in a parameter section
 with a repeated parameter.
@@ -875,7 +875,7 @@ _importable_ if it is [accessible](05-classes-and-objects.html#modifiers).
 The most general form of an import expression is a list of _import selectors_
 
 ```scala
-{ ´x_1´ => ´y_1 , \ldots , x_n´ => ´y_n´, _ }
+{ ´x_1´ => ´y_1, ..., x_n´ => ´y_n´, _ }
 ```
 
 for ´n \geq 0´, where the final wildcard `‘_’` may be absent.  It
@@ -883,7 +883,7 @@ makes available each importable member `´p´.´x_i´` under the unqualified nam
 ´y_i´. I.e. every import selector `´x_i´ => ´y_i´` renames
 `´p´.´x_i´` to
 ´y_i´.  If a final wildcard is present, all importable members ´z´ of
-´p´ other than `´x_1 , \ldots , x_n,y_1 , \ldots , y_n´` are also made available
+´p´ other than `´x_1, ..., x_n,y_1, ..., y_n´` are also made available
 under their own unqualified names.
 
 Import selectors work in the same way for type and term members. For
@@ -918,9 +918,9 @@ i.e. it makes available without qualification all members of ´p´
 (this is analogous to `import ´p´.*` in Java).
 
 An import clause with multiple import expressions
-`import ´p_1´.´I_1 , \ldots , p_n´.´I_n´` is interpreted as a
+`import ´p_1´.´I_1, ..., p_n´.´I_n´` is interpreted as a
 sequence of import clauses
-`import ´p_1´.´I_1´; ´\ldots´; import ´p_n´.´I_n´`.
+`import ´p_1´.´I_1´; ...; import ´p_n´.´I_n´`.
 
 ###### Example
 Consider the object definition:
diff --git a/docs/_spec/05-classes-and-objects.md b/docs/_spec/05-classes-and-objects.md
index 5c3a74e608a2..88ca4de54692 100644
--- a/docs/_spec/05-classes-and-objects.md
+++ b/docs/_spec/05-classes-and-objects.md
@@ -31,10 +31,10 @@ A _template_ defines the type signature, behavior and initial state of a
 trait or class of objects or of a single object. Templates form part of
 instance creation expressions, class definitions, and object
 definitions.  A template
-`´sc´ with ´mt_1´ with ´\ldots´ with ´mt_n´ { ´\mathit{stats}´ }`
+`´sc´ with ´mt_1´ with ... with ´mt_n´ { ´\mathit{stats}´ }`
 consists of a constructor invocation ´sc´
 which defines the template's _superclass_, trait references
-`´mt_1 , \ldots , mt_n´` ´(n \geq 0)´, which define the
+`´mt_1, ..., mt_n´` ´(n \geq 0)´, which define the
 template's _traits_, and a statement sequence ´\mathit{stats}´ which
 contains initialization code and additional member definitions for the
 template.
@@ -43,7 +43,7 @@ Each trait reference ´mt_i´ must denote a [trait](#traits).
 By contrast, the superclass constructor ´sc´ normally refers to a
 class which is not a trait. It is possible to write a list of
 parents that starts with a trait reference, e.g.
-`´mt_1´ with ´\ldots´ with ´mt_n´`. In that case the list
+`´mt_1´ with ... with ´mt_n´`. In that case the list
 of parents is implicitly extended to include the supertype of ´mt_1´
 as the first parent type. The new supertype must have at least one
 constructor that does not take parameters.  In the following, we will
@@ -53,7 +53,7 @@ constructor, not a trait reference.
 
 The list of parents of a template must be well-formed. This means that
 the class denoted by the superclass constructor ´sc´ must be a
-subclass of the superclasses of all the traits ´mt_1 , \ldots , mt_n´.
+subclass of the superclasses of all the traits ´mt_1, ..., mt_n´.
 In other words, the non-trait classes inherited by a template form a
 chain in the inheritance hierarchy which starts with the template's
 superclass.
@@ -155,12 +155,12 @@ Constr  ::=  AnnotType {‘(’ [Exprs] ‘)’}
 Constructor invocations define the type, members, and initial state of
 objects created by an instance creation expression, or of parts of an
 object's definition which are inherited by a class or object
-definition. A constructor invocation is a function application
-`´x´.´c´[´\mathit{targs}´](´\mathit{args}_1´)´\ldots´(´\mathit{args}_n´)`, where ´x´ is a
+definition. A constructor invocation is a method application
+`´x´.´c´[´\mathit{targs}´](´\mathit{args}_1´)...(´\mathit{args}_n´)`, where ´x´ is a
 [stable identifier](03-types.html#paths), ´c´ is a type name which either designates a
 class or defines an alias type for one, ´\mathit{targs}´ is a type argument
-list, ´\mathit{args}_1 , \ldots , \mathit{args}_n´ are argument lists, and there is a
-constructor of that class which is [applicable](06-expressions.html#function-applications)
+list, ´\mathit{args}_1, ..., \mathit{args}_n´ are argument lists, and there is a
+constructor of that class which is [applicable](06-expressions.html#method-applications)
 to the given arguments. If the constructor invocation uses named or
 default arguments, it is transformed into a block expression using the
 same transformation as described [here](sec:named-default).
@@ -172,11 +172,11 @@ using [local type inference](06-expressions.html#local-type-inference). If no ex
 arguments are given, an empty list `()` is implicitly supplied.
 
 An evaluation of a constructor invocation
-`´x´.´c´[´\mathit{targs}´](´\mathit{args}_1´)´\ldots´(´\mathit{args}_n´)`
+`´x´.´c´[´\mathit{targs}´](´\mathit{args}_1´)...(´\mathit{args}_n´)`
 consists of the following steps:
 
 - First, the prefix ´x´ is evaluated.
-- Then, the arguments ´\mathit{args}_1 , \ldots , \mathit{args}_n´ are evaluated from
+- Then, the arguments ´\mathit{args}_1, ..., \mathit{args}_n´ are evaluated from
   left to right.
 - Finally, the class being constructed is initialized by evaluating the
   template of the class referred to by ´c´.
@@ -193,7 +193,7 @@ Let ´C´ be a class with template
 ´C_1´ with ... with ´C_n´ { ´\mathit{stats}´ }`.
 The _linearization_ of ´C´, ´\mathcal{L}(C)´ is defined as follows:
 $$
-\mathcal{L}(C) = C, \mathcal{L}(C_n) \; \vec{+} \; \ldots \; \vec{+} \; \mathcal{L}(C_1)
+\mathcal{L}(C) = C, \mathcal{L}(C_n) \; \vec{+} \; ... \; \vec{+} \; \mathcal{L}(C_1)
 $$
 
 Here ´\vec{+}´ denotes concatenation where elements of the right operand
@@ -246,7 +246,7 @@ which is not a suffix of the linearization of `Iter`.
 
 ### Class Members
 
-A class ´C´ defined by a template `´C_1´ with ´\ldots´ with ´C_n´ { ´\mathit{stats}´ }`
+A class ´C´ defined by a template `´C_1´ with ... with ´C_n´ { ´\mathit{stats}´ }`
 can define members in its statement sequence
 ´\mathit{stats}´ and can inherit members from all parent classes.  Scala
 adopts Java and C\#'s conventions for static overloading of
@@ -694,7 +694,7 @@ ClassTemplateOpt  ::=  ‘extends’ ClassTemplate | [[‘extends’] TemplateBo
 The most general form of class definition is
 
 ```scala
-class ´c´[´\mathit{tps}\,´] ´as´ ´m´(´\mathit{ps}_1´)´\ldots´(´\mathit{ps}_n´) extends ´t´    ´\quad(n \geq 0)´.
+class ´c´[´\mathit{tps}\,´] ´as´ ´m´(´\mathit{ps}_1´)...(´\mathit{ps}_n´) extends ´t´    ´\quad(n \geq 0)´.
 ```
 
 Here,
@@ -714,7 +714,7 @@ Here,
   - ´m´ is an [access modifier](#modifiers) such as
     `private` or `protected`, possibly with a qualification.
     If such an access modifier is given it applies to the primary constructor of the class.
-  - ´(\mathit{ps}\_1)\ldots(\mathit{ps}\_n)´ are formal value parameter clauses for
+  - ´(\mathit{ps}\_1)...(\mathit{ps}\_n)´ are formal value parameter clauses for
     the _primary constructor_ of the class. The scope of a formal value parameter includes
     all subsequent parameter sections and the template ´t´. However, a formal
     value parameter may not form part of the types of any of the parent classes or members of the class template ´t´.
@@ -737,12 +737,12 @@ Here,
   - ´t´ is a [template](#templates) of the form
 
     ```scala
-    ´sc´ with ´mt_1´ with ´\ldots´ with ´mt_m´ { ´\mathit{stats}´ } // ´m \geq 0´
+    ´sc´ with ´mt_1´ with ... with ´mt_m´ { ´\mathit{stats}´ } // ´m \geq 0´
     ```
 
     which defines the base classes, behavior and initial state of objects of
     the class. The extends clause
-    `extends ´sc´ with ´mt_1´ with ´\ldots´ with ´mt_m´`
+    `extends ´sc´ with ´mt_1´ with ... with ´mt_m´`
     can be omitted, in which case
     `extends scala.AnyRef` is assumed.  The class body
     `{ ´\mathit{stats}´ }` may also be omitted, in which case the empty body
@@ -789,14 +789,14 @@ SelfInvocation ::= ‘this’ ArgumentExprs {ArgumentExprs}
 
 A class may have additional constructors besides the primary
 constructor.  These are defined by constructor definitions of the form
-`def this(´\mathit{ps}_1´)´\ldots´(´\mathit{ps}_n´) = ´e´`.  Such a
+`def this(´\mathit{ps}_1´)...(´\mathit{ps}_n´) = ´e´`.  Such a
 definition introduces an additional constructor for the enclosing
 class, with parameters as given in the formal parameter lists ´\mathit{ps}_1
-, \ldots , \mathit{ps}_n´, and whose evaluation is defined by the constructor
+, ..., \mathit{ps}_n´, and whose evaluation is defined by the constructor
 expression ´e´.  The scope of each formal parameter is the subsequent
 parameter sections and the constructor
 expression ´e´.  A constructor expression is either a self constructor
-invocation `this(´\mathit{args}_1´)´\ldots´(´\mathit{args}_n´)` or a block
+invocation `this(´\mathit{args}_1´)...(´\mathit{args}_n´)` or a block
 which begins with a self constructor invocation. The self constructor
 invocation must construct a generic instance of the class. I.e. if the
 class in question has name ´C´ and type parameters
@@ -861,16 +861,16 @@ implicitly added to such a parameter, unless the parameter already carries
 a `val` or `var` modifier. Hence, an accessor
 definition for the parameter is [generated](#class-definitions).
 
-A case class definition of `´c´[´\mathit{tps}\,´](´\mathit{ps}_1\,´)´\ldots´(´\mathit{ps}_n´)` with type
+A case class definition of `´c´[´\mathit{tps}\,´](´\mathit{ps}_1\,´)...(´\mathit{ps}_n´)` with type
 parameters ´\mathit{tps}´ and value parameters ´\mathit{ps}´ implies
 the definition of a companion object, which serves as an [extractor object](08-pattern-matching.html#extractor-patterns). It has the following shape:
 
 ```scala
 object ´c´ {
-  def apply[´\mathit{tps}\,´](´\mathit{ps}_1\,´)´\ldots´(´\mathit{ps}_n´): ´c´[´\mathit{tps}\,´] = new ´c´[´\mathit{Ts}\,´](´\mathit{xs}_1\,´)´\ldots´(´\mathit{xs}_n´)
+  def apply[´\mathit{tps}\,´](´\mathit{ps}_1\,´)...(´\mathit{ps}_n´): ´c´[´\mathit{tps}\,´] = new ´c´[´\mathit{Ts}\,´](´\mathit{xs}_1\,´)...(´\mathit{xs}_n´)
   def unapply[´\mathit{tps}\,´](´x´: ´c´[´\mathit{tps}\,´]) =
     if (x eq null) scala.None
-    else scala.Some(´x.\mathit{xs}_{11}, \ldots , x.\mathit{xs}_{1k}´)
+    else scala.Some(´x.\mathit{xs}_{11}, ... , x.\mathit{xs}_{1k}´)
 }
 ```
 
@@ -878,7 +878,7 @@ Here, ´\mathit{Ts}´ stands for the vector of types defined in the type
 parameter section ´\mathit{tps}´,
 each ´\mathit{xs}\_i´ denotes the parameter names of the parameter
 section ´\mathit{ps}\_i´, and
-´\mathit{xs}\_{11}, \ldots , \mathit{xs}\_{1k}´ denote the names of all parameters
+´\mathit{xs}\_{11}, ... , \mathit{xs}\_{1k}´ denote the names of all parameters
 in the first parameter section ´\mathit{xs}\_1´.
 If a type parameter section is missing in the class, it is also missing in the `apply` and `unapply` methods.
 
@@ -905,7 +905,7 @@ class already has a member (directly defined or inherited) with that name, or th
 class has a repeated parameter. The method is defined as follows:
 
 ```scala
-def copy[´\mathit{tps}\,´](´\mathit{ps}'_1\,´)´\ldots´(´\mathit{ps}'_n´): ´c´[´\mathit{tps}\,´] = new ´c´[´\mathit{Ts}\,´](´\mathit{xs}_1\,´)´\ldots´(´\mathit{xs}_n´)
+def copy[´\mathit{tps}\,´](´\mathit{ps}'_1\,´)...(´\mathit{ps}'_n´): ´c´[´\mathit{tps}\,´] = new ´c´[´\mathit{Ts}\,´](´\mathit{xs}_1\,´)...(´\mathit{xs}_n´)
 ```
 
 Again, `´\mathit{Ts}´` stands for the vector of types defined in the type parameter section `´\mathit{tps}´`
@@ -1090,11 +1090,11 @@ most general form is
 ´t´ is a [template](#templates) of the form
 
 ```scala
-´sc´ with ´mt_1´ with ´\ldots´ with ´mt_n´ { ´\mathit{stats}´ }
+´sc´ with ´mt_1´ with ... with ´mt_n´ { ´\mathit{stats}´ }
 ```
 
 which defines the base classes, behavior and initial state of ´m´.
-The extends clause `extends ´sc´ with ´mt_1´ with ´\ldots´ with ´mt_n´`
+The extends clause `extends ´sc´ with ´mt_1´ with ... with ´mt_n´`
 can be omitted, in which case
 `extends scala.AnyRef` is assumed.  The class body
 `{ ´\mathit{stats}´ }` may also be omitted, in which case the empty body
@@ -1105,7 +1105,7 @@ conforming to the template ´t´.  It is roughly equivalent to the
 following definition of a lazy value:
 
 ```scala
-lazy val ´m´ = new ´sc´ with ´mt_1´ with ´\ldots´ with ´mt_n´ { this: ´m.type´ => ´\mathit{stats}´ }
+lazy val ´m´ = new ´sc´ with ´mt_1´ with ... with ´mt_n´ { this: ´m.type´ => ´\mathit{stats}´ }
 ```
 
 Note that the value defined by an object definition is instantiated
diff --git a/docs/_spec/06-expressions.md b/docs/_spec/06-expressions.md
index f574d7ad2469..36c31af8969c 100644
--- a/docs/_spec/06-expressions.md
+++ b/docs/_spec/06-expressions.md
@@ -62,12 +62,12 @@ expression: If the type of an expression would be an existential type
 [skolemization](03-types.html#existential-types) of ´T´.
 
 Skolemization is reversed by type packing. Assume an expression ´e´ of
-type ´T´ and let ´t_1[\mathit{tps}\_1] >: L_1 <: U_1 , \ldots , t_n[\mathit{tps}\_n] >: L_n <: U_n´ be
+type ´T´ and let ´t_1[\mathit{tps}\_1] >: L_1 <: U_1, ..., t_n[\mathit{tps}\_n] >: L_n <: U_n´ be
 all the type variables created by skolemization of some part of ´e´ which are free in ´T´.
 Then the _packed type_ of ´e´ is
 
 ```scala
-´T´ forSome { type ´t_1[\mathit{tps}\_1] >: L_1 <: U_1´; ´\ldots´; type ´t_n[\mathit{tps}\_n] >: L_n <: U_n´ }.
+´T´ forSome { type ´t_1[\mathit{tps}\_1] >: L_1 <: U_1´; ...; type ´t_n[\mathit{tps}\_n] >: L_n <: U_n´ }.
 ```
 
 ## Literals
@@ -246,9 +246,9 @@ ArgumentExprs ::=  ‘(’ [Exprs] ‘)’
 Exprs         ::=  Expr {‘,’ Expr}
 ```
 
-An application `´f(e_1 , \ldots , e_m)´` applies the function `´f´` to the argument expressions `´e_1, \ldots , e_m´`. For this expression to be well-typed, the function must be *applicable* to its arguments, which is defined next by case analysis on ´f´'s type.
+An application `´f(e_1, ..., e_m)´` applies the function `´f´` to the argument expressions `´e_1, ..., e_m´`. For this expression to be well-typed, the function must be *applicable* to its arguments, which is defined next by case analysis on ´f´'s type.
 
-If ´f´ has a method type `(´p_1´:´T_1 , \ldots , p_n´:´T_n´)´U´`, each argument expression ´e_i´ is typed with the corresponding parameter type ´T_i´ as expected type. Let ´S_i´ be the type of argument ´e_i´ ´(i = 1 , \ldots , m)´. The method ´f´ must be _applicable_ to its arguments ´e_1, \ldots , e_n´ of types ´S_1 , \ldots , S_n´. We say that an argument expression ´e_i´ is a _named_ argument if it has the form `´x_i=e'_i´` and `´x_i´` is one of the parameter names `´p_1, \ldots, p_n´`.
+If ´f´ has a method type `(´p_1´:´T_1, ..., p_n´:´T_n´)´U´`, each argument expression ´e_i´ is typed with the corresponding parameter type ´T_i´ as expected type. Let ´S_i´ be the type of argument ´e_i´ ´(i = 1, ..., m)´. The method ´f´ must be _applicable_ to its arguments ´e_1, ..., e_n´ of types ´S_1, ..., S_n´. We say that an argument expression ´e_i´ is a _named_ argument if it has the form `´x_i=e'_i´` and `´x_i´` is one of the parameter names `´p_1, ..., p_n´`.
 
 Once the types ´S_i´ have been determined, the method ´f´ of the above method type is said to be applicable if all of the following conditions hold:
   - for every named argument ´p_j=e_i'´ the type ´S_i´ is [compatible](03-types.html#compatibility) with the parameter type ´T_j´;
@@ -258,12 +258,12 @@ Once the types ´S_i´ have been determined, the method ´f´ of the above metho
 If ´f´ is a polymorphic method, [local type inference](#local-type-inference) is used to instantiate ´f´'s type parameters.
 The polymorphic method is applicable if type inference can determine type arguments so that the instantiated method is applicable.
 
-If ´f´ has some value type, the application is taken to be equivalent to `´f´.apply(´e_1 , \ldots , e_m´)`,
+If ´f´ has some value type, the application is taken to be equivalent to `´f´.apply(´e_1, ..., e_m´)`,
 i.e. the application of an `apply` method defined by ´f´. The value `´f´` is applicable to the given arguments if `´f´.apply` is applicable.
 
 
-The application `´f´(´e_1 , \ldots , e_n´)` evaluates ´f´ and then each argument
-´e_1 , \ldots , e_n´ from left to right, except for arguments that correspond to
+The application `´f´(´e_1, ..., e_n´)` evaluates ´f´ and then each argument
+´e_1, ..., e_n´ from left to right, except for arguments that correspond to
 a by-name parameter (see below).  Each argument expression is converted to the
 type of its corresponding formal parameter.  After that, the application is
 rewritten to the function's right hand side, with actual arguments substituted
@@ -338,7 +338,7 @@ If an application is to use named arguments ´p = e´ or default
 arguments, the following conditions must hold.
 
 - For every named argument ´p_i = e_i´ which appears left of a positional argument
-  in the argument list ´e_1 \ldots e_m´, the argument position ´i´ coincides with
+  in the argument list ´e_1 ... e_m´, the argument position ´i´ coincides with
   the position of parameter ´p_i´ in the parameter list of the applied method.
 - The names ´x_i´ of all named arguments are pairwise distinct and no named
   argument defines a parameter which is already specified by a
@@ -367,16 +367,16 @@ the form
 ```scala
 { val q = ´p´
   val ´x_1´ = expr´_1´
-  ´\ldots´
+  ...
   val ´x_k´ = expr´_k´
-  q.´m´[´\mathit{targs}´](´\mathit{args}_1´)´, \ldots ,´(´\mathit{args}_l´)
+  q.´m´[´\mathit{targs}´](´\mathit{args}_1´), ...,(´\mathit{args}_l´)
 }
 ```
 
-where every argument in ´(\mathit{args}\_1) , \ldots , (\mathit{args}\_l)´ is a reference to
-one of the values ´x_1 , \ldots , x_k´. To integrate the current application
+where every argument in ´(\mathit{args}\_1), ..., (\mathit{args}\_l)´ is a reference to
+one of the values ´x_1, ..., x_k´. To integrate the current application
 into the block, first a value definition using a fresh name ´y_i´ is created
-for every argument in ´e_1 , \ldots , e_m´, which is initialised to ´e_i´ for
+for every argument in ´e_1, ..., e_m´, which is initialised to ´e_i´ for
 positional arguments and to ´e'_i´ for named arguments of the form
 `´x_i=e'_i´`. Then, for every parameter which is not specified
 by the argument list, a value definition using a fresh name ´z_i´ is created,
@@ -386,33 +386,33 @@ this parameter.
 
 Let ´\mathit{args}´ be a permutation of the generated names ´y_i´ and ´z_i´ such such
 that the position of each name matches the position of its corresponding
-parameter in the method type `(´p_1:T_1 , \ldots , p_n:T_n´)´U´`.
+parameter in the method type `(´p_1:T_1, ..., p_n:T_n´)´U´`.
 The final result of the transformation is a block of the form
 
 ```scala
 { val q = ´p´
   val ´x_1´ = expr´_1´
-  ´\ldots´
+  ...
   val ´x_l´ = expr´_k´
   val ´y_1´ = ´e_1´
-  ´\ldots´
+  ...
   val ´y_m´ = ´e_m´
-  val ´z_1´ = ´q.m\$default\$i[\mathit{targs}](\mathit{args}_1), \ldots ,(\mathit{args}_l)´
-  ´\ldots´
-  val ´z_d´ = ´q.m\$default\$j[\mathit{targs}](\mathit{args}_1), \ldots ,(\mathit{args}_l)´
-  q.´m´[´\mathit{targs}´](´\mathit{args}_1´)´, \ldots ,´(´\mathit{args}_l´)(´\mathit{args}´)
+  val ´z_1´ = ´q.m\$default\$i[\mathit{targs}](\mathit{args}_1), ..., (\mathit{args}_l)´
+  ...
+  val ´z_d´ = ´q.m\$default\$j[\mathit{targs}](\mathit{args}_1), ..., (\mathit{args}_l)´
+  q.´m´[´\mathit{targs}´](´\mathit{args}_1´), ..., (´\mathit{args}_l´)(´\mathit{args}´)
 }
 ```
 
 ### Signature Polymorphic Methods
 
-For invocations of signature polymorphic methods of the target platform `´f´(´e_1 , \ldots , e_m´)`,
-the invoked method has a different method type `(´p_1´:´T_1 , \ldots , p_n´:´T_n´)´U´` at each call
-site. The parameter types `´T_ , \ldots , T_n´` are the types of the argument expressions
-`´e_1 , \ldots , e_m´`. If the declared return type `´R´` of the signature polymorphic method is
+For invocations of signature polymorphic methods of the target platform `´f´(´e_1, ..., e_m´)`,
+the invoked method has a different method type `(´p_1´:´T_1, ..., p_n´:´T_n´)´U´` at each call
+site. The parameter types `´T_, ..., T_n´` are the types of the argument expressions
+`´e_1, ..., e_m´`. If the declared return type `´R´` of the signature polymorphic method is
 any type other than `scala.AnyRef`, then the return type `´U´` is `´R´`.
 Otherwise, `´U´` is the expected type at the call site. If the expected type is undefined then
-`´U´` is `scala.AnyRef`. The parameter names `´p_1 , \ldots , p_n´` are fresh.
+`´U´` is `scala.AnyRef`. The parameter names `´p_1, ..., p_n´` are fresh.
 
 ###### Note
 
@@ -456,19 +456,19 @@ because otherwise the underscore would be considered part of the name.
 SimpleExpr    ::=  SimpleExpr TypeArgs
 ```
 
-A _type application_ `´e´[´T_1 , \ldots , T_n´]` instantiates
+A _type application_ `´e´[´T_1, ..., T_n´]` instantiates
 a polymorphic value ´e´ of type
-`[´a_1´ >: ´L_1´ <: ´U_1, \ldots , a_n´ >: ´L_n´ <: ´U_n´]´S´`
+`[´a_1´ >: ´L_1´ <: ´U_1, ..., a_n´ >: ´L_n´ <: ´U_n´]´S´`
 with argument types
-`´T_1 , \ldots , T_n´`.  Every argument type ´T_i´ must obey
+`´T_1, ..., T_n´`.  Every argument type ´T_i´ must obey
 the corresponding bounds ´L_i´ and ´U_i´.  That is, for each ´i = 1
-, \ldots , n´, we must have ´\sigma L_i <: T_i <: \sigma
-U_i´, where ´\sigma´ is the substitution ´[a_1 := T_1 , \ldots , a_n
+, ..., n´, we must have ´\sigma L_i <: T_i <: \sigma
+U_i´, where ´\sigma´ is the substitution ´[a_1 := T_1, ..., a_n
 := T_n]´.  The type of the application is ´\sigma S´.
 
 If the function part ´e´ is of some value type, the type application
 is taken to be equivalent to
-`´e´.apply[´T_1 , \ldots ,´ T´_n´]`, i.e. the application of an `apply` method defined by
+`´e´.apply[´T_1 , ...,´ T´_n´]`, i.e. the application of an `apply` method defined by
 ´e´.
 
 Type applications can be omitted if
@@ -482,9 +482,9 @@ and the expected result type.
 SimpleExpr   ::=  ‘(’ [Exprs] ‘)’
 ```
 
-A _tuple expression_ `(´e_1 , \ldots , e_n´)` is an alias
+A _tuple expression_ `(´e_1´, ..., ´e_n´)` is an alias
 for the class instance creation
-`scala.Tuple´n´(´e_1 , \ldots , e_n´)`, where ´n \geq 2´.
+`scala.Tuple´n´(´e_1´, ..., ´e_n´)`, where ´n \geq 2´.
 The empty tuple
 `()` is the unique value of type `scala.Unit`.
 
@@ -562,8 +562,8 @@ BlockExpr  ::=  ‘{’ CaseClauses ‘}’
 Block      ::=  BlockStat {semi BlockStat} [ResultExpr]
 ```
 
-A _block expression_ `{´s_1´; ´\ldots´; ´s_n´; ´e\,´}` is
-constructed from a sequence of block statements ´s_1 , \ldots , s_n´
+A _block expression_ `{´s_1´; ...; ´s_n´; ´e\,´}` is
+constructed from a sequence of block statements ´s_1, ..., s_n´
 and a final expression ´e´.  The statement sequence may not contain
 two definitions or declarations that bind the same name in the same
 namespace.  The final expression can be omitted, in which
@@ -573,11 +573,11 @@ The expected type of the final expression ´e´ is the expected
 type of the block. The expected type of all preceding statements is
 undefined.
 
-The type of a block `´s_1´; ´\ldots´; ´s_n´; ´e´` is
+The type of a block `´s_1´; ...; ´s_n´; ´e´` is
 `´T´ forSome {´\,Q\,´}`, where ´T´ is the type of ´e´ and ´Q´
 contains [existential clauses](03-types.html#existential-types)
 for every value or type name which is free in ´T´
-and which is defined locally in one of the statements ´s_1 , \ldots , s_n´.
+and which is defined locally in one of the statements ´s_1, ..., s_n´.
 We say the existential clause _binds_ the occurrence of the value or type name.
 Specifically,
 
@@ -599,7 +599,7 @@ Evaluation of the block entails evaluation of its
 statement sequence, followed by an evaluation of the final expression
 ´e´, which defines the result of the block.
 
-A block expression `{´c_1´; ´\ldots´; ´c_n´}` where ´s_1 , \ldots , s_n´ are
+A block expression `{´c_1´; ...; ´c_n´}` where ´s_1, ..., s_n´ are
 case clauses forms a [pattern matching anonymous function](08-pattern-matching.html#pattern-matching-anonymous-functions).
 
 ###### Example
@@ -696,22 +696,22 @@ parts of an expression as follows.
   expression, then operators with higher precedence bind more closely
   than operators with lower precedence.
 - If there are consecutive infix
-  operations ´e_0; \mathit{op}\_1; e_1; \mathit{op}\_2 \ldots \mathit{op}\_n; e_n´
-  with operators ´\mathit{op}\_1 , \ldots , \mathit{op}\_n´ of the same precedence,
+  operations ´e_0; \mathit{op}\_1; e_1; \mathit{op}\_2 ... \mathit{op}\_n; e_n´
+  with operators ´\mathit{op}\_1, ..., \mathit{op}\_n´ of the same precedence,
   then all these operators must
   have the same associativity. If all operators are left-associative,
   the sequence is interpreted as
-  ´(\ldots(e_0;\mathit{op}\_1;e_1);\mathit{op}\_2\ldots);\mathit{op}\_n;e_n´.
+  ´(...(e_0;\mathit{op}\_1;e_1);\mathit{op}\_2...);\mathit{op}\_n;e_n´.
   Otherwise, if all operators are right-associative, the
   sequence is interpreted as
-  ´e_0;\mathit{op}\_1;(e_1;\mathit{op}\_2;(\ldots \mathit{op}\_n;e_n)\ldots)´.
+  ´e_0;\mathit{op}\_1;(e_1;\mathit{op}\_2;(... \mathit{op}\_n;e_n)...)´.
 - Postfix operators always have lower precedence than infix
   operators. E.g. ´e_1;\mathit{op}\_1;e_2;\mathit{op}\_2´ is always equivalent to
   ´(e_1;\mathit{op}\_1;e_2);\mathit{op}\_2´.
 
 The right-hand operand of a left-associative operator may consist of
-several arguments enclosed in parentheses, e.g. ´e;\mathit{op};(e_1,\ldots,e_n)´.
-This expression is then interpreted as ´e.\mathit{op}(e_1,\ldots,e_n)´.
+several arguments enclosed in parentheses, e.g. ´e;\mathit{op};(e_1,...,e_n)´.
+This expression is then interpreted as ´e.\mathit{op}(e_1,...,e_n)´.
 
 A left-associative binary
 operation ´e_1;\mathit{op};e_2´ is interpreted as ´e_1.\mathit{op}(e_2)´. If ´\mathit{op}´ is
@@ -778,8 +778,8 @@ Here are examples of well-typed and ill-typed expressions.
 Expr1              ::=  PostfixExpr ‘:’ Annotation {Annotation}
 ```
 
-An _annotated expression_ `´e´: @´a_1´ ´\ldots´ @´a_n´`
-attaches [annotations](11-annotations.html#user-defined-annotations) ´a_1 , \ldots , a_n´ to the
+An _annotated expression_ `´e´: @´a_1´ ... @´a_n´`
+attaches [annotations](11-annotations.html#user-defined-annotations) ´a_1, ..., a_n´ to the
 expression ´e´.
 
 ## Assignments
@@ -977,35 +977,35 @@ comprehensions have been eliminated.
   - A for comprehension
 
     ```scala
-    for (´p´ <- ´e´; ´p'´ <- ´e'; \ldots´) yield ´e''´
+    for (´p´ <- ´e´; ´p'´ <- ´e'; ...´) yield ´e''´
     ```
 
-    where `´\ldots´` is a (possibly empty)
+    where `...` is a (possibly empty)
     sequence of generators, definitions, or guards,
     is translated to
 
     ```scala
-    ´e´.flatMap { case ´p´ => for (´p'´ <- ´e'; \ldots´) yield ´e''´ }
+    ´e´.flatMap { case ´p´ => for (´p'´ <- ´e'; ...´) yield ´e''´ }
     ```
 
   - A for loop
 
     ```scala
-    for (´p´ <- ´e´; ´p'´ <- ´e'; \ldots´) ´e''´
+    for (´p´ <- ´e´; ´p'´ <- ´e'; ...´) ´e''´
     ```
 
-    where `´\ldots´` is a (possibly empty)
+    where `...` is a (possibly empty)
     sequence of generators, definitions, or guards,
     is translated to
 
     ```scala
-    ´e´.foreach { case ´p´ => for (´p'´ <- ´e'; \ldots´) ´e''´ }
+    ´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 , \ldots , x_n´) => ´g\,´)` where
-    ´x_1 , \ldots , x_n´ are the free variables of ´p´.
+    `´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 value definition
     `´p'´ = ´e'´` is translated to the following generator of pairs of values, where
@@ -1137,7 +1137,7 @@ where the handler ´h´ is usually a
 [pattern matching anonymous function](08-pattern-matching.html#pattern-matching-anonymous-functions)
 
 ```scala
-{ case ´p_1´ => ´b_1´ ´\ldots´ case ´p_n´ => ´b_n´ }
+{ case ´p_1´ => ´b_1´ ... case ´p_n´ => ´b_n´ }
 ```
 
 This expression is evaluated by evaluating the block
@@ -1187,7 +1187,7 @@ Bindings        ::=  ‘(’ Binding {‘,’ Binding} ‘)’
 Binding         ::=  (id | ‘_’) [‘:’ Type]
 ```
 
-The anonymous function of arity ´n´, `(´x_1´: ´T_1 , \ldots , x_n´: ´T_n´) => e` maps parameters ´x_i´ of types ´T_i´ to a result given by expression ´e´. The scope of each formal parameter ´x_i´ is ´e´. Formal parameters must have pairwise distinct names.
+The anonymous function of arity ´n´, `(´x_1´: ´T_1, ..., x_n´: ´T_n´) => e` maps parameters ´x_i´ of types ´T_i´ to a result given by expression ´e´. The scope of each formal parameter ´x_i´ is ´e´. Formal parameters must have pairwise distinct names.
 
 In the case of a single untyped formal parameter, `(´x\,´) => ´e´` can be abbreviated to `´x´ => ´e´`. If an anonymous function `(´x´: ´T\,´) => ´e´` with a single typed parameter appears as the result expression of a block, it can be abbreviated to `´x´: ´T´ => e`.
 
@@ -1196,12 +1196,12 @@ A formal parameter may also be a wildcard represented by an underscore `_`. In t
 A named parameter of an anonymous function may be optionally preceded by an `implicit` modifier. In that case the parameter is labeled [`implicit`](07-implicits.html#implicit-parameters-and-views); however the parameter section itself does not count as an [implicit parameter section](07-implicits.html#implicit-parameters). Hence, arguments to anonymous functions always have to be given explicitly.
 
 ### Translation
-If the expected type of the anonymous function is of the shape `scala.Function´n´[´S_1 , \ldots , S_n´, ´R\,´]`, or can be [SAM-converted](#sam-conversion) to such a function type, the type `´T_i´` of a parameter `´x_i´` can be omitted, as far as `´S_i´` is defined in the expected type, and `´T_i´ = ´S_i´` is assumed. Furthermore, the expected type when type checking ´e´ is ´R´.
+If the expected type of the anonymous function is of the shape `scala.Function´n´[´S_1´, ..., ´S_n´, ´R\,´]`, or can be [SAM-converted](#sam-conversion) to such a function type, the type `´T_i´` of a parameter `´x_i´` can be omitted, as far as `´S_i´` is defined in the expected type, and `´T_i´ = ´S_i´` is assumed. Furthermore, the expected type when type checking ´e´ is ´R´.
 
-If there is no expected type for the function literal, all formal parameter types `´T_i´` must be specified explicitly, and the expected type of ´e´ is undefined. The type of the anonymous function is `scala.Function´n´[´T_1 , \ldots , T_n´, ´R\,´]`, where ´R´ is the [packed type](#expression-typing) of ´e´. ´R´ must be equivalent to a type which does not refer to any of the formal parameters ´x_i´.
+If there is no expected type for the function literal, all formal parameter types `´T_i´` must be specified explicitly, and the expected type of ´e´ is undefined. The type of the anonymous function is `scala.Function´n´[´T_1´, ..., ´T_n´, ´R\,´]`, where ´R´ is the [packed type](#expression-typing) of ´e´. ´R´ must be equivalent to a type which does not refer to any of the formal parameters ´x_i´.
 
 The eventual run-time value of an anonymous function is determined by the expected type:
-  - a subclass of one of the builtin function types, `scala.Function´n´[´S_1 , \ldots , S_n´, ´R\,´]` (with ´S_i´ and ´R´ fully defined),
+  - a subclass of one of the builtin function types, `scala.Function´n´[´S_1, ..., S_n´, ´R\,´]` (with ´S_i´ and ´R´ fully defined),
   - a [single-abstract-method (SAM) type](#sam-conversion);
   - `PartialFunction[´T´, ´U´]`
   - some other type.
@@ -1209,8 +1209,8 @@ The eventual run-time value of an anonymous function is determined by the expect
 The standard anonymous function evaluates in the same way as the following instance creation expression:
 
 ```scala
-new scala.Function´n´[´T_1 , \ldots , T_n´, ´T´] {
-  def apply(´x_1´: ´T_1 , \ldots , x_n´: ´T_n´): ´T´ = ´e´
+new scala.Function´n´[´T_1, ..., T_n´, ´T´] {
+  def apply(´x_1´: ´T_1, ..., x_n´: ´T_n´): ´T´ = ´e´
 }
 ```
 
@@ -1220,7 +1220,7 @@ The underlying platform may provide more efficient ways of constructing these in
 
 When a `PartialFunction` is required, an additional member `isDefinedAt`
 is synthesized, which simply returns `true`.
-However, if the function literal has the shape `x => x match { $\ldots$ }`,
+However, if the function literal has the shape `x => x match { $...$ }`,
 then `isDefinedAt` is derived from the pattern match in the following way:
 each case from the match expression evaluates to `true`,
 and if there is no default case,
@@ -1268,7 +1268,7 @@ An expression ´e´ of syntactic category `Expr` _binds_ an underscore section
 (2) there is no other expression of syntactic category `Expr`
 which is properly contained in ´e´ and which itself properly contains ´u´.
 
-If an expression ´e´ binds underscore sections ´u_1 , \ldots , u_n´, in this order, it is equivalent to
+If an expression ´e´ binds underscore sections ´u_1, ..., u_n´, in this order, it is equivalent to
 the anonymous function `(´u'_1´, ... ´u'_n´) => ´e'´`
 where each ´u_i'´ results from ´u_i´ by replacing the underscore with a fresh identifier and
 ´e'´ results from ´e´ by replacing each underscore section ´u_i´ by ´u_i'´.
@@ -1296,7 +1296,7 @@ include at least the expressions of the following forms:
 - A string literal
 - A class constructed with [`Predef.classOf`](12-the-scala-standard-library.html#the-predef-object)
 - An element of an enumeration from the underlying platform
-- A literal array, of the form `Array´(c_1 , \ldots , c_n)´`,
+- A literal array, of the form `Array´(c_1, ..., c_n)´`,
   where all of the ´c_i´'s are themselves constant expressions
 - An identifier defined by a [constant value definition](04-basic-declarations-and-definitions.html#value-declarations-and-definitions).
 
@@ -1354,16 +1354,16 @@ is applied to pick a unique member.
 An expression ´e´ of polymorphic type
 
 ```scala
-[´a_1´ >: ´L_1´ <: ´U_1 , \ldots , a_n´ >: ´L_n´ <: ´U_n´]´T´
+[´a_1´ >: ´L_1´ <: ´U_1, ..., a_n´ >: ´L_n´ <: ´U_n´]´T´
 ```
 
 which does not appear as the function part of
 a type application is converted to a type instance of ´T´
 by determining with [local type inference](#local-type-inference)
-instance types `´T_1 , \ldots , T_n´`
-for the type variables `´a_1 , \ldots , a_n´` and
+instance types `´T_1, ..., T_n´`
+for the type variables `´a_1, ..., a_n´` and
 implicitly embedding ´e´ in the [type application](#type-applications)
-`´e´[´T_1 , \ldots , T_n´]`.
+`´e´[´T_1, ..., T_n´]`.
 
 ###### Numeric Widening
 If ´e´ has a primitive number type which [weakly conforms](03-types.html#weak-conformance)
@@ -1456,24 +1456,24 @@ member.  The way this is done depends on whether or not ´e´ is used as
 a function. Let ´\mathscr{A}´ be the set of members referenced by ´e´.
 
 Assume first that ´e´ appears as a function in an application, as in
-`´e´(´e_1 , \ldots , e_m´)`.
+`´e´(´e_1´, ..., ´e_m´)`.
 
 One first determines the set of functions that is potentially [applicable](#function-applications)
 based on the _shape_ of the arguments.
 
 The *shape* of an argument expression ´e´, written  ´\mathit{shape}(e)´, is
 a type that is defined as follows:
-  - For a function expression `(´p_1´: ´T_1 , \ldots , p_n´: ´T_n´) => ´b´: (Any ´, \ldots ,´ Any) => ´\mathit{shape}(b)´`,
+  - For a function expression `(´p_1´: ´T_1, ..., p_n´: ´T_n´) => ´b´: (Any, ..., Any) => ´\mathit{shape}(b)´`,
     where `Any` occurs ´n´ times in the argument type.
   - For a pattern-matching anonymous function definition `{ case ... }`: `PartialFunction[Any, Nothing]`.
   - For a named argument `´n´ = ´e´`: ´\mathit{shape}(e)´.
   - For all other expressions: `Nothing`.
 
 Let ´\mathscr{B}´ be the set of alternatives in ´\mathscr{A}´ that are [_applicable_](#function-applications)
-to expressions ´(e_1 , \ldots , e_n)´ of types ´(\mathit{shape}(e_1) , \ldots , \mathit{shape}(e_n))´.
+to expressions ´(e_1, ..., e_n)´ of types ´(\mathit{shape}(e_1), ..., \mathit{shape}(e_n))´.
 If there is precisely one alternative in ´\mathscr{B}´, that alternative is chosen.
 
-Otherwise, let ´S_1 , \ldots , S_m´ be the list of types obtained by typing each argument as follows.
+Otherwise, let ´S_1, ..., S_m´ be the list of types obtained by typing each argument as follows.
 
 Normally, an argument is typed without an expected type, except when
 all alternatives explicitly specify the same parameter type for this argument (a missing parameter type,
@@ -1501,12 +1501,12 @@ given `´k´`. Then, the expected type for `´e_i´` is derived as follows:
      (and a potentially varying result type), the expected type encodes these argument types and the SAM class.
 
 For every member ´m´ in ´\mathscr{B}´ one determines whether it is applicable
-to expressions (´e_1 , \ldots , e_m´) of types ´S_1, \ldots , S_m´.
+to expressions (´e_1, ..., e_m´) of types ´S_1, ..., S_m´.
 
 It is an error if none of the members in ´\mathscr{B}´ is applicable. If there is one
 single applicable alternative, that alternative is chosen. Otherwise, let ´\mathscr{CC}´
 be the set of applicable alternatives which don't employ any default argument
-in the application to ´e_1 , \ldots , e_m´.
+in the application to ´e_1, ..., e_m´.
 
 It is again an error if ´\mathscr{CC}´ is empty.
 Otherwise, one chooses the _most specific_ alternative among the alternatives
@@ -1524,20 +1524,20 @@ question: given
  so the method is not more specific than the value.
 -->
 
-- A parameterized method ´m´ of type `(´p_1:T_1, \ldots , p_n:T_n´)´U´` is
+- A parameterized method ´m´ of type `(´p_1:T_1, ..., p_n:T_n´)´U´` is
   _as specific as_ some other member ´m'´ of type ´S´ if ´m'´ is [applicable](#function-applications)
-  to arguments `(´p_1 , \ldots , p_n´)` of types ´T_1 , \ldots , T_n´.
-- A polymorphic method of type `[´a_1´ >: ´L_1´ <: ´U_1 , \ldots , a_n´ >: ´L_n´ <: ´U_n´]´T´` is
+  to arguments `(´p_1, ..., p_n´)` of types ´T_1, ..., T_n´.
+- A polymorphic method of type `[´a_1´ >: ´L_1´ <: ´U_1, ..., a_n´ >: ´L_n´ <: ´U_n´]´T´` is
   as specific as some other member of type ´S´ if ´T´ is as specific as ´S´
-  under the assumption that for ´i = 1 , \ldots , n´ each ´a_i´ is an abstract type name
+  under the assumption that for ´i = 1, ..., n´ each ´a_i´ is an abstract type name
   bounded from below by ´L_i´ and from above by ´U_i´.
 - A member of any other type is always as specific as a parameterized method or a polymorphic method.
 - Given two members of types ´T´ and ´U´ which are neither parameterized nor polymorphic method types,
   the member of type ´T´ is as specific as the member of type ´U´ if
   the existential dual of ´T´ conforms to the existential dual of ´U´.
   Here, the existential dual of a polymorphic type
-  `[´a_1´ >: ´L_1´ <: ´U_1 , \ldots , a_n´ >: ´L_n´ <: ´U_n´]´T´` is
-  `´T´ forSome { type ´a_1´ >: ´L_1´ <: ´U_1´ ´, \ldots ,´ type ´a_n´ >: ´L_n´ <: ´U_n´}`.
+  `[´a_1´ >: ´L_1´ <: ´U_1, ..., a_n´ >: ´L_n´ <: ´U_n´]´T´` is
+  `´T´ forSome { type ´a_1´ >: ´L_1´ <: ´U_1´, ..., type ´a_n´ >: ´L_n´ <: ´U_n´}`.
   The existential dual of every other type is the type itself.
 
 The _relative weight_ of an alternative ´A´ over an alternative ´B´ is a
@@ -1580,8 +1580,8 @@ Consider the following definitions:
 
 ```scala
 class A extends B {}
-def f(x: B, y: B) = ´\ldots´
-def f(x: A, y: B) = ´\ldots´
+def f(x: B, y: B) = ...
+def f(x: A, y: B) = ...
 val a: A
 val b: B
 ```
@@ -1591,7 +1591,7 @@ definition of ´f´ whereas the application `f(a, a)`
 refers to the second.  Assume now we add a third overloaded definition
 
 ```scala
-def f(x: B, y: A) = ´\ldots´
+def f(x: B, y: A) = ...
 ```
 
 Then the application `f(a, a)` is rejected for being ambiguous, since
@@ -1600,12 +1600,12 @@ no most specific applicable signature exists.
 ### Local Type Inference
 
 Local type inference infers type arguments to be passed to expressions
-of polymorphic type. Say ´e´ is of type [´a_1´ >: ´L_1´ <: ´U_1, \ldots , a_n´ >: ´L_n´ <: ´U_n´]´T´
+of polymorphic type. Say ´e´ is of type [´a_1´ >: ´L_1´ <: ´U_1, ..., a_n´ >: ´L_n´ <: ´U_n´]´T´
 and no explicit type parameters are given.
 
 Local type inference converts this expression to a type
-application `´e´[´T_1 , \ldots , T_n´]`. The choice of the
-type arguments ´T_1 , \ldots , T_n´ depends on the context in which
+application `´e´[´T_1, ..., T_n´]`. The choice of the
+type arguments ´T_1, ..., T_n´ depends on the context in which
 the expression appears and on the expected type ´\mathit{pt}´.
 There are three cases.
 
@@ -1613,9 +1613,9 @@ There are three cases.
 If the expression appears as the prefix of a selection with a name
 ´x´, then type inference is _deferred_ to the whole expression
 ´e.x´. That is, if ´e.x´ has type ´S´, it is now treated as having
-type [´a_1´ >: ´L_1´ <: ´U_1 , \ldots , a_n´ >: ´L_n´ <: ´U_n´]´S´,
+type [´a_1´ >: ´L_1´ <: ´U_1, ..., a_n´ >: ´L_n´ <: ´U_n´]´S´,
 and local type inference is applied in turn to infer type arguments
-for ´a_1 , \ldots , a_n´, using the context in which ´e.x´ appears.
+for ´a_1, ..., a_n´, using the context in which ´e.x´ appears.
 
 ###### Case 2: Values
 If the expression ´e´ appears as a value without being applied to
@@ -1631,7 +1631,7 @@ parameters ´a_i´ such that
   unless it is a singleton type corresponding to an object or a constant value
   definition or the corresponding bound ´U_i´ is a subtype of `scala.Singleton`.
 - All type parameter bounds are respected, i.e.
-  ´\sigma L_i <: \sigma a_i´ and ´\sigma a_i <: \sigma U_i´ for ´i = 1 , \ldots , n´.
+  ´\sigma L_i <: \sigma a_i´ and ´\sigma a_i <: \sigma U_i´ for ´i = 1, ..., n´.
 - The expression's type conforms to the expected type, i.e.
   ´\sigma T <: \sigma \mathit{pt}´.
 
@@ -1647,21 +1647,21 @@ an _optimal solution_ of the given constraint system for the type ´T´.
 
 ###### Case 3: Methods
 The last case applies if the expression
-´e´ appears in an application ´e(d_1 , \ldots , d_m)´. In that case
-´T´ is a method type ´(p_1:R_1 , \ldots , p_m:R_m)T'´. Without loss of
+´e´ appears in an application ´e(d_1, ..., d_m)´. In that case
+´T´ is a method type ´(p_1:R_1, ..., p_m:R_m)T'´. Without loss of
 generality we can assume that the result type ´T'´ is a value type; if
 it is a method type we apply [eta-expansion](#eta-expansion-section) to
 convert it to a function type.  One computes first the types ´S_j´ of
 the argument expressions ´d_j´, using two alternative schemes.  Each
 argument expression ´d_j´ is typed first with the expected type ´R_j´,
-in which the type parameters ´a_1 , \ldots , a_n´ are taken as type
+in which the type parameters ´a_1, ..., a_n´ are taken as type
 constants.  If this fails, the argument ´d_j´ is typed instead with an
 expected type ´R_j'´ which results from ´R_j´ by replacing every type
-parameter in ´a_1 , \ldots , a_n´ with _undefined_.
+parameter in ´a_1, ..., a_n´ with _undefined_.
 
 In a second step, type arguments are inferred by solving a constraint
 system which relates the method's type with the expected type
-´\mathit{pt}´ and the argument types ´S_1 , \ldots , S_m´. Solving the
+´\mathit{pt}´ and the argument types ´S_1, ..., S_m´. Solving the
 constraint system means
 finding a substitution ´\sigma´ of types ´T_i´ for the type parameters
 ´a_i´ such that
@@ -1670,11 +1670,11 @@ finding a substitution ´\sigma´ of types ´T_i´ for the type parameters
   unless it is a singleton type corresponding to an object or a constant value
   definition or the corresponding bound ´U_i´ is a subtype of `scala.Singleton`.
 - All type parameter bounds are respected, i.e. ´\sigma L_i <: \sigma a_i´ and
-  ´\sigma a_i <: \sigma U_i´ for ´i = 1 , \ldots , n´.
+  ´\sigma a_i <: \sigma U_i´ for ´i = 1, ..., n´.
 - The method's result type ´T'´ conforms to the expected type, i.e. ´\sigma T' <: \sigma \mathit{pt}´.
 - Each argument type [weakly conforms](03-types.html#weak-conformance)
   to the corresponding formal parameter
-  type, i.e. ´\sigma S_j <:_w \sigma R_j´ for ´j = 1 , \ldots , m´.
+  type, i.e. ´\sigma S_j <:_w \sigma R_j´ for ´j = 1, ..., m´.
 
 It is a compile time error if no such substitution exists.  If several
 solutions exist, an optimal one for the type ´T'´ is chosen.
@@ -1788,18 +1788,18 @@ _Eta-expansion_ converts an expression of method type to an
 equivalent expression of function type. It proceeds in two steps.
 
 First, one identifies the maximal sub-expressions of ´e´; let's
-say these are ´e_1 , \ldots , e_m´. For each of these, one creates a
+say these are ´e_1, ..., e_m´. For each of these, one creates a
 fresh name ´x_i´. Let ´e'´ be the expression resulting from
 replacing every maximal subexpression ´e_i´ in ´e´ by the
 corresponding fresh name ´x_i´. Second, one creates a fresh name ´y_i´
-for every argument type ´T_i´ of the method (´i = 1 , \ldots ,
+for every argument type ´T_i´ of the method (´i = 1 , ...,
 n´). The result of eta-conversion is then:
 
 ```scala
 { val ´x_1´ = ´e_1´;
-  ´\ldots´
+  ...
   val ´x_m´ = ´e_m´;
-  (´y_1: T_1 , \ldots , y_n: T_n´) => ´e'´(´y_1 , \ldots , y_n´)
+  (´y_1: T_1, ..., y_n: T_n´) => ´e'´(´y_1, ..., y_n´)
 }
 ```
 
diff --git a/docs/_spec/07-implicits.md b/docs/_spec/07-implicits.md
index 6f38fdd48074..47dc4ca0b0d4 100644
--- a/docs/_spec/07-implicits.md
+++ b/docs/_spec/07-implicits.md
@@ -45,7 +45,7 @@ object Monoids {
 ## Implicit Parameters
 
 An _implicit parameter list_
-`(implicit ´p_1´,´\ldots´,´p_n´)` of a method marks the parameters ´p_1 , \ldots , p_n´ as
+`(implicit ´p_1´,...,´p_n´)` of a method marks the parameters ´p_1, ..., p_n´ as
 implicit. A method or constructor can have only one implicit parameter
 list, and it must be the last parameter list given.
 
@@ -71,18 +71,18 @@ Here, we say a class ´C´ is _associated_ with a type ´T´ if it is a [base cl
 
 The _parts_ of a type ´T´ are:
 
-- if ´T´ is a compound type `´T_1´ with ´\ldots´ with ´T_n´`,
-  the union of the parts of ´T_1 , \ldots , T_n´, as well as ´T´ itself;
-- if ´T´ is a parameterized type `´S´[´T_1 , \ldots , T_n´]`,
-  the union of the parts of ´S´ and ´T_1 , \ldots , T_n´;
+- if ´T´ is a compound type `´T_1´ with ... with ´T_n´`,
+  the union of the parts of ´T_1, ..., T_n´, as well as ´T´ itself;
+- if ´T´ is a parameterized type `´S´[´T_1, ..., T_n´]`,
+  the union of the parts of ´S´ and ´T_1, ..., T_n´;
 - if ´T´ is a singleton type `´p´.type`,
   the parts of the type of ´p´;
 - if ´T´ is a type projection `´S´#´U´`,
   the parts of ´S´ as well as ´T´ itself;
 - if ´T´ is a type alias, the parts of its expansion;
 - if ´T´ is an abstract type, the parts of its upper bound;
-- if ´T´ denotes an implicit conversion to a type with a method with argument types ´T_1 , \ldots , T_n´ and result type ´U´,
-  the union of the parts of ´T_1 , \ldots , T_n´ and ´U´;
+- if ´T´ denotes an implicit conversion to a type with a method with argument types ´T_1, ..., T_n´ and result type ´U´,
+  the union of the parts of ´T_1, ..., T_n´ and ´U´;
 - the parts of quantified (existential or universal) and annotated types are defined as the parts of the underlying types (e.g., the parts of `T forSome { ... }` are the parts of `T`);
 - in all other cases, just ´T´ itself.
 
@@ -268,7 +268,7 @@ the type:
 - For a type designator,  ´\mathit{ttcs}(p.c) ~=~ \{c\}´;
 - For a parameterized type,  ´\mathit{ttcs}(p.c[\mathit{targs}]) ~=~ \{c\}´;
 - For a singleton type,  ´\mathit{ttcs}(p.type) ~=~ \mathit{ttcs}(T)´, provided ´p´ has type ´T´;
-- For a compound type, `´\mathit{ttcs}(T_1´ with ´\ldots´ with ´T_n)´` ´~=~ \mathit{ttcs}(T_1) \cup \ldots \cup \mathit{ttcs}(T_n)´.
+- For a compound type, `´\mathit{ttcs}(T_1´ with ... with ´T_n)´` ´~=~ \mathit{ttcs}(T_1) \cup ... \cup \mathit{ttcs}(T_n)´.
 
 The _complexity_ ´\operatorname{complexity}(T)´ of a core type is an integer which also depends on the form of
 the type:
@@ -277,7 +277,7 @@ the type:
 - For a parameterized type, ´\operatorname{complexity}(p.c[\mathit{targs}]) ~=~ 1 + \Sigma \operatorname{complexity}(\mathit{targs})´
 - For a singleton type denoting a package ´p´, ´\operatorname{complexity}(p.type) ~=~ 0´
 - For any other singleton type, ´\operatorname{complexity}(p.type) ~=~ 1 + \operatorname{complexity}(T)´, provided ´p´ has type ´T´;
-- For a compound type, `´\operatorname{complexity}(T_1´ with ´\ldots´ with ´T_n)´` ´= \Sigma\operatorname{complexity}(T_i)´
+- For a compound type, `´\operatorname{complexity}(T_1´ with ... with ´T_n)´` ´= \Sigma\operatorname{complexity}(T_i)´
 
 The _covering set_ ´\mathit{cs}(T)´ of a type ´T´ is the set of type designators mentioned in a type.
 For example, given the following,
@@ -495,31 +495,31 @@ Then the following rules apply.
 1.  If ´T´ is an instance of `Array[´S´]`, a manifest is generated
     with the invocation `´\mathit{Mobj}´.arrayType[S](m)`, where ´m´ is the manifest
     determined for ´M[S]´.
-1.  If ´T´ is some other class type ´S´#´C[U_1, \ldots, U_n]´ where the prefix
+1.  If ´T´ is some other class type ´S´#´C[U_1, ..., U_n]´ where the prefix
     type ´S´ cannot be statically determined from the class ´C´,
     a manifest is generated with the invocation `´\mathit{Mobj}´.classType[T](´m_0´, classOf[T], ´ms´)`
     where ´m_0´ is the manifest determined for ´M'[S]´ and ´ms´ are the
-    manifests determined for ´M'[U_1], \ldots, M'[U_n]´.
-1.  If ´T´ is some other class type with type arguments ´U_1 , \ldots , U_n´,
+    manifests determined for ´M'[U_1], ..., M'[U_n]´.
+1.  If ´T´ is some other class type with type arguments ´U_1, ..., U_n´,
     a manifest is generated
     with the invocation `´\mathit{Mobj}´.classType[T](classOf[T], ´ms´)`
     where ´ms´ are the
-    manifests determined for ´M'[U_1] , \ldots , M'[U_n]´.
+    manifests determined for ´M'[U_1], ..., M'[U_n]´.
 1.  If ´T´ is a singleton type `´p´.type`, a manifest is generated with
     the invocation `´\mathit{Mobj}´.singleType[T](´p´)`
 1.  If ´T´ is a refined type ´T' \{ R \}´, a manifest is generated for ´T'´.
     (That is, refinements are never reflected in manifests).
 1.  If ´T´ is an intersection type
-    `´T_1´ with ´, \ldots ,´ with ´T_n´`
+    `´T_1´ with ... with ´T_n´`
     where ´n > 1´, the result depends on whether a full manifest is
     to be determined or not.
     If ´M´ is trait `Manifest`, then
     a manifest is generated with the invocation
     `Manifest.intersectionType[T](´ms´)` where ´ms´ are the manifests
-    determined for ´M[T_1] , \ldots , M[T_n]´.
+    determined for ´M[T_1], ..., M[T_n]´.
     Otherwise, if ´M´ is trait `ClassManifest`,
     then a manifest is generated for the [intersection dominator](03-types.html#type-erasure)
-    of the types ´T_1 , \ldots , T_n´.
+    of the types ´T_1, ..., T_n´.
 1.  If ´T´ is some other type, then if ´M´ is trait `OptManifest`,
     a manifest is generated from the designator `scala.reflect.NoManifest`.
     If ´M´ is a type different from `OptManifest`, a static error results.
diff --git a/docs/_spec/08-pattern-matching.md b/docs/_spec/08-pattern-matching.md
index 53dc3ffe4547..f7203e831438 100644
--- a/docs/_spec/08-pattern-matching.md
+++ b/docs/_spec/08-pattern-matching.md
@@ -194,20 +194,20 @@ one is a variable pattern.
 SimplePattern   ::=  StableId ‘(’ [Patterns] ‘)’
 ```
 
-A _constructor pattern_ is of the form ´c(p_1 , \ldots , p_n)´ where ´n
+A _constructor pattern_ is of the form ´c(p_1, ..., p_n)´ where ´n
 \geq 0´. It consists of a stable identifier ´c´, followed by element
-patterns ´p_1 , \ldots , p_n´. The constructor ´c´ is a simple or
+patterns ´p_1, ..., p_n´. The constructor ´c´ is a simple or
 qualified name which denotes a [case class](05-classes-and-objects.html#case-classes).
 If the case class is monomorphic, then it
 must conform to the expected type of the pattern, and the formal
 parameter types of ´x´'s [primary constructor](05-classes-and-objects.html#class-definitions)
-are taken as the expected types of the element patterns ´p_1, \ldots ,
+are taken as the expected types of the element patterns ´p_1, ...,
 p_n´.  If the case class is polymorphic, then its type parameters are
 instantiated so that the instantiation of ´c´ conforms to the expected
 type of the pattern. The instantiated formal parameter types of ´c´'s
 primary constructor are then taken as the expected types of the
-component patterns ´p_1, \ldots , p_n´.  The pattern matches all
-objects created from constructor invocations ´c(v_1 , \ldots , v_n)´
+component patterns ´p_1, ..., p_n´.  The pattern matches all
+objects created from constructor invocations ´c(v_1, ..., v_n)´
 where each element pattern ´p_i´ matches the corresponding value
 ´v_i´.
 
@@ -220,8 +220,8 @@ repeated parameter. This is further discussed [here](#pattern-sequences).
   SimplePattern   ::=  ‘(’ [Patterns] ‘)’
 ```
 
-A _tuple pattern_ `(´p_1 , \ldots , p_n´)` is an alias
-for the constructor pattern `scala.Tuple´n´(´p_1 , \ldots , p_n´)`,
+A _tuple pattern_ `(´p_1´, ..., ´p_n´)` is an alias
+for the constructor pattern `scala.Tuple´n´(´p_1´, ..., ´p_n´)`,
 where ´n \geq 2´. The empty tuple
 `()` is the unique value of type `scala.Unit`.
 
@@ -231,7 +231,7 @@ where ´n \geq 2´. The empty tuple
   SimplePattern   ::=  StableId ‘(’ [Patterns] ‘)’
 ```
 
-An _extractor pattern_ ´x(p_1 , \ldots , p_n)´ where ´n \geq 0´ is of
+An _extractor pattern_ ´x(p_1, ..., p_n)´ where ´n \geq 0´ is of
 the same syntactic form as a constructor pattern. However, instead of
 a case class, the stable identifier ´x´ denotes an object which has a
 member method named `unapply` or `unapplySeq` that matches
@@ -245,7 +245,7 @@ method `get` with return type `T`, and a method `isEmpty` with a return type
 that conforms to `Boolean`. `Option[T]` is an extractor type for type `T`.
 
 An `unapply` method in an object ´x´ _matches_ the pattern
-´x(p_1 , \ldots , p_n)´ if it has a single parameter (and, optionally, an
+´x(p_1, ..., p_n)´ if it has a single parameter (and, optionally, an
 implicit parameter list) and one of the following applies:
 
 * ´n=0´ and `unapply`'s result type conforms to `Boolean`. In this case
@@ -257,18 +257,18 @@ implicit parameter list) and one of the following applies:
   values ´v´ for which `´x´.unapply(´v´)` yields a value ´u´ for which `´u´.isEmpty` yields
   `false`, `´u´.get` yields a value ´v_1´, and ´p_1´ matches ´v_1´.
 * ´n>1´ and `unapply`'s result type is
-  an extractor type for some type ´T´ with members ´\_1 , \ldots , \_n´ returning
-  types ´T_1 , \ldots , T_n´.  In this case, the argument patterns ´p_1
-  , \ldots , p_n´ are typed in turn with expected types ´T_1 , \ldots ,
+  an extractor type for some type ´T´ with members ´\_1, ..., \_n´ returning
+  types ´T_1, ..., T_n´.  In this case, the argument patterns ´p_1
+ , ..., p_n´ are typed in turn with expected types ´T_1 , ...,
   T_n´.  The extractor pattern matches then all values ´v´ for which
   `´x´.unapply(´v´)` yields a value ´u´ for which
   `´u´.isEmpty` yields `false`, `´u´.get` yields some value ´t´, and each pattern
   ´p_i´ matches the corresponding value ´t._1´ from
-  ´t._1 , \ldots , t._n´.
+  ´t._1, ..., t._n´.
 
 An `unapplySeq` method in an object ´x´ matches the pattern
-´x(q_1 , \ldots , q_m, p_1 , \ldots , p_n)´ if it takes exactly one argument
-and its result type is of the form `Option[(´T_1 , \ldots , T_m´, Seq[S])]` (if `m = 0`, the type `Option[Seq[S]]` is also accepted).
+´x(q_1, ..., q_m, p_1, ..., p_n)´ if it takes exactly one argument
+and its result type is of the form `Option[(´T_1, ..., T_m´, Seq[S])]` (if `m = 0`, the type `Option[Seq[S]]` is also accepted).
 This case is further discussed [below](#pattern-sequences).
 
 ###### Example 1
@@ -330,9 +330,9 @@ object Extractor {
 SimplePattern ::= StableId ‘(’ [Patterns ‘,’] [varid ‘@’] ‘_’ ‘*’ ‘)’
 ```
 
-A _pattern sequence_ ´p_1 , \ldots , p_n´ appears in two contexts.
-First, in a constructor pattern ´c(q_1 , \ldots , q_m, p_1 , \ldots , p_n)´, where ´c´ is a case class which has ´m+1´ primary constructor parameters,  ending in a [repeated parameter](04-basic-declarations-and-definitions.html#repeated-parameters) of type `S*`.
-Second, in an extractor pattern ´x(q_1 , \ldots , q_m, p_1 , \ldots , p_n)´ if the extractor object ´x´ does not have an `unapply` method,
+A _pattern sequence_ ´p_1, ..., p_n´ appears in two contexts.
+First, in a constructor pattern ´c(q_1, ..., q_m, p_1, ..., p_n)´, where ´c´ is a case class which has ´m+1´ primary constructor parameters,  ending in a [repeated parameter](04-basic-declarations-and-definitions.html#repeated-parameters) of type `S*`.
+Second, in an extractor pattern ´x(q_1, ..., q_m, p_1, ..., p_n)´ if the extractor object ´x´ does not have an `unapply` method,
 but it does define an `unapplySeq` method with a result type that is an extractor type for type `(T_1, ... , T_m, Seq[S])` (if `m = 0`, an extractor type for the type `Seq[S]` is also accepted). The expected type for the patterns ´p_i´ is ´S´.
 
 The last pattern in a pattern sequence may be a _sequence wildcard_ `_*`.
@@ -340,9 +340,9 @@ Each element pattern ´p_i´ is type-checked with
 ´S´ as expected type, unless it is a sequence wildcard. If a final
 sequence wildcard is present, the pattern matches all values ´v´ that
 are sequences which start with elements matching patterns
-´p_1 , \ldots , p_{n-1}´.  If no final sequence wildcard is given, the
+´p_1, ..., p_{n-1}´.  If no final sequence wildcard is given, the
 pattern matches all values ´v´ that are sequences of
-length ´n´ which consist of elements matching patterns ´p_1 , \ldots ,
+length ´n´ which consist of elements matching patterns ´p_1 , ...,
 p_n´.
 
 ### Infix Operation Patterns
@@ -356,9 +356,9 @@ constructor or extractor pattern ´\mathit{op}(p, q)´.  The precedence and
 associativity of operators in patterns is the same as in
 [expressions](06-expressions.html#prefix,-infix,-and-postfix-operations).
 
-An infix operation pattern ´p;\mathit{op};(q_1 , \ldots , q_n)´ is a
+An infix operation pattern ´p;\mathit{op};(q_1, ..., q_n)´ is a
 shorthand for the constructor or extractor pattern ´\mathit{op}(p, q_1
-, \ldots , q_n)´.
+, ..., q_n)´.
 
 ### Pattern Alternatives
 
@@ -366,7 +366,7 @@ shorthand for the constructor or extractor pattern ´\mathit{op}(p, q_1
   Pattern   ::=  Pattern1 { ‘|’ Pattern1 }
 ```
 
-A _pattern alternative_ `´p_1´ | ´\ldots´ | ´p_n´`
+A _pattern alternative_ `´p_1´ | ... | ´p_n´`
 consists of a number of alternative patterns ´p_i´. All alternative
 patterns are type checked with the expected type of the pattern. They
 may not bind variables other than wildcards. The alternative pattern
@@ -398,9 +398,9 @@ A pattern ´p´ is _irrefutable_ for a type ´T´, if one of the following appli
 
 1.  ´p´ is a variable pattern,
 1.  ´p´ is a typed pattern ´x: T'´, and ´T <: T'´,
-1.  ´p´ is a constructor pattern ´c(p_1 , \ldots , p_n)´, the type ´T´
+1.  ´p´ is a constructor pattern ´c(p_1, ..., p_n)´, the type ´T´
     is an instance of class ´c´, the [primary constructor](05-classes-and-objects.html#class-definitions)
-    of type ´T´ has argument types ´T_1 , \ldots , T_n´, and each ´p_i´ is
+    of type ´T´ has argument types ´T_1, ..., T_n´, and each ´p_i´ is
     irrefutable for ´T_i´.
 1.  ´p´ is an extractor pattern for which the extractor type is `Some[´T´]` for
     some type ´T´
@@ -438,11 +438,11 @@ A type pattern ´T´ is of one of the following  forms:
   denoted by the literal ´lit´ (the `==` method is used to compare the matched
   value to ´lit´).
 
-* A compound type pattern `´T_1´ with ´\ldots´ with ´T_n´` where each ´T_i´ is a
+* A compound type pattern `´T_1´ with ... with ´T_n´` where each ´T_i´ is a
   type pattern. This type pattern matches all values that are matched by each of
   the type patterns ´T_i´.
 
-* A parameterized type pattern ´T[a_1 , \ldots , a_n]´, where the ´a_i´
+* A parameterized type pattern ´T[a_1, ..., a_n]´, where the ´a_i´
   are type variable patterns or wildcards `_`.
   This type pattern matches all values which match ´T´ for
   some arbitrary instantiation of the type variables and wildcards. The
@@ -472,46 +472,46 @@ pattern.
 ### Type parameter inference for typed patterns
 
 Assume a typed pattern ´p: T'´. Let ´T´ result from ´T'´ where all wildcards in
-´T'´ are renamed to fresh variable names. Let ´a_1 , \ldots , a_n´ be
+´T'´ are renamed to fresh variable names. Let ´a_1, ..., a_n´ be
 the type variables in ´T´. These type variables are considered bound
 in the pattern. Let the expected type of the pattern be ´\mathit{pt}´.
 
 Type parameter inference constructs first a set of subtype constraints over
 the type variables ´a_i´. The initial constraints set ´\mathcal{C}\_0´ reflects
 just the bounds of these type variables. That is, assuming ´T´ has
-bound type variables ´a_1 , \ldots , a_n´ which correspond to class
-type parameters ´a_1' , \ldots , a_n'´ with lower bounds ´L_1, \ldots , L_n´
-and upper bounds ´U_1 , \ldots , U_n´, ´\mathcal{C}_0´ contains the constraints
+bound type variables ´a_1, ..., a_n´ which correspond to class
+type parameters ´a_1', ..., a_n'´ with lower bounds ´L_1, ..., L_n´
+and upper bounds ´U_1, ..., U_n´, ´\mathcal{C}_0´ contains the constraints
 
 $$
 \begin{cases}
-a_i &<: \sigma U_i & \quad (i = 1, \ldots , n) \\\\
-\sigma L_i &<: a_i & \quad (i = 1, \ldots , n)
+a_i &<: \sigma U_i & \quad (i = 1, ..., n) \\\\
+\sigma L_i &<: a_i & \quad (i = 1, ..., n)
 \end{cases}
 $$
 
-where ´\sigma´ is the substitution ´[a_1' := a_1 , \ldots , a_n' :=a_n]´.
+where ´\sigma´ is the substitution ´[a_1' := a_1, ..., a_n' :=a_n]´.
 
 The set ´\mathcal{C}_0´ is then augmented by further subtype constraints. There are two
 cases.
 
 ###### Case 1
-If there exists a substitution ´\sigma´ over the type variables ´a_i , \ldots , a_n´ such that ´\sigma T´ conforms to ´\mathit{pt}´, one determines the weakest subtype constraints
-´\mathcal{C}\_1´ over the type variables ´a_1, \ldots , a_n´ such that ´\mathcal{C}\_0 \wedge \mathcal{C}_1´ implies that ´T´ conforms to ´\mathit{pt}´.
+If there exists a substitution ´\sigma´ over the type variables ´a_i, ..., a_n´ such that ´\sigma T´ conforms to ´\mathit{pt}´, one determines the weakest subtype constraints
+´\mathcal{C}\_1´ over the type variables ´a_1, ..., a_n´ such that ´\mathcal{C}\_0 \wedge \mathcal{C}_1´ implies that ´T´ conforms to ´\mathit{pt}´.
 
 ###### Case 2
 Otherwise, if ´T´ can not be made to conform to ´\mathit{pt}´ by
 instantiating its type variables, one determines all type variables in
 ´\mathit{pt}´ which are defined as type parameters of a method enclosing
-the pattern. Let the set of such type parameters be ´b_1 , \ldots ,
+the pattern. Let the set of such type parameters be ´b_1 , ...,
 b_m´. Let ´\mathcal{C}\_0'´ be the subtype constraints reflecting the bounds of the
 type variables ´b_i´.  If ´T´ denotes an instance type of a final
 class, let ´\mathcal{C}\_2´ be the weakest set of subtype constraints over the type
-variables ´a_1 , \ldots , a_n´ and ´b_1 , \ldots , b_m´ such that
+variables ´a_1, ..., a_n´ and ´b_1, ..., b_m´ such that
 ´\mathcal{C}\_0 \wedge \mathcal{C}\_0' \wedge \mathcal{C}\_2´ implies that ´T´ conforms to
 ´\mathit{pt}´.  If ´T´ does not denote an instance type of a final class,
 let ´\mathcal{C}\_2´ be the weakest set of subtype constraints over the type variables
-´a_1 , \ldots , a_n´ and ´b_1 , \ldots , b_m´ such that ´\mathcal{C}\_0 \wedge
+´a_1, ..., a_n´ and ´b_1, ..., b_m´ such that ´\mathcal{C}\_0 \wedge
 \mathcal{C}\_0' \wedge \mathcal{C}\_2´ implies that it is possible to construct a type
 ´T'´ which conforms to both ´T´ and ´\mathit{pt}´. It is a static error if
 there is no satisfiable set of constraints ´\mathcal{C}\_2´ with this property.
@@ -521,13 +521,13 @@ variables which imply the established constraint system. The process
 is different for the two cases above.
 
 ###### Case 1
-We take ´a_i >: L_i <: U_i´ where each ´L_i´ is minimal and each ´U_i´ is maximal wrt ´<:´ such that ´a_i >: L_i <: U_i´ for ´i = 1, \ldots, n´ implies ´\mathcal{C}\_0 \wedge \mathcal{C}\_1´.
+We take ´a_i >: L_i <: U_i´ where each ´L_i´ is minimal and each ´U_i´ is maximal wrt ´<:´ such that ´a_i >: L_i <: U_i´ for ´i = 1, ..., n´ implies ´\mathcal{C}\_0 \wedge \mathcal{C}\_1´.
 
 ###### Case 2
 We take ´a_i >: L_i <: U_i´ and ´b\_i >: L_i' <: U_i' ´ where each ´L_i´
 and ´L_j'´ is minimal and each ´U_i´ and ´U_j'´ is maximal such that
-´a_i >: L_i <: U_i´ for ´i = 1 , \ldots , n´ and
-´b_j >: L_j' <: U_j'´ for ´j = 1 , \ldots , m´
+´a_i >: L_i <: U_i´ for ´i = 1, ..., n´ and
+´b_j >: L_j' <: U_j'´ for ´j = 1, ..., m´
 implies ´\mathcal{C}\_0 \wedge \mathcal{C}\_0' \wedge \mathcal{C}_2´.
 
 In both cases, local type inference is permitted to limit the
@@ -536,10 +536,10 @@ to be understood relative to the set of types of acceptable
 complexity.
 
 ### Type parameter inference for constructor patterns
-Assume a constructor pattern ´C(p_1 , \ldots , p_n)´ where class ´C´
-has type parameters ´a_1 , \ldots , a_n´.  These type parameters
+Assume a constructor pattern ´C(p_1, ..., p_n)´ where class ´C´
+has type parameters ´a_1, ..., a_n´.  These type parameters
 are inferred in the same way as for the typed pattern
-`(_: ´C[a_1 , \ldots , a_n]´)`.
+`(_: ´C[a_1, ..., a_n]´)`.
 
 ###### Example
 Consider the program fragment:
@@ -625,7 +625,7 @@ function's declared result type, `Number`.
 A _pattern matching expression_
 
 ```scala
-e match { case ´p_1´ => ´b_1´ ´\ldots´ case ´p_n´ => ´b_n´ }
+e match { case ´p_1´ => ´b_1´ ... case ´p_n´ => ´b_n´ }
 ```
 
 consists of a selector expression ´e´ and a number ´n > 0´ of
@@ -636,9 +636,9 @@ The scope of the pattern
 variables in ´p_i´ comprises the pattern's guard and the corresponding block ´b_i´.
 
 Let ´T´ be the type of the selector expression ´e´ and let ´a_1
-, \ldots , a_m´ be the type parameters of all methods enclosing
+, ..., a_m´ be the type parameters of all methods enclosing
 the pattern matching expression.  For every ´a_i´, let ´L_i´ be its
-lower bound and ´U_i´ be its higher bound.  Every pattern ´p \in \{p_1, , \ldots , p_n\}´
+lower bound and ´U_i´ be its higher bound.  Every pattern ´p \in \{p_1,, ..., p_n\}´
 can be typed in two ways. First, it is attempted
 to type ´p´ with ´T´ as its expected type. If this fails, ´p´ is
 instead typed with a modified expected type ´T'´ which results from
@@ -646,12 +646,12 @@ instead typed with a modified expected type ´T'´ which results from
 *undefined*.  If this second step fails also, a compile-time
 error results. If the second step succeeds, let ´T_p´ be the type of
 pattern ´p´ seen as an expression. One then determines minimal bounds
-´L_11 , \ldots , L_m'´ and maximal bounds ´U_1' , \ldots , U_m'´ such
+´L_11, ..., L_m'´ and maximal bounds ´U_1', ..., U_m'´ such
 that for all ´i´, ´L_i <: L_i'´ and ´U_i' <: U_i´ and the following
 constraint system is satisfied:
 
 $$
-L_1 <: a_1 <: U_1\;\wedge\;\ldots\;\wedge\;L_m <: a_m <: U_m \ \Rightarrow\ T_p <: T
+L_1 <: a_1 <: U_1\;\wedge\;...\;\wedge\;L_m <: a_m <: U_m \ \Rightarrow\ T_p <: T
 $$
 
 If no such bounds can be found, a compile time error results.  If such
@@ -742,23 +742,23 @@ conforms to its expected type, `T`.
 An anonymous function can be defined by a sequence of cases
 
 ```scala
-{ case ´p_1´ => ´b_1´ ´\ldots´ case ´p_n´ => ´b_n´ }
+{ case ´p_1´ => ´b_1´ ... case ´p_n´ => ´b_n´ }
 ```
 
 which appear as an expression without a prior `match`.  The
 expected type of such an expression must in part be defined. It must
-be either `scala.Function´k´[´S_1 , \ldots , S_k´, ´R´]` for some ´k > 0´,
+be either `scala.Function´k´[´S_1, ..., S_k´, ´R´]` for some ´k > 0´,
 or `scala.PartialFunction[´S_1´, ´R´]`, where the
-argument type(s) ´S_1 , \ldots , S_k´ must be fully determined, but the result type
+argument type(s) ´S_1, ..., S_k´ must be fully determined, but the result type
 ´R´ may be undetermined.
 
 If the expected type is [SAM-convertible](06-expressions.html#sam-conversion)
-to `scala.Function´k´[´S_1 , \ldots , S_k´, ´R´]`,
+to `scala.Function´k´[´S_1, ..., S_k´, ´R´]`,
 the expression is taken to be equivalent to the anonymous function:
 
 ```scala
-(´x_1: S_1 , \ldots , x_k: S_k´) => (´x_1 , \ldots , x_k´) match {
-  case ´p_1´ => ´b_1´ ´\ldots´ case ´p_n´ => ´b_n´
+(´x_1: S_1, ..., x_k: S_k´) => (´x_1, ..., x_k´) match {
+  case ´p_1´ => ´b_1´ ... case ´p_n´ => ´b_n´
 }
 ```
 
@@ -768,9 +768,9 @@ equivalent to the following instance creation expression, where
  ´T´ is the weak least upper bound of the types of all ´b_i´.
 
 ```scala
-new scala.Function´k´[´S_1 , \ldots , S_k´, ´T´] {
-  def apply(´x_1: S_1 , \ldots , x_k: S_k´): ´T´ = (´x_1 , \ldots , x_k´) match {
-    case ´p_1´ => ´b_1´ ´\ldots´ case ´p_n´ => ´b_n´
+new scala.Function´k´[´S_1, ..., S_k´, ´T´] {
+  def apply(´x_1: S_1, ..., x_k: S_k´): ´T´ = (´x_1, ..., x_k´) match {
+    case ´p_1´ => ´b_1´ ... case ´p_n´ => ´b_n´
   }
 }
 ```
@@ -781,10 +781,10 @@ the expression is taken to be equivalent to the following instance creation expr
 ```scala
 new scala.PartialFunction[´S´, ´T´] {
   def apply(´x´: ´S´): ´T´ = x match {
-    case ´p_1´ => ´b_1´ ´\ldots´ case ´p_n´ => ´b_n´
+    case ´p_1´ => ´b_1´ ... case ´p_n´ => ´b_n´
   }
   def isDefinedAt(´x´: ´S´): Boolean = {
-    case ´p_1´ => true ´\ldots´ case ´p_n´ => true
+    case ´p_1´ => true ... case ´p_n´ => true
     case _ => false
   }
 }
@@ -792,7 +792,7 @@ new scala.PartialFunction[´S´, ´T´] {
 
 Here, ´x´ is a fresh name and ´T´ is the weak least upper bound of the
 types of all ´b_i´. The final default case in the `isDefinedAt`
-method is omitted if one of the patterns ´p_1 , \ldots , p_n´ is
+method is omitted if one of the patterns ´p_1, ..., p_n´ is
 already a variable or wildcard pattern.
 
 ###### Example
diff --git a/docs/_spec/09-top-level-definitions.md b/docs/_spec/09-top-level-definitions.md
index 33c436e8d77b..3588d26f6034 100644
--- a/docs/_spec/09-top-level-definitions.md
+++ b/docs/_spec/09-top-level-definitions.md
@@ -27,7 +27,7 @@ A _compilation unit_
 
 ```scala
 package ´p_1´;
-´\ldots´
+...
 package ´p_n´;
 ´\mathit{stats}´
 ```
@@ -37,10 +37,10 @@ clauses is equivalent to a compilation unit consisting of the
 packaging
 
 ```scala
-package ´p_1´ { ´\ldots´
+package ´p_1´ { ...
   package ´p_n´ {
     ´\mathit{stats}´
-  } ´\ldots´
+  } ...
 }
 ```
 
diff --git a/docs/_spec/11-annotations.md b/docs/_spec/11-annotations.md
index 388d99b60e56..9f806ff5a471 100644
--- a/docs/_spec/11-annotations.md
+++ b/docs/_spec/11-annotations.md
@@ -14,7 +14,7 @@ chapter: 11
 ## Definition
 
 Annotations associate meta-information with definitions.
-A simple annotation has the form `@´c´` or `@´c(a_1 , \ldots , a_n)´`.
+A simple annotation has the form `@´c´` or `@´c(a_1, ..., a_n)´`.
 Here, ´c´ is a constructor of a class ´C´, which must conform
 to the class `scala.Annotation`.
 
diff --git a/docs/_spec/12-the-scala-standard-library.md b/docs/_spec/12-the-scala-standard-library.md
index 80d66c0c4166..9bbc12e463dd 100644
--- a/docs/_spec/12-the-scala-standard-library.md
+++ b/docs/_spec/12-the-scala-standard-library.md
@@ -56,10 +56,10 @@ abstract class Any {
   final def != (that: Any): Boolean  =  !(this == that)
 
   /** Hash code; abstract here */
-  def hashCode: Int = ´\ldots´
+  def hashCode: Int = ...
 
   /** Textual representation; abstract here */
-  def toString: String = ´\ldots´
+  def toString: String = ...
 
   /** Type test; needs to be inlined to work as given */
   def isInstanceOf[a]: Boolean
@@ -78,11 +78,11 @@ final class AnyVal extends Any
 /** The root class of all reference types */
 class AnyRef extends Any {
   def equals(that: Any): Boolean      = this eq that
-  final def eq(that: AnyRef): Boolean = ´\ldots´ // reference equality
+  final def eq(that: AnyRef): Boolean = ... // reference equality
   final def ne(that: AnyRef): Boolean = !(this eq that)
 
-  def hashCode: Int = ´\ldots´     // hashCode computed from allocation address
-  def toString: String  = ´\ldots´ // toString computed from hashCode and class name
+  def hashCode: Int = ...     // hashCode computed from allocation address
+  def toString: String  = ... // toString computed from hashCode and class name
 
   def synchronized[T](body: => T): T // execute `body` in while locking `this`.
 }
@@ -353,13 +353,13 @@ right operand.
 
 ### The `Tuple` classes
 
-Scala defines tuple classes `Tuple´n´` for ´n = 2 , \ldots , 22´.
+Scala defines tuple classes `Tuple´n´` for ´n = 2, ..., 22´.
 These are defined as follows.
 
 ```scala
 package scala
 case class Tuple´n´[+T_1, ..., +T_n](_1: T_1, ..., _´n´: T_´n´) {
-  def toString = "(" ++ _1 ++ "," ++ ´\ldots´ ++ "," ++ _´n´ ++ ")"
+  def toString = "(" ++ _1 ++ "," ++ ... ++ "," ++ _´n´ ++ ")"
 }
 ```
 
@@ -397,10 +397,10 @@ informational purposes only:
 ```scala
 final class Array[T](_length: Int)
 extends java.io.Serializable with java.lang.Cloneable {
-  def length: Int = ´\ldots´
-  def apply(i: Int): T = ´\ldots´
-  def update(i: Int, x: T): Unit = ´\ldots´
-  override def clone(): Array[T] = ´\ldots´
+  def length: Int = ...
+  def apply(i: Int): T = ...
+  def update(i: Int, x: T): Unit = ...
+  override def clone(): Array[T] = ...
 }
 ```
 
@@ -502,46 +502,46 @@ package scala
 object Array {
   /** copies array elements from `src` to `dest`. */
   def copy(src: AnyRef, srcPos: Int,
-           dest: AnyRef, destPos: Int, length: Int): Unit = ´\ldots´
+           dest: AnyRef, destPos: Int, length: Int): Unit = ...
 
   /** Returns an array of length 0 */
   def empty[T: ClassTag]: Array[T] =
 
   /** Create an array with given elements. */
-  def apply[T: ClassTag](xs: T*): Array[T] = ´\ldots´
+  def apply[T: ClassTag](xs: T*): Array[T] = ...
 
   /** Creates array with given dimensions */
-  def ofDim[T: ClassTag](n1: Int): Array[T] = ´\ldots´
+  def ofDim[T: ClassTag](n1: Int): Array[T] = ...
   /** Creates a 2-dimensional array */
-  def ofDim[T: ClassTag](n1: Int, n2: Int): Array[Array[T]] = ´\ldots´
-  ´\ldots´
+  def ofDim[T: ClassTag](n1: Int, n2: Int): Array[Array[T]] = ...
+  ...
 
   /** Concatenate all argument arrays into a single array. */
-  def concat[T: ClassTag](xss: Array[T]*): Array[T] = ´\ldots´
+  def concat[T: ClassTag](xss: Array[T]*): Array[T] = ...
 
   /** Returns an array that contains the results of some element computation a number
     * of times. */
-  def fill[T: ClassTag](n: Int)(elem: => T): Array[T] = ´\ldots´
+  def fill[T: ClassTag](n: Int)(elem: => T): Array[T] = ...
   /** Returns a two-dimensional array that contains the results of some element
     * computation a number of times. */
-  def fill[T: ClassTag](n1: Int, n2: Int)(elem: => T): Array[Array[T]] = ´\ldots´
-  ´\ldots´
+  def fill[T: ClassTag](n1: Int, n2: Int)(elem: => T): Array[Array[T]] = ...
+  ...
 
   /** Returns an array containing values of a given function over a range of integer
     * values starting from 0. */
-  def tabulate[T: ClassTag](n: Int)(f: Int => T): Array[T] = ´\ldots´
+  def tabulate[T: ClassTag](n: Int)(f: Int => T): Array[T] = ...
   /** Returns a two-dimensional array containing values of a given function
     * over ranges of integer values starting from `0`. */
-  def tabulate[T: ClassTag](n1: Int, n2: Int)(f: (Int, Int) => T): Array[Array[T]] = ´\ldots´
-  ´\ldots´
+  def tabulate[T: ClassTag](n1: Int, n2: Int)(f: (Int, Int) => T): Array[Array[T]] = ...
+  ...
 
   /** Returns an array containing a sequence of increasing integers in a range. */
-  def range(start: Int, end: Int): Array[Int] = ´\ldots´
+  def range(start: Int, end: Int): Array[Int] = ...
   /** Returns an array containing equally spaced values in some integer interval. */
-  def range(start: Int, end: Int, step: Int): Array[Int] = ´\ldots´
+  def range(start: Int, end: Int, step: Int): Array[Int] = ...
 
   /** Returns an array containing repeated applications of a function to a start value. */
-  def iterate[T: ClassTag](start: T, len: Int)(f: T => T): Array[T] = ´\ldots´
+  def iterate[T: ClassTag](start: T, len: Int)(f: T => T): Array[T] = ...
 
   /** Enables pattern matching over arrays */
   def unapplySeq[A](x: Array[A]): Option[IndexedSeq[A]] = Some(x)

From 95b703f237d06dbc05842495356c232b69e6f6ea Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Tue, 18 Oct 2022 16:19:08 +0200
Subject: [PATCH 106/657] Reformat to 1sentence=1line convention

---
 docs/_spec/01-lexical-syntax.md               |  308 ++--
 docs/_spec/02-identifiers-names-and-scopes.md |   97 +-
 docs/_spec/03-types.md                        |  713 +++-------
 .../04-basic-declarations-and-definitions.md  |  538 +++----
 docs/_spec/05-classes-and-objects.md          |  890 ++++--------
 docs/_spec/06-expressions.md                  | 1266 ++++++-----------
 docs/_spec/07-implicits.md                    |  348 ++---
 docs/_spec/08-pattern-matching.md             |  589 +++-----
 docs/_spec/09-top-level-definitions.md        |  104 +-
 docs/_spec/10-xml-expressions-and-patterns.md |   61 +-
 docs/_spec/11-annotations.md                  |  192 +--
 docs/_spec/12-the-scala-standard-library.md   |  437 +++---
 docs/_spec/13-syntax-summary.md               |    3 +-
 docs/_spec/README.md                          |    4 +
 14 files changed, 1899 insertions(+), 3651 deletions(-)

diff --git a/docs/_spec/01-lexical-syntax.md b/docs/_spec/01-lexical-syntax.md
index 46bd876b4077..032cf3703bb9 100644
--- a/docs/_spec/01-lexical-syntax.md
+++ b/docs/_spec/01-lexical-syntax.md
@@ -9,22 +9,16 @@ chapter: 1
 Scala source code consists of Unicode text.
 
 The program text is tokenized as described in this chapter.
-See the last section for special support for XML literals,
-which are parsed in _XML mode_.
+See the last section for special support for XML literals, which are parsed in _XML mode_.
 
-To construct tokens, characters are distinguished according to the following
-classes (Unicode general category given in parentheses):
+To construct tokens, characters are distinguished according to the following classes (Unicode general category given in parentheses):
 
 1. Whitespace characters. `\u0020 | \u0009 | \u000D | \u000A`.
-1. Letters, which include lower case letters (`Ll`), upper case letters (`Lu`),
-   title case letters (`Lt`), other letters (`Lo`), modifier letters (`Lm`), 
-   letter numerals (`Nl`) and the two characters `\u0024 ‘$’` and `\u005F ‘_’`.
+1. Letters, which include lower case letters (`Ll`), upper case letters (`Lu`), title case letters (`Lt`), other letters (`Lo`), modifier letters (`Lm`), letter numerals (`Nl`) and the two characters `\u0024 ‘$’` and `\u005F ‘_’`.
 1. Digits `‘0’ | ... | ‘9’`.
 1. Parentheses `‘(’ | ‘)’ | ‘[’ | ‘]’ | ‘{’ | ‘}’ `.
 1. Delimiter characters ``‘`’ | ‘'’ | ‘"’ | ‘.’ | ‘;’ | ‘,’ ``.
-1. Operator characters. These consist of all printable ASCII characters
-   (`\u0020` - `\u007E`) that are in none of the sets above, mathematical
-   symbols (`Sm`) and other symbols (`So`).
+1. Operator characters. These consist of all printable ASCII characters (`\u0020` - `\u007E`) that are in none of the sets above, mathematical symbols (`Sm`) and other symbols (`So`).
 
 ## Identifiers
 
@@ -44,19 +38,16 @@ UnicodeEscape ::= ‘\’ ‘u’ {‘u’} hexDigit hexDigit hexDigit hexDigit
 hexDigit      ::= ‘0’ | ... | ‘9’ | ‘A’ | ... | ‘F’ | ‘a’ | ... | ‘f’
 ```
 
-There are three ways to form an identifier. First, an identifier can
-start with a letter, followed by an arbitrary sequence of
-letters and digits. This may be followed by underscore `‘_‘`
-characters and another string composed of either letters and digits or
-of operator characters.  Second, an identifier can start with an operator
-character followed by an arbitrary sequence of operator characters.
-The preceding two forms are called _plain_ identifiers.  Finally,
-an identifier may also be formed by an arbitrary string between
-backquotes (host systems may impose some restrictions on which
-strings are legal for identifiers).  The identifier then is composed
-of all characters excluding the backquotes themselves.
+There are three ways to form an identifier.
+First, an identifier can start with a letter, followed by an arbitrary sequence of letters and digits.
+This may be followed by underscore `‘_‘` characters and another string composed of either letters and digits or of operator characters.
+Second, an identifier can start with an operator character followed by an arbitrary sequence of operator characters.
+The preceding two forms are called _plain_ identifiers.
+Finally, an identifier may also be formed by an arbitrary string between backquotes (host systems may impose some restrictions on which strings are legal for identifiers).
+The identifier then is composed of all characters excluding the backquotes themselves.
 
-As usual, the longest match rule applies. For instance, the string
+As usual, the longest match rule applies.
+For instance, the string
 
 ```scala
 big_bob++=`def`
@@ -65,15 +56,9 @@ big_bob++=`def`
 decomposes into the three identifiers `big_bob`, `++=`, and
 `def`.
 
-The rules for pattern matching further distinguish between
-_variable identifiers_, which start with a lower case letter
-or `_`, and _constant identifiers_, which do not.
+The rules for pattern matching further distinguish between _variable identifiers_, which start with a lower case letter or `_`, and _constant identifiers_, which do not.
 
-For this purpose, lower case letters include not only a-z,
-but also all characters in Unicode category Ll (lowercase letter),
-as well as all letters that have contributory property
-Other_Lowercase, except characters in category Nl (letter numerals),
-which are never taken as lower case.
+For this purpose, lower case letters include not only a-z, but also all characters in Unicode category Ll (lowercase letter), as well as all letters that have contributory property Other_Lowercase, except characters in category Nl (letter numerals), which are never taken as lower case.
 
 The following are examples of variable identifiers:
 
@@ -94,8 +79,7 @@ Some examples of constant identifiers are
 The ‘$’ character is reserved for compiler-synthesized identifiers.
 User programs should not define identifiers that contain ‘$’ characters.
 
-The following names are reserved words instead of being members of the
-syntactic class `id` of lexical identifiers.
+The following names are reserved words instead of being members of the syntactic class `id` of lexical identifiers.
 
 ```scala
 abstract    case        catch       class       def
@@ -109,8 +93,7 @@ val         var         while       with        yield
 _    :    =    =>    <-    <:    <%     >:    #    @
 ```
 
-The Unicode operators `\u21D2` ‘´\Rightarrow´’ and `\u2190` ‘´\leftarrow´’, which have the ASCII
-equivalents `=>` and `<-`, are also reserved.
+The Unicode operators `\u21D2` ‘´\Rightarrow´’ and `\u2190` ‘´\leftarrow´’, which have the ASCII equivalents `=>` and `<-`, are also reserved.
 
 > Here are examples of identifiers:
 > ```scala
@@ -131,24 +114,21 @@ equivalents `=>` and `<-`, are also reserved.
 semi ::= ‘;’ |  nl {nl}
 ```
 
-Scala is a line-oriented language where statements may be terminated by
-semi-colons or newlines. A newline in a Scala source text is treated
-as the special token “nl” if the three following criteria are satisfied:
+Scala is a line-oriented language where statements may be terminated by semi-colons or newlines.
+A newline in a Scala source text is treated as the special token “nl” if the three following criteria are satisfied:
 
 1. The token immediately preceding the newline can terminate a statement.
 1. The token immediately following the newline can begin a statement.
 1. The token appears in a region where newlines are enabled.
 
-The tokens that can terminate a statement are: literals, identifiers
-and the following delimiters and reserved words:
+The tokens that can terminate a statement are: literals, identifiers and the following delimiters and reserved words:
 
 ```scala
 this    null    true    false    return    type    <xml-start>
 _       )       ]       }
 ```
 
-The tokens that can begin a statement are all Scala tokens _except_
-the following delimiters and reserved words:
+The tokens that can begin a statement are all Scala tokens _except_ the following delimiters and reserved words:
 
 ```scala
 catch    else    extends    finally    forSome    match
@@ -161,64 +141,39 @@ A `case` token can begin a statement only if followed by a
 
 Newlines are enabled in:
 
-1. all of a Scala source file, except for nested regions where newlines
-   are disabled, and
-1. the interval between matching `{` and `}` brace tokens,
-   except for nested regions where newlines are disabled.
+1. all of a Scala source file, except for nested regions where newlines are disabled, and
+1. the interval between matching `{` and `}` brace tokens, except for nested regions where newlines are disabled.
 
 Newlines are disabled in:
 
-1. the interval between matching `(` and `)` parenthesis tokens, except for
-   nested regions where newlines are enabled, and
-1. the interval between matching `[` and `]` bracket tokens, except for nested
-   regions where newlines are enabled.
-1. The interval between a `case` token and its matching
-   `=>` token, except for nested regions where newlines are
-   enabled.
+1. the interval between matching `(` and `)` parenthesis tokens, except for nested regions where newlines are enabled, and
+1. the interval between matching `[` and `]` bracket tokens, except for nested regions where newlines are enabled.
+1. The interval between a `case` token and its matching `=>` token, except for nested regions where newlines are enabled.
 1. Any regions analyzed in [XML mode](#xml-mode).
 
-Note that the brace characters of `{...}` escapes in XML and
-string literals are not tokens,
-and therefore do not enclose a region where newlines
-are enabled.
-
-Normally, only a single `nl` token is inserted between two
-consecutive non-newline tokens which are on different lines, even if there are multiple lines
-between the two tokens. However, if two tokens are separated by at
-least one completely blank line (i.e a line which contains no
-printable characters), then two `nl` tokens are inserted.
-
-The Scala grammar (given in full [here](13-syntax-summary.html))
-contains productions where optional `nl` tokens, but not
-semicolons, are accepted. This has the effect that a new line in one of these
-positions does not terminate an expression or statement. These positions can
-be summarized as follows:
-
-Multiple newline tokens are accepted in the following places (note
-that a semicolon in place of the newline would be illegal in every one
-of these cases):
-
-- between the condition of a
-  [conditional expression](06-expressions.html#conditional-expressions)
-  or [while loop](06-expressions.html#while-loop-expressions) and the next
-  following expression,
-- between the enumerators of a
-  [for-comprehension](06-expressions.html#for-comprehensions-and-for-loops)
-  and the next following expression, and
-- after the initial `type` keyword in a
-  [type definition or declaration](04-basic-declarations-and-definitions.html#type-declarations-and-type-aliases).
+Note that the brace characters of `{...}` escapes in XML and string literals are not tokens, and therefore do not enclose a region where newlines are enabled.
+
+Normally, only a single `nl` token is inserted between two consecutive non-newline tokens which are on different lines, even if there are multiple lines between the two tokens.
+However, if two tokens are separated by at least one completely blank line (i.e a line which contains no printable characters), then two `nl` tokens are inserted.
+
+The Scala grammar (given in full [here](13-syntax-summary.html)) contains productions where optional `nl` tokens, but not semicolons, are accepted.
+This has the effect that a new line in one of these positions does not terminate an expression or statement.
+These positions can be summarized as follows:
+
+Multiple newline tokens are accepted in the following places (note that a semicolon in place of the newline would be illegal in every one of these cases):
+
+- between the condition of a [conditional expression](06-expressions.html#conditional-expressions) or [while loop](06-expressions.html#while-loop-expressions) and the next following expression,
+- between the enumerators of a [for-comprehension](06-expressions.html#for-comprehensions-and-for-loops) and the next following expression, and
+- after the initial `type` keyword in a [type definition or declaration](04-basic-declarations-and-definitions.html#type-declarations-and-type-aliases).
 
 A single new line token is accepted
 
-- in front of an opening brace ‘{’, if that brace is a legal
-  continuation of the current statement or expression,
-- after an [infix operator](06-expressions.html#prefix,-infix,-and-postfix-operations),
-  if the first token on the next line can start an expression,
+- in front of an opening brace ‘{’, if that brace is a legal continuation of the current statement or expression,
+- after an [infix operator](06-expressions.html#prefix,-infix,-and-postfix-operations), if the first token on the next line can start an expression,
 - in front of a [parameter clause](04-basic-declarations-and-definitions.html#function-declarations-and-definitions), and
 - after an [annotation](11-annotations.html#user-defined-annotations).
 
-> The newline tokens between the two lines are not
-> treated as statement separators.
+> The newline tokens between the two lines are not treated as statement separators.
 >
 > ```scala
 > if (x > 0)
@@ -245,8 +200,7 @@ A single new line token is accepted
 > }
 > ```
 >
-> With an additional newline character, the same code is interpreted as
-> an object creation followed by a local block:
+> With an additional newline character, the same code is interpreted as an object creation followed by a local block:
 >
 > ```scala
 > new Iterator[Int]
@@ -265,8 +219,7 @@ A single new line token is accepted
 >   x > 10
 > ```
 >
-> With an additional newline character, the same code is interpreted as
-> two expressions:
+> With an additional newline character, the same code is interpreted as two expressions:
 >
 > ```scala
 >   x < 0 ||
@@ -281,8 +234,7 @@ A single new line token is accepted
 >         (y: Int) = x + y
 > ```
 >
-> With an additional newline character, the same code is interpreted as
-> an abstract function definition and a syntactically illegal statement:
+> With an additional newline character, the same code is interpreted as an abstract function definition and a syntactically illegal statement:
 >
 > ```scala
 > def func(x: Int)
@@ -297,8 +249,7 @@ A single new line token is accepted
 > protected class Data { ... }
 > ```
 >
-> With an additional newline character, the same code is interpreted as
-> an attribute and a separate statement (which is syntactically illegal).
+> With an additional newline character, the same code is interpreted as an attribute and a separate statement (which is syntactically illegal).
 >
 > ```scala
 > @serializable
@@ -308,9 +259,8 @@ A single new line token is accepted
 
 ## Literals
 
-There are literals for integer numbers, floating point numbers,
-characters, booleans, symbols, strings.  The syntax of these literals is in
-each case as in Java.
+There are literals for integer numbers, floating point numbers, characters, booleans, symbols, strings.
+The syntax of these literals is in each case as in Java.
 
 <!-- TODO
   say that we take values from Java, give examples of some lits in
@@ -337,21 +287,16 @@ decimalNumeral  ::=  digit {digit}
 hexNumeral      ::=  ‘0’ (‘x’ | ‘X’) hexDigit {hexDigit}
 ```
 
-Values of type `Int` are all integer
-numbers between $-2\^{31}$ and $2\^{31}-1$, inclusive.  Values of
-type `Long` are all integer numbers between $-2\^{63}$ and
-$2\^{63}-1$, inclusive. A compile-time error occurs if an integer literal
-denotes a number outside these ranges.
+Values of type `Int` are all integer numbers between $-2\^{31}$ and $2\^{31}-1$, inclusive.
+Values of type `Long` are all integer numbers between $-2\^{63}$ and
+$2\^{63}-1$, inclusive.
+A compile-time error occurs if an integer literal denotes a number outside these ranges.
 
-Integer literals are usually of type `Int`, or of type
-`Long` when followed by a `L` or `l` suffix.
+Integer literals are usually of type `Int`, or of type `Long` when followed by a `L` or `l` suffix.
 (Lowercase `l` is deprecated for reasons of legibility.)
 
-However, if the expected type [_pt_](06-expressions.html#expression-typing) of a literal
-in an expression is either `Byte`, `Short`, or `Char`
-and the integer number fits in the numeric range defined by the type,
-then the number is converted to type _pt_ and the literal's type
-is _pt_. The numeric ranges given by these types are:
+However, if the expected type [_pt_](06-expressions.html#expression-typing) of a literal in an expression is either `Byte`, `Short`, or `Char` and the integer number fits in the numeric range defined by the type, then the number is converted to type _pt_ and the literal's type is _pt_.
+The numeric ranges given by these types are:
 
 |                |                          |
 |----------------|--------------------------|
@@ -359,8 +304,7 @@ is _pt_. The numeric ranges given by these types are:
 |`Short`         | ´-2\^{15}´ to ´2\^{15}-1´|
 |`Char`          | ´0´ to ´2\^{16}-1´       |
 
-The digits of a numeric literal may be separated by
-arbitrarily many underscores for purposes of legibility.
+The digits of a numeric literal may be separated by arbitrarily many underscores for purposes of legibility.
 
 > ```scala
 > 0           21_000      0x7F        -42L        0xFFFF_FFFF
@@ -377,16 +321,10 @@ exponentPart          ::=  (‘E’ | ‘e’) [‘+’ | ‘-’] digit {digit}
 floatType             ::=  ‘F’ | ‘f’ | ‘D’ | ‘d’
 ```
 
-Floating point literals are of type `Float` when followed by
-a floating point type suffix `F` or `f`, and are
-of type `Double` otherwise.  The type `Float`
-consists of all IEEE 754 32-bit single-precision binary floating point
-values, whereas the type `Double` consists of all IEEE 754
-64-bit double-precision binary floating point values.
+Floating point literals are of type `Float` when followed by a floating point type suffix `F` or `f`, and are of type `Double` otherwise.
+The type `Float` consists of all IEEE 754 32-bit single-precision binary floating point values, whereas the type `Double` consists of all IEEE 754 64-bit double-precision binary floating point values.
 
-If a floating point literal in a program is followed by a token
-starting with a letter, there must be at least one intervening
-whitespace character between the two tokens.
+If a floating point literal in a program is followed by a token starting with a letter, there must be at least one intervening whitespace character between the two tokens.
 
 > ```scala
 > 0.0        1e30f      3.14159f      1.0e-100      .1
@@ -394,8 +332,7 @@ whitespace character between the two tokens.
 
 <!-- -->
 
-> The phrase `1.toString` parses as three different tokens:
-> the integer literal `1`, a `.`, and the identifier `toString`.
+> The phrase `1.toString` parses as three different tokens: the integer literal `1`, a `.`, and the identifier `toString`.
 
 <!-- -->
 
@@ -407,8 +344,7 @@ whitespace character between the two tokens.
 booleanLiteral  ::=  ‘true’ | ‘false’
 ```
 
-The boolean literals `true` and `false` are
-members of type `Boolean`.
+The boolean literals `true` and `false` are members of type `Boolean`.
 
 ### Character Literals
 
@@ -417,9 +353,7 @@ characterLiteral  ::=  ‘'’ (charNoQuoteOrNewline | escapeSeq) ‘'’
 ```
 
 A character literal is a single character enclosed in quotes.
-The character can be any Unicode character except the single quote
-delimiter or `\u000A` (LF) or `\u000D` (CR);
-or any Unicode character represented by an
+The character can be any Unicode character except the single quote delimiter or `\u000A` (LF) or `\u000D` (CR); or any Unicode character represented by an
 [escape sequence](#escape-sequences).
 
 > ```scala
@@ -434,9 +368,7 @@ stringElement  ::=  charNoDoubleQuoteOrNewline | escapeSeq
 ```
 
 A string literal is a sequence of characters in double quotes.
-The characters can be any Unicode character except the double quote
-delimiter or `\u000A` (LF) or `\u000D` (CR);
-or any Unicode character represented by an [escape sequence](#escape-sequences).
+The characters can be any Unicode character except the double quote delimiter or `\u000A` (LF) or `\u000D` (CR); or any Unicode character represented by an [escape sequence](#escape-sequences).
 
 If the string literal contains a double quote character, it must be escaped using
 `"\""`.
@@ -455,13 +387,10 @@ stringLiteral   ::=  ‘"""’ multiLineChars ‘"""’
 multiLineChars  ::=  {[‘"’] [‘"’] charNoDoubleQuote} {‘"’}
 ```
 
-A multi-line string literal is a sequence of characters enclosed in
-triple quotes `""" ... """`. The sequence of characters is
-arbitrary, except that it may contain three or more consecutive quote characters
-only at the very end. Characters
-must not necessarily be printable; newlines or other
-control characters are also permitted. [Escape sequences](#escape-sequences) are
-not processed, except for Unicode escapes (this is deprecated since 2.13.2).
+A multi-line string literal is a sequence of characters enclosed in triple quotes `""" ... """`.
+The sequence of characters is arbitrary, except that it may contain three or more consecutive quote characters only at the very end.
+Characters must not necessarily be printable; newlines or other control characters are also permitted.
+[Escape sequences](#escape-sequences) are not processed, except for Unicode escapes (this is deprecated since 2.13.2).
 
 > ```scala
 >   """the present string
@@ -477,8 +406,7 @@ not processed, except for Unicode escapes (this is deprecated since 2.13.2).
 >      lines.
 > ```
 >
-> The Scala library contains a utility method `stripMargin`
-> which can be used to strip leading whitespace from multi-line strings.
+> The Scala library contains a utility method `stripMargin` which can be used to strip leading whitespace from multi-line strings.
 > The expression
 >
 > ```scala
@@ -513,35 +441,28 @@ alphaid                ::= upper idrest
 
 ```
 
-An interpolated string consists of an identifier starting with a letter immediately
-followed by a string literal. There may be no whitespace characters or comments 
-between the leading identifier and the opening quote `"` of the string.
-The string literal in an interpolated string can be standard (single quote)
-or multi-line (triple quote).
+An interpolated string consists of an identifier starting with a letter immediately followed by a string literal.
+There may be no whitespace characters or comments between the leading identifier and the opening quote `"` of the string.
+The string literal in an interpolated string can be standard (single quote) or multi-line (triple quote).
 
-Inside an interpolated string none of the usual escape characters are interpreted
-no matter whether the string literal is normal (enclosed in single quotes) or
-multi-line (enclosed in triple quotes). Note that the sequence `\"` does not
-close a normal string literal (enclosed in single quotes).
+Inside an interpolated string none of the usual escape characters are interpreted no matter whether the string literal is normal (enclosed in single quotes) or multi-line (enclosed in triple quotes).
+Note that the sequence `\"` does not close a normal string literal (enclosed in single quotes).
 
 There are three forms of dollar sign escape.
 The most general form encloses an expression in `${` and `}`, i.e. `${expr}`. 
-The expression enclosed in the braces that follow the leading `$` character is of 
-syntactical category BlockExpr. Hence, it can contain multiple statements, 
-and newlines are significant. Single ‘$’-signs are not permitted in isolation 
-in an interpolated string. A single ‘$’-sign can still be obtained by doubling the ‘$’
-character: ‘$$’. A single ‘"’-sign can be obtained by the sequence ‘\$"’.
-
-The simpler form consists of a ‘$’-sign followed by an identifier starting with 
-a letter and followed only by letters, digits, and underscore characters, e.g., `$id`.
-The simpler form is expanded by putting braces around the identifier,
-e.g., `$id` is equivalent to `${id}`. In the following, unless we explicitly state otherwise,
-we assume that this expansion has already been performed.
-
-The expanded expression is type checked normally. Usually, `StringContext` will resolve to 
-the default implementation in the scala package, 
-but it could also be user-defined. Note that new interpolators can also be added through 
-implicit conversion of the built-in `scala.StringContext`.
+The expression enclosed in the braces that follow the leading `$` character is of syntactical category BlockExpr.
+Hence, it can contain multiple statements, and newlines are significant.
+Single ‘$’-signs are not permitted in isolation in an interpolated string.
+A single ‘$’-sign can still be obtained by doubling the ‘$’ character: ‘$$’.
+A single ‘"’-sign can be obtained by the sequence ‘\$"’.
+
+The simpler form consists of a ‘$’-sign followed by an identifier starting with a letter and followed only by letters, digits, and underscore characters, e.g., `$id`.
+The simpler form is expanded by putting braces around the identifier, e.g., `$id` is equivalent to `${id}`.
+In the following, unless we explicitly state otherwise, we assume that this expansion has already been performed.
+
+The expanded expression is type checked normally.
+Usually, `StringContext` will resolve to  the default implementation in the scala package,  but it could also be user-defined.
+Note that new interpolators can also be added through implicit conversion of the built-in `scala.StringContext`.
 
 One could write an extension
 ```scala
@@ -565,11 +486,9 @@ The following character escape sequences are recognized in character and string
 | `‘\‘ ‘'‘`     | `\u0027` | single quote    |  `'`   |
 | `‘\‘ ‘\‘`     | `\u005c` | backslash       |  `\`   |
 
-In addition, Unicode escape sequences of the form `\uxxxx`, where each `x` is a hex digit are
-recognized in character and string literals.
+In addition, Unicode escape sequences of the form `\uxxxx`, where each `x` is a hex digit are recognized in character and string literals.
 
-It is a compile time error if a backslash character in a character or
-string literal does not start a valid escape sequence.
+It is a compile time error if a backslash character in a character or string literal does not start a valid escape sequence.
 
 ### Symbol literals
 
@@ -579,30 +498,23 @@ symbolLiteral  ::=  ‘'’ plainid
 
 A symbol literal `'x` is deprecated shorthand for the expression `scala.Symbol("x")`.
 
-The `apply` method of `Symbol`'s companion object
-caches weak references to `Symbol`s, thus ensuring that
-identical symbol literals are equivalent with respect to reference
-equality.
+The `apply` method of `Symbol`'s companion object caches weak references to `Symbol`s, thus ensuring that identical symbol literals are equivalent with respect to reference equality.
 
 ## Whitespace and Comments
 
-Tokens may be separated by whitespace characters
-and/or comments. Comments come in two forms:
+Tokens may be separated by whitespace characters and/or comments.
+Comments come in two forms:
 
-A single-line comment is a sequence of characters which starts with
-`//` and extends to the end of the line.
+A single-line comment is a sequence of characters which starts with `//` and extends to the end of the line.
 
-A multi-line comment is a sequence of characters between
-`/*` and `*/`. Multi-line comments may be nested,
-but are required to be properly nested.  Therefore, a comment like
-`/* /* */` will be rejected as having an unterminated
-comment.
+A multi-line comment is a sequence of characters between `/*` and `*/`.
+Multi-line comments may be nested, but are required to be properly nested.
+Therefore, a comment like `/* /* */` will be rejected as having an unterminated comment.
 
 ## Trailing Commas in Multi-line Expressions
 
-If a comma (`,`) is followed immediately, ignoring whitespace, by a newline and
-a closing parenthesis (`)`), bracket (`]`), or brace (`}`), then the comma is
-treated as a "trailing comma" and is ignored. For example:
+If a comma (`,`) is followed immediately, ignoring whitespace, by a newline and a closing parenthesis (`)`), bracket (`]`), or brace (`}`), then the comma is treated as a "trailing comma" and is ignored.
+For example:
 
 ```scala
 foo(
@@ -614,11 +526,8 @@ foo(
 
 ## XML mode
 
-In order to allow literal inclusion of XML fragments, lexical analysis
-switches from Scala mode to XML mode when encountering an opening
-angle bracket ‘<’ in the following circumstance: The ‘<’ must be
-preceded either by whitespace, an opening parenthesis or an opening
-brace and immediately followed by a character starting an XML name.
+In order to allow literal inclusion of XML fragments, lexical analysis switches from Scala mode to XML mode when encountering an opening angle bracket ‘<’ in the following circumstance:
+The ‘<’ must be preceded either by whitespace, an opening parenthesis or an opening brace and immediately followed by a character starting an XML name.
 
 ```ebnf
  ( whitespace | ‘(’ | ‘{’ ) ‘<’ (XNameStart | ‘!’ | ‘?’)
@@ -628,20 +537,13 @@ brace and immediately followed by a character starting an XML name.
 
 The scanner switches from XML mode to Scala mode if either
 
-- the XML expression or the XML pattern started by the initial ‘<’ has been
-  successfully parsed, or if
-- the parser encounters an embedded Scala expression or pattern and
-  forces the Scanner
-  back to normal mode, until the Scala expression or pattern is
-  successfully parsed. In this case, since code and XML fragments can be
-  nested, the parser has to maintain a stack that reflects the nesting
-  of XML and Scala expressions adequately.
+- the XML expression or the XML pattern started by the initial ‘<’ has been successfully parsed, or if
+- the parser encounters an embedded Scala expression or pattern and forces the Scanner back to normal mode, until the Scala expression or pattern is successfully parsed.
+In this case, since code and XML fragments can be nested, the parser has to maintain a stack that reflects the nesting of XML and Scala expressions adequately.
 
-Note that no Scala tokens are constructed in XML mode, and that comments are interpreted
-as text.
+Note that no Scala tokens are constructed in XML mode, and that comments are interpreted as text.
 
-> The following value definition uses an XML literal with two embedded
-> Scala expressions:
+> The following value definition uses an XML literal with two embedded Scala expressions:
 >
 > ```scala
 > val b = <book>
diff --git a/docs/_spec/02-identifiers-names-and-scopes.md b/docs/_spec/02-identifiers-names-and-scopes.md
index b8bde8cfd1a9..2b34ae8844cf 100644
--- a/docs/_spec/02-identifiers-names-and-scopes.md
+++ b/docs/_spec/02-identifiers-names-and-scopes.md
@@ -6,8 +6,8 @@ chapter: 2
 
 # Identifiers, Names and Scopes
 
-Names in Scala identify types, values, methods, and classes which are
-collectively called _entities_. Names are introduced by local
+Names in Scala identify types, values, methods, and classes which are collectively called _entities_.
+Names are introduced by local
 [definitions and declarations](04-basic-declarations-and-definitions.html#basic-declarations-and-definitions),
 [inheritance](05-classes-and-objects.html#class-members),
 [import clauses](04-basic-declarations-and-definitions.html#import-clauses), or
@@ -16,29 +16,22 @@ which are collectively called _bindings_.
 
 Bindings of different kinds have precedence defined on them:
 
-1. Definitions and declarations that are local, inherited, or made
-   available by a package clause and also defined in the same compilation unit
-   as the reference to them, have the highest precedence.
+1. Definitions and declarations that are local, inherited, or made available by a package clause and also defined in the same compilation unit as the reference to them, have the highest precedence.
 1. Explicit imports have the next highest precedence.
 1. Wildcard imports have the next highest precedence.
-1. Definitions made available by a package clause, but not also defined in the
-   same compilation unit as the reference to them, as well as imports which
-   are supplied by the compiler but not explicitly written in source code,
-   have the lowest precedence.
+1. Definitions made available by a package clause, but not also defined in the same compilation unit as the reference to them, as well as imports which are supplied by the compiler but not explicitly written in source code, have the lowest precedence.
 
-There are two different name spaces, one for [types](03-types.html#types)
-and one for [terms](06-expressions.html#expressions). The same name may designate a
-type and a term, depending on the context where the name is used.
+There are two different name spaces, one for [types](03-types.html#types) and one for [terms](06-expressions.html#expressions).
+The same name may designate a type and a term, depending on the context where the name is used.
 
 A binding has a _scope_ in which the entity defined by a single
-name can be accessed using a simple name. Scopes are nested.  A binding
-in some inner scope _shadows_ bindings of lower precedence in the
-same scope as well as bindings of the same or lower precedence in outer
-scopes.
+name can be accessed using a simple name.
+Scopes are nested.
+A binding in some inner scope _shadows_ bindings of lower precedence in the same scope as well as bindings of the same or lower precedence in outer scopes.
 
-Note that shadowing is only a partial order. In the following example,
-neither binding of `x` shadows the other. Consequently, the
-reference to `x` in the last line of the block is ambiguous.
+Note that shadowing is only a partial order.
+In the following example, neither binding of `x` shadows the other.
+Consequently, the reference to `x` in the last line of the block is ambiguous.
 
 ```scala
 val x = 1
@@ -48,32 +41,24 @@ locally {
 }
 ```
 
-A reference to an unqualified (type- or term-) identifier ´x´ is bound
-by the unique binding, which
+A reference to an unqualified (type- or term-) identifier ´x´ is bound by the unique binding, which
 
 - defines an entity with name ´x´ in the same namespace as the identifier, and
-- shadows all other bindings that define entities with name ´x´ in that
-  namespace.
-
-It is an error if no such binding exists.  If ´x´ is bound by an
-import clause, then the simple name ´x´ is taken to be equivalent to
-the qualified name to which ´x´ is mapped by the import clause. If ´x´
-is bound by a definition or declaration, then ´x´ refers to the entity
-introduced by that binding. In that case, the type of ´x´ is the type
-of the referenced entity.
-
-A reference to a qualified (type- or term-) identifier ´e.x´ refers to
-the member of the type ´T´ of ´e´ which has the name ´x´ in the same
-namespace as the identifier. It is an error if ´T´ is not a [value type](03-types.html#value-types).
+- shadows all other bindings that define entities with name ´x´ in that namespace.
+
+It is an error if no such binding exists.
+If ´x´ is bound by an import clause, then the simple name ´x´ is taken to be equivalent to the qualified name to which ´x´ is mapped by the import clause.
+If ´x´ is bound by a definition or declaration, then ´x´ refers to the entity introduced by that binding.
+In that case, the type of ´x´ is the type of the referenced entity.
+
+A reference to a qualified (type- or term-) identifier ´e.x´ refers to the member of the type ´T´ of ´e´ which has the name ´x´ in the same namespace as the identifier.
+It is an error if ´T´ is not a [value type](03-types.html#value-types).
 The type of ´e.x´ is the member type of the referenced entity in ´T´.
 
 Binding precedence implies that the way source is bundled in files affects name resolution.
-In particular, imported names have higher precedence than names, defined in other files,
-that might otherwise be visible because they are defined in
-either the current package or an enclosing package.
+In particular, imported names have higher precedence than names, defined in other files, that might otherwise be visible because they are defined in either the current package or an enclosing package.
 
-Note that a package definition is taken as lowest precedence, since packages
-are open and can be defined across arbitrary compilation units.
+Note that a package definition is taken as lowest precedence, since packages are open and can be defined across arbitrary compilation units.
 
 ```scala
 package util {
@@ -85,8 +70,8 @@ package util {
 }
 ```
 
-The compiler supplies imports in a preamble to every source file. This preamble
-conceptually has the following form, where braces indicate nested scopes:
+The compiler supplies imports in a preamble to every source file.
+This preamble conceptually has the following form, where braces indicate nested scopes:
 
 ```scala
 import java.lang._
@@ -99,16 +84,12 @@ import java.lang._
 }
 ```
 
-These imports are taken as lowest precedence, so that they are always shadowed
-by user code, which may contain competing imports and definitions.
-They also increase the nesting depth as shown, so that later imports
-shadow earlier ones.
+These imports are taken as lowest precedence, so that they are always shadowed by user code, which may contain competing imports and definitions.
+They also increase the nesting depth as shown, so that later imports shadow earlier ones.
 
-As a convenience, multiple bindings of a type identifier to the same
-underlying type is permitted. This is possible when import clauses introduce
-a binding of a member type alias with the same binding precedence, typically
-through wildcard imports. This allows redundant type aliases to be imported
-without introducing an ambiguity.
+As a convenience, multiple bindings of a type identifier to the same underlying type is permitted.
+This is possible when import clauses introduce a binding of a member type alias with the same binding precedence, typically through wildcard imports.
+This allows redundant type aliases to be imported without introducing an ambiguity.
 
 ```scala
 object X { type T = annotation.tailrec }
@@ -119,8 +100,7 @@ object Z {
 }
 ```
 
-Similarly, imported aliases of names introduced by package statements are
-allowed, even though the names are strictly ambiguous:
+Similarly, imported aliases of names introduced by package statements are allowed, even though the names are strictly ambiguous:
 
 ```scala
 // c.scala
@@ -132,16 +112,12 @@ package p { class X extends C }
 package q { class Y extends C }
 ```
 
-The reference to `C` in the definition of `X` is strictly ambiguous
-because `C` is available by virtue of the package clause in
-a different file, and can't shadow the imported name. But because
-the references are the same, the definition is taken as though it
-did shadow the import.
+The reference to `C` in the definition of `X` is strictly ambiguous because `C` is available by virtue of the package clause in a different file, and can't shadow the imported name.
+But because the references are the same, the definition is taken as though it did shadow the import.
 
 ###### Example
 
-Assume the following two definitions of objects named `X` in packages `p` and `q`
-in separate compilation units.
+Assume the following two definitions of objects named `X` in packages `p` and `q` in separate compilation units.
 
 ```scala
 package p {
@@ -153,8 +129,7 @@ package q {
 }
 ```
 
-The following program illustrates different kinds of bindings and
-precedences between them.
+The following program illustrates different kinds of bindings and precedences between them.
 
 ```scala
 package p {                   // `X' bound by package clause
diff --git a/docs/_spec/03-types.md b/docs/_spec/03-types.md
index 205af416b9c5..664ddea49713 100644
--- a/docs/_spec/03-types.md
+++ b/docs/_spec/03-types.md
@@ -29,40 +29,29 @@ chapter: 3
   Types             ::=  Type {‘,’ Type}
 ```
 
-We distinguish between proper types and type constructors, which
-take type parameters and yield types. A subset of proper types
-called _value types_ represents sets of (first-class) values.
+We distinguish between proper types and type constructors, which take type parameters and yield types.
+A subset of proper types called _value types_ represents sets of (first-class) values.
 Value types are either _concrete_ or _abstract_.
 
-Every concrete value type can be represented as a _class type_, i.e. a
-[type designator](#type-designators) that refers to a
-[class or a trait](05-classes-and-objects.html#class-definitions) [^1], or as a
-[compound type](#compound-types) representing an
-intersection of types, possibly with a [refinement](#compound-types)
-that further constrains the types of its members.
+Every concrete value type can be represented as a _class type_, i.e. a [type designator](#type-designators) that refers to a [class or a trait](05-classes-and-objects.html#class-definitions) [^1], or as a [compound type](#compound-types) representing an intersection of types, possibly with a [refinement](#compound-types) that further constrains the types of its members.
+
 <!--
 A shorthand exists for denoting [function types](#function-types)
 -->
-Abstract value types are introduced by [type parameters](04-basic-declarations-and-definitions.html#type-parameters)
-and [abstract type bindings](04-basic-declarations-and-definitions.html#type-declarations-and-type-aliases).
+Abstract value types are introduced by [type parameters](04-basic-declarations-and-definitions.html#type-parameters) and [abstract type bindings](04-basic-declarations-and-definitions.html#type-declarations-and-type-aliases).
 Parentheses in types can be used for grouping.
 
 [^1]: We assume that objects and packages also implicitly
       define a class (of the same name as the object or package, but
       inaccessible to user programs).
 
-Non-value types capture properties of identifiers that
-[are not values](#non-value-types). For example, a
-[type constructor](#type-constructors) does not directly specify a type of
-values. However, when a type constructor is applied to the correct type
-arguments, it yields a proper type, which may be a value type.
+Non-value types capture properties of identifiers that [are not values](#non-value-types).
+For example, a [type constructor](#type-constructors) does not directly specify a type of values.
+However, when a type constructor is applied to the correct type arguments, it yields a proper type, which may be a value type.
 
-Non-value types are expressed indirectly in Scala. E.g., a method type is
-described by writing down a method signature, which in itself is not a real
-type, although it  gives rise to a corresponding [method type](#method-types).
-Type constructors are another example, as one can write
-`type Swap[m[_, _], a,b] = m[b, a]`, but there is no syntax to write
-the corresponding anonymous type function directly.
+Non-value types are expressed indirectly in Scala. 
+E.g., a method type is described by writing down a method signature, which in itself is not a real type, although it  gives rise to a corresponding [method type](#method-types).
+Type constructors are another example, as one can write `type Swap[m[_, _], a,b] = m[b, a]`, but there is no syntax to write the corresponding anonymous type function directly.
 
 ## Paths
 
@@ -75,30 +64,24 @@ StableId        ::=  id
 ClassQualifier  ::= ‘[’ id ‘]’
 ```
 
-Paths are not types themselves, but they can be a part of named types
-and in that function form a central role in Scala's type system.
+Paths are not types themselves, but they can be a part of named types and in that function form a central role in Scala's type system.
 
 A path is one of the following.
 
 - The empty path ε (which cannot be written explicitly in user programs).
 - ´C.´`this`, where ´C´ references a class.
-  The path `this` is taken as a shorthand for ´C.´`this` where
-  ´C´ is the name of the class directly enclosing the reference.
+  The path `this` is taken as a shorthand for ´C.´`this` where ´C´ is the name of the class directly enclosing the reference.
 - ´p.x´ where ´p´ is a path and ´x´ is a stable member of ´p´.
-  _Stable members_ are packages or members introduced by object definitions or
-  by value definitions of [non-volatile types](#volatile-types).
+  _Stable members_ are packages or members introduced by object definitions or by value definitions of [non-volatile types](#volatile-types).
 - ´C.´`super`´.x´ or ´C.´`super`´[M].x´
-  where ´C´ references a class and ´x´ references a
-  stable member of the super class or designated parent class ´M´ of ´C´.
-  The prefix `super` is taken as a shorthand for ´C.´`super` where
-  ´C´ is the name of the class directly enclosing the reference.
+  where ´C´ references a class and ´x´ references a stable member of the super class or designated parent class ´M´ of ´C´.
+  The prefix `super` is taken as a shorthand for ´C.´`super` where ´C´ is the name of the class directly enclosing the reference.
 
 A _stable identifier_ is a path which ends in an identifier.
 
 ## Value Types
 
-Every value in Scala has a type which is of one of the following
-forms.
+Every value in Scala has a type which is of one of the following forms.
 
 ### Singleton Types
 
@@ -106,12 +89,9 @@ forms.
 SimpleType  ::=  Path ‘.’ ‘type’
 ```
 
-A _singleton type_ is of the form ´p.´`type`. Where ´p´ is a path pointing to a
-value which [conforms](06-expressions.html#expression-typing) to
-`scala.AnyRef`, the type denotes the set of values consisting of `null` and the
-value denoted by ´p´ (i.e., the value ´v´ for which `v eq p`). Where the path
-does not conform to `scala.AnyRef` the type denotes the set consisting of only
-the value denoted by ´p´.
+A _singleton type_ is of the form ´p.´`type`.
+Where ´p´ is a path pointing to a value which [conforms](06-expressions.html#expression-typing) to `scala.AnyRef`, the type denotes the set of values consisting of `null` and the value denoted by ´p´ (i.e., the value ´v´ for which `v eq p`).
+Where the path does not conform to `scala.AnyRef` the type denotes the set consisting of only the value denoted by ´p´.
 
 <!-- a pattern match/type test against a singleton type `p.type` desugars to `_ eq p` -->
 
@@ -121,21 +101,17 @@ the value denoted by ´p´.
 SimpleType  ::=  Literal
 ```
 
-A literal type `lit` is a special kind of singleton type which denotes the
-single literal value `lit`.  Thus, the type ascription `1: 1` gives the most
-precise type to the literal value `1`:  the literal type `1`.
+A literal type `lit` is a special kind of singleton type which denotes the single literal value `lit`.
+Thus, the type ascription `1: 1` gives the most precise type to the literal value `1`:  the literal type `1`.
 
 At run time, an expression `e` is considered to have literal type `lit` if `e == lit`.
-Concretely, the result of `e.isInstanceOf[lit]` and `e match { case _ : lit => }` is
-determined by evaluating `e == lit`.
+Concretely, the result of `e.isInstanceOf[lit]` and `e match { case _ : lit => }` is determined by evaluating `e == lit`.
 
-Literal types are available for all types for which there is dedicated syntax
-except `Unit`. This includes the numeric types (other than `Byte` and `Short`
-which don't currently have syntax), `Boolean`, `Char` and `String`.
+Literal types are available for all types for which there is dedicated syntax except `Unit`.
+This includes the numeric types (other than `Byte` and `Short` which don't currently have syntax), `Boolean`, `Char` and `String`.
 
 ### Stable Types
-A _stable type_ is a singleton type, a literal type,
-or a type that is declared to be a subtype of trait `scala.Singleton`.
+A _stable type_ is a singleton type, a literal type, or a type that is declared to be a subtype of trait `scala.Singleton`.
 
 ### Type Projection
 
@@ -143,8 +119,7 @@ or a type that is declared to be a subtype of trait `scala.Singleton`.
 SimpleType  ::=  SimpleType ‘#’ id
 ```
 
-A _type projection_ ´T´#´x´ references the type member named
-´x´ of type ´T´.
+A _type projection_ ´T´#´x´ references the type member named ´x´ of type ´T´.
 
 <!--
 The following is no longer necessary:
@@ -158,24 +133,21 @@ If ´x´ references an abstract type member, then ´T´ must be a
 SimpleType  ::=  StableId
 ```
 
-A _type designator_ refers to a named value type. It can be simple or
-qualified. All such type designators are shorthands for type projections.
+A _type designator_ refers to a named value type.
+It can be simple or qualified. 
+All such type designators are shorthands for type projections.
 
-Specifically, the unqualified type name ´t´ where ´t´ is bound in some
-class, object, or package ´C´ is taken as a shorthand for
-´C.´`this.type#`´t´. If ´t´ is
-not bound in a class, object, or package, then ´t´ is taken as a
-shorthand for ε`.type#`´t´.
+Specifically, the unqualified type name ´t´ where ´t´ is bound in some class, object, or package ´C´ is taken as a shorthand for
+´C.´`this.type#`´t´.
+If ´t´ is not bound in a class, object, or package, then ´t´ is taken as a shorthand for ε`.type#`´t´.
 
-A qualified type designator has the form `p.t` where `p` is
-a [path](#paths) and _t_ is a type name. Such a type designator is
-equivalent to the type projection `p.type#t`.
+A qualified type designator has the form `p.t` where `p` is a [path](#paths) and _t_ is a type name.
+Such a type designator is equivalent to the type projection `p.type#t`.
 
 ###### Example
 
-Some type designators and their expansions are listed below. We assume
-a local type parameter ´t´, a value `maintable`
-with a type member `Node` and the standard class `scala.Int`,
+Some type designators and their expansions are listed below.
+We assume a local type parameter ´t´, a value `maintable` with a type member `Node` and the standard class `scala.Int`,
 
 | Designator          | Expansion                 |
 |-------------------- | --------------------------|
@@ -191,16 +163,11 @@ SimpleType      ::=  SimpleType TypeArgs
 TypeArgs        ::=  ‘[’ Types ‘]’
 ```
 
-A _parameterized type_ ´T[ T_1, ..., T_n ]´ consists of a type
-designator ´T´ and type parameters ´T_1, ..., T_n´ where
-´n \geq 1´. ´T´ must refer to a type constructor which takes ´n´ type
-parameters ´a_1, ..., a_n´.
+A _parameterized type_ ´T[ T_1, ..., T_n ]´ consists of a type designator ´T´ and type parameters ´T_1, ..., T_n´ where ´n \geq 1´.
+´T´ must refer to a type constructor which takes ´n´ type parameters ´a_1, ..., a_n´.
 
-Say the type parameters have lower bounds ´L_1, ..., L_n´ and
-upper bounds ´U_1, ..., U_n´.  The parameterized type is
-well-formed if each actual type parameter
-_conforms to its bounds_, i.e. ´\sigma L_i <: T_i <: \sigma U_i´ where ´\sigma´ is the
-substitution ´[ a_1 := T_1, ..., a_n := T_n ]´.
+Say the type parameters have lower bounds ´L_1, ..., L_n´ and upper bounds ´U_1, ..., U_n´.
+The parameterized type is well-formed if each actual type parameter _conforms to its bounds_, i.e. ´\sigma L_i <: T_i <: \sigma U_i´ where ´\sigma´ is the substitution ´[ a_1 := T_1, ..., a_n := T_n ]´.
 
 ###### Example Parameterized Types
 
@@ -229,8 +196,7 @@ G[S, String]
 
 ###### Example
 
-Given the [above type definitions](#example-parameterized-types),
-the following types are ill-formed:
+Given the [above type definitions](#example-parameterized-types), the following types are ill-formed:
 
 ```scala
 TreeMap[I]            // illegal: wrong number of parameters
@@ -251,15 +217,11 @@ G[S, Int]             // illegal: S constrains its parameter to
 SimpleType    ::=   ‘(’ Types ‘)’
 ```
 
-A _tuple type_ ´(T_1 , ... , T_n)´ is an alias for the
-class `scala.Tuple´n´[´T_1´, ... , ´T_n´]`, where ´n \geq 2´.
+A _tuple type_ ´(T_1 , ... , T_n)´ is an alias for the class `scala.Tuple´n´[´T_1´, ... , ´T_n´]`, where ´n \geq 2´.
 
-Tuple classes are case classes whose fields can be accessed using
-selectors `_1`, ..., `_n`. Their functionality is
-abstracted in a corresponding `Product` trait. The _n_-ary tuple
-class and product trait are defined at least as follows in the
-standard Scala library (they might also add other methods and
-implement other traits).
+Tuple classes are case classes whose fields can be accessed using selectors `_1`, ..., `_n`.
+Their functionality is abstracted in a corresponding `Product` trait.
+The _n_-ary tuple class and product trait are defined at least as follows in the standard Scala library (they might also add other methods and implement other traits).
 
 ```scala
 case class Tuple´_n´[+´T_1´, ..., +´T_n´](_1: ´T_1´, ..., _n: ´T_n´)
@@ -279,9 +241,7 @@ trait Product´_n´[+´T_1´, ..., +´T_n´] {
 AnnotType  ::=  SimpleType {Annotation}
 ```
 
-An _annotated type_ ´T´ ´a_1, ..., a_n´
-attaches [annotations](11-annotations.html#user-defined-annotations)
-´a_1, ..., a_n´ to the type ´T´.
+An _annotated type_ ´T´ ´a_1, ..., a_n´ attaches [annotations](11-annotations.html#user-defined-annotations) ´a_1, ..., a_n´ to the type ´T´.
 
 ###### Example
 
@@ -302,37 +262,24 @@ RefineStat      ::=  Dcl
                   |
 ```
 
-A _compound type_ ´T_1´ `with` ... `with` ´T_n \\{ R \\}´
-represents objects with members as given in the component types
-´T_1, ..., T_n´ and the refinement ´\\{ R \\}´. A refinement
-´\\{ R \\}´ contains declarations and type definitions.
-If a declaration or definition overrides a declaration or definition in
-one of the component types ´T_1, ..., T_n´, the usual rules for
-[overriding](05-classes-and-objects.html#overriding) apply; otherwise the declaration
-or definition is said to be “structural” [^2].
-
-[^2]: A reference to a structurally defined member (method call or access
-      to a value or variable) may generate binary code that is significantly
-      slower than an equivalent code to a non-structural member.
-
-Within a method declaration in a structural refinement, the type of
-any value parameter may only refer to type parameters or abstract
-types that are contained inside the refinement. That is, it must refer
-either to a type parameter of the method itself, or to a type
-definition within the refinement. This restriction does not apply to
-the method's result type.
-
-If no refinement is given, the empty refinement is implicitly added,
-i.e. ´T_1´ `with` ... `with` ´T_n´ is a shorthand for ´T_1´ `with` ... `with` ´T_n \\{\\}´.
-
-A compound type may also consist of just a refinement
-´\\{ R \\}´ with no preceding component types. Such a type is
-equivalent to `AnyRef` ´\\{ R \\}´.
+A _compound type_ ´T_1´ `with` ... `with` ´T_n \\{ R \\}´ represents objects with members as given in the component types ´T_1, ..., T_n´ and the refinement ´\\{ R \\}´. 
+A refinement ´\\{ R \\}´ contains declarations and type definitions.
+If a declaration or definition overrides a declaration or definition in one of the component types ´T_1, ..., T_n´, the usual rules for [overriding](05-classes-and-objects.html#overriding) apply; otherwise the declaration or definition is said to be “structural” [^2].
+
+[^2]: A reference to a structurally defined member (method call or access to a value or variable) may generate binary code that is significantly slower than an equivalent code to a non-structural member.
+
+Within a method declaration in a structural refinement, the type of any value parameter may only refer to type parameters or abstract types that are contained inside the refinement. 
+That is, it must refer either to a type parameter of the method itself, or to a type definition within the refinement. 
+This restriction does not apply to the method's result type.
+
+If no refinement is given, the empty refinement is implicitly added, i.e. ´T_1´ `with` ... `with` ´T_n´ is a shorthand for ´T_1´ `with` ... `with` ´T_n \\{\\}´.
+
+A compound type may also consist of just a refinement ´\\{ R \\}´ with no preceding component types.
+Such a type is equivalent to `AnyRef` ´\\{ R \\}´.
 
 ###### Example
 
-The following example shows how to declare and use a method which has
-a parameter type that contains a refinement with structural declarations.
+The following example shows how to declare and use a method which has a parameter type that contains a refinement with structural declarations.
 
 ```scala
 case class Bird (val name: String) extends Object {
@@ -356,10 +303,7 @@ takeoff(42, bird)
 takeoff(89, a380)
 ```
 
-Although `Bird` and `Plane` do not share any parent class other than
-`Object`, the parameter _r_ of method `takeoff` is defined using a
-refinement with structural declarations to accept any object that declares
-a value `callsign` and a `fly` method.
+Although `Bird` and `Plane` do not share any parent class other than `Object`, the parameter _r_ of method `takeoff` is defined using a refinement with structural declarations to accept any object that declares a value `callsign` and a `fly` method.
 
 ### Infix Types
 
@@ -367,26 +311,15 @@ a value `callsign` and a `fly` method.
 InfixType     ::=  CompoundType {id [nl] CompoundType}
 ```
 
-An _infix type_ ´T_1´ `op` ´T_2´ consists of an infix
-operator `op` which gets applied to two type operands ´T_1´ and
-´T_2´.  The type is equivalent to the type application
-`op`´[T_1, T_2]´.  The infix operator `op` may be an
-arbitrary identifier.
-
-All type infix operators have the same precedence; parentheses have to
-be used for grouping. The [associativity](06-expressions.html#prefix,-infix,-and-postfix-operations)
-of a type operator is determined as for term operators: type operators
-ending in a colon ‘:’ are right-associative; all other
-operators are left-associative.
-
-In a sequence of consecutive type infix operations
-´t_0 \, \mathit{op} \, t_1 \, \mathit{op_2} \, ... \, \mathit{op_n} \, t_n´,
-all operators ´\mathit{op}\_1, ..., \mathit{op}\_n´ must have the same
-associativity. If they are all left-associative, the sequence is
-interpreted as
-´(... (t_0 \mathit{op_1} t_1) \mathit{op_2} ...) \mathit{op_n} t_n´,
-otherwise it is interpreted as
-´t_0 \mathit{op_1} (t_1 \mathit{op_2} ( ... \mathit{op_n} t_n) ...)´.
+An _infix type_ ´T_1´ `op` ´T_2´ consists of an infix operator `op` which gets applied to two type operands ´T_1´ and ´T_2´.
+The type is equivalent to the type application `op`´[T_1, T_2]´.
+The infix operator `op` may be an arbitrary identifier.
+
+All type infix operators have the same precedence; parentheses have to be used for grouping.
+The [associativity](06-expressions.html#prefix,-infix,-and-postfix-operations) of a type operator is determined as for term operators: type operators ending in a colon ‘:’ are right-associative; all other operators are left-associative.
+
+In a sequence of consecutive type infix operations ´t_0 \, \mathit{op} \, t_1 \, \mathit{op_2} \, ... \, \mathit{op_n} \, t_n´, all operators ´\mathit{op}\_1, ..., \mathit{op}\_n´ must have the same associativity.
+If they are all left-associative, the sequence is interpreted as ´(... (t_0 \mathit{op_1} t_1) \mathit{op_2} ...) \mathit{op_n} t_n´, otherwise it is interpreted as ´t_0 \mathit{op_1} (t_1 \mathit{op_2} ( ... \mathit{op_n} t_n) ...)´.
 
 ### Function Types
 
@@ -396,22 +329,15 @@ FunctionArgs      ::=  InfixType
                     |  ‘(’ [ ParamType {‘,’ ParamType } ] ‘)’
 ```
 
-The type ´(T_1, ..., T_n) \Rightarrow U´ represents the set of function
-values that take arguments of types ´T_1, ..., Tn´ and yield
-results of type ´U´.  In the case of exactly one argument type
-´T \Rightarrow U´ is a shorthand for ´(T) \Rightarrow U´.
-An argument type of the form ´\Rightarrow T´
-represents a [call-by-name parameter](04-basic-declarations-and-definitions.html#by-name-parameters) of type ´T´.
+The type ´(T_1, ..., T_n) \Rightarrow U´ represents the set of function values that take arguments of types ´T_1, ..., Tn´ and yield results of type ´U´.
+In the case of exactly one argument type ´T \Rightarrow U´ is a shorthand for ´(T) \Rightarrow U´.
+An argument type of the form ´\Rightarrow T´ represents a [call-by-name parameter](04-basic-declarations-and-definitions.html#by-name-parameters) of type ´T´.
 
-Function types associate to the right, e.g.
-´S \Rightarrow T \Rightarrow U´ is the same as
-´S \Rightarrow (T \Rightarrow U)´.
+Function types associate to the right, e.g. ´S \Rightarrow T \Rightarrow U´ is the same as ´S \Rightarrow (T \Rightarrow U)´.
 
-Function types are shorthands for class types that define `apply`
-functions.  Specifically, the ´n´-ary function type
-´(T_1 , \ldots , T_n) \Rightarrow U´ is a shorthand for the class type
-`Function´_n´[´T_1´ , … , ´T_n´, ´U´]`. Such class
-types are defined in the Scala library for ´n´ between 0 and 22 as follows.
+Function types are shorthands for class types that define `apply` functions.
+Specifically, the ´n´-ary function type ´(T_1 , \ldots , T_n) \Rightarrow U´ is a shorthand for the class type `Function´_n´[´T_1´ , … , ´T_n´, ´U´]`.
+Such class types are defined in the Scala library for ´n´ between 0 and 22 as follows.
 
 ```scala
 package scala
@@ -421,8 +347,7 @@ trait Function´_n´[-´T_1´, ..., -´T_n´, +´U´] {
 }
 ```
 
-Hence, function types are [covariant](04-basic-declarations-and-definitions.html#variance-annotations) in their
-result type and contravariant in their argument types.
+Hence, function types are [covariant](04-basic-declarations-and-definitions.html#variance-annotations) in their result type and contravariant in their argument types.
 
 ### Existential Types
 
@@ -434,63 +359,32 @@ ExistentialDcl     ::= ‘type’ TypeDcl
                     |  ‘val’ ValDcl
 ```
 
-An _existential type_ has the form `´T´ forSome { ´Q´ }`
-where ´Q´ is a sequence of
-[type declarations](04-basic-declarations-and-definitions.html#type-declarations-and-type-aliases).
-
-Let
-´t_1[\mathit{tps}\_1] >: L_1 <: U_1 , \ldots , t_n[\mathit{tps}\_n] >: L_n <: U_n´
-be the types declared in ´Q´ (any of the
-type parameter sections `[ ´\mathit{tps}_i´ ]` might be missing).
-The scope of each type ´t_i´ includes the type ´T´ and the existential clause
-´Q´.
-The type variables ´t_i´ are said to be _bound_ in the type
-`´T´ forSome { ´Q´ }`.
-Type variables which occur in a type ´T´ but which are not bound in ´T´ are said
-to be _free_ in ´T´.
-
-A _type instance_ of `´T´ forSome { ´Q´ }`
-is a type ´\sigma T´ where ´\sigma´ is a substitution over ´t_1 , \ldots , t_n´
-such that, for each ´i´, ´\sigma L_i <: \sigma t_i <: \sigma U_i´.
-The set of values denoted by the existential type `´T´ forSome {´\,Q\,´}`
-is the union of the set of values of all its type instances.
-
-A _skolemization_ of `´T´ forSome { ´Q´ }` is
-a type instance ´\sigma T´, where ´\sigma´ is the substitution
-´[t_1'/t_1 , \ldots , t_n'/t_n]´ and each ´t_i'´ is a fresh abstract type
-with lower bound ´\sigma L_i´ and upper bound ´\sigma U_i´.
+An _existential type_ has the form `´T´ forSome { ´Q´ }` where ´Q´ is a sequence of [type declarations](04-basic-declarations-and-definitions.html#type-declarations-and-type-aliases).
+
+Let ´t_1[\mathit{tps}\_1] >: L_1 <: U_1 , \ldots , t_n[\mathit{tps}\_n] >: L_n <: U_n´ be the types declared in ´Q´ (any of the type parameter sections `[ ´\mathit{tps}_i´ ]` might be missing).
+The scope of each type ´t_i´ includes the type ´T´ and the existential clause ´Q´.
+The type variables ´t_i´ are said to be _bound_ in the type `´T´ forSome { ´Q´ }`.
+Type variables which occur in a type ´T´ but which are not bound in ´T´ are said to be _free_ in ´T´.
+
+A _type instance_ of `´T´ forSome { ´Q´ }` is a type ´\sigma T´ where ´\sigma´ is a substitution over ´t_1 , \ldots , t_n´ such that, for each ´i´, ´\sigma L_i <: \sigma t_i <: \sigma U_i´.
+The set of values denoted by the existential type `´T´ forSome {´\,Q\,´}` is the union of the set of values of all its type instances.
+
+A _skolemization_ of `´T´ forSome { ´Q´ }` is a type instance ´\sigma T´, where ´\sigma´ is the substitution ´[t_1'/t_1 , \ldots , t_n'/t_n]´ and each ´t_i'´ is a fresh abstract type with lower bound ´\sigma L_i´ and upper bound ´\sigma U_i´.
 
 #### Simplification Rules
 
 Existential types obey the following four equivalences:
 
-1. Multiple for-clauses in an existential type can be merged. E.g.,
-`´T´ forSome { ´Q´ } forSome { ´Q'´ }`
-is equivalent to
-`´T´ forSome { ´Q´ ; ´Q'´}`.
-1. Unused quantifications can be dropped. E.g.,
-`´T´ forSome { ´Q´ ; ´Q'´}`
-where none of the types defined in ´Q'´ are referred to by ´T´ or ´Q´,
-is equivalent to
-`´T´ forSome {´ Q ´}`.
-1. An empty quantification can be dropped. E.g.,
-`´T´ forSome { }` is equivalent to ´T´.
-1. An existential type `´T´ forSome { ´Q´ }` where ´Q´ contains
-a clause `type ´t[\mathit{tps}] >: L <: U´` is equivalent
-to the type `´T'´ forSome { ´Q´ }` where ´T'´ results from ´T´ by replacing
-every [covariant occurrence](04-basic-declarations-and-definitions.html#variance-annotations) of ´t´ in ´T´ by ´U´ and by
-replacing every contravariant occurrence of ´t´ in ´T´ by ´L´.
+1. Multiple for-clauses in an existential type can be merged. E.g., `´T´ forSome { ´Q´ } forSome { ´Q'´ }` is equivalent to `´T´ forSome { ´Q´ ; ´Q'´}`.
+1. Unused quantifications can be dropped. 
+E.g., `´T´ forSome { ´Q´ ; ´Q'´}` where none of the types defined in ´Q'´ are referred to by ´T´ or ´Q´, is equivalent to `´T´ forSome {´ Q ´}`.
+1. An empty quantification can be dropped. E.g., `´T´ forSome { }` is equivalent to ´T´.
+1. An existential type `´T´ forSome { ´Q´ }` where ´Q´ contains a clause `type ´t[\mathit{tps}] >: L <: U´` is equivalent to the type `´T'´ forSome { ´Q´ }` where ´T'´ results from ´T´ by replacing every [covariant occurrence](04-basic-declarations-and-definitions.html#variance-annotations) of ´t´ in ´T´ by ´U´ and by replacing every contravariant occurrence of ´t´ in ´T´ by ´L´.
 
 #### Existential Quantification over Values
 
-As a syntactic convenience, the bindings clause
-in an existential type may also contain
-value declarations `val ´x´: ´T´`.
-An existential type `´T´ forSome { ´Q´; val ´x´: ´S\,´;´\,Q'´ }`
-is treated as a shorthand for the type
-`´T'´ forSome { ´Q´; type ´t´ <: ´S´ with Singleton; ´Q'´ }`, where ´t´ is a
-fresh type name and ´T'´ results from ´T´ by replacing every occurrence of
-`´x´.type` with ´t´.
+As a syntactic convenience, the bindings clause in an existential type may also contain value declarations `val ´x´: ´T´`.
+An existential type `´T´ forSome { ´Q´; val ´x´: ´S\,´;´\,Q'´ }` is treated as a shorthand for the type `´T'´ forSome { ´Q´; type ´t´ <: ´S´ with Singleton; ´Q'´ }`, where ´t´ is a fresh type name and ´T'´ results from ´T´ by replacing every occurrence of `´x´.type` with ´t´.
 
 #### Placeholder Syntax for Existential Types
 
@@ -499,31 +393,23 @@ WildcardType   ::=  ‘_’ TypeBounds
 ```
 
 Scala supports a placeholder syntax for existential types.
-A _wildcard type_ is of the form `_´\;´>:´\,L\,´<:´\,U´`. Both bound
-clauses may be omitted. If a lower bound clause `>:´\,L´` is missing,
-`>:´\,´scala.Nothing`
-is assumed. If an upper bound clause `<:´\,U´` is missing,
-`<:´\,´scala.Any` is assumed. A wildcard type is a shorthand for an
-existentially quantified type variable, where the existential quantification is
-implicit.
+A _wildcard type_ is of the form `_´\;´>:´\,L\,´<:´\,U´`.
+Both bound clauses may be omitted.
+If a lower bound clause `>:´\,L´` is missing, `>:´\,´scala.Nothing` is assumed.
+If an upper bound clause `<:´\,U´` is missing, `<:´\,´scala.Any` is assumed.
+A wildcard type is a shorthand for an existentially quantified type variable, where the existential quantification is implicit.
 
 A wildcard type must appear as a type argument of a parameterized type.
-Let ´T = p.c[\mathit{targs},T,\mathit{targs}']´ be a parameterized type where
-´\mathit{targs}, \mathit{targs}'´ may be empty and
-´T´ is a wildcard type `_´\;´>:´\,L\,´<:´\,U´`. Then ´T´ is equivalent to the
-existential
-type
+Let ´T = p.c[\mathit{targs},T,\mathit{targs}']´ be a parameterized type where ´\mathit{targs}, \mathit{targs}'´ may be empty and ´T´ is a wildcard type `_´\ ´>:´\,L\,´<:´\,U´`.
+Then ´T´ is equivalent to the existential type
 
 ```scala
 ´p.c[\mathit{targs},t,\mathit{targs}']´ forSome { type ´t´ >: ´L´ <: ´U´ }
 ```
 
 where ´t´ is some fresh type variable.
-Wildcard types may also appear as parts of [infix types](#infix-types)
-, [function types](#function-types),
-or [tuple types](#tuple-types).
-Their expansion is then the expansion in the equivalent parameterized
-type.
+Wildcard types may also appear as parts of [infix types](#infix-types), [function types](#function-types), or [tuple types](#tuple-types).
+Their expansion is then the expansion in the equivalent parameterized type.
 
 ###### Example
 
@@ -577,35 +463,25 @@ is equivalent (by simplification rule 4 above) to
 List[java.lang.Number] forSome { type T <: java.lang.Number }
 ```
 
-which is in turn equivalent (by simplification rules 2 and 3 above) to
-`List[java.lang.Number]`.
+which is in turn equivalent (by simplification rules 2 and 3 above) to `List[java.lang.Number]`.
 
 ## Non-Value Types
 
-The types explained in the following do not denote sets of values, nor
-do they appear explicitly in programs. They are introduced in this
-report as the internal types of defined identifiers.
+The types explained in the following do not denote sets of values, nor do they appear explicitly in programs. 
+They are introduced in this report as the internal types of defined identifiers.
 
 ### Method Types
 
-A _method type_ is denoted internally as ´(\mathit{Ps})U´, where ´(\mathit{Ps})´
-is a sequence of parameter names and types ´(p_1:T_1, ..., p_n:T_n)´
-for some ´n \geq 0´ and ´U´ is a (value or method) type.  This type
-represents named methods that take arguments named ´p_1, ..., p_n´
-of types ´T_1, ..., T_n´
-and that return a result of type ´U´.
+A _method type_ is denoted internally as ´(\mathit{Ps})U´, where ´(\mathit{Ps})´ is a sequence of parameter names and types ´(p_1:T_1, ..., p_n:T_n)´ for some ´n \geq 0´ and ´U´ is a (value or method) type.
+This type represents named methods that take arguments named ´p_1, ..., p_n´ of types ´T_1, ..., T_n´ and that return a result of type ´U´.
 
-Method types associate to the right: ´(\mathit{Ps}\_1)(\mathit{Ps}\_2)U´ is
-treated as ´(\mathit{Ps}\_1)((\mathit{Ps}\_2)U)´.
+Method types associate to the right: ´(\mathit{Ps}\_1)(\mathit{Ps}\_2)U´ is treated as ´(\mathit{Ps}\_1)((\mathit{Ps}\_2)U)´.
 
-A special case are types of methods without any parameters. They are
-written here `=> T`. Parameterless methods name expressions
-that are re-evaluated each time the parameterless method name is
-referenced.
+A special case are types of methods without any parameters.
+They are written here `=> T`. Parameterless methods name expressions that are re-evaluated each time the parameterless method name is referenced.
 
-Method types do not exist as types of values. If a method name is used
-as a value, its type is [implicitly converted](06-expressions.html#implicit-conversions) to a
-corresponding function type.
+Method types do not exist as types of values.
+If a method name is used as a value, its type is [implicitly converted](06-expressions.html#implicit-conversions) to a corresponding function type.
 
 ###### Example
 
@@ -627,15 +503,8 @@ c: (Int) (String, String) String
 
 ### Polymorphic Method Types
 
-A polymorphic method type is denoted internally as `[´\mathit{tps}\,´]´T´` where
-`[´\mathit{tps}\,´]` is a type parameter section
-`[´a_1´ >: ´L_1´ <: ´U_1, ..., a_n´ >: ´L_n´ <: ´U_n´]`
-for some ´n \geq 0´ and ´T´ is a
-(value or method) type.  This type represents named methods that
-take type arguments `´S_1, ..., S_n´` which
-[conform](#parameterized-types) to the lower bounds
-`´L_1, ..., L_n´` and the upper bounds
-`´U_1, ..., U_n´` and that yield results of type ´T´.
+A polymorphic method type is denoted internally as `[´\mathit{tps}\,´]´T´` where `[´\mathit{tps}\,´]` is a type parameter section `[´a_1´ >: ´L_1´ <: ´U_1, ..., a_n´ >: ´L_n´ <: ´U_n´]` for some ´n \geq 0´ and ´T´ is a (value or method) type.
+This type represents named methods that take type arguments `´S_1, ..., S_n´` which [conform](#parameterized-types) to the lower bounds `´L_1, ..., L_n´` and the upper bounds `´U_1, ..., U_n´` and that yield results of type ´T´.
 
 ###### Example
 
@@ -656,11 +525,7 @@ union : [A >: Nothing <: Comparable[A]] (x: Set[A], xs: Set[A]) Set[A]
 ### Type Constructors
 
 A _type constructor_ is represented internally much like a polymorphic method type.
-`[´\pm´ ´a_1´ >: ´L_1´ <: ´U_1, ..., \pm a_n´ >: ´L_n´ <: ´U_n´] ´T´`
-represents a type that is expected by a
-[type constructor parameter](04-basic-declarations-and-definitions.html#type-parameters) or an
-[abstract type constructor binding](04-basic-declarations-and-definitions.html#type-declarations-and-type-aliases) with
-the corresponding type parameter clause.
+`[´\pm´ ´a_1´ >: ´L_1´ <: ´U_1, ..., \pm a_n´ >: ´L_n´ <: ´U_n´] ´T´` represents a type that is expected by a [type constructor parameter](04-basic-declarations-and-definitions.html#type-parameters) or an [abstract type constructor binding](04-basic-declarations-and-definitions.html#type-declarations-and-type-aliases) with the corresponding type parameter clause.
 
 ###### Example
 
@@ -672,9 +537,7 @@ trait Iterable[+X] {
 }
 ```
 
-Conceptually, the type constructor `Iterable` is a name for the
-anonymous type `[+X] Iterable[X]`, which may be passed to the
-`newType` type constructor parameter in `flatMap`.
+Conceptually, the type constructor `Iterable` is a name for the anonymous type `[+X] Iterable[X]`, which may be passed to the `newType` type constructor parameter in `flatMap`.
 
 <!-- ### Overloaded Types
 
@@ -722,83 +585,45 @@ These notions are defined mutually recursively as follows.
 
 1. The set of _base types_ of a type is a set of class types,
    given as follows.
-  - The base types of a class type ´C´ with parents ´T_1, ..., T_n´ are
-    ´C´ itself, as well as the base types of the compound type
-    `´T_1´ with ... with ´T_n´ { ´R´ }`.
+  - The base types of a class type ´C´ with parents ´T_1, ..., T_n´ are ´C´ itself, as well as the base types of the compound type `´T_1´ with ... with ´T_n´ { ´R´ }`.
   - The base types of an aliased type are the base types of its alias.
   - The base types of an abstract type are the base types of its upper bound.
-  - The base types of a parameterized type
-    `´C´[´T_1, ..., T_n´]` are the base types
-    of type ´C´, where every occurrence of a type parameter ´a_i´
-    of ´C´ has been replaced by the corresponding parameter type ´T_i´.
-  - The base types of a singleton type `´p´.type` are the base types of
-    the type of ´p´.
-  - The base types of a compound type
-    `´T_1´ with ... with ´T_n´ { ´R´ }`
-    are the _reduced union_ of the base
-    classes of all ´T_i´'s. This means:
-    Let the multi-set ´\mathscr{S}´ be the multi-set-union of the
-    base types of all ´T_i´'s.
-    If ´\mathscr{S}´ contains several type instances of the same class, say
-    `´S^i´#´C´[´T^i_1, ..., T^i_n´]` ´(i \in I)´, then
-    all those instances
-    are replaced by one of them which conforms to all
-    others. It is an error if no such instance exists. It follows that the
-    reduced union, if it exists,
-    produces a set of class types, where different types are instances of
-    different classes.
-  - The base types of a type selection `´S´#´T´` are
-    determined as follows. If ´T´ is an alias or abstract type, the
-    previous clauses apply. Otherwise, ´T´ must be a (possibly
-    parameterized) class type, which is defined in some class ´B´.  Then
-    the base types of `´S´#´T´` are the base types of ´T´
-    in ´B´ seen from the prefix type ´S´.
-  - The base types of an existential type `´T´ forSome { ´Q´ }` are
-    all types `´S´ forSome { ´Q´ }` where ´S´ is a base type of ´T´.
-
-1. The notion of a type ´T´ _in class ´C´ seen from some prefix type ´S´_
-   makes sense only if the prefix type ´S´
-   has a type instance of class ´C´ as a base type, say
-   `´S'´#´C´[´T_1, ..., T_n´]`. Then we define as follows.
-    - If `´S´ = ´\epsilon´.type`, then ´T´ in ´C´ seen from ´S´ is
-      ´T´ itself.
-    - Otherwise, if ´S´ is an existential type `´S'´ forSome { ´Q´ }`, and
-      ´T´ in ´C´ seen from ´S'´ is ´T'´,
-      then ´T´ in ´C´ seen from ´S´ is `´T'´ forSome {´\,Q\,´}`.
-    - Otherwise, if ´T´ is the ´i´'th type parameter of some class ´D´, then
-        - If ´S´ has a base type `´D´[´U_1, ..., U_n´]`, for some type
-          parameters `[´U_1, ..., U_n´]`, then ´T´ in ´C´ seen from ´S´
-          is ´U_i´.
-        - Otherwise, if ´C´ is defined in a class ´C'´, then
-          ´T´ in ´C´ seen from ´S´ is the same as ´T´ in ´C'´ seen from ´S'´.
-        - Otherwise, if ´C´ is not defined in another class, then
-          ´T´ in ´C´ seen from ´S´ is ´T´ itself.
-    - Otherwise, if ´T´ is the singleton type `´D´.this.type` for some class ´D´
-      then
-        - If ´D´ is a subclass of ´C´ and ´S´ has a type instance of class ´D´
-          among its base types, then ´T´ in ´C´ seen from ´S´ is ´S´.
-        - Otherwise, if ´C´ is defined in a class ´C'´, then
-          ´T´ in ´C´ seen from ´S´ is the same as ´T´ in ´C'´ seen from ´S'´.
-        - Otherwise, if ´C´ is not defined in another class, then
-          ´T´ in ´C´ seen from ´S´ is ´T´ itself.
-    - If ´T´ is some other type, then the described mapping is performed
-      to all its type components.
-
-    If ´T´ is a possibly parameterized class type, where ´T´'s class
-    is defined in some other class ´D´, and ´S´ is some prefix type,
-    then we use "´T´ seen from ´S´" as a shorthand for
-    "´T´ in ´D´ seen from ´S´".
+  - The base types of a parameterized type `´C´[´T_1, ..., T_n´]` are the base types of type ´C´, where every occurrence of a type parameter ´a_i´ of ´C´ has been replaced by the corresponding parameter type ´T_i´.
+  - The base types of a singleton type `´p´.type` are the base types of the type of ´p´.
+  - The base types of a compound type `´T_1´ with ... with ´T_n´ { ´R´ }` are the _reduced union_ of the base classes of all ´T_i´'s.
+  This means: Let the multi-set ´\mathscr{S}´ be the multi-set-union of the base types of all ´T_i´'s.
+  If ´\mathscr{S}´ contains several type instances of the same class, say `´S^i´#´C´[´T^i_1, ..., T^i_n´]` ´(i \in I)´, then all those instances are replaced by one of them which conforms to all others.
+  It is an error if no such instance exists.
+  It follows that the reduced union, if it exists, produces a set of class types, where different types are instances of different classes.
+  - The base types of a type selection `´S´#´T´` are determined as follows.
+  If ´T´ is an alias or abstract type, the previous clauses apply.
+  Otherwise, ´T´ must be a (possibly parameterized) class type, which is defined in some class ´B´.
+  Then the base types of `´S´#´T´` are the base types of ´T´ in ´B´ seen from the prefix type ´S´.
+  - The base types of an existential type `´T´ forSome { ´Q´ }` are all types `´S´ forSome { ´Q´ }` where ´S´ is a base type of ´T´.
+
+1. The notion of a type ´T´ _in class ´C´ seen from some prefix type ´S´_ makes sense only if the prefix type ´S´ has a type instance of class ´C´ as a base type, say `´S'´#´C´[´T_1, ..., T_n´]`.
+Then we define as follows.
+  - If `´S´ = ´\epsilon´.type`, then ´T´ in ´C´ seen from ´S´ is ´T´ itself.
+  - Otherwise, if ´S´ is an existential type `´S'´ forSome { ´Q´ }`, and ´T´ in ´C´ seen from ´S'´ is ´T'´, then ´T´ in ´C´ seen from ´S´ is `´T'´ forSome {´\,Q\,´}`.
+  - Otherwise, if ´T´ is the ´i´'th type parameter of some class ´D´, then
+    - If ´S´ has a base type `´D´[´U_1, ..., U_n´]`, for some type parameters `[´U_1, ..., U_n´]`, then ´T´ in ´C´ seen from ´S´ is ´U_i´.
+    - Otherwise, if ´C´ is defined in a class ´C'´, then ´T´ in ´C´ seen from ´S´ is the same as ´T´ in ´C'´ seen from ´S'´.
+    - Otherwise, if ´C´ is not defined in another class, then ´T´ in ´C´ seen from ´S´ is ´T´ itself.
+  - Otherwise, if ´T´ is the singleton type `´D´.this.type` for some class ´D´
+    then
+    - If ´D´ is a subclass of ´C´ and ´S´ has a type instance of class ´D´ among its base types, then ´T´ in ´C´ seen from ´S´ is ´S´.
+    - Otherwise, if ´C´ is defined in a class ´C'´, then ´T´ in ´C´ seen from ´S´ is the same as ´T´ in ´C'´ seen from ´S'´.
+    - Otherwise, if ´C´ is not defined in another class, then ´T´ in ´C´ seen from ´S´ is ´T´ itself.
+  - If ´T´ is some other type, then the described mapping is performed to all its type components.
+
+If ´T´ is a possibly parameterized class type, where ´T´'s class is defined in some other class ´D´, and ´S´ is some prefix type, then we use "´T´ seen from ´S´" as a shorthand for "´T´ in ´D´ seen from ´S´".
 
 1. The _member bindings_ of a type ´T´ are
-   1. all bindings ´d´ such that there exists a type instance of some class ´C´ among the base types of ´T´
-     and there exists a definition or declaration ´d'´ in ´C´
-     such that ´d´ results from ´d'´ by replacing every
-     type ´T'´ in ´d'´ by ´T'´ in ´C´ seen from ´T´, and
-   2. all bindings of the type's [refinement](#compound-types), if it has one.
+  1. all bindings ´d´ such that there exists a type instance of some class ´C´ among the base types of ´T´ and there exists a definition or declaration ´d'´ in ´C´ such that ´d´ results from ´d'´ by replacing every type ´T'´ in ´d'´ by ´T'´ in ´C´ seen from ´T´, and
+  2. all bindings of the type's [refinement](#compound-types), if it has one.
 
-   The _definition_ of a type projection `S#T` is the member
-   binding ´d_T´ of the type `T` in `S`. In that case, we also say
-   that `S#T` _is defined by_ ´d_T´.
+The _definition_ of a type projection `S#T` is the member binding ´d_T´ of the type `T` in `S`.
+In that case, we also say that `S#T` _is defined by_ ´d_T´.
 
 ## Relations between types
 
@@ -818,30 +643,16 @@ Equivalence ´(\equiv)´ between types is the smallest congruence [^congruence]
 - If ´t´ is defined by a type alias `type ´t´ = ´T´`, then ´t´ is equivalent to ´T´.
 - If a path ´p´ has a singleton type `´q´.type`, then `´p´.type ´\equiv q´.type`.
 - If ´O´ is defined by an object definition, and ´p´ is a path consisting only of package or object selectors and ending in ´O´, then `´O´.this.type ´\equiv p´.type`.
-- Two [compound types](#compound-types) are equivalent if the sequences
-  of their component are pairwise equivalent, and occur in the same order, and
-  their refinements are equivalent. Two refinements are equivalent if they
-  bind the same names and the modifiers, types and bounds of every
-  declared entity are equivalent in both refinements.
+- Two [compound types](#compound-types) are equivalent if the sequences of their component are pairwise equivalent, and occur in the same order, and their refinements are equivalent. Two refinements are equivalent if they bind the same names and the modifiers, types and bounds of every declared entity are equivalent in both refinements.
 - Two [method types](#method-types) are equivalent if:
-    - neither are implicit, or they both are [^implicit];
-    - they have equivalent result types;
-    - they have the same number of parameters; and
-    - corresponding parameters have equivalent types.
-      Note that the names of parameters do not matter for method type equivalence.
-- Two [polymorphic method types](#polymorphic-method-types) are equivalent if
-  they have the same number of type parameters, and, after renaming one set of
-  type parameters by another, the result types as well as lower and upper bounds
-  of corresponding type parameters are equivalent.
-- Two [existential types](#existential-types)
-  are equivalent if they have the same number of
-  quantifiers, and, after renaming one list of type quantifiers by
-  another, the quantified types as well as lower and upper bounds of
-  corresponding quantifiers are equivalent.
-- Two [type constructors](#type-constructors) are equivalent if they have the
-  same number of type parameters, and, after renaming one list of type
-  parameters by another, the result types as well as variances, lower and upper
-  bounds of corresponding type parameters are equivalent.
+  - neither are implicit, or they both are [^implicit];
+  - they have equivalent result types;
+  - they have the same number of parameters; and
+  - corresponding parameters have equivalent types.
+    Note that the names of parameters do not matter for method type equivalence.
+- Two [polymorphic method types](#polymorphic-method-types) are equivalent if they have the same number of type parameters, and, after renaming one set of type parameters by another, the result types as well as lower and upper bounds of corresponding type parameters are equivalent.
+- Two [existential types](#existential-types) are equivalent if they have the same number of quantifiers, and, after renaming one list of type quantifiers by another, the quantified types as well as lower and upper bounds of corresponding quantifiers are equivalent.
+- Two [type constructors](#type-constructors) are equivalent if they have the same number of type parameters, and, after renaming one list of type parameters by another, the result types as well as variances, lower and upper bounds of corresponding type parameters are equivalent.
 
 [^congruence]: A congruence is an equivalence relation which is closed under formation of contexts.
 [^implicit]: A method type is implicit if the parameter section that defines it starts with the `implicit` keyword.
@@ -850,86 +661,39 @@ Equivalence ´(\equiv)´ between types is the smallest congruence [^congruence]
 
 The conformance relation ´(<:)´ is the smallest transitive relation that satisfies the following conditions.
 
-
 - Conformance includes equivalence. If `T \equiv U` then `T <: U`.
 - For every value type `T`, `scala.Nothing <: ´T´ <: scala.Any`.
 - For every type constructor ´T´ (with any number of type parameters), `scala.Nothing <: ´T´ <: scala.Any`.
 - For every value type ´T´, `scala.Null <: ´T´` unless `´T´ <: scala.AnyVal`.
-- A type variable or abstract type ´t´ conforms to its upper bound and
-  its lower bound conforms to ´t´.
+- A type variable or abstract type ´t´ conforms to its upper bound and its lower bound conforms to ´t´.
 - A class type or parameterized type conforms to any of its base-types.
 - A singleton type `´p´.type` conforms to the type of the path ´p´.
 - A singleton type `´p´.type` conforms to the type `scala.Singleton`.
 - A type projection `´T´#´t´` conforms to `´U´#´t´` if ´T´ conforms to ´U´.
-- A parameterized type `´T´[´T_1´, ..., ´T_n´]` conforms to
-  `´T´[´U_1´, ..., ´U_n´]` if
-  the following three conditions hold for ´i \in \{ 1, ..., n \}´:
- 1. If the ´i´'th type parameter of ´T´ is declared covariant, then
-       ´T_i <: U_i´.
- 1. If the ´i´'th type parameter of ´T´ is declared contravariant, then
-       ´U_i <: T_i´.
- 1. If the ´i´'th type parameter of ´T´ is declared neither covariant
-       nor contravariant, then ´U_i \equiv T_i´.
-- A compound type `´T_1´ with ... with ´T_n´ {´R\,´}` conforms to
-  each of its component types ´T_i´.
-- If ´T <: U_i´ for ´i \in \{ 1, ..., n \}´ and for every
-  binding ´d´ of a type or value ´x´ in ´R´ there exists a member
-  binding of ´x´ in ´T´ which subsumes ´d´, then ´T´ conforms to the
-  compound type `´U_1´ with ... with ´U_n´ {´R\,´}`.
-- The existential type `´T´ forSome {´\,Q\,´}` conforms to
-  ´U´ if its [skolemization](#existential-types)
-  conforms to ´U´.
-- The type ´T´ conforms to the existential type `´U´ forSome {´\,Q\,´}`
-  if ´T´ conforms to one of the [type instances](#existential-types)
-  of `´U´ forSome {´\,Q\,´}`.
-- If
-  ´T_i \equiv T_i'´ for ´i \in \{ 1, ..., n\}´ and ´U´ conforms to ´U'´
-  then the method type ´(p_1:T_1, ..., p_n:T_n) U´ conforms to
-  ´(p_1':T_1', ..., p_n':T_n') U'´.
-- The polymorphic type
-  ´[a_1 >: L_1 <: U_1, ..., a_n >: L_n <: U_n] T´ conforms to the
-  polymorphic type
-  ´[a_1 >: L_1' <: U_1', ..., a_n >: L_n' <: U_n'] T'´ if, assuming
-  ´L_1' <: a_1 <: U_1', ..., L_n' <: a_n <: U_n'´
-  one has ´T <: T'´ and ´L_i <: L_i'´ and ´U_i' <: U_i´
-  for ´i \in \{ 1, ..., n \}´.
-- Type constructors ´T´ and ´T'´ follow a similar discipline. We characterize
-  ´T´ and ´T'´ by their type parameter clauses
-  ´[a_1, ..., a_n]´ and
-  ´[a_1', ..., a_n']´, where an ´a_i´ or ´a_i'´ may include a variance
-  annotation, a higher-order type parameter clause, and bounds. Then, ´T´
-  conforms to ´T'´ if any list ´[t_1, ..., t_n]´ -- with declared
-  variances, bounds and higher-order type parameter clauses -- of valid type
-  arguments for ´T'´ is also a valid list of type arguments for ´T´ and
-  ´T[t_1, ..., t_n] <: T'[t_1, ..., t_n]´. Note that this entails
-  that:
-    - The bounds on ´a_i´ must be weaker than the corresponding bounds declared
-      for ´a'_i´.
-    - The variance of ´a_i´ must match the variance of ´a'_i´, where covariance
-      matches covariance, contravariance matches contravariance and any variance
-      matches invariance.
-    - Recursively, these restrictions apply to the corresponding higher-order
-      type parameter clauses of ´a_i´ and ´a'_i´.
-
-A declaration or definition in some compound type of class type ´C´
-_subsumes_ another declaration of the same name in some compound type or class
-type ´C'´, if one of the following holds.
-
-- A value declaration or definition that defines a name ´x´ with type ´T´
-  subsumes a value or method declaration that defines ´x´ with type ´T'´, provided
-  ´T <: T'´.
-- A method declaration or definition that defines a name ´x´ with type ´T´
-  subsumes a method declaration that defines ´x´ with type ´T'´, provided
-  ´T <: T'´.
-- A type alias
-  `type ´t´[´T_1´, ..., ´T_n´] = ´T´` subsumes a type alias
-  `type ´t´[´T_1´, ..., ´T_n´] = ´T'´` if ´T \equiv T'´.
-- A type declaration `type ´t´[´T_1´, ..., ´T_n´] >: ´L´ <: ´U´` subsumes
-  a type declaration `type ´t´[´T_1´, ..., ´T_n´] >: ´L'´ <: ´U'´` if
-  ´L' <: L´ and ´U <: U'´.
-- A type or class definition that binds a type name ´t´ subsumes an abstract
-  type declaration `type t[´T_1´, ..., ´T_n´] >: L <: U` if
-  ´L <: t <: U´.
+- A parameterized type `´T´[´T_1´, ..., ´T_n´]` conforms to `´T´[´U_1´, ..., ´U_n´]` if the following three conditions hold for ´i \in \{ 1, ..., n \}´:
+  1. If the ´i´'th type parameter of ´T´ is declared covariant, then ´T_i <: U_i´.
+  1. If the ´i´'th type parameter of ´T´ is declared contravariant, then ´U_i <: T_i´.
+  1. If the ´i´'th type parameter of ´T´ is declared neither covariant nor contravariant, then ´U_i \equiv T_i´.
+- A compound type `´T_1´ with ... with ´T_n´ {´R\,´}` conforms to each of its component types ´T_i´.
+- If ´T <: U_i´ for ´i \in \{ 1, ..., n \}´ and for every binding ´d´ of a type or value ´x´ in ´R´ there exists a member binding of ´x´ in ´T´ which subsumes ´d´, then ´T´ conforms to the compound type `´U_1´ with ... with ´U_n´ {´R\,´}`.
+- The existential type `´T´ forSome {´\,Q\,´}` conforms to ´U´ if its [skolemization](#existential-types) conforms to ´U´.
+- The type ´T´ conforms to the existential type `´U´ forSome {´\,Q\,´}` if ´T´ conforms to one of the [type instances](#existential-types) of `´U´ forSome {´\,Q\,´}`.
+- If ´T_i \equiv T_i'´ for ´i \in \{ 1, ..., n\}´ and ´U´ conforms to ´U'´ then the method type ´(p_1:T_1, ..., p_n:T_n) U´ conforms to ´(p_1':T_1', ..., p_n':T_n') U'´.
+- The polymorphic type ´[a_1 >: L_1 <: U_1, ..., a_n >: L_n <: U_n] T´ conforms to the polymorphic type ´[a_1 >: L_1' <: U_1', ..., a_n >: L_n' <: U_n'] T'´ if, assuming ´L_1' <: a_1 <: U_1', ..., L_n' <: a_n <: U_n'´ one has ´T <: T'´ and ´L_i <: L_i'´ and ´U_i' <: U_i´ for ´i \in \{ 1, ..., n \}´.
+- Type constructors ´T´ and ´T'´ follow a similar discipline. We characterize ´T´ and ´T'´ by their type parameter clauses ´[a_1, ..., a_n]´ and ´[a_1', ..., a_n']´, where an ´a_i´ or ´a_i'´ may include a variance annotation, a higher-order type parameter clause, and bounds.
+Then, ´T´ conforms to ´T'´ if any list ´[t_1, ..., t_n]´ -- with declared variances, bounds and higher-order type parameter clauses -- of valid type arguments for ´T'´ is also a valid list of type arguments for ´T´ and ´T[t_1, ..., t_n] <: T'[t_1, ..., t_n]´.
+Note that this entails that:
+  - The bounds on ´a_i´ must be weaker than the corresponding bounds declared for ´a'_i´.
+  - The variance of ´a_i´ must match the variance of ´a'_i´, where covariance matches covariance, contravariance matches contravariance and any variance matches invariance.
+  - Recursively, these restrictions apply to the corresponding higher-order type parameter clauses of ´a_i´ and ´a'_i´.
+
+A declaration or definition in some compound type of class type ´C´ _subsumes_ another declaration of the same name in some compound type or class type ´C'´, if one of the following holds.
+
+- A value declaration or definition that defines a name ´x´ with type ´T´ subsumes a value or method declaration that defines ´x´ with type ´T'´, provided ´T <: T'´.
+- A method declaration or definition that defines a name ´x´ with type ´T´ subsumes a method declaration that defines ´x´ with type ´T'´, provided ´T <: T'´.
+- A type alias `type ´t´[´T_1´, ..., ´T_n´] = ´T´` subsumes a type alias `type ´t´[´T_1´, ..., ´T_n´] = ´T'´` if ´T \equiv T'´.
+- A type declaration `type ´t´[´T_1´, ..., ´T_n´] >: ´L´ <: ´U´` subsumes a type declaration `type ´t´[´T_1´, ..., ´T_n´] >: ´L'´ <: ´U'´` if ´L' <: L´ and ´U <: U'´.
+- A type or class definition that binds a type name ´t´ subsumes an abstract type declaration `type t[´T_1´, ..., ´T_n´] >: L <: U` if ´L <: t <: U´.
 
 
 #### Least upper bounds and greatest lower bounds
@@ -944,30 +708,20 @@ class B extends A[B]
 class C extends A[C]
 ```
 
-Then the types `A[Any], A[A[Any]], A[A[A[Any]]], ...` form
-a descending sequence of upper bounds for `B` and `C`. The
-least upper bound would be the infinite limit of that sequence, which
-does not exist as a Scala type. Since cases like this are in general
-impossible to detect, a Scala compiler is free to reject a term
-which has a type specified as a least upper or greatest lower bound,
-and that bound would be more complex than some compiler-set
-limit [^4].
-
-The least upper bound or greatest lower bound might also not be
-unique. For instance `A with B` and `B with A` are both
-greatest lower bounds of `A` and `B`. If there are several
-least upper bounds or greatest lower bounds, the Scala compiler is
-free to pick any one of them.
-
-[^4]: The current Scala compiler limits the nesting level
-      of parameterization in such bounds to be at most two deeper than the
-      maximum nesting level of the operand types
+Then the types `A[Any], A[A[Any]], A[A[A[Any]]], ...` form a descending sequence of upper bounds for `B` and `C`.
+The least upper bound would be the infinite limit of that sequence, which does not exist as a Scala type.
+Since cases like this are in general impossible to detect, a Scala compiler is free to reject a term which has a type specified as a least upper or greatest lower bound, and that bound would be more complex than some compiler-set limit [^4].
+
+The least upper bound or greatest lower bound might also not be unique.
+For instance `A with B` and `B with A` are both greatest lower bounds of `A` and `B`.
+If there are several least upper bounds or greatest lower bounds, the Scala compiler is free to pick any one of them.
+
+[^4]: The current Scala compiler limits the nesting level of parameterization in such bounds to be at most two deeper than the maximum nesting level of the operand types
 
 ### Weak Conformance
 
 In some situations Scala uses a more general conformance relation.
-A type ´S´ _weakly conforms_ to a type ´T´, written ´S <:_w T´,
-if ´S <: T´ or both ´S´ and ´T´ are primitive number types and ´S´ precedes ´T´ in the following ordering.
+A type ´S´ _weakly conforms_ to a type ´T´, written ´S <:_w T´, if ´S <: T´ or both ´S´ and ´T´ are primitive number types and ´S´ precedes ´T´ in the following ordering.
 
 ```scala
 Byte  ´<:_w´ Short
@@ -981,11 +735,12 @@ Float ´<:_w´ Double
 A _weak least upper bound_ is a least upper bound with respect to weak conformance.
 
 ### Compatibility
-A type ´T´ is _compatible_ to a type ´U´ if ´T´ (or its corresponding function type) [weakly conforms](#weak-conformance) to ´U´
-after applying [eta-expansion](06-expressions.html#eta-expansion). If ´T´ is a method type, it's converted to the corresponding function type. If the types do not weakly conform, the following alternatives are checked in order:
-  - [view application](07-implicits.html#views): there's an implicit view from ´T´ to ´U´;
-  - dropping by-name modifiers: if ´U´ is of the shape `´=> U'´` (and ´T´ is not), `´T <:_w U'´`;
-  - SAM conversion: if ´T´ corresponds to a function type, and ´U´ declares a single abstract method whose type [corresponds](06-expressions.html#sam-conversion) to the function type ´U'´, `´T <:_w U'´`.
+A type ´T´ is _compatible_ to a type ´U´ if ´T´ (or its corresponding function type) [weakly conforms](#weak-conformance) to ´U´ after applying [eta-expansion](06-expressions.html#eta-expansion).
+If ´T´ is a method type, it's converted to the corresponding function type.
+If the types do not weakly conform, the following alternatives are checked in order:
+- [view application](07-implicits.html#views): there's an implicit view from ´T´ to ´U´;
+- dropping by-name modifiers: if ´U´ is of the shape `´=> U'´` (and ´T´ is not), `´T <:_w U'´`;
+- SAM conversion: if ´T´ corresponds to a function type, and ´U´ declares a single abstract method whose type [corresponds](06-expressions.html#sam-conversion) to the function type ´U'´, `´T <:_w U'´`.
 
 <!--- TODO: include other implicit conversions in addition to view application?
 
@@ -1011,68 +766,48 @@ def foo(x: ToString): Unit
 trait ToString { def convert(x: Int): String }
 ```
 
-The application `foo((x: Int) => x.toString)` [resolves](06-expressions.html#overloading-resolution) to the first overload,
-as it's more specific:
-  - `Int => String` is compatible to `ToString` -- when expecting a value of type `ToString`, you may pass a function literal from `Int` to `String`, as it will be SAM-converted to said function;
-  - `ToString` is not compatible to `Int => String` -- when expecting a function from `Int` to `String`, you may not pass a `ToString`.
+The application `foo((x: Int) => x.toString)` [resolves](06-expressions.html#overloading-resolution) to the first overload, as it's more specific:
+- `Int => String` is compatible to `ToString` -- when expecting a value of type `ToString`, you may pass a function literal from `Int` to `String`, as it will be SAM-converted to said function;
+- `ToString` is not compatible to `Int => String` -- when expecting a function from `Int` to `String`, you may not pass a `ToString`.
 
 ## Volatile Types
 
-Type volatility approximates the possibility that a type parameter or
-abstract type instance of a type does not have any non-null values.
+Type volatility approximates the possibility that a type parameter or abstract type instance of a type does not have any non-null values.
 A value member of a volatile type cannot appear in a [path](#paths).
 
 A type is _volatile_ if it falls into one of four categories:
 
-A compound type `´T_1´ with ... with ´T_n´ {´R\,´}`
-is volatile if one of the following three conditions hold.
+A compound type `´T_1´ with ... with ´T_n´ {´R\,´}` is volatile if one of the following three conditions hold.
 
 1. One of ´T_2, ..., T_n´ is a type parameter or abstract type, or
-1. ´T_1´ is an abstract type and either the refinement ´R´
-   or a type ´T_j´ for ´j > 1´ contributes an abstract member
-   to the compound type, or
+1. ´T_1´ is an abstract type and either the refinement ´R´ or a type ´T_j´ for ´j > 1´ contributes an abstract member to the compound type, or
 1. one of ´T_1, ..., T_n´ is a singleton type.
 
-Here, a type ´S´ _contributes an abstract member_ to a type ´T´ if
-´S´ contains an abstract member that is also a member of ´T´.
-A refinement ´R´ contributes an abstract member to a type ´T´ if ´R´
-contains an abstract declaration which is also a member of ´T´.
+Here, a type ´S´ _contributes an abstract member_ to a type ´T´ if ´S´ contains an abstract member that is also a member of ´T´.
+A refinement ´R´ contributes an abstract member to a type ´T´ if ´R´ contains an abstract declaration which is also a member of ´T´.
 
-A type designator is volatile if it is an alias of a volatile type, or
-if it designates a type parameter or abstract type that has a volatile type as
-its upper bound.
+A type designator is volatile if it is an alias of a volatile type, or if it designates a type parameter or abstract type that has a volatile type as its upper bound.
 
-A singleton type `´p´.type` is volatile, if the underlying
-type of path ´p´ is volatile.
+A singleton type `´p´.type` is volatile, if the underlying type of path ´p´ is volatile.
 
-An existential type `´T´ forSome {´\,Q\,´}` is volatile if
-´T´ is volatile.
+An existential type `´T´ forSome {´\,Q\,´}` is volatile if ´T´ is volatile.
 
 ## Type Erasure
 
 A type is called _generic_ if it contains type arguments or type variables.
-_Type erasure_ is a mapping from (possibly generic) types to
-non-generic types. We write ´|T|´ for the erasure of type ´T´.
+_Type erasure_ is a mapping from (possibly generic) types to non-generic types.
+We write ´|T|´ for the erasure of type ´T´.
 The erasure mapping is defined as follows.
 
 - The erasure of an alias type is the erasure of its right-hand side.
 - The erasure of an abstract type is the erasure of its upper bound.
-- The erasure of the parameterized type `scala.Array´[T_1]´` is
- `scala.Array´[|T_1|]´`.
+- The erasure of the parameterized type `scala.Array´[T_1]´` is `scala.Array´[|T_1|]´`.
 - The erasure of every other parameterized type ´T[T_1, ..., T_n]´ is ´|T|´.
-- The erasure of a singleton type `´p´.type` is the
-  erasure of the type of ´p´.
+- The erasure of a singleton type `´p´.type` is the erasure of the type of ´p´.
 - The erasure of a type projection `´T´#´x´` is `|´T´|#´x´`.
-- The erasure of a compound type
-  `´T_1´ with ... with ´T_n´ {´R\,´}` is the erasure of the intersection
-  dominator of ´T_1, ..., T_n´.
+- The erasure of a compound type `´T_1´ with ... with ´T_n´ {´R\,´}` is the erasure of the intersection dominator of ´T_1, ..., T_n´.
 - The erasure of an existential type `´T´ forSome {´\,Q\,´}` is ´|T|´.
 
-The _intersection dominator_ of a list of types ´T_1, ..., T_n´ is computed
-as follows.
-Let ´T_{i_1}, ..., T_{i_m}´ be the subsequence of types ´T_i´
-which are not supertypes of some other type ´T_j´.
-If this subsequence contains a type designator ´T_c´ that refers to a class
-which is not a trait,
-the intersection dominator is ´T_c´. Otherwise, the intersection
-dominator is the first element of the subsequence, ´T_{i_1}´.
+The _intersection dominator_ of a list of types ´T_1, ..., T_n´ is computed as follows.
+Let ´T_{i_1}, ..., T_{i_m}´ be the subsequence of types ´T_i´ which are not supertypes of some other type ´T_j´.
+If this subsequence contains a type designator ´T_c´ that refers to a class which is not a trait, the intersection dominator is ´T_c´. Otherwise, the intersection dominator is the first element of the subsequence, ´T_{i_1}´.
diff --git a/docs/_spec/04-basic-declarations-and-definitions.md b/docs/_spec/04-basic-declarations-and-definitions.md
index 0dd311e558b8..f9e55b15a59b 100644
--- a/docs/_spec/04-basic-declarations-and-definitions.md
+++ b/docs/_spec/04-basic-declarations-and-definitions.md
@@ -19,22 +19,16 @@ Def         ::=  PatVarDef
               |  TmplDef
 ```
 
-A _declaration_ introduces names and assigns them types. It can
-form part of a [class definition](05-classes-and-objects.html#templates) or of a
-refinement in a [compound type](03-types.html#compound-types).
-
-A _definition_ introduces names that denote terms or types. It can
-form part of an object or class definition or it can be local to a
-block.  Both declarations and definitions produce _bindings_ that
-associate type names with type definitions or bounds, and that
-associate term names with types.
-
-The scope of a name introduced by a declaration or definition is the
-whole statement sequence containing the binding.  However, there is a
-restriction on forward references in blocks: In a statement sequence
-´s_1 ... s_n´ making up a block, if a simple name in ´s_i´ refers
-to an entity defined by ´s_j´ where ´j \geq i´, then for all ´s_k´
-between and including ´s_i´ and ´s_j´,
+A _declaration_ introduces names and assigns them types.
+It can form part of a [class definition](05-classes-and-objects.html#templates) or of a refinement in a [compound type](03-types.html#compound-types).
+
+A _definition_ introduces names that denote terms or types.
+It can form part of an object or class definition or it can be local to a block.
+Both declarations and definitions produce _bindings_ that associate type names with type definitions or bounds, and that associate term names with types.
+
+The scope of a name introduced by a declaration or definition is the whole statement sequence containing the binding.
+However, there is a restriction on forward references in blocks:
+In a statement sequence ´s_1 ... s_n´ making up a block, if a simple name in ´s_i´ refers to an entity defined by ´s_j´ where ´j \geq i´, then for all ´s_k´ between and including ´s_i´ and ´s_j´,
 
 - ´s_k´ cannot be a variable definition.
 - If ´s_k´ is a value definition, it must be lazy.
@@ -105,21 +99,16 @@ PatDef       ::=  Pattern2 {‘,’ Pattern2} [‘:’ Type] ‘=’ Expr
 ids          ::=  id {‘,’ id}
 ```
 
-A value declaration `val ´x´: ´T´` introduces ´x´ as a name of a value of
-type ´T´.
+A value declaration `val ´x´: ´T´` introduces ´x´ as a name of a value of type ´T´.
 
-A value definition `val ´x´: ´T´ = ´e´` defines ´x´ as a
-name of the value that results from the evaluation of ´e´.
-If the value definition is not recursive, the type
-´T´ may be omitted, in which case the [packed type](06-expressions.html#expression-typing) of
-expression ´e´ is assumed.  If a type ´T´ is given, then ´e´ is expected to
-conform to it.
+A value definition `val ´x´: ´T´ = ´e´` defines ´x´ as a name of the value that results from the evaluation of ´e´.
+If the value definition is not recursive, the type ´T´ may be omitted, in which case the [packed type](06-expressions.html#expression-typing) of expression ´e´ is assumed.
+If a type ´T´ is given, then ´e´ is expected to conform to it.
 
-Evaluation of the value definition implies evaluation of its
-right-hand side ´e´, unless it has the modifier `lazy`.  The
-effect of the value definition is to bind ´x´ to the value of ´e´
-converted to type ´T´. A `lazy` value definition evaluates
-its right hand side ´e´ the first time the value is accessed.
+Evaluation of the value definition implies evaluation of its right-hand side ´e´, unless it has the modifier `lazy`.
+The effect of the value definition is to bind ´x´ to the value of ´e´
+converted to type ´T´.
+A `lazy` value definition evaluates its right hand side ´e´ the first time the value is accessed.
 
 A _constant value definition_ is of the form
 
@@ -128,15 +117,11 @@ final val x = e
 ```
 
 where `e` is a [constant expression](06-expressions.html#constant-expressions).
-The `final` modifier must be
-present and no type annotation may be given. References to the
-constant value `x` are themselves treated as constant expressions; in the
-generated code they are replaced by the definition's right-hand side `e`.
+The `final` modifier must be present and no type annotation may be given. 
+References to the constant value `x` are themselves treated as constant expressions; in the generated code they are replaced by the definition's right-hand side `e`.
 
-Value definitions can alternatively have a [pattern](08-pattern-matching.html#patterns)
-as left-hand side.  If ´p´ is some pattern other
-than a simple name or a name followed by a colon and a type, then the
-value definition `val ´p´ = ´e´` is expanded as follows:
+Value definitions can alternatively have a [pattern](08-pattern-matching.html#patterns) as left-hand side.
+If ´p´ is some pattern other than a simple name or a name followed by a colon and a type, then the value definition `val ´p´ = ´e´` is expanded as follows:
 
 1. If the pattern ´p´ has bound variables ´x_1, ..., x_n´, where ´n > 1´:
 
@@ -184,12 +169,9 @@ val xs = x´\$´._2
 
 The name of any declared or defined value may not end in `_=`.
 
-A value declaration `val ´x_1, ..., x_n´: ´T´` is a shorthand for the
-sequence of value declarations `val ´x_1´: ´T´; ...; val ´x_n´: ´T´`.
-A value definition `val ´p_1, ..., p_n´ = ´e´` is a shorthand for the
-sequence of value definitions `val ´p_1´ = ´e´; ...; val ´p_n´ = ´e´`.
-A value definition `val ´p_1, ..., p_n: T´ = ´e´` is a shorthand for the
-sequence of value definitions `val ´p_1: T´ = ´e´; ...; val ´p_n: T´ = ´e´`.
+A value declaration `val ´x_1, ..., x_n´: ´T´` is a shorthand for the sequence of value declarations `val ´x_1´: ´T´; ...; val ´x_n´: ´T´`.
+A value definition `val ´p_1, ..., p_n´ = ´e´` is a shorthand for the sequence of value definitions `val ´p_1´ = ´e´; ...; val ´p_n´ = ´e´`.
+A value definition `val ´p_1, ..., p_n: T´ = ´e´` is a shorthand for the sequence of value definitions `val ´p_1: T´ = ´e´; ...; val ´p_n: T´ = ´e´`.
 
 ## Variable Declarations and Definitions
 
@@ -201,30 +183,21 @@ VarDef         ::=  PatDef
                  |  ids ‘:’ Type ‘=’ ‘_’
 ```
 
-A variable declaration `var ´x´: ´T´` is equivalent to the declarations
-of both a _getter function_ ´x´ *and* a _setter function_ `´x´_=`:
+A variable declaration `var ´x´: ´T´` is equivalent to the declarations of both a _getter function_ ´x´ *and* a _setter function_ `´x´_=`:
 
 ```scala
 def ´x´: ´T´
 def ´x´_= (´y´: ´T´): Unit
 ```
 
-An implementation of a class may _define_ a declared variable
-using a variable definition, or by defining the corresponding setter and getter methods.
+An implementation of a class may _define_ a declared variable using a variable definition, or by defining the corresponding setter and getter methods.
 
-A variable definition `var ´x´: ´T´ = ´e´` introduces a
-mutable variable with type ´T´ and initial value as given by the
-expression ´e´. The type ´T´ can be omitted, in which case the type of
-´e´ is assumed. If ´T´ is given, then ´e´ is expected to
-[conform to it](06-expressions.html#expression-typing).
+A variable definition `var ´x´: ´T´ = ´e´` introduces a mutable variable with type ´T´ and initial value as given by the expression ´e´.
+The type ´T´ can be omitted, in which case the type of ´e´ is assumed.
+If ´T´ is given, then ´e´ is expected to [conform to it](06-expressions.html#expression-typing).
 
-Variable definitions can alternatively have a [pattern](08-pattern-matching.html#patterns)
-as left-hand side.  A variable definition
- `var ´p´ = ´e´` where ´p´ is a pattern other
-than a simple name or a name followed by a colon and a type is expanded in the same way
-as a [value definition](#value-declarations-and-definitions)
-`val ´p´ = ´e´`, except that
-the free names in ´p´ are introduced as mutable variables, not values.
+Variable definitions can alternatively have a [pattern](08-pattern-matching.html#patterns) as left-hand side.
+A variable definition  `var ´p´ = ´e´` where ´p´ is a pattern other than a simple name or a name followed by a colon and a type is expanded in the same way as a [value definition](#value-declarations-and-definitions) `val ´p´ = ´e´`, except that the free names in ´p´ are introduced as mutable variables, not values.
 
 The name of any declared or defined variable may not end in `_=`.
 
@@ -242,23 +215,16 @@ The default value depends on the type ´T´ as follows:
 |`()`      | `Unit`                             |
 |`null`    | all other types                    |
 
-When they occur as members of a template, both forms of variable
-definition also introduce a getter function ´x´ which returns the
-value currently assigned to the variable, as well as a setter function
-`´x´_=` which changes the value currently assigned to the variable.
+When they occur as members of a template, both forms of variable definition also introduce a getter function ´x´ which returns the value currently assigned to the variable, as well as a setter function `´x´_=` which changes the value currently assigned to the variable.
 The functions have the same signatures as for a variable declaration.
-The template then has these getter and setter functions as
-members, whereas the original variable cannot be accessed directly as
-a template member.
+The template then has these getter and setter functions as members, whereas the original variable cannot be accessed directly as a template member.
 
 ###### Example
 
-The following example shows how _properties_ can be
-simulated in Scala. It defines a class `TimeOfDayVar` of time
-values with updatable integer fields representing hours, minutes, and
-seconds. Its implementation contains tests that allow only legal
-values to be assigned to these fields. The user code, on the other
-hand, accesses these fields just like normal variables.
+The following example shows how _properties_ can be simulated in Scala.
+It defines a class `TimeOfDayVar` of time values with updatable integer fields representing hours, minutes, and seconds.
+Its implementation contains tests that allow only legal values to be assigned to these fields.
+The user code, on the other hand, accesses these fields just like normal variables.
 
 ```scala
 class TimeOfDayVar {
@@ -283,13 +249,9 @@ d.hours = 8; d.minutes = 30; d.seconds = 0
 d.hours = 25                  // throws a DateError exception
 ```
 
-A variable declaration `var ´x_1, ..., x_n´: ´T´` is a shorthand for the
-sequence of variable declarations `var ´x_1´: ´T´; ...; var ´x_n´: ´T´`.
-A variable definition `var ´x_1, ..., x_n´ = ´e´` is a shorthand for the
-sequence of variable definitions `var ´x_1´ = ´e´; ...; var ´x_n´ = ´e´`.
-A variable definition `var ´x_1, ..., x_n: T´ = ´e´` is a shorthand for
-the sequence of variable definitions
-`var ´x_1: T´ = ´e´; ...; var ´x_n: T´ = ´e´`.
+A variable declaration `var ´x_1, ..., x_n´: ´T´` is a shorthand for the sequence of variable declarations `var ´x_1´: ´T´; ...; var ´x_n´: ´T´`.
+A variable definition `var ´x_1, ..., x_n´ = ´e´` is a shorthand for the sequence of variable definitions `var ´x_1´ = ´e´; ...; var ´x_n´ = ´e´`.
+A variable definition `var ´x_1, ..., x_n: T´ = ´e´` is a shorthand for the sequence of variable definitions `var ´x_1: T´ = ´e´; ...; var ´x_n: T´ = ´e´`.
 
 ## Type Declarations and Type Aliases
 
@@ -302,44 +264,33 @@ Def        ::=  ‘type’ {nl} TypeDef
 TypeDef    ::=  id [TypeParamClause] ‘=’ Type
 ```
 
-A _type declaration_ `type ´t´[´\mathit{tps}\,´] >: ´L´ <: ´U´` declares
-´t´ to be an abstract type with lower bound type ´L´ and upper bound
-type ´U´. If the type parameter clause `[´\mathit{tps}\,´]` is omitted, ´t´ abstracts over a proper type, otherwise ´t´ stands for a type constructor that accepts type arguments as described by the type parameter clause.
-
-If a type declaration appears as a member declaration of a
-type, implementations of the type may implement ´t´ with any type ´T´
-for which ´L <: T <: U´. It is a compile-time error if
-´L´ does not conform to ´U´.  Either or both bounds may be omitted.
-If the lower bound ´L´ is absent, the bottom type
-`scala.Nothing` is assumed.  If the upper bound ´U´ is absent,
-the top type `scala.Any` is assumed.
-
-A type constructor declaration imposes additional restrictions on the
-concrete types for which ´t´ may stand. Besides the bounds ´L´ and
-´U´, the type parameter clause may impose higher-order bounds and
-variances, as governed by the [conformance of type constructors](03-types.html#conformance).
-
-The scope of a type parameter extends over the bounds `>: ´L´ <: ´U´` and the type parameter clause ´\mathit{tps}´ itself. A
-higher-order type parameter clause (of an abstract type constructor
-´tc´) has the same kind of scope, restricted to the declaration of the
-type parameter ´tc´.
-
-To illustrate nested scoping, these declarations are all equivalent: `type t[m[x] <: Bound[x], Bound[x]]`, `type t[m[x] <: Bound[x], Bound[y]]` and `type t[m[x] <: Bound[x], Bound[_]]`, as the scope of, e.g., the type parameter of ´m´ is limited to the declaration of ´m´. In all of them, ´t´ is an abstract type member that abstracts over two type constructors: ´m´ stands for a type constructor that takes one type parameter and that must be a subtype of ´Bound´, ´t´'s second type constructor parameter. `t[MutableList, Iterable]` is a valid use of ´t´.
-
-A _type alias_ `type ´t´ = ´T´` defines ´t´ to be an alias
-name for the type ´T´.  The left hand side of a type alias may
-have a type parameter clause, e.g. `type ´t´[´\mathit{tps}\,´] = ´T´`.  The scope
-of a type parameter extends over the right hand side ´T´ and the
-type parameter clause ´\mathit{tps}´ itself.
-
-The scope rules for [definitions](#basic-declarations-and-definitions)
-and [type parameters](#function-declarations-and-definitions)
-make it possible that a type name appears in its
-own bound or in its right-hand side.  However, it is a static error if
-a type alias refers recursively to the defined type constructor itself.
-That is, the type ´T´ in a type alias `type ´t´[´\mathit{tps}\,´] = ´T´` may not
-refer directly or indirectly to the name ´t´.  It is also an error if
-an abstract type is directly or indirectly its own upper or lower bound.
+A _type declaration_ `type ´t´[´\mathit{tps}\,´] >: ´L´ <: ´U´` declares ´t´ to be an abstract type with lower bound type ´L´ and upper bound type ´U´.
+If the type parameter clause `[´\mathit{tps}\,´]` is omitted, ´t´ abstracts over a proper type, otherwise ´t´ stands for a type constructor that accepts type arguments as described by the type parameter clause.
+
+If a type declaration appears as a member declaration of a type, implementations of the type may implement ´t´ with any type ´T´ for which ´L <: T <: U´.
+It is a compile-time error if ´L´ does not conform to ´U´.
+Either or both bounds may be omitted.
+If the lower bound ´L´ is absent, the bottom type `scala.Nothing` is assumed.
+If the upper bound ´U´ is absent, the top type `scala.Any` is assumed.
+
+A type constructor declaration imposes additional restrictions on the concrete types for which ´t´ may stand.
+Besides the bounds ´L´ and ´U´, the type parameter clause may impose higher-order bounds and variances, as governed by the [conformance of type constructors](03-types.html#conformance).
+
+The scope of a type parameter extends over the bounds `>: ´L´ <: ´U´` and the type parameter clause ´\mathit{tps}´ itself.
+A higher-order type parameter clause (of an abstract type constructor ´tc´) has the same kind of scope, restricted to the declaration of the type parameter ´tc´.
+
+To illustrate nested scoping, these declarations are all equivalent: `type t[m[x] <: Bound[x], Bound[x]]`, `type t[m[x] <: Bound[x], Bound[y]]` and `type t[m[x] <: Bound[x], Bound[_]]`, as the scope of, e.g., the type parameter of ´m´ is limited to the declaration of ´m´.
+In all of them, ´t´ is an abstract type member that abstracts over two type constructors: ´m´ stands for a type constructor that takes one type parameter and that must be a subtype of ´Bound´, ´t´'s second type constructor parameter.
+`t[MutableList, Iterable]` is a valid use of ´t´.
+
+A _type alias_ `type ´t´ = ´T´` defines ´t´ to be an alias name for the type ´T´.
+The left hand side of a type alias may have a type parameter clause, e.g. `type ´t´[´\mathit{tps}\,´] = ´T´`.
+The scope of a type parameter extends over the right hand side ´T´ and the type parameter clause ´\mathit{tps}´ itself.
+
+The scope rules for [definitions](#basic-declarations-and-definitions) and [type parameters](#function-declarations-and-definitions) make it possible that a type name appears in its own bound or in its right-hand side.
+However, it is a static error if a type alias refers recursively to the defined type constructor itself.
+That is, the type ´T´ in a type alias `type ´t´[´\mathit{tps}\,´] = ´T´` may not refer directly or indirectly to the name ´t´.
+It is also an error if an abstract type is directly or indirectly its own upper or lower bound.
 
 ###### Example
 
@@ -366,14 +317,11 @@ type MyCollection <: Iterable   // Type constructor members must explicitly
                                 // state their type parameters.
 ```
 
-If a type alias `type ´t´[´\mathit{tps}\,´] = ´S´` refers to a class type
-´S´, the name ´t´ can also be used as a constructor for
-objects of type ´S´.
+If a type alias `type ´t´[´\mathit{tps}\,´] = ´S´` refers to a class type ´S´, the name ´t´ can also be used as a constructor for objects of type ´S´.
 
 ###### Example
 
-Suppose we make `Pair` an alias of the parameterized class `Tuple2`,
-as follows:
+Suppose we make `Pair` an alias of the parameterized class `Tuple2`, as follows:
 
 ```scala
 type Pair[+A, +B] = Tuple2[A, B]
@@ -383,8 +331,7 @@ object Pair {
 }
 ```
 
-As a consequence, for any two types ´S´ and ´T´, the type
-`Pair[´S´, ´T\,´]` is equivalent to the type `Tuple2[´S´, ´T\,´]`.
+As a consequence, for any two types ´S´ and ´T´, the type `Pair[´S´, ´T\,´]` is equivalent to the type `Tuple2[´S´, ´T\,´]`.
 `Pair` can also be used as a constructor instead of `Tuple2`, as in:
 
 ```scala
@@ -399,19 +346,14 @@ VariantTypeParam ::= {Annotation} [‘+’ | ‘-’] TypeParam
 TypeParam        ::= (id | ‘_’) [TypeParamClause] [‘>:’ Type] [‘<:’ Type] [‘:’ Type]
 ```
 
-Type parameters appear in type definitions, class definitions, and
-function definitions.  In this section we consider only type parameter
-definitions with lower bounds `>: ´L´` and upper bounds
-`<: ´U´` whereas a discussion of context bounds
-`: ´U´` and view bounds `<% ´U´`
-is deferred to [here](07-implicits.html#context-bounds-and-view-bounds).
+Type parameters appear in type definitions, class definitions, and function definitions.
+In this section we consider only type parameter definitions with lower bounds `>: ´L´` and upper bounds `<: ´U´` whereas a discussion of context bounds `: ´U´` and view bounds `<% ´U´` is deferred to [here](07-implicits.html#context-bounds-and-view-bounds).
 
-The most general form of a proper type parameter is
+The most general form of a proper type parameter is 
 `´@a_1 ... @a_n´ ´\pm´ ´t´ >: ´L´ <: ´U´`.
-Here, ´L´, and ´U´ are lower and upper bounds that
-constrain possible type arguments for the parameter.  It is a
-compile-time error if ´L´ does not conform to ´U´. ´\pm´ is a _variance_, i.e. an optional prefix of either `+`, or
-`-`. One or more annotations may precede the type parameter.
+Here, ´L´, and ´U´ are lower and upper bounds that constrain possible type arguments for the parameter.
+It is a compile-time error if ´L´ does not conform to ´U´.
+´\pm´ is a _variance_, i.e. an optional prefix of either `+`, or `-`. One or more annotations may precede the type parameter.
 
 <!--
 The upper bound ´U´ in a type parameter clauses may not be a final
@@ -424,11 +366,18 @@ TODO: Why
 TODO: this is a pretty awkward description of scoping and distinctness of binders
 -->
 
-The names of all type parameters must be pairwise different in their enclosing type parameter clause.  The scope of a type parameter includes in each case the whole type parameter clause. Therefore it is possible that a type parameter appears as part of its own bounds or the bounds of other type parameters in the same clause.  However, a type parameter may not be bounded directly or indirectly by itself.
+The names of all type parameters must be pairwise different in their enclosing type parameter clause.
+The scope of a type parameter includes in each case the whole type parameter clause.
+Therefore it is possible that a type parameter appears as part of its own bounds or the bounds of other type parameters in the same clause.
+However, a type parameter may not be bounded directly or indirectly by itself.
 
-A type constructor parameter adds a nested type parameter clause to the type parameter. The most general form of a type constructor parameter is `´@a_1 ... @a_n \pm t[\mathit{tps}\,]´ >: ´L´ <: ´U´`.
+A type constructor parameter adds a nested type parameter clause to the type parameter.
+The most general form of a type constructor parameter is `´@a_1 ... @a_n \pm t[\mathit{tps}\,]´ >: ´L´ <: ´U´`.
 
-The above scoping restrictions are generalized to the case of nested type parameter clauses, which declare higher-order type parameters. Higher-order type parameters (the type parameters of a type parameter ´t´) are only visible in their immediately surrounding parameter clause (possibly including clauses at a deeper nesting level) and in the bounds of ´t´. Therefore, their names must only be pairwise different from the names of other visible parameters. Since the names of higher-order type parameters are thus often irrelevant, they may be denoted with a `‘_’`, which is nowhere visible.
+The above scoping restrictions are generalized to the case of nested type parameter clauses, which declare higher-order type parameters.
+Higher-order type parameters (the type parameters of a type parameter ´t´) are only visible in their immediately surrounding parameter clause (possibly including clauses at a deeper nesting level) and in the bounds of ´t´.
+Therefore, their names must only be pairwise different from the names of other visible parameters.
+Since the names of higher-order type parameters are thus often irrelevant, they may be denoted with a `‘_’`, which is nowhere visible.
 
 ###### Example
 Here are some well-formed type parameter clauses:
@@ -456,53 +405,32 @@ The following type parameter clauses are illegal:
 
 ## Variance Annotations
 
-Variance annotations indicate how instances of parameterized types
-vary with respect to [subtyping](03-types.html#conformance).  A
-‘+’ variance indicates a covariant dependency, a
-‘-’ variance indicates a contravariant dependency, and a
-missing variance indication indicates an invariant dependency.
-
-A variance annotation constrains the way the annotated type variable
-may appear in the type or class which binds the type parameter.  In a
-type definition `type ´T´[´\mathit{tps}\,´] = ´S´`, or a type
-declaration `type ´T´[´\mathit{tps}\,´] >: ´L´ <: ´U´` type parameters labeled
-‘+’ must only appear in covariant position whereas
-type parameters labeled ‘-’ must only appear in contravariant
-position. Analogously, for a class definition
-`class ´C´[´\mathit{tps}\,´](´\mathit{ps}\,´) extends ´T´ { ´x´: ´S´ => ...}`,
-type parameters labeled
-‘+’ must only appear in covariant position in the
-self type ´S´ and the template ´T´, whereas type
-parameters labeled ‘-’ must only appear in contravariant
-position.
-
-The variance position of a type parameter in a type or template is
-defined as follows.  Let the opposite of covariance be contravariance,
-and the opposite of invariance be itself.  The top-level of the type
-or template is always in covariant position. The variance position
-changes at the following constructs.
-
-- The variance position of a method parameter is the opposite of the
-  variance position of the enclosing parameter clause.
-- The variance position of a type parameter is the opposite of the
-  variance position of the enclosing type parameter clause.
-- The variance position of the lower bound of a type declaration or type parameter
-  is the opposite of the variance position of the type declaration or parameter.
+Variance annotations indicate how instances of parameterized types vary with respect to [subtyping](03-types.html#conformance).
+A ‘+’ variance indicates a covariant dependency, a ‘-’ variance indicates a contravariant dependency, and a missing variance indication indicates an invariant dependency.
+
+A variance annotation constrains the way the annotated type variable may appear in the type or class which binds the type parameter.
+In a type definition `type ´T´[´\mathit{tps}\,´] = ´S´`, or a type declaration `type ´T´[´\mathit{tps}\,´] >: ´L´ <: ´U´` type parameters labeled ‘+’ must only appear in covariant position whereas type parameters labeled ‘-’ must only appear in contravariant position.
+Analogously, for a class definition `class ´C´[´\mathit{tps}\,´](´\mathit{ps}\,´) extends ´T´ { ´x´: ´S´ => ...}`, type parameters labeled ‘+’ must only appear in covariant position in the self type ´S´ and the template ´T´, whereas type parameters labeled ‘-’ must only appear in contravariant position.
+
+The variance position of a type parameter in a type or template is defined as follows.
+Let the opposite of covariance be contravariance, and the opposite of invariance be itself.
+The top-level of the type or template is always in covariant position.
+The variance position changes at the following constructs.
+
+- The variance position of a method parameter is the opposite of the variance position of the enclosing parameter clause.
+- The variance position of a type parameter is the opposite of the variance position of the enclosing type parameter clause.
+- The variance position of the lower bound of a type declaration or type parameter is the opposite of the variance position of the type declaration or parameter.
 - The type of a mutable variable is always in invariant position.
 - The right-hand side of a type alias is always in invariant position.
 - The prefix ´S´ of a type selection `´S´#´T´` is always in invariant position.
-- For a type argument ´T´ of a type `´S´[´... T ...´ ]`: If the
-  corresponding type parameter is invariant, then ´T´ is in
-  invariant position.  If the corresponding type parameter is
-  contravariant, the variance position of ´T´ is the opposite of
-  the variance position of the enclosing type `´S´[´... T ...´ ]`.
+- For a type argument ´T´ of a type `´S´[´... T ...´ ]`:
+If the corresponding type parameter is invariant, then ´T´ is in invariant position.
+If the corresponding type parameter is contravariant, the variance position of ´T´ is the opposite of the variance position of the enclosing type `´S´[´... T ...´ ]`.
 
 <!-- TODO: handle type aliases -->
 
-References to the type parameters in
-[object-private or object-protected values, types, variables, or methods](05-classes-and-objects.html#modifiers) of the class are not
-checked for their variance position. In these members the type parameter may
-appear anywhere without restricting its legal variance annotations.
+References to the type parameters in [object-private or object-protected values, types, variables, or methods](05-classes-and-objects.html#modifiers) of the class are not checked for their variance position.
+In these members the type parameter may appear anywhere without restricting its legal variance annotations.
 
 ###### Example
 The following variance annotation is legal.
@@ -513,16 +441,14 @@ abstract class P[+A, +B] {
 }
 ```
 
-With this variance annotation, type instances
-of ´P´ subtype covariantly with respect to their arguments.
+With this variance annotation, type instances of ´P´ subtype covariantly with respect to their arguments.
 For instance,
 
 ```scala
 P[IOException, String] <: P[Throwable, AnyRef]
 ```
 
-If the members of ´P´ are mutable variables,
-the same variance annotation becomes illegal.
+If the members of ´P´ are mutable variables, the same variance annotation becomes illegal.
 
 ```scala
 abstract class Q[+A, +B](x: A, y: B) {
@@ -531,8 +457,7 @@ abstract class Q[+A, +B](x: A, y: B) {
 }
 ```
 
-If the mutable variables are object-private, the class definition
-becomes legal again:
+If the mutable variables are object-private, the class definition becomes legal again:
 
 ```scala
 abstract class R[+A, +B](x: A, y: B) {
@@ -543,8 +468,7 @@ abstract class R[+A, +B](x: A, y: B) {
 
 ###### Example
 
-The following variance annotation is illegal, since ´a´ appears
-in contravariant position in the parameter of `append`:
+The following variance annotation is illegal, since ´a´ appears in contravariant position in the parameter of `append`:
 
 ```scala
 abstract class Sequence[+A] {
@@ -554,8 +478,7 @@ abstract class Sequence[+A] {
 }
 ```
 
-The problem can be avoided by generalizing the type of `append`
-by means of a lower bound:
+The problem can be avoided by generalizing the type of `append` by means of a lower bound:
 
 ```scala
 abstract class Sequence[+A] {
@@ -571,11 +494,8 @@ abstract class OutputChannel[-A] {
 }
 ```
 
-With that annotation, we have that
-`OutputChannel[AnyRef]` conforms to `OutputChannel[String]`.
-That is, a
-channel on which one can write any object can substitute for a channel
-on which one can write only strings.
+With that annotation, we have that `OutputChannel[AnyRef]` conforms to `OutputChannel[String]`.
+That is, a channel on which one can write any object can substitute for a channel on which one can write only strings.
 
 ## Function Declarations and Definitions
 
@@ -595,47 +515,27 @@ ParamType          ::=  Type
                      |  Type ‘*’
 ```
 
-A _function declaration_ has the form `def ´f\,\mathit{psig}´: ´T´`, where
-´f´ is the function's name, ´\mathit{psig}´ is its parameter
-signature and ´T´ is its result type. A _function definition_
-`def ´f\,\mathit{psig}´: ´T´ = ´e´` also includes a _function body_ ´e´,
-i.e. an expression which defines the function's result.  A parameter
-signature consists of an optional type parameter clause `[´\mathit{tps}\,´]`,
-followed by zero or more value parameter clauses
-`(´\mathit{ps}_1´)...(´\mathit{ps}_n´)`.  Such a declaration or definition
-introduces a value with a (possibly polymorphic) method type whose
-parameter types and result type are as given.
-
-The type of the function body is expected to [conform](06-expressions.html#expression-typing)
-to the function's declared
-result type, if one is given. If the function definition is not
-recursive, the result type may be omitted, in which case it is
-determined from the packed type of the function body.
-
-A _type parameter clause_ ´\mathit{tps}´ consists of one or more
-[type declarations](#type-declarations-and-type-aliases), which introduce type
-parameters, possibly with bounds.  The scope of a type parameter includes
-the whole signature, including any of the type parameter bounds as
-well as the function body, if it is present.
-
-A _value parameter clause_ ´\mathit{ps}´ consists of zero or more formal
-parameter bindings such as `´x´: ´T´` or `´x: T = e´`, which bind value
-parameters and associate them with their types.
+A _function declaration_ has the form `def ´f\,\mathit{psig}´: ´T´`, where ´f´ is the function's name, ´\mathit{psig}´ is its parameter signature and ´T´ is its result type.
+A _function definition_ `def ´f\,\mathit{psig}´: ´T´ = ´e´` also includes a _function body_ ´e´, i.e. an expression which defines the function's result.
+A parameter signature consists of an optional type parameter clause `[´\mathit{tps}\,´]`, followed by zero or more value parameter clauses `(´\mathit{ps}_1´)...(´\mathit{ps}_n´)`.
+Such a declaration or definition introduces a value with a (possibly polymorphic) method type whose parameter types and result type are as given.
+
+The type of the function body is expected to [conform](06-expressions.html#expression-typing) to the function's declared result type, if one is given.
+If the function definition is not recursive, the result type may be omitted, in which case it is determined from the packed type of the function body.
+
+A _type parameter clause_ ´\mathit{tps}´ consists of one or more [type declarations](#type-declarations-and-type-aliases), which introduce type parameters, possibly with bounds.
+The scope of a type parameter includes the whole signature, including any of the type parameter bounds as well as the function body, if it is present.
+
+A _value parameter clause_ ´\mathit{ps}´ consists of zero or more formal parameter bindings such as `´x´: ´T´` or `´x: T = e´`, which bind value parameters and associate them with their types.
 
 ### Default Arguments
 
-Each value parameter
-declaration may optionally define a default argument. The default argument
-expression ´e´ is type-checked with an expected type ´T'´ obtained
-by replacing all occurrences of the function's type parameters in ´T´ by
-the undefined type.
-
-For every parameter ´p_{i,j}´ with a default argument a method named
-`´f\$´default´\$´n` is generated which computes the default argument
-expression. Here, ´n´ denotes the parameter's position in the method
-declaration. These methods are parametrized by the type parameter clause
-`[´\mathit{tps}\,´]` and all value parameter clauses
-`(´\mathit{ps}_1´)...(´\mathit{ps}_{i-1}´)` preceding ´p_{i,j}´.
+Each value parameter declaration may optionally define a default argument.
+The default argument expression ´e´ is type-checked with an expected type ´T'´ obtained by replacing all occurrences of the function's type parameters in ´T´ by the undefined type.
+
+For every parameter ´p_{i,j}´ with a default argument a method named `´f\$´default´\$´n` is generated which computes the default argument expression.
+Here, ´n´ denotes the parameter's position in the method declaration.
+These methods are parametrized by the type parameter clause `[´\mathit{tps}\,´]` and all value parameter clauses `(´\mathit{ps}_1´)...(´\mathit{ps}_{i-1}´)` preceding ´p_{i,j}´.
 The `´f\$´default´\$´n` methods are inaccessible for user programs.
 
 ###### Example
@@ -646,22 +546,19 @@ def compare[T](a: T = 0)(b: T = a) = (a == b)
 ```
 
 the default expression `0` is type-checked with an undefined expected
-type. When applying `compare()`, the default value `0` is inserted
-and `T` is instantiated to `Int`. The methods computing the default
-arguments have the form:
+type.
+When applying `compare()`, the default value `0` is inserted and `T` is instantiated to `Int`.
+The methods computing the default arguments have the form:
 
 ```scala
 def compare´\$´default´\$´1[T]: Int = 0
 def compare´\$´default´\$´2[T](a: T): T = a
 ```
 
-The scope of a formal value parameter name ´x´ comprises all subsequent
-parameter clauses, as well as the method return type and the function body, if
-they are given. Both type parameter names and value parameter names must
-be pairwise distinct.
+The scope of a formal value parameter name ´x´ comprises all subsequent parameter clauses, as well as the method return type and the function body, if they are given.
+Both type parameter names and value parameter names must be pairwise distinct.
 
-A default value which depends on earlier parameters uses the actual arguments
-if they are provided, not the default arguments.
+A default value which depends on earlier parameters uses the actual arguments if they are provided, not the default arguments.
 
 ```scala
 def f(a: Int = 0)(b: Int = a + 1) = b // OK
@@ -669,8 +566,7 @@ def f(a: Int = 0)(b: Int = a + 1) = b // OK
 f(10)()                               // returns 11 (not 1)
 ```
 
-If an [implicit argument](07-implicits.html#implicit-parameters)
-is not found by implicit search, it may be supplied using a default argument.
+If an [implicit argument](07-implicits.html#implicit-parameters) is not found by implicit search, it may be supplied using a default argument.
 
 ```scala
 implicit val i: Int = 2
@@ -684,16 +580,12 @@ f                                     // "hihi"
 ParamType          ::=  ‘=>’ Type
 ```
 
-The type of a value parameter may be prefixed by `=>`, e.g.
-`´x´: => ´T´`. The type of such a parameter is then the
-parameterless method type `=> ´T´`. This indicates that the
-corresponding argument is not evaluated at the point of function
-application, but instead is evaluated at each use within the
-function. That is, the argument is evaluated using _call-by-name_.
+The type of a value parameter may be prefixed by `=>`, e.g. `´x´: => ´T´`.
+The type of such a parameter is then the parameterless method type `=> ´T´`.
+This indicates that the corresponding argument is not evaluated at the point of function application, but instead is evaluated at each use within the function.
+That is, the argument is evaluated using _call-by-name_.
 
-The by-name modifier is disallowed for parameters of classes that
-carry a `val` or `var` prefix, including parameters of case
-classes for which a `val` prefix is implicitly generated.
+The by-name modifier is disallowed for parameters of classes that carry a `val` or `var` prefix, including parameters of case classes for which a `val` prefix is implicitly generated.
 
 ###### Example
 The declaration
@@ -702,8 +594,7 @@ The declaration
 def whileLoop (cond: => Boolean) (stat: => Unit): Unit
 ```
 
-indicates that both parameters of `whileLoop` are evaluated using
-call-by-name.
+indicates that both parameters of `whileLoop` are evaluated using call-by-name.
 
 ### Repeated Parameters
 
@@ -711,30 +602,16 @@ call-by-name.
 ParamType          ::=  Type ‘*’
 ```
 
-The last value parameter of a parameter section may be suffixed by
-`'*'`, e.g. `(..., ´x´:´T´*)`.  The type of such a
-_repeated_ parameter inside the method is then the sequence type
-`scala.Seq[´T´]`.  Methods with repeated parameters
-`´T´*` take a variable number of arguments of type ´T´.
-That is, if a method ´m´ with type
-`(´p_1:T_1, ..., p_n:T_n, p_s:S´*)´U´` is applied to arguments
-´(e_1, ..., e_k)´ where ´k \geq n´, then ´m´ is taken in that application
-to have type ´(p_1:T_1, ..., p_n:T_n, p_s:S, ..., p_{s'}:S)U´, with
-´k - n´ occurrences of type
-´S´ where any parameter names beyond ´p_s´ are fresh. The only exception to
-this rule is if the last argument is
-marked to be a _sequence argument_ via a `_*` type
-annotation. If ´m´ above is applied to arguments
-`(´e_1, ..., e_n, e'´: _*)`, then the type of ´m´ in
-that application is taken to be
-`(´p_1:T_1, ... , p_n:T_n,p_{s}:´scala.Seq[´S´])`.
-
-It is not allowed to define any default arguments in a parameter section
-with a repeated parameter.
+The last value parameter of a parameter section may be suffixed by `'*'`, e.g. `(..., ´x´:´T´*)`.
+The type of such a _repeated_ parameter inside the method is then the sequence type `scala.Seq[´T´]`.
+Methods with repeated parameters `´T´*` take a variable number of arguments of type ´T´.
+That is, if a method ´m´ with type `(´p_1:T_1, ..., p_n:T_n, p_s:S´*)´U´` is applied to arguments ´(e_1, ..., e_k)´ where ´k \geq n´, then ´m´ is taken in that application to have type ´(p_1:T_1, ..., p_n:T_n, p_s:S, ..., p_{s'}:S)U´, with ´k - n´ occurrences of type ´S´ where any parameter names beyond ´p_s´ are fresh. The only exception to this rule is if the last argument is marked to be a _sequence argument_ via a `_*` type annotation.
+If ´m´ above is applied to arguments `(´e_1, ..., e_n, e'´: _*)`, then the type of ´m´ in that application is taken to be `(´p_1:T_1, ... , p_n:T_n,p_{s}:´scala.Seq[´S´])`.
+
+It is not allowed to define any default arguments in a parameter section with a repeated parameter.
 
 ###### Example
-The following method definition computes the sum of the squares of a
-variable number of integer arguments.
+The following method definition computes the sum of the squares of a variable number of integer arguments.
 
 ```scala
 def sum(args: Int*) = {
@@ -744,8 +621,7 @@ def sum(args: Int*) = {
 }
 ```
 
-The following applications of this method yield `0`, `1`,
-`6`, in that order.
+The following applications of this method yield `0`, `1`, `6`, in that order.
 
 ```scala
 sum()
@@ -765,8 +641,7 @@ The following application of method `sum` is ill-formed:
 sum(xs)       // ***** error: expected: Int, found: List[Int]
 ```
 
-By contrast, the following application is well formed and yields again
-the result `6`:
+By contrast, the following application is well formed and yields again the result `6`:
 
 ```scala
 sum(xs: _*)
@@ -779,17 +654,12 @@ FunDcl   ::=  FunSig
 FunDef   ::=  FunSig [nl] ‘{’ Block ‘}’
 ```
 
-Special syntax exists for procedures, i.e. functions that return the
-`Unit` value `()`.
-A _procedure declaration_ is a function declaration where the result type
-is omitted. The result type is then implicitly completed to the
-`Unit` type. E.g., `def ´f´(´\mathit{ps}´)` is equivalent to
-`def ´f´(´\mathit{ps}´): Unit`.
+Special syntax exists for procedures, i.e. functions that return the `Unit` value `()`.
+A _procedure declaration_ is a function declaration where the result type is omitted.
+The result type is then implicitly completed to the `Unit` type. E.g., `def ´f´(´\mathit{ps}´)` is equivalent to `def ´f´(´\mathit{ps}´): Unit`.
 
-A _procedure definition_ is a function definition where the result type
-and the equals sign are omitted; its defining expression must be a block.
-E.g., `def ´f´(´\mathit{ps}´) {´\mathit{stats}´}` is equivalent to
-`def ´f´(´\mathit{ps}´): Unit = {´\mathit{stats}´}`.
+A _procedure definition_ is a function definition where the result type and the equals sign are omitted; its defining expression must be a block.
+E.g., `def ´f´(´\mathit{ps}´) {´\mathit{stats}´}` is equivalent to `def ´f´(´\mathit{ps}´): Unit = {´\mathit{stats}´}`.
 
 ###### Example
 Here is a declaration and a definition of a procedure named `write`:
@@ -816,14 +686,10 @@ object Terminal extends Writer {
 
 ### Method Return Type Inference
 
-A class member definition ´m´ that overrides some other function ´m'´
-in a base class of ´C´ may leave out the return type, even if it is
-recursive. In this case, the return type ´R'´ of the overridden
-function ´m'´, seen as a member of ´C´, is taken as the return type of
-´m´ for each recursive invocation of ´m´. That way, a type ´R´ for the
-right-hand side of ´m´ can be determined, which is then taken as the
-return type of ´m´. Note that ´R´ may be different from ´R'´, as long
-as ´R´ conforms to ´R'´.
+A class member definition ´m´ that overrides some other function ´m'´ in a base class of ´C´ may leave out the return type, even if it is recursive.
+In this case, the return type ´R'´ of the overridden function ´m'´, seen as a member of ´C´, is taken as the return type of ´m´ for each recursive invocation of ´m´.
+That way, a type ´R´ for the right-hand side of ´m´ can be determined, which is then taken as the return type of ´m´.
+Note that ´R´ may be different from ´R'´, as long as ´R´ conforms to ´R'´.
 
 ###### Example
 Assume the following definitions:
@@ -837,8 +703,7 @@ class C extends I {
 }
 ```
 
-Here, it is OK to leave out the result type of `factorial`
-in `C`, even though the method is recursive.
+Here, it is OK to leave out the result type of `factorial` in `C`, even though the method is recursive.
 
 <!-- ## Overloaded Definitions
 \label{sec:overloaded-defs}
@@ -867,60 +732,37 @@ ImportSelectors ::= ‘{’ {ImportSelector ‘,’}
 ImportSelector  ::= id [‘=>’ id | ‘=>’ ‘_’]
 ```
 
-An import clause has the form `import ´p´.´I´` where ´p´ is a
-[stable identifier](03-types.html#paths) and ´I´ is an import expression.
-The import expression determines a set of names of importable members of ´p´
-which are made available without qualification.  A member ´m´ of ´p´ is
-_importable_ if it is [accessible](05-classes-and-objects.html#modifiers).
+An import clause has the form `import ´p´.´I´` where ´p´ is a [stable identifier](03-types.html#paths) and ´I´ is an import expression.
+The import expression determines a set of names of importable members of ´p´ which are made available without qualification.
+A member ´m´ of ´p´ is _importable_ if it is [accessible](05-classes-and-objects.html#modifiers).
 The most general form of an import expression is a list of _import selectors_
 
 ```scala
 { ´x_1´ => ´y_1, ..., x_n´ => ´y_n´, _ }
 ```
 
-for ´n \geq 0´, where the final wildcard `‘_’` may be absent.  It
-makes available each importable member `´p´.´x_i´` under the unqualified name
-´y_i´. I.e. every import selector `´x_i´ => ´y_i´` renames
-`´p´.´x_i´` to
-´y_i´.  If a final wildcard is present, all importable members ´z´ of
-´p´ other than `´x_1, ..., x_n,y_1, ..., y_n´` are also made available
-under their own unqualified names.
-
-Import selectors work in the same way for type and term members. For
-instance, an import clause `import ´p´.{´x´ => ´y\,´}` renames the term
-name `´p´.´x´` to the term name ´y´ and the type name `´p´.´x´`
-to the type name ´y´. At least one of these two names must
-reference an importable member of ´p´.
-
-If the target in an import selector is a wildcard, the import selector
-hides access to the source member. For instance, the import selector
-`´x´ => _` “renames” ´x´ to the wildcard symbol (which is
-unaccessible as a name in user programs), and thereby effectively
-prevents unqualified access to ´x´. This is useful if there is a
-final wildcard in the same import selector list, which imports all
-members not mentioned in previous import selectors.
-
-The scope of a binding introduced by an import-clause starts
-immediately after the import clause and extends to the end of the
-enclosing block, template, package clause, or compilation unit,
-whichever comes first.
-
-Several shorthands exist. An import selector may be just a simple name
-´x´. In this case, ´x´ is imported without renaming, so the
-import selector is equivalent to `´x´ => ´x´`. Furthermore, it is
-possible to replace the whole import selector list by a single
-identifier or wildcard. The import clause `import ´p´.´x´` is
-equivalent to `import ´p´.{´x\,´}`, i.e. it makes available without
-qualification the member ´x´ of ´p´. The import clause
-`import ´p´._` is equivalent to
-`import ´p´.{_}`,
-i.e. it makes available without qualification all members of ´p´
-(this is analogous to `import ´p´.*` in Java).
-
-An import clause with multiple import expressions
-`import ´p_1´.´I_1, ..., p_n´.´I_n´` is interpreted as a
-sequence of import clauses
-`import ´p_1´.´I_1´; ...; import ´p_n´.´I_n´`.
+for ´n \geq 0´, where the final wildcard `‘_’` may be absent.
+It makes available each importable member `´p´.´x_i´` under the unqualified name ´y_i´. I.e. every import selector `´x_i´ => ´y_i´` renames `´p´.´x_i´` to
+´y_i´.
+If a final wildcard is present, all importable members ´z´ of ´p´ other than `´x_1, ..., x_n,y_1, ..., y_n´` are also made available under their own unqualified names.
+
+Import selectors work in the same way for type and term members.
+For instance, an import clause `import ´p´.{´x´ => ´y\,´}` renames the term
+name `´p´.´x´` to the term name ´y´ and the type name `´p´.´x´` to the type name ´y´.
+At least one of these two names must reference an importable member of ´p´.
+
+If the target in an import selector is a wildcard, the import selector hides access to the source member.
+For instance, the import selector `´x´ => _` “renames” ´x´ to the wildcard symbol (which is unaccessible as a name in user programs), and thereby effectively prevents unqualified access to ´x´.
+This is useful if there is a final wildcard in the same import selector list, which imports all members not mentioned in previous import selectors.
+
+The scope of a binding introduced by an import-clause starts immediately after the import clause and extends to the end of the enclosing block, template, package clause, or compilation unit, whichever comes first.
+
+Several shorthands exist. An import selector may be just a simple name ´x´.
+In this case, ´x´ is imported without renaming, so the import selector is equivalent to `´x´ => ´x´`.
+Furthermore, it is possible to replace the whole import selector list by a single identifier or wildcard.
+The import clause `import ´p´.´x´` is equivalent to `import ´p´.{´x\,´}`, i.e. it makes available without qualification the member ´x´ of ´p´. The import clause `import ´p´._` is equivalent to `import ´p´.{_}`, i.e. it makes available without qualification all members of ´p´ (this is analogous to `import ´p´.*` in Java).
+
+An import clause with multiple import expressions `import ´p_1´.´I_1, ..., p_n´.´I_n´` is interpreted as a sequence of import clauses `import ´p_1´.´I_1´; ...; import ´p_n´.´I_n´`.
 
 ###### Example
 Consider the object definition:
diff --git a/docs/_spec/05-classes-and-objects.md b/docs/_spec/05-classes-and-objects.md
index 88ca4de54692..d89fcfb115ff 100644
--- a/docs/_spec/05-classes-and-objects.md
+++ b/docs/_spec/05-classes-and-objects.md
@@ -12,8 +12,7 @@ TmplDef          ::= [‘case’] ‘class’ ClassDef
                   |  ‘trait’ TraitDef
 ```
 
-[Classes](#class-definitions) and [objects](#object-definitions)
-are both defined in terms of _templates_.
+[Classes](#class-definitions) and [objects](#object-definitions) are both defined in terms of _templates_.
 
 ## Templates
 
@@ -27,70 +26,40 @@ SelfType        ::=  id [‘:’ Type] ‘=>’
                  |   this ‘:’ Type ‘=>’
 ```
 
-A _template_ defines the type signature, behavior and initial state of a
-trait or class of objects or of a single object. Templates form part of
-instance creation expressions, class definitions, and object
-definitions.  A template
-`´sc´ with ´mt_1´ with ... with ´mt_n´ { ´\mathit{stats}´ }`
-consists of a constructor invocation ´sc´
-which defines the template's _superclass_, trait references
-`´mt_1, ..., mt_n´` ´(n \geq 0)´, which define the
-template's _traits_, and a statement sequence ´\mathit{stats}´ which
-contains initialization code and additional member definitions for the
-template.
+A _template_ defines the type signature, behavior and initial state of a trait or class of objects or of a single object.
+Templates form part of instance creation expressions, class definitions, and object definitions.
+A template `´sc´ with ´mt_1´ with ... with ´mt_n´ { ´\mathit{stats}´ }` consists of a constructor invocation ´sc´ which defines the template's _superclass_, trait references `´mt_1, ..., mt_n´` ´(n \geq 0)´, which define the template's _traits_, and a statement sequence ´\mathit{stats}´ which contains initialization code and additional member definitions for the template.
 
 Each trait reference ´mt_i´ must denote a [trait](#traits).
-By contrast, the superclass constructor ´sc´ normally refers to a
-class which is not a trait. It is possible to write a list of
-parents that starts with a trait reference, e.g.
-`´mt_1´ with ... with ´mt_n´`. In that case the list
-of parents is implicitly extended to include the supertype of ´mt_1´
-as the first parent type. The new supertype must have at least one
-constructor that does not take parameters.  In the following, we will
-always assume that this implicit extension has been performed, so that
-the first parent class of a template is a regular superclass
-constructor, not a trait reference.
-
-The list of parents of a template must be well-formed. This means that
-the class denoted by the superclass constructor ´sc´ must be a
-subclass of the superclasses of all the traits ´mt_1, ..., mt_n´.
-In other words, the non-trait classes inherited by a template form a
-chain in the inheritance hierarchy which starts with the template's
-superclass.
-
-The _least proper supertype_ of a template is the class type or
-[compound type](03-types.html#compound-types) consisting of all its parent
-class types.
-
-The statement sequence ´\mathit{stats}´ contains member definitions that
-define new members or overwrite members in the parent classes.  If the
-template forms part of an abstract class or trait definition, the
-statement part ´\mathit{stats}´ may also contain declarations of abstract
-members. If the template forms part of a concrete class definition,
-´\mathit{stats}´ may still contain declarations of abstract type members, but
-not of abstract term members.  Furthermore, ´\mathit{stats}´ may in any case
-also contain expressions; these are executed in the order they are
-given as part of the initialization of a template.
-
-The sequence of template statements may be prefixed with a formal
-parameter definition and an arrow, e.g. `´x´ =>`, or
-`´x´:´T´ =>`.  If a formal parameter is given, it can be
-used as an alias for the reference `this` throughout the
-body of the template.
-If the formal parameter comes with a type ´T´, this definition affects
-the _self type_ ´S´ of the underlying class or object as follows:  Let ´C´ be the type
-of the class or trait or object defining the template.
-If a type ´T´ is given for the formal self parameter, ´S´
-is the greatest lower bound of ´T´ and ´C´.
+By contrast, the superclass constructor ´sc´ normally refers to a class which is not a trait.
+It is possible to write a list of parents that starts with a trait reference, e.g. `´mt_1´ with ... with ´mt_n´`.
+In that case the list of parents is implicitly extended to include the supertype of ´mt_1´ as the first parent type.
+The new supertype must have at least one constructor that does not take parameters.
+In the following, we will always assume that this implicit extension has been performed, so that the first parent class of a template is a regular superclass constructor, not a trait reference.
+
+The list of parents of a template must be well-formed.
+This means that the class denoted by the superclass constructor ´sc´ must be a subclass of the superclasses of all the traits ´mt_1, ..., mt_n´.
+In other words, the non-trait classes inherited by a template form a chain in the inheritance hierarchy which starts with the template's superclass.
+
+The _least proper supertype_ of a template is the class type or [compound type](03-types.html#compound-types) consisting of all its parent class types.
+
+The statement sequence ´\mathit{stats}´ contains member definitions that define new members or overwrite members in the parent classes.
+If the template forms part of an abstract class or trait definition, the statement part ´\mathit{stats}´ may also contain declarations of abstract members.
+If the template forms part of a concrete class definition, ´\mathit{stats}´ may still contain declarations of abstract type members, but not of abstract term members.
+Furthermore, ´\mathit{stats}´ may in any case also contain expressions; these are executed in the order they are given as part of the initialization of a template.
+
+The sequence of template statements may be prefixed with a formal parameter definition and an arrow, e.g. `´x´ =>`, or `´x´:´T´ =>`.
+If a formal parameter is given, it can be used as an alias for the reference `this` throughout the body of the template.
+If the formal parameter comes with a type ´T´, this definition affects the _self type_ ´S´ of the underlying class or object as follows:
+Let ´C´ be the type of the class or trait or object defining the template.
+If a type ´T´ is given for the formal self parameter, ´S´ is the greatest lower bound of ´T´ and ´C´.
 If no type ´T´ is given, ´S´ is just ´C´.
 Inside the template, the type of `this` is assumed to be ´S´.
 
-The self type of a class or object must conform to the self types of
-all classes which are inherited by the template ´t´.
+The self type of a class or object must conform to the self types of all classes which are inherited by the template ´t´.
 
-A second form of self type annotation reads just
-`this: ´S´ =>`. It prescribes the type ´S´ for `this`
-without introducing an alias name for it.
+A second form of self type annotation reads just `this: ´S´ =>`.
+It prescribes the type ´S´ for `this` without introducing an alias name for it.
 
 ###### Example
 Consider the following class definitions:
@@ -117,30 +86,21 @@ A template may have a Java class as its superclass and Java interfaces as its mi
 
 Consider a template `´sc´ with ´mt_1´ with ´mt_n´ { ´\mathit{stats}´ }`.
 
-If this is the template of a [trait](#traits) then its _mixin-evaluation_
-consists of an evaluation of the statement sequence ´\mathit{stats}´.
+If this is the template of a [trait](#traits) then its _mixin-evaluation_ consists of an evaluation of the statement sequence ´\mathit{stats}´.
 
-If this is not a template of a trait, then its _evaluation_
-consists of the following steps.
+If this is not a template of a trait, then its _evaluation_ consists of the following steps.
 
 - First, the superclass constructor ´sc´ is
   [evaluated](#constructor-invocations).
-- Then, all base classes in the template's [linearization](#class-linearization)
-  up to the template's superclass denoted by ´sc´ are
-  mixin-evaluated. Mixin-evaluation happens in reverse order of
-  occurrence in the linearization.
+- Then, all base classes in the template's [linearization](#class-linearization) up to the template's superclass denoted by ´sc´ are mixin-evaluated.
+Mixin-evaluation happens in reverse order of occurrence in the linearization.
 - Finally, the statement sequence ´\mathit{stats}\,´ is evaluated.
 
 ###### Delayed Initialization
-This statement sequence constitutes the initialization code for an object
-or class after the superclass constructor invocation and the mixin-evaluation
-of the template's base classes as described above.
-Normally, this code is passed to a special hook, inaccessible to user code,
-which simply executes it.
+This statement sequence constitutes the initialization code for an object or class after the superclass constructor invocation and the mixin-evaluation of the template's base classes as described above.
+Normally, this code is passed to a special hook, inaccessible to user code, which simply executes it.
 
-However, in objects and classes (but not traits) which extend `scala.DelayedInit`,
-the initialization code is passed to a `delayedInit` method which can be
-overridden to implement arbitrary semantics.
+However, in objects and classes (but not traits) which extend `scala.DelayedInit`, the initialization code is passed to a `delayedInit` method which can be overridden to implement arbitrary semantics.
 
 ```scala
 def delayedInit(body: => Unit): Unit
@@ -152,52 +112,35 @@ def delayedInit(body: => Unit): Unit
 Constr  ::=  AnnotType {‘(’ [Exprs] ‘)’}
 ```
 
-Constructor invocations define the type, members, and initial state of
-objects created by an instance creation expression, or of parts of an
-object's definition which are inherited by a class or object
-definition. A constructor invocation is a method application
-`´x´.´c´[´\mathit{targs}´](´\mathit{args}_1´)...(´\mathit{args}_n´)`, where ´x´ is a
-[stable identifier](03-types.html#paths), ´c´ is a type name which either designates a
-class or defines an alias type for one, ´\mathit{targs}´ is a type argument
-list, ´\mathit{args}_1, ..., \mathit{args}_n´ are argument lists, and there is a
-constructor of that class which is [applicable](06-expressions.html#method-applications)
-to the given arguments. If the constructor invocation uses named or
-default arguments, it is transformed into a block expression using the
-same transformation as described [here](sec:named-default).
-
-The prefix `´x´.` can be omitted.  A type argument list
-can be given only if the class ´c´ takes type parameters.  Even then
-it can be omitted, in which case a type argument list is synthesized
-using [local type inference](06-expressions.html#local-type-inference). If no explicit
-arguments are given, an empty list `()` is implicitly supplied.
-
-An evaluation of a constructor invocation
-`´x´.´c´[´\mathit{targs}´](´\mathit{args}_1´)...(´\mathit{args}_n´)`
-consists of the following steps:
+Constructor invocations define the type, members, and initial state of objects created by an instance creation expression, or of parts of an object's definition which are inherited by a class or object definition.
+A constructor invocation is a method application `´x´.´c´[´\mathit{targs}´](´\mathit{args}_1´)...(´\mathit{args}_n´)`, where ´x´ is a [stable identifier](03-types.html#paths), ´c´ is a type name which either designates a class or defines an alias type for one, ´\mathit{targs}´ is a type argument list, ´\mathit{args}_1, ..., \mathit{args}_n´ are argument lists, and there is a constructor of that class which is [applicable](06-expressions.html#method-applications) to the given arguments.
+If the constructor invocation uses named or default arguments, it is transformed into a block expression using the same transformation as described [here](sec:named-default).
+
+The prefix `´x´.` can be omitted.
+A type argument list can be given only if the class ´c´ takes type parameters.
+Even then it can be omitted, in which case a type argument list is synthesized using [local type inference](06-expressions.html#local-type-inference).
+If no explicit arguments are given, an empty list `()` is implicitly supplied.
+
+An evaluation of a constructor invocation `´x´.´c´[´\mathit{targs}´](´\mathit{args}_1´)...(´\mathit{args}_n´)` consists of the following steps:
 
 - First, the prefix ´x´ is evaluated.
-- Then, the arguments ´\mathit{args}_1, ..., \mathit{args}_n´ are evaluated from
-  left to right.
-- Finally, the class being constructed is initialized by evaluating the
-  template of the class referred to by ´c´.
+- Then, the arguments ´\mathit{args}_1, ..., \mathit{args}_n´ are evaluated from left to right.
+- Finally, the class being constructed is initialized by evaluating the template of the class referred to by ´c´.
 
 ### Class Linearization
 
-The classes reachable through transitive closure of the direct
-inheritance relation from a class ´C´ are called the _base classes_ of ´C´.  Because of mixins, the inheritance relationship
-on base classes forms in general a directed acyclic graph. A
-linearization of this graph is defined as follows.
+The classes reachable through transitive closure of the direct inheritance relation from a class ´C´ are called the _base classes_ of ´C´.
+Because of mixins, the inheritance relationship on base classes forms in general a directed acyclic graph.
+A linearization of this graph is defined as follows.
 
 ###### Definition: linearization
-Let ´C´ be a class with template
-´C_1´ with ... with ´C_n´ { ´\mathit{stats}´ }`.
+Let ´C´ be a class with template ´C_1´ with ... with ´C_n´ { ´\mathit{stats}´ }`.
 The _linearization_ of ´C´, ´\mathcal{L}(C)´ is defined as follows:
 $$
 \mathcal{L}(C) = C, \mathcal{L}(C_n) \; \vec{+} \; ... \; \vec{+} \; \mathcal{L}(C_1)
 $$
 
-Here ´\vec{+}´ denotes concatenation where elements of the right operand
-replace identical elements of the left operand:
+Here ´\vec{+}´ denotes concatenation where elements of the right operand replace identical elements of the left operand:
 
 $$
 \begin{array}{lcll}
@@ -222,11 +165,8 @@ Then the linearization of class `Iter` is
 { Iter, RichIterator, StringIterator, AbsIterator, AnyRef, Any }
 ```
 
-Note that the linearization of a class refines the inheritance
-relation: if ´C´ is a subclass of ´D´, then ´C´ precedes ´D´ in any
-linearization where both ´C´ and ´D´ occur.
-[Linearization](#definition:-linearization) also satisfies the property that
-a linearization of a class always contains the linearization of its direct superclass as a suffix.
+Note that the linearization of a class refines the inheritance relation: if ´C´ is a subclass of ´D´, then ´C´ precedes ´D´ in any linearization where both ´C´ and ´D´ occur.
+[Linearization](#definition:-linearization) also satisfies the property that a linearization of a class always contains the linearization of its direct superclass as a suffix.
 
 For instance, the linearization of `StringIterator` is
 
@@ -246,28 +186,18 @@ which is not a suffix of the linearization of `Iter`.
 
 ### Class Members
 
-A class ´C´ defined by a template `´C_1´ with ... with ´C_n´ { ´\mathit{stats}´ }`
-can define members in its statement sequence
-´\mathit{stats}´ and can inherit members from all parent classes.  Scala
-adopts Java and C\#'s conventions for static overloading of
-methods. It is thus possible that a class defines and/or inherits
-several methods with the same name.  To decide whether a defined
-member of a class ´C´ overrides a member of a parent class, or whether
-the two co-exist as overloaded variants in ´C´, Scala uses the
-following definition of _matching_ on members:
+A class ´C´ defined by a template `´C_1´ with ... with ´C_n´ { ´\mathit{stats}´ }` can define members in its statement sequence ´\mathit{stats}´ and can inherit members from all parent classes.
+Scala adopts Java and C\#'s conventions for static overloading of methods.
+It is thus possible that a class defines and/or inherits several methods with the same name.
+To decide whether a defined member of a class ´C´ overrides a member of a parent class, or whether the two co-exist as overloaded variants in ´C´, Scala uses the following definition of _matching_ on members:
 
 ###### Definition: matching
-A member definition ´M´ _matches_ a member definition ´M'´, if ´M´
-and ´M'´ bind the same name, and one of following holds.
+A member definition ´M´ _matches_ a member definition ´M'´, if ´M´ and ´M'´ bind the same name, and one of following holds.
 
 1. Neither ´M´ nor ´M'´ is a method definition.
 2. ´M´ and ´M'´ define both monomorphic methods with equivalent argument types.
-3. ´M´ defines a parameterless method and ´M'´ defines a method
-   with an empty parameter list `()` or _vice versa_.
-4. ´M´ and ´M'´ define both polymorphic methods with
-   equal number of argument types ´\overline T´, ´\overline T'´
-   and equal numbers of type parameters
-   ´\overline t´, ´\overline t'´, say, and  ´\overline T' = [\overline t'/\overline t]\overline T´.
+3. ´M´ defines a parameterless method and ´M'´ defines a method with an empty parameter list `()` or _vice versa_.
+4. ´M´ and ´M'´ define both polymorphic methods with equal number of argument types ´\overline T´, ´\overline T'´ and equal numbers of type parameters ´\overline t´, ´\overline t'´, say, and  ´\overline T' = [\overline t'/\overline t]\overline T´.
 
 <!--
 every argument type
@@ -276,33 +206,20 @@ every argument type
 -->
 
 Member definitions fall into two categories: concrete and abstract.
-Members of class ´C´ are either _directly defined_ (i.e. they appear in
-´C´'s statement sequence ´\mathit{stats}´) or they are _inherited_.  There are two rules
-that determine the set of members of a class, one for each category:
-
-A _concrete member_ of a class ´C´ is any concrete definition ´M´ in
-some class ´C_i \in \mathcal{L}(C)´, except if there is a preceding class
-´C_j \in \mathcal{L}(C)´ where ´j < i´ which directly defines a concrete
-member ´M'´ matching ´M´.
-
-An _abstract member_ of a class ´C´ is any abstract definition ´M´
-in some class ´C_i \in \mathcal{L}(C)´, except if ´C´ contains already a
-concrete member ´M'´ matching ´M´, or if there is a preceding class
-´C_j \in \mathcal{L}(C)´ where ´j < i´ which directly defines an abstract
-member ´M'´ matching ´M´.
-
-This definition also determines the [overriding](#overriding) relationships
-between matching members of a class ´C´ and its parents.
+Members of class ´C´ are either _directly defined_ (i.e. they appear in ´C´'s statement sequence ´\mathit{stats}´) or they are _inherited_.
+There are two rules that determine the set of members of a class, one for each category:
+
+A _concrete member_ of a class ´C´ is any concrete definition ´M´ in some class ´C_i \in \mathcal{L}(C)´, except if there is a preceding clas ´C_j \in \mathcal{L}(C)´ where ´j < i´ which directly defines a concrete member ´M'´ matching ´M´.
+
+An _abstract member_ of a class ´C´ is any abstract definition ´M´ in some class ´C_i \in \mathcal{L}(C)´, except if ´C´ contains already a concrete member ´M'´ matching ´M´, or if there is a preceding class ´C_j \in \mathcal{L}(C)´ where ´j < i´ which directly defines an abstract member ´M'´ matching ´M´.
+
+This definition also determines the [overriding](#overriding) relationships between matching members of a class ´C´ and its parents.
 First, a concrete definition always overrides an abstract definition.
-Second, for definitions ´M´ and ´M´' which are both concrete or both abstract,
-´M´ overrides ´M'´ if ´M´ appears in a class that precedes (in the
-linearization of ´C´) the class in which ´M'´ is defined.
+Second, for definitions ´M´ and ´M´' which are both concrete or both abstract, ´M´ overrides ´M'´ if ´M´ appears in a class that precedes (in the linearization of ´C´) the class in which ´M'´ is defined.
 
-It is an error if a template directly defines two matching members. It
-is also an error if a template contains two members (directly defined
-or inherited) with the same name and the same [erased type](03-types.html#type-erasure).
-Finally, a template is not allowed to contain two methods (directly
-defined or inherited) with the same name which both define default arguments.
+It is an error if a template directly defines two matching members.
+It is also an error if a template contains two members (directly defined or inherited) with the same name and the same [erased type](03-types.html#type-erasure).
+Finally, a template is not allowed to contain two methods (directly defined or inherited) with the same name which both define default arguments.
 
 ###### Example
 Consider the trait definitions:
@@ -314,64 +231,46 @@ trait C extends A { override def f: Int = 4 ; def g: Int }
 trait D extends B with C { def h: Int }
 ```
 
-Then trait `D` has a directly defined abstract member `h`. It
-inherits member `f` from trait `C` and member `g` from
-trait `B`.
+Then trait `D` has a directly defined abstract member `h`.
+It inherits member `f` from trait `C` and member `g` from trait `B`.
 
 ### Overriding
 
 <!-- TODO: Explain that classes cannot override each other -->
 
-A member ´M´ of class ´C´ that [matches](#class-members)
-a non-private member ´M'´ of a
-base class of ´C´ is said to _override_ that member.  In this case
-the binding of the overriding member ´M´ must [subsume](03-types.html#conformance)
-the binding of the overridden member ´M'´.
-Furthermore, the following restrictions on modifiers apply to ´M´ and
-´M'´:
+A member ´M´ of class ´C´ that [matches](#class-members) a non-private member ´M'´ of a base class of ´C´ is said to _override_ that member.
+In this case the binding of the overriding member ´M´ must [subsume](03-types.html#conformance) the binding of the overridden member ´M'´.
+Furthermore, the following restrictions on modifiers apply to ´M´ and ´M'´:
 
 - ´M'´ must not be labeled `final`.
 - ´M´ must not be [`private`](#modifiers).
-- If ´M´ is labeled `private[´C´]` for some enclosing class or package ´C´,
-  then ´M'´ must be labeled `private[´C'´]` for some class or package ´C'´ where
-  ´C'´ equals ´C´ or ´C'´ is contained in ´C´.
+- If ´M´ is labeled `private[´C´]` for some enclosing class or package ´C´, then ´M'´ must be labeled `private[´C'´]` for some class or package ´C'´ where ´C'´ equals ´C´ or ´C'´ is contained in ´C´.
 
 <!-- TODO: check whether this is accurate -->
-- If ´M´ is labeled `protected`, then ´M'´ must also be
-  labeled `protected`.
+- If ´M´ is labeled `protected`, then ´M'´ must also be labeled `protected`.
 - If ´M'´ is not an abstract member, then ´M´ must be labeled `override`.
-  Furthermore, one of two possibilities must hold:
+Furthermore, one of two possibilities must hold:
     - either ´M´ is defined in a subclass of the class where is ´M'´ is defined,
-    - or both ´M´ and ´M'´ override a third member ´M''´ which is defined
-      in a base class of both the classes containing ´M´ and ´M'´
-- If ´M'´ is [incomplete](#modifiers) in ´C´ then ´M´ must be
-  labeled `abstract override`.
-- If ´M´ and ´M'´ are both concrete value definitions, then either none
-  of them is marked `lazy` or both must be marked `lazy`.
+    - or both ´M´ and ´M'´ override a third member ´M''´ which is defined in a base class of both the classes containing ´M´ and ´M'´
+- If ´M'´ is [incomplete](#modifiers) in ´C´ then ´M´ must be labeled `abstract override`.
+- If ´M´ and ´M'´ are both concrete value definitions, then either none of them is marked `lazy` or both must be marked `lazy`.
 
 - A stable member can only be overridden by a stable member.
-  For example, this is not allowed:
+For example, this is not allowed:
 
 ```scala
 class X { val stable = 1}
 class Y extends X { override var stable = 1 } // error
 ```
 
-Another restriction applies to abstract type members: An abstract type
-member with a [volatile type](03-types.html#volatile-types) as its upper
-bound may not override an abstract type member which does not have a
-volatile upper bound.
+Another restriction applies to abstract type members:
+An abstract type member with a [volatile type](03-types.html#volatile-types) as its upper bound may not override an abstract type member which does not have a volatile upper bound.
 
-A special rule concerns parameterless methods. If a parameterless
-method defined as `def ´f´: ´T´ = ...` or `def ´f´ = ...` overrides a method of
-type ´()T'´ which has an empty parameter list, then ´f´ is also
-assumed to have an empty parameter list.
+A special rule concerns parameterless methods.
+If a parameterless method defined as `def ´f´: ´T´ = ...` or `def ´f´ = ...` overrides a method of type ´()T'´ which has an empty parameter list, then ´f´ is also assumed to have an empty parameter list.
 
-An overriding method inherits all default arguments from the definition
-in the superclass. By specifying default arguments in the overriding method
-it is possible to add new defaults (if the corresponding parameter in the
-superclass does not have a default) or to override the defaults of the
-superclass (otherwise).
+An overriding method inherits all default arguments from the definition in the superclass.
+By specifying default arguments in the overriding method it is possible to add new defaults (if the corresponding parameter in the superclass does not have a default) or to override the defaults of the superclass (otherwise).
 
 ###### Example
 
@@ -384,12 +283,9 @@ trait B extends Root { type T <: B }
 trait C extends A with B
 ```
 
-Then the class definition `C` is not well-formed because the
-binding of `T` in `C` is
-`type T <: B`,
-which fails to subsume the binding `type T <: A` of `T`
-in type `A`. The problem can be solved by adding an overriding
-definition of type `T` in class `C`:
+Then the class definition `C` is not well-formed because the binding of `T` in `C` is `type T <: B`, which fails to subsume the binding `type T <: A` of `T`
+in type `A`.
+The problem can be solved by adding an overriding definition of type `T` in class `C`:
 
 ```scala
 class C extends A with B { type T <: C }
@@ -397,18 +293,15 @@ class C extends A with B { type T <: C }
 
 ### Inheritance Closure
 
-Let ´C´ be a class type. The _inheritance closure_ of ´C´ is the
-smallest set ´\mathscr{S}´ of types such that
+Let ´C´ be a class type.
+The _inheritance closure_ of ´C´ is the smallest set ´\mathscr{S}´ of types such that
 
 - ´C´ is in ´\mathscr{S}´.
-- If ´T´ is in ´\mathscr{S}´, then every type ´T'´ which forms syntactically
-  a part of ´T´ is also in ´\mathscr{S}´.
-- If ´T´ is a class type in ´\mathscr{S}´, then all [parents](#templates)
-  of ´T´ are also in ´\mathscr{S}´.
+- If ´T´ is in ´\mathscr{S}´, then every type ´T'´ which forms syntactically a part of ´T´ is also in ´\mathscr{S}´.
+- If ´T´ is a class type in ´\mathscr{S}´, then all [parents](#templates) of ´T´ are also in ´\mathscr{S}´.
 
-It is a static error if the inheritance closure of a class type
-consists of an infinite number of types. (This restriction is
-necessary to make subtyping decidable[^kennedy]).
+It is a static error if the inheritance closure of a class type consists of an infinite number of types.
+(This restriction is necessary to make subtyping decidable[^kennedy]).
 
 [^kennedy]: Kennedy, Pierce. [On Decidability of Nominal Subtyping with Variance.]( https://research.microsoft.com/pubs/64041/fool2007.pdf) in FOOL 2007
 
@@ -419,9 +312,8 @@ EarlyDefs         ::= ‘{’ [EarlyDef {semi EarlyDef}] ‘}’ ‘with’
 EarlyDef          ::=  {Annotation} {Modifier} PatVarDef
 ```
 
-A template may start with an _early field definition_ clause,
-which serves to define certain field values before the supertype
-constructor is called. In a template
+A template may start with an _early field definition_ clause, which serves to define certain field values before the supertype constructor is called.
+In a template
 
 ```scala
 { val ´p_1´: ´T_1´ = ´e_1´
@@ -430,33 +322,21 @@ constructor is called. In a template
 } with ´sc´ with ´mt_1´ with ´mt_n´ { ´\mathit{stats}´ }
 ```
 
-The initial pattern definitions of ´p_1 , \ldots , p_n´ are called
-_early definitions_. They define fields
-which form part of the template. Every early definition must define
-at least one variable.
-
-An early definition is type-checked and evaluated in the scope which
-is in effect just before the template being defined, augmented by any
-type parameters of the enclosing class and by any early definitions
-preceding the one being defined. In particular, any reference to
-`this` in an early definition refers
-to the identity of `this` just outside the template. Consequently, it
-is impossible for an early definition to refer to the object being
-constructed by the template, or to refer to one of its fields and
-methods, except for any other preceding early definition in the same
-section. Furthermore, references to preceding early definitions
-always refer to the value that's defined there and do not take into account
-overriding definitions. In other words, a block of early definitions
-is evaluated exactly as if it were a local block containing a number of value
-definitions.
-
-Early definitions are evaluated
-before the superclass constructor of the template is called,
-in the order they are defined.
+The initial pattern definitions of ´p_1 , \ldots , p_n´ are called _early definitions_.
+They define fields which form part of the template.
+Every early definition must define at least one variable.
+
+An early definition is type-checked and evaluated in the scope which is in effect just before the template being defined, augmented by any type parameters of the enclosing class and by any early definitions preceding the one being defined.
+In particular, any reference to `this` in an early definition refers to the identity of `this` just outside the template.
+Consequently, it is impossible for an early definition to refer to the object being constructed by the template, or to refer to one of its fields and methods, except for any other preceding early definition in the same section.
+Furthermore, references to preceding early definitions always refer to the value that's defined there and do not take into account overriding definitions.
+In other words, a block of early definitions is evaluated exactly as if it were a local block containing a number of value definitions.
+
+Early definitions are evaluated before the superclass constructor of the template is called, in the order they are defined.
 
 ###### Example
-Early definitions are particularly useful for
-traits, which do not have normal constructor parameters. Example:
+Early definitions are particularly useful for traits, which do not have normal constructor parameters.
+Example:
 
 ```scala
 trait Greeting {
@@ -470,14 +350,11 @@ class C extends {
 }
 ```
 
-In the code above, the field `name` is initialized before the
-constructor of `Greeting` is called. Therefore, field `msg` in
-class `Greeting` is properly initialized to `"How are you, Bob"`.
+In the code above, the field `name` is initialized before the constructor of `Greeting` is called.
+Therefore, field `msg` in class `Greeting` is properly initialized to `"How are you, Bob"`.
 
-If `name` had been initialized instead in `C`'s normal class
-body, it would be initialized after the constructor of
-`Greeting`. In that case, `msg` would be initialized to
-`"How are you, <null>"`.
+If `name` had been initialized instead in `C`'s normal class body, it would be initialized after the constructor of `Greeting`.
+In that case, `msg` would be initialized to `"How are you, <null>"`.
 
 ## Modifiers
 
@@ -494,45 +371,30 @@ AccessModifier    ::=  (‘private’ | ‘protected’) [AccessQualifier]
 AccessQualifier   ::=  ‘[’ (id | ‘this’) ‘]’
 ```
 
-Member definitions may be preceded by modifiers which affect the
-accessibility and usage of the identifiers bound by them.  If several
-modifiers are given, their order does not matter, but the same
-modifier may not occur more than once.  Modifiers preceding a repeated
-definition apply to all constituent definitions.  The rules governing
-the validity and meaning of a modifier are as follows.
+Member definitions may be preceded by modifiers which affect the accessibility and usage of the identifiers bound by them.
+If several modifiers are given, their order does not matter, but the same modifier may not occur more than once.
+Modifiers preceding a repeated definition apply to all constituent definitions.
+The rules governing the validity and meaning of a modifier are as follows.
 
 ### `private`
-The `private` modifier can be used with any definition or declaration in a
-template. Private members of a template can be accessed only from within the
-directly enclosing template and its companion module or
-[companion class](#object-definitions).
-
-The `private` modifier is also valid for
-[top-level](09-top-level-definitions.html#packagings) templates.
-
-A `private` modifier can be _qualified_ with an identifier ´C´ (e.g.
-`private[´C´]`) that must denote a class or package enclosing the definition.
-Members labeled with such a modifier are accessible respectively only from code
-inside the package ´C´ or only from code inside the class ´C´ and its
-[companion module](#object-definitions).
-
-A different form of qualification is `private[this]`. A member
-´M´ marked with this modifier is called _object-protected_; it can be accessed only from within
-the object in which it is defined. That is, a selection ´p.M´ is only
-legal if the prefix is `this` or `´O´.this`, for some
-class ´O´ enclosing the reference. In addition, the restrictions for
-unqualified `private` apply.
-
-Members marked private without a qualifier are called _class-private_,
-whereas members labeled with `private[this]`
-are called _object-private_.  A member _is private_ if it is
-either class-private or object-private, but not if it is marked
-`private[´C´]` where ´C´ is an identifier; in the latter
-case the member is called _qualified private_.
-
-Class-private or object-private members may not be abstract, and may
-not have `protected` or `override` modifiers. They are not inherited
-by subclasses and they may not override definitions in parent classes.
+The `private` modifier can be used with any definition or declaration in a template.
+Private members of a template can be accessed only from within the directly enclosing template and its companion module or [companion class](#object-definitions).
+
+The `private` modifier is also valid for [top-level](09-top-level-definitions.html#packagings) templates.
+
+A `private` modifier can be _qualified_ with an identifier ´C´ (e.g. `private[´C´]`) that must denote a class or package enclosing the definition.
+Members labeled with such a modifier are accessible respectively only from code inside the package ´C´ or only from code inside the class ´C´ and its [companion module](#object-definitions).
+
+A different form of qualification is `private[this]`.
+A member ´M´ marked with this modifier is called _object-protected_; it can be accessed only from within the object in which it is defined.
+That is, a selection ´p.M´ is only legal if the prefix is `this` or `´O´.this`, for some class ´O´ enclosing the reference.
+In addition, the restrictions for unqualified `private` apply.
+
+Members marked private without a qualifier are called _class-private_, whereas members labeled with `private[this]` are called _object-private_.
+A member _is private_ if it is either class-private or object-private, but not if it is marked `private[´C´]` where ´C´ is an identifier; in the latter case the member is called _qualified private_.
+
+Class-private or object-private members may not be abstract, and may not have `protected` or `override` modifiers.
+They are not inherited by subclasses and they may not override definitions in parent classes.
 
 ### `protected`
 The `protected` modifier applies to class member definitions.
@@ -541,91 +403,60 @@ Protected members of a class can be accessed from within
   - all templates that have the defining class as a base class,
   - the companion module of any of those classes.
 
-A `protected` modifier can be qualified with an identifier ´C´ (e.g.
-`protected[´C´]`) that must denote a class or package enclosing the definition.
-Members labeled with such a modifier are also accessible respectively from all
-code inside the package ´C´ or from all code inside the class ´C´ and its
-[companion module](#object-definitions).
-
-A protected identifier ´x´ may be used as a member name in a selection
-`´r´.´x´` only if one of the following applies:
-  - The access is within the template defining the member, or, if
-    a qualification ´C´ is given, inside the package ´C´,
-    or the class ´C´, or its companion module, or
-  - ´r´ is one of the reserved words `this` and
-    `super`, or
-  - ´r´'s type conforms to a type-instance of the
-    class which contains the access.
-
-A different form of qualification is `protected[this]`. A member
-´M´ marked with this modifier is called _object-protected_; it can be accessed only from within
-the object in which it is defined. That is, a selection ´p.M´ is only
-legal if the prefix is `this` or `´O´.this`, for some
-class ´O´ enclosing the reference. In addition, the restrictions for
-unqualified `protected` apply.
+A `protected` modifier can be qualified with an identifier ´C´ (e.g. `protected[´C´]`) that must denote a class or package enclosing the definition.
+Members labeled with such a modifier are also accessible respectively from all code inside the package ´C´ or from all code inside the class ´C´ and its [companion module](#object-definitions).
+
+A protected identifier ´x´ may be used as a member name in a selection `´r´.´x´` only if one of the following applies:
+  - The access is within the template defining the member, or, if a qualification ´C´ is given, inside the package ´C´, or the class ´C´, or its companion module, or
+  - ´r´ is one of the reserved words `this` and `super`, or
+  - ´r´'s type conforms to a type-instance of the class which contains the access.
+
+A different form of qualification is `protected[this]`.
+A member ´M´ marked with this modifier is called _object-protected_; it can be accessed only from within the object in which it is defined. That is, a selection ´p.M´ is only legal if the prefix is `this` or `´O´.this`, for some class ´O´ enclosing the reference. In addition, the restrictions for unqualified `protected` apply.
 
 ### `override`
 The `override` modifier applies to class member definitions or declarations.
-It is mandatory for member definitions or declarations that override some
-other concrete member definition in a parent class. If an `override`
-modifier is given, there must be at least one overridden member
-definition or declaration (either concrete or abstract).
+It is mandatory for member definitions or declarations that override some other concrete member definition in a parent class.
+If an `override` modifier is given, there must be at least one overridden member definition or declaration (either concrete or abstract).
 
 ### `abstract override`
-The `override` modifier has an additional significance when
-combined with the `abstract` modifier.  That modifier combination
-is only allowed for value members of traits.
+The `override` modifier has an additional significance when combined with the `abstract` modifier.
+That modifier combination is only allowed for value members of traits.
 
-We call a member ´M´ of a template _incomplete_ if it is either
-abstract (i.e. defined by a declaration), or it is labeled
-`abstract` and `override` and
-every member overridden by ´M´ is again incomplete.
+We call a member ´M´ of a template _incomplete_ if it is either abstract (i.e. defined by a declaration), or it is labeled `abstract` and `override` and every member overridden by ´M´ is again incomplete.
 
-Note that the `abstract override` modifier combination does not
-influence the concept whether a member is concrete or abstract. A
-member is _abstract_ if only a declaration is given for it;
-it is _concrete_ if a full definition is given.
+Note that the `abstract override` modifier combination does not influence the concept whether a member is concrete or abstract.
+A member is _abstract_ if only a declaration is given for it; it is _concrete_ if a full definition is given.
 
 ### `abstract`
-The `abstract` modifier is used in class definitions. It is
-redundant for traits, and mandatory for all other classes which have
-incomplete members.  Abstract classes cannot be
-[instantiated](06-expressions.html#instance-creation-expressions) with a constructor invocation
-unless followed by mixins and/or a refinement which override all
-incomplete members of the class. Only abstract classes and traits can have
-abstract term members.
-
-The `abstract` modifier can also be used in conjunction with
-`override` for class member definitions. In that case the
-previous discussion applies.
+The `abstract` modifier is used in class definitions.
+It is redundant for traits, and mandatory for all other classes which have incomplete members.
+Abstract classes cannot be [instantiated](06-expressions.html#instance-creation-expressions) with a constructor invocation unless followed by mixins and/or a refinement which override all incomplete members of the class.
+Only abstract classes and traits can have abstract term members.
+
+The `abstract` modifier can also be used in conjunction with `override` for class member definitions.
+In that case the previous discussion applies.
 
 ### `final`
-The `final` modifier applies to class member definitions and to
-class definitions. A `final` class member definition may not be
-overridden in subclasses. A `final` class may not be inherited by
-a template. `final` is redundant for object definitions.  Members
-of final classes or objects are implicitly also final, so the
-`final` modifier is generally redundant for them, too. Note, however, that
-[constant value definitions](04-basic-declarations-and-definitions.html#value-declarations-and-definitions)
-do require an explicit `final` modifier,
-even if they are defined in a final class or object.
-`final` is permitted for abstract classes
-but it may not be applied to traits or incomplete members,
-and it may not be combined in one modifier list with `sealed`.
+The `final` modifier applies to class member definitions and to class definitions.
+A `final` class member definition may not be overridden in subclasses.
+A `final` class may not be inherited by a template.
+`final` is redundant for object definitions.
+Members of final classes or objects are implicitly also final, so the `final` modifier is generally redundant for them, too.
+Note, however, that [constant value definitions](04-basic-declarations-and-definitions.html#value-declarations-and-definitions) do require an explicit `final` modifier, even if they are defined in a final class or object.
+`final` is permitted for abstract classes but it may not be applied to traits or incomplete members, and it may not be combined in one modifier list with `sealed`.
 
 ### `sealed`
-The `sealed` modifier applies to class definitions. A
-`sealed` class may not be directly inherited, except if the inheriting
-template is defined in the same source file as the inherited class.
+The `sealed` modifier applies to class definitions.
+A `sealed` class may not be directly inherited, except if the inheriting template is defined in the same source file as the inherited class.
 However, subclasses of a sealed class can be inherited anywhere.
 
 ### `lazy`
-The `lazy` modifier applies to value definitions. A `lazy`
-value is initialized the first time it is accessed (which might never
-happen at all). Attempting to access a lazy value during its
-initialization might lead to looping behavior. If an exception is
-thrown during initialization, the value is considered uninitialized,
-and a later access will retry to evaluate its right hand side.
+The `lazy` modifier applies to value definitions.
+A `lazy` value is initialized the first time it is accessed (which might never
+happen at all).
+Attempting to access a lazy value during its initialization might lead to looping behavior.
+If an exception is thrown during initialization, the value is considered uninitialized, and a later access will retry to evaluate its right hand side.
 
 ###### Example
 The following code illustrates the use of qualified private:
@@ -641,18 +472,12 @@ class Outer {
 }
 ```
 
-Here, accesses to the method `f` can appear anywhere within
-`Outer`, but not outside it. Accesses to method
-`g` can appear anywhere within the package
-`outerpkg.innerpkg`, as would be the case for
-package-private methods in Java. Finally, accesses to method
-`h` can appear anywhere within package `outerpkg`,
-including packages contained in it.
+Here, accesses to the method `f` can appear anywhere within `Outer`, but not outside it.
+Accesses to method `g` can appear anywhere within the package `outerpkg.innerpkg`, as would be the case for package-private methods in Java.
+Finally, accesses to method `h` can appear anywhere within package `outerpkg`, including packages contained in it.
 
 ###### Example
-A useful idiom to prevent clients of a class from
-constructing new instances of that class is to declare the class
-`abstract` and `sealed`:
+A useful idiom to prevent clients of a class from constructing new instances of that class is to declare the class `abstract` and `sealed`:
 
 ```scala
 object m {
@@ -663,18 +488,15 @@ object m {
 }
 ```
 
-For instance, in the code above clients can create instances of class
-`m.C` only by calling the `nextC` method of an existing `m.C`
-object; it is not possible for clients to create objects of class
-`m.C` directly. Indeed the following two lines are both in error:
+For instance, in the code above clients can create instances of class `m.C` only by calling the `nextC` method of an existing `m.C` object; it is not possible for clients to create objects of class `m.C` directly.
+Indeed the following two lines are both in error:
 
 ```scala
 new m.C(0)    // **** error: C is abstract, so it cannot be instantiated.
 new m.C(0) {} // **** error: illegal inheritance from sealed class.
 ```
 
-A similar access restriction can be achieved by marking the primary
-constructor `private` ([example](#example-private-constructor)).
+A similar access restriction can be achieved by marking the primary constructor `private` ([example](#example-private-constructor)).
 
 ## Class Definitions
 
@@ -700,31 +522,23 @@ class ´c´[´\mathit{tps}\,´] ´as´ ´m´(´\mathit{ps}_1´)...(´\mathit{ps}
 Here,
 
   - ´c´ is the name of the class to be defined.
-  - ´\mathit{tps}´ is a non-empty list of type parameters of the class
-    being defined.  The scope of a type parameter is the whole class
-    definition including the type parameter section itself.  It is
-    illegal to define two type parameters with the same name.  The type
-    parameter section `[´\mathit{tps}\,´]` may be omitted. A class with a type
-    parameter section is called _polymorphic_, otherwise it is called
-    _monomorphic_.
-  - ´as´ is a possibly empty sequence of
-    [annotations](11-annotations.html#user-defined-annotations).
-    If any annotations are given, they apply to the primary constructor of the
-    class.
-  - ´m´ is an [access modifier](#modifiers) such as
-    `private` or `protected`, possibly with a qualification.
-    If such an access modifier is given it applies to the primary constructor of the class.
-  - ´(\mathit{ps}\_1)...(\mathit{ps}\_n)´ are formal value parameter clauses for
-    the _primary constructor_ of the class. The scope of a formal value parameter includes
-    all subsequent parameter sections and the template ´t´. However, a formal
-    value parameter may not form part of the types of any of the parent classes or members of the class template ´t´.
-    It is illegal to define two formal value parameters with the same name.
+  - ´\mathit{tps}´ is a non-empty list of type parameters of the class being defined.
+  The scope of a type parameter is the whole class definition including the type parameter section itself.
+  It is illegal to define two type parameters with the same name.
+  The type parameter section `[´\mathit{tps}\,´]` may be omitted.
+  A class with a type parameter section is called _polymorphic_, otherwise it is called _monomorphic_.
+  - ´as´ is a possibly empty sequence of [annotations](11-annotations.html#user-defined-annotations).
+  If any annotations are given, they apply to the primary constructor of the class.
+  - ´m´ is an [access modifier](#modifiers) such as `private` or `protected`, possibly with a qualification.
+  If such an access modifier is given it applies to the primary constructor of the class.
+  - ´(\mathit{ps}\_1)...(\mathit{ps}\_n)´ are formal value parameter clauses for the _primary constructor_ of the class.
+  The scope of a formal value parameter includes all subsequent parameter sections and the template ´t´.
+  However, a formal value parameter may not form part of the types of any of the parent classes or members of the class template ´t´.
+  It is illegal to define two formal value parameters with the same name.
 
     If a class has no formal parameter section that is not implicit, an empty parameter section `()` is assumed.
 
-    If a formal parameter declaration ´x: T´ is preceded by a `val`
-    or `var` keyword, an accessor (getter) [definition](04-basic-declarations-and-definitions.html#variable-declarations-and-definitions)
-    for this parameter is implicitly added to the class.
+    If a formal parameter declaration ´x: T´ is preceded by a `val` or `var` keyword, an accessor (getter) [definition](04-basic-declarations-and-definitions.html#variable-declarations-and-definitions) for this parameter is implicitly added to the class.
 
     The getter introduces a value member ´x´ of class ´c´ that is defined as an alias of the parameter.
     If the introducing keyword is `var`, a setter accessor [`´x´_=`](04-basic-declarations-and-definitions.html#variable-declarations-and-definitions) is also implicitly added to the class.
@@ -740,18 +554,11 @@ Here,
     ´sc´ with ´mt_1´ with ... with ´mt_m´ { ´\mathit{stats}´ } // ´m \geq 0´
     ```
 
-    which defines the base classes, behavior and initial state of objects of
-    the class. The extends clause
-    `extends ´sc´ with ´mt_1´ with ... with ´mt_m´`
-    can be omitted, in which case
-    `extends scala.AnyRef` is assumed.  The class body
-    `{ ´\mathit{stats}´ }` may also be omitted, in which case the empty body
-    `{}` is assumed.
+    which defines the base classes, behavior and initial state of objects of the class.
+    The extends clause `extends ´sc´ with ´mt_1´ with ... with ´mt_m´` can be omitted, in which case `extends scala.AnyRef` is assumed.
+    The class body `{ ´\mathit{stats}´ }` may also be omitted, in which case the empty body `{}` is assumed.
 
-This class definition defines a type `´c´[´\mathit{tps}\,´]` and a constructor
-which when applied to parameters conforming to types ´\mathit{ps}´
-initializes instances of type `´c´[´\mathit{tps}\,´]` by evaluating the template
-´t´.
+This class definition defines a type `´c´[´\mathit{tps}\,´]` and a constructor which when applied to parameters conforming to types ´\mathit{ps}´ initializes instances of type `´c´[´\mathit{tps}\,´]` by evaluating the template ´t´.
 
 ###### Example – `val` and `var` parameters
 The following example illustrates `val` and `var` parameters of a class `C`:
@@ -787,45 +594,21 @@ ConstrBlock    ::= ‘{’ SelfInvocation {semi BlockStat} ‘}’
 SelfInvocation ::= ‘this’ ArgumentExprs {ArgumentExprs}
 ```
 
-A class may have additional constructors besides the primary
-constructor.  These are defined by constructor definitions of the form
-`def this(´\mathit{ps}_1´)...(´\mathit{ps}_n´) = ´e´`.  Such a
-definition introduces an additional constructor for the enclosing
-class, with parameters as given in the formal parameter lists ´\mathit{ps}_1
-, ..., \mathit{ps}_n´, and whose evaluation is defined by the constructor
-expression ´e´.  The scope of each formal parameter is the subsequent
-parameter sections and the constructor
-expression ´e´.  A constructor expression is either a self constructor
-invocation `this(´\mathit{args}_1´)...(´\mathit{args}_n´)` or a block
-which begins with a self constructor invocation. The self constructor
-invocation must construct a generic instance of the class. I.e. if the
-class in question has name ´C´ and type parameters
-`[´\mathit{tps}\,´]`, then a self constructor invocation must
-generate an instance of `´C´[´\mathit{tps}\,´]`; it is not permitted
-to instantiate formal type parameters.
-
-The signature and the self constructor invocation of a constructor
-definition are type-checked and evaluated in the scope which is in
-effect at the point of the enclosing class definition, augmented by
-any type parameters of the enclosing class and by any
-[early definitions](#early-definitions) of the enclosing template.
-The rest of the
-constructor expression is type-checked and evaluated as a function
-body in the current class.
-
-If there are auxiliary constructors of a class ´C´, they form together
-with ´C´'s primary [constructor](#class-definitions)
-an overloaded constructor
-definition. The usual rules for
-[overloading resolution](06-expressions.html#overloading-resolution)
-apply for constructor invocations of ´C´,
-including for the self constructor invocations in the constructor
-expressions themselves. However, unlike other methods, constructors
-are never inherited.  To prevent infinite cycles of constructor
-invocations, there is the restriction that every self constructor
-invocation must refer to a constructor definition which precedes it
-(i.e. it must refer to either a preceding auxiliary constructor or the
-primary constructor of the class).
+A class may have additional constructors besides the primary constructor.
+These are defined by constructor definitions of the form `def this(´\mathit{ps}_1´)...(´\mathit{ps}_n´) = ´e´`.
+Such a definition introduces an additional constructor for the enclosing class, with parameters as given in the formal parameter lists ´\mathit{ps}_1 , ..., \mathit{ps}_n´, and whose evaluation is defined by the constructor expression ´e´.
+The scope of each formal parameter is the subsequent parameter sections and the constructor expression ´e´.
+A constructor expression is either a self constructor invocation `this(´\mathit{args}_1´)...(´\mathit{args}_n´)` or a block which begins with a self constructor invocation.
+The self constructor invocation must construct a generic instance of the class. 
+I.e. if the class in question has name ´C´ and type parameters `[´\mathit{tps}\,´]`, then a self constructor invocation must generate an instance of `´C´[´\mathit{tps}\,´]`; it is not permitted to instantiate formal type parameters.
+
+The signature and the self constructor invocation of a constructor definition are type-checked and evaluated in the scope which is in effect at the point of the enclosing class definition, augmented by any type parameters of the enclosing class and by any [early definitions](#early-definitions) of the enclosing template.
+The rest of the constructor expression is type-checked and evaluated as a function body in the current class.
+
+If there are auxiliary constructors of a class ´C´, they form together with ´C´'s primary [constructor](#class-definitions) an overloaded constructor definition.
+The usual rules for [overloading resolution](06-expressions.html#overloading-resolution) apply for constructor invocations of ´C´, including for the self constructor invocations in the constructor expressions themselves.
+However, unlike other methods, constructors are never inherited.
+To prevent infinite cycles of constructor invocations, there is the restriction that every self constructor invocation must refer to a constructor definition which precedes it (i.e. it must refer to either a preceding auxiliary constructor or the primary constructor of the class).
 
 ###### Example
 Consider the class definition
@@ -839,9 +622,8 @@ class LinkedList[A]() {
 }
 ```
 
-This defines a class `LinkedList` with three constructors.  The
-second constructor constructs a singleton list, while the
-third one constructs a list with a given head and tail.
+This defines a class `LinkedList` with three constructors.
+The second constructor constructs a singleton list, while the third one constructs a list with a given head and tail.
 
 ### Case Classes
 
@@ -849,21 +631,16 @@ third one constructs a list with a given head and tail.
 TmplDef  ::=  ‘case’ ‘class’ ClassDef
 ```
 
-If a class definition is prefixed with `case`, the class is said
-to be a _case class_.
+If a class definition is prefixed with `case`, the class is said to be a _case class_.
 
 A case class is required to have a parameter section that is not implicit.
-The formal parameters in the first parameter section 
-are called _elements_ and are treated specially.
-First, the value of such a parameter can be extracted as a
-field of a constructor pattern. Second, a `val` prefix is
-implicitly added to such a parameter, unless the parameter already carries
-a `val` or `var` modifier. Hence, an accessor
-definition for the parameter is [generated](#class-definitions).
-
-A case class definition of `´c´[´\mathit{tps}\,´](´\mathit{ps}_1\,´)...(´\mathit{ps}_n´)` with type
-parameters ´\mathit{tps}´ and value parameters ´\mathit{ps}´ implies
-the definition of a companion object, which serves as an [extractor object](08-pattern-matching.html#extractor-patterns). It has the following shape:
+The formal parameters in the first parameter section are called _elements_ and are treated specially.
+First, the value of such a parameter can be extracted as a field of a constructor pattern.
+Second, a `val` prefix is implicitly added to such a parameter, unless the parameter already carries a `val` or `var` modifier.
+Hence, an accessor definition for the parameter is [generated](#class-definitions).
+
+A case class definition of `´c´[´\mathit{tps}\,´](´\mathit{ps}_1\,´)...(´\mathit{ps}_n´)` with type parameters ´\mathit{tps}´ and value parameters ´\mathit{ps}´ implies the definition of a companion object, which serves as an [extractor object](08-pattern-matching.html#extractor-patterns).
+It has the following shape:
 
 ```scala
 object ´c´ {
@@ -874,62 +651,38 @@ object ´c´ {
 }
 ```
 
-Here, ´\mathit{Ts}´ stands for the vector of types defined in the type
-parameter section ´\mathit{tps}´,
-each ´\mathit{xs}\_i´ denotes the parameter names of the parameter
-section ´\mathit{ps}\_i´, and
-´\mathit{xs}\_{11}, ... , \mathit{xs}\_{1k}´ denote the names of all parameters
-in the first parameter section ´\mathit{xs}\_1´.
+Here, ´\mathit{Ts}´ stands for the vector of types defined in the type parameter section ´\mathit{tps}´, each ´\mathit{xs}\_i´ denotes the parameter names of the parameter section ´\mathit{ps}\_i´, and ´\mathit{xs}\_{11}, ... , \mathit{xs}\_{1k}´ denote the names of all parameters in the first parameter section ´\mathit{xs}\_1´.
 If a type parameter section is missing in the class, it is also missing in the `apply` and `unapply` methods.
 
-If the companion object ´c´ is already defined,
-the  `apply` and `unapply` methods are added to the existing object.
-If the object ´c´ already has a [matching](#definition-matching)
-`apply` (or `unapply`) member, no new definition is added.
+If the companion object ´c´ is already defined, the  `apply` and `unapply` methods are added to the existing object.
+If the object ´c´ already has a [matching](#definition-matching) `apply` (or `unapply`) member, no new definition is added.
 The definition of `apply` is omitted if class ´c´ is `abstract`.
 
-If the case class definition contains an empty value parameter list, the
-`unapply` method returns a `Boolean` instead of an `Option` type and
-is defined as follows:
+If the case class definition contains an empty value parameter list, the `unapply` method returns a `Boolean` instead of an `Option` type and is defined as follows:
 
 ```scala
 def unapply[´\mathit{tps}\,´](´x´: ´c´[´\mathit{tps}\,´]) = x ne null
 ```
 
-The name of the `unapply` method is changed to `unapplySeq` if the first
-parameter section ´\mathit{ps}_1´ of ´c´ ends in a
-[repeated parameter](04-basic-declarations-and-definitions.html#repeated-parameters).
+The name of the `unapply` method is changed to `unapplySeq` if the first parameter section ´\mathit{ps}_1´ of ´c´ ends in a [repeated parameter](04-basic-declarations-and-definitions.html#repeated-parameters).
 
-A method named `copy` is implicitly added to every case class unless the
-class already has a member (directly defined or inherited) with that name, or the
-class has a repeated parameter. The method is defined as follows:
+A method named `copy` is implicitly added to every case class unless the class already has a member (directly defined or inherited) with that name, or the class has a repeated parameter.
+The method is defined as follows:
 
 ```scala
 def copy[´\mathit{tps}\,´](´\mathit{ps}'_1\,´)...(´\mathit{ps}'_n´): ´c´[´\mathit{tps}\,´] = new ´c´[´\mathit{Ts}\,´](´\mathit{xs}_1\,´)...(´\mathit{xs}_n´)
 ```
 
-Again, `´\mathit{Ts}´` stands for the vector of types defined in the type parameter section `´\mathit{tps}´`
-and each `´xs_i´` denotes the parameter names of the parameter section `´ps'_i´`. The value
-parameters `´ps'_{1,j}´` of first parameter list have the form `´x_{1,j}´:´T_{1,j}´=this.´x_{1,j}´`,
-the other parameters `´ps'_{i,j}´` of the `copy` method are defined as `´x_{i,j}´:´T_{i,j}´`.
-In all cases `´x_{i,j}´` and `´T_{i,j}´` refer to the name and type of the corresponding class parameter
-`´\mathit{ps}_{i,j}´`.
-
-Every case class implicitly overrides some method definitions of class
-[`scala.AnyRef`](12-the-scala-standard-library.html#root-classes) unless a definition of the same
-method is already given in the case class itself or a concrete
-definition of the same method is given in some base class of the case
-class different from `AnyRef`. In particular:
-
-- Method `equals: (Any)Boolean` is structural equality, where two
-  instances are equal if they both belong to the case class in question and they
-  have equal (with respect to `equals`) constructor arguments (restricted to the class's _elements_, i.e., the first parameter section).
-- Method `hashCode: Int` computes a hash-code. If the hashCode methods
-  of the data structure members map equal (with respect to equals)
-  values to equal hash-codes, then the case class hashCode method does
-  too.
-- Method `toString: String` returns a string representation which
-  contains the name of the class and its elements.
+Again, `´\mathit{Ts}´` stands for the vector of types defined in the type parameter section `´\mathit{tps}´` and each `´xs_i´` denotes the parameter names of the parameter section `´ps'_i´`.
+The value parameters `´ps'_{1,j}´` of first parameter list have the form `´x_{1,j}´:´T_{1,j}´=this.´x_{1,j}´`, the other parameters `´ps'_{i,j}´` of the `copy` method are defined as `´x_{i,j}´:´T_{i,j}´`.
+In all cases `´x_{i,j}´` and `´T_{i,j}´` refer to the name and type of the corresponding class parameter `´\mathit{ps}_{i,j}´`.
+
+Every case class implicitly overrides some method definitions of class [`scala.AnyRef`](12-the-scala-standard-library.html#root-classes) unless a definition of the same method is already given in the case class itself or a concrete definition of the same method is given in some base class of the case class different from `AnyRef`.
+In particular:
+
+- Method `equals: (Any)Boolean` is structural equality, where two instances are equal if they both belong to the case class in question and they have equal (with respect to `equals`) constructor arguments (restricted to the class's _elements_, i.e., the first parameter section).
+- Method `hashCode: Int` computes a hash-code. If the hashCode methods of the data structure members map equal (with respect to equals) values to equal hash-codes, then the case class hashCode method does too.
+- Method `toString: String` returns a string representation which contains the name of the class and its elements.
 
 ###### Example
 Here is the definition of abstract syntax for lambda calculus:
@@ -941,9 +694,7 @@ case class Apply (f: Expr, e: Expr)   extends Expr
 case class Lambda(x: String, e: Expr) extends Expr
 ```
 
-This defines a class `Expr` with case classes
-`Var`, `Apply` and `Lambda`. A call-by-value evaluator
-for lambda expressions could then be written as follows.
+This defines a class `Expr` with case classes `Var`, `Apply` and `Lambda`. A call-by-value evaluator for lambda expressions could then be written as follows.
 
 ```scala
 type Env = String => Value
@@ -961,17 +712,13 @@ def eval(e: Expr, env: Env): Value = e match {
 }
 ```
 
-It is possible to define further case classes that extend type
-`Expr` in other parts of the program, for instance
+It is possible to define further case classes that extend type `Expr` in other parts of the program, for instance
 
 ```scala
 case class Number(x: Int) extends Expr
 ```
 
-This form of extensibility can be excluded by declaring the base class
-`Expr` `sealed`; in this case, all classes that
-directly extend `Expr` must be in the same source file as
-`Expr`.
+This form of extensibility can be excluded by declaring the base class `Expr` `sealed`; in this case, all classes that directly extend `Expr` must be in the same source file as `Expr`.
 
 ## Traits
 
@@ -981,28 +728,21 @@ TraitDef         ::=  id [TypeParamClause] TraitTemplateOpt
 TraitTemplateOpt ::=  ‘extends’ TraitTemplate | [[‘extends’] TemplateBody]
 ```
 
-A _trait_ is a class that is meant to be added to some other class
-as a mixin. Unlike normal classes, traits cannot have
-constructor parameters. Furthermore, no constructor arguments are
-passed to the superclass of the trait. This is not necessary as traits are
-initialized after the superclass is initialized.
+A _trait_ is a class that is meant to be added to some other class as a mixin.
+Unlike normal classes, traits cannot have constructor parameters.
+Furthermore, no constructor arguments are passed to the superclass of the trait.
+This is not necessary as traits are initialized after the superclass is initialized.
 
 Assume a trait ´D´ defines some aspect of an instance ´x´ of type ´C´ (i.e. ´D´ is a base class of ´C´).
-Then the _actual supertype_ of ´D´ in ´x´ is the compound type consisting of all the
-base classes in ´\mathcal{L}(C)´ that succeed ´D´.  The actual supertype gives
-the context for resolving a [`super` reference](06-expressions.html#this-and-super) in a trait.
-Note that the actual supertype depends on the type to which the trait is added in a mixin composition;
-it is not statically known at the time the trait is defined.
+Then the _actual supertype_ of ´D´ in ´x´ is the compound type consisting of all the base classes in ´\mathcal{L}(C)´ that succeed ´D´.
+The actual supertype gives the context for resolving a [`super` reference](06-expressions.html#this-and-super) in a trait.
+Note that the actual supertype depends on the type to which the trait is added in a mixin composition; it is not statically known at the time the trait is defined.
 
-If ´D´ is not a trait, then its actual supertype is simply its
-least proper supertype (which is statically known).
+If ´D´ is not a trait, then its actual supertype is simply its least proper supertype (which is statically known).
 
 ###### Example
-The following trait defines the property
-of being comparable to objects of some type. It contains an abstract
-method `<` and default implementations of the other
-comparison operators `<=`, `>`, and
-`>=`.
+The following trait defines the property of being comparable to objects of some type.
+It contains an abstract method `<` and default implementations of the other comparison operators `<=`, `>`, and `>=`.
 
 ```scala
 trait Comparable[T <: Comparable[T]] { self: T =>
@@ -1014,13 +754,10 @@ trait Comparable[T <: Comparable[T]] { self: T =>
 ```
 
 ###### Example
-Consider an abstract class `Table` that implements maps
-from a type of keys `A` to a type of values `B`. The class
-has a method `set` to enter a new key / value pair into the table,
-and a method `get` that returns an optional value matching a
-given key. Finally, there is a method `apply` which is like
-`get`, except that it returns a given default value if the table
-is undefined for the given key. This class is implemented as follows.
+Consider an abstract class `Table` that implements maps from a type of keys `A` to a type of values `B`.
+The class has a method `set` to enter a new key / value pair into the table, and a method `get` that returns an optional value matching a given key.
+Finally, there is a method `apply` which is like `get`, except that it returns a given default value if the table is undefined for the given key.
+This class is implemented as follows.
 
 ```scala
 abstract class Table[A, B](defaultValue: B) {
@@ -1043,8 +780,7 @@ class ListTable[A, B](defaultValue: B) extends Table[A, B](defaultValue) {
 }
 ```
 
-Here is a trait that prevents concurrent access to the
-`get` and `set` operations of its parent class:
+Here is a trait that prevents concurrent access to the `get` and `set` operations of its parent class:
 
 ```scala
 trait SynchronizedTable[A, B] extends Table[A, B] {
@@ -1055,27 +791,18 @@ trait SynchronizedTable[A, B] extends Table[A, B] {
 }
 ```
 
-Note that `SynchronizedTable` does not pass an argument to
-its superclass, `Table`, even  though `Table` is defined with a
-formal parameter. Note also that the `super` calls
-in `SynchronizedTable`'s `get` and `set` methods
-statically refer to abstract methods in class `Table`. This is
-legal, as long as the calling method is labeled
-[`abstract override`](#modifiers).
+Note that `SynchronizedTable` does not pass an argument to its superclass, `Table`, even  though `Table` is defined with a formal parameter.
+Note also that the `super` calls in `SynchronizedTable`'s `get` and `set` methods statically refer to abstract methods in class `Table`.
+This is legal, as long as the calling method is labeled [`abstract override`](#modifiers).
 
-Finally, the following mixin composition creates a synchronized list
-table with strings as keys and integers as values and with a default
-value `0`:
+Finally, the following mixin composition creates a synchronized list table with strings as keys and integers as values and with a default value `0`:
 
 ```scala
 object MyTable extends ListTable[String, Int](0) with SynchronizedTable[String, Int]
 ```
 
-The object `MyTable` inherits its `get` and `set`
-method from `SynchronizedTable`.  The `super` calls in these
-methods are re-bound to refer to the corresponding implementations in
-`ListTable`, which is the actual supertype of `SynchronizedTable`
-in `MyTable`.
+The object `MyTable` inherits its `get` and `set` method from `SynchronizedTable`.
+The `super` calls in these methods are re-bound to refer to the corresponding implementations in `ListTable`, which is the actual supertype of `SynchronizedTable` in `MyTable`.
 
 ## Object Definitions
 
@@ -1083,50 +810,36 @@ in `MyTable`.
 ObjectDef       ::=  id ClassTemplate
 ```
 
-An _object definition_ defines a single object of a new class. Its
-most general form is
-`object ´m´ extends ´t´`. Here,
-´m´ is the name of the object to be defined, and
-´t´ is a [template](#templates) of the form
+An _object definition_ defines a single object of a new class.
+Its most general form is `object ´m´ extends ´t´`.
+Here, ´m´ is the name of the object to be defined, and ´t´ is a [template](#templates) of the form
 
 ```scala
 ´sc´ with ´mt_1´ with ... with ´mt_n´ { ´\mathit{stats}´ }
 ```
 
 which defines the base classes, behavior and initial state of ´m´.
-The extends clause `extends ´sc´ with ´mt_1´ with ... with ´mt_n´`
-can be omitted, in which case
-`extends scala.AnyRef` is assumed.  The class body
-`{ ´\mathit{stats}´ }` may also be omitted, in which case the empty body
-`{}` is assumed.
+The extends clause `extends ´sc´ with ´mt_1´ with ... with ´mt_n´` can be omitted, in which case `extends scala.AnyRef` is assumed.
+The class body `{ ´\mathit{stats}´ }` may also be omitted, in which case the empty body `{}` is assumed.
 
-The object definition defines a single object (or: _module_)
-conforming to the template ´t´.  It is roughly equivalent to the
-following definition of a lazy value:
+The object definition defines a single object (or: _module_) conforming to the template ´t´.
+It is roughly equivalent to the following definition of a lazy value:
 
 ```scala
 lazy val ´m´ = new ´sc´ with ´mt_1´ with ... with ´mt_n´ { this: ´m.type´ => ´\mathit{stats}´ }
 ```
 
-Note that the value defined by an object definition is instantiated
-lazily.  The `new ´m´$cls` constructor is evaluated
-not at the point of the object definition, but is instead evaluated
-the first time ´m´ is dereferenced during execution of the program
-(which might be never at all). An attempt to dereference ´m´ again
-during evaluation of the constructor will lead to an infinite loop
-or run-time error.
-Other threads trying to dereference ´m´ while the
-constructor is being evaluated block until evaluation is complete.
-
-The expansion given above is not accurate for top-level objects. It
-cannot be because variable and method definition cannot appear on the
-top-level outside of a [package object](09-top-level-definitions.html#package-objects). Instead,
-top-level objects are translated to static fields.
+Note that the value defined by an object definition is instantiated lazily.
+The `new ´m´$cls` constructor is evaluated not at the point of the object definition, but is instead evaluated the first time ´m´ is dereferenced during execution of the program (which might be never at all).
+An attempt to dereference ´m´ again during evaluation of the constructor will lead to an infinite loop or run-time error.
+Other threads trying to dereference ´m´ while the constructor is being evaluated block until evaluation is complete.
+
+The expansion given above is not accurate for top-level objects.
+It cannot be because variable and method definition cannot appear on the top-level outside of a [package object](09-top-level-definitions.html#package-objects).
+Instead, top-level objects are translated to static fields.
 
 ###### Example
-Classes in Scala do not have static members; however, an equivalent
-effect can be achieved by an accompanying object definition
-E.g.
+Classes in Scala do not have static members; however, an equivalent effect can be achieved by an accompanying object definition E.g.
 
 ```scala
 abstract class Point {
@@ -1139,22 +852,13 @@ object Point {
 }
 ```
 
-This defines a class `Point` and an object `Point` which
-contains `origin` as a member.  Note that the double use of the
-name `Point` is legal, since the class definition defines the
-name `Point` in the type name space, whereas the object
-definition defines a name in the term namespace.
-
-This technique is applied by the Scala compiler when interpreting a
-Java class with static members. Such a class ´C´ is conceptually seen
-as a pair of a Scala class that contains all instance members of ´C´
-and a Scala object that contains all static members of ´C´.
-
-Generally, a _companion module_ of a class is an object which has
-the same name as the class and is defined in the same scope and
-compilation unit. Conversely, the class is called the _companion class_
-of the module.
-
-Very much like a concrete class definition, an object definition may
-still contain declarations of abstract type members, but not of
-abstract term members.
+This defines a class `Point` and an object `Point` which contains `origin` as a member.
+Note that the double use of the name `Point` is legal, since the class definition defines the name `Point` in the type name space, whereas the object definition defines a name in the term namespace.
+
+This technique is applied by the Scala compiler when interpreting a Java class with static members.
+Such a class ´C´ is conceptually seen as a pair of a Scala class that contains all instance members of ´C´ and a Scala object that contains all static members of ´C´.
+
+Generally, a _companion module_ of a class is an object which has the same name as the class and is defined in the same scope and compilation unit.
+Conversely, the class is called the _companion class_ of the module.
+
+Very much like a concrete class definition, an object definition may still contain declarations of abstract type members, but not of abstract term members.
diff --git a/docs/_spec/06-expressions.md b/docs/_spec/06-expressions.md
index 36c31af8969c..597756550e6f 100644
--- a/docs/_spec/06-expressions.md
+++ b/docs/_spec/06-expressions.md
@@ -47,23 +47,21 @@ Ascription   ::=  ‘:’ InfixType
                |  ‘:’ ‘_’ ‘*’
 ```
 
-Expressions are composed of operators and operands. Expression forms are
-discussed subsequently in decreasing order of precedence.
+Expressions are composed of operators and operands.
+Expression forms are discussed subsequently in decreasing order of precedence.
 
 ## Expression Typing
 
-The typing of expressions is often relative to some _expected type_  (which might be undefined). When we write "expression ´e´ is expected to conform to type ´T´", we mean:
+The typing of expressions is often relative to some _expected type_  (which might be undefined).
+When we write "expression ´e´ is expected to conform to type ´T´", we mean:
   1. the expected type of ´e´ is ´T´, and
   2. the type of expression ´e´ must conform to ´T´.
 
-The following skolemization rule is applied universally for every
-expression: If the type of an expression would be an existential type
-´T´, then the type of the expression is assumed instead to be a
-[skolemization](03-types.html#existential-types) of ´T´.
+The following skolemization rule is applied universally for every expression:
+If the type of an expression would be an existential type ´T´, then the type of the expression is assumed instead to be a [skolemization](03-types.html#existential-types) of ´T´.
 
-Skolemization is reversed by type packing. Assume an expression ´e´ of
-type ´T´ and let ´t_1[\mathit{tps}\_1] >: L_1 <: U_1, ..., t_n[\mathit{tps}\_n] >: L_n <: U_n´ be
-all the type variables created by skolemization of some part of ´e´ which are free in ´T´.
+Skolemization is reversed by type packing.
+Assume an expression ´e´ of type ´T´ and let ´t_1[\mathit{tps}\_1] >: L_1 <: U_1, ..., t_n[\mathit{tps}\_n] >: L_n <: U_n´ be all the type variables created by skolemization of some part of ´e´ which are free in ´T´.
 Then the _packed type_ of ´e´ is
 
 ```scala
@@ -76,8 +74,7 @@ Then the _packed type_ of ´e´ is
 SimpleExpr    ::=  Literal
 ```
 
-Typing of literals is described along with their [lexical syntax](01-lexical-syntax.html#literals);
-their evaluation is immediate.
+Typing of literals is described along with their [lexical syntax](01-lexical-syntax.html#literals); their evaluation is immediate.
 
 ## The _Null_ Value
 
@@ -85,16 +82,13 @@ The `null` value is of type `scala.Null`, and thus conforms to every reference t
 It denotes a reference value which refers to a special `null` object.
 This object implements methods in class `scala.AnyRef` as follows:
 
-- `eq(´x\,´)` and `==(´x\,´)` return `true` iff the
-  argument ´x´ is also the "null" object.
-- `ne(´x\,´)` and `!=(´x\,´)` return true iff the
-  argument x is not also the "null" object.
+- `eq(´x\,´)` and `==(´x\,´)` return `true` iff the argument ´x´ is also the "null" object.
+- `ne(´x\,´)` and `!=(´x\,´)` return true iff the argument x is not also the "null" object.
 - `isInstanceOf[´T\,´]` always returns `false`.
 - `asInstanceOf[´T\,´]` returns the [default value](04-basic-declarations-and-definitions.html#value-declarations-and-definitions) of type ´T´.
 - `##` returns ``0``.
 
-A reference to any other member of the "null" object causes a
-`NullPointerException` to be thrown.
+A reference to any other member of the "null" object causes a `NullPointerException` to be thrown.
 
 ## Designators
 
@@ -103,50 +97,31 @@ SimpleExpr  ::=  Path
               |  SimpleExpr ‘.’ id
 ```
 
-A designator refers to a named term. It can be a _simple name_ or
-a _selection_.
+A designator refers to a named term. It can be a _simple name_ or a _selection_.
 
-A simple name ´x´ refers to a value as specified
-[here](02-identifiers-names-and-scopes.html#identifiers,-names-and-scopes).
-If ´x´ is bound by a definition or declaration in an enclosing class
-or object ´C´, it is taken to be equivalent to the selection
-`´C´.this.´x´` where ´C´ is taken to refer to the class containing ´x´
-even if the type name ´C´ is [shadowed](02-identifiers-names-and-scopes.html#identifiers,-names-and-scopes) at the
-occurrence of ´x´.
+A simple name ´x´ refers to a value as specified [here](02-identifiers-names-and-scopes.html#identifiers,-names-and-scopes).
+If ´x´ is bound by a definition or declaration in an enclosing class or object ´C´, it is taken to be equivalent to the selection `´C´.this.´x´` where ´C´ is taken to refer to the class containing ´x´ even if the type name ´C´ is [shadowed](02-identifiers-names-and-scopes.html#identifiers,-names-and-scopes) at the occurrence of ´x´.
 
-If ´r´ is a [stable identifier](03-types.html#paths) of type ´T´, the selection ´r.x´ refers
-statically to a term member ´m´ of ´r´ that is identified in ´T´ by
-the name ´x´.
+If ´r´ is a [stable identifier](03-types.html#paths) of type ´T´, the selection ´r.x´ refers statically to a term member ´m´ of ´r´ that is identified in ´T´ by the name ´x´.
 
 <!-- There might be several such members, in which
 case overloading resolution (\sref{overloading-resolution}) is applied
 to pick a unique one.}  -->
 
-For other expressions ´e´, ´e.x´ is typed as
-if it was `{ val ´y´ = ´e´; ´y´.´x´ }`, for some fresh name
-´y´.
+For other expressions ´e´, ´e.x´ is typed as if it was `{ val ´y´ = ´e´; ´y´.´x´ }`, for some fresh name ´y´.
 
-The expected type of a designator's prefix is always undefined.  The
-type of a designator is the type ´T´ of the entity it refers to, with
-the following exception: The type of a [path](03-types.html#paths) ´p´
-which occurs in a context where a [stable type](03-types.html#singleton-types)
-is required is the singleton type `´p´.type`.
+The expected type of a designator's prefix is always undefined.
+The type of a designator is the type ´T´ of the entity it refers to, with the following exception: The type of a [path](03-types.html#paths) ´p´ which occurs in a context where a [stable type](03-types.html#singleton-types) is required is the singleton type `´p´.type`.
 
-The contexts where a stable type is required are those that satisfy
-one of the following conditions:
+The contexts where a stable type is required are those that satisfy one of the following conditions:
 
-1. The path ´p´ occurs as the prefix of a selection and it does not
-designate a constant, or
+1. The path ´p´ occurs as the prefix of a selection and it does not designate a constant, or
 1. The expected type ´\mathit{pt}´ is a stable type, or
-1. The expected type ´\mathit{pt}´ is an abstract type with a stable type as lower
-   bound, and the type ´T´ of the entity referred to by ´p´ does not
-   conform to ´\mathit{pt}´, or
+1. The expected type ´\mathit{pt}´ is an abstract type with a stable type as lower bound, and the type ´T´ of the entity referred to by ´p´ does not conform to ´\mathit{pt}´, or
 1. The path ´p´ designates a module.
 
-The selection ´e.x´ is evaluated by first evaluating the qualifier
-expression ´e´, which yields an object ´r´, say. The selection's
-result is then the member of ´r´ that is either defined by ´m´ or defined
-by a definition overriding ´m´.
+The selection ´e.x´ is evaluated by first evaluating the qualifier expression ´e´, which yields an object ´r´, say.
+The selection's result is then the member of ´r´ that is either defined by ´m´ or defined by a definition overriding ´m´.
 
 ## This and Super
 
@@ -155,52 +130,34 @@ SimpleExpr  ::=  [id ‘.’] ‘this’
               |  [id ‘.’] ‘super’ [ClassQualifier] ‘.’ id
 ```
 
-The expression `this` can appear in the statement part of a
-template or compound type. It stands for the object being defined by
-the innermost template or compound type enclosing the reference. If
-this is a compound type, the type of `this` is that compound type.
-If it is a template of a
-class or object definition with simple name ´C´, the type of this
-is the same as the type of `´C´.this`.
-
-The expression `´C´.this` is legal in the statement part of an
-enclosing class or object definition with simple name ´C´. It
-stands for the object being defined by the innermost such definition.
-If the expression's expected type is a stable type, or
-`´C´.this` occurs as the prefix of a selection, its type is
-`´C´.this.type`, otherwise it is the self type of class ´C´.
-
-A reference `super.´m´` refers statically to a method or type ´m´
-in the least proper supertype of the innermost template containing the
-reference.  It evaluates to the member ´m'´ in the actual supertype of
-that template which is equal to ´m´ or which overrides ´m´.  The
-statically referenced member ´m´ must be a type or a
-method.
+The expression `this` can appear in the statement part of a template or compound type.
+It stands for the object being defined by the innermost template or compound type enclosing the reference.
+If this is a compound type, the type of `this` is that compound type.
+If it is a template of a class or object definition with simple name ´C´, the type of this is the same as the type of `´C´.this`.
+
+The expression `´C´.this` is legal in the statement part of an enclosing class or object definition with simple name ´C´.
+It stands for the object being defined by the innermost such definition.
+If the expression's expected type is a stable type, or `´C´.this` occurs as the prefix of a selection, its type is `´C´.this.type`, otherwise it is the self type of class ´C´.
+
+A reference `super.´m´` refers statically to a method or type ´m´ in the least proper supertype of the innermost template containing the reference.
+It evaluates to the member ´m'´ in the actual supertype of that template which is equal to ´m´ or which overrides ´m´.
+The statically referenced member ´m´ must be a type or a method.
 
 <!-- explanation: so that we need not create several fields for overriding vals -->
 
-If it is
-a method, it must be concrete, or the template
-containing the reference must have a member ´m'´ which overrides ´m´
-and which is labeled `abstract override`.
-
-A reference `´C´.super.´m´` refers statically to a method
-or type ´m´ in the least proper supertype of the innermost enclosing class or
-object definition named ´C´ which encloses the reference. It evaluates
-to the member ´m'´ in the actual supertype of that class or object
-which is equal to ´m´ or which overrides ´m´. The
-statically referenced member ´m´ must be a type or a
-method.  If the statically
-referenced member ´m´ is a method, it must be concrete, or the innermost enclosing
-class or object definition named ´C´ must have a member ´m'´ which
-overrides ´m´ and which is labeled `abstract override`.
-
-The `super` prefix may be followed by a trait qualifier
-`[´T\,´]`, as in `´C´.super[´T\,´].´x´`. This is
-called a _static super reference_.  In this case, the reference is
-to the type or method of ´x´ in the parent trait of ´C´ whose simple
-name is ´T´. That member must be uniquely defined. If it is a method,
-it must be concrete.
+If it is a method, it must be concrete, or the template containing the reference must have a member ´m'´ which overrides ´m´ and which is labeled `abstract override`.
+
+A reference `´C´.super.´m´` refers statically to a method or type ´m´ in the least proper supertype of the innermost enclosing class or object definition named ´C´ which encloses the reference.
+It evaluates to the member ´m'´ in the actual supertype of that class or object
+which is equal to ´m´ or which overrides ´m´.
+The statically referenced member ´m´ must be a type or a method.
+If the statically referenced member ´m´ is a method, it must be concrete, or the innermost enclosing class or object definition named ´C´ must have a member ´m'´ which overrides ´m´ and which is labeled `abstract override`.
+
+The `super` prefix may be followed by a trait qualifier `[´T\,´]`, as in `´C´.super[´T\,´].´x´`.
+This is called a _static super reference_.
+In this case, the reference is to the type or method of ´x´ in the parent trait of ´C´ whose simple name is ´T´.
+That member must be uniquely defined.
+If it is a method, it must be concrete.
 
 ###### Example
 Consider the following class definitions
@@ -217,8 +174,7 @@ class D extends A with B {
 }
 ```
 
-The linearization of class `C` is `{C, B, Root}` and
-the linearization of class `D` is `{D, B, A, Root}`.
+The linearization of class `C` is `{C, B, Root}` and the linearization of class `D` is `{D, B, A, Root}`.
 Then we have:
 
 ```scala
@@ -232,8 +188,7 @@ Then we have:
 (new D).superD == "B"
 ```
 
-Note that the `superB` method returns different results
-depending on whether `B` is mixed in with class `Root` or `A`.
+Note that the `superB` method returns different results depending on whether `B` is mixed in with class `Root` or `A`.
 
 ## Function Applications
 
@@ -246,9 +201,13 @@ ArgumentExprs ::=  ‘(’ [Exprs] ‘)’
 Exprs         ::=  Expr {‘,’ Expr}
 ```
 
-An application `´f(e_1, ..., e_m)´` applies the function `´f´` to the argument expressions `´e_1, ..., e_m´`. For this expression to be well-typed, the function must be *applicable* to its arguments, which is defined next by case analysis on ´f´'s type.
+An application `´f(e_1, ..., e_m)´` applies the function `´f´` to the argument expressions `´e_1, ..., e_m´`.
+For this expression to be well-typed, the function must be *applicable* to its arguments, which is defined next by case analysis on ´f´'s type.
 
-If ´f´ has a method type `(´p_1´:´T_1, ..., p_n´:´T_n´)´U´`, each argument expression ´e_i´ is typed with the corresponding parameter type ´T_i´ as expected type. Let ´S_i´ be the type of argument ´e_i´ ´(i = 1, ..., m)´. The method ´f´ must be _applicable_ to its arguments ´e_1, ..., e_n´ of types ´S_1, ..., S_n´. We say that an argument expression ´e_i´ is a _named_ argument if it has the form `´x_i=e'_i´` and `´x_i´` is one of the parameter names `´p_1, ..., p_n´`.
+If ´f´ has a method type `(´p_1´:´T_1, ..., p_n´:´T_n´)´U´`, each argument expression ´e_i´ is typed with the corresponding parameter type ´T_i´ as expected type.
+Let ´S_i´ be the type of argument ´e_i´ ´(i = 1, ..., m)´.
+The method ´f´ must be _applicable_ to its arguments ´e_1, ..., e_n´ of types ´S_1, ..., S_n´.
+We say that an argument expression ´e_i´ is a _named_ argument if it has the form `´x_i=e'_i´` and `´x_i´` is one of the parameter names `´p_1, ..., p_n´`.
 
 Once the types ´S_i´ have been determined, the method ´f´ of the above method type is said to be applicable if all of the following conditions hold:
   - for every named argument ´p_j=e_i'´ the type ´S_i´ is [compatible](03-types.html#compatibility) with the parameter type ´T_j´;
@@ -258,57 +217,37 @@ Once the types ´S_i´ have been determined, the method ´f´ of the above metho
 If ´f´ is a polymorphic method, [local type inference](#local-type-inference) is used to instantiate ´f´'s type parameters.
 The polymorphic method is applicable if type inference can determine type arguments so that the instantiated method is applicable.
 
-If ´f´ has some value type, the application is taken to be equivalent to `´f´.apply(´e_1, ..., e_m´)`,
-i.e. the application of an `apply` method defined by ´f´. The value `´f´` is applicable to the given arguments if `´f´.apply` is applicable.
-
-
-The application `´f´(´e_1, ..., e_n´)` evaluates ´f´ and then each argument
-´e_1, ..., e_n´ from left to right, except for arguments that correspond to
-a by-name parameter (see below).  Each argument expression is converted to the
-type of its corresponding formal parameter.  After that, the application is
-rewritten to the function's right hand side, with actual arguments substituted
-for formal parameters.  The result of evaluating the rewritten right-hand side
-is finally converted to the function's declared result type, if one is given.
-
-The case of a formal parameter with a parameterless
-method type `=> ´T´` is treated specially. In this case, the
-corresponding actual argument expression ´e´ is not evaluated before the
-application. Instead, every use of the formal parameter on the
-right-hand side of the rewrite rule entails a re-evaluation of ´e´.
-In other words, the evaluation order for
-`=>`-parameters is _call-by-name_ whereas the evaluation
-order for normal parameters is _call-by-value_.
-Furthermore, it is required that ´e´'s [packed type](#expression-typing)
-conforms to the parameter type ´T´.
-The behavior of by-name parameters is preserved if the application is
-transformed into a block due to named or default arguments. In this case,
-the local value for that parameter has the form `val ´y_i´ = () => ´e´`
-and the argument passed to the function is `´y_i´()`.
-
-The last argument in an application may be marked as a sequence
-argument, e.g. `´e´: _*`. Such an argument must correspond
-to a [repeated parameter](04-basic-declarations-and-definitions.html#repeated-parameters) of type
-`´S´*` and it must be the only argument matching this
-parameter (i.e. the number of formal parameters and actual arguments
-must be the same). Furthermore, the type of ´e´ must conform to
-`scala.Seq[´T´]`, for some type ´T´ which conforms to
-´S´. In this case, the argument list is transformed by replacing the
-sequence ´e´ with its elements. When the application uses named
-arguments, the vararg parameter has to be specified exactly once.
-
-If only a single argument is supplied, it may be supplied as a block expression
-and parentheses can be omitted, in the form `´f´ { block }`. This is valid when
-`f` has a single formal parameter or when all other formal parameters have
-default values.
-
-A function application usually allocates a new frame on the program's
-run-time stack. However, if a local method or a final method calls
-itself as its last action, the call is executed using the stack-frame
-of the caller.
+If ´f´ has some value type, the application is taken to be equivalent to `´f´.apply(´e_1, ..., e_m´)`, i.e. the application of an `apply` method defined by ´f´.
+The value `´f´` is applicable to the given arguments if `´f´.apply` is applicable.
+
+
+The application `´f´(´e_1, ..., e_n´)` evaluates ´f´ and then each argument ´e_1, ..., e_n´ from left to right, except for arguments that correspond to a by-name parameter (see below).
+Each argument expression is converted to the type of its corresponding formal parameter.
+After that, the application is rewritten to the function's right hand side, with actual arguments substituted for formal parameters.
+The result of evaluating the rewritten right-hand side is finally converted to the function's declared result type, if one is given.
+
+The case of a formal parameter with a parameterless method type `=> ´T´` is treated specially.
+In this case, the corresponding actual argument expression ´e´ is not evaluated before the application.
+Instead, every use of the formal parameter on the right-hand side of the rewrite rule entails a re-evaluation of ´e´.
+In other words, the evaluation order for `=>`-parameters is _call-by-name_ whereas the evaluation order for normal parameters is _call-by-value_.
+Furthermore, it is required that ´e´'s [packed type](#expression-typing) conforms to the parameter type ´T´.
+The behavior of by-name parameters is preserved if the application is transformed into a block due to named or default arguments.
+In this case, the local value for that parameter has the form `val ´y_i´ = () => ´e´` and the argument passed to the function is `´y_i´()`.
+
+The last argument in an application may be marked as a sequence argument, e.g. `´e´: _*`.
+Such an argument must correspond to a [repeated parameter](04-basic-declarations-and-definitions.html#repeated-parameters) of type `´S´*` and it must be the only argument matching this parameter (i.e. the number of formal parameters and actual arguments must be the same).
+Furthermore, the type of ´e´ must conform to `scala.Seq[´T´]`, for some type ´T´ which conforms to ´S´.
+In this case, the argument list is transformed by replacing the sequence ´e´ with its elements.
+When the application uses named arguments, the vararg parameter has to be specified exactly once.
+
+If only a single argument is supplied, it may be supplied as a block expression and parentheses can be omitted, in the form `´f´ { block }`.
+This is valid when `f` has a single formal parameter or when all other formal parameters have default values.
+
+A function application usually allocates a new frame on the program's run-time stack.
+However, if a local method or a final method calls itself as its last action, the call is executed using the stack-frame of the caller.
 
 ###### Example
-Assume the following method which computes the sum of a
-variable number of arguments:
+Assume the following method which computes the sum of a variable number of arguments:
 
 ```scala
 def sum(xs: Int*) = xs.foldLeft(0)((x, y) => x + y)
@@ -321,7 +260,8 @@ sum(1, 2, 3, 4)
 sum(List(1, 2, 3, 4): _*)
 ```
 
-both yield `10` as result. On the other hand,
+both yield `10` as result.
+On the other hand,
 
 ```scala
 sum(List(1, 2, 3, 4))
@@ -334,25 +274,15 @@ The keyword is ignored.
 
 ### Named and Default Arguments
 
-If an application is to use named arguments ´p = e´ or default
-arguments, the following conditions must hold.
+If an application is to use named arguments ´p = e´ or default arguments, the following conditions must hold.
 
-- For every named argument ´p_i = e_i´ which appears left of a positional argument
-  in the argument list ´e_1 ... e_m´, the argument position ´i´ coincides with
-  the position of parameter ´p_i´ in the parameter list of the applied method.
-- The names ´x_i´ of all named arguments are pairwise distinct and no named
-  argument defines a parameter which is already specified by a
-  positional argument.
-- Every formal parameter ´p_j:T_j´ which is not specified by either a positional
-  or named argument has a default argument.
+- For every named argument ´p_i = e_i´ which appears left of a positional argument in the argument list ´e_1 ... e_m´, the argument position ´i´ coincides with the position of parameter ´p_i´ in the parameter list of the applied method.
+- The names ´x_i´ of all named arguments are pairwise distinct and no named argument defines a parameter which is already specified by a positional argument.
+- Every formal parameter ´p_j:T_j´ which is not specified by either a positional or named argument has a default argument.
 
-If the application uses named or default
-arguments the following transformation is applied to convert it into
-an application without named or default arguments.
+If the application uses named or default arguments the following transformation is applied to convert it into an application without named or default arguments.
 
-If the method ´f´
-has the form `´p.m´[´\mathit{targs}´]` it is transformed into the
-block
+If the method ´f´ has the form `´p.m´[´\mathit{targs}´]` it is transformed into the block
 
 ```scala
 { val q = ´p´
@@ -360,9 +290,8 @@ block
 }
 ```
 
-If the method ´f´ is itself an application expression the transformation
-is applied recursively on ´f´. The result of transforming ´f´ is a block of
-the form
+If the method ´f´ is itself an application expression the transformation is applied recursively on ´f´.
+The result of transforming ´f´ is a block of the form
 
 ```scala
 { val q = ´p´
@@ -373,20 +302,11 @@ the form
 }
 ```
 
-where every argument in ´(\mathit{args}\_1), ..., (\mathit{args}\_l)´ is a reference to
-one of the values ´x_1, ..., x_k´. To integrate the current application
-into the block, first a value definition using a fresh name ´y_i´ is created
-for every argument in ´e_1, ..., e_m´, which is initialised to ´e_i´ for
-positional arguments and to ´e'_i´ for named arguments of the form
-`´x_i=e'_i´`. Then, for every parameter which is not specified
-by the argument list, a value definition using a fresh name ´z_i´ is created,
-which is initialized using the method computing the
-[default argument](04-basic-declarations-and-definitions.html#function-declarations-and-definitions) of
-this parameter.
-
-Let ´\mathit{args}´ be a permutation of the generated names ´y_i´ and ´z_i´ such such
-that the position of each name matches the position of its corresponding
-parameter in the method type `(´p_1:T_1, ..., p_n:T_n´)´U´`.
+where every argument in ´(\mathit{args}\_1), ..., (\mathit{args}\_l)´ is a reference to one of the values ´x_1, ..., x_k´.
+To integrate the current application into the block, first a value definition using a fresh name ´y_i´ is created for every argument in ´e_1, ..., e_m´, which is initialised to ´e_i´ for positional arguments and to ´e'_i´ for named arguments of the form `´x_i=e'_i´`.
+Then, for every parameter which is not specified by the argument list, a value definition using a fresh name ´z_i´ is created, which is initialized using the method computing the [default argument](04-basic-declarations-and-definitions.html#function-declarations-and-definitions) of this parameter.
+
+Let ´\mathit{args}´ be a permutation of the generated names ´y_i´ and ´z_i´ such such that the position of each name matches the position of its corresponding parameter in the method type `(´p_1:T_1, ..., p_n:T_n´)´U´`.
 The final result of the transformation is a block of the form
 
 ```scala
@@ -406,20 +326,15 @@ The final result of the transformation is a block of the form
 
 ### Signature Polymorphic Methods
 
-For invocations of signature polymorphic methods of the target platform `´f´(´e_1, ..., e_m´)`,
-the invoked method has a different method type `(´p_1´:´T_1, ..., p_n´:´T_n´)´U´` at each call
-site. The parameter types `´T_, ..., T_n´` are the types of the argument expressions
-`´e_1, ..., e_m´`. If the declared return type `´R´` of the signature polymorphic method is
-any type other than `scala.AnyRef`, then the return type `´U´` is `´R´`.
-Otherwise, `´U´` is the expected type at the call site. If the expected type is undefined then
-`´U´` is `scala.AnyRef`. The parameter names `´p_1, ..., p_n´` are fresh.
+For invocations of signature polymorphic methods of the target platform `´f´(´e_1, ..., e_m´)`, the invoked method has a different method type `(´p_1´:´T_1, ..., p_n´:´T_n´)´U´` at each call site.
+The parameter types `´T_, ..., T_n´` are the types of the argument expressions `´e_1, ..., e_m´`.
+If the declared return type `´R´` of the signature polymorphic method is any type other than `scala.AnyRef`, then the return type `´U´` is `´R´`.
+Otherwise, `´U´` is the expected type at the call site. If the expected type is undefined then `´U´` is `scala.AnyRef`.
+The parameter names `´p_1, ..., p_n´` are fresh.
 
 ###### Note
 
-On the Java platform version 11 and later, signature polymorphic methods are native,
-members of `java.lang.invoke.MethodHandle` or `java.lang.invoke.VarHandle`, and have a single
-repeated parameter of type `java.lang.Object*`.
-
+On the Java platform version 11 and later, signature polymorphic methods are native, members of `java.lang.invoke.MethodHandle` or `java.lang.invoke.VarHandle`, and have a single repeated parameter of type `java.lang.Object*`.
 
 ## Method Values
 
@@ -428,13 +343,9 @@ SimpleExpr    ::=  SimpleExpr1 ‘_’
 ```
 
 The expression `´e´ _` is well-formed if ´e´ is of method
-type or if ´e´ is a call-by-name parameter.  If ´e´ is a method with
-parameters, `´e´ _` represents ´e´ converted to a function
-type by [eta expansion](#eta-expansion-section). If ´e´ is a
-parameterless method or call-by-name parameter of type
-`=> ´T´`, `´e´ _` represents the function of type
-`() => ´T´`, which evaluates ´e´ when it is applied to the empty
-parameter list `()`.
+type or if ´e´ is a call-by-name parameter.
+If ´e´ is a method with parameters, `´e´ _` represents ´e´ converted to a function type by [eta expansion](#eta-expansion-section).
+If ´e´ is a parameterless method or call-by-name parameter of type `=> ´T´`, `´e´ _` represents the function of type `() => ´T´`, which evaluates ´e´ when it is applied to the empty parameter list `()`.
 
 ###### Example
 The method values in the left column are each equivalent to the [eta-expanded expressions](#eta-expansion-section) on the right.
@@ -447,8 +358,7 @@ The method values in the left column are each equivalent to the [eta-expanded ex
 |`(1 to 9).fold(z)_`            | `{ val eta1 = 1 to 9; val eta2 = z; op => eta1.fold(eta2)(op) }`            |
 |`Some(1).fold(??? : Int)_`     | `{ val eta1 = Some(1); val eta2 = () => ???; op => eta1.fold(eta2())(op) }` |
 
-Note that a space is necessary between a method name and the trailing underscore
-because otherwise the underscore would be considered part of the name.
+Note that a space is necessary between a method name and the trailing underscore because otherwise the underscore would be considered part of the name.
 
 ## Type Applications
 
@@ -456,25 +366,15 @@ because otherwise the underscore would be considered part of the name.
 SimpleExpr    ::=  SimpleExpr TypeArgs
 ```
 
-A _type application_ `´e´[´T_1, ..., T_n´]` instantiates
-a polymorphic value ´e´ of type
-`[´a_1´ >: ´L_1´ <: ´U_1, ..., a_n´ >: ´L_n´ <: ´U_n´]´S´`
-with argument types
-`´T_1, ..., T_n´`.  Every argument type ´T_i´ must obey
-the corresponding bounds ´L_i´ and ´U_i´.  That is, for each ´i = 1
-, ..., n´, we must have ´\sigma L_i <: T_i <: \sigma
-U_i´, where ´\sigma´ is the substitution ´[a_1 := T_1, ..., a_n
-:= T_n]´.  The type of the application is ´\sigma S´.
+A _type application_ `´e´[´T_1, ..., T_n´]` instantiates a polymorphic value ´e´ of type `[´a_1´ >: ´L_1´ <: ´U_1, ..., a_n´ >: ´L_n´ <: ´U_n´]´S´` with argument types `´T_1, ..., T_n´`.
+Every argument type ´T_i´ must obey the corresponding bounds ´L_i´ and ´U_i´.
+That is, for each ´i = 1, ..., n´, we must have ´\sigma L_i <: T_i <: \sigma U_i´, where ´\sigma´ is the substitution ´[a_1 := T_1, ..., a_n
+:= T_n]´.
+The type of the application is ´\sigma S´.
 
-If the function part ´e´ is of some value type, the type application
-is taken to be equivalent to
-`´e´.apply[´T_1 , ...,´ T´_n´]`, i.e. the application of an `apply` method defined by
-´e´.
+If the function part ´e´ is of some value type, the type application is taken to be equivalent to `´e´.apply[´T_1 , ...,´ T´_n´]`, i.e. the application of an `apply` method defined by ´e´.
 
-Type applications can be omitted if
-[local type inference](#local-type-inference) can infer best type parameters
-for a polymorphic method from the types of the actual method arguments
-and the expected result type.
+Type applications can be omitted if [local type inference](#local-type-inference) can infer best type parameters for a polymorphic method from the types of the actual method arguments and the expected result type.
 
 ## Tuples
 
@@ -482,11 +382,8 @@ and the expected result type.
 SimpleExpr   ::=  ‘(’ [Exprs] ‘)’
 ```
 
-A _tuple expression_ `(´e_1´, ..., ´e_n´)` is an alias
-for the class instance creation
-`scala.Tuple´n´(´e_1´, ..., ´e_n´)`, where ´n \geq 2´.
-The empty tuple
-`()` is the unique value of type `scala.Unit`.
+A _tuple expression_ `(´e_1´, ..., ´e_n´)` is an alias for the class instance creation `scala.Tuple´n´(´e_1´, ..., ´e_n´)`, where ´n \geq 2´.
+The empty tuple `()` is the unique value of type `scala.Unit`.
 
 ## Instance Creation Expressions
 
@@ -494,44 +391,33 @@ The empty tuple
 SimpleExpr     ::=  ‘new’ (ClassTemplate | TemplateBody)
 ```
 
-A _simple instance creation expression_ is of the form
-`new ´c´`
-where ´c´ is a [constructor invocation](05-classes-and-objects.html#constructor-invocations). Let ´T´ be
-the type of ´c´. Then ´T´ must
-denote a (a type instance of) a non-abstract subclass of
-`scala.AnyRef`. Furthermore, the _concrete self type_ of the
-expression must conform to the [self type](05-classes-and-objects.html#templates) of the class denoted by
-´T´. The concrete self type is normally
-´T´, except if the expression `new ´c´` appears as the
-right hand side of a value definition
+A _simple instance creation expression_ is of the form `new ´c´` where ´c´ is a [constructor invocation](05-classes-and-objects.html#constructor-invocations).
+Let ´T´ be the type of ´c´.
+Then ´T´ must denote a (a type instance of) a non-abstract subclass of `scala.AnyRef`.
+Furthermore, the _concrete self type_ of the expression must conform to the [self type](05-classes-and-objects.html#templates) of the class denoted by ´T´.
+The concrete self type is normally ´T´, except if the expression `new ´c´` appears as the right hand side of a value definition
 
 ```scala
 val ´x´: ´S´ = new ´c´
 ```
 
 (where the type annotation `: ´S´` may be missing).
-In the latter case, the concrete self type of the expression is the
-compound type `´T´ with ´x´.type`.
+In the latter case, the concrete self type of the expression is the compound type `´T´ with ´x´.type`.
 
-The expression is evaluated by creating a fresh
-object of type ´T´ which is initialized by evaluating ´c´. The
-type of the expression is ´T´.
+The expression is evaluated by creating a fresh object of type ´T´ which is initialized by evaluating ´c´.
+The type of the expression is ´T´.
 
-A _general instance creation expression_ is of the form
-`new ´t´` for some [class template](05-classes-and-objects.html#templates) ´t´.
+A _general instance creation expression_ is of the form `new ´t´` for some [class template](05-classes-and-objects.html#templates) ´t´.
 Such an expression is equivalent to the block
 
 ```scala
 { class ´a´ extends ´t´; new ´a´ }
 ```
 
-where ´a´ is a fresh name of an _anonymous class_ which is
-inaccessible to user programs.
+where ´a´ is a fresh name of an _anonymous class_ which is inaccessible to user programs.
 
-There is also a shorthand form for creating values of structural
-types: If `{´D´}` is a class body, then
-`new {´D´}` is equivalent to the general instance creation expression
-`new AnyRef{´D´}`.
+There is also a shorthand form for creating values of structural types:
+If `{´D´}` is a class body, then `new {´D´}` is equivalent to the general instance creation expression `new AnyRef{´D´}`.
 
 ###### Example
 Consider the following structural instance creation expression:
@@ -562,45 +448,27 @@ BlockExpr  ::=  ‘{’ CaseClauses ‘}’
 Block      ::=  BlockStat {semi BlockStat} [ResultExpr]
 ```
 
-A _block expression_ `{´s_1´; ...; ´s_n´; ´e\,´}` is
-constructed from a sequence of block statements ´s_1, ..., s_n´
-and a final expression ´e´.  The statement sequence may not contain
-two definitions or declarations that bind the same name in the same
-namespace.  The final expression can be omitted, in which
-case the unit value `()` is assumed.
+A _block expression_ `{´s_1´; ...; ´s_n´; ´e\,´}` is constructed from a sequence of block statements ´s_1, ..., s_n´ and a final expression ´e´.
+The statement sequence may not contain two definitions or declarations that bind the same name in the same namespace.
+The final expression can be omitted, in which case the unit value `()` is assumed.
 
-The expected type of the final expression ´e´ is the expected
-type of the block. The expected type of all preceding statements is
-undefined.
+The expected type of the final expression ´e´ is the expected type of the block.
+The expected type of all preceding statements is undefined.
 
-The type of a block `´s_1´; ...; ´s_n´; ´e´` is
-`´T´ forSome {´\,Q\,´}`, where ´T´ is the type of ´e´ and ´Q´
-contains [existential clauses](03-types.html#existential-types)
-for every value or type name which is free in ´T´
-and which is defined locally in one of the statements ´s_1, ..., s_n´.
+The type of a block `´s_1´; ...; ´s_n´; ´e´` is `´T´ forSome {´\,Q\,´}`, where ´T´ is the type of ´e´ and ´Q´ contains [existential clauses](03-types.html#existential-types) for every value or type name which is free in ´T´ and which is defined locally in one of the statements ´s_1, ..., s_n´.
 We say the existential clause _binds_ the occurrence of the value or type name.
 Specifically,
 
-- A locally defined type definition  `type´\;t = T´`
-  is bound by the existential clause `type´\;t >: T <: T´`.
-  It is an error if ´t´ carries type parameters.
-- A locally defined value definition `val´\;x: T = e´` is
-  bound by the existential clause `val´\;x: T´`.
-- A locally defined class definition `class´\;c´ extends´\;t´`
-  is bound by the existential clause `type´\;c <: T´` where
-  ´T´ is the least class type or refinement type which is a proper
-  supertype of the type ´c´. It is an error if ´c´ carries type parameters.
-- A locally defined object definition `object´\;x\;´extends´\;t´`
-  is bound by the existential clause `val´\;x: T´` where
-  ´T´ is the least class type or refinement type which is a proper supertype of the type
-  `´x´.type`.
-
-Evaluation of the block entails evaluation of its
-statement sequence, followed by an evaluation of the final expression
-´e´, which defines the result of the block.
-
-A block expression `{´c_1´; ...; ´c_n´}` where ´s_1, ..., s_n´ are
-case clauses forms a [pattern matching anonymous function](08-pattern-matching.html#pattern-matching-anonymous-functions).
+- A locally defined type definition  `type´\;t = T´` is bound by the existential clause `type´\;t >: T <: T´`.
+It is an error if ´t´ carries type parameters.
+- A locally defined value definition `val´\;x: T = e´` is bound by the existential clause `val´\;x: T´`.
+- A locally defined class definition `class´\;c´ extends´\;t´` is bound by the existential clause `type´\;c <: T´` where ´T´ is the least class type or refinement type which is a proper supertype of the type ´c´.
+It is an error if ´c´ carries type parameters.
+- A locally defined object definition `object´\;x\;´extends´\;t´` is bound by the existential clause `val´\;x: T´` where ´T´ is the least class type or refinement type which is a proper supertype of the type `´x´.type`.
+
+Evaluation of the block entails evaluation of its statement sequence, followed by an evaluation of the final expression ´e´, which defines the result of the block.
+
+A block expression `{´c_1´; ...; ´c_n´}` where ´s_1, ..., s_n´ are case clauses forms a [pattern matching anonymous function](08-pattern-matching.html#pattern-matching-anonymous-functions).
 
 ###### Example
 Assuming a class `Ref[T](x: T)`, the block
@@ -616,9 +484,7 @@ The block
 { class C extends B {´\ldots´} ; new C }
 ```
 
-simply has type `B`, because with the rules [here](03-types.html#simplification-rules)
-the existentially quantified type
-`_1 forSome { type _1 <: B }` can be simplified to `B`.
+simply has type `B`, because with the rules [here](03-types.html#simplification-rules) the existentially quantified type `_1 forSome { type _1 <: B }` can be simplified to `B`.
 
 ## Prefix, Infix, and Postfix Operations
 
@@ -633,35 +499,26 @@ Expressions can be constructed from operands and operators.
 
 ### Prefix Operations
 
-A prefix operation ´\mathit{op};e´ consists of a prefix operator ´\mathit{op}´, which
-must be one of the identifiers ‘`+`’, ‘`-`’, ‘`!`’ or ‘`~`’,
-which must not be enclosed in backquotes.
-The expression ´\mathit{op};e´ is
-equivalent to the postfix method application
-`e.unary_´\mathit{op}´`.
+A prefix operation ´\mathit{op};e´ consists of a prefix operator ´\mathit{op}´, which must be one of the identifiers ‘`+`’, ‘`-`’, ‘`!`’ or ‘`~`’, which must not be enclosed in backquotes.
+The expression ´\mathit{op};e´ is equivalent to the postfix method application `e.unary_´\mathit{op}´`.
 
 <!-- TODO: Generalize to arbitrary operators -->
 
-Prefix operators are different from normal method applications in
-that their operand expression need not be atomic. For instance, the
-input sequence `-sin(x)` is read as `-(sin(x))`, whereas the
-method application `negate sin(x)` would be parsed as the
-application of the infix operator `sin` to the operands
-`negate` and `(x)`.
+Prefix operators are different from normal method applications in that their operand expression need not be atomic.
+For instance, the input sequence `-sin(x)` is read as `-(sin(x))`, whereas the method application `negate sin(x)` would be parsed as the application of the infix operator `sin` to the operands `negate` and `(x)`.
 
 ### Postfix Operations
 
-A postfix operator can be an arbitrary identifier. The postfix
-operation ´e;\mathit{op}´ is interpreted as ´e.\mathit{op}´.
+A postfix operator can be an arbitrary identifier.
+The postfix operation ´e;\mathit{op}´ is interpreted as ´e.\mathit{op}´.
 
 ### Infix Operations
 
-An infix operator can be an arbitrary identifier. Infix operators have
-precedence and associativity defined as follows:
+An infix operator can be an arbitrary identifier.
+Infix operators have precedence and associativity defined as follows:
 
-The _precedence_ of an infix operator 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.
+The _precedence_ of an infix operator 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.
 
 ```scala
 (all letters, as defined in [chapter 1](01-lexical-syntax.html), including `_` and `$`)
@@ -676,65 +533,42 @@ precedence, with characters on the same line having the same precedence.
 (other operator characters, as defined in [chapter 1](01-lexical-syntax.html), including Unicode categories `Sm` and `So`)
 ```
 
-That is, operators starting with a letter have lowest precedence,
-followed by operators starting with ‘`|`’, etc.
+That is, operators starting with a letter have lowest precedence, followed by operators starting with ‘`|`’, etc.
 
-There's one exception to this rule, which concerns
-[_assignment operators_](#assignment-operators).
-The precedence of an assignment operator is the same as the one
-of simple assignment `(=)`. That is, it is lower than the
-precedence of any other operator.
+There's one exception to this rule, which concerns [_assignment operators_](#assignment-operators).
+The precedence of an assignment operator is the same as the one of simple assignment `(=)`.
+That is, it is lower than the precedence of any other operator.
 
 The _associativity_ of an operator is determined by the operator's
-last character.  Operators ending in a colon ‘`:`’ are
-right-associative. All other operators are left-associative.
-
-Precedence and associativity of operators determine the grouping of
-parts of an expression as follows.
-
-- If there are several infix operations in an
-  expression, then operators with higher precedence bind more closely
-  than operators with lower precedence.
-- If there are consecutive infix
-  operations ´e_0; \mathit{op}\_1; e_1; \mathit{op}\_2 ... \mathit{op}\_n; e_n´
-  with operators ´\mathit{op}\_1, ..., \mathit{op}\_n´ of the same precedence,
-  then all these operators must
-  have the same associativity. If all operators are left-associative,
-  the sequence is interpreted as
-  ´(...(e_0;\mathit{op}\_1;e_1);\mathit{op}\_2...);\mathit{op}\_n;e_n´.
-  Otherwise, if all operators are right-associative, the
-  sequence is interpreted as
-  ´e_0;\mathit{op}\_1;(e_1;\mathit{op}\_2;(... \mathit{op}\_n;e_n)...)´.
-- Postfix operators always have lower precedence than infix
-  operators. E.g. ´e_1;\mathit{op}\_1;e_2;\mathit{op}\_2´ is always equivalent to
-  ´(e_1;\mathit{op}\_1;e_2);\mathit{op}\_2´.
-
-The right-hand operand of a left-associative operator may consist of
-several arguments enclosed in parentheses, e.g. ´e;\mathit{op};(e_1,...,e_n)´.
+last character.
+Operators ending in a colon ‘`:`’ are right-associative.
+All other operators are left-associative.
+
+Precedence and associativity of operators determine the grouping of parts of an expression as follows.
+
+- If there are several infix operations in an expression, then operators with higher precedence bind more closely than operators with lower precedence.
+- If there are consecutive infix operations ´e_0; \mathit{op}\_1; e_1; \mathit{op}\_2 ... \mathit{op}\_n; e_n´ with operators ´\mathit{op}\_1, ..., \mathit{op}\_n´ of the same precedence, then all these operators must have the same associativity.
+If all operators are left-associative, the sequence is interpreted as ´(...(e_0;\mathit{op}\_1;e_1);\mathit{op}\_2...);\mathit{op}\_n;e_n´.
+Otherwise, if all operators are right-associative, the sequence is interpreted as ´e_0;\mathit{op}\_1;(e_1;\mathit{op}\_2;(... \mathit{op}\_n;e_n)...)´.
+- Postfix operators always have lower precedence than infix operators. E.g. ´e_1;\mathit{op}\_1;e_2;\mathit{op}\_2´ is always equivalent to ´(e_1;\mathit{op}\_1;e_2);\mathit{op}\_2´.
+
+The right-hand operand of a left-associative operator may consist of several arguments enclosed in parentheses, e.g. ´e;\mathit{op};(e_1,...,e_n)´.
 This expression is then interpreted as ´e.\mathit{op}(e_1,...,e_n)´.
 
-A left-associative binary
-operation ´e_1;\mathit{op};e_2´ is interpreted as ´e_1.\mathit{op}(e_2)´. If ´\mathit{op}´ is
-right-associative and its parameter is passed by name, the same operation is interpreted as
-´e_2.\mathit{op}(e_1)´. If ´\mathit{op}´ is right-associative and its parameter is passed by value,
-it is interpreted as `{ val ´x´=´e_1´; ´e_2´.´\mathit{op}´(´x\,´) }`, where ´x´ is a fresh name.
+A left-associative binary operation ´e_1;\mathit{op};e_2´ is interpreted as ´e_1.\mathit{op}(e_2)´. If ´\mathit{op}´ is right-associative and its parameter is passed by name, the same operation is interpreted as ´e_2.\mathit{op}(e_1)´.
+If ´\mathit{op}´ is right-associative and its parameter is passed by value, it is interpreted as `{ val ´x´=´e_1´; ´e_2´.´\mathit{op}´(´x\,´) }`, where ´x´ is a fresh name.
 
 ### Assignment Operators
 
-An _assignment operator_ is an operator symbol (syntax category
-`op` in [Identifiers](01-lexical-syntax.html#identifiers)) that ends in an equals character
-“`=`”, with the following exceptions:
+An _assignment operator_ is an operator symbol (syntax category `op` in [Identifiers](01-lexical-syntax.html#identifiers)) that ends in an equals character “`=`”, with the following exceptions:
 
 1. the operator also starts with an equals character, or
 1. the operator is one of `(<=)`, `(>=)`, `(!=)`.
 
-Assignment operators are treated specially in that they
-can be expanded to assignments if no other interpretation is valid.
+Assignment operators are treated specially in that they can be expanded to assignments if no other interpretation is valid.
 
-Let's consider an assignment operator such as `+=` in an infix
-operation `´l´ += ´r´`, where ´l´, ´r´ are expressions.
-This operation can be re-interpreted as an operation which corresponds
-to the assignment
+Let's consider an assignment operator such as `+=` in an infix operation `´l´ += ´r´`, where ´l´, ´r´ are expressions.
+This operation can be re-interpreted as an operation which corresponds to the assignment
 
 ```scala
 ´l´ = ´l´ + ´r´
@@ -744,14 +578,9 @@ except that the operation's left-hand-side ´l´ is evaluated only once.
 
 The re-interpretation occurs if the following two conditions are fulfilled.
 
-1. The left-hand-side ´l´ does not have a member named
-   `+=`, and also cannot be converted by an
-   [implicit conversion](#implicit-conversions)
-   to a value with a member named `+=`.
+1. The left-hand-side ´l´ does not have a member named `+=`, and also cannot be converted by an [implicit conversion](#implicit-conversions) to a value with a member named `+=`.
 1. The assignment `´l´ = ´l´ + ´r´` is type-correct.
-   In particular this implies that ´l´ refers to a variable or object
-   that can be assigned to, and that is convertible to a value with a member
-   named `+`.
+In particular this implies that ´l´ refers to a variable or object that can be assigned to, and that is convertible to a value with a member named `+`.
 
 ## Typed Expressions
 
@@ -759,9 +588,9 @@ The re-interpretation occurs if the following two conditions are fulfilled.
 Expr1              ::=  PostfixExpr ‘:’ CompoundType
 ```
 
-The _typed expression_ ´e: T´ has type ´T´. The type of
-expression ´e´ is expected to conform to ´T´. The result of
-the expression is the value of ´e´ converted to type ´T´.
+The _typed expression_ ´e: T´ has type ´T´.
+The type of expression ´e´ is expected to conform to ´T´.
+The result of the expression is the value of ´e´ converted to type ´T´.
 
 ###### Example
 Here are examples of well-typed and ill-typed expressions.
@@ -778,9 +607,7 @@ Here are examples of well-typed and ill-typed expressions.
 Expr1              ::=  PostfixExpr ‘:’ Annotation {Annotation}
 ```
 
-An _annotated expression_ `´e´: @´a_1´ ... @´a_n´`
-attaches [annotations](11-annotations.html#user-defined-annotations) ´a_1, ..., a_n´ to the
-expression ´e´.
+An _annotated expression_ `´e´: @´a_1´ ... @´a_n´` attaches [annotations](11-annotations.html#user-defined-annotations) ´a_1, ..., a_n´ to the expression ´e´.
 
 ## Assignments
 
@@ -790,25 +617,14 @@ Expr1        ::=  [SimpleExpr ‘.’] id ‘=’ Expr
                |  SimpleExpr1 ArgumentExprs ‘=’ Expr
 ```
 
-The interpretation of an assignment to a simple variable `´x´ = ´e´`
-depends on the definition of ´x´. If ´x´ denotes a mutable
-variable, then the assignment changes the current value of ´x´ to be
-the result of evaluating the expression ´e´. The type of ´e´ is
-expected to conform to the type of ´x´. If ´x´ is a parameterless
-method defined in some template, and the same template contains a
-setter method `´x´_=` as member, then the assignment
-`´x´ = ´e´` is interpreted as the invocation
-`´x´_=(´e\,´)` of that setter method.  Analogously, an
-assignment `´f.x´ = ´e´` to a parameterless method ´x´
-is interpreted as the invocation `´f.x´_=(´e\,´)`.
-If ´x´ is an application of a unary operator, then the expression
-is interpreted as though it were written as the explicit application
-`´x´.unary_´\mathit{op}´`, namely, as `´x´.unary_´\mathit{op}´_=(´e\,´)`.
-
-An assignment `´f´(´\mathit{args}\,´) = ´e´` with a method application to the
-left of the ‘`=`’ operator is interpreted as
-`´f.´update(´\mathit{args}´, ´e\,´)`, i.e.
-the invocation of an `update` method defined by ´f´.
+The interpretation of an assignment to a simple variable `´x´ = ´e´` depends on the definition of ´x´.
+If ´x´ denotes a mutable variable, then the assignment changes the current value of ´x´ to be the result of evaluating the expression ´e´.
+The type of ´e´ is expected to conform to the type of ´x´.
+If ´x´ is a parameterless method defined in some template, and the same template contains a setter method `´x´_=` as member, then the assignment `´x´ = ´e´` is interpreted as the invocation `´x´_=(´e\,´)` of that setter method.
+Analogously, an assignment `´f.x´ = ´e´` to a parameterless method ´x´ is interpreted as the invocation `´f.x´_=(´e\,´)`.
+If ´x´ is an application of a unary operator, then the expression is interpreted as though it were written as the explicit application `´x´.unary_´\mathit{op}´`, namely, as `´x´.unary_´\mathit{op}´_=(´e\,´)`.
+
+An assignment `´f´(´\mathit{args}\,´) = ´e´` with a method application to the left of the ‘`=`’ operator is interpreted as `´f.´update(´\mathit{args}´, ´e\,´)`, i.e. the invocation of an `update` method defined by ´f´.
 
 ###### Example
 Here are some assignment expressions and their equivalent expansions.
@@ -846,8 +662,7 @@ def matmul(xss: Array[Array[Double]], yss: Array[Array[Double]]) = {
 }
 ```
 
-Desugaring the array accesses and assignments yields the following
-expanded version:
+Desugaring the array accesses and assignments yields the following expanded version:
 
 ```scala
 def matmul(xss: Array[Array[Double]], yss: Array[Array[Double]]) = {
@@ -877,25 +692,17 @@ def matmul(xss: Array[Array[Double]], yss: Array[Array[Double]]) = {
 Expr1          ::=  ‘if’ ‘(’ Expr ‘)’ {nl} Expr [[semi] ‘else’ Expr]
 ```
 
-The _conditional expression_ `if (´e_1´) ´e_2´ else ´e_3´` chooses
-one of the values of ´e_2´ and ´e_3´, depending on the
-value of ´e_1´. The condition ´e_1´ is expected to
-conform to type `Boolean`.  The then-part ´e_2´ and the
-else-part ´e_3´ are both expected to conform to the expected
-type of the conditional expression. The type of the conditional
-expression is the [weak least upper bound](03-types.html#weak-conformance)
-of the types of ´e_2´ and
-´e_3´.  A semicolon preceding the `else` symbol of a
-conditional expression is ignored.
+The _conditional expression_ `if (´e_1´) ´e_2´ else ´e_3´` chooses one of the values of ´e_2´ and ´e_3´, depending on the value of ´e_1´.
+The condition ´e_1´ is expected to conform to type `Boolean`.
+The then-part ´e_2´ and the else-part ´e_3´ are both expected to conform to the expected type of the conditional expression.
+The type of the conditional expression is the [weak least upper bound](03-types.html#weak-conformance) of the types of ´e_2´ and ´e_3´.
+A semicolon preceding the `else` symbol of a conditional expression is ignored.
 
-The conditional expression is evaluated by evaluating first
-´e_1´. If this evaluates to `true`, the result of
-evaluating ´e_2´ is returned, otherwise the result of
-evaluating ´e_3´ is returned.
+The conditional expression is evaluated by evaluating first ´e_1´.
+If this evaluates to `true`, the result of evaluating ´e_2´ is returned, otherwise the result of evaluating ´e_3´ is returned.
 
-A short form of the conditional expression eliminates the
-else-part. The conditional expression `if (´e_1´) ´e_2´` is
-evaluated as if it was `if (´e_1´) ´e_2´ else ()`.
+A short form of the conditional expression eliminates the else-part.
+The conditional expression `if (´e_1´) ´e_2´` is evaluated as if it was `if (´e_1´) ´e_2´ else ()`.
 
 ## While Loop Expressions
 
@@ -903,9 +710,7 @@ evaluated as if it was `if (´e_1´) ´e_2´ else ()`.
 Expr1          ::=  ‘while’ ‘(’ Expr ‘)’ {nl} Expr
 ```
 
-The _while loop expression_ `while (´e_1´) ´e_2´` is typed and
-evaluated as if it was an application of `whileLoop (´e_1´) (´e_2´)` where
-the hypothetical method `whileLoop` is defined as follows.
+The _while loop expression_ `while (´e_1´) ´e_2´` is typed and evaluated as if it was an application of `whileLoop (´e_1´) (´e_2´)` where the hypothetical method `whileLoop` is defined as follows.
 
 ```scala
 def whileLoop(cond: => Boolean)(body: => Unit): Unit  =
@@ -918,8 +723,7 @@ def whileLoop(cond: => Boolean)(body: => Unit): Unit  =
 Expr1          ::=  ‘do’ Expr [semi] ‘while’ ‘(’ Expr ‘)’
 ```
 
-The _do loop expression_ `do ´e_1´ while (´e_2´)` is typed and
-evaluated as if it was the expression `(´e_1´ ; while (´e_2´) ´e_1´)`.
+The _do loop expression_ `do ´e_1´ while (´e_2´)` is typed and evaluated as if it was the expression `(´e_1´ ; while (´e_2´) ´e_1´)`.
 A semicolon preceding the `while` symbol of a do loop expression is ignored.
 
 ## For Comprehensions and For Loops
@@ -932,57 +736,36 @@ Generator      ::=  [‘case’] Pattern1 ‘<-’ Expr {[semi] Guard | semi Pat
 Guard          ::=  ‘if’ PostfixExpr
 ```
 
-A _for loop_ `for (´\mathit{enums}\,´) ´e´` executes expression ´e´
-for each binding generated by the enumerators ´\mathit{enums}´. 
-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 _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. The precise meaning of generators and guards is
-defined by translation to invocations of four methods: `map`,
-`withFilter`, `flatMap`, and `foreach`. 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
+A _for loop_ `for (´\mathit{enums}\,´) ´e´` executes expression ´e´ for each binding generated by the enumerators ´\mathit{enums}´. 
+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 _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.
+The precise meaning of generators and guards is defined by translation to invocations of four methods: `map`, `withFilter`, `flatMap`, and `foreach`.
+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
 
 ```scala
 ´p´ <- ´e´.withFilter { case ´p´ => true; case _ => false }
 ```
 
-Then, the following rules are applied repeatedly until all
-comprehensions have been eliminated.
+Then, the following rules are applied repeatedly until all comprehensions have been eliminated.
 
-  - A for comprehension
-    `for (´p´ <- ´e\,´) yield ´e'´`
-    is translated to
-    `´e´.map { case ´p´ => ´e'´ }`.
-  - A for loop
-    `for (´p´ <- ´e\,´) ´e'´`
-    is translated to
-    `´e´.foreach { case ´p´ => ´e'´ }`.
+  - A for comprehension `for (´p´ <- ´e\,´) yield ´e'´` is translated to `´e´.map { case ´p´ => ´e'´ }`.
+  - A for loop `for (´p´ <- ´e\,´) ´e'´` is translated to `´e´.foreach { case ´p´ => ´e'´ }`.
   - A for comprehension
 
     ```scala
     for (´p´ <- ´e´; ´p'´ <- ´e'; ...´) yield ´e''´
     ```
 
-    where `...` is a (possibly empty)
-    sequence of generators, definitions, or guards,
-    is translated to
+    where `...` is a (possibly empty) sequence of generators, definitions, or guards, is translated to
 
     ```scala
     ´e´.flatMap { case ´p´ => for (´p'´ <- ´e'; ...´) yield ´e''´ }
@@ -994,30 +777,22 @@ comprehensions have been eliminated.
     for (´p´ <- ´e´; ´p'´ <- ´e'; ...´) ´e''´
     ```
 
-    where `...` is a (possibly empty)
-    sequence of generators, definitions, or guards,
-    is translated to
+    where `...` is a (possibly empty) sequence of generators, definitions, or guards, is translated to
 
     ```scala
     ´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((´x_1, ..., x_n´) => ´g\,´)` where ´x_1, ..., x_n´ are the free variables of ´p´.
 
-  - 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:
+  - 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:
 
     ```scala
     (´p´, ´p'´) <- for (´x @ p´ <- ´e´) yield { val ´x' @ p'´ = ´e'´; (´x´, ´x'´) }
     ```
 
 ###### Example
-The following code produces all pairs of numbers between ´1´ and ´n-1´
-whose sums are prime.
+The following code produces all pairs of numbers between ´1´ and ´n-1´ whose sums are prime.
 
 ```scala
 for  { i <- 1 until n
@@ -1037,8 +812,7 @@ The for comprehension is translated to:
 ```
 
 ###### Example
-For comprehensions can be used to express vector
-and matrix algorithms concisely.
+For comprehensions can be used to express vector and matrix algorithms concisely.
 For instance, here is a method to compute the transpose of a given matrix:
 
 <!-- see test/files/run/t0421.scala -->
@@ -1072,9 +846,7 @@ def matmul(xss: Array[Array[Double]], yss: Array[Array[Double]]) = {
 }
 ```
 
-The code above makes use of the fact that `map`, `flatMap`,
-`withFilter`, and `foreach` are defined for instances of class
-`scala.Array`.
+The code above makes use of the fact that `map`, `flatMap`, `withFilter`, and `foreach` are defined for instances of class `scala.Array`.
 
 ## Return Expressions
 
@@ -1082,32 +854,22 @@ The code above makes use of the fact that `map`, `flatMap`,
 Expr1      ::=  ‘return’ [Expr]
 ```
 
-A _return expression_ `return ´e´` must occur inside the body of some
-enclosing user defined method. The innermost enclosing method in a
-source program, ´m´, must have an explicitly declared result type, and
-the type of ´e´ must conform to it.
+A _return expression_ `return ´e´` must occur inside the body of some enclosing user defined method.
+The innermost enclosing method in a source program, ´m´, must have an explicitly declared result type, and the type of ´e´ must conform to it.
 
-The return expression evaluates the expression ´e´ and returns its
-value as the result of ´m´. The evaluation of any statements or
-expressions following the return expression is omitted. The type of
-a return expression is `scala.Nothing`.
+The return expression evaluates the expression ´e´ and returns its value as the result of ´m´.
+The evaluation of any statements or expressions following the return expression is omitted.
+The type of a return expression is `scala.Nothing`.
 
-The expression ´e´ may be omitted. The return expression
-`return` is type-checked and evaluated as if it were `return ()`.
+The expression ´e´ may be omitted.
+The return expression `return` is type-checked and evaluated as if it were `return ()`.
 
-Returning from the method from within a nested function may be
-implemented by throwing and catching a
-`scala.runtime.NonLocalReturnControl`. Any exception catches
-between the point of return and the enclosing methods might see
-and catch that exception. A key comparison makes sure that this
-exception is only caught by the method instance which is terminated
-by the return.
+Returning from the method from within a nested function may be implemented by throwing and catching a `scala.runtime.NonLocalReturnControl`.
+Any exception catches between the point of return and the enclosing methods might see and catch that exception.
+A key comparison makes sure that this exception is only caught by the method instance which is terminated by the return.
 
-If the return expression is itself part of an anonymous function, it
-is possible that the enclosing method ´m´ has already returned
-before the return expression is executed. In that case, the thrown
-`scala.runtime.NonLocalReturnControl` will not be caught, and will
-propagate up the call stack.
+If the return expression is itself part of an anonymous function, it is possible that the enclosing method ´m´ has already returned before the return expression is executed.
+In that case, the thrown `scala.runtime.NonLocalReturnControl` will not be caught, and will propagate up the call stack.
 
 ## Throw Expressions
 
@@ -1115,16 +877,12 @@ propagate up the call stack.
 Expr1      ::=  ‘throw’ Expr
 ```
 
-A _throw expression_ `throw ´e´` evaluates the expression
-´e´. The type of this expression must conform to
-`Throwable`.  If ´e´ evaluates to an exception
-reference, evaluation is aborted with the thrown exception. If ´e´
-evaluates to `null`, evaluation is instead aborted with a
-`NullPointerException`. If there is an active
-[`try` expression](#try-expressions) which handles the thrown
-exception, evaluation resumes with the handler; otherwise the thread
-executing the `throw` is aborted.  The type of a throw expression
-is `scala.Nothing`.
+A _throw expression_ `throw ´e´` evaluates the expression ´e´.
+The type of this expression must conform to `Throwable`.
+If ´e´ evaluates to an exception reference, evaluation is aborted with the thrown exception.
+If ´e´ evaluates to `null`, evaluation is instead aborted with a `NullPointerException`.
+If there is an active [`try` expression](#try-expressions) which handles the thrown exception, evaluation resumes with the handler; otherwise the thread executing the `throw` is aborted.
+The type of a throw expression is `scala.Nothing`.
 
 ## Try Expressions
 
@@ -1132,51 +890,36 @@ is `scala.Nothing`.
 Expr1 ::=  ‘try’ Expr [‘catch’ Expr] [‘finally’ Expr]
 ```
 
-A _try expression_ is of the form `try { ´b´ } catch ´h´`
-where the handler ´h´ is usually a
-[pattern matching anonymous function](08-pattern-matching.html#pattern-matching-anonymous-functions)
+A _try expression_ is of the form `try { ´b´ } catch ´h´` where the handler ´h´ is usually a [pattern matching anonymous function](08-pattern-matching.html#pattern-matching-anonymous-functions)
 
 ```scala
 { case ´p_1´ => ´b_1´ ... case ´p_n´ => ´b_n´ }
 ```
 
-This expression is evaluated by evaluating the block
-´b´.  If evaluation of ´b´ does not cause an exception to be
-thrown, the result of ´b´ is returned. Otherwise the
-handler ´h´ is applied to the thrown exception.
-If the handler contains a case matching the thrown exception,
-the first such case is invoked. If the handler contains
-no case matching the thrown exception, the exception is
-re-thrown. More generally, if the handler is a `PartialFunction`,
-it is applied only if it is defined at the given exception.
-
-Let ´\mathit{pt}´ be the expected type of the try expression.  The block
-´b´ is expected to conform to ´\mathit{pt}´.  The handler ´h´
-is expected conform to type `scala.Function[scala.Throwable, ´\mathit{pt}\,´]`.
-The type of the try expression is the [weak least upper bound](03-types.html#weak-conformance)
-of the type of ´b´ and the result type of ´h´.
-
-A try expression `try { ´b´ } finally ´e´` evaluates the block
-´b´.  If evaluation of ´b´ does not cause an exception to be
-thrown, the expression ´e´ is evaluated. If an exception is thrown
-during evaluation of ´e´, the evaluation of the try expression is
-aborted with the thrown exception. If no exception is thrown during
-evaluation of ´e´, the result of ´b´ is returned as the
-result of the try expression.
-
-If an exception is thrown during evaluation of ´b´, the finally block
-´e´ is also evaluated. If another exception ´e´ is thrown
-during evaluation of ´e´, evaluation of the try expression is
-aborted with the thrown exception. If no exception is thrown during
-evaluation of ´e´, the original exception thrown in ´b´ is
-re-thrown once evaluation of ´e´ has completed.  The block
-´b´ is expected to conform to the expected type of the try
-expression. The finally expression ´e´ is expected to conform to
-type `Unit`.
-
-A try expression `try { ´b´ } catch ´e_1´ finally ´e_2´`
-is a shorthand
-for  `try { try { ´b´ } catch ´e_1´ } finally ´e_2´`.
+This expression is evaluated by evaluating the block ´b´.
+If evaluation of ´b´ does not cause an exception to be thrown, the result of ´b´ is returned.
+Otherwise the handler ´h´ is applied to the thrown exception.
+If the handler contains a case matching the thrown exception, the first such case is invoked.
+If the handler contains no case matching the thrown exception, the exception is re-thrown.
+More generally, if the handler is a `PartialFunction`, it is applied only if it is defined at the given exception.
+
+Let ´\mathit{pt}´ be the expected type of the try expression.
+The block ´b´ is expected to conform to ´\mathit{pt}´.
+The handler ´h´ is expected conform to type `scala.Function[scala.Throwable, ´\mathit{pt}\,´]`.
+The type of the try expression is the [weak least upper bound](03-types.html#weak-conformance) of the type of ´b´ and the result type of ´h´.
+
+A try expression `try { ´b´ } finally ´e´` evaluates the block ´b´.
+If evaluation of ´b´ does not cause an exception to be thrown, the expression ´e´ is evaluated.
+If an exception is thrown during evaluation of ´e´, the evaluation of the try expression is aborted with the thrown exception.
+If no exception is thrown during evaluation of ´e´, the result of ´b´ is returned as the result of the try expression.
+
+If an exception is thrown during evaluation of ´b´, the finally block ´e´ is also evaluated.
+If another exception ´e´ is thrown during evaluation of ´e´, evaluation of the try expression is aborted with the thrown exception.
+If no exception is thrown during evaluation of ´e´, the original exception thrown in ´b´ is re-thrown once evaluation of ´e´ has completed.
+The block ´b´ is expected to conform to the expected type of the try expression.
+The finally expression ´e´ is expected to conform to type `Unit`.
+
+A try expression `try { ´b´ } catch ´e_1´ finally ´e_2´` is a shorthand for  `try { try { ´b´ } catch ´e_1´ } finally ´e_2´`.
 
 ## Anonymous Functions
 
@@ -1187,18 +930,27 @@ Bindings        ::=  ‘(’ Binding {‘,’ Binding} ‘)’
 Binding         ::=  (id | ‘_’) [‘:’ Type]
 ```
 
-The anonymous function of arity ´n´, `(´x_1´: ´T_1, ..., x_n´: ´T_n´) => e` maps parameters ´x_i´ of types ´T_i´ to a result given by expression ´e´. The scope of each formal parameter ´x_i´ is ´e´. Formal parameters must have pairwise distinct names.
+The anonymous function of arity ´n´, `(´x_1´: ´T_1, ..., x_n´: ´T_n´) => e` maps parameters ´x_i´ of types ´T_i´ to a result given by expression ´e´.
+The scope of each formal parameter ´x_i´ is ´e´.
+Formal parameters must have pairwise distinct names.
 
-In the case of a single untyped formal parameter, `(´x\,´) => ´e´` can be abbreviated to `´x´ => ´e´`. If an anonymous function `(´x´: ´T\,´) => ´e´` with a single typed parameter appears as the result expression of a block, it can be abbreviated to `´x´: ´T´ => e`.
+In the case of a single untyped formal parameter, `(´x\,´) => ´e´` can be abbreviated to `´x´ => ´e´`.
+If an anonymous function `(´x´: ´T\,´) => ´e´` with a single typed parameter appears as the result expression of a block, it can be abbreviated to `´x´: ´T´ => e`.
 
-A formal parameter may also be a wildcard represented by an underscore `_`. In that case, a fresh name for the parameter is chosen arbitrarily.
+A formal parameter may also be a wildcard represented by an underscore `_`.
+In that case, a fresh name for the parameter is chosen arbitrarily.
 
-A named parameter of an anonymous function may be optionally preceded by an `implicit` modifier. In that case the parameter is labeled [`implicit`](07-implicits.html#implicit-parameters-and-views); however the parameter section itself does not count as an [implicit parameter section](07-implicits.html#implicit-parameters). Hence, arguments to anonymous functions always have to be given explicitly.
+A named parameter of an anonymous function may be optionally preceded by an `implicit` modifier.
+In that case the parameter is labeled [`implicit`](07-implicits.html#implicit-parameters-and-views); however the parameter section itself does not count as an [implicit parameter section](07-implicits.html#implicit-parameters).
+Hence, arguments to anonymous functions always have to be given explicitly.
 
 ### Translation
-If the expected type of the anonymous function is of the shape `scala.Function´n´[´S_1´, ..., ´S_n´, ´R\,´]`, or can be [SAM-converted](#sam-conversion) to such a function type, the type `´T_i´` of a parameter `´x_i´` can be omitted, as far as `´S_i´` is defined in the expected type, and `´T_i´ = ´S_i´` is assumed. Furthermore, the expected type when type checking ´e´ is ´R´.
+If the expected type of the anonymous function is of the shape `scala.Function´n´[´S_1´, ..., ´S_n´, ´R\,´]`, or can be [SAM-converted](#sam-conversion) to such a function type, the type `´T_i´` of a parameter `´x_i´` can be omitted, as far as `´S_i´` is defined in the expected type, and `´T_i´ = ´S_i´` is assumed.
+Furthermore, the expected type when type checking ´e´ is ´R´.
 
-If there is no expected type for the function literal, all formal parameter types `´T_i´` must be specified explicitly, and the expected type of ´e´ is undefined. The type of the anonymous function is `scala.Function´n´[´T_1´, ..., ´T_n´, ´R\,´]`, where ´R´ is the [packed type](#expression-typing) of ´e´. ´R´ must be equivalent to a type which does not refer to any of the formal parameters ´x_i´.
+If there is no expected type for the function literal, all formal parameter types `´T_i´` must be specified explicitly, and the expected type of ´e´ is undefined.
+The type of the anonymous function is `scala.Function´n´[´T_1´, ..., ´T_n´, ´R\,´]`, where ´R´ is the [packed type](#expression-typing) of ´e´.
+´R´ must be equivalent to a type which does not refer to any of the formal parameters ´x_i´.
 
 The eventual run-time value of an anonymous function is determined by the expected type:
   - a subclass of one of the builtin function types, `scala.Function´n´[´S_1, ..., S_n´, ´R\,´]` (with ´S_i´ and ´R´ fully defined),
@@ -1218,15 +970,9 @@ The same evaluation holds for a SAM type, except that the instantiated type is g
 
 The underlying platform may provide more efficient ways of constructing these instances, such as Java 8's `invokedynamic` bytecode and `LambdaMetaFactory` class.
 
-When a `PartialFunction` is required, an additional member `isDefinedAt`
-is synthesized, which simply returns `true`.
-However, if the function literal has the shape `x => x match { $...$ }`,
-then `isDefinedAt` is derived from the pattern match in the following way:
-each case from the match expression evaluates to `true`,
-and if there is no default case,
-a default case is added that evaluates to `false`.
-For more details on how that is implemented see
-["Pattern Matching Anonymous Functions"](08-pattern-matching.html#pattern-matching-anonymous-functions).
+When a `PartialFunction` is required, an additional member `isDefinedAt` is synthesized, which simply returns `true`.
+However, if the function literal has the shape `x => x match { $...$ }`, then `isDefinedAt` is derived from the pattern match in the following way: each case from the match expression evaluates to `true`, and if there is no default case, a default case is added that evaluates to `false`.
+For more details on how that is implemented see ["Pattern Matching Anonymous Functions"](08-pattern-matching.html#pattern-matching-anonymous-functions).
 
 ###### Example
 Examples of anonymous functions:
@@ -1253,29 +999,18 @@ _ => 5                             // The function that ignores its argument
 SimpleExpr1  ::=  ‘_’
 ```
 
-An expression (of syntactic category `Expr`)
-may contain embedded underscore symbols `_` at places where identifiers
-are legal. Such an expression represents an anonymous function where subsequent
-occurrences of underscores denote successive parameters.
+An expression (of syntactic category `Expr`) may contain embedded underscore symbols `_` at places where identifiers are legal.
+Such an expression represents an anonymous function where subsequent occurrences of underscores denote successive parameters.
 
-Define an _underscore section_ to be an expression of the form
-`_:´T´` where ´T´ is a type, or else of the form `_`,
-provided the underscore does not appear as the expression part of a
-type ascription `_:´T´`.
+Define an _underscore section_ to be an expression of the form `_:´T´` where ´T´ is a type, or else of the form `_`, provided the underscore does not appear as the expression part of a type ascription `_:´T´`.
 
-An expression ´e´ of syntactic category `Expr` _binds_ an underscore section
-´u´, if the following two conditions hold: (1) ´e´ properly contains ´u´, and
-(2) there is no other expression of syntactic category `Expr`
-which is properly contained in ´e´ and which itself properly contains ´u´.
+An expression ´e´ of syntactic category `Expr` _binds_ an underscore section ´u´, if the following two conditions hold: (1) ´e´ properly contains ´u´, and (2) there is no other expression of syntactic category `Expr` which is properly contained in ´e´ and which itself properly contains ´u´.
 
-If an expression ´e´ binds underscore sections ´u_1, ..., u_n´, in this order, it is equivalent to
-the anonymous function `(´u'_1´, ... ´u'_n´) => ´e'´`
-where each ´u_i'´ results from ´u_i´ by replacing the underscore with a fresh identifier and
-´e'´ results from ´e´ by replacing each underscore section ´u_i´ by ´u_i'´.
+If an expression ´e´ binds underscore sections ´u_1, ..., u_n´, in this order, it is equivalent to the anonymous function `(´u'_1´, ... ´u'_n´) => ´e'´` where each ´u_i'´ results from ´u_i´ by replacing the underscore with a fresh identifier and ´e'´ results from ´e´ by replacing each underscore section ´u_i´ by ´u_i'´.
 
 ###### Example
-The anonymous functions in the left column use placeholder
-syntax. Each of these is equivalent to the anonymous function on its right.
+The anonymous functions in the left column use placeholder syntax.
+Each of these is equivalent to the anonymous function on its right.
 
 | | |
 |---------------------------|----------------------------|
@@ -1289,15 +1024,13 @@ syntax. Each of these is equivalent to the anonymous function on its right.
 ## Constant Expressions
 
 Constant expressions are expressions that the Scala compiler can evaluate to a constant.
-The definition of "constant expression" depends on the platform, but they
-include at least the expressions of the following forms:
+The definition of "constant expression" depends on the platform, but they include at least the expressions of the following forms:
 
 - A literal of a value class, such as an integer
 - A string literal
 - A class constructed with [`Predef.classOf`](12-the-scala-standard-library.html#the-predef-object)
 - An element of an enumeration from the underlying platform
-- A literal array, of the form `Array´(c_1, ..., c_n)´`,
-  where all of the ´c_i´'s are themselves constant expressions
+- A literal array, of the form `Array´(c_1, ..., c_n)´`, where all of the ´c_i´'s are themselves constant expressions
 - An identifier defined by a [constant value definition](04-basic-declarations-and-definitions.html#value-declarations-and-definitions).
 
 ## Statements
@@ -1315,40 +1048,31 @@ TemplateStat ::=  Import
                |
 ```
 
-Statements occur as parts of blocks and templates.  A _statement_ can be
-an import, a definition or an expression, or it can be empty.
-Statements used in the template of a class definition can also be
-declarations.  An expression that is used as a statement can have an
-arbitrary value type. An expression statement ´e´ is evaluated by
-evaluating ´e´ and discarding the result of the evaluation.
+Statements occur as parts of blocks and templates.
+A _statement_ can be an import, a definition or an expression, or it can be empty.
+Statements used in the template of a class definition can also be declarations.
+An expression that is used as a statement can have an arbitrary value type.
+An expression statement ´e´ is evaluated by evaluating ´e´ and discarding the result of the evaluation.
 
 <!-- Generalize to implicit coercion? -->
 
-Block statements may be definitions which bind local names in the
-block. The only modifier allowed in all block-local definitions is
-`implicit`. When prefixing a class or object definition,
-modifiers `abstract`, `final`, and `sealed` are also
-permitted.
+Block statements may be definitions which bind local names in the block.
+The only modifier allowed in all block-local definitions is `implicit`.
+When prefixing a class or object definition, modifiers `abstract`, `final`, and `sealed` are also permitted.
 
-Evaluation of a statement sequence entails evaluation of the
-statements in the order they are written.
+Evaluation of a statement sequence entails evaluation of the statements in the order they are written.
 
 ## Implicit Conversions
 
-Implicit conversions can be applied to expressions whose type does not
-match their expected type, to qualifiers in selections, and to unapplied methods. The
-available implicit conversions are given in the next two sub-sections.
+Implicit conversions can be applied to expressions whose type does not match their expected type, to qualifiers in selections, and to unapplied methods.
+The available implicit conversions are given in the next two sub-sections.
 
 ### Value Conversions
 
-The following seven implicit conversions can be applied to an
-expression ´e´ which has some value type ´T´ and which is type-checked with
-some expected type ´\mathit{pt}´.
+The following seven implicit conversions can be applied to an expression ´e´ which has some value type ´T´ and which is type-checked with some expected type ´\mathit{pt}´.
 
 ###### Static Overloading Resolution
-If an expression denotes several possible members of a class,
-[overloading resolution](#overloading-resolution)
-is applied to pick a unique member.
+If an expression denotes several possible members of a class, [overloading resolution](#overloading-resolution) is applied to pick a unique member.
 
 ###### Type Instantiation
 An expression ´e´ of polymorphic type
@@ -1357,47 +1081,31 @@ An expression ´e´ of polymorphic type
 [´a_1´ >: ´L_1´ <: ´U_1, ..., a_n´ >: ´L_n´ <: ´U_n´]´T´
 ```
 
-which does not appear as the function part of
-a type application is converted to a type instance of ´T´
-by determining with [local type inference](#local-type-inference)
-instance types `´T_1, ..., T_n´`
-for the type variables `´a_1, ..., a_n´` and
-implicitly embedding ´e´ in the [type application](#type-applications)
-`´e´[´T_1, ..., T_n´]`.
+which does not appear as the function part of a type application is converted to a type instance of ´T´ by determining with [local type inference](#local-type-inference) instance types `´T_1, ..., T_n´` for the type variables `´a_1, ..., a_n´` and implicitly embedding ´e´ in the [type application](#type-applications) `´e´[´T_1, ..., T_n´]`.
 
 ###### Numeric Widening
-If ´e´ has a primitive number type which [weakly conforms](03-types.html#weak-conformance)
-to the expected type, it is widened to
-the expected type using one of the numeric conversion methods
-`toShort`, `toChar`, `toInt`, `toLong`,
-`toFloat`, `toDouble` defined [in the standard library](12-the-scala-standard-library.html#numeric-value-types).
+If ´e´ has a primitive number type which [weakly conforms](03-types.html#weak-conformance) to the expected type, it is widened to the expected type using one of the numeric conversion methods `toShort`, `toChar`, `toInt`, `toLong`, `toFloat`, `toDouble` defined [in the standard library](12-the-scala-standard-library.html#numeric-value-types).
 
-Since conversions from `Int` to `Float` and from `Long` to `Float` or `Double`
-may incur a loss of precision, those implicit conversions are deprecated.
-The conversion is permitted for literals if the original value can be recovered,
-that is, if conversion back to the original type produces the original value.
+Since conversions from `Int` to `Float` and from `Long` to `Float` or `Double` may incur a loss of precision, those implicit conversions are deprecated.
+The conversion is permitted for literals if the original value can be recovered, that is, if conversion back to the original type produces the original value.
 
 ###### Numeric Literal Narrowing
-If the expected type is `Byte`, `Short` or `Char`, and
-the expression ´e´ is an integer literal fitting in the range of that
-type, it is converted to the same literal in that type.
+If the expected type is `Byte`, `Short` or `Char`, and the expression ´e´ is an integer literal fitting in the range of that type, it is converted to the same literal in that type.
 
 ###### Value Discarding
-If ´e´ has some value type and the expected type is `Unit`,
-´e´ is converted to the expected type by embedding it in the
-term `{ ´e´; () }`.
+If ´e´ has some value type and the expected type is `Unit`, ´e´ is converted to the expected type by embedding it in the term `{ ´e´; () }`.
 
 ###### SAM conversion
 An expression `(p1, ..., pN) => body` of function type `(T1, ..., TN) => T` is sam-convertible to the expected type `S` if the following holds:
   - the class `C` of `S` declares an abstract method `m` with signature `(p1: A1, ..., pN: AN): R`;
   - besides `m`, `C` must not declare or inherit any other deferred value members;
   - the method `m` must have a single argument list;
-  - there must be a type `U` that is a subtype of `S`, so that the expression
-    `new U { final def m(p1: A1, ..., pN: AN): R = body }` is well-typed (conforming to the expected type `S`);
+  - there must be a type `U` that is a subtype of `S`, so that the expression `new U { final def m(p1: A1, ..., pN: AN): R = body }` is well-typed (conforming to the expected type `S`);
   - for the purpose of scoping, `m` should be considered a static member (`U`'s members are not in scope in `body`);
   - `(A1, ..., AN) => R` is a subtype of `(T1, ..., TN) => T` (satisfying this condition drives type inference of unknown type parameters in `S`);
 
-Note that a function literal that targets a SAM is not necessarily compiled to the above instance creation expression. This is platform-dependent.
+Note that a function literal that targets a SAM is not necessarily compiled to the above instance creation expression.
+This is platform-dependent.
 
 It follows that:
   - if class `C` defines a constructor, it must be accessible and must define exactly one, empty, argument list;
@@ -1412,106 +1120,71 @@ Finally, we impose some implementation restrictions (these may be lifted in futu
   - `C` must not be `@specialized`.
 
 ###### View Application
-If none of the previous conversions applies, and ´e´'s type
-does not conform to the expected type ´\mathit{pt}´, it is attempted to convert
-´e´ to the expected type with a [view](07-implicits.html#views).
+If none of the previous conversions applies, and ´e´'s type does not conform to the expected type ´\mathit{pt}´, it is attempted to convert ´e´ to the expected type with a [view](07-implicits.html#views).
 
 ###### Selection on `Dynamic`
-If none of the previous conversions applies, and ´e´ is a prefix
-of a selection ´e.x´, and ´e´'s type conforms to class `scala.Dynamic`,
-then the selection is rewritten according to the rules for
-[dynamic member selection](#dynamic-member-selection).
+If none of the previous conversions applies, and ´e´ is a prefix of a selection ´e.x´, and ´e´'s type conforms to class `scala.Dynamic`, then the selection is rewritten according to the rules for [dynamic member selection](#dynamic-member-selection).
 
 ### Method Conversions
 
-The following four implicit conversions can be applied to methods
-which are not applied to some argument list.
+The following four implicit conversions can be applied to methods which are not applied to some argument list.
 
 ###### Evaluation
-A parameterless method ´m´ of type `=> ´T´` is always converted to
-type ´T´ by evaluating the expression to which ´m´ is bound.
+A parameterless method ´m´ of type `=> ´T´` is always converted to type ´T´ by evaluating the expression to which ´m´ is bound.
 
 ###### Implicit Application
-If the method takes only implicit parameters, implicit
-arguments are passed following the rules [here](07-implicits.html#implicit-parameters).
+If the method takes only implicit parameters, implicit arguments are passed following the rules [here](07-implicits.html#implicit-parameters).
 
 ###### Eta Expansion
-Otherwise, if the method is not a constructor,
-and the expected type ´\mathit{pt}´ is a function type, or,
-for methods of non-zero arity, a type [sam-convertible](#sam-conversion) to a function type,
-´(\mathit{Ts}') \Rightarrow T'´, [eta-expansion](#eta-expansion-section)
-is performed on the expression ´e´.
+Otherwise, if the method is not a constructor, and the expected type ´\mathit{pt}´ is a function type, or, for methods of non-zero arity, a type [sam-convertible](#sam-conversion) to a function type, ´(\mathit{Ts}') \Rightarrow T'´, [eta-expansion](#eta-expansion-section) is performed on the expression ´e´.
 
 (The exception for zero-arity methods is to avoid surprises due to unexpected sam conversion.)
 
 ###### Empty Application
-Otherwise, if ´e´ has method type ´()T´, it is implicitly applied to the empty
-argument list, yielding ´e()´.
+Otherwise, if ´e´ has method type ´()T´, it is implicitly applied to the empty argument list, yielding ´e()´.
 
 ### Overloading Resolution
 
-If an identifier or selection ´e´ references several members of a
-class, the context of the reference is used to identify a unique
-member.  The way this is done depends on whether or not ´e´ is used as
-a function. Let ´\mathscr{A}´ be the set of members referenced by ´e´.
+If an identifier or selection ´e´ references several members of a class, the context of the reference is used to identify a unique member.
+The way this is done depends on whether or not ´e´ is used as a function.
+Let ´\mathscr{A}´ be the set of members referenced by ´e´.
 
-Assume first that ´e´ appears as a function in an application, as in
-`´e´(´e_1´, ..., ´e_m´)`.
+Assume first that ´e´ appears as a function in an application, as in `´e´(´e_1´, ..., ´e_m´)`.
 
-One first determines the set of functions that is potentially [applicable](#function-applications)
-based on the _shape_ of the arguments.
+One first determines the set of functions that is potentially [applicable](#function-applications) based on the _shape_ of the arguments.
 
-The *shape* of an argument expression ´e´, written  ´\mathit{shape}(e)´, is
-a type that is defined as follows:
-  - For a function expression `(´p_1´: ´T_1, ..., p_n´: ´T_n´) => ´b´: (Any, ..., Any) => ´\mathit{shape}(b)´`,
-    where `Any` occurs ´n´ times in the argument type.
+The *shape* of an argument expression ´e´, written  ´\mathit{shape}(e)´, is a type that is defined as follows:
+  - For a function expression `(´p_1´: ´T_1, ..., p_n´: ´T_n´) => ´b´: (Any, ..., Any) => ´\mathit{shape}(b)´`, where `Any` occurs ´n´ times in the argument type.
   - For a pattern-matching anonymous function definition `{ case ... }`: `PartialFunction[Any, Nothing]`.
   - For a named argument `´n´ = ´e´`: ´\mathit{shape}(e)´.
   - For all other expressions: `Nothing`.
 
-Let ´\mathscr{B}´ be the set of alternatives in ´\mathscr{A}´ that are [_applicable_](#function-applications)
-to expressions ´(e_1, ..., e_n)´ of types ´(\mathit{shape}(e_1), ..., \mathit{shape}(e_n))´.
+Let ´\mathscr{B}´ be the set of alternatives in ´\mathscr{A}´ that are [_applicable_](#function-applications) to expressions ´(e_1, ..., e_n)´ of types ´(\mathit{shape}(e_1), ..., \mathit{shape}(e_n))´.
 If there is precisely one alternative in ´\mathscr{B}´, that alternative is chosen.
 
 Otherwise, let ´S_1, ..., S_m´ be the list of types obtained by typing each argument as follows.
 
-Normally, an argument is typed without an expected type, except when
-all alternatives explicitly specify the same parameter type for this argument (a missing parameter type,
-due to e.g. arity differences, is taken as `NoType`, thus resorting to no expected type),
-or when trying to propagate more type information to aid inference of higher-order function parameter types, as explained next.
-
-The intuition for higher-order function parameter type inference is that all arguments must be of a function-like type
-(`PartialFunction`, `FunctionN` or some equivalent [SAM type](#sam-conversion)),
-which in turn must define the same set of higher-order argument types, so that they can safely be used as
-the expected type of a given argument of the overloaded method, without unduly ruling out any alternatives.
-The intent is not to steer overloading resolution, but to preserve enough type information to steer type
-inference of the arguments (a function literal or eta-expanded method) to this overloaded method.
-
-Note that the expected type drives eta-expansion (not performed unless a function-like type is expected),
-as well as inference of omitted parameter types of function literals.
-
-More precisely, an argument `´e_i´` is typed with an expected type that is derived from the `´i´`th argument
-type found in each alternative (call these `´T_{ij}´` for alternative `´j´` and argument position `´i´`) when
-all `´T_{ij}´` are function types `´(A_{1j},..., A_{nj}) => ?´` (or the equivalent `PartialFunction`, or SAM)
-of some arity `´n´`, and their argument types `´A_{kj}´` are identical across all overloads `´j´` for a
-given `´k´`. Then, the expected type for `´e_i´` is derived as follows:
+Normally, an argument is typed without an expected type, except when all alternatives explicitly specify the same parameter type for this argument (a missing parameter type, due to e.g. arity differences, is taken as `NoType`, thus resorting to no expected type), or when trying to propagate more type information to aid inference of higher-order function parameter types, as explained next.
+
+The intuition for higher-order function parameter type inference is that all arguments must be of a function-like type (`PartialFunction`, `FunctionN` or some equivalent [SAM type](#sam-conversion)), which in turn must define the same set of higher-order argument types, so that they can safely be used as the expected type of a given argument of the overloaded method, without unduly ruling out any alternatives.
+The intent is not to steer overloading resolution, but to preserve enough type information to steer type inference of the arguments (a function literal or eta-expanded method) to this overloaded method.
+
+Note that the expected type drives eta-expansion (not performed unless a function-like type is expected), as well as inference of omitted parameter types of function literals.
+
+More precisely, an argument `´e_i´` is typed with an expected type that is derived from the `´i´`th argument type found in each alternative (call these `´T_{ij}´` for alternative `´j´` and argument position `´i´`) when all `´T_{ij}´` are function types `´(A_{1j},..., A_{nj}) => ?´` (or the equivalent `PartialFunction`, or SAM) of some arity `´n´`, and their argument types `´A_{kj}´` are identical across all overloads `´j´` for a given `´k´`.
+Then, the expected type for `´e_i´` is derived as follows:
    - we use `´PartialFunction[A_{1j},..., A_{nj}, ?]´` if for some overload `´j´`, `´T_{ij}´`'s type symbol is `PartialFunction`;
    - else, if for some `´j´`, `´T_{ij}´` is `FunctionN`, the expected type is `´FunctionN[A_{1j},..., A_{nj}, ?]´`;
-   - else, if for all `´j´`, `´T_{ij}´` is a SAM type of the same class, defining argument types `´A_{1j},..., A_{nj}´`
-     (and a potentially varying result type), the expected type encodes these argument types and the SAM class.
+   - else, if for all `´j´`, `´T_{ij}´` is a SAM type of the same class, defining argument types `´A_{1j},..., A_{nj}´` (and a potentially varying result type), the expected type encodes these argument types and the SAM class.
 
-For every member ´m´ in ´\mathscr{B}´ one determines whether it is applicable
-to expressions (´e_1, ..., e_m´) of types ´S_1, ..., S_m´.
+For every member ´m´ in ´\mathscr{B}´ one determines whether it is applicable to expressions (´e_1, ..., e_m´) of types ´S_1, ..., S_m´.
 
-It is an error if none of the members in ´\mathscr{B}´ is applicable. If there is one
-single applicable alternative, that alternative is chosen. Otherwise, let ´\mathscr{CC}´
-be the set of applicable alternatives which don't employ any default argument
-in the application to ´e_1, ..., e_m´.
+It is an error if none of the members in ´\mathscr{B}´ is applicable.
+If there is one single applicable alternative, that alternative is chosen.
+Otherwise, let ´\mathscr{CC}´ be the set of applicable alternatives which don't employ any default argument in the application to ´e_1, ..., e_m´.
 
 It is again an error if ´\mathscr{CC}´ is empty.
-Otherwise, one chooses the _most specific_ alternative among the alternatives
-in ´\mathscr{CC}´, according to the following definition of being "as specific as", and
-"more specific than":
+Otherwise, one chooses the _most specific_ alternative among the alternatives in ´\mathscr{CC}´, according to the following definition of being "as specific as", and "more specific than":
 
 <!--
 question: given
@@ -1524,21 +1197,12 @@ question: given
  so the method is not more specific than the value.
 -->
 
-- A parameterized method ´m´ of type `(´p_1:T_1, ..., p_n:T_n´)´U´` is
-  _as specific as_ some other member ´m'´ of type ´S´ if ´m'´ is [applicable](#function-applications)
-  to arguments `(´p_1, ..., p_n´)` of types ´T_1, ..., T_n´.
-- A polymorphic method of type `[´a_1´ >: ´L_1´ <: ´U_1, ..., a_n´ >: ´L_n´ <: ´U_n´]´T´` is
-  as specific as some other member of type ´S´ if ´T´ is as specific as ´S´
-  under the assumption that for ´i = 1, ..., n´ each ´a_i´ is an abstract type name
-  bounded from below by ´L_i´ and from above by ´U_i´.
+- A parameterized method ´m´ of type `(´p_1:T_1, ..., p_n:T_n´)´U´` is _as specific as_ some other member ´m'´ of type ´S´ if ´m'´ is [applicable](#function-applications) to arguments `(´p_1, ..., p_n´)` of types ´T_1, ..., T_n´.
+- A polymorphic method of type `[´a_1´ >: ´L_1´ <: ´U_1, ..., a_n´ >: ´L_n´ <: ´U_n´]´T´` is as specific as some other member of type ´S´ if ´T´ is as specific as ´S´ under the assumption that for ´i = 1, ..., n´ each ´a_i´ is an abstract type name bounded from below by ´L_i´ and from above by ´U_i´.
 - A member of any other type is always as specific as a parameterized method or a polymorphic method.
-- Given two members of types ´T´ and ´U´ which are neither parameterized nor polymorphic method types,
-  the member of type ´T´ is as specific as the member of type ´U´ if
-  the existential dual of ´T´ conforms to the existential dual of ´U´.
-  Here, the existential dual of a polymorphic type
-  `[´a_1´ >: ´L_1´ <: ´U_1, ..., a_n´ >: ´L_n´ <: ´U_n´]´T´` is
-  `´T´ forSome { type ´a_1´ >: ´L_1´ <: ´U_1´, ..., type ´a_n´ >: ´L_n´ <: ´U_n´}`.
-  The existential dual of every other type is the type itself.
+- Given two members of types ´T´ and ´U´ which are neither parameterized nor polymorphic method types, the member of type ´T´ is as specific as the member of type ´U´ if the existential dual of ´T´ conforms to the existential dual of ´U´.
+Here, the existential dual of a polymorphic type `[´a_1´ >: ´L_1´ <: ´U_1, ..., a_n´ >: ´L_n´ <: ´U_n´]´T´` is `´T´ forSome { type ´a_1´ >: ´L_1´ <: ´U_1´, ..., type ´a_n´ >: ´L_n´ <: ´U_n´}`.
+The existential dual of every other type is the type itself.
 
 The _relative weight_ of an alternative ´A´ over an alternative ´B´ is a
 number from 0 to 2, defined as the sum of
@@ -1546,34 +1210,26 @@ number from 0 to 2, defined as the sum of
 - 1 if ´A´ is as specific as ´B´, 0 otherwise, and
 - 1 if ´A´ is defined in a class or object which is derived from the class or object defining ´B´, 0 otherwise.
 
-A class or object ´C´ is _derived_ from a class or object ´D´ if one of
-the following holds:
+A class or object ´C´ is _derived_ from a class or object ´D´ if one of the following holds:
 
 - ´C´ is a subclass of ´D´, or
 - ´C´ is a companion object of a class derived from ´D´, or
 - ´D´ is a companion object of a class from which ´C´ is derived.
 
-An alternative ´A´ is _more specific_ than an alternative ´B´ if
-the relative weight of ´A´ over ´B´ is greater than the relative
-weight of ´B´ over ´A´.
+An alternative ´A´ is _more specific_ than an alternative ´B´ if the relative weight of ´A´ over ´B´ is greater than the relative weight of ´B´ over ´A´.
 
-It is an error if there is no alternative in ´\mathscr{CC}´ which is more
-specific than all other alternatives in ´\mathscr{CC}´.
+It is an error if there is no alternative in ´\mathscr{CC}´ which is more specific than all other alternatives in ´\mathscr{CC}´.
 
-Assume next that ´e´ appears as a function in a type application, as
-in `´e´[´\mathit{targs}\,´]`. Then all alternatives in
-´\mathscr{A}´ which take the same number of type parameters as there are type
-arguments in ´\mathit{targs}´ are chosen. It is an error if no such alternative exists.
-If there are several such alternatives, overloading resolution is
-applied again to the whole expression `´e´[´\mathit{targs}\,´]`.
+Assume next that ´e´ appears as a function in a type application, as in `´e´[´\mathit{targs}\,´]`.
+Then all alternatives in ´\mathscr{A}´ which take the same number of type parameters as there are type arguments in ´\mathit{targs}´ are chosen.
+It is an error if no such alternative exists.
+If there are several such alternatives, overloading resolution is applied again to the whole expression `´e´[´\mathit{targs}\,´]`.
 
 Assume finally that ´e´ does not appear as a function in either an application or a type application.
-If an expected type is given, let ´\mathscr{B}´ be the set of those alternatives
-in ´\mathscr{A}´ which are [compatible](03-types.html#compatibility) to it.
+If an expected type is given, let ´\mathscr{B}´ be the set of those alternatives in ´\mathscr{A}´ which are [compatible](03-types.html#compatibility) to it.
 Otherwise, let ´\mathscr{B}´ be the same as ´\mathscr{A}´.
 In this last case we choose the most specific alternative among all alternatives in ´\mathscr{B}´.
-It is an error if there is no alternative in ´\mathscr{B}´ which is
-more specific than all other alternatives in ´\mathscr{B}´.
+It is an error if there is no alternative in ´\mathscr{B}´ which is more specific than all other alternatives in ´\mathscr{B}´.
 
 ###### Example
 Consider the following definitions:
@@ -1586,109 +1242,69 @@ val a: A
 val b: B
 ```
 
-Then the application `f(b, b)` refers to the first
-definition of ´f´ whereas the application `f(a, a)`
-refers to the second.  Assume now we add a third overloaded definition
+Then the application `f(b, b)` refers to the first definition of ´f´ whereas the application `f(a, a)` refers to the second.
+Assume now we add a third overloaded definition
 
 ```scala
 def f(x: B, y: A) = ...
 ```
 
-Then the application `f(a, a)` is rejected for being ambiguous, since
-no most specific applicable signature exists.
+Then the application `f(a, a)` is rejected for being ambiguous, since no most specific applicable signature exists.
 
 ### Local Type Inference
 
-Local type inference infers type arguments to be passed to expressions
-of polymorphic type. Say ´e´ is of type [´a_1´ >: ´L_1´ <: ´U_1, ..., a_n´ >: ´L_n´ <: ´U_n´]´T´
-and no explicit type parameters are given.
+Local type inference infers type arguments to be passed to expressions of polymorphic type.
+Say ´e´ is of type [´a_1´ >: ´L_1´ <: ´U_1, ..., a_n´ >: ´L_n´ <: ´U_n´]´T´ and no explicit type parameters are given.
 
-Local type inference converts this expression to a type
-application `´e´[´T_1, ..., T_n´]`. The choice of the
-type arguments ´T_1, ..., T_n´ depends on the context in which
-the expression appears and on the expected type ´\mathit{pt}´.
+Local type inference converts this expression to a type application `´e´[´T_1, ..., T_n´]`.
+The choice of the type arguments ´T_1, ..., T_n´ depends on the context in which the expression appears and on the expected type ´\mathit{pt}´.
 There are three cases.
 
 ###### Case 1: Selections
-If the expression appears as the prefix of a selection with a name
-´x´, then type inference is _deferred_ to the whole expression
-´e.x´. That is, if ´e.x´ has type ´S´, it is now treated as having
-type [´a_1´ >: ´L_1´ <: ´U_1, ..., a_n´ >: ´L_n´ <: ´U_n´]´S´,
-and local type inference is applied in turn to infer type arguments
-for ´a_1, ..., a_n´, using the context in which ´e.x´ appears.
+If the expression appears as the prefix of a selection with a name ´x´, then type inference is _deferred_ to the whole expression ´e.x´.
+That is, if ´e.x´ has type ´S´, it is now treated as having type [´a_1´ >: ´L_1´ <: ´U_1, ..., a_n´ >: ´L_n´ <: ´U_n´]´S´, and local type inference is applied in turn to infer type arguments for ´a_1, ..., a_n´, using the context in which ´e.x´ appears.
 
 ###### Case 2: Values
-If the expression ´e´ appears as a value without being applied to
-value arguments, the type arguments are inferred by solving a
-constraint system which relates the expression's type ´T´ with the
-expected type ´\mathit{pt}´. Without loss of generality we can assume that
-´T´ is a value type; if it is a method type we apply
-[eta-expansion](#eta-expansion-section) to convert it to a function type. Solving
-means finding a substitution ´\sigma´ of types ´T_i´ for the type
-parameters ´a_i´ such that
-
-- None of the inferred types ´T_i´ is a [singleton type](03-types.html#singleton-types)
-  unless it is a singleton type corresponding to an object or a constant value
-  definition or the corresponding bound ´U_i´ is a subtype of `scala.Singleton`.
-- All type parameter bounds are respected, i.e.
-  ´\sigma L_i <: \sigma a_i´ and ´\sigma a_i <: \sigma U_i´ for ´i = 1, ..., n´.
-- The expression's type conforms to the expected type, i.e.
-  ´\sigma T <: \sigma \mathit{pt}´.
+If the expression ´e´ appears as a value without being applied to value arguments, the type arguments are inferred by solving a constraint system which relates the expression's type ´T´ with the expected type ´\mathit{pt}´.
+Without loss of generality we can assume that ´T´ is a value type; if it is a method type we apply [eta-expansion](#eta-expansion-section) to convert it to a function type.
+Solving means finding a substitution ´\sigma´ of types ´T_i´ for the type parameters ´a_i´ such that
+
+- None of the inferred types ´T_i´ is a [singleton type](03-types.html#singleton-types) unless it is a singleton type corresponding to an object or a constant value definition or the corresponding bound ´U_i´ is a subtype of `scala.Singleton`.
+- All type parameter bounds are respected, i.e. ´\sigma L_i <: \sigma a_i´ and ´\sigma a_i <: \sigma U_i´ for ´i = 1, ..., n´.
+- The expression's type conforms to the expected type, i.e. ´\sigma T <: \sigma \mathit{pt}´.
 
 It is a compile time error if no such substitution exists.
-If several substitutions exist, local-type inference will choose for
-each type variable ´a_i´ a minimal or maximal type ´T_i´ of the
-solution space.  A _maximal_ type ´T_i´ will be chosen if the type
-parameter ´a_i´ appears [contravariantly](04-basic-declarations-and-definitions.html#variance-annotations) in the
-type ´T´ of the expression.  A _minimal_ type ´T_i´ will be chosen
-in all other situations, i.e. if the variable appears covariantly,
-non-variantly or not at all in the type ´T´. We call such a substitution
-an _optimal solution_ of the given constraint system for the type ´T´.
+If several substitutions exist, local-type inference will choose for each type variable ´a_i´ a minimal or maximal type ´T_i´ of the solution space.
+A _maximal_ type ´T_i´ will be chosen if the type parameter ´a_i´ appears [contravariantly](04-basic-declarations-and-definitions.html#variance-annotations) in the type ´T´ of the expression.
+A _minimal_ type ´T_i´ will be chosen in all other situations, i.e. if the variable appears covariantly, non-variantly or not at all in the type ´T´.
+We call such a substitution an _optimal solution_ of the given constraint system for the type ´T´.
 
 ###### Case 3: Methods
-The last case applies if the expression
-´e´ appears in an application ´e(d_1, ..., d_m)´. In that case
-´T´ is a method type ´(p_1:R_1, ..., p_m:R_m)T'´. Without loss of
-generality we can assume that the result type ´T'´ is a value type; if
-it is a method type we apply [eta-expansion](#eta-expansion-section) to
-convert it to a function type.  One computes first the types ´S_j´ of
-the argument expressions ´d_j´, using two alternative schemes.  Each
-argument expression ´d_j´ is typed first with the expected type ´R_j´,
-in which the type parameters ´a_1, ..., a_n´ are taken as type
-constants.  If this fails, the argument ´d_j´ is typed instead with an
-expected type ´R_j'´ which results from ´R_j´ by replacing every type
-parameter in ´a_1, ..., a_n´ with _undefined_.
-
-In a second step, type arguments are inferred by solving a constraint
-system which relates the method's type with the expected type
-´\mathit{pt}´ and the argument types ´S_1, ..., S_m´. Solving the
-constraint system means
-finding a substitution ´\sigma´ of types ´T_i´ for the type parameters
-´a_i´ such that
-
-- None of the inferred types ´T_i´ is a [singleton type](03-types.html#singleton-types)
-  unless it is a singleton type corresponding to an object or a constant value
-  definition or the corresponding bound ´U_i´ is a subtype of `scala.Singleton`.
-- All type parameter bounds are respected, i.e. ´\sigma L_i <: \sigma a_i´ and
-  ´\sigma a_i <: \sigma U_i´ for ´i = 1, ..., n´.
+The last case applies if the expression ´e´ appears in an application ´e(d_1, ..., d_m)´.
+In that case ´T´ is a method type ´(p_1:R_1, ..., p_m:R_m)T'´.
+Without loss of generality we can assume that the result type ´T'´ is a value type; if it is a method type we apply [eta-expansion](#eta-expansion-section) to
+convert it to a function type.
+One computes first the types ´S_j´ of the argument expressions ´d_j´, using two alternative schemes.
+Each argument expression ´d_j´ is typed first with the expected type ´R_j´, in which the type parameters ´a_1, ..., a_n´ are taken as type constants.
+If this fails, the argument ´d_j´ is typed instead with an expected type ´R_j'´ which results from ´R_j´ by replacing every type parameter in ´a_1, ..., a_n´ with _undefined_.
+
+In a second step, type arguments are inferred by solving a constraint system which relates the method's type with the expected type ´\mathit{pt}´ and the argument types ´S_1, ..., S_m´.
+Solving the constraint system means finding a substitution ´\sigma´ of types ´T_i´ for the type parameters ´a_i´ such that
+
+- None of the inferred types ´T_i´ is a [singleton type](03-types.html#singleton-types) unless it is a singleton type corresponding to an object or a constant value definition or the corresponding bound ´U_i´ is a subtype of `scala.Singleton`.
+- All type parameter bounds are respected, i.e. ´\sigma L_i <: \sigma a_i´ and ´\sigma a_i <: \sigma U_i´ for ´i = 1, ..., n´.
 - The method's result type ´T'´ conforms to the expected type, i.e. ´\sigma T' <: \sigma \mathit{pt}´.
-- Each argument type [weakly conforms](03-types.html#weak-conformance)
-  to the corresponding formal parameter
-  type, i.e. ´\sigma S_j <:_w \sigma R_j´ for ´j = 1, ..., m´.
+- Each argument type [weakly conforms](03-types.html#weak-conformance) to the corresponding formal parameter type, i.e. ´\sigma S_j <:_w \sigma R_j´ for ´j = 1, ..., m´.
 
-It is a compile time error if no such substitution exists.  If several
-solutions exist, an optimal one for the type ´T'´ is chosen.
+It is a compile time error if no such substitution exists.
+If several solutions exist, an optimal one for the type ´T'´ is chosen.
 
-All or parts of an expected type ´\mathit{pt}´ may be undefined. The rules for
-[conformance](03-types.html#conformance) are extended to this case by adding
-the rule that for any type ´T´ the following two statements are always
-true: ´\mathit{undefined} <: T´ and ´T <: \mathit{undefined}´
+All or parts of an expected type ´\mathit{pt}´ may be undefined.
+The rules for [conformance](03-types.html#conformance) are extended to this case by adding the rule that for any type ´T´ the following two statements are always true: ´\mathit{undefined} <: T´ and ´T <: \mathit{undefined}´
 
-It is possible that no minimal or maximal solution for a type variable
-exists, in which case a compile-time error results. Because ´<:´ is a
-pre-order, it is also possible that a solution set has several optimal
-solutions for a type. In that case, a Scala compiler is free to pick
-any one of them.
+It is possible that no minimal or maximal solution for a type variable exists, in which case a compile-time error results.
+Because ´<:´ is a pre-order, it is also possible that a solution set has several optimal solutions for a type.
+In that case, a Scala compiler is free to pick any one of them.
 
 ###### Example
 Consider the two methods:
@@ -1704,33 +1320,26 @@ and the definition
 val xs = cons(1, nil)
 ```
 
-The application of `cons` is typed with an undefined expected
-type. This application is completed by local type inference to
-`cons[Int](1, nil)`.
-Here, one uses the following
-reasoning to infer the type argument `Int` for the type
-parameter `a`:
+The application of `cons` is typed with an undefined expected type.
+This application is completed by local type inference to `cons[Int](1, nil)`.
+Here, one uses the following reasoning to infer the type argument `Int` for the type parameter `a`:
 
-First, the argument expressions are typed. The first argument `1`
-has type `Int` whereas the second argument `nil` is
-itself polymorphic. One tries to type-check `nil` with an
-expected type `List[a]`. This leads to the constraint system
+First, the argument expressions are typed. The first argument `1` has type `Int` whereas the second argument `nil` is itself polymorphic.
+One tries to type-check `nil` with an expected type `List[a]`.
+This leads to the constraint system
 
 ```scala
 List[b?] <: List[a]
 ```
 
-where we have labeled `b?` with a question mark to indicate
-that it is a variable in the constraint system.
-Because class `List` is covariant, the optimal
-solution of this constraint is
+where we have labeled `b?` with a question mark to indicate that it is a variable in the constraint system.
+Because class `List` is covariant, the optimal solution of this constraint is
 
 ```scala
 b = scala.Nothing
 ```
 
-In a second step, one solves the following constraint system for
-the type parameter `a` of `cons`:
+In a second step, one solves the following constraint system for the type parameter `a` of `cons`:
 
 ```scala
 Int <: a?
@@ -1757,16 +1366,14 @@ val ys = cons("abc", xs)
 where `xs` is defined of type `List[Int]` as before.
 In this case local type inference proceeds as follows.
 
-First, the argument expressions are typed. The first argument
-`"abc"` has type `String`. The second argument `xs` is
-first tried to be typed with expected type `List[a]`. This fails,
-as `List[Int]` is not a subtype of `List[a]`. Therefore,
-the second strategy is tried; `xs` is now typed with expected type
-`List[´\mathit{undefined}´]`. This succeeds and yields the argument type
-`List[Int]`.
+First, the argument expressions are typed.
+The first argument `"abc"` has type `String`.
+The second argument `xs` is first tried to be typed with expected type `List[a]`.
+This fails,as `List[Int]` is not a subtype of `List[a]`.
+Therefore, the second strategy is tried; `xs` is now typed with expected type `List[´\mathit{undefined}´]`.
+This succeeds and yields the argument type `List[Int]`.
 
-In a second step, one solves the following constraint system for
-the type parameter `a` of `cons`:
+In a second step, one solves the following constraint system for the type parameter `a` of `cons`:
 
 ```scala
 String <: a?
@@ -1784,16 +1391,14 @@ so `scala.Any` is the type inferred for `a`.
 
 ### <a name="eta-expansion-section">Eta Expansion</a>
 
-_Eta-expansion_ converts an expression of method type to an
-equivalent expression of function type. It proceeds in two steps.
+_Eta-expansion_ converts an expression of method type to an equivalent expression of function type.
+It proceeds in two steps.
 
-First, one identifies the maximal sub-expressions of ´e´; let's
-say these are ´e_1, ..., e_m´. For each of these, one creates a
-fresh name ´x_i´. Let ´e'´ be the expression resulting from
-replacing every maximal subexpression ´e_i´ in ´e´ by the
-corresponding fresh name ´x_i´. Second, one creates a fresh name ´y_i´
-for every argument type ´T_i´ of the method (´i = 1 , ...,
-n´). The result of eta-conversion is then:
+First, one identifies the maximal sub-expressions of ´e´; let's say these are ´e_1, ..., e_m´.
+For each of these, one creates a fresh name ´x_i´.
+Let ´e'´ be the expression resulting from replacing every maximal subexpression ´e_i´ in ´e´ by the corresponding fresh name ´x_i´.
+Second, one creates a fresh name ´y_i´ for every argument type ´T_i´ of the method (´i = 1 , ..., n´).
+The result of eta-conversion is then:
 
 ```scala
 { val ´x_1´ = ´e_1´;
@@ -1803,13 +1408,12 @@ n´). The result of eta-conversion is then:
 }
 ```
 
-The behavior of [call-by-name parameters](#function-applications)
-is preserved under eta-expansion: the corresponding actual argument expression,
-a sub-expression of parameterless method type, is not evaluated in the expanded block.
+The behavior of [call-by-name parameters](#function-applications) is preserved under eta-expansion: the corresponding actual argument expression, a sub-expression of parameterless method type, is not evaluated in the expanded block.
 
 ### Dynamic Member Selection
 
-The standard Scala library defines a marker trait `scala.Dynamic`. Subclasses of this trait are able to intercept selections and applications on their instances by defining methods of the names `applyDynamic`, `applyDynamicNamed`, `selectDynamic`, and `updateDynamic`.
+The standard Scala library defines a marker trait `scala.Dynamic`.
+Subclasses of this trait are able to intercept selections and applications on their instances by defining methods of the names `applyDynamic`, `applyDynamicNamed`, `selectDynamic`, and `updateDynamic`.
 
 The following rewrites are performed, assuming ´e´'s type conforms to `scala.Dynamic`, and the original expression does not type check under the normal rules, as specified fully in the relevant subsection of [implicit conversion](#dynamic-member-selection):
 
diff --git a/docs/_spec/07-implicits.md b/docs/_spec/07-implicits.md
index 47dc4ca0b0d4..a0db9dd9b418 100644
--- a/docs/_spec/07-implicits.md
+++ b/docs/_spec/07-implicits.md
@@ -13,17 +13,13 @@ LocalModifier  ::= ‘implicit’
 ParamClauses   ::= {ParamClause} [nl] ‘(’ ‘implicit’ Params ‘)’
 ```
 
-Template members and parameters labeled with an `implicit`
-modifier can be passed to [implicit parameters](#implicit-parameters)
-and can be used as implicit conversions called [views](#views).
-The `implicit` modifier is illegal for all
-type members, as well as for [top-level objects](09-top-level-definitions.html#packagings).
+Template members and parameters labeled with an `implicit` modifier can be passed to [implicit parameters](#implicit-parameters) and can be used as implicit conversions called [views](#views).
+The `implicit` modifier is illegal for all type members, as well as for [top-level objects](09-top-level-definitions.html#packagings).
 
 ###### Example Monoid
 
-The following code defines an abstract class of monoids and
-two concrete implementations, `StringMonoid` and
-`IntMonoid`. The two implementations are marked implicit.
+The following code defines an abstract class of monoids and two concrete implementations, `StringMonoid` and `IntMonoid`.
+The two implementations are marked implicit.
 
 ```scala
 abstract class Monoid[A] extends SemiGroup[A] {
@@ -44,61 +40,41 @@ object Monoids {
 
 ## Implicit Parameters
 
-An _implicit parameter list_
-`(implicit ´p_1´,...,´p_n´)` of a method marks the parameters ´p_1, ..., p_n´ as
-implicit. A method or constructor can have only one implicit parameter
-list, and it must be the last parameter list given.
-
-A method with implicit parameters can be applied to arguments just
-like a normal method. In this case the `implicit` label has no
-effect. However, if such a method misses arguments for its implicit
-parameters, such arguments will be automatically provided.
-
-The actual arguments that are eligible to be passed to an implicit
-parameter of type ´T´ fall into two categories. First, eligible are
-all identifiers ´x´ that can be accessed at the point of the method
-call without a prefix and that denote an
-[implicit definition](#the-implicit-modifier)
-or an implicit parameter. To be accessible without a prefix, an identifier
-must be a local name, a member of an enclosing template or a name introduced by an
-[import clause](04-basic-declarations-and-definitions.html#import-clauses). If there are no eligible
-identifiers under this rule, then, second, eligible are also all
-`implicit` members of some object that belongs to the implicit
-scope of the implicit parameter's type, ´T´.
+An _implicit parameter list_ `(implicit ´p_1´,...,´p_n´)` of a method marks the parameters ´p_1, ..., p_n´ as implicit.
+A method or constructor can have only one implicit parameter list, and it must be the last parameter list given.
+
+A method with implicit parameters can be applied to arguments just like a normal method.
+In this case the `implicit` label has no effect.
+However, if such a method misses arguments for its implicit parameters, such arguments will be automatically provided.
+
+The actual arguments that are eligible to be passed to an implicit parameter of type ´T´ fall into two categories.
+First, eligible are all identifiers ´x´ that can be accessed at the point of the method call without a prefix and that denote an [implicit definition](#the-implicit-modifier) or an implicit parameter.
+To be accessible without a prefix, an identifier must be a local name, a member of an enclosing template or a name introduced by an [import clause](04-basic-declarations-and-definitions.html#import-clauses).
+If there are no eligible identifiers under this rule, then, second, eligible are also all `implicit` members of some object that belongs to the implicit scope of the implicit parameter's type, ´T´.
 
 The _implicit scope_ of a type ´T´ consists of all [companion modules](05-classes-and-objects.html#object-definitions) of classes that are associated with the implicit parameter's type.
 Here, we say a class ´C´ is _associated_ with a type ´T´ if it is a [base class](05-classes-and-objects.html#class-linearization) of some part of ´T´.
 
 The _parts_ of a type ´T´ are:
 
-- if ´T´ is a compound type `´T_1´ with ... with ´T_n´`,
-  the union of the parts of ´T_1, ..., T_n´, as well as ´T´ itself;
-- if ´T´ is a parameterized type `´S´[´T_1, ..., T_n´]`,
-  the union of the parts of ´S´ and ´T_1, ..., T_n´;
-- if ´T´ is a singleton type `´p´.type`,
-  the parts of the type of ´p´;
-- if ´T´ is a type projection `´S´#´U´`,
-  the parts of ´S´ as well as ´T´ itself;
+- if ´T´ is a compound type `´T_1´ with ... with ´T_n´`, the union of the parts of ´T_1, ..., T_n´, as well as ´T´ itself;
+- if ´T´ is a parameterized type `´S´[´T_1, ..., T_n´]`, the union of the parts of ´S´ and ´T_1, ..., T_n´;
+- if ´T´ is a singleton type `´p´.type`, the parts of the type of ´p´;
+- if ´T´ is a type projection `´S´#´U´`, the parts of ´S´ as well as ´T´ itself;
 - if ´T´ is a type alias, the parts of its expansion;
 - if ´T´ is an abstract type, the parts of its upper bound;
-- if ´T´ denotes an implicit conversion to a type with a method with argument types ´T_1, ..., T_n´ and result type ´U´,
-  the union of the parts of ´T_1, ..., T_n´ and ´U´;
+- if ´T´ denotes an implicit conversion to a type with a method with argument types ´T_1, ..., T_n´ and result type ´U´, the union of the parts of ´T_1, ..., T_n´ and ´U´;
 - the parts of quantified (existential or universal) and annotated types are defined as the parts of the underlying types (e.g., the parts of `T forSome { ... }` are the parts of `T`);
 - in all other cases, just ´T´ itself.
 
 Note that packages are internally represented as classes with companion modules to hold the package members.
 Thus, implicits defined in a package object are part of the implicit scope of a type prefixed by that package.
 
-If there are several eligible arguments which match the implicit
-parameter's type, a most specific one will be chosen using the rules
-of static [overloading resolution](06-expressions.html#overloading-resolution).
-If the parameter has a default argument and no implicit argument can
-be found the default argument is used.
+If there are several eligible arguments which match the implicit parameter's type, a most specific one will be chosen using the rules of static [overloading resolution](06-expressions.html#overloading-resolution).
+If the parameter has a default argument and no implicit argument can be found the default argument is used.
 
 ###### Example
-Assuming the classes from the [`Monoid` example](#example-monoid), here is a
-method which computes the sum of a list of elements using the
-monoid's `add` and `unit` operations.
+Assuming the classes from the [`Monoid` example](#example-monoid), here is a method which computes the sum of a list of elements using the monoid's `add` and `unit` operations.
 
 ```scala
 def sum[A](xs: List[A])(implicit m: Monoid[A]): A =
@@ -106,23 +82,15 @@ def sum[A](xs: List[A])(implicit m: Monoid[A]): A =
   else m.add(xs.head, sum(xs.tail))
 ```
 
-The monoid in question is marked as an implicit parameter, and can therefore
-be inferred based on the type of the list.
-Consider for instance the call `sum(List(1, 2, 3))`
-in a context where `stringMonoid` and `intMonoid`
-are visible.  We know that the formal type parameter `a` of
-`sum` needs to be instantiated to `Int`. The only
-eligible object which matches the implicit formal parameter type
-`Monoid[Int]` is `intMonoid` so this object will
-be passed as implicit parameter.
+The monoid in question is marked as an implicit parameter, and can therefore be inferred based on the type of the list.
+Consider for instance the call `sum(List(1, 2, 3))` in a context where `stringMonoid` and `intMonoid` are visible.
+We know that the formal type parameter `a` of `sum` needs to be instantiated to `Int`.
+The only eligible object which matches the implicit formal parameter type `Monoid[Int]` is `intMonoid` so this object will be passed as implicit parameter.
 
-This discussion also shows that implicit parameters are inferred after
-any type arguments are [inferred](06-expressions.html#local-type-inference).
+This discussion also shows that implicit parameters are inferred after any type arguments are [inferred](06-expressions.html#local-type-inference).
 
-Implicit methods can themselves have implicit parameters. An example
-is the following method from module `scala.List`, which injects
-lists into the `scala.Ordered` class, provided the element
-type of the list is also convertible to this type.
+Implicit methods can themselves have implicit parameters.
+An example is the following method from module `scala.List`, which injects lists into the `scala.Ordered` class, provided the element type of the list is also convertible to this type.
 
 ```scala
 implicit def list2ordered[A](x: List[A])
@@ -136,16 +104,14 @@ Assume in addition a method
 implicit def int2ordered(x: Int): Ordered[Int]
 ```
 
-that injects integers into the `Ordered` class.  We can now
-define a `sort` method over ordered lists:
+that injects integers into the `Ordered` class.
+We can now define a `sort` method over ordered lists:
 
 ```scala
 def sort[A](xs: List[A])(implicit a2ordered: A => Ordered[A]) = ...
 ```
 
-We can apply `sort` to a list of lists of integers
-`yss: List[List[Int]]`
-as follows:
+We can apply `sort` to a list of lists of integers `yss: List[List[Int]]` as follows:
 
 ```scala
 sort(yss)
@@ -157,28 +123,22 @@ The call above will be completed by passing two nested implicit arguments:
 sort(yss)((xs: List[Int]) => list2ordered[Int](xs)(int2ordered))
 ```
 
-The possibility of passing implicit arguments to implicit arguments
-raises the possibility of an infinite recursion.  For instance, one
-might try to define the following method, which injects _every_ type into the
-`Ordered` class:
+The possibility of passing implicit arguments to implicit arguments raises the possibility of an infinite recursion.
+For instance, one might try to define the following method, which injects _every_ type into the `Ordered` class:
 
 ```scala
 implicit def magic[A](x: A)(implicit a2ordered: A => Ordered[A]): Ordered[A] =
   a2ordered(x)
 ```
 
-Now, if one tried to apply
-`sort` to an argument `arg` of a type that did not have
-another injection into the `Ordered` class, one would obtain an infinite
-expansion:
+Now, if one tried to apply `sort` to an argument `arg` of a type that did not have another injection into the `Ordered` class, one would obtain an infinite expansion:
 
 ```scala
 sort(arg)(x => magic(x)(x => magic(x)(x => ... )))
 ```
 
-Such infinite expansions should be detected and reported as errors, however to support the deliberate
-implicit construction of recursive values we allow implicit arguments to be marked as by-name. At call
-sites recursive uses of implicit values are permitted if they occur in an implicit by-name argument.
+Such infinite expansions should be detected and reported as errors, however to support the deliberate implicit construction of recursive values we allow implicit arguments to be marked as by-name.
+At call sites recursive uses of implicit values are permitted if they occur in an implicit by-name argument.
 
 Consider the following example,
 
@@ -196,8 +156,8 @@ val foo = implicitly[Foo]
 assert(foo eq foo.next)
 ```
 
-As with the `magic` case above this diverges due to the recursive implicit argument `rec` of method
-`foo`. If we mark the implicit argument as by-name,
+As with the `magic` case above this diverges due to the recursive implicit argument `rec` of method `foo`.
+If we mark the implicit argument as by-name,
 
 ```scala
 trait Foo {
@@ -215,8 +175,7 @@ assert(foo eq foo.next)
 
 the example compiles with the assertion successful.
 
-When compiled, recursive by-name implicit arguments of this sort are extracted out as val members of a
-local synthetic object at call sites as follows,
+When compiled, recursive by-name implicit arguments of this sort are extracted out as val members of a local synthetic object at call sites as follows,
 
 ```scala
 val foo: Foo = scala.Predef.implicitly[Foo](
@@ -232,46 +191,33 @@ val foo: Foo = scala.Predef.implicitly[Foo](
 assert(foo eq foo.next)
 ```
 
-Note that the recursive use of `rec$1` occurs within the by-name argument of `foo` and is consequently
-deferred. The desugaring matches what a programmer would do to construct such a recursive value
-explicitly.
-
-To prevent infinite expansions, such as the `magic` example above, the compiler keeps track of a stack
-of “open implicit types” for which implicit arguments are currently being searched. Whenever an
-implicit argument for type ´T´ is searched, ´T´ is added to the stack paired with the implicit
-definition which produces it, and whether it was required to satisfy a by-name implicit argument or
-not. The type is removed from the stack once the search for the implicit argument either definitely
-fails or succeeds. Everytime a type is about to be added to the stack, it is checked against
-existing entries which were produced by the same implicit definition and then,
-
-+ if it is equivalent to some type which is already on the stack and there is a by-name argument between
-  that entry and the top of the stack. In this case the search for that type succeeds immediately and
-  the implicit argument is compiled as a recursive reference to the found argument.  That argument is
-  added as an entry in the synthesized implicit dictionary if it has not already been added.
-+ otherwise if the _core_ of the type _dominates_ the core of a type already on the stack, then the
-  implicit expansion is said to _diverge_ and the search for that type fails immediately.
+Note that the recursive use of `rec$1` occurs within the by-name argument of `foo` and is consequently deferred.
+The desugaring matches what a programmer would do to construct such a recursive value explicitly.
+
+To prevent infinite expansions, such as the `magic` example above, the compiler keeps track of a stack of “open implicit types” for which implicit arguments are currently being searched.
+Whenever an implicit argument for type ´T´ is searched, ´T´ is added to the stack paired with the implicit definition which produces it, and whether it was required to satisfy a by-name implicit argument or not.
+The type is removed from the stack once the search for the implicit argument either definitely fails or succeeds.
+Everytime a type is about to be added to the stack, it is checked against existing entries which were produced by the same implicit definition and then,
+
++ if it is equivalent to some type which is already on the stack and there is a by-name argument between that entry and the top of the stack.
+In this case the search for that type succeeds immediately and the implicit argument is compiled as a recursive reference to the found argument.
+That argument is added as an entry in the synthesized implicit dictionary if it has not already been added.
++ otherwise if the _core_ of the type _dominates_ the core of a type already on the stack, then the implicit expansion is said to _diverge_ and the search for that type fails immediately.
 + otherwise it is added to the stack paired with the implicit definition which produces it.
-  Implicit resolution continues with the implicit arguments of that definition (if any).
+Implicit resolution continues with the implicit arguments of that definition (if any).
 
-Here, the _core type_ of ´T´ is ´T´ with aliases expanded,
-top-level type [annotations](11-annotations.html#user-defined-annotations) and
-[refinements](03-types.html#compound-types) removed, and occurrences of top-level existentially bound
-variables replaced by their upper bounds.
+Here, the _core type_ of ´T´ is ´T´ with aliases expanded, top-level type [annotations](11-annotations.html#user-defined-annotations) and [refinements](03-types.html#compound-types) removed, and occurrences of top-level existentially bound variables replaced by their upper bounds.
 
-A core type ´T´ _dominates_ a type ´U´ if ´T´ is [equivalent](03-types.html#equivalence) to ´U´,
-or if the top-level type constructors of ´T´ and ´U´ have a common element and ´T´ is more complex
-than ´U´ and the _covering sets_ of ´T´ and ´U´ are equal.
+A core type ´T´ _dominates_ a type ´U´ if ´T´ is [equivalent](03-types.html#equivalence) to ´U´, or if the top-level type constructors of ´T´ and ´U´ have a common element and ´T´ is more complex than ´U´ and the _covering sets_ of ´T´ and ´U´ are equal.
 
-The set of _top-level type constructors_ ´\mathit{ttcs}(T)´ of a type ´T´ depends on the form of
-the type:
+The set of _top-level type constructors_ ´\mathit{ttcs}(T)´ of a type ´T´ depends on the form of the type:
 
 - For a type designator,  ´\mathit{ttcs}(p.c) ~=~ \{c\}´;
 - For a parameterized type,  ´\mathit{ttcs}(p.c[\mathit{targs}]) ~=~ \{c\}´;
 - For a singleton type,  ´\mathit{ttcs}(p.type) ~=~ \mathit{ttcs}(T)´, provided ´p´ has type ´T´;
 - For a compound type, `´\mathit{ttcs}(T_1´ with ... with ´T_n)´` ´~=~ \mathit{ttcs}(T_1) \cup ... \cup \mathit{ttcs}(T_n)´.
 
-The _complexity_ ´\operatorname{complexity}(T)´ of a core type is an integer which also depends on the form of
-the type:
+The _complexity_ ´\operatorname{complexity}(T)´ of a core type is an integer which also depends on the form of the type:
 
 - For a type designator, ´\operatorname{complexity}(p.c) ~=~ 1 + \operatorname{complexity}(p)´
 - For a parameterized type, ´\operatorname{complexity}(p.c[\mathit{targs}]) ~=~ 1 + \Sigma \operatorname{complexity}(\mathit{targs})´
@@ -295,9 +241,7 @@ the corresponding covering sets are:
 - ´\mathit{cs}(C)´: List, Tuple2, Int, String
 
 ###### Example
-When typing `sort(xs)` for some list `xs` of type `List[List[List[Int]]]`,
-the sequence of types for
-which implicit arguments are searched is
+When typing `sort(xs)` for some list `xs` of type `List[List[List[Int]]]`, the sequence of types for which implicit arguments are searched is
 
 ```scala
 List[List[Int]] => Ordered[List[List[Int]]],
@@ -305,20 +249,19 @@ List[Int] => Ordered[List[Int]],
 Int => Ordered[Int]
 ```
 
-All types share the common type constructor `scala.Function1`,
-but the complexity of each new type is lower than the complexity of the previous types.
+All types share the common type constructor `scala.Function1`, but the complexity of each new type is lower than the complexity of the previous types.
 Hence, the code typechecks.
 
 ###### Example
-Let `ys` be a list of some type which cannot be converted
-to `Ordered`. For instance:
+Let `ys` be a list of some type which cannot be converted to `Ordered`.
+For instance:
 
 ```scala
 val ys = List(new IllegalArgumentException, new ClassCastException, new Error)
 ```
 
-Assume that the definition of `magic` above is in scope. Then the sequence
-of types for which implicit arguments are searched is
+Assume that the definition of `magic` above is in scope.
+Then the sequence of types for which implicit arguments are searched is
 
 ```scala
 Throwable => Ordered[Throwable],
@@ -326,47 +269,31 @@ Throwable => Ordered[Throwable],
 ...
 ```
 
-Since the second type in the sequence is equal to the first, the compiler
-will issue an error signalling a divergent implicit expansion.
+Since the second type in the sequence is equal to the first, the compiler will issue an error signalling a divergent implicit expansion.
 
 ## Views
 
-Implicit parameters and methods can also define implicit conversions
-called views. A _view_ from type ´S´ to type ´T´ is
-defined by an implicit value which has function type
-`´S´ => ´T´` or `(=> ´S´) => ´T´` or by a method convertible to a value of that
-type.
+Implicit parameters and methods can also define implicit conversions called views.
+A _view_ from type ´S´ to type ´T´ is defined by an implicit value which has function type `´S´ => ´T´` or `(=> ´S´) => ´T´` or by a method convertible to a value of that type.
 
 Views are applied in three situations:
 
-1.  If an expression ´e´ is of type ´T´, and ´T´ does not conform to the
-    expression's expected type ´\mathit{pt}´. In this case an implicit ´v´ is
-    searched which is applicable to ´e´ and whose result type conforms to
-    ´\mathit{pt}´.  The search proceeds as in the case of implicit parameters,
-    where the implicit scope is the one of `´T´ => ´\mathit{pt}´`. If
-    such a view is found, the expression ´e´ is converted to
-    `´v´(´e´)`.
-1.  In a selection ´e.m´ with ´e´ of type ´T´, if the selector ´m´ does
-    not denote an accessible member of ´T´.  In this case, a view ´v´ is searched
-    which is applicable to ´e´ and whose result contains a member named
-    ´m´.  The search proceeds as in the case of implicit parameters, where
-    the implicit scope is the one of ´T´.  If such a view is found, the
-    selection ´e.m´ is converted to `´v´(´e´).´m´`.
-1.  In a selection ´e.m(\mathit{args})´ with ´e´ of type ´T´, if the selector
-    ´m´ denotes some member(s) of ´T´, but none of these members is applicable to the arguments
-    ´\mathit{args}´. In this case a view ´v´ is searched which is applicable to ´e´
-    and whose result contains a method ´m´ which is applicable to ´\mathit{args}´.
-    The search proceeds as in the case of implicit parameters, where
-    the implicit scope is the one of ´T´.  If such a view is found, the
-    selection ´e.m´ is converted to `´v´(´e´).´m(\mathit{args})´`.
-
-The implicit view, if it is found, can accept its argument ´e´ as a
-call-by-value or as a call-by-name parameter. However, call-by-value
-implicits take precedence over call-by-name implicits.
-
-As for implicit parameters, overloading resolution is applied
-if there are several possible candidates (of either the call-by-value
-or the call-by-name category).
+1.  If an expression ´e´ is of type ´T´, and ´T´ does not conform to the expression's expected type ´\mathit{pt}´.
+In this case an implicit ´v´ is searched which is applicable to ´e´ and whose result type conforms to ´\mathit{pt}´.
+The search proceeds as in the case of implicit parameters, where the implicit scope is the one of `´T´ => ´\mathit{pt}´`.
+If such a view is found, the expression ´e´ is converted to `´v´(´e´)`.
+1.  In a selection ´e.m´ with ´e´ of type ´T´, if the selector ´m´ does not denote an accessible member of ´T´.
+In this case, a view ´v´ is searched which is applicable to ´e´ and whose result contains a member named ´m´.
+The search proceeds as in the case of implicit parameters, where the implicit scope is the one of ´T´.
+If such a view is found, the selection ´e.m´ is converted to `´v´(´e´).´m´`.
+1.  In a selection ´e.m(\mathit{args})´ with ´e´ of type ´T´, if the selector ´m´ denotes some member(s) of ´T´, but none of these members is applicable to the arguments ´\mathit{args}´.
+In this case a view ´v´ is searched which is applicable to ´e´ and whose result contains a method ´m´ which is applicable to ´\mathit{args}´.
+The search proceeds as in the case of implicit parameters, where the implicit scope is the one of ´T´.  If such a view is found, the selection ´e.m´ is converted to `´v´(´e´).´m(\mathit{args})´`.
+
+The implicit view, if it is found, can accept its argument ´e´ as a call-by-value or as a call-by-name parameter.
+However, call-by-value implicits take precedence over call-by-name implicits.
+
+As for implicit parameters, overloading resolution is applied if there are several possible candidates (of either the call-by-value or the call-by-name category).
 
 ###### Example Ordered
 
@@ -376,9 +303,7 @@ Class `scala.Ordered[A]` contains a method
   def <= [B >: A](that: B)(implicit b2ordered: B => Ordered[B]): Boolean
 ```
 
-Assume two lists `xs` and `ys` of type `List[Int]`
-and assume that the `list2ordered` and `int2ordered`
-methods defined [here](#implicit-parameters) are in scope.
+Assume two lists `xs` and `ys` of type `List[Int]` and assume that the `list2ordered` and `int2ordered` methods defined [here](#implicit-parameters) are in scope.
 Then the operation
 
 ```scala
@@ -393,10 +318,7 @@ is legal, and is expanded to:
     (xs => list2ordered(xs)(int2ordered))
 ```
 
-The first application of `list2ordered` converts the list
-`xs` to an instance of class `Ordered`, whereas the second
-occurrence is part of an implicit parameter passed to the `<=`
-method.
+The first application of `list2ordered` converts the list `xs` to an instance of class `Ordered`, whereas the second occurrence is part of an implicit parameter passed to the `<=` method.
 
 ## Context Bounds and View Bounds
 
@@ -405,20 +327,15 @@ method.
                 {‘<%’ Type} {‘:’ Type}
 ```
 
-A type parameter ´A´ of a method or non-trait class may have one or more view
-bounds `´A´ <% ´T´`. In this case the type parameter may be
-instantiated to any type ´S´ which is convertible by application of a
-view to the bound ´T´.
+A type parameter ´A´ of a method or non-trait class may have one or more view bounds `´A´ <% ´T´`.
+In this case the type parameter may be instantiated to any type ´S´ which is convertible by application of a view to the bound ´T´.
 
-A type parameter ´A´ of a method or non-trait class may also have one
-or more context bounds `´A´ : ´T´`. In this case the type parameter may be
-instantiated to any type ´S´ for which _evidence_ exists at the
-instantiation point that ´S´ satisfies the bound ´T´. Such evidence
-consists of an implicit value with type ´T[S]´.
+A type parameter ´A´ of a method or non-trait class may also have one or more context bounds `´A´ : ´T´`.
+In this case the type parameter may be instantiated to any type ´S´ for which _evidence_ exists at the instantiation point that ´S´ satisfies the bound ´T´.
+Such evidence consists of an implicit value with type ´T[S]´.
 
-A method or class containing type parameters with view or context bounds is treated as being
-equivalent to a method with implicit parameters. Consider first the case of a
-single parameter with view and/or context bounds such as:
+A method or class containing type parameters with view or context bounds is treated as being equivalent to a method with implicit parameters.
+Consider first the case of a single parameter with view and/or context bounds such as:
 
 ```scala
 def ´f´[´A´ <% ´T_1´ ... <% ´T_m´ : ´U_1´ : ´U_n´](´\mathit{ps}´): ´R´ = ...
@@ -431,14 +348,11 @@ def ´f´[´A´](´\mathit{ps}´)(implicit ´v_1´: ´A´ => ´T_1´, ..., ´v_m
                        ´w_1´: ´U_1´[´A´], ..., ´w_n´: ´U_n´[´A´]): ´R´ = ...
 ```
 
-where the ´v_i´ and ´w_j´ are fresh names for the newly introduced implicit parameters. These
-parameters are called _evidence parameters_.
+where the ´v_i´ and ´w_j´ are fresh names for the newly introduced implicit parameters.
+These parameters are called _evidence parameters_.
 
-If a class or method has several view- or context-bounded type parameters, each
-such type parameter is expanded into evidence parameters in the order
-they appear and all the resulting evidence parameters are concatenated
-in one implicit parameter section.  Since traits do not take
-constructor parameters, this translation does not work for them.
+If a class or method has several view- or context-bounded type parameters, each such type parameter is expanded into evidence parameters in the order they appear and all the resulting evidence parameters are concatenated in one implicit parameter section.
+Since traits do not take constructor parameters, this translation does not work for them.
 Consequently, type-parameters in traits may not be view- or context-bounded.
 
 Evidence parameters are prepended to the existing implicit parameter section, if one exists.
@@ -452,8 +366,7 @@ def foo[A: M](implicit b: B): C
 ```
 
 ###### Example
-The `<=` method from the [`Ordered` example](#example-ordered) can be declared
-more concisely as follows:
+The `<=` method from the [`Ordered` example](#example-ordered) can be declared more concisely as follows:
 
 ```scala
 def <= [B >: A <% Ordered[B]](that: B): Boolean
@@ -461,11 +374,9 @@ def <= [B >: A <% Ordered[B]](that: B): Boolean
 
 ## Manifests
 
-Manifests are type descriptors that can be automatically generated by
-the Scala compiler as arguments to implicit parameters. The Scala
-standard library contains a hierarchy of four manifest classes,
-with `OptManifest`
-at the top. Their signatures follow the outline below.
+Manifests are type descriptors that can be automatically generated by the Scala compiler as arguments to implicit parameters.
+The Scala standard library contains a hierarchy of four manifest classes, with `OptManifest` at the top.
+Their signatures follow the outline below.
 
 ```scala
 trait OptManifest[+T]
@@ -474,52 +385,23 @@ trait ClassManifest[T] extends OptManifest[T]
 trait Manifest[T] extends ClassManifest[T]
 ```
 
-If an implicit parameter of a method or constructor is of a subtype ´M[T]´ of
-class `OptManifest[T]`, _a manifest is determined for ´M[S]´_,
-according to the following rules.
+If an implicit parameter of a method or constructor is of a subtype ´M[T]´ of class `OptManifest[T]`, _a manifest is determined for ´M[S]´_, according to the following rules.
 
-First if there is already an implicit argument that matches ´M[T]´, this
-argument is selected.
+First if there is already an implicit argument that matches ´M[T]´, this argument is selected.
 
-Otherwise, let ´\mathit{Mobj}´ be the companion object `scala.reflect.Manifest`
-if ´M´ is trait `Manifest`, or be
-the companion object `scala.reflect.ClassManifest` otherwise. Let ´M'´ be the trait
-`Manifest` if ´M´ is trait `Manifest`, or be the trait `OptManifest` otherwise.
+Otherwise, let ´\mathit{Mobj}´ be the companion object `scala.reflect.Manifest` if ´M´ is trait `Manifest`, or be the companion object `scala.reflect.ClassManifest` otherwise.
+Let ´M'´ be the trait `Manifest` if ´M´ is trait `Manifest`, or be the trait `OptManifest` otherwise.
 Then the following rules apply.
 
-1.  If ´T´ is a value class or one of the classes `Any`, `AnyVal`, `Object`,
-    `Null`, or `Nothing`,
-    a manifest for it is generated by selecting
-    the corresponding manifest value `Manifest.´T´`, which exists in the
-    `Manifest` module.
-1.  If ´T´ is an instance of `Array[´S´]`, a manifest is generated
-    with the invocation `´\mathit{Mobj}´.arrayType[S](m)`, where ´m´ is the manifest
-    determined for ´M[S]´.
-1.  If ´T´ is some other class type ´S´#´C[U_1, ..., U_n]´ where the prefix
-    type ´S´ cannot be statically determined from the class ´C´,
-    a manifest is generated with the invocation `´\mathit{Mobj}´.classType[T](´m_0´, classOf[T], ´ms´)`
-    where ´m_0´ is the manifest determined for ´M'[S]´ and ´ms´ are the
-    manifests determined for ´M'[U_1], ..., M'[U_n]´.
-1.  If ´T´ is some other class type with type arguments ´U_1, ..., U_n´,
-    a manifest is generated
-    with the invocation `´\mathit{Mobj}´.classType[T](classOf[T], ´ms´)`
-    where ´ms´ are the
-    manifests determined for ´M'[U_1], ..., M'[U_n]´.
-1.  If ´T´ is a singleton type `´p´.type`, a manifest is generated with
-    the invocation `´\mathit{Mobj}´.singleType[T](´p´)`
+1.  If ´T´ is a value class or one of the classes `Any`, `AnyVal`, `Object`, `Null`, or `Nothing`, a manifest for it is generated by selecting the corresponding manifest value `Manifest.´T´`, which exists in the `Manifest` module.
+1.  If ´T´ is an instance of `Array[´S´]`, a manifest is generated with the invocation `´\mathit{Mobj}´.arrayType[S](m)`, where ´m´ is the manifest determined for ´M[S]´.
+1.  If ´T´ is some other class type ´S´#´C[U_1, ..., U_n]´ where the prefix type ´S´ cannot be statically determined from the class ´C´, a manifest is generated with the invocation `´\mathit{Mobj}´.classType[T](´m_0´, classOf[T], ´ms´)` where ´m_0´ is the manifest determined for ´M'[S]´ and ´ms´ are the manifests determined for ´M'[U_1], ..., M'[U_n]´.
+1.  If ´T´ is some other class type with type arguments ´U_1, ..., U_n´, a manifest is generated with the invocation `´\mathit{Mobj}´.classType[T](classOf[T], ´ms´)` where ´ms´ are the manifests determined for ´M'[U_1], ..., M'[U_n]´.
+1.  If ´T´ is a singleton type `´p´.type`, a manifest is generated with the invocation `´\mathit{Mobj}´.singleType[T](´p´)`
 1.  If ´T´ is a refined type ´T' \{ R \}´, a manifest is generated for ´T'´.
-    (That is, refinements are never reflected in manifests).
-1.  If ´T´ is an intersection type
-    `´T_1´ with ... with ´T_n´`
-    where ´n > 1´, the result depends on whether a full manifest is
-    to be determined or not.
-    If ´M´ is trait `Manifest`, then
-    a manifest is generated with the invocation
-    `Manifest.intersectionType[T](´ms´)` where ´ms´ are the manifests
-    determined for ´M[T_1], ..., M[T_n]´.
-    Otherwise, if ´M´ is trait `ClassManifest`,
-    then a manifest is generated for the [intersection dominator](03-types.html#type-erasure)
-    of the types ´T_1, ..., T_n´.
-1.  If ´T´ is some other type, then if ´M´ is trait `OptManifest`,
-    a manifest is generated from the designator `scala.reflect.NoManifest`.
-    If ´M´ is a type different from `OptManifest`, a static error results.
+(That is, refinements are never reflected in manifests).
+1.  If ´T´ is an intersection type `´T_1´ with ... with ´T_n´` where ´n > 1´, the result depends on whether a full manifest is to be determined or not.
+If ´M´ is trait `Manifest`, then a manifest is generated with the invocation `Manifest.intersectionType[T](´ms´)` where ´ms´ are the manifests determined for ´M[T_1], ..., M[T_n]´.
+Otherwise, if ´M´ is trait `ClassManifest`, then a manifest is generated for the [intersection dominator](03-types.html#type-erasure) of the types ´T_1, ..., T_n´.
+1.  If ´T´ is some other type, then if ´M´ is trait `OptManifest`, a manifest is generated from the designator `scala.reflect.NoManifest`.
+If ´M´ is a type different from `OptManifest`, a static error results.
diff --git a/docs/_spec/08-pattern-matching.md b/docs/_spec/08-pattern-matching.md
index f7203e831438..45d777f584a0 100644
--- a/docs/_spec/08-pattern-matching.md
+++ b/docs/_spec/08-pattern-matching.md
@@ -28,30 +28,20 @@ chapter: 8
   Patterns        ::=  Pattern {‘,’ Patterns}
 ```
 
-A pattern is built from constants, constructors, variables and type
-tests. Pattern matching tests whether a given value (or sequence of values)
-has the shape defined by a pattern, and, if it does, binds the
-variables in the pattern to the corresponding components of the value
-(or sequence of values).  The same variable name may not be bound more
-than once in a pattern.
+A pattern is built from constants, constructors, variables and type tests.
+Pattern matching tests whether a given value (or sequence of values) has the shape defined by a pattern, and, if it does, binds the variables in the pattern to the corresponding components of the value (or sequence of values).
+The same variable name may not be bound more than once in a pattern.
 
 ###### Example
 Some examples of patterns are:
- 1.  The pattern `ex: IOException` matches all instances of class
-        `IOException`, binding variable `ex` to the instance.
- 1.  The pattern `Some(x)` matches values of the form `Some(´v´)`,
-        binding `x` to the argument value ´v´ of the `Some` constructor.
- 1.  The pattern `(x, _)` matches pairs of values, binding `x` to
-        the first component of the pair. The second component is matched
-        with a wildcard pattern.
- 1.  The pattern `x :: y :: xs` matches lists of length ´\geq 2´,
-        binding `x` to the list's first element, `y` to the list's
-        second element, and `xs` to the remainder.
+ 1.  The pattern `ex: IOException` matches all instances of class `IOException`, binding variable `ex` to the instance.
+ 1.  The pattern `Some(x)` matches values of the form `Some(´v´)`, binding `x` to the argument value ´v´ of the `Some` constructor.
+ 1.  The pattern `(x, _)` matches pairs of values, binding `x` to the first component of the pair. The second component is matched with a wildcard pattern.
+ 1.  The pattern `x :: y :: xs` matches lists of length ´\geq 2´, binding `x` to the list's first element, `y` to the list's second element, and `xs` to the remainder.
  1.  The pattern `1 | 2 | 3` matches the integers between 1 and 3.
 
-Pattern matching is always done in a context which supplies an
-expected type of the pattern. We distinguish the following kinds of
-patterns.
+Pattern matching is always done in a context which supplies an expected type of the pattern.
+We distinguish the following kinds of patterns.
 
 ### Variable Patterns
 
@@ -60,11 +50,10 @@ patterns.
                     |  varid
 ```
 
-A _variable pattern_ ´x´ is a simple identifier which starts with a
-lower case letter.  It matches any value, and binds the variable name
-to that value.  The type of ´x´ is the expected type of the pattern as
-given from outside.  A special case is the wild-card pattern `_`
-which is treated as if it was a fresh variable on each occurrence.
+A _variable pattern_ ´x´ is a simple identifier which starts with a lower case letter.
+It matches any value, and binds the variable name to that value.
+The type of ´x´ is the expected type of the pattern as given from outside.
+A special case is the wild-card pattern `_` which is treated as if it was a fresh variable on each occurrence.
 
 ### Typed Patterns
 
@@ -73,12 +62,9 @@ which is treated as if it was a fresh variable on each occurrence.
                     |  ‘_’ ‘:’ TypePat
 ```
 
-A _typed pattern_ ´x: T´ consists of a pattern variable ´x´ and a
-type pattern ´T´.  The type of ´x´ is the type pattern ´T´, where
-each type variable and wildcard is replaced by a fresh, unknown type.
-This pattern matches any value matched by the [type pattern](#type-patterns)
-´T´; it binds the variable name to
-that value.
+A _typed pattern_ ´x: T´ consists of a pattern variable ´x´ and a type pattern ´T´.
+The type of ´x´ is the type pattern ´T´, where each type variable and wildcard is replaced by a fresh, unknown type.
+This pattern matches any value matched by the [type pattern](#type-patterns) ´T´; it binds the variable name to that value.
 
 ### Pattern Binders
 
@@ -86,11 +72,9 @@ that value.
   Pattern2        ::=  varid ‘@’ Pattern3
 ```
 
-A _pattern binder_ `´x´@´p´` consists of a pattern variable ´x´ and a
-pattern ´p´. The type of the variable ´x´ is the static type ´T´ implied
-by the pattern ´p´.
-This pattern matches any value ´v´ matched by the pattern ´p´,
-and it binds the variable name to that value.
+A _pattern binder_ `´x´@´p´` consists of a pattern variable ´x´ and a pattern ´p´.
+The type of the variable ´x´ is the static type ´T´ implied by the pattern ´p´.
+This pattern matches any value ´v´ matched by the pattern ´p´, and it binds the variable name to that value.
 
 A pattern ´p´ _implies_ a type ´T´ if the pattern matches only values of the type ´T´.
 
@@ -100,9 +84,8 @@ A pattern ´p´ _implies_ a type ´T´ if the pattern matches only values of the
   SimplePattern   ::=  Literal
 ```
 
-A _literal pattern_ ´L´ matches any value that is equal (in terms of
-`==`) to the literal ´L´. The type of ´L´ must conform to the
-expected type of the pattern.
+A _literal pattern_ ´L´ matches any value that is equal (in terms of `==`) to the literal ´L´.
+The type of ´L´ must conform to the expected type of the pattern.
 
 ### Interpolated string patterns
 
@@ -110,9 +93,8 @@ expected type of the pattern.
   Literal  ::=  interpolatedString
 ```
 
-The expansion of interpolated string literals in patterns is the same as 
-in expressions. If it occurs in a pattern, a interpolated string literal 
-of either of the forms
+The expansion of interpolated string literals in patterns is the same as  in expressions.
+If it occurs in a pattern, a interpolated string literal of either of the forms
 ```
 id"text0{ pat1 }text1 ... { patn }textn"
 id"""text0{ pat1 }text1 ... { patn }textn"""
@@ -121,13 +103,10 @@ is equivalent to:
 ```
 StringContext("""text0""", ..., """textn""").id(pat1, ..., patn)
 ```
-You could define your own `StringContext` to shadow the default one that's 
-in the `scala` package.
+You could define your own `StringContext` to shadow the default one that's in the `scala` package.
 
-This expansion is well-typed if the member `id` evaluates to an extractor 
-object. If the extractor object has `apply` as well as `unapply` or 
-`unapplySeq` methods, processed strings can be used as either expressions
-or patterns.
+This expansion is well-typed if the member `id` evaluates to an extractor object.
+If the extractor object has `apply` as well as `unapply` or `unapplySeq` methods, processed strings can be used as either expressions or patterns.
 
 Taking XML as an example
 ```scala
@@ -159,14 +138,11 @@ where linktext is a variable bound by the pattern.
 ```
 
 A _stable identifier pattern_ is a [stable identifier](03-types.html#paths) ´r´.
-The type of ´r´ must conform to the expected
-type of the pattern. The pattern matches any value ´v´ such that
-`´r´ == ´v´` (see [here](12-the-scala-standard-library.html#root-classes)).
+The type of ´r´ must conform to the expected type of the pattern.
+The pattern matches any value ´v´ such that `´r´ == ´v´` (see [here](12-the-scala-standard-library.html#root-classes)).
 
-To resolve the syntactic overlap with a variable pattern, a
-stable identifier pattern may not be a simple name starting with a lower-case
-letter. However, it is possible to enclose such a variable name in
-backquotes; then it is treated as a stable identifier pattern.
+To resolve the syntactic overlap with a variable pattern, a stable identifier pattern may not be a simple name starting with a lower-case letter.
+However, it is possible to enclose such a variable name in backquotes; then it is treated as a stable identifier pattern.
 
 ###### Example
 Consider the following class definition:
@@ -185,8 +161,7 @@ class C { c =>
 }
 ```
 
-Here, the first three patterns are stable identifier patterns, while the last
-one is a variable pattern.
+Here, the first three patterns are stable identifier patterns, while the last one is a variable pattern.
 
 ### Constructor Patterns
 
@@ -194,25 +169,15 @@ one is a variable pattern.
 SimplePattern   ::=  StableId ‘(’ [Patterns] ‘)’
 ```
 
-A _constructor pattern_ is of the form ´c(p_1, ..., p_n)´ where ´n
-\geq 0´. It consists of a stable identifier ´c´, followed by element
-patterns ´p_1, ..., p_n´. The constructor ´c´ is a simple or
-qualified name which denotes a [case class](05-classes-and-objects.html#case-classes).
-If the case class is monomorphic, then it
-must conform to the expected type of the pattern, and the formal
-parameter types of ´x´'s [primary constructor](05-classes-and-objects.html#class-definitions)
-are taken as the expected types of the element patterns ´p_1, ...,
-p_n´.  If the case class is polymorphic, then its type parameters are
-instantiated so that the instantiation of ´c´ conforms to the expected
-type of the pattern. The instantiated formal parameter types of ´c´'s
-primary constructor are then taken as the expected types of the
-component patterns ´p_1, ..., p_n´.  The pattern matches all
-objects created from constructor invocations ´c(v_1, ..., v_n)´
-where each element pattern ´p_i´ matches the corresponding value
-´v_i´.
-
-A special case arises when ´c´'s formal parameter types end in a
-repeated parameter. This is further discussed [here](#pattern-sequences).
+A _constructor pattern_ is of the form ´c(p_1, ..., p_n)´ where ´n \geq 0´. It consists of a stable identifier ´c´, followed by element patterns ´p_1, ..., p_n´.
+The constructor ´c´ is a simple or qualified name which denotes a [case class](05-classes-and-objects.html#case-classes).
+If the case class is monomorphic, then it must conform to the expected type of the pattern, and the formal parameter types of ´x´'s [primary constructor](05-classes-and-objects.html#class-definitions) are taken as the expected types of the element patterns ´p_1, ..., p_n´.
+If the case class is polymorphic, then its type parameters are instantiated so that the instantiation of ´c´ conforms to the expected type of the pattern.
+The instantiated formal parameter types of ´c´'s primary constructor are then taken as the expected types of the component patterns ´p_1, ..., p_n´.
+The pattern matches all objects created from constructor invocations ´c(v_1, ..., v_n)´ where each element pattern ´p_i´ matches the corresponding value ´v_i´.
+
+A special case arises when ´c´'s formal parameter types end in a repeated parameter.
+This is further discussed [here](#pattern-sequences).
 
 ### Tuple Patterns
 
@@ -220,10 +185,7 @@ repeated parameter. This is further discussed [here](#pattern-sequences).
   SimplePattern   ::=  ‘(’ [Patterns] ‘)’
 ```
 
-A _tuple pattern_ `(´p_1´, ..., ´p_n´)` is an alias
-for the constructor pattern `scala.Tuple´n´(´p_1´, ..., ´p_n´)`,
-where ´n \geq 2´. The empty tuple
-`()` is the unique value of type `scala.Unit`.
+A _tuple pattern_ `(´p_1´, ..., ´p_n´)` is an alias for the constructor pattern `scala.Tuple´n´(´p_1´, ..., ´p_n´)`, where ´n \geq 2´. The empty tuple `()` is the unique value of type `scala.Unit`.
 
 ### Extractor Patterns
 
@@ -231,44 +193,26 @@ where ´n \geq 2´. The empty tuple
   SimplePattern   ::=  StableId ‘(’ [Patterns] ‘)’
 ```
 
-An _extractor pattern_ ´x(p_1, ..., p_n)´ where ´n \geq 0´ is of
-the same syntactic form as a constructor pattern. However, instead of
-a case class, the stable identifier ´x´ denotes an object which has a
-member method named `unapply` or `unapplySeq` that matches
-the pattern.
-
-An extractor pattern cannot match the value `null`. The implementation
-ensures that the `unapply`/`unapplySeq` method is not applied to `null`.
-
-A type is said to be an _extractor type_ for some type `T` if it has a
-method `get` with return type `T`, and a method `isEmpty` with a return type
-that conforms to `Boolean`. `Option[T]` is an extractor type for type `T`.
-
-An `unapply` method in an object ´x´ _matches_ the pattern
-´x(p_1, ..., p_n)´ if it has a single parameter (and, optionally, an
-implicit parameter list) and one of the following applies:
-
-* ´n=0´ and `unapply`'s result type conforms to `Boolean`. In this case
-  the extractor pattern matches all values ´v´ for which
-  `´x´.unapply(´v´)` yields `true`.
-* ´n=1´ and `unapply`'s result type is an extractor type for some
-  type ´T´.  In this case, the (only) argument pattern ´p_1´ is typed in
-  turn with expected type ´T´.  The extractor pattern matches then all
-  values ´v´ for which `´x´.unapply(´v´)` yields a value ´u´ for which `´u´.isEmpty` yields
-  `false`, `´u´.get` yields a value ´v_1´, and ´p_1´ matches ´v_1´.
-* ´n>1´ and `unapply`'s result type is
-  an extractor type for some type ´T´ with members ´\_1, ..., \_n´ returning
-  types ´T_1, ..., T_n´.  In this case, the argument patterns ´p_1
- , ..., p_n´ are typed in turn with expected types ´T_1 , ...,
-  T_n´.  The extractor pattern matches then all values ´v´ for which
-  `´x´.unapply(´v´)` yields a value ´u´ for which
-  `´u´.isEmpty` yields `false`, `´u´.get` yields some value ´t´, and each pattern
-  ´p_i´ matches the corresponding value ´t._1´ from
-  ´t._1, ..., t._n´.
-
-An `unapplySeq` method in an object ´x´ matches the pattern
-´x(q_1, ..., q_m, p_1, ..., p_n)´ if it takes exactly one argument
-and its result type is of the form `Option[(´T_1, ..., T_m´, Seq[S])]` (if `m = 0`, the type `Option[Seq[S]]` is also accepted).
+An _extractor pattern_ ´x(p_1, ..., p_n)´ where ´n \geq 0´ is of the same syntactic form as a constructor pattern.
+However, instead of a case class, the stable identifier ´x´ denotes an object which has a member method named `unapply` or `unapplySeq` that matches the pattern.
+
+An extractor pattern cannot match the value `null`. The implementation ensures that the `unapply`/`unapplySeq` method is not applied to `null`.
+
+A type is said to be an _extractor type_ for some type `T` if it has a method `get` with return type `T`, and a method `isEmpty` with a return type that conforms to `Boolean`.
+`Option[T]` is an extractor type for type `T`.
+
+An `unapply` method in an object ´x´ _matches_ the pattern ´x(p_1, ..., p_n)´ if it has a single parameter (and, optionally, an implicit parameter list) and one of the following applies:
+
+* ´n=0´ and `unapply`'s result type conforms to `Boolean`.
+In this case the extractor pattern matches all values ´v´ for which `´x´.unapply(´v´)` yields `true`.
+* ´n=1´ and `unapply`'s result type is an extractor type for some type ´T´.
+In this case, the (only) argument pattern ´p_1´ is typed in turn with expected type ´T´.
+The extractor pattern matches then all values ´v´ for which `´x´.unapply(´v´)` yields a value ´u´ for which `´u´.isEmpty` yields `false`, `´u´.get` yields a value ´v_1´, and ´p_1´ matches ´v_1´.
+* ´n>1´ and `unapply`'s result type is an extractor type for some type ´T´ with members ´\_1, ..., \_n´ returning types ´T_1, ..., T_n´.
+In this case, the argument patterns ´p_1, ..., p_n´ are typed in turn with expected types ´T_1 , ..., T_n´.
+The extractor pattern matches then all values ´v´ for which `´x´.unapply(´v´)` yields a value ´u´ for which `´u´.isEmpty` yields `false`, `´u´.get` yields some value ´t´, and each pattern ´p_i´ matches the corresponding value ´t._1´ from ´t._1, ..., t._n´.
+
+An `unapplySeq` method in an object ´x´ matches the pattern ´x(q_1, ..., q_m, p_1, ..., p_n)´ if it takes exactly one argument and its result type is of the form `Option[(´T_1, ..., T_m´, Seq[S])]` (if `m = 0`, the type `Option[Seq[S]]` is also accepted).
 This case is further discussed [below](#pattern-sequences).
 
 ###### Example 1
@@ -282,8 +226,7 @@ object Pair {
 }
 ```
 
-This means that the name `Pair` can be used in place of `Tuple2` for tuple
-formation as well as for deconstruction of tuples in patterns.
+This means that the name `Pair` can be used in place of `Tuple2` for tuple formation as well as for deconstruction of tuples in patterns.
 Hence, the following is possible:
 
 ```scala
@@ -306,12 +249,9 @@ class NameBased[A, B](a: A, b: B) {
 }
 ```
 
-Then `NameBased` is an extractor type for `NameBased` itself, since it has a
-member `isEmpty` returning a value of type Boolean, and it has a member `get`
-returning a value of type `NameBased`.
+Then `NameBased` is an extractor type for `NameBased` itself, since it has a member `isEmpty` returning a value of type Boolean, and it has a member `get` returning a value of type `NameBased`.
 
-Since it also has members `_1` and `_2`, it can be used in an extractor pattern
-with n = 2 as follows:
+Since it also has members `_1` and `_2`, it can be used in an extractor pattern with n = 2 as follows:
 
 ```scala
 object Extractor {
@@ -332,18 +272,12 @@ SimplePattern ::= StableId ‘(’ [Patterns ‘,’] [varid ‘@’] ‘_’ 
 
 A _pattern sequence_ ´p_1, ..., p_n´ appears in two contexts.
 First, in a constructor pattern ´c(q_1, ..., q_m, p_1, ..., p_n)´, where ´c´ is a case class which has ´m+1´ primary constructor parameters,  ending in a [repeated parameter](04-basic-declarations-and-definitions.html#repeated-parameters) of type `S*`.
-Second, in an extractor pattern ´x(q_1, ..., q_m, p_1, ..., p_n)´ if the extractor object ´x´ does not have an `unapply` method,
-but it does define an `unapplySeq` method with a result type that is an extractor type for type `(T_1, ... , T_m, Seq[S])` (if `m = 0`, an extractor type for the type `Seq[S]` is also accepted). The expected type for the patterns ´p_i´ is ´S´.
+Second, in an extractor pattern ´x(q_1, ..., q_m, p_1, ..., p_n)´ if the extractor object ´x´ does not have an `unapply` method, but it does define an `unapplySeq` method with a result type that is an extractor type for type `(T_1, ... , T_m, Seq[S])` (if `m = 0`, an extractor type for the type `Seq[S]` is also accepted). The expected type for the patterns ´p_i´ is ´S´.
 
 The last pattern in a pattern sequence may be a _sequence wildcard_ `_*`.
-Each element pattern ´p_i´ is type-checked with
-´S´ as expected type, unless it is a sequence wildcard. If a final
-sequence wildcard is present, the pattern matches all values ´v´ that
-are sequences which start with elements matching patterns
-´p_1, ..., p_{n-1}´.  If no final sequence wildcard is given, the
-pattern matches all values ´v´ that are sequences of
-length ´n´ which consist of elements matching patterns ´p_1 , ...,
-p_n´.
+Each element pattern ´p_i´ is type-checked with ´S´ as expected type, unless it is a sequence wildcard.
+If a final sequence wildcard is present, the pattern matches all values ´v´ that are sequences which start with elements matching patterns ´p_1, ..., p_{n-1}´.
+If no final sequence wildcard is given, the pattern matches all values ´v´ that are sequences of length ´n´ which consist of elements matching patterns ´p_1, ..., p_n´.
 
 ### Infix Operation Patterns
 
@@ -352,13 +286,10 @@ p_n´.
 ```
 
 An _infix operation pattern_ ´p;\mathit{op};q´ is a shorthand for the
-constructor or extractor pattern ´\mathit{op}(p, q)´.  The precedence and
-associativity of operators in patterns is the same as in
-[expressions](06-expressions.html#prefix,-infix,-and-postfix-operations).
+constructor or extractor pattern ´\mathit{op}(p, q)´.
+The precedence and associativity of operators in patterns is the same as in [expressions](06-expressions.html#prefix,-infix,-and-postfix-operations).
 
-An infix operation pattern ´p;\mathit{op};(q_1, ..., q_n)´ is a
-shorthand for the constructor or extractor pattern ´\mathit{op}(p, q_1
-, ..., q_n)´.
+An infix operation pattern ´p;\mathit{op};(q_1, ..., q_n)´ is a shorthand for the constructor or extractor pattern ´\mathit{op}(p, q_1, ..., q_n)´.
 
 ### Pattern Alternatives
 
@@ -366,11 +297,10 @@ shorthand for the constructor or extractor pattern ´\mathit{op}(p, q_1
   Pattern   ::=  Pattern1 { ‘|’ Pattern1 }
 ```
 
-A _pattern alternative_ `´p_1´ | ... | ´p_n´`
-consists of a number of alternative patterns ´p_i´. All alternative
-patterns are type checked with the expected type of the pattern. They
-may not bind variables other than wildcards. The alternative pattern
-matches a value ´v´ if at least one its alternatives matches ´v´.
+A _pattern alternative_ `´p_1´ | ... | ´p_n´` consists of a number of alternative patterns ´p_i´.
+All alternative patterns are type checked with the expected type of the pattern.
+They may not bind variables other than wildcards.
+The alternative pattern matches a value ´v´ if at least one its alternatives matches ´v´.
 
 ### XML Patterns
 
@@ -380,17 +310,10 @@ XML patterns are treated [here](10-xml-expressions-and-patterns.html#xml-pattern
 
 Regular expression patterns have been discontinued in Scala from version 2.0.
 
-Later version of Scala provide a much simplified version of regular
-expression patterns that cover most scenarios of non-text sequence
-processing.  A _sequence pattern_ is a pattern that stands in a
-position where either (1) a pattern of a type `T` which is
-conforming to
-`Seq[A]` for some `A` is expected, or (2) a case
-class constructor that has an iterated formal parameter
-`A*`.  A wildcard star pattern `_*` in the
-rightmost position stands for arbitrary long sequences. It can be
-bound to variables using `@`, as usual, in which case the variable will have the
-type `Seq[A]`.
+Later version of Scala provide a much simplified version of regular expression patterns that cover most scenarios of non-text sequence processing.
+A _sequence pattern_ is a pattern that stands in a position where either (1) a pattern of a type `T` which is conforming to `Seq[A]` for some `A` is expected, or (2) a case class constructor that has an iterated formal parameter `A*`.
+A wildcard star pattern `_*` in the rightmost position stands for arbitrary long sequences.
+It can be bound to variables using `@`, as usual, in which case the variable will have the type `Seq[A]`.
 
 ### Irrefutable Patterns
 
@@ -398,16 +321,10 @@ A pattern ´p´ is _irrefutable_ for a type ´T´, if one of the following appli
 
 1.  ´p´ is a variable pattern,
 1.  ´p´ is a typed pattern ´x: T'´, and ´T <: T'´,
-1.  ´p´ is a constructor pattern ´c(p_1, ..., p_n)´, the type ´T´
-    is an instance of class ´c´, the [primary constructor](05-classes-and-objects.html#class-definitions)
-    of type ´T´ has argument types ´T_1, ..., T_n´, and each ´p_i´ is
-    irrefutable for ´T_i´.
-1.  ´p´ is an extractor pattern for which the extractor type is `Some[´T´]` for
-    some type ´T´
-1.  ´p´ is an extractor pattern for which the extractor types `isEmpty` method
-    is the singleton type `false`
-1.  ´p´ is an extractor pattern for which the return type is the singleton type
-    `true`
+1.  ´p´ is a constructor pattern ´c(p_1, ..., p_n)´, the type ´T´ is an instance of class ´c´, the [primary constructor](05-classes-and-objects.html#class-definitions) of type ´T´ has argument types ´T_1, ..., T_n´, and each ´p_i´ is irrefutable for ´T_i´.
+1.  ´p´ is an extractor pattern for which the extractor type is `Some[´T´]` for some type ´T´
+1.  ´p´ is an extractor pattern for which the extractor types `isEmpty` method is the singleton type `false`
+1.  ´p´ is an extractor pattern for which the return type is the singleton type `true`
 
 ## Type Patterns
 
@@ -418,70 +335,50 @@ A pattern ´p´ is _irrefutable_ for a type ´T´, if one of the following appli
 Type patterns consist of types, type variables, and wildcards.
 A type pattern ´T´ is of one of the following  forms:
 
-* A reference to a class ´C´, ´p.C´, or `´T´#´C´`.  This
-  type pattern matches any non-null instance of the given class.
-  Note that the prefix of the class, if it exists, is relevant for determining
-  class instances. For instance, the pattern ´p.C´ matches only
-  instances of classes ´C´ which were created with the path ´p´ as
-  prefix. This also applies to prefixes which are not given syntactically.
-  For example, if ´C´ refers to a class defined in the nearest enclosing
-  class and is thus equivalent to ´this.C´, it is considered to have a prefix.
-
-  The bottom types `scala.Nothing` and `scala.Null` cannot
-  be used as type patterns, because they would match nothing in any case.
-
-* A singleton type `´p´.type`. This type pattern matches only the value
-  denoted by the path ´p´ (the `eq` method is used to compare the matched value
-  to ´p´).
-
-* A literal type `´lit´`. This type pattern matches only the value
-  denoted by the literal ´lit´ (the `==` method is used to compare the matched
-  value to ´lit´).
-
-* A compound type pattern `´T_1´ with ... with ´T_n´` where each ´T_i´ is a
-  type pattern. This type pattern matches all values that are matched by each of
-  the type patterns ´T_i´.
-
-* A parameterized type pattern ´T[a_1, ..., a_n]´, where the ´a_i´
-  are type variable patterns or wildcards `_`.
-  This type pattern matches all values which match ´T´ for
-  some arbitrary instantiation of the type variables and wildcards. The
-  bounds or alias type of these type variable are determined as
-  described [here](#type-parameter-inference-in-patterns).
-
-* A parameterized type pattern `scala.Array´[T_1]´`, where
-  ´T_1´ is a type pattern. This type pattern matches any non-null instance
-  of type `scala.Array´[U_1]´`, where ´U_1´ is a type matched by ´T_1´.
-
-Types which are not of one of the forms described above are also
-accepted as type patterns. However, such type patterns will be translated to their
-[erasure](03-types.html#type-erasure).  The Scala
-compiler will issue an "unchecked" warning for these patterns to
-flag the possible loss of type-safety.
-
-A _type variable pattern_ is a simple identifier which starts with
-a lower case letter.
+* A reference to a class ´C´, ´p.C´, or `´T´#´C´`.
+This type pattern matches any non-null instance of the given class.
+Note that the prefix of the class, if it exists, is relevant for determining class instances.
+For instance, the pattern ´p.C´ matches only instances of classes ´C´ which were created with the path ´p´ as prefix.
+This also applies to prefixes which are not given syntactically.
+For example, if ´C´ refers to a class defined in the nearest enclosing class and is thus equivalent to ´this.C´, it is considered to have a prefix.
+
+The bottom types `scala.Nothing` and `scala.Null` cannot be used as type patterns, because they would match nothing in any case.
+
+* A singleton type `´p´.type`. This type pattern matches only the value denoted by the path ´p´ (the `eq` method is used to compare the matched value to ´p´).
+
+* A literal type `´lit´`. This type pattern matches only the value denoted by the literal ´lit´ (the `==` method is used to compare the matched value to ´lit´).
+
+* A compound type pattern `´T_1´ with ... with ´T_n´` where each ´T_i´ is a type pattern.
+This type pattern matches all values that are matched by each of the type patterns ´T_i´.
+
+* A parameterized type pattern ´T[a_1, ..., a_n]´, where the ´a_i´ are type variable patterns or wildcards `_`.
+This type pattern matches all values which match ´T´ for some arbitrary instantiation of the type variables and wildcards.
+The bounds or alias type of these type variable are determined as described [here](#type-parameter-inference-in-patterns).
+
+* A parameterized type pattern `scala.Array´[T_1]´`, where ´T_1´ is a type pattern.
+This type pattern matches any non-null instance of type `scala.Array´[U_1]´`, where ´U_1´ is a type matched by ´T_1´.
+
+Types which are not of one of the forms described above are also accepted as type patterns.
+However, such type patterns will be translated to their [erasure](03-types.html#type-erasure).
+The Scala compiler will issue an "unchecked" warning for these patterns to flag the possible loss of type-safety.
+
+A _type variable pattern_ is a simple identifier which starts with a lower case letter.
 
 ## Type Parameter Inference in Patterns
 
-Type parameter inference is the process of finding bounds for the
-bound type variables in a typed pattern or constructor
-pattern. Inference takes into account the expected type of the
-pattern.
+Type parameter inference is the process of finding bounds for the bound type variables in a typed pattern or constructor pattern.
+Inference takes into account the expected type of the pattern.
 
 ### Type parameter inference for typed patterns
 
-Assume a typed pattern ´p: T'´. Let ´T´ result from ´T'´ where all wildcards in
-´T'´ are renamed to fresh variable names. Let ´a_1, ..., a_n´ be
-the type variables in ´T´. These type variables are considered bound
-in the pattern. Let the expected type of the pattern be ´\mathit{pt}´.
+Assume a typed pattern ´p: T'´. Let ´T´ result from ´T'´ where all wildcards in ´T'´ are renamed to fresh variable names.
+Let ´a_1, ..., a_n´ be the type variables in ´T´.
+These type variables are considered bound in the pattern.
+Let the expected type of the pattern be ´\mathit{pt}´.
 
-Type parameter inference constructs first a set of subtype constraints over
-the type variables ´a_i´. The initial constraints set ´\mathcal{C}\_0´ reflects
-just the bounds of these type variables. That is, assuming ´T´ has
-bound type variables ´a_1, ..., a_n´ which correspond to class
-type parameters ´a_1', ..., a_n'´ with lower bounds ´L_1, ..., L_n´
-and upper bounds ´U_1, ..., U_n´, ´\mathcal{C}_0´ contains the constraints
+Type parameter inference constructs first a set of subtype constraints over the type variables ´a_i´.
+The initial constraints set ´\mathcal{C}\_0´ reflects just the bounds of these type variables.
+That is, assuming ´T´ has bound type variables ´a_1, ..., a_n´ which correspond to class type parameters ´a_1', ..., a_n'´ with lower bounds ´L_1, ..., L_n´ and upper bounds ´U_1, ..., U_n´, ´\mathcal{C}_0´ contains the constraints
 
 $$
 \begin{cases}
@@ -492,54 +389,35 @@ $$
 
 where ´\sigma´ is the substitution ´[a_1' := a_1, ..., a_n' :=a_n]´.
 
-The set ´\mathcal{C}_0´ is then augmented by further subtype constraints. There are two
-cases.
+The set ´\mathcal{C}_0´ is then augmented by further subtype constraints.
+There are two cases.
 
 ###### Case 1
-If there exists a substitution ´\sigma´ over the type variables ´a_i, ..., a_n´ such that ´\sigma T´ conforms to ´\mathit{pt}´, one determines the weakest subtype constraints
-´\mathcal{C}\_1´ over the type variables ´a_1, ..., a_n´ such that ´\mathcal{C}\_0 \wedge \mathcal{C}_1´ implies that ´T´ conforms to ´\mathit{pt}´.
+If there exists a substitution ´\sigma´ over the type variables ´a_i, ..., a_n´ such that ´\sigma T´ conforms to ´\mathit{pt}´, one determines the weakest subtype constraints ´\mathcal{C}\_1´ over the type variables ´a_1, ..., a_n´ such that ´\mathcal{C}\_0 \wedge \mathcal{C}_1´ implies that ´T´ conforms to ´\mathit{pt}´.
 
 ###### Case 2
-Otherwise, if ´T´ can not be made to conform to ´\mathit{pt}´ by
-instantiating its type variables, one determines all type variables in
-´\mathit{pt}´ which are defined as type parameters of a method enclosing
-the pattern. Let the set of such type parameters be ´b_1 , ...,
-b_m´. Let ´\mathcal{C}\_0'´ be the subtype constraints reflecting the bounds of the
-type variables ´b_i´.  If ´T´ denotes an instance type of a final
-class, let ´\mathcal{C}\_2´ be the weakest set of subtype constraints over the type
-variables ´a_1, ..., a_n´ and ´b_1, ..., b_m´ such that
-´\mathcal{C}\_0 \wedge \mathcal{C}\_0' \wedge \mathcal{C}\_2´ implies that ´T´ conforms to
-´\mathit{pt}´.  If ´T´ does not denote an instance type of a final class,
-let ´\mathcal{C}\_2´ be the weakest set of subtype constraints over the type variables
-´a_1, ..., a_n´ and ´b_1, ..., b_m´ such that ´\mathcal{C}\_0 \wedge
-\mathcal{C}\_0' \wedge \mathcal{C}\_2´ implies that it is possible to construct a type
-´T'´ which conforms to both ´T´ and ´\mathit{pt}´. It is a static error if
-there is no satisfiable set of constraints ´\mathcal{C}\_2´ with this property.
-
-The final step consists in choosing type bounds for the type
-variables which imply the established constraint system. The process
-is different for the two cases above.
+Otherwise, if ´T´ can not be made to conform to ´\mathit{pt}´ by instantiating its type variables, one determines all type variables in ´\mathit{pt}´ which are defined as type parameters of a method enclosing the pattern.
+Let the set of such type parameters be ´b_1 , ..., b_m´.
+Let ´\mathcal{C}\_0'´ be the subtype constraints reflecting the bounds of the type variables ´b_i´.
+If ´T´ denotes an instance type of a final class, let ´\mathcal{C}\_2´ be the weakest set of subtype constraints over the type variables ´a_1, ..., a_n´ and ´b_1, ..., b_m´ such that ´\mathcal{C}\_0 \wedge \mathcal{C}\_0' \wedge \mathcal{C}\_2´ implies that ´T´ conforms to ´\mathit{pt}´.
+If ´T´ does not denote an instance type of a final class, let ´\mathcal{C}\_2´ be the weakest set of subtype constraints over the type variables ´a_1, ..., a_n´ and ´b_1, ..., b_m´ such that ´\mathcal{C}\_0 \wedge \mathcal{C}\_0' \wedge \mathcal{C}\_2´ implies that it is possible to construct a type ´T'´ which conforms to both ´T´ and ´\mathit{pt}´.
+It is a static error if there is no satisfiable set of constraints ´\mathcal{C}\_2´ with this property.
+
+The final step consists in choosing type bounds for the type variables which imply the established constraint system.
+The process is different for the two cases above.
 
 ###### Case 1
 We take ´a_i >: L_i <: U_i´ where each ´L_i´ is minimal and each ´U_i´ is maximal wrt ´<:´ such that ´a_i >: L_i <: U_i´ for ´i = 1, ..., n´ implies ´\mathcal{C}\_0 \wedge \mathcal{C}\_1´.
 
 ###### Case 2
-We take ´a_i >: L_i <: U_i´ and ´b\_i >: L_i' <: U_i' ´ where each ´L_i´
-and ´L_j'´ is minimal and each ´U_i´ and ´U_j'´ is maximal such that
-´a_i >: L_i <: U_i´ for ´i = 1, ..., n´ and
-´b_j >: L_j' <: U_j'´ for ´j = 1, ..., m´
-implies ´\mathcal{C}\_0 \wedge \mathcal{C}\_0' \wedge \mathcal{C}_2´.
+We take ´a_i >: L_i <: U_i´ and ´b\_i >: L_i' <: U_i' ´ where each ´L_i´ and ´L_j'´ is minimal and each ´U_i´ and ´U_j'´ is maximal such that ´a_i >: L_i <: U_i´ for ´i = 1, ..., n´ and ´b_j >: L_j' <: U_j'´ for ´j = 1, ..., m´ implies ´\mathcal{C}\_0 \wedge \mathcal{C}\_0' \wedge \mathcal{C}_2´.
 
-In both cases, local type inference is permitted to limit the
-complexity of inferred bounds. Minimality and maximality of types have
-to be understood relative to the set of types of acceptable
-complexity.
+In both cases, local type inference is permitted to limit the complexity of inferred bounds.
+Minimality and maximality of types have to be understood relative to the set of types of acceptable complexity.
 
 ### Type parameter inference for constructor patterns
-Assume a constructor pattern ´C(p_1, ..., p_n)´ where class ´C´
-has type parameters ´a_1, ..., a_n´.  These type parameters
-are inferred in the same way as for the typed pattern
-`(_: ´C[a_1, ..., a_n]´)`.
+Assume a constructor pattern ´C(p_1, ..., p_n)´ where class ´C´ has type parameters ´a_1, ..., a_n´.
+These type parameters are inferred in the same way as for the typed pattern `(_: ´C[a_1, ..., a_n]´)`.
 
 ###### Example
 Consider the program fragment:
@@ -551,12 +429,11 @@ x match {
 }
 ```
 
-Here, the type pattern `List[a]` is matched against the
-expected type `Any`. The pattern binds the type variable
-`a`.  Since `List[a]` conforms to `Any`
-for every type argument, there are no constraints on `a`.
-Hence, `a` is introduced as an abstract type with no
-bounds. The scope of `a` is right-hand side of its case clause.
+Here, the type pattern `List[a]` is matched against the expected type `Any`.
+The pattern binds the type variable `a`.
+Since `List[a]` conforms to `Any` for every type argument, there are no constraints on `a`.
+Hence, `a` is introduced as an abstract type with no bounds.
+The scope of `a` is right-hand side of its case clause.
 
 On the other hand, if `x` is declared as
 
@@ -564,11 +441,8 @@ On the other hand, if `x` is declared as
 val x: List[List[String]],
 ```
 
-this generates the constraint
-`List[a] <: List[List[String]]`, which simplifies to
-`a <: List[String]`, because `List` is covariant. Hence,
-`a` is introduced with upper bound
-`List[String]`.
+this generates the constraint `List[a] <: List[List[String]]`, which simplifies to `a <: List[String]`, because `List` is covariant.
+Hence, `a` is introduced with upper bound `List[String]`.
 
 ###### Example
 Consider the program fragment:
@@ -580,16 +454,10 @@ x match {
 }
 ```
 
-Scala does not maintain information about type arguments at run-time,
-so there is no way to check that `x` is a list of strings.
-Instead, the Scala compiler will [erase](03-types.html#type-erasure) the
-pattern to `List[_]`; that is, it will only test whether the
-top-level runtime-class of the value `x` conforms to
-`List`, and the pattern match will succeed if it does.  This
-might lead to a class cast exception later on, in the case where the
-list `x` contains elements other than strings.  The Scala
-compiler will flag this potential loss of type-safety with an
-"unchecked" warning message.
+Scala does not maintain information about type arguments at run-time, so there is no way to check that `x` is a list of strings.
+Instead, the Scala compiler will [erase](03-types.html#type-erasure) the pattern to `List[_]`; that is, it will only test whether the top-level runtime-class of the value `x` conforms to `List`, and the pattern match will succeed if it does.
+This might lead to a class cast exception later on, in the case where the list `x` contains elements other than strings.
+The Scala compiler will flag this potential loss of type-safety with an "unchecked" warning message.
 
 ###### Example
 Consider the program fragment
@@ -602,17 +470,11 @@ def f[B](t: Term[B]): B = t match {
 }
 ```
 
-The expected type of the pattern `y: Number` is
-`Term[B]`.  The type `Number` does not conform to
-`Term[B]`; hence Case 2 of the rules above
-applies. This means that `B` is treated as another type
-variable for which subtype constraints are inferred. In our case the
-applicable constraint is `Number <: Term[B]`, which
-entails `B = Int`.  Hence, `B` is treated in
-the case clause as an abstract type with lower and upper bound
-`Int`. Therefore, the right hand side of the case clause,
-`y.n`, of type `Int`, is found to conform to the
-function's declared result type, `Number`.
+The expected type of the pattern `y: Number` is `Term[B]`.
+The type `Number` does not conform to `Term[B]`; hence Case 2 of the rules above applies.
+This means that `B` is treated as another type variable for which subtype constraints are inferred.
+In our case the applicable constraint is `Number <: Term[B]`, which entails `B = Int`.  Hence, `B` is treated in the case clause as an abstract type with lower and upper bound `Int`.
+Therefore, the right hand side of the case clause, `y.n`, of type `Int`, is found to conform to the function's declared result type, `Number`.
 
 ## Pattern Matching Expressions
 
@@ -628,70 +490,46 @@ A _pattern matching expression_
 e match { case ´p_1´ => ´b_1´ ... case ´p_n´ => ´b_n´ }
 ```
 
-consists of a selector expression ´e´ and a number ´n > 0´ of
-cases. Each case consists of a (possibly guarded) pattern ´p_i´ and a
-block ´b_i´. Each ´p_i´ might be complemented by a guard
-`if ´e´` where ´e´ is a boolean expression.
-The scope of the pattern
-variables in ´p_i´ comprises the pattern's guard and the corresponding block ´b_i´.
-
-Let ´T´ be the type of the selector expression ´e´ and let ´a_1
-, ..., a_m´ be the type parameters of all methods enclosing
-the pattern matching expression.  For every ´a_i´, let ´L_i´ be its
-lower bound and ´U_i´ be its higher bound.  Every pattern ´p \in \{p_1,, ..., p_n\}´
-can be typed in two ways. First, it is attempted
-to type ´p´ with ´T´ as its expected type. If this fails, ´p´ is
-instead typed with a modified expected type ´T'´ which results from
-´T´ by replacing every occurrence of a type parameter ´a_i´ by
-*undefined*.  If this second step fails also, a compile-time
-error results. If the second step succeeds, let ´T_p´ be the type of
-pattern ´p´ seen as an expression. One then determines minimal bounds
-´L_11, ..., L_m'´ and maximal bounds ´U_1', ..., U_m'´ such
-that for all ´i´, ´L_i <: L_i'´ and ´U_i' <: U_i´ and the following
-constraint system is satisfied:
+consists of a selector expression ´e´ and a number ´n > 0´ of cases.
+Each case consists of a (possibly guarded) pattern ´p_i´ and a block ´b_i´.
+Each ´p_i´ might be complemented by a guard `if ´e´` where ´e´ is a boolean expression.
+The scope of the pattern variables in ´p_i´ comprises the pattern's guard and the corresponding block ´b_i´.
+
+Let ´T´ be the type of the selector expression ´e´ and let ´a_1, ..., a_m´ be the type parameters of all methods enclosing the pattern matching expression.  
+For every ´a_i´, let ´L_i´ be its lower bound and ´U_i´ be its higher bound.
+Every pattern ´p \in \{p_1,, ..., p_n\}´ can be typed in two ways.
+First, it is attempted to type ´p´ with ´T´ as its expected type.
+If this fails, ´p´ is instead typed with a modified expected type ´T'´ which results from ´T´ by replacing every occurrence of a type parameter ´a_i´ by
+*undefined*.
+If this second step fails also, a compile-time error results.
+If the second step succeeds, let ´T_p´ be the type of pattern ´p´ seen as an expression.
+One then determines minimal bounds ´L_11, ..., L_m'´ and maximal bounds ´U_1', ..., U_m'´ such that for all ´i´, ´L_i <: L_i'´ and ´U_i' <: U_i´ and the following constraint system is satisfied:
 
 $$
 L_1 <: a_1 <: U_1\;\wedge\;...\;\wedge\;L_m <: a_m <: U_m \ \Rightarrow\ T_p <: T
 $$
 
-If no such bounds can be found, a compile time error results.  If such
-bounds are found, the pattern matching clause starting with ´p´ is
-then typed under the assumption that each ´a_i´ has lower bound ´L_i'´
-instead of ´L_i´ and has upper bound ´U_i'´ instead of ´U_i´.
-
-The expected type of every block ´b_i´ is the expected type of the
-whole pattern matching expression.  The type of the pattern matching
-expression is then the [weak least upper bound](03-types.html#weak-conformance)
-of the types of all blocks
-´b_i´.
-
-When applying a pattern matching expression to a selector value,
-patterns are tried in sequence until one is found which matches the
-[selector value](#patterns). Say this case is `case ´p_i \Rightarrow b_i´`.
-The result of the whole expression is the result of evaluating ´b_i´,
-where all pattern variables of ´p_i´ are bound to
-the corresponding parts of the selector value.  If no matching pattern
-is found, a `scala.MatchError` exception is thrown.
-
-The pattern in a case may also be followed by a guard suffix
-`if e` with a boolean expression ´e´.  The guard expression is
-evaluated if the preceding pattern in the case matches. If the guard
-expression evaluates to `true`, the pattern match succeeds as
-normal. If the guard expression evaluates to `false`, the pattern
-in the case is considered not to match and the search for a matching
-pattern continues.
-
-In the interest of efficiency the evaluation of a pattern matching
-expression may try patterns in some other order than textual
-sequence. This might affect evaluation through
-side effects in guards. However, it is guaranteed that a guard
-expression is evaluated only if the pattern it guards matches.
-
-If the selector of a pattern match is an instance of a
-[`sealed` class](05-classes-and-objects.html#modifiers),
-the compilation of pattern matching can emit warnings which diagnose
-that a given set of patterns is not exhaustive, i.e. that there is a
-possibility of a `MatchError` being raised at run-time.
+If no such bounds can be found, a compile time error results.
+If such bounds are found, the pattern matching clause starting with ´p´ is then typed under the assumption that each ´a_i´ has lower bound ´L_i'´ instead of ´L_i´ and has upper bound ´U_i'´ instead of ´U_i´.
+
+The expected type of every block ´b_i´ is the expected type of the whole pattern matching expression.
+The type of the pattern matching expression is then the [weak least upper bound](03-types.html#weak-conformance) of the types of all blocks ´b_i´.
+
+When applying a pattern matching expression to a selector value, patterns are tried in sequence until one is found which matches the [selector value](#patterns).
+Say this case is `case ´p_i \Rightarrow b_i´`.
+The result of the whole expression is the result of evaluating ´b_i´, where all pattern variables of ´p_i´ are bound to the corresponding parts of the selector value.
+If no matching pattern is found, a `scala.MatchError` exception is thrown.
+
+The pattern in a case may also be followed by a guard suffix `if e` with a boolean expression ´e´.
+The guard expression is evaluated if the preceding pattern in the case matches.
+If the guard expression evaluates to `true`, the pattern match succeeds as normal.
+If the guard expression evaluates to `false`, the pattern in the case is considered not to match and the search for a matching pattern continues.
+
+In the interest of efficiency the evaluation of a pattern matching expression may try patterns in some other order than textual sequence.
+This might affect evaluation through side effects in guards.
+However, it is guaranteed that a guard expression is evaluated only if the pattern it guards matches.
+
+If the selector of a pattern match is an instance of a [`sealed` class](05-classes-and-objects.html#modifiers), the compilation of pattern matching can emit warnings which diagnose that a given set of patterns is not exhaustive, i.e. that there is a possibility of a `MatchError` being raised at run-time.
 
 ###### Example
 
@@ -707,9 +545,8 @@ case class If[T](c: Term[Boolean],
                  t2: Term[T]) extends Term[T]
 ```
 
-There are terms to represent numeric literals, incrementation, a zero
-test, and a conditional. Every term carries as a type parameter the
-type of the expression it represents (either `Int` or `Boolean`).
+There are terms to represent numeric literals, incrementation, a zero test, and a conditional.
+Every term carries as a type parameter the type of the expression it represents (either `Int` or `Boolean`).
 
 A type-safe evaluator for such terms can be written as follows.
 
@@ -722,16 +559,11 @@ def eval[T](t: Term[T]): T = t match {
 }
 ```
 
-Note that the evaluator makes crucial use of the fact that type
-parameters of enclosing methods can acquire new bounds through pattern
-matching.
+Note that the evaluator makes crucial use of the fact that type parameters of enclosing methods can acquire new bounds through pattern matching.
 
-For instance, the type of the pattern in the second case,
-`Succ(u)`, is `Int`. It conforms to the selector type
-`T` only if we assume an upper and lower bound of `Int` for `T`.
-Under the assumption `Int <: T <: Int` we can also
-verify that the type right hand side of the second case, `Int`
-conforms to its expected type, `T`.
+For instance, the type of the pattern in the second case, `Succ(u)`, is `Int`. 
+It conforms to the selector type `T` only if we assume an upper and lower bound of `Int` for `T`.
+Under the assumption `Int <: T <: Int` we can also verify that the type right hand side of the second case, `Int` conforms to its expected type, `T`.
 
 ## Pattern Matching Anonymous Functions
 
@@ -745,16 +577,11 @@ An anonymous function can be defined by a sequence of cases
 { case ´p_1´ => ´b_1´ ... case ´p_n´ => ´b_n´ }
 ```
 
-which appear as an expression without a prior `match`.  The
-expected type of such an expression must in part be defined. It must
-be either `scala.Function´k´[´S_1, ..., S_k´, ´R´]` for some ´k > 0´,
-or `scala.PartialFunction[´S_1´, ´R´]`, where the
-argument type(s) ´S_1, ..., S_k´ must be fully determined, but the result type
-´R´ may be undetermined.
+which appear as an expression without a prior `match`.
+The expected type of such an expression must in part be defined.
+It must be either `scala.Function´k´[´S_1, ..., S_k´, ´R´]` for some ´k > 0´, or `scala.PartialFunction[´S_1´, ´R´]`, where the argument type(s) ´S_1, ..., S_k´ must be fully determined, but the result type ´R´ may be undetermined.
 
-If the expected type is [SAM-convertible](06-expressions.html#sam-conversion)
-to `scala.Function´k´[´S_1, ..., S_k´, ´R´]`,
-the expression is taken to be equivalent to the anonymous function:
+If the expected type is [SAM-convertible](06-expressions.html#sam-conversion) to `scala.Function´k´[´S_1, ..., S_k´, ´R´]`, the expression is taken to be equivalent to the anonymous function:
 
 ```scala
 (´x_1: S_1, ..., x_k: S_k´) => (´x_1, ..., x_k´) match {
@@ -763,9 +590,7 @@ the expression is taken to be equivalent to the anonymous function:
 ```
 
 Here, each ´x_i´ is a fresh name.
-As was shown [here](06-expressions.html#anonymous-functions), this anonymous function is in turn
-equivalent to the following instance creation expression, where
- ´T´ is the weak least upper bound of the types of all ´b_i´.
+As was shown [here](06-expressions.html#anonymous-functions), this anonymous function is in turn equivalent to the following instance creation expression, where ´T´ is the weak least upper bound of the types of all ´b_i´.
 
 ```scala
 new scala.Function´k´[´S_1, ..., S_k´, ´T´] {
@@ -775,8 +600,7 @@ new scala.Function´k´[´S_1, ..., S_k´, ´T´] {
 }
 ```
 
-If the expected type is `scala.PartialFunction[´S´, ´R´]`,
-the expression is taken to be equivalent to the following instance creation expression:
+If the expected type is `scala.PartialFunction[´S´, ´R´]`, the expression is taken to be equivalent to the following instance creation expression:
 
 ```scala
 new scala.PartialFunction[´S´, ´T´] {
@@ -790,15 +614,11 @@ new scala.PartialFunction[´S´, ´T´] {
 }
 ```
 
-Here, ´x´ is a fresh name and ´T´ is the weak least upper bound of the
-types of all ´b_i´. The final default case in the `isDefinedAt`
-method is omitted if one of the patterns ´p_1, ..., p_n´ is
-already a variable or wildcard pattern.
+Here, ´x´ is a fresh name and ´T´ is the weak least upper bound of the types of all ´b_i´.
+The final default case in the `isDefinedAt` method is omitted if one of the patterns ´p_1, ..., p_n´ is already a variable or wildcard pattern.
 
 ###### Example
-Here's an example which uses 
-`foldLeft` to compute the scalar product of
-two vectors:
+Here's an example which uses `foldLeft` to compute the scalar product of two vectors:
 
 ```scala
 def scalarProduct(xs: Array[Double], ys: Array[Double]) =
@@ -807,8 +627,7 @@ def scalarProduct(xs: Array[Double], ys: Array[Double]) =
   }
 ```
 
-The case clauses in this code are equivalent to the following
-anonymous function:
+The case clauses in this code are equivalent to the following anonymous function:
 
 ```scala
 (x, y) => (x, y) match {
diff --git a/docs/_spec/09-top-level-definitions.md b/docs/_spec/09-top-level-definitions.md
index 3588d26f6034..8406c0180533 100644
--- a/docs/_spec/09-top-level-definitions.md
+++ b/docs/_spec/09-top-level-definitions.md
@@ -19,9 +19,7 @@ TopStat          ::=  {Annotation} {Modifier} TmplDef
 QualId           ::=  id {‘.’ id}
 ```
 
-A compilation unit consists of a sequence of packagings, import
-clauses, and class and object definitions, which may be preceded by a
-package clause.
+A compilation unit consists of a sequence of packagings, import clauses, and class and object definitions, which may be preceded by a package clause.
 
 A _compilation unit_
 
@@ -32,9 +30,7 @@ package ´p_n´;
 ´\mathit{stats}´
 ```
 
-starting with one or more package
-clauses is equivalent to a compilation unit consisting of the
-packaging
+starting with one or more package clauses is equivalent to a compilation unit consisting of the packaging
 
 ```scala
 package ´p_1´ { ...
@@ -59,20 +55,16 @@ The exception to the implicit import of `scala.Predef` can be useful to hide, e.
 Packaging       ::=  ‘package’ QualId [nl] ‘{’ TopStatSeq ‘}’
 ```
 
-A _package_ is a special object which defines a set of member classes,
-objects and packages.  Unlike other objects, packages are not introduced
-by a definition.  Instead, the set of members of a package is determined by
-packagings.
+A _package_ is a special object which defines a set of member classes, objects and packages.
+Unlike other objects, packages are not introduced by a definition.
+Instead, the set of members of a package is determined by packagings.
 
-A packaging `package ´p´ { ´\mathit{ds}´ }` injects all
-definitions in ´\mathit{ds}´ as members into the package whose qualified name
-is ´p´. Members of a package are called _top-level_ definitions.
-If a definition in ´\mathit{ds}´ is labeled `private`, it is
-visible only for other members in the package.
+A packaging `package ´p´ { ´\mathit{ds}´ }` injects all definitions in ´\mathit{ds}´ as members into the package whose qualified name is ´p´.
+Members of a package are called _top-level_ definitions.
+If a definition in ´\mathit{ds}´ is labeled `private`, it is visible only for other members in the package.
 
-Inside the packaging, all members of package ´p´ are visible under their
-simple names. However this rule does not extend to members of enclosing
-packages of ´p´ that are designated by a prefix of the path ´p´.
+Inside the packaging, all members of package ´p´ are visible under their simple names.
+However this rule does not extend to members of enclosing packages of ´p´ that are designated by a prefix of the path ´p´.
 
 ```scala
 package org.net.prj {
@@ -80,19 +72,15 @@ package org.net.prj {
 }
 ```
 
-all members of package `org.net.prj` are visible under their
-simple names, but members of packages `org` or `org.net` require
-explicit qualification or imports.
+all members of package `org.net.prj` are visible under their simple names, but members of packages `org` or `org.net` require explicit qualification or imports.
 
-Selections ´p´.´m´ from ´p´ as well as imports from ´p´
-work as for objects. However, unlike other objects, packages may not
-be used as values. It is illegal to have a package with the same fully
-qualified name as a module or a class.
+Selections ´p´.´m´ from ´p´ as well as imports from ´p´ work as for objects.
+However, unlike other objects, packages may not be used as values.
+It is illegal to have a package with the same fully qualified name as a module or a class.
 
-Top-level definitions outside a packaging are assumed to be injected
-into a special empty package. That package cannot be named and
-therefore cannot be imported. However, members of the empty package
-are visible to each other without qualification.
+Top-level definitions outside a packaging are assumed to be injected into a special empty package.
+That package cannot be named and therefore cannot be imported.
+However, members of the empty package are visible to each other without qualification.
 
 ## Package Objects
 
@@ -100,17 +88,13 @@ are visible to each other without qualification.
 PackageObject   ::=  ‘package’ ‘object’ ObjectDef
 ```
 
-A _package object_ `package object ´p´ extends ´t´` adds the
-members of template ´t´ to the package ´p´. There can be only one
-package object per package. The standard naming convention is to place
-the definition above in a file named `package.scala` that's
-located in the directory corresponding to package ´p´.
+A _package object_ `package object ´p´ extends ´t´` adds the members of template ´t´ to the package ´p´.
+There can be only one package object per package.
+The standard naming convention is to place the definition above in a file named `package.scala` that's located in the directory corresponding to package ´p´.
 
-The package object should not define a member with the same name as
-one of the top-level objects or classes defined in package ´p´. If
-there is a name conflict, the behavior of the program is currently
-undefined. It is expected that this restriction will be lifted in a
-future version of Scala.
+The package object should not define a member with the same name as one of the top-level objects or classes defined in package ´p´.
+If there is a name conflict, the behavior of the program is currently undefined.
+It is expected that this restriction will be lifted in a future version of Scala.
 
 ## Package References
 
@@ -119,18 +103,12 @@ QualId           ::=  id {‘.’ id}
 ```
 
 A reference to a package takes the form of a qualified identifier.
-Like all other references, package references are relative. That is,
-a package reference starting in a name ´p´ will be looked up in the
-closest enclosing scope that defines a member named ´p´.
+Like all other references, package references are relative.
+That is, a package reference starting in a name ´p´ will be looked up in the closest enclosing scope that defines a member named ´p´.
 
-If a package name is shadowed, it's possible to refer to its
-fully-qualified name by prefixing it with
-the special predefined name `_root_`, which refers to the
-outermost root package that contains all top-level packages.
+If a package name is shadowed, it's possible to refer to its fully-qualified name by prefixing it with the special predefined name `_root_`, which refers to the outermost root package that contains all top-level packages.
 
-The name `_root_` has this special denotation only when
-used as the first element of a qualifier; it is an ordinary
-identifier otherwise.
+The name `_root_` has this special denotation only when used as the first element of a qualifier; it is an ordinary identifier otherwise.
 
 ###### Example
 Consider the following program:
@@ -154,29 +132,20 @@ package a {
 
 ```
 
-Here, the reference `_root_.b.B` refers to class `B` in the
-toplevel package `b`. If the `_root_` prefix had been
-omitted, the name `b` would instead resolve to the package
-`a.b`, and, provided that package does not also
-contain a class `B`, a compiler-time error would result.
+Here, the reference `_root_.b.B` refers to class `B` in the toplevel package `b`.
+If the `_root_` prefix had been omitted, the name `b` would instead resolve to the package `a.b`, and, provided that package does not also contain a class `B`, a compiler-time error would result.
 
 ## Programs
 
-A _program_ is a top-level object that has a member method
-_main_ of type `(Array[String])Unit`. Programs can be
-executed from a command shell. The program's command arguments are
-passed to the `main` method as a parameter of type
-`Array[String]`.
+A _program_ is a top-level object that has a member method _main_ of type `(Array[String])Unit`. Programs can be executed from a command shell.
+The program's command arguments are passed to the `main` method as a parameter of type `Array[String]`.
 
-The `main` method of a program can be directly defined in the
-object, or it can be inherited. The scala library defines a special class
-`scala.App` whose body acts as a `main` method.
-An objects ´m´ inheriting from this class is thus a program,
-which executes the initialization code of the object ´m´.
+The `main` method of a program can be directly defined in the object, or it can be inherited.
+The scala library defines a special class `scala.App` whose body acts as a `main` method.
+An objects ´m´ inheriting from this class is thus a program, which executes the initialization code of the object ´m´.
 
 ###### Example
-The following example will create a hello world program by defining
-a method `main` in module `test.HelloWorld`.
+The following example will create a hello world program by defining a method `main` in module `test.HelloWorld`.
 
 ```scala
 package test
@@ -199,8 +168,7 @@ java test.HelloWorld
 
 would work as well.
 
-`HelloWorld` can also be defined without a `main` method
-by inheriting from `App` instead:
+`HelloWorld` can also be defined without a `main` method by inheriting from `App` instead:
 
 ```scala
 package test
diff --git a/docs/_spec/10-xml-expressions-and-patterns.md b/docs/_spec/10-xml-expressions-and-patterns.md
index a9b7edb14fff..c929e24fe93d 100644
--- a/docs/_spec/10-xml-expressions-and-patterns.md
+++ b/docs/_spec/10-xml-expressions-and-patterns.md
@@ -9,28 +9,22 @@ chapter: 10
 __By Burak Emir__
 
 This chapter describes the syntactic structure of XML expressions and patterns.
-It follows as closely as possible the XML 1.0 specification,
-changes being mandated by the possibility of embedding Scala code fragments.
+It follows as closely as possible the XML 1.0 specification, changes being mandated by the possibility of embedding Scala code fragments.
 
 ## XML expressions
 
-XML expressions are expressions generated by the following production, where the
-opening bracket `<` of the first element must be in a position to start the lexical
-[XML mode](01-lexical-syntax.html#xml-mode).
+XML expressions are expressions generated by the following production, where the opening bracket `<` of the first element must be in a position to start the lexical [XML mode](01-lexical-syntax.html#xml-mode).
 
 ```ebnf
 XmlExpr ::= XmlContent {Element}
 ```
 
-Well-formedness constraints of the XML specification apply, which
-means for instance that start tags and end tags must match, and
-attributes may only be defined once, except for constraints
-related to entity resolution.
+Well-formedness constraints of the XML specification apply, which means for instance that start tags and end tags must match, and attributes may only be defined once, except for constraints related to entity resolution.
 
-The following productions describe Scala's extensible markup language,
-designed as close as possible to the W3C extensible markup language
-standard. Only the productions for attribute values and character data are changed.
-Scala does not support declarations. Entity references are not resolved at runtime.
+The following productions describe Scala's extensible markup language, designed as close as possible to the W3C extensible markup language standard.
+Only the productions for attribute values and character data are changed.
+Scala does not support declarations.
+Entity references are not resolved at runtime.
 
 ```ebnf
 Element       ::=    EmptyElemTag
@@ -50,21 +44,13 @@ XmlContent    ::=    Element
                 |    Comment
 ```
 
-If an XML expression is a single element, its value is a runtime
-representation of an XML node (an instance of a subclass of
-`scala.xml.Node`). If the XML expression consists of more
-than one element, then its value is a runtime representation of a
-sequence of XML nodes (an instance of a subclass of
-`scala.Seq[scala.xml.Node]`).
+If an XML expression is a single element, its value is a runtime representation of an XML node (an instance of a subclass of `scala.xml.Node`).
+If the XML expression consists of more than one element, then its value is a runtime representation of a sequence of XML nodes (an instance of a subclass of `scala.Seq[scala.xml.Node]`).
 
-If an XML expression is an entity reference, CDATA section, processing
-instruction, or a comment, it is represented by an instance of the
-corresponding Scala runtime class.
+If an XML expression is an entity reference, CDATA section, processing instruction, or a comment, it is represented by an instance of the corresponding Scala runtime class.
 
-By default, beginning and trailing whitespace in element content is removed,
-and consecutive occurrences of whitespace are replaced by a single space
-character `\u0020`. This behavior can be changed to preserve all whitespace
-with a compiler option.
+By default, beginning and trailing whitespace in element content is removed, and consecutive occurrences of whitespace are replaced by a single space character `\u0020`.
+This behavior can be changed to preserve all whitespace with a compiler option.
 
 ```ebnf
 Attribute  ::=    Name Eq AttValue
@@ -80,10 +66,9 @@ CharData      ::=   { CharNoRef } ´\textit{ without}´ {CharNoRef}‘{’CharB
 ```
 
 <!-- {% raw  %} sigh: liquid borks on the double brace below; brace yourself, liquid! -->
-XML expressions may contain Scala expressions as attribute values or
-within nodes. In the latter case, these are embedded using a single opening
-brace `{` and ended by a closing brace `}`. To express a single opening braces
-within XML text as generated by CharData, it must be doubled.
+XML expressions may contain Scala expressions as attribute values or within nodes.
+In the latter case, these are embedded using a single opening brace `{` and ended by a closing brace `}`.
+To express a single opening braces within XML text as generated by CharData, it must be doubled.
 Thus, `{{` represents the XML text `{` and does not introduce an embedded Scala expression.
 <!-- {% endraw %} -->
 
@@ -104,9 +89,7 @@ XNameStart    ::= ‘_’ | BaseChar | Ideographic
 
 ## XML patterns
 
-XML patterns are patterns generated by the following production, where
-the opening bracket `<` of the element patterns must be in a position
-to start the lexical [XML mode](01-lexical-syntax.html#xml-mode).
+XML patterns are patterns generated by the following production, where the opening bracket `<` of the element patterns must be in a position to start the lexical [XML mode](01-lexical-syntax.html#xml-mode).
 
 ```ebnf
 XmlPattern  ::= ElementPattern
@@ -114,18 +97,14 @@ XmlPattern  ::= ElementPattern
 
 Well-formedness constraints of the XML specification apply.
 
-An XML pattern has to be a single element pattern. It
-matches exactly those runtime
-representations of an XML tree
-that have the same structure as described by the pattern.
+An XML pattern has to be a single element pattern.
+It matches exactly those runtime representations of an XML tree that have the same structure as described by the pattern.
 XML patterns may contain [Scala patterns](08-pattern-matching.html#pattern-matching-expressions).
 
 Whitespace is treated the same way as in XML expressions.
 
-By default, beginning and trailing whitespace in element content is removed,
-and consecutive occurrences of whitespace are replaced by a single space
-character `\u0020`. This behavior can be changed to preserve all whitespace
-with a compiler option.
+By default, beginning and trailing whitespace in element content is removed, and consecutive occurrences of whitespace are replaced by a single space character `\u0020`.
+This behavior can be changed to preserve all whitespace with a compiler option.
 
 ```ebnf
 ElemPattern   ::=    EmptyElemTagP
diff --git a/docs/_spec/11-annotations.md b/docs/_spec/11-annotations.md
index 9f806ff5a471..11325a1639f0 100644
--- a/docs/_spec/11-annotations.md
+++ b/docs/_spec/11-annotations.md
@@ -15,16 +15,14 @@ chapter: 11
 
 Annotations associate meta-information with definitions.
 A simple annotation has the form `@´c´` or `@´c(a_1, ..., a_n)´`.
-Here, ´c´ is a constructor of a class ´C´, which must conform
-to the class `scala.Annotation`.
+Here, ´c´ is a constructor of a class ´C´, which must conform to the class `scala.Annotation`.
 
-Annotations may apply to definitions or declarations, types, or
-expressions.  An annotation of a definition or declaration appears in
-front of that definition.  An annotation of a type appears after
-that type. An annotation of an expression ´e´ appears after the
-expression ´e´, separated by a colon. More than one annotation clause
-may apply to an entity. The order in which these annotations are given
-does not matter.
+Annotations may apply to definitions or declarations, types, or expressions.
+An annotation of a definition or declaration appears in front of that definition.
+An annotation of a type appears after that type.
+An annotation of an expression ´e´ appears after the expression ´e´, separated by a colon.
+More than one annotation clause may apply to an entity.
+The order in which these annotations are given does not matter.
 
 Examples:
 
@@ -39,138 +37,90 @@ String @local                               // Type annotation
 
 ### Java Platform Annotations
 
-The meaning of annotation clauses is implementation-dependent. On the
-Java platform, the following annotations have a standard meaning.
+The meaning of annotation clauses is implementation-dependent.
+On the Java platform, the following annotations have a standard meaning.
 
-  * `@transient` Marks a field to be non-persistent; this is
-    equivalent to the `transient`
-    modifier in Java.
+* `@transient` Marks a field to be non-persistent; this is equivalent to the `transient` modifier in Java.
 
-  * `@volatile` Marks a field which can change its value
-    outside the control of the program; this
-    is equivalent to the `volatile`
-    modifier in Java.
+* `@volatile` Marks a field which can change its value outside the control of the program; this is equivalent to the `volatile` modifier in Java.
 
-  * `@SerialVersionUID(<longlit>)` Attaches a serial version identifier (a
-    `long` constant) to a class.
-    This is equivalent to the following field
-    definition in Java:
+* `@SerialVersionUID(<longlit>)` Attaches a serial version identifier (a `long` constant) to a class.
+This is equivalent to the following field definition in Java:
 
-    ```java
-    private final static SerialVersionUID = <longlit>
-    ```
+```java
+private final static SerialVersionUID = <longlit>
+```
 
-  * `@throws(<classlit>)` A Java compiler checks that a program contains handlers for checked exceptions
-    by analyzing which checked exceptions can result from the execution of a method or
-    constructor. For each checked exception which is a possible result, the
-    `throws`
-    clause for the method or constructor must mention the class of that exception
-    or one of the superclasses of the class of that exception.
+* `@throws(<classlit>)` A Java compiler checks that a program contains handlers for checked exceptions by analyzing which checked exceptions can result from the execution of a method or constructor.
+For each checked exception which is a possible result, the `throws` clause for the method or constructor must mention the class of that exception or one of the superclasses of the class of that exception.
 
 ### Java Beans Annotations
 
-  * `@scala.beans.BeanProperty` When prefixed to a definition of some variable `X`, this
-    annotation causes getter and setter methods `getX`, `setX`
-    in the Java bean style to be added in the class containing the
-    variable. The first letter of the variable appears capitalized after
-    the `get` or `set`. When the annotation is added to the
-    definition of an immutable value definition `X`, only a getter is
-    generated. The construction of these methods is part of
-    code-generation; therefore, these methods become visible only once a
-    classfile for the containing class is generated.
+* `@scala.beans.BeanProperty` When prefixed to a definition of some variable `X`, this annotation causes getter and setter methods `getX`, `setX` in the Java bean style to be added in the class containing the variable.
+The first letter of the variable appears capitalized after the `get` or `set`.
+When the annotation is added to the definition of an immutable value definition `X`, only a getter is generated.
+The construction of these methods is part of code-generation; therefore, these methods become visible only once a classfile for the containing class is generated.
 
-  * `@scala.beans.BooleanBeanProperty` This annotation is equivalent to `scala.reflect.BeanProperty`, but
-    the generated getter method is named `isX` instead of `getX`.
+* `@scala.beans.BooleanBeanProperty` This annotation is equivalent to `scala.reflect.BeanProperty`, but the generated getter method is named `isX` instead of `getX`.
 
 ### Deprecation Annotations
 
-  * `@deprecated(message: <stringlit>, since: <stringlit>)`<br/>
-    Marks a definition as deprecated. Accesses to the
-    defined entity will then cause a deprecated warning mentioning the
-    _message_ `<stringlit>` to be issued from the compiler.
-    The argument _since_ documents since when the definition should be considered deprecated.<br/>
-    Deprecated warnings are suppressed in code that belongs itself to a definition
-    that is labeled deprecated.
+* `@deprecated(message: <stringlit>, since: <stringlit>)`<br/>
+Marks a definition as deprecated.
+Accesses to the defined entity will then cause a deprecated warning mentioning the _message_ `<stringlit>` to be issued from the compiler.
+The argument _since_ documents since when the definition should be considered deprecated.<br/>
+Deprecated warnings are suppressed in code that belongs itself to a definition that is labeled deprecated.
 
-  * `@deprecatedName(name: <stringlit>, since: <stringlit>)`<br/>
-    Marks a formal parameter name as deprecated. Invocations of this entity
-    using named parameter syntax referring to the deprecated parameter name cause a deprecation warning.
+* `@deprecatedName(name: <stringlit>, since: <stringlit>)`<br/>
+Marks a formal parameter name as deprecated.
+Invocations of this entity using named parameter syntax referring to the deprecated parameter name cause a deprecation warning.
 
 ### Scala Compiler Annotations
 
-  * `@unchecked` When applied to the selector of a `match` expression,
-    this attribute suppresses any warnings about non-exhaustive pattern
-    matches that would otherwise be emitted. For instance, no warnings
-    would be produced for the method definition below.
-
-    ```scala
-    def f(x: Option[Int]) = (x: @unchecked) match {
-      case Some(y) => y
-    }
-    ```
-
-    Without the `@unchecked` annotation, a Scala compiler could
-    infer that the pattern match is non-exhaustive, and could produce a
-    warning because `Option` is a `sealed` class.
-
-  * `@uncheckedStable` When applied a value declaration or definition, it allows the defined
-    value to appear in a path, even if its type is [volatile](03-types.html#volatile-types).
-    For instance, the following member definitions are legal:
-
-    ```scala
-    type A { type T }
-    type B
-    @uncheckedStable val x: A with B // volatile type
-    val y: x.T                       // OK since `x' is still a path
-    ```
-
-    Without the `@uncheckedStable` annotation, the designator `x`
-    would not be a path since its type `A with B` is volatile. Hence,
-    the reference `x.T` would be malformed.
-
-    When applied to value declarations or definitions that have non-volatile
-    types, the annotation has no effect.
-
-  * `@specialized` When applied to the definition of a type parameter, this annotation causes
-    the compiler
-    to generate specialized definitions for primitive types. An optional list of
-    primitive
-    types may be given, in which case specialization takes into account only
-    those types.
-    For instance, the following code would generate specialized traits for
-    `Unit`, `Int` and `Double`
-
-    ```scala
-    trait Function0[@specialized(Unit, Int, Double) T] {
-      def apply: T
-    }
-    ```
-
-    Whenever the static type of an expression matches a specialized variant of
-    a definition, the compiler will instead use the specialized version.
-    See the [specialization sid](https://docs.scala-lang.org/sips/scala-specialization.html) for more details of the implementation.
+* `@unchecked` When applied to the selector of a `match` expression, this attribute suppresses any warnings about non-exhaustive pattern matches that would otherwise be emitted.
+For instance, no warnings would be produced for the method definition below.
+```scala
+def f(x: Option[Int]) = (x: @unchecked) match {
+  case Some(y) => y
+}
+```
+Without the `@unchecked` annotation, a Scala compiler could infer that the pattern match is non-exhaustive, and could produce a warning because `Option` is a `sealed` class.
+
+* `@uncheckedStable` When applied a value declaration or definition, it allows the defined value to appear in a path, even if its type is [volatile](03-types.html#volatile-types).
+For instance, the following member definitions are legal:
+```scala
+type A { type T }
+type B
+@uncheckedStable val x: A with B // volatile type
+val y: x.T                       // OK since `x' is still a path
+```
+Without the `@uncheckedStable` annotation, the designator `x` would not be a path since its type `A with B` is volatile.
+Hence, the reference `x.T` would be malformed.
+
+When applied to value declarations or definitions that have non-volatile types, the annotation has no effect.
+
+* `@specialized` When applied to the definition of a type parameter, this annotation causes the compiler to generate specialized definitions for primitive types.
+An optional list of primitive types may be given, in which case specialization takes into account only those types.
+For instance, the following code would generate specialized traits for `Unit`, `Int` and `Double`
+```scala
+trait Function0[@specialized(Unit, Int, Double) T] {
+  def apply: T
+}
+```
+Whenever the static type of an expression matches a specialized variant of a definition, the compiler will instead use the specialized version.
+See the [specialization sid](https://docs.scala-lang.org/sips/scala-specialization.html) for more details of the implementation.
     
 
 ## User-defined Annotations
 
-Other annotations may be interpreted by platform- or application-dependent
-tools. The class `scala.annotation.Annotation` is the base class for
-user-defined annotations. It has two sub-traits:
-- `scala.annotation.StaticAnnotation`: Instances of a subclass of this trait
-  will be stored in the generated class files, and therefore accessible to
-  runtime reflection and later compilation runs.
-- `scala.annotation.ConstantAnnotation`: Instances of a subclass of this trait
-  may only have arguments which are
-  [constant expressions](06-expressions.html#constant-expressions), and are
-  also stored in the generated class files.
-- If an annotation class inherits from neither `scala.ConstantAnnotation` nor
-  `scala.StaticAnnotation`, its instances are visible only locally during the
-  compilation run that analyzes them.
+Other annotations may be interpreted by platform- or application-dependent tools.
+The class `scala.annotation.Annotation` is the base class for user-defined annotations. It has two sub-traits:
+- `scala.annotation.StaticAnnotation`: Instances of a subclass of this trait will be stored in the generated class files, and therefore accessible to runtime reflection and later compilation runs.
+- `scala.annotation.ConstantAnnotation`: Instances of a subclass of this trait may only have arguments which are [constant expressions](06-expressions.html#constant-expressions), and are also stored in the generated class files.
+- If an annotation class inherits from neither `scala.ConstantAnnotation` nor `scala.StaticAnnotation`, its instances are visible only locally during the compilation run that analyzes them.
 
 ## Host-platform Annotations
 
-The host platform may define its own annotation format. These annotations do not
-extend any of the classes in the `scala.annotation` package, but can generally
-be used in the same way as Scala annotations. The host platform may impose
-additional restrictions on the expressions which are valid as annotation
-arguments.
+The host platform may define its own annotation format.
+These annotations do not extend any of the classes in the `scala.annotation` package, but can generally be used in the same way as Scala annotations.
+The host platform may impose additional restrictions on the expressions which are valid as annotation arguments.
diff --git a/docs/_spec/12-the-scala-standard-library.md b/docs/_spec/12-the-scala-standard-library.md
index 9bbc12e463dd..086d396ba4dd 100644
--- a/docs/_spec/12-the-scala-standard-library.md
+++ b/docs/_spec/12-the-scala-standard-library.md
@@ -6,39 +6,28 @@ chapter: 12
 
 # The Scala Standard Library
 
-The Scala standard library consists of the package `scala` with a
-number of classes and modules. Some of these classes are described in
-the following.
+The Scala standard library consists of the package `scala` with a number of classes and modules.
+Some of these classes are described in the following.
 
 ![Class hierarchy of Scala](public/images/classhierarchy.png)
 
 ## Root Classes
 
 The root of this hierarchy is formed by class `Any`.
-Every class in a Scala execution environment inherits directly or
-indirectly from this class.  Class `Any` has two direct
-subclasses: `AnyRef` and `AnyVal`.
+Every class in a Scala execution environment inherits directly or indirectly from this class.
+Class `Any` has two direct subclasses: `AnyRef` and `AnyVal`.
 
-The subclass `AnyRef` represents all values which are represented
-as objects in the underlying host system. Classes written in other languages
-inherit from `scala.AnyRef`.
+The subclass `AnyRef` represents all values which are represented as objects in the underlying host system.
+Classes written in other languages inherit from `scala.AnyRef`.
 
-The predefined subclasses of class `AnyVal` describe
-values which are not implemented as objects in the underlying host
-system.
+The predefined subclasses of class `AnyVal` describe values which are not implemented as objects in the underlying host system.
 
-User-defined Scala classes which do not explicitly inherit from
-`AnyVal` inherit directly or indirectly from `AnyRef`. They cannot
-inherit from both `AnyRef` and `AnyVal`.
+User-defined Scala classes which do not explicitly inherit from `AnyVal` inherit directly or indirectly from `AnyRef`.
+They cannot inherit from both `AnyRef` and `AnyVal`.
 
-Classes `AnyRef` and `AnyVal` are required to provide only
-the members declared in class `Any`, but implementations may add
-host-specific methods to these classes (for instance, an
-implementation may identify class `AnyRef` with its own root
-class for objects).
+Classes `AnyRef` and `AnyVal` are required to provide only the members declared in class `Any`, but implementations may add host-specific methods to these classes (for instance, an implementation may identify class `AnyRef` with its own root class for objects).
 
-The signatures of these root classes are described by the following
-definitions.
+The signatures of these root classes are described by the following definitions.
 
 ```scala
 package scala
@@ -88,8 +77,7 @@ class AnyRef extends Any {
 }
 ```
 
-The type test `´x´.isInstanceOf[´T´]` is equivalent to a typed
-pattern match
+The type test `´x´.isInstanceOf[´T´]` is equivalent to a typed pattern match
 
 ```scala
 ´x´ match {
@@ -98,33 +86,25 @@ pattern match
 }
 ```
 
-where the type ´T'´ is the same as ´T´ except if ´T´ is
-of the form ´D´ or ´D[\mathit{tps}]´ where ´D´ is a type member of some outer class ´C´.
+where the type ´T'´ is the same as ´T´ except if ´T´ is of the form ´D´ or ´D[\mathit{tps}]´ where ´D´ is a type member of some outer class ´C´.
 In this case ´T'´ is `´C´#´D´` (or `´C´#´D[tps]´`, respectively), whereas ´T´ itself would expand to `´C´.this.´D[tps]´`.
 In other words, an `isInstanceOf` test does not check that types have the same enclosing instance.
 
-The test `´x´.asInstanceOf[´T´]` is treated specially if ´T´ is a
-[numeric value type](#value-classes). In this case the cast will
-be translated to an application of a [conversion method](#numeric-value-types)
-`x.to´T´`. For non-numeric values ´x´ the operation will raise a
-`ClassCastException`.
+The test `´x´.asInstanceOf[´T´]` is treated specially if ´T´ is a [numeric value type](#value-classes).
+In this case the cast will be translated to an application of a [conversion method](#numeric-value-types) `x.to´T´`.
+For non-numeric values ´x´ the operation will raise a `ClassCastException`.
 
 ## Value Classes
 
-Value classes are classes whose instances are not represented as
-objects by the underlying host system.  All value classes inherit from
-class `AnyVal`. Scala implementations need to provide the
-value classes `Unit`, `Boolean`, `Double`, `Float`,
-`Long`, `Int`, `Char`, `Short`, and `Byte`
-(but are free to provide others as well).
+Value classes are classes whose instances are not represented as objects by the underlying host system.
+All value classes inherit from class `AnyVal`.
+Scala implementations need to provide the value classes `Unit`, `Boolean`, `Double`, `Float`, `Long`, `Int`, `Char`, `Short`, and `Byte` (but are free to provide others as well).
 The signatures of these classes are defined in the following.
 
 ### Numeric Value Types
 
-Classes `Double`, `Float`,
-`Long`, `Int`, `Char`, `Short`, and `Byte`
-are together called _numeric value types_. Classes `Byte`,
-`Short`, or `Char` are called _subrange types_.
+Classes `Double`, `Float`, `Long`, `Int`, `Char`, `Short`, and `Byte` are together called _numeric value types_.
+Classes `Byte`, `Short`, or `Char` are called _subrange types_.
 Subrange types, as well as `Int` and `Long` are called _integer types_, whereas `Float` and `Double` are called _floating point types_.
 
 Numeric value types are ranked in the following partial order:
@@ -137,81 +117,52 @@ Byte - Short
         Char
 ```
 
-`Byte` and `Short` are the lowest-ranked types in this order,
-whereas `Double` is the highest-ranked.  Ranking does _not_
-imply a [conformance relationship](03-types.html#conformance); for
-instance `Int` is not a subtype of `Long`.  However, object
-[`Predef`](#the-predef-object) defines [views](07-implicits.html#views)
-from every numeric value type to all higher-ranked numeric value types.
-Therefore, lower-ranked types are implicitly converted to higher-ranked types
-when required by the [context](06-expressions.html#implicit-conversions).
-
-Given two numeric value types ´S´ and ´T´, the _operation type_ of
-´S´ and ´T´ is defined as follows: If both ´S´ and ´T´ are subrange
-types then the operation type of ´S´ and ´T´ is `Int`.  Otherwise
-the operation type of ´S´ and ´T´ is the larger of the two types wrt
-ranking. Given two numeric values ´v´ and ´w´ the operation type of
-´v´ and ´w´ is the operation type of their run-time types.
+`Byte` and `Short` are the lowest-ranked types in this order, whereas `Double` is the highest-ranked.
+Ranking does _not_
+imply a [conformance relationship](03-types.html#conformance); for instance `Int` is not a subtype of `Long`.
+However, object [`Predef`](#the-predef-object) defines [views](07-implicits.html#views) from every numeric value type to all higher-ranked numeric value types.
+Therefore, lower-ranked types are implicitly converted to higher-ranked types when required by the [context](06-expressions.html#implicit-conversions).
+
+Given two numeric value types ´S´ and ´T´, the _operation type_ of ´S´ and ´T´ is defined as follows: If both ´S´ and ´T´ are subrange types then the operation type of ´S´ and ´T´ is `Int`.
+Otherwise the operation type of ´S´ and ´T´ is the larger of the two types wrt
+ranking.
+Given two numeric values ´v´ and ´w´ the operation type of ´v´ and ´w´ is the operation type of their run-time types.
 
 Any numeric value type ´T´ supports the following methods.
 
-  * Comparison methods for equals (`==`), not-equals (`!=`),
-    less-than (`<`), greater-than (`>`), less-than-or-equals
-    (`<=`), greater-than-or-equals (`>=`), which each exist in 7
-    overloaded alternatives. Each alternative takes a parameter of some
-    numeric value type. Its result type is type `Boolean`. The
-    operation is evaluated by converting the receiver and its argument to
-    their operation type and performing the given comparison operation of
-    that type.
-  * Arithmetic methods addition (`+`), subtraction (`-`),
-    multiplication (`*`), division (`/`), and remainder
-    (`%`), which each exist in 7 overloaded alternatives. Each
-    alternative takes a parameter of some numeric value type ´U´.  Its
-    result type is the operation type of ´T´ and ´U´. The operation is
-    evaluated by converting the receiver and its argument to their
-    operation type and performing the given arithmetic operation of that
-    type.
-  * Parameterless arithmetic methods identity (`+`) and negation
-    (`-`), with result type ´T´.  The first of these returns the
-    receiver unchanged, whereas the second returns its negation.
-  * Conversion methods `toByte`, `toShort`, `toChar`,
-    `toInt`, `toLong`, `toFloat`, `toDouble` which
-    convert the receiver object to the target type, using the rules of
-    Java's numeric type cast operation. The conversion might truncate the
-    numeric value (as when going from `Long` to `Int` or from
-    `Int` to `Byte`) or it might lose precision (as when going
-    from `Double` to `Float` or when converting between
-    `Long` and `Float`).
+* Comparison methods for equals (`==`), not-equals (`!=`), less-than (`<`), greater-than (`>`), less-than-or-equals (`<=`), greater-than-or-equals (`>=`), which each exist in 7 overloaded alternatives.
+Each alternative takes a parameter of some numeric value type.
+Its result type is type `Boolean`.
+The operation is evaluated by converting the receiver and its argument to their operation type and performing the given comparison operation of that type.
+* Arithmetic methods addition (`+`), subtraction (`-`), multiplication (`*`), division (`/`), and remainder (`%`), which each exist in 7 overloaded alternatives.
+Each alternative takes a parameter of some numeric value type ´U´.
+Its result type is the operation type of ´T´ and ´U´.
+The operation is evaluated by converting the receiver and its argument to their operation type and performing the given arithmetic operation of that type.
+* Parameterless arithmetic methods identity (`+`) and negation (`-`), with result type ´T´.
+The first of these returns the receiver unchanged, whereas the second returns its negation.
+* Conversion methods `toByte`, `toShort`, `toChar`, `toInt`, `toLong`, `toFloat`, `toDouble` which convert the receiver object to the target type, using the rules of Java's numeric type cast operation.
+The conversion might truncate the numeric value (as when going from `Long` to `Int` or from `Int` to `Byte`) or it might lose precision (as when going from `Double` to `Float` or when converting between `Long` and `Float`).
 
 Integer numeric value types support in addition the following operations:
 
-  * Bit manipulation methods bitwise-and (`&`), bitwise-or
-    {`|`}, and bitwise-exclusive-or (`^`), which each exist in 5
-    overloaded alternatives. Each alternative takes a parameter of some
-    integer numeric value type. Its result type is the operation type of
-    ´T´ and ´U´. The operation is evaluated by converting the receiver and
-    its argument to their operation type and performing the given bitwise
-    operation of that type.
-
-  * A parameterless bit-negation method (`~`). Its result type is
-    the receiver type ´T´ or `Int`, whichever is larger.
-    The operation is evaluated by converting the receiver to the result
-    type and negating every bit in its value.
-  * Bit-shift methods left-shift (`<<`), arithmetic right-shift
-    (`>>`), and unsigned right-shift (`>>>`). Each of these
-    methods has two overloaded alternatives, which take a parameter ´n´
-    of type `Int`, respectively `Long`. The result type of the
-    operation is the receiver type ´T´, or `Int`, whichever is larger.
-    The operation is evaluated by converting the receiver to the result
-    type and performing the specified shift by ´n´ bits.
-
-Numeric value types also implement operations `equals`,
-`hashCode`, and `toString` from class `Any`.
-
-The `equals` method tests whether the argument is a numeric value
-type. If this is true, it will perform the `==` operation which
-is appropriate for that type. That is, the `equals` method of a
-numeric value type can be thought of being defined as follows:
+* Bit manipulation methods bitwise-and (`&`), bitwise-or {`|`}, and bitwise-exclusive-or (`^`), which each exist in 5 overloaded alternatives.
+Each alternative takes a parameter of some integer numeric value type.
+Its result type is the operation type of ´T´ and ´U´.
+The operation is evaluated by converting the receiver and its argument to their operation type and performing the given bitwise operation of that type.
+
+* A parameterless bit-negation method (`~`).
+Its result type is the receiver type ´T´ or `Int`, whichever is larger.
+The operation is evaluated by converting the receiver to the result type and negating every bit in its value.
+* Bit-shift methods left-shift (`<<`), arithmetic right-shift (`>>`), and unsigned right-shift (`>>>`).
+Each of these methods has two overloaded alternatives, which take a parameter ´n´ of type `Int`, respectively `Long`.
+The result type of the operation is the receiver type ´T´, or `Int`, whichever is larger.
+The operation is evaluated by converting the receiver to the result type and performing the specified shift by ´n´ bits.
+
+Numeric value types also implement operations `equals`, `hashCode`, and `toString` from class `Any`.
+
+The `equals` method tests whether the argument is a numeric value type.
+If this is true, it will perform the `==` operation which is appropriate for that type.
+That is, the `equals` method of a numeric value type can be thought of being defined as follows:
 
 ```scala
 def equals(other: Any): Boolean = other match {
@@ -226,12 +177,10 @@ def equals(other: Any): Boolean = other match {
 }
 ```
 
-The `hashCode` method returns an integer hashcode that maps equal
-numeric values to equal results. It is guaranteed to be the identity
-for type `Int` and for all subrange types.
+The `hashCode` method returns an integer hashcode that maps equal numeric values to equal results.
+It is guaranteed to be the identity for type `Int` and for all subrange types.
 
-The `toString` method displays its receiver as an integer or
-floating point number.
+The `toString` method displays its receiver as an integer or floating point number.
 
 ###### Example
 
@@ -285,9 +234,8 @@ abstract sealed class Int extends AnyVal {
 
 ### Class `Boolean`
 
-Class `Boolean` has only two values: `true` and
-`false`. It implements operations as given in the following
-class definition.
+Class `Boolean` has only two values: `true` and `false`.
+It implements operations as given in the following class definition.
 
 ```scala
 package scala
@@ -309,47 +257,36 @@ abstract sealed class Boolean extends AnyVal {
 }
 ```
 
-The class also implements operations `equals`, `hashCode`,
-and `toString` from class `Any`.
+The class also implements operations `equals`, `hashCode`, and `toString` from class `Any`.
 
-The `equals` method returns `true` if the argument is the
-same boolean value as the receiver, `false` otherwise.  The
-`hashCode` method returns a fixed, implementation-specific hash-code when invoked on `true`,
-and a different, fixed, implementation-specific hash-code when invoked on `false`. The `toString` method
-returns the receiver converted to a string, i.e. either `"true"` or `"false"`.
+The `equals` method returns `true` if the argument is the same boolean value as the receiver, `false` otherwise.
+The `hashCode` method returns a fixed, implementation-specific hash-code when invoked on `true`, and a different, fixed, implementation-specific hash-code when invoked on `false`.
+The `toString` method returns the receiver converted to a string, i.e. either `"true"` or `"false"`.
 
 ### Class `Unit`
 
-Class `Unit` has only one value: `()`. It implements only
-the three methods `equals`, `hashCode`, and `toString`
-from class `Any`.
+Class `Unit` has only one value: `()`.
+It implements only the three methods `equals`, `hashCode`, and `toString` from class `Any`.
 
-The `equals` method returns `true` if the argument is the
-unit value `()`, `false` otherwise.  The
-`hashCode` method returns a fixed, implementation-specific hash-code,
+The `equals` method returns `true` if the argument is the unit value `()`, `false` otherwise.
+The `hashCode` method returns a fixed, implementation-specific hash-code.
 The `toString` method returns `"()"`.
 
 ## Standard Reference Classes
 
-This section presents some standard Scala reference classes which are
-treated in a special way by the Scala compiler – either Scala provides
-syntactic sugar for them, or the Scala compiler generates special code
-for their operations. Other classes in the standard Scala library are
-documented in the Scala library documentation by HTML pages.
+This section presents some standard Scala reference classes which are treated in a special way by the Scala compiler – either Scala provides syntactic sugar for them, or the Scala compiler generates special code for their operations.
+Other classes in the standard Scala library are documented in the Scala library documentation by HTML pages.
 
 ### Class `String`
 
-Scala's `String` class is usually derived from the standard String
-class of the underlying host system (and may be identified with
-it). For Scala clients the class is taken to support in each case a
-method
+Scala's `String` class is usually derived from the standard String class of the underlying host system (and may be identified with it).
+For Scala clients the class is taken to support in each case a method
 
 ```scala
 def + (that: Any): String
 ```
 
-which concatenates its left operand with the textual representation of its
-right operand.
+which concatenates its left operand with the textual representation of its right operand.
 
 ### The `Tuple` classes
 
@@ -385,14 +322,12 @@ class PartialFunction[-A, +B] extends Function1[A, B] {
 }
 ```
 
-The implicitly imported [`Predef`](#the-predef-object) object defines the name
-`Function` as an alias of `Function1`.
+The implicitly imported [`Predef`](#the-predef-object) object defines the name `Function` as an alias of `Function1`.
 
 ### Class `Array`
 
-All operations on arrays desugar to the corresponding operations of the
-underlying platform. Therefore, the following class definition is given for
-informational purposes only:
+All operations on arrays desugar to the corresponding operations of the underlying platform.
+Therefore, the following class definition is given for informational purposes only:
 
 ```scala
 final class Array[T](_length: Int)
@@ -404,20 +339,14 @@ extends java.io.Serializable with java.lang.Cloneable {
 }
 ```
 
-If ´T´ is not a type parameter or abstract type, the type `Array[T]`
-is represented as the array type `|T|[]` in the
-underlying host system, where `|T|` is the erasure of `T`.
-If ´T´ is a type parameter or abstract type, a different representation might be
-used (it is `Object` on the Java platform).
+If ´T´ is not a type parameter or abstract type, the type `Array[T]` is represented as the array type `|T|[]` in the underlying host system, where `|T|` is the erasure of `T`.
+If ´T´ is a type parameter or abstract type, a different representation might be used (it is `Object` on the Java platform).
 
 #### Operations
 
-`length` returns the length of the array, `apply` means subscripting,
-and `update` means element update.
+`length` returns the length of the array, `apply` means subscripting, and `update` means element update.
 
-Because of the syntactic sugar for `apply` and `update` operations,
-we have the following correspondences between Scala and Java code for
-operations on an array `xs`:
+Because of the syntactic sugar for `apply` and `update` operations, we have the following correspondences between Scala and Java code for operations on an array `xs`:
 
 |_Scala_           |_Java_      |
 |------------------|------------|
@@ -425,35 +354,22 @@ operations on an array `xs`:
 |`xs(i)`           |`xs[i]`     |
 |`xs(i) = e`       |`xs[i] = e` |
 
-Two implicit conversions exist in `Predef` that are frequently applied to arrays:
-a conversion to `scala.collection.mutable.ArrayOps` and a conversion to
-`scala.collection.mutable.ArraySeq` (a subtype of `scala.collection.Seq`).
+Two implicit conversions exist in `Predef` that are frequently applied to arrays: a conversion to `scala.collection.mutable.ArrayOps` and a conversion to `scala.collection.mutable.ArraySeq` (a subtype of `scala.collection.Seq`).
 
-Both types make many of the standard operations found in the Scala
-collections API available. The conversion to `ArrayOps` is temporary, as all operations
-defined on `ArrayOps` return a value of type `Array`, while the conversion to `ArraySeq`
-is permanent as all operations return a value of type `ArraySeq`.
+Both types make many of the standard operations found in the Scala collections API available.
+The conversion to `ArrayOps` is temporary, as all operations defined on `ArrayOps` return a value of type `Array`, while the conversion to `ArraySeq` is permanent as all operations return a value of type `ArraySeq`.
 The conversion to `ArrayOps` takes priority over the conversion to `ArraySeq`.
 
-Because of the tension between parametrized types in Scala and the ad-hoc
-implementation of arrays in the host-languages, some subtle points
-need to be taken into account when dealing with arrays. These are
-explained in the following.
+Because of the tension between parametrized types in Scala and the ad-hoc implementation of arrays in the host-languages, some subtle points need to be taken into account when dealing with arrays.
+These are explained in the following.
 
 #### Variance
 
-Unlike arrays in Java, arrays in Scala are _not_
-co-variant; That is, ´S <: T´ does not imply
-`Array[´S´] ´<:´ Array[´T´]` in Scala.
-However, it is possible to cast an array
-of ´S´ to an array of ´T´ if such a cast is permitted in the host
-environment.
+Unlike arrays in Java, arrays in Scala are _not_ co-variant; That is, ´S <: T´ does not imply `Array[´S´] ´<:´ Array[´T´]` in Scala.
+However, it is possible to cast an array of ´S´ to an array of ´T´ if such a cast is permitted in the host environment.
 
-For instance `Array[String]` does not conform to
-`Array[Object]`, even though `String` conforms to `Object`.
-However, it is possible to cast an expression of type
-`Array[String]` to `Array[Object]`, and this
-cast will succeed without raising a `ClassCastException`. Example:
+For instance `Array[String]` does not conform to `Array[Object]`, even though `String` conforms to `Object`.
+However, it is possible to cast an expression of type `Array[String]` to `Array[Object]`, and this cast will succeed without raising a `ClassCastException`. Example:
 
 ```scala
 val xs = new Array[String](2)
@@ -461,14 +377,9 @@ val xs = new Array[String](2)
 val ys: Array[Object] = xs.asInstanceOf[Array[Object]] // OK
 ```
 
-The instantiation of an array with a polymorphic element type ´T´ requires
-information about type ´T´ at runtime.
-This information is synthesized by adding a [context bound](07-implicits.html#context-bounds-and-view-bounds)
-of `scala.reflect.ClassTag` to type ´T´.
-An example is the
-following implementation of method `mkArray`, which creates
-an array of an arbitrary type ´T´, given a sequence of ´T´`s which
-defines its elements:
+The instantiation of an array with a polymorphic element type ´T´ requires information about type ´T´ at runtime.
+This information is synthesized by adding a [context bound](07-implicits.html#context-bounds-and-view-bounds) of `scala.reflect.ClassTag` to type ´T´.
+An example is the following implementation of method `mkArray`, which creates an array of an arbitrary type ´T´, given a sequence of ´T´`s which defines its elements:
 
 ```scala
 import reflect.ClassTag
@@ -483,19 +394,14 @@ def mkArray[T : ClassTag](elems: Seq[T]): Array[T] = {
 }
 ```
 
-If type ´T´ is a type for which the host platform offers a specialized array
-representation, this representation is used.
+If type ´T´ is a type for which the host platform offers a specialized array representation, this representation is used.
 
 ###### Example
-On the Java Virtual Machine, an invocation of `mkArray(List(1,2,3))`
-will return a primitive array of `int`s, written as `int[]` in Java.
+On the Java Virtual Machine, an invocation of `mkArray(List(1,2,3))` will return a primitive array of `int`s, written as `int[]` in Java.
 
 #### Companion object
 
-`Array`'s companion object provides various factory methods for the
-instantiation of single- and multi-dimensional arrays, an extractor method
-[`unapplySeq`](08-pattern-matching.html#extractor-patterns) which enables pattern matching
-over arrays and additional utility methods:
+`Array`'s companion object provides various factory methods for the instantiation of single- and multi-dimensional arrays, an extractor method [`unapplySeq`](08-pattern-matching.html#extractor-patterns) which enables pattern matching over arrays and additional utility methods:
 
 ```scala
 package scala
@@ -623,10 +529,8 @@ trait Node {
 
 ## The `Predef` Object
 
-The `Predef` object defines standard functions and type aliases
-for Scala programs. It is implicitly imported, as described in
-[the chapter on name binding](02-identifiers-names-and-scopes.html),
-so that all its defined members are available without qualification.
+The `Predef` object defines standard functions and type aliases for Scala programs.
+It is implicitly imported, as described in [the chapter on name binding](02-identifiers-names-and-scopes.html), so that all its defined members are available without qualification.
 Its definition for the JVM environment conforms to the following signature:
 
 ```scala
@@ -728,89 +632,70 @@ object Predef {
 ### Predefined Implicit Definitions
 
 The `Predef` object also contains a number of implicit definitions, which are available by default (because `Predef` is implicitly imported).
-Implicit definitions come in two priorities. High-priority implicits are defined in the `Predef` class itself whereas low priority implicits are defined in a class inherited by `Predef`. The rules of
-static [overloading resolution](06-expressions.html#overloading-resolution)
-stipulate that, all other things being equal, implicit resolution
-prefers high-priority implicits over low-priority ones.
+Implicit definitions come in two priorities.
+High-priority implicits are defined in the `Predef` class itself whereas low priority implicits are defined in a class inherited by `Predef`.
+The rules of static [overloading resolution](06-expressions.html#overloading-resolution) stipulate that, all other things being equal, implicit resolution prefers high-priority implicits over low-priority ones.
 
 The available low-priority implicits include definitions falling into the following categories.
 
-1.  For every primitive type, a wrapper that takes values of that type
-    to instances of a `runtime.Rich*` class. For instance, values of type `Int`
-    can be implicitly converted to instances of class `runtime.RichInt`.
+1.  For every primitive type, a wrapper that takes values of that type to instances of a `runtime.Rich*` class.
+For instance, values of type `Int` can be implicitly converted to instances of class `runtime.RichInt`.
 
-1.  For every array type with elements of primitive type, a wrapper that
-    takes the arrays of that type to instances of a `ArraySeq` class. For instance, values of type `Array[Float]` can be implicitly converted to instances of class `ArraySeq[Float]`.
-    There are also generic array wrappers that take elements
-    of type `Array[T]` for arbitrary `T` to `ArraySeq`s.
+1.  For every array type with elements of primitive type, a wrapper that takes the arrays of that type to instances of a `ArraySeq` class.
+For instance, values of type `Array[Float]` can be implicitly converted to instances of class `ArraySeq[Float]`.
+There are also generic array wrappers that take elements of type `Array[T]` for arbitrary `T` to `ArraySeq`s.
 
 1.  An implicit conversion from `String` to `WrappedString`.
 
 The available high-priority implicits include definitions falling into the following categories.
 
-  * An implicit wrapper that adds `ensuring` methods
-    with the following overloaded variants to type `Any`.
-
-    ```scala
-    def ensuring(cond: Boolean): A = { assert(cond); x }
-    def ensuring(cond: Boolean, msg: Any): A = { assert(cond, msg); x }
-    def ensuring(cond: A => Boolean): A = { assert(cond(x)); x }
-    def ensuring(cond: A => Boolean, msg: Any): A = { assert(cond(x), msg); x }
-    ```
-
-  * An implicit wrapper that adds a `->` method with the following implementation
-    to type `Any`.
-
-    ```scala
-    def -> [B](y: B): (A, B) = (x, y)
-    ```
-
-  * For every array type with elements of primitive type, a wrapper that
-    takes the arrays of that type to instances of a `runtime.ArrayOps`
-    class. For instance, values of type `Array[Float]` can be implicitly
-    converted to instances of class `runtime.ArrayOps[Float]`.  There are
-    also generic array wrappers that take elements of type `Array[T]` for
-    arbitrary `T` to `ArrayOps`s.
-
-  * An implicit wrapper that adds `+` and `formatted` method with the following
-    implementations to type `Any`.
-
-    ```scala
-    def +(other: String) = String.valueOf(self) + other
-    def formatted(fmtstr: String): String = fmtstr format self
-    ```
-
-  * Numeric primitive conversions that implement the transitive closure of the
-    following mappings:
-
-    ```
-    Byte  -> Short
-    Short -> Int
-    Char  -> Int
-    Int   -> Long
-    Long  -> Float
-    Float -> Double
-    ```
-
-  * Boxing and unboxing conversions between primitive types and their boxed
-    versions:
-
-    ```
-    Byte    <-> java.lang.Byte
-    Short   <-> java.lang.Short
-    Char    <-> java.lang.Character
-    Int     <-> java.lang.Integer
-    Long    <-> java.lang.Long
-    Float   <-> java.lang.Float
-    Double  <-> java.lang.Double
-    Boolean <-> java.lang.Boolean
-    ```
-
-  * An implicit definition that generates instances of type `T <:< T`, for
-    any type `T`. Here, `<:<` is a class defined as follows.
-
-    ```scala
-    sealed abstract class <:<[-From, +To] extends (From => To)
-    ```
-
-    Implicit parameters of `<:<` types are typically used to implement type constraints.
+* An implicit wrapper that adds `ensuring` methods with the following overloaded variants to type `Any`.
+```scala
+def ensuring(cond: Boolean): A = { assert(cond); x }
+def ensuring(cond: Boolean, msg: Any): A = { assert(cond, msg); x }
+def ensuring(cond: A => Boolean): A = { assert(cond(x)); x }
+def ensuring(cond: A => Boolean, msg: Any): A = { assert(cond(x), msg); x }
+```
+
+* An implicit wrapper that adds a `->` method with the following implementation to type `Any`.
+```scala
+def -> [B](y: B): (A, B) = (x, y)
+```
+
+* For every array type with elements of primitive type, a wrapper that takes the arrays of that type to instances of a `runtime.ArrayOps` class.
+For instance, values of type `Array[Float]` can be implicitly converted to instances of class `runtime.ArrayOps[Float]`.
+There are also generic array wrappers that take elements of type `Array[T]` for arbitrary `T` to `ArrayOps`s.
+
+* An implicit wrapper that adds `+` and `formatted` method with the following implementations to type `Any`.
+```scala
+def +(other: String) = String.valueOf(self) + other
+def formatted(fmtstr: String): String = fmtstr format self
+```
+
+* Numeric primitive conversions that implement the transitive closure of the following mappings:
+```
+Byte  -> Short
+Short -> Int
+Char  -> Int
+Int   -> Long
+Long  -> Float
+Float -> Double
+```
+
+* Boxing and unboxing conversions between primitive types and their boxed versions:
+```
+Byte    <-> java.lang.Byte
+Short   <-> java.lang.Short
+Char    <-> java.lang.Character
+Int     <-> java.lang.Integer
+Long    <-> java.lang.Long
+Float   <-> java.lang.Float
+Double  <-> java.lang.Double
+Boolean <-> java.lang.Boolean
+```
+
+* An implicit definition that generates instances of type `T <:< T`, for any type `T`. Here, `<:<` is a class defined as follows.
+```scala
+sealed abstract class <:<[-From, +To] extends (From => To)
+```
+Implicit parameters of `<:<` types are typically used to implement type constraints.
diff --git a/docs/_spec/13-syntax-summary.md b/docs/_spec/13-syntax-summary.md
index e799a6f579b3..7c1d394bd4e1 100644
--- a/docs/_spec/13-syntax-summary.md
+++ b/docs/_spec/13-syntax-summary.md
@@ -88,8 +88,7 @@ semi             ::=  ‘;’ |  nl {nl}
 
 ## Context-free Syntax
 
-The context-free syntax of Scala is given by the following EBNF
-grammar:
+The context-free syntax of Scala is given by the following EBNF grammar:
 
 ```ebnf
   Literal           ::=  [‘-’] integerLiteral
diff --git a/docs/_spec/README.md b/docs/_spec/README.md
index e1c7e3497601..5aa9240c6158 100644
--- a/docs/_spec/README.md
+++ b/docs/_spec/README.md
@@ -39,6 +39,10 @@ and open http://0.0.0.0:4000/ to view the spec. Jekyll will rebuild as you edit
 - Use of the appropriate unicode characters instead of the latex modifiers for accents, etc. is necessary. For example, é instead of `\'e`.
 - MathJAX errors  will appear within the  rendered DOM as span  elements with class `mtext` and style attribute `color: red` applied. It is  possible to search for this combination in the development  tools of the browser of your choice. In chrome, CTRL+F / CMD+F within the inspect element panel allows you to do this.
 
+- This document follows the "one sentence <=> one line" convention, with the following exceptions below.
+- - A multiline code bloc is part of the sentence
+- - An enumeration of links is long enough
+
 ### Macro replacements:
 
 - While  MathJAX just  support LaTeX style  command definition,  it is recommended  to not use  this as  it will likely cause issues with preparing the document for PDF or ebook distribution.

From 75d671fe392c406851924f062d679ee98cd2c372 Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Wed, 12 Oct 2022 16:54:18 +0200
Subject: [PATCH 107/657] Replace function by method wherever possible

---
 docs/_spec/01-lexical-syntax.md               |  2 +-
 docs/_spec/03-types.md                        |  2 +-
 .../04-basic-declarations-and-definitions.md  | 42 +++++++++----------
 docs/_spec/05-classes-and-objects.md          |  2 +-
 docs/_spec/06-expressions.md                  | 32 +++++++-------
 docs/_spec/08-pattern-matching.md             |  2 +-
 docs/_spec/12-the-scala-standard-library.md   |  2 +-
 7 files changed, 42 insertions(+), 42 deletions(-)

diff --git a/docs/_spec/01-lexical-syntax.md b/docs/_spec/01-lexical-syntax.md
index 032cf3703bb9..862e85a014be 100644
--- a/docs/_spec/01-lexical-syntax.md
+++ b/docs/_spec/01-lexical-syntax.md
@@ -234,7 +234,7 @@ A single new line token is accepted
 >         (y: Int) = x + y
 > ```
 >
-> With an additional newline character, the same code is interpreted as an abstract function definition and a syntactically illegal statement:
+> With an additional newline character, the same code is interpreted as an abstract method definition and a syntactically illegal statement:
 >
 > ```scala
 > def func(x: Int)
diff --git a/docs/_spec/03-types.md b/docs/_spec/03-types.md
index 664ddea49713..42157b176888 100644
--- a/docs/_spec/03-types.md
+++ b/docs/_spec/03-types.md
@@ -335,7 +335,7 @@ An argument type of the form ´\Rightarrow T´ represents a [call-by-name parame
 
 Function types associate to the right, e.g. ´S \Rightarrow T \Rightarrow U´ is the same as ´S \Rightarrow (T \Rightarrow U)´.
 
-Function types are shorthands for class types that define `apply` functions.
+Function types are shorthands for class types that define an `apply` method.
 Specifically, the ´n´-ary function type ´(T_1 , \ldots , T_n) \Rightarrow U´ is a shorthand for the class type `Function´_n´[´T_1´ , … , ´T_n´, ´U´]`.
 Such class types are defined in the Scala library for ´n´ between 0 and 22 as follows.
 
diff --git a/docs/_spec/04-basic-declarations-and-definitions.md b/docs/_spec/04-basic-declarations-and-definitions.md
index f9e55b15a59b..af98eef2a37d 100644
--- a/docs/_spec/04-basic-declarations-and-definitions.md
+++ b/docs/_spec/04-basic-declarations-and-definitions.md
@@ -183,7 +183,7 @@ VarDef         ::=  PatDef
                  |  ids ‘:’ Type ‘=’ ‘_’
 ```
 
-A variable declaration `var ´x´: ´T´` is equivalent to the declarations of both a _getter function_ ´x´ *and* a _setter function_ `´x´_=`:
+A variable declaration `var ´x´: ´T´` is equivalent to the declarations of both a _getter method_ ´x´ *and* a _setter method_ `´x´_=`:
 
 ```scala
 def ´x´: ´T´
@@ -215,9 +215,9 @@ The default value depends on the type ´T´ as follows:
 |`()`      | `Unit`                             |
 |`null`    | all other types                    |
 
-When they occur as members of a template, both forms of variable definition also introduce a getter function ´x´ which returns the value currently assigned to the variable, as well as a setter function `´x´_=` which changes the value currently assigned to the variable.
-The functions have the same signatures as for a variable declaration.
-The template then has these getter and setter functions as members, whereas the original variable cannot be accessed directly as a template member.
+When they occur as members of a template, both forms of variable definition also introduce a getter method ´x´ which returns the value currently assigned to the variable, as well as a setter method `´x´_=` which changes the value currently assigned to the variable.
+The methods have the same signatures as for a variable declaration.
+The template then has these getter and setter methods as members, whereas the original variable cannot be accessed directly as a template member.
 
 ###### Example
 
@@ -287,7 +287,7 @@ A _type alias_ `type ´t´ = ´T´` defines ´t´ to be an alias name for the ty
 The left hand side of a type alias may have a type parameter clause, e.g. `type ´t´[´\mathit{tps}\,´] = ´T´`.
 The scope of a type parameter extends over the right hand side ´T´ and the type parameter clause ´\mathit{tps}´ itself.
 
-The scope rules for [definitions](#basic-declarations-and-definitions) and [type parameters](#function-declarations-and-definitions) make it possible that a type name appears in its own bound or in its right-hand side.
+The scope rules for [definitions](#basic-declarations-and-definitions) and [type parameters](#method-declarations-and-definitions) make it possible that a type name appears in its own bound or in its right-hand side.
 However, it is a static error if a type alias refers recursively to the defined type constructor itself.
 That is, the type ´T´ in a type alias `type ´t´[´\mathit{tps}\,´] = ´T´` may not refer directly or indirectly to the name ´t´.
 It is also an error if an abstract type is directly or indirectly its own upper or lower bound.
@@ -346,7 +346,7 @@ VariantTypeParam ::= {Annotation} [‘+’ | ‘-’] TypeParam
 TypeParam        ::= (id | ‘_’) [TypeParamClause] [‘>:’ Type] [‘<:’ Type] [‘:’ Type]
 ```
 
-Type parameters appear in type definitions, class definitions, and function definitions.
+Type parameters appear in type definitions, class definitions, and method definitions.
 In this section we consider only type parameter definitions with lower bounds `>: ´L´` and upper bounds `<: ´U´` whereas a discussion of context bounds `: ´U´` and view bounds `<% ´U´` is deferred to [here](07-implicits.html#context-bounds-and-view-bounds).
 
 The most general form of a proper type parameter is 
@@ -497,7 +497,7 @@ abstract class OutputChannel[-A] {
 With that annotation, we have that `OutputChannel[AnyRef]` conforms to `OutputChannel[String]`.
 That is, a channel on which one can write any object can substitute for a channel on which one can write only strings.
 
-## Function Declarations and Definitions
+## Method Declarations and Definitions
 
 ```ebnf
 Dcl                ::=  ‘def’ FunDcl
@@ -515,23 +515,23 @@ ParamType          ::=  Type
                      |  Type ‘*’
 ```
 
-A _function declaration_ has the form `def ´f\,\mathit{psig}´: ´T´`, where ´f´ is the function's name, ´\mathit{psig}´ is its parameter signature and ´T´ is its result type.
-A _function definition_ `def ´f\,\mathit{psig}´: ´T´ = ´e´` also includes a _function body_ ´e´, i.e. an expression which defines the function's result.
+A _method declaration_ has the form `def ´f\,\mathit{psig}´: ´T´`, where ´f´ is the method's name, ´\mathit{psig}´ is its parameter signature and ´T´ is its result type.
+A _method definition_ `def ´f\,\mathit{psig}´: ´T´ = ´e´` also includes a _method body_ ´e´, i.e. an expression which defines the method's result.
 A parameter signature consists of an optional type parameter clause `[´\mathit{tps}\,´]`, followed by zero or more value parameter clauses `(´\mathit{ps}_1´)...(´\mathit{ps}_n´)`.
 Such a declaration or definition introduces a value with a (possibly polymorphic) method type whose parameter types and result type are as given.
 
-The type of the function body is expected to [conform](06-expressions.html#expression-typing) to the function's declared result type, if one is given.
-If the function definition is not recursive, the result type may be omitted, in which case it is determined from the packed type of the function body.
+The type of the method body is expected to [conform](06-expressions.html#expression-typing) to the method's declared result type, if one is given.
+If the method definition is not recursive, the result type may be omitted, in which case it is determined from the packed type of the method body.
 
 A _type parameter clause_ ´\mathit{tps}´ consists of one or more [type declarations](#type-declarations-and-type-aliases), which introduce type parameters, possibly with bounds.
-The scope of a type parameter includes the whole signature, including any of the type parameter bounds as well as the function body, if it is present.
+The scope of a type parameter includes the whole signature, including any of the type parameter bounds as well as the method body, if it is present.
 
 A _value parameter clause_ ´\mathit{ps}´ consists of zero or more formal parameter bindings such as `´x´: ´T´` or `´x: T = e´`, which bind value parameters and associate them with their types.
 
 ### Default Arguments
 
 Each value parameter declaration may optionally define a default argument.
-The default argument expression ´e´ is type-checked with an expected type ´T'´ obtained by replacing all occurrences of the function's type parameters in ´T´ by the undefined type.
+The default argument expression ´e´ is type-checked with an expected type ´T'´ obtained by replacing all occurrences of the method's type parameters in ´T´ by the undefined type.
 
 For every parameter ´p_{i,j}´ with a default argument a method named `´f\$´default´\$´n` is generated which computes the default argument expression.
 Here, ´n´ denotes the parameter's position in the method declaration.
@@ -555,7 +555,7 @@ def compare´\$´default´\$´1[T]: Int = 0
 def compare´\$´default´\$´2[T](a: T): T = a
 ```
 
-The scope of a formal value parameter name ´x´ comprises all subsequent parameter clauses, as well as the method return type and the function body, if they are given.
+The scope of a formal value parameter name ´x´ comprises all subsequent parameter clauses, as well as the method return type and the method body, if they are given.
 Both type parameter names and value parameter names must be pairwise distinct.
 
 A default value which depends on earlier parameters uses the actual arguments if they are provided, not the default arguments.
@@ -582,7 +582,7 @@ ParamType          ::=  ‘=>’ Type
 
 The type of a value parameter may be prefixed by `=>`, e.g. `´x´: => ´T´`.
 The type of such a parameter is then the parameterless method type `=> ´T´`.
-This indicates that the corresponding argument is not evaluated at the point of function application, but instead is evaluated at each use within the function.
+This indicates that the corresponding argument is not evaluated at the point of method application, but instead is evaluated at each use within the method.
 That is, the argument is evaluated using _call-by-name_.
 
 The by-name modifier is disallowed for parameters of classes that carry a `val` or `var` prefix, including parameters of case classes for which a `val` prefix is implicitly generated.
@@ -654,11 +654,11 @@ FunDcl   ::=  FunSig
 FunDef   ::=  FunSig [nl] ‘{’ Block ‘}’
 ```
 
-Special syntax exists for procedures, i.e. functions that return the `Unit` value `()`.
-A _procedure declaration_ is a function declaration where the result type is omitted.
+Special syntax exists for procedures, i.e. methods that return the `Unit` value `()`.
+A _procedure declaration_ is a method declaration where the result type is omitted.
 The result type is then implicitly completed to the `Unit` type. E.g., `def ´f´(´\mathit{ps}´)` is equivalent to `def ´f´(´\mathit{ps}´): Unit`.
 
-A _procedure definition_ is a function definition where the result type and the equals sign are omitted; its defining expression must be a block.
+A _procedure definition_ is a method definition where the result type and the equals sign are omitted; its defining expression must be a block.
 E.g., `def ´f´(´\mathit{ps}´) {´\mathit{stats}´}` is equivalent to `def ´f´(´\mathit{ps}´): Unit = {´\mathit{stats}´}`.
 
 ###### Example
@@ -686,8 +686,8 @@ object Terminal extends Writer {
 
 ### Method Return Type Inference
 
-A class member definition ´m´ that overrides some other function ´m'´ in a base class of ´C´ may leave out the return type, even if it is recursive.
-In this case, the return type ´R'´ of the overridden function ´m'´, seen as a member of ´C´, is taken as the return type of ´m´ for each recursive invocation of ´m´.
+A class member definition ´m´ that overrides some other method ´m'´ in a base class of ´C´ may leave out the return type, even if it is recursive.
+In this case, the return type ´R'´ of the overridden method ´m'´, seen as a member of ´C´, is taken as the return type of ´m´ for each recursive invocation of ´m´.
 That way, a type ´R´ for the right-hand side of ´m´ can be determined, which is then taken as the return type of ´m´.
 Note that ´R´ may be different from ´R'´, as long as ´R´ conforms to ´R'´.
 
@@ -709,7 +709,7 @@ Here, it is OK to leave out the result type of `factorial` in `C`, even though t
 \label{sec:overloaded-defs}
 \todo{change}
 
-An overloaded definition is a set of ´n > 1´ value or function
+An overloaded definition is a set of ´n > 1´ value or method
 definitions in the same statement sequence that define the same name,
 binding it to types `´T_1 \commadots T_n´`, respectively.
 The individual definitions are called _alternatives_.  Overloaded
diff --git a/docs/_spec/05-classes-and-objects.md b/docs/_spec/05-classes-and-objects.md
index d89fcfb115ff..622f9dc8ae59 100644
--- a/docs/_spec/05-classes-and-objects.md
+++ b/docs/_spec/05-classes-and-objects.md
@@ -603,7 +603,7 @@ The self constructor invocation must construct a generic instance of the class.
 I.e. if the class in question has name ´C´ and type parameters `[´\mathit{tps}\,´]`, then a self constructor invocation must generate an instance of `´C´[´\mathit{tps}\,´]`; it is not permitted to instantiate formal type parameters.
 
 The signature and the self constructor invocation of a constructor definition are type-checked and evaluated in the scope which is in effect at the point of the enclosing class definition, augmented by any type parameters of the enclosing class and by any [early definitions](#early-definitions) of the enclosing template.
-The rest of the constructor expression is type-checked and evaluated as a function body in the current class.
+The rest of the constructor expression is type-checked and evaluated as a method body in the current class.
 
 If there are auxiliary constructors of a class ´C´, they form together with ´C´'s primary [constructor](#class-definitions) an overloaded constructor definition.
 The usual rules for [overloading resolution](06-expressions.html#overloading-resolution) apply for constructor invocations of ´C´, including for the self constructor invocations in the constructor expressions themselves.
diff --git a/docs/_spec/06-expressions.md b/docs/_spec/06-expressions.md
index 597756550e6f..92697e64f0ac 100644
--- a/docs/_spec/06-expressions.md
+++ b/docs/_spec/06-expressions.md
@@ -190,7 +190,7 @@ Then we have:
 
 Note that the `superB` method returns different results depending on whether `B` is mixed in with class `Root` or `A`.
 
-## Function Applications
+## Method Applications
 
 ```ebnf
 SimpleExpr    ::=  SimpleExpr1 ArgumentExprs
@@ -201,8 +201,8 @@ ArgumentExprs ::=  ‘(’ [Exprs] ‘)’
 Exprs         ::=  Expr {‘,’ Expr}
 ```
 
-An application `´f(e_1, ..., e_m)´` applies the function `´f´` to the argument expressions `´e_1, ..., e_m´`.
-For this expression to be well-typed, the function must be *applicable* to its arguments, which is defined next by case analysis on ´f´'s type.
+An application `´f(e_1, ..., e_m)´` applies the expression `´f´` to the argument expressions `´e_1, ..., e_m´`.
+For the overal expression to be well-typed, ´f´ must be *applicable* to its arguments, which is defined next by case analysis on ´f´'s type.
 
 If ´f´ has a method type `(´p_1´:´T_1, ..., p_n´:´T_n´)´U´`, each argument expression ´e_i´ is typed with the corresponding parameter type ´T_i´ as expected type.
 Let ´S_i´ be the type of argument ´e_i´ ´(i = 1, ..., m)´.
@@ -223,8 +223,8 @@ The value `´f´` is applicable to the given arguments if `´f´.apply` is appli
 
 The application `´f´(´e_1, ..., e_n´)` evaluates ´f´ and then each argument ´e_1, ..., e_n´ from left to right, except for arguments that correspond to a by-name parameter (see below).
 Each argument expression is converted to the type of its corresponding formal parameter.
-After that, the application is rewritten to the function's right hand side, with actual arguments substituted for formal parameters.
-The result of evaluating the rewritten right-hand side is finally converted to the function's declared result type, if one is given.
+After that, the application is rewritten to the method's right hand side, with actual arguments substituted for formal parameters.
+The result of evaluating the rewritten right-hand side is finally converted to the method's declared result type, if one is given.
 
 The case of a formal parameter with a parameterless method type `=> ´T´` is treated specially.
 In this case, the corresponding actual argument expression ´e´ is not evaluated before the application.
@@ -232,7 +232,7 @@ Instead, every use of the formal parameter on the right-hand side of the rewrite
 In other words, the evaluation order for `=>`-parameters is _call-by-name_ whereas the evaluation order for normal parameters is _call-by-value_.
 Furthermore, it is required that ´e´'s [packed type](#expression-typing) conforms to the parameter type ´T´.
 The behavior of by-name parameters is preserved if the application is transformed into a block due to named or default arguments.
-In this case, the local value for that parameter has the form `val ´y_i´ = () => ´e´` and the argument passed to the function is `´y_i´()`.
+In this case, the local value for that parameter has the form `val ´y_i´ = () => ´e´` and the argument passed to the method is `´y_i´()`.
 
 The last argument in an application may be marked as a sequence argument, e.g. `´e´: _*`.
 Such an argument must correspond to a [repeated parameter](04-basic-declarations-and-definitions.html#repeated-parameters) of type `´S´*` and it must be the only argument matching this parameter (i.e. the number of formal parameters and actual arguments must be the same).
@@ -243,7 +243,7 @@ When the application uses named arguments, the vararg parameter has to be specif
 If only a single argument is supplied, it may be supplied as a block expression and parentheses can be omitted, in the form `´f´ { block }`.
 This is valid when `f` has a single formal parameter or when all other formal parameters have default values.
 
-A function application usually allocates a new frame on the program's run-time stack.
+A method application usually allocates a new frame on the program's run-time stack.
 However, if a local method or a final method calls itself as its last action, the call is executed using the stack-frame of the caller.
 
 ###### Example
@@ -304,7 +304,7 @@ The result of transforming ´f´ is a block of the form
 
 where every argument in ´(\mathit{args}\_1), ..., (\mathit{args}\_l)´ is a reference to one of the values ´x_1, ..., x_k´.
 To integrate the current application into the block, first a value definition using a fresh name ´y_i´ is created for every argument in ´e_1, ..., e_m´, which is initialised to ´e_i´ for positional arguments and to ´e'_i´ for named arguments of the form `´x_i=e'_i´`.
-Then, for every parameter which is not specified by the argument list, a value definition using a fresh name ´z_i´ is created, which is initialized using the method computing the [default argument](04-basic-declarations-and-definitions.html#function-declarations-and-definitions) of this parameter.
+Then, for every parameter which is not specified by the argument list, a value definition using a fresh name ´z_i´ is created, which is initialized using the method computing the [default argument](04-basic-declarations-and-definitions.html#method-declarations-and-definitions) of this parameter.
 
 Let ´\mathit{args}´ be a permutation of the generated names ´y_i´ and ´z_i´ such such that the position of each name matches the position of its corresponding parameter in the method type `(´p_1:T_1, ..., p_n:T_n´)´U´`.
 The final result of the transformation is a block of the form
@@ -366,13 +366,13 @@ Note that a space is necessary between a method name and the trailing underscore
 SimpleExpr    ::=  SimpleExpr TypeArgs
 ```
 
-A _type application_ `´e´[´T_1, ..., T_n´]` instantiates a polymorphic value ´e´ of type `[´a_1´ >: ´L_1´ <: ´U_1, ..., a_n´ >: ´L_n´ <: ´U_n´]´S´` with argument types `´T_1, ..., T_n´`.
+A _type application_ `´e´[´T_1, ..., T_n´]` instantiates a polymorphic method ´e´ of type `[´a_1´ >: ´L_1´ <: ´U_1, ..., a_n´ >: ´L_n´ <: ´U_n´]´S´` with argument types `´T_1, ..., T_n´`.
 Every argument type ´T_i´ must obey the corresponding bounds ´L_i´ and ´U_i´.
 That is, for each ´i = 1, ..., n´, we must have ´\sigma L_i <: T_i <: \sigma U_i´, where ´\sigma´ is the substitution ´[a_1 := T_1, ..., a_n
 := T_n]´.
 The type of the application is ´\sigma S´.
 
-If the function part ´e´ is of some value type, the type application is taken to be equivalent to `´e´.apply[´T_1 , ...,´ T´_n´]`, i.e. the application of an `apply` method defined by ´e´.
+If ´e´ is not a method, and is instead of some value type, the type application is taken to be equivalent to `´e´.apply[´T_1 , ...,´ T´_n´]`, i.e. the application of an `apply` method defined by ´e´.
 
 Type applications can be omitted if [local type inference](#local-type-inference) can infer best type parameters for a polymorphic method from the types of the actual method arguments and the expected result type.
 
@@ -1146,12 +1146,12 @@ Otherwise, if ´e´ has method type ´()T´, it is implicitly applied to the emp
 ### Overloading Resolution
 
 If an identifier or selection ´e´ references several members of a class, the context of the reference is used to identify a unique member.
-The way this is done depends on whether or not ´e´ is used as a function.
+The way this is done depends on whether or not ´e´ is used as a method.
 Let ´\mathscr{A}´ be the set of members referenced by ´e´.
 
 Assume first that ´e´ appears as a function in an application, as in `´e´(´e_1´, ..., ´e_m´)`.
 
-One first determines the set of functions that is potentially [applicable](#function-applications) based on the _shape_ of the arguments.
+One first determines the set of methods that are potentially [applicable](#method-applications) based on the _shape_ of the arguments.
 
 The *shape* of an argument expression ´e´, written  ´\mathit{shape}(e)´, is a type that is defined as follows:
   - For a function expression `(´p_1´: ´T_1, ..., p_n´: ´T_n´) => ´b´: (Any, ..., Any) => ´\mathit{shape}(b)´`, where `Any` occurs ´n´ times in the argument type.
@@ -1159,7 +1159,7 @@ The *shape* of an argument expression ´e´, written  ´\mathit{shape}(e)´, is
   - For a named argument `´n´ = ´e´`: ´\mathit{shape}(e)´.
   - For all other expressions: `Nothing`.
 
-Let ´\mathscr{B}´ be the set of alternatives in ´\mathscr{A}´ that are [_applicable_](#function-applications) to expressions ´(e_1, ..., e_n)´ of types ´(\mathit{shape}(e_1), ..., \mathit{shape}(e_n))´.
+Let ´\mathscr{B}´ be the set of alternatives in ´\mathscr{A}´ that are [_applicable_](#method-applications) to expressions ´(e_1, ..., e_n)´ of types ´(\mathit{shape}(e_1), ..., \mathit{shape}(e_n))´.
 If there is precisely one alternative in ´\mathscr{B}´, that alternative is chosen.
 
 Otherwise, let ´S_1, ..., S_m´ be the list of types obtained by typing each argument as follows.
@@ -1197,7 +1197,7 @@ question: given
  so the method is not more specific than the value.
 -->
 
-- A parameterized method ´m´ of type `(´p_1:T_1, ..., p_n:T_n´)´U´` is _as specific as_ some other member ´m'´ of type ´S´ if ´m'´ is [applicable](#function-applications) to arguments `(´p_1, ..., p_n´)` of types ´T_1, ..., T_n´.
+- A parameterized method ´m´ of type `(´p_1:T_1, ..., p_n:T_n´)´U´` is _as specific as_ some other member ´m'´ of type ´S´ if ´m'´ is [applicable](#method-applications) to arguments `(´p_1, ..., p_n´)` of types ´T_1, ..., T_n´.
 - A polymorphic method of type `[´a_1´ >: ´L_1´ <: ´U_1, ..., a_n´ >: ´L_n´ <: ´U_n´]´T´` is as specific as some other member of type ´S´ if ´T´ is as specific as ´S´ under the assumption that for ´i = 1, ..., n´ each ´a_i´ is an abstract type name bounded from below by ´L_i´ and from above by ´U_i´.
 - A member of any other type is always as specific as a parameterized method or a polymorphic method.
 - Given two members of types ´T´ and ´U´ which are neither parameterized nor polymorphic method types, the member of type ´T´ is as specific as the member of type ´U´ if the existential dual of ´T´ conforms to the existential dual of ´U´.
@@ -1220,12 +1220,12 @@ An alternative ´A´ is _more specific_ than an alternative ´B´ if the relativ
 
 It is an error if there is no alternative in ´\mathscr{CC}´ which is more specific than all other alternatives in ´\mathscr{CC}´.
 
-Assume next that ´e´ appears as a function in a type application, as in `´e´[´\mathit{targs}\,´]`.
+Assume next that ´e´ appears as a method in a type application, as in `´e´[´\mathit{targs}\,´]`.
 Then all alternatives in ´\mathscr{A}´ which take the same number of type parameters as there are type arguments in ´\mathit{targs}´ are chosen.
 It is an error if no such alternative exists.
 If there are several such alternatives, overloading resolution is applied again to the whole expression `´e´[´\mathit{targs}\,´]`.
 
-Assume finally that ´e´ does not appear as a function in either an application or a type application.
+Assume finally that ´e´ does not appear as a method in either an application or a type application.
 If an expected type is given, let ´\mathscr{B}´ be the set of those alternatives in ´\mathscr{A}´ which are [compatible](03-types.html#compatibility) to it.
 Otherwise, let ´\mathscr{B}´ be the same as ´\mathscr{A}´.
 In this last case we choose the most specific alternative among all alternatives in ´\mathscr{B}´.
diff --git a/docs/_spec/08-pattern-matching.md b/docs/_spec/08-pattern-matching.md
index 45d777f584a0..97fb73d58b06 100644
--- a/docs/_spec/08-pattern-matching.md
+++ b/docs/_spec/08-pattern-matching.md
@@ -474,7 +474,7 @@ The expected type of the pattern `y: Number` is `Term[B]`.
 The type `Number` does not conform to `Term[B]`; hence Case 2 of the rules above applies.
 This means that `B` is treated as another type variable for which subtype constraints are inferred.
 In our case the applicable constraint is `Number <: Term[B]`, which entails `B = Int`.  Hence, `B` is treated in the case clause as an abstract type with lower and upper bound `Int`.
-Therefore, the right hand side of the case clause, `y.n`, of type `Int`, is found to conform to the function's declared result type, `Number`.
+Therefore, the right hand side of the case clause, `y.n`, of type `Int`, is found to conform to the method's declared result type, `Number`.
 
 ## Pattern Matching Expressions
 
diff --git a/docs/_spec/12-the-scala-standard-library.md b/docs/_spec/12-the-scala-standard-library.md
index 086d396ba4dd..401735286a51 100644
--- a/docs/_spec/12-the-scala-standard-library.md
+++ b/docs/_spec/12-the-scala-standard-library.md
@@ -529,7 +529,7 @@ trait Node {
 
 ## The `Predef` Object
 
-The `Predef` object defines standard functions and type aliases for Scala programs.
+The `Predef` object defines standard methods and type aliases for Scala programs.
 It is implicitly imported, as described in [the chapter on name binding](02-identifiers-names-and-scopes.html), so that all its defined members are available without qualification.
 Its definition for the JVM environment conforms to the following signature:
 

From ac6fcafdcd35deddaf5e11319c172c5641904838 Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Fri, 3 Feb 2023 15:11:31 +0100
Subject: [PATCH 108/657] Update readme

---
 docs/_spec/README.md | 21 ++++++++++++++-------
 1 file changed, 14 insertions(+), 7 deletions(-)

diff --git a/docs/_spec/README.md b/docs/_spec/README.md
index 5aa9240c6158..b9eba413f8a2 100644
--- a/docs/_spec/README.md
+++ b/docs/_spec/README.md
@@ -1,4 +1,6 @@
-# Scala Language Reference
+# WIP Scala 3 Language Specification
+
+**This is still a work in progress, and should *not* be regarded as a source of truth.**
 
 First of all, the language specification is meant to be correct, precise and clear.
 
@@ -16,9 +18,6 @@ We aim to track the configuration GitHub Pages uses but differences may arise as
 
 ## Building
 
-<!-- TODO: change url to correct one -->
-Travis CI builds the spec automatically after every merged pull release and publishes to https://www.scala-lang.org/files/archive/spec/2.13/.
-
 <!-- TODO: Check nothing else is needed -->
 To preview locally, run the following commands in the docs/_spec subfolder:
 
@@ -40,8 +39,16 @@ and open http://0.0.0.0:4000/ to view the spec. Jekyll will rebuild as you edit
 - MathJAX errors  will appear within the  rendered DOM as span  elements with class `mtext` and style attribute `color: red` applied. It is  possible to search for this combination in the development  tools of the browser of your choice. In chrome, CTRL+F / CMD+F within the inspect element panel allows you to do this.
 
 - This document follows the "one sentence <=> one line" convention, with the following exceptions below.
-- - A multiline code bloc is part of the sentence
-- - An enumeration of links is long enough
+  - A multiline code block is part of the sentence
+  - An enumeration of links is long enough
+
+- Whenever doing an enumeration of the kind "a, ..., z", follow the following conventions:
+  - It should always be "separator whitespace period period period separator whitespace", for example `, ..., ` or `,\n...,\n` for multiline.
+  - If in a code block, only the elements (a and z above) should be in math mode (between forward ticks)
+  - If in a math expression, the whole thing should be in a single math mode
+  - Look at the [Tuple Types section](docs/_spec/03-types.html#tuple-types) for an example of the different cases above.
+
+- Try to use "Note" blocks to point out logical conclusions that are not obvious, for examples, look at the [Tuple Types section](docs/_spec/03-types.html#tuple-types).
 
 ### Macro replacements:
 
@@ -51,7 +58,7 @@ and open http://0.0.0.0:4000/ to view the spec. Jekyll will rebuild as you edit
 - As MathJAX has  no support for slanted font (latex  command \sl), so in all instances  this should be replaced with \mathit{}
 - The macro \U{ABCD} used for unicode character references can be replaced with \\uABCD.
 - The macro \URange{ABCD}{DCBA} used for unicode character ranges can be replaced with \\uABCD-\\uDBCA.
-- The macro \commadots can be replaced with ` , … , `.
+- The macro \commadots can be replaced with ` , … , ` (But should not, see above).
 - There is no adequate replacement for `\textsc{...}`  (small caps) in pandoc markdown. While unicode contains a number of  small capital  letters, it  is notably  missing Q and  X as  these glyphs  are intended  for phonetic spelling, therefore these  cannot be reliably used. For now,  the best option is to use  underscore emphasis and capitalise the text manually, `_LIKE THIS_`.
 
 ### Unicode Character replacements

From ec261b64f50b77d69d1ad4c57b05aeb9e4691c7d Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Fri, 3 Feb 2023 15:36:31 +0100
Subject: [PATCH 109/657] Remove travis key

---
 docs/_spec/id_dsa_travis.enc | 68 ------------------------------------
 1 file changed, 68 deletions(-)
 delete mode 100644 docs/_spec/id_dsa_travis.enc

diff --git a/docs/_spec/id_dsa_travis.enc b/docs/_spec/id_dsa_travis.enc
deleted file mode 100644
index 6709463580af..000000000000
--- a/docs/_spec/id_dsa_travis.enc
+++ /dev/null
@@ -1,68 +0,0 @@
-U2FsdGVkX19ePRmShLaiBw8T+ZZjbrD7zejYuQmDFA3U6/CSCjOzJLrQSBViWwH5
-/0BvyYdva00SW9g+soQfXShHlnJUz89ZpQj2Z82ipnebtcgy20jnlsNUdo0FG2aG
-tAD3OUNxY+IsCeM7tvym955x7TGjDreygZfMUcVibJNZfk3MKPu1uF7xBD800hQE
-1eW21bE2bUZeIMPY3t7ZIIqAH+RbYOir0O/XKoxhdTVgpXDE3ntaGIvLr/rleIyT
-nsE5UN5XNP/ONj7hsK3kSSoDHujQ5TxvhF60IGJyXksJEBtM1ZirMG20/SKPuT9C
-5ROkA3lOMNFkYiSiQiy4c6uU0ynSdkZ22xiJX6d+qvyhybZsBJhSo4ksE5XbwOjX
-0QJ6pro5IT+dq/KQadzlGv/27+trc3Dvf5lnxlYZ0vZDx81/dwFUI0VVLF4CBIo5
-4KBH/b/2lOAkVB9sNpJZoutMh9c4ay6h0rAJC7BzXFxMZSKvDhJmjEUzVDGTgOny
-cv6Tpabf/pC+KtqlxQoVq4JTfcGB/TPt7gKE87E4fIUPcBZ36A6NH2slbzNCBuSQ
-4h5t2C7e/WPPCFVL5Q+0usLdUaMUoaKeKpDK/LecbOUKcdYfYhoSlgV23ApllsES
-YLk9Ldl7sbUx9pVT/suI61CGs/3AVMjKq/l5wemM5T9Y7LYYK1TirEvRL2yZy9Eq
-OnCWPA/2j9u13O4ZahHJ+JPp/eQXjPlt++IRk0mF5Ua1mKHWJIFr10SXKy9W/2n8
-b8BVnAaFTdv99vgRTjb0Ic5fYivEzvas/yxv7rA5d/LQ5oLNJrhzOnkQvzFzjGI6
-0N6vBV+1BDFQsnz0vBR7gzV+KhQenVIbyFQsxpp4pzP1N1/QZ/qujD6IiAG3H/DG
-kLJc7UO3EfdQ6yRvGYVFsZ4GBBAjtD0y+lUIG7q6y57FvHKKvN+4Y7Yy5IUlfpUE
-Y4hu5k4oAY9w0EkyOZsSGLMtwZhaLUX/jWgTjXoe8+pp234DIaSBWCsVqj5PHTnZ
-6v1fdmpM+rXS4mFpJnegmmv0WG8l4Fk8QfUExxn5VgXkoAPFhYWDFNiFJw4ZRsBX
-2KsnUyi4X0UYjAhVya6JVDMD1l42RskZFXKynTaXSXT+fS1zUZlcpXVy9qdOng7Z
-UZrMixTt3kFcw2WDULpHqpbmqbbSXqoErZOSquKzAJw0AO81otsSFiCvb7q05Uw6
-Y6mWmPrIYDZJ78CraA1HPtDvmRW0jRes8kQ6BUhHeVZuS8bGvUSzwEwnzUtaF+Gz
-XESJ2wKWVRHqyzbY48UHNllYQfReXV1xQ5t6mQeAVYa+sRRBFSXW4QFwIAxjuB2x
-0+yBCzoP0DL8hqtrlYOf4ycQvb0xXq+CajTFzO1lD3tzonq9cM8BsAHXaTYyIYd1
-GtaMxhXfEDKAwaB1t9LHfvV31BGvDv+4XVNAc8ru/wVAxbNptVfstkBj1W5Ns7to
-W8AmPKASAFddbkbPCYiVVNQnsa+RC9YPu87QQJcD+BiszPGz2LG0L5EOAiis5uFL
-e6S3Lvbx2yomW5CaFOOd36zqB6DJmMDsWluHNzrX8BPUeSEcHfqMrM5WV4HhtTsU
-c7Rs5fY0uA/J8VBVGUHLBodW4jnRJAVlCXsncRgj50cATwRnhQpCeRAjMsB7NSsF
-Fo1wyMz9k/w69efqJKwX3R29zP3bCTTt36FdQ+uB37L+Fgek6FHUpjL8M0dGB4Tc
-5y+YO9eUmzs7Lkl6AHEf4rM14yzL/ETJWP+IBjPg9Np3y6auiKKZ5thXSWmCUD05
-HBoBsX1Fk88NpfDzp2mTzFWDm2XWNnBzcSZn8jSLcSj6KAB3j8myun1u5Ah5M3gd
-vgm23GoohOODwzhaZzQbFA8J7aVTXQkzshmqtfjLpg4QtpXThgSTZ7pij/UW4pKU
-fMEQAFi7uu2mrkQK+V6H/USCL63bpcALSskXrXZkGMOxJZfA1ND6GCKWQPZeVi1h
-O3mgbVsRhRZ8F1rGySwP/Z9D0IWQRBotuVWh4rHqoYzafpO1QjVRm/yfVOSbr9yB
-ObEFLIv6c+Eu4I8FbM839qLUiufv+8tUsHzVjN+zP14KwDaiVMC3Y56YQp4wqR2B
-IAufYraqoP+q8wmFiux9hPDy857sgyXqdPIQy+p0yNuUJl8ZlQYzCgPhNx4pE1P5
-YOoNJ9AsaN0CMI82M6A8thjPLZfFZ+6Nt8jdBipmMe0APq3wfb9NPWlVx3sh0/Bp
-cF3y3xQRgRBk8Twq3Imol2cFCsYu8cQNyPxKCQG/NHKVUffXiUoFsBCvg8oGYU0s
-mew25XAx9iZ7+/JC0dmeMQ2xOF9dKPnIhcM5rVt8WSFX4IxTawpUAQlN4N6rHFfx
-/w2WHInL34zpBDTQqKUWC+AdxVMc9Is8X1Zpv+GoBv3LEHt8GNKRFG6HmTW6sz+v
-0aHbvT2jU1iWqDf9icL29MRT0nXuzoZN0Nf69RBjvnTh35gE8r7y5URaBVI0mZkU
-ZL5Fohc2mLmzR7Te8B6/eAdov8nkeLPg5CDkq1T7O/R8hpiHGncfkaqbZTv0oUdN
-1Hu9Kt12aakem647KnfdhsWifzMv3nY6uT082iXbI9uXvh1WLMp1HZkTeUvARAan
-i/VgiO/0+BBTv/XywpJphsy4UfOJ5cTbg2FWQ8f/DsJMqlbsBQeqD+G9j9b7W2Eg
-f3XdvLoWhwR0uLCeHyAA+wfzogltXRxavX8c9wmzbkl8X1fYN6aiPJRr45lenvqS
-4n2PAj2qX23n8+sI9iH1Af026Nrb/Kvbo9f/gfaQj2Z2WXiGIT0/RGH4Mz3V/mvD
-sNKvSVzQ5VEkvxcMtXmkC7AJBYOKSyv0Vp/2ySzltxkghvBrrbq/RX9Cr2iJBZJN
-RrqfefkT8A7vOI+YSjNRTIrRHTc/UfX+nZldzCPfeh3lU2eKUkappZHsGXda++uN
-K7mMrXNoy4yCd5YNTCeLiQorklGxzeCCtoa8C+gDSbJY7HtjkvwbeaXUi7CpNPa3
-0GBPe5bQcK+vsynVgHnGU8qH4VOE7dgDWMjUi5+IdGC26zcsM6VvMArfk93Ny3xX
-5AS61/4oMKBAedxVQejMD/xUVdjf6x0U+6gKGIlZFyiNl4kPtY+o0Ok7BkFItsDn
-sC9dKRlwrvQlI6uNE3+Rk6R5rQLX1EW4UBnOL7YOOWLypiviB0DKas8FTL6RzWfl
-TeZRwDS7nYWXYHSBvexEfDnEbv4Xnncz0gQ42ixmTXWVNNGcS8mNLR8GKpQGKEX7
-t6Bub1GZd8EsdVDkG1EUU3qwk6fx4PgGfqxZ+MgrZOlXhYbHmJTE83IeuYfBbAb3
-2MxbOhYmENigWNRf5S9vRkMr254xDJ1eIAAE3FHqeW1fEPbrHy8M1AS1DKlEoNMI
-yW2lcOP0HAuib4sLXTqa8d00h7qiClyy3NCtPwKyUganSzSIKOMO7G+Bbf6gJfhN
-VBr58/nj8aUZzKCdJO5U1Hou6/fUPnTltyURrfbe/B0RpMCCoUNcwpfT0VltOEDa
-4pDD3Z9lnejSmCKplbWLvEWVPi4muNXg9E08cTnolqQIx0zWTMMZkhmzq3z3hKh9
-F1uLWaZd/dzyIxkHVTujKfyEaOmFH+MDzquHoJFaXtlK2220ARSlTgEBUHfICesA
-dtXDw/ipuUCy5GAloUWZDJGz8DwCWBwsl/pN+oXq0SK0kZXcjCn04l/LVikAJjUK
-fcAlg3SAkwXW17pocvOfxCF6cBJBcNYi74V5n5GSW0entbx4J3ki4UpEI0OQFGEJ
-9alenvjUqJGHRGLjMdhv0YjNX15Ww/eAaBFlm19z7Uf02EuTDx4RuxyODGn/oYUa
-NXB0obcO2t9ZLj1KrAgY4mseerdY3jJeh2fk6g2Unbo+RDMtB1fMcyaP2ApCxlZg
-GVRYULd8shdCKQTg/5eUcNvVpE66m1EyfreE9XZBLwf35O7Bb1t1Aj56gWHg2raS
-gLsdecV+7dDSMm71QNNhLreo1iQ6uKKRM5KATHCbvSzeYSTwGNOzXHYBjEC48RpR
-nGn8qNT1s7Ddl6W8/kABN0L3i4dNgAIE10AuJuaJGukr0Wiv/aWookD/lGgB6SlS
-EJOqZks1YQC/7gLgYIiYnL1iphHonLclqh+GHCqEONPfql7XwonawtNnPYvGVz20
-XynW1kKiF05CPWsolLhgOj8F4eVeTFEG5qPfELZeK0ADxIkbpWOXnYUWXLn59gby
-sdijsfJtmWh5aaESy5iEfBTedGaX60+AntTwoN0ncXuseDorwEo3DrUuObjCi5wL
-vhxedV446Do4PEEinUV499CGrMlc+lB2UEn5lJ2Fi1uhakbvhhTLL3zgmhaNlr0u

From 9db5c9e66d05a6f6d0a75aa7ca1cd94914ec1d57 Mon Sep 17 00:00:00 2001
From: Jamie Thompson <bishbashboshjt@gmail.com>
Date: Mon, 6 Feb 2023 15:26:17 +0100
Subject: [PATCH 110/657] install correct sass-embedded

---
 docs/_spec/Dockerfile | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/docs/_spec/Dockerfile b/docs/_spec/Dockerfile
index a08c5d0e7f98..1fc28081c59f 100644
--- a/docs/_spec/Dockerfile
+++ b/docs/_spec/Dockerfile
@@ -5,7 +5,9 @@ RUN apt-get install -y curl \
   && apt-get install -y nodejs \
   && curl -L https://www.npmjs.com/install.sh | sh
 
-RUN gem install  bundler:1.17.2 jekyll 
+RUN gem update --system
+RUN gem install sass-embedded -v 1.58.0
+RUN gem install bundler:1.17.2 jekyll
 
 WORKDIR /srv/jekyll
 

From 1f5a99013fb172348f0bc0b4dcc77db940e79aea Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 6 Feb 2023 16:33:58 +0100
Subject: [PATCH 111/657] Propagate implicit search errors from implicit macros

Fixes partially #16835
---
 .../dotty/tools/dotc/transform/Splicer.scala  | 10 ++++++++-
 .../dotty/tools/dotc/typer/Implicits.scala    | 16 +++++++++++---
 tests/neg-macros/i16835.check                 |  6 ++++++
 tests/neg-macros/i16835/Macro_1.scala         | 21 +++++++++++++++++++
 tests/neg-macros/i16835/Test_2.scala          |  1 +
 5 files changed, 50 insertions(+), 4 deletions(-)
 create mode 100644 tests/neg-macros/i16835.check
 create mode 100644 tests/neg-macros/i16835/Macro_1.scala
 create mode 100644 tests/neg-macros/i16835/Test_2.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/Splicer.scala b/compiler/src/dotty/tools/dotc/transform/Splicer.scala
index b936afb73dc8..3d3cd1f41c84 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicer.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicer.scala
@@ -119,7 +119,7 @@ object Splicer {
         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
+          isMacroOwner(x) // symbol was generated within another macro expansion
         )
         && !locals.contains(sym) // symbol is not in current scope
     }.traverse(tree)
@@ -222,6 +222,14 @@ object Splicer {
       checkIfValidStaticCall(tree)(using Set.empty)
   }
 
+  /** Is this the dummy owner of a macro expansion */
+  def isMacroOwner(sym: Symbol)(using Context): Boolean =
+    sym.is(Macro, butNot = Method) && sym.name == nme.MACROkw
+
+  /** Is this the dummy owner of a macro expansion */
+  def inMacroExpansion(using Context) =
+    ctx.owner.ownersIterator.exists(isMacroOwner)
+
   /** Tree interpreter that evaluates the tree.
    *  Interpreter is assumed to start at quotation level -1.
    */
diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
index 20859b8c9d25..7d185d335218 100644
--- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -31,6 +31,7 @@ import Feature.migrateTo3
 import config.Printers.{implicits, implicitsDetailed}
 import collection.mutable
 import reporting._
+import transform.Splicer
 import annotation.tailrec
 
 import scala.annotation.internal.sharable
@@ -567,6 +568,12 @@ object Implicits:
 
     def msg(using Context) = em"Failed to synthesize an instance of type ${clarify(expectedType)}:${formatReasons}"
 
+  class MacroErrorsFailure(errors: List[Diagnostic.Error],
+                           val expectedType: Type,
+                           val argument: Tree) extends SearchFailureType {
+    def msg(using Context): Message =
+      em"${errors.map(_.msg).mkString("\n")}"
+  }
 end Implicits
 
 import Implicits._
@@ -1157,19 +1164,22 @@ trait Implicits:
       if ctx.reporter.hasErrors
          || !cand.ref.symbol.isAccessibleFrom(cand.ref.prefix)
       then
-        ctx.reporter.removeBufferedMessages
-        adapted.tpe match {
+        val res = 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 _ =>
+          case tpe =>
             // 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 if Splicer.inMacroExpansion && tpe <:< pt then
+              SearchFailure(adapted.withType(new MacroErrorsFailure(ctx.reporter.allErrors.reverse, pt, argument)))
             else
               SearchFailure(adapted.withType(new MismatchedImplicit(ref, pt, argument)))
         }
+        ctx.reporter.removeBufferedMessages
+        res
       else
         SearchSuccess(adapted, ref, cand.level, cand.isExtension)(ctx.typerState, ctx.gadt)
     }
diff --git a/tests/neg-macros/i16835.check b/tests/neg-macros/i16835.check
new file mode 100644
index 000000000000..fb02f3c7f13f
--- /dev/null
+++ b/tests/neg-macros/i16835.check
@@ -0,0 +1,6 @@
+
+-- Error: tests/neg-macros/i16835/Test_2.scala:1:17 --------------------------------------------------------------------
+1 |def test: Unit = foo // error
+  |                 ^^^
+  |                 my error
+  |                 my second error
diff --git a/tests/neg-macros/i16835/Macro_1.scala b/tests/neg-macros/i16835/Macro_1.scala
new file mode 100644
index 000000000000..ddee5dbecb4e
--- /dev/null
+++ b/tests/neg-macros/i16835/Macro_1.scala
@@ -0,0 +1,21 @@
+import scala.quoted.*
+
+class Bar
+
+inline def foo: Unit = ${ fooExpr }
+
+def fooExpr(using Quotes): Expr[Unit] =
+  import quotes.reflect.*
+  Implicits.search(TypeRepr.of[Bar]) match
+    case res: ImplicitSearchSuccess   => '{}
+    case failure: ImplicitSearchFailure =>
+      report.errorAndAbort(failure.explanation)
+
+
+inline given bar: Bar = ${ barExpr }
+
+def barExpr(using Quotes): Expr[Bar] =
+  import quotes.reflect.*
+  report.error(s"my error")
+  report.error(s"my second error")
+  '{ new Bar }
diff --git a/tests/neg-macros/i16835/Test_2.scala b/tests/neg-macros/i16835/Test_2.scala
new file mode 100644
index 000000000000..0dc2d39d6c3d
--- /dev/null
+++ b/tests/neg-macros/i16835/Test_2.scala
@@ -0,0 +1 @@
+def test: Unit = foo // error

From 790af81c1d1f8905a2f0707fd14bb7f8708b3d6d Mon Sep 17 00:00:00 2001
From: Yichen Xu <yichen.x@outlook.com>
Date: Mon, 6 Feb 2023 23:06:41 +0100
Subject: [PATCH 112/657] Simplify and document box adaptation

---
 .../dotty/tools/dotc/cc/CheckCaptures.scala   | 63 ++++++++-----------
 1 file changed, 27 insertions(+), 36 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index 077d345d792d..77363a165f64 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -656,7 +656,7 @@ class CheckCaptures extends Recheck, SymTransformer:
           expected
 
     /** Adapt `actual` type to `expected` type by inserting boxing and unboxing conversions
-     * 
+     *
      *  @param alwaysConst  always make capture set variables constant after adaptation
      */
     def adaptBoxed(actual: Type, expected: Type, pos: SrcPos, alwaysConst: Boolean = false)(using Context): Type =
@@ -721,61 +721,52 @@ class CheckCaptures extends Recheck, SymTransformer:
         val arrow = if covariant then "~~>" else "<~~"
         i"adapting $actual $arrow $expected"
 
-      /** Destruct a capturing type `tp` to a tuple (cs, tp0, boxed),
-       *  where `tp0` is not a capturing type.
-       *
-       *  If `tp` is a nested capturing type, the return tuple always represents
-       *  the innermost capturing type. The outer capture annotations can be
-       *  reconstructed with the returned function.
-       */
-      def destructCapturingType(tp: Type, reconstruct: Type => Type = x => x): ((Type, CaptureSet, Boolean), Type => Type) =
-        tp.dealias match
-          case tp @ CapturingType(parent, cs) =>
-            if parent.dealias.isCapturingType then
-              destructCapturingType(parent, res => reconstruct(tp.derivedCapturingType(res, cs)))
-            else
-              ((parent, cs, tp.isBoxed), reconstruct)
-          case actual =>
-            val res = if tp.isFromJavaObject then tp else actual
-            ((res, 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) = destructCapturingType(actual)
-
-          val needsAdaptation = actualIsBoxed != expected.isBoxedCapturing
-          val insertBox = needsAdaptation && covariant != actualIsBoxed
-
-          val (parent1, cs1) = parent match {
+          // Decompose the actual type into the inner shape type, the capture set and the box status
+          val styp = if actual.isFromJavaObject then actual else actual.stripCapturing
+          val cs = actual.captureSet
+          val boxed = actual.isBoxedCapturing
+
+          // A box/unbox should be inserted, if the actual box status mismatches with the expectation
+          val needsAdaptation = boxed != expected.isBoxedCapturing
+          // Whether to insert a box or an unbox?
+          val insertBox = needsAdaptation && covariant != boxed
+
+          // Adapt the inner shape type: get the adapted shape type, and the capture set leaked during adaptation
+          val (styp1, leaked) = styp match {
             case actual @ AppliedType(tycon, args) if defn.isNonRefinedFunction(actual) =>
-              val (parent1, leaked) = adaptFun(parent, args.init, args.last, expected, covariant, insertBox,
+              adaptFun(actual, 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,
+              adaptFun(actual, 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,
+              adaptFun(actual, 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,
+              adaptTypeFun(actual, 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)
+              (styp, CaptureSet())
           }
 
+          // Capture set of the term after adaptation
+          val cs1 = cs ++ leaked
+
+          // Compute the adapted type
+          def adaptedType(resultBoxed: Boolean) =
+            styp1.capturing(if alwaysConst then CaptureSet(cs1.elems) else cs1).forceBoxStatus(resultBoxed)
+
           if needsAdaptation then
             val criticalSet =          // the set which is not allowed to have `*`
               if covariant then cs1    // can't box with `*`
@@ -797,9 +788,9 @@ class CheckCaptures extends Recheck, SymTransformer:
               }
               if !insertBox then  // unboxing
                 markFree(criticalSet, pos)
-              recon(CapturingType(parent1, if alwaysConst then CaptureSet(cs1.elems) else cs1, !actualIsBoxed))
+              adaptedType(!boxed)
           else
-            recon(CapturingType(parent1, if alwaysConst then CaptureSet(cs1.elems) else cs1, actualIsBoxed))
+            adaptedType(boxed)
       }
 
       var actualw = actual.widenDealias

From 31bf9578954aa07e32fc4a5029ab0a734b10bc64 Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Tue, 7 Feb 2023 11:57:24 +0100
Subject: [PATCH 113/657] docs: update CONTRIBUTING.md to point to contributing
 guide

This is a follow-up of
https://github.com/scala/docs.scala-lang/pull/2692. In that PR I went
ahead and migrated all of the information contained in this
`CONTRIBUTING.md` to the actual guide. Now we just point there to ensure
everything is in one place.
---
 CONTRIBUTING.md | 63 ++++---------------------------------------------
 1 file changed, 4 insertions(+), 59 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 3267d1f02700..48206fd67b3c 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,60 +1,5 @@
-# Dotty Developer Guidelines
+# Contributing to Dotty
 
-These guidelines are meant to be a living document that should be changed and adapted as needed. We encourage changes that make it easier to achieve our goals in an efficient way.
-
-## General Workflow
-
-This is the process for committing code to the Scala project. There are of course exceptions to these rules, for example minor changes to comments and documentation, fixing a broken build etc.
-
-1. Make sure you have signed the [Scala CLA](https://www.lightbend.com/contribute/cla/scala), if not, sign it.
-2. Before starting to work on a feature or a fix, it's good practice to ensure that:
-    1. There is a ticket for your work in the project's [issue tracker](https://github.com/lampepfl/dotty/issues);
-    2. The ticket has been discussed and prioritized by the team.
-3. You should always perform your work in its own Git branch. The branch should be given a descriptive name that explains its intent. Some teams also like adding the ticket number and/or the [GitHub](http://github.com) user ID to the branch name, these details is up to each of the individual teams. (See below for more details on branch naming.)
-4. When the feature or fix is completed you should open a [Pull Request](https://help.github.com/articles/using-pull-requests) on GitHub.
-5. The Pull Request should be reviewed by other maintainers (as many as feasible/practical). Note that a reviewer can also be an outside contributor—members of Typesafe  or VirtusLab and independent contributors are encouraged to participate in the review process. It is not a closed process. Please try to avoid conflict of interest—the spirit of the review process is to evenly distribute the understanding of our code base across its maintainers as well as to load balance quality assurance. Assigning a review to a "sure win" reviewer is not a good long-term solution.
-6. After the review, you should resolve issues brought up by the reviewers as needed (pushing a new commit to address reviewers' comments), iterating until the reviewers give their thumbs up, the "LGTM" (acronym for "Looks Good To Me").
-7. Once the code has passed review the Pull Request can be merged into the distribution.
-
-## Pull Request Requirements
-
-In order for a Pull Request to be considered, it has to meet these requirements:
-
-1. Live up to the current code standard:
-   - Not violate [DRY](https://www.oreilly.com/library/view/97-things-every/9780596809515/ch30.html).
-   - [Boy Scout Rule](https://www.oreilly.com/library/view/97-things-every/9780596809515/ch08.html) should be applied.
-2. Tests are of paramount importance.
-3. The code must be well documented in the project's standard documentation format (see the ‘Documentation’ section below).
-
-If *all* of these requirements are not met then the code should **not** be merged into the distribution, and need not even be reviewed.
-
-## Documentation
-
-All contributed code should come accompanied by documentation. Pull requests containing undocumented code will not be accepted. Both user-facing Scaladoc comments, as well as committer-facing internal documentation (i.e. essential design decisions that other maintainers should know about should be placed inline with line comments `//`) should be accompanying all contributed code where possible.
-
-
-## Work In Progress
-
-It is ok to work on a public feature branch in the GitHub repository. Something that can sometimes be useful for early feedback etc. If so, then it is preferable to name the branch accordingly. This can be done by either prefixing the name with ``wip-`` as in ‘Work In Progress’, or use hierarchical names like ``wip/..``, ``feature/..`` or ``topic/..``. Either way is fine as long as it is clear that it is work in progress and not ready for merge. This work can temporarily have a lower standard. However, to be merged into master it will have to go through the regular process outlined above, with Pull Request, review etc..
-
-Also, to facilitate both well-formed commits and working together, the ``wip`` and ``feature``/``topic`` identifiers also have special meaning. Any branch labeled with ``wip`` is considered “git-unstable” and may be rebased and have its history rewritten.   Any branch with ``feature``/``topic`` in the name is considered “stable” enough for others to depend on when a group is working on a feature.
-
-## Creating Commits And Writing Commit Messages
-
-Follow these guidelines when creating public commits and writing commit messages.
-
-1. If your work spans multiple local commits (for example; if you do safe point commits while working in a feature branch or work in a branch for long time doing merges/rebases etc.) then please do not commit it all but rewrite the history by squashing the commits into one large commit which is accompanied by a detailed commit message for (as discussed in the following sections). For more info, see the article: [Git Workflow](http://sandofsky.com/blog/git-workflow.html). Additionally, every commit should be able to be used in isolation—that is, each commit must build and pass all tests.
-2. The first line should be a descriptive sentence about what the commit is doing. It should be possible to fully understand what the commit does by just reading this single line. It is **not ok** to only list the ticket number, type "minor fix" or similar. If the commit has a corresponding ticket, include a reference to the ticket number, prefixed with "Closes #", at the beginning of the first line followed by the title of the ticket, assuming that it aptly and concisely summarizes the commit in a single line. If the commit is a small fix, then you are done. If not, go to 3.
-3. Following the single line description (ideally no more than 70 characters long) should be a blank line followed by an enumerated list with the details of the commit.
-4. Add keywords for your commit (depending on the degree of automation we reach, the list may change over time):
-    * ``Review by @githubuser`` - will notify the reviewer via GitHub. Everyone is encouraged to give feedback, however. (Remember that @-mentions will result in notifications also when pushing to a WIP branch, so please only include this in your commit message when you're ready for your pull request to be reviewed. Alternatively, you may request a review in the pull request's description.)
-    * ``Fix/Fixing/Fixes/Close/Closing/Refs #ticket`` - if you want to mark the ticket as fixed in the issue tracker (Assembla understands this).
-    * ``backport to _branch name_`` - if the fix needs to be cherry-picked to another branch (like 2.9.x, 2.10.x, etc)
-
-Example:
-
-    Closes #2 Fixes the build
-
-      - Details 1
-      - Details 2
-      - Details 3
+Firstly, thanks for being willing to contribute to Dotty! Head on over the
+[Scala 3 Contributing
+Guide](https://docs.scala-lang.org/scala3/guides/contribution/contribution-intro.html), which should have all the info you're looking for.

From 03e3bd437d35a0a65ec175711d2e52e6bc4d5481 Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Wed, 12 Oct 2022 13:53:21 +0200
Subject: [PATCH 114/657] Apply class-shadowing.md

---
 docs/_spec/05-classes-and-objects.md          |  2 +-
 .../dropped-features/class-shadowing.md       |  2 --
 .../dropped-features/class-shadowing-spec.md  | 26 -------------------
 3 files changed, 1 insertion(+), 29 deletions(-)
 rename docs/_spec/{TODOreference => APPLIEDreference}/dropped-features/class-shadowing.md (94%)
 delete mode 100644 docs/_spec/TODOreference/dropped-features/class-shadowing-spec.md

diff --git a/docs/_spec/05-classes-and-objects.md b/docs/_spec/05-classes-and-objects.md
index 622f9dc8ae59..c40bd49cae16 100644
--- a/docs/_spec/05-classes-and-objects.md
+++ b/docs/_spec/05-classes-and-objects.md
@@ -241,7 +241,7 @@ It inherits member `f` from trait `C` and member `g` from trait `B`.
 A member ´M´ of class ´C´ that [matches](#class-members) a non-private member ´M'´ of a base class of ´C´ is said to _override_ that member.
 In this case the binding of the overriding member ´M´ must [subsume](03-types.html#conformance) the binding of the overridden member ´M'´.
 Furthermore, the following restrictions on modifiers apply to ´M´ and ´M'´:
-
+- ´M'´ must not be a class.
 - ´M'´ must not be labeled `final`.
 - ´M´ must not be [`private`](#modifiers).
 - If ´M´ is labeled `private[´C´]` for some enclosing class or package ´C´, then ´M'´ must be labeled `private[´C'´]` for some class or package ´C'´ where ´C'´ equals ´C´ or ´C'´ is contained in ´C´.
diff --git a/docs/_spec/TODOreference/dropped-features/class-shadowing.md b/docs/_spec/APPLIEDreference/dropped-features/class-shadowing.md
similarity index 94%
rename from docs/_spec/TODOreference/dropped-features/class-shadowing.md
rename to docs/_spec/APPLIEDreference/dropped-features/class-shadowing.md
index 8bfdb1eb196c..a27b53db7cce 100644
--- a/docs/_spec/TODOreference/dropped-features/class-shadowing.md
+++ b/docs/_spec/APPLIEDreference/dropped-features/class-shadowing.md
@@ -29,5 +29,3 @@ The issue is that the two `Ops` classes _look_ like one overrides the
 other, but classes in Scala 2 cannot be overridden. To keep things clean
 (and its internal operations consistent) the Scala 3 compiler forces you
 to rename the inner classes so that their names are different.
-
-[More details](./class-shadowing-spec.md)
diff --git a/docs/_spec/TODOreference/dropped-features/class-shadowing-spec.md b/docs/_spec/TODOreference/dropped-features/class-shadowing-spec.md
deleted file mode 100644
index 6c81087408c6..000000000000
--- a/docs/_spec/TODOreference/dropped-features/class-shadowing-spec.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-layout: doc-page
-title: "Dropped: Class Shadowing - More Details"
-nightlyOf: https://docs.scala-lang.org/scala3/reference/dropped-features/class-shadowing-spec.html
----
-
-Spec diff: in section [5.1.4 Overriding](https://www.scala-lang.org/files/archive/spec/2.13/05-classes-and-objects.html#Overriding), add *M' must not be a class*.
-
-> Why do we want to make this change to the language?
-
-Class shadowing is irregular compared to other types of overrides. Indeed, inner classes are not actually overridden but simply shadowed.
-
-
-> How much existing code is going to be affected?
-
-From all the code compiled so far with Scala 3 the only instance of this I could find is in the stdlib. Looking at [this commit](https://github.com/lampepfl/scala/commit/68f13bf39979b631ed211ec1751934306ceb5d6c#diff-7aa508b70e055b47c823764e3e5646b8) it seems like the usage of class shadowing was accidental.
-
-
-> How exactly is existing code going to be affected?
-
-Code that relies on overridden inner classes will stop compiling.
-
-
-> Is this change going to be migratable automatically?
-
-No.

From 63fe1c089f798a8806f15ae971118c1fa25f2e33 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Wed, 8 Feb 2023 10:06:24 +0100
Subject: [PATCH 115/657] Add regression tests

Closes #16842
---
 tests/neg/i16842.scala | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 tests/neg/i16842.scala

diff --git a/tests/neg/i16842.scala b/tests/neg/i16842.scala
new file mode 100644
index 000000000000..1e7e5cc14339
--- /dev/null
+++ b/tests/neg/i16842.scala
@@ -0,0 +1,25 @@
+sealed trait Expr1
+sealed trait Literal extends Expr1
+
+case class ArrayLiter(elems: List[Expr1]) extends Literal
+
+sealed trait SemanticType {
+  type T // the type with which a literal of this semanticType is represented
+}
+case object SemanticInt extends SemanticType {
+  type T = Int
+}
+
+case class SemanticArray[U <: SemanticType](dim: Int) extends SemanticType {
+  type T = List[U]
+}
+
+sealed trait Expr2[+T]
+class Liter[T <: SemanticType](val ty: T, val value: ty.T) extends Expr2[T]
+
+def typecheckArrayLiter(
+    a: ArrayLiter
+): Liter[SemanticArray[SemanticType]] = {
+  val x: List[Expr2[SemanticInt.type]] = List()
+  Liter(SemanticArray[SemanticInt.type], x) // error // error
+}

From 5fb27667a5843c388670f1f7688b37007aa94610 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Wed, 8 Feb 2023 10:59:39 +0100
Subject: [PATCH 116/657] Print owner of bind symbol with -Yprint-debug-owners

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

diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index 6f258fdddbe9..8ffb99f073fb 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -571,7 +571,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         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)
+        toTextOwner(bind) ~ 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, " | ") }

From 36926c8a6256b4baf883251499e11a6466fd49ea Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Pa=C5=82ka?= <prolativus@gmail.com>
Date: Wed, 8 Feb 2023 16:39:33 +0100
Subject: [PATCH 117/657] Add --should-fail flag to the bisect script

---
 project/scripts/bisect.scala | 26 +++++++++++++++++---------
 1 file changed, 17 insertions(+), 9 deletions(-)

diff --git a/project/scripts/bisect.scala b/project/scripts/bisect.scala
index e60e632a7feb..2e554a885c79 100755
--- a/project/scripts/bisect.scala
+++ b/project/scripts/bisect.scala
@@ -31,6 +31,7 @@ val usageMessage = """
   |The optional <bisect-options> may be any combination of:
   |* --dry-run
   |    Don't try to bisect - just make sure the validation command works correctly
+  |
   |* --releases <releases-range>
   |    Bisect only releases from the given range (defaults to all releases).
   |    The range format is <first>...<last>, where both <first> and <last> are optional, e.g.
@@ -38,8 +39,12 @@ val usageMessage = """
   |    * 3.2.1-RC1-bin-20220620-de3a82c-NIGHTLY..
   |    * ..3.3.0-RC1-bin-20221124-e25362d-NIGHTLY
   |    The ranges are treated as inclusive.
+  |
   |* --bootstrapped
-  |    Publish locally and test a bootstrapped compiler rather than a nonboostrapped one
+  |    Publish locally and test a bootstrapped compiler rather than a nonboostrapped one.
+  |
+  |* --should-fail
+  |    Expect the validation command to fail rather that succeed. This can be used e.g. to find out when some illegal code started to compile.
   |
   |Warning: The bisect script should not be run multiple times in parallel because of a potential race condition while publishing artifacts locally.
 
@@ -54,7 +59,7 @@ val usageMessage = """
 
   val validationScript = scriptOptions.validationCommand.validationScript
   val releases = Releases.fromRange(scriptOptions.releasesRange)
-  val releaseBisect = ReleaseBisect(validationScript, releases)
+  val releaseBisect = ReleaseBisect(validationScript, shouldFail = scriptOptions.shouldFail, releases)
 
   releaseBisect.verifyEdgeReleases()
 
@@ -64,18 +69,19 @@ val usageMessage = """
     println(s"First bad release: ${firstBadRelease.version}")
     println("\nFinished bisecting releases\n")
 
-    val commitBisect = CommitBisect(validationScript, bootstrapped = scriptOptions.bootstrapped, lastGoodRelease.hash, firstBadRelease.hash)
+    val commitBisect = CommitBisect(validationScript, shouldFail = scriptOptions.shouldFail, bootstrapped = scriptOptions.bootstrapped, lastGoodRelease.hash, firstBadRelease.hash)
     commitBisect.bisect()
 
 
-case class ScriptOptions(validationCommand: ValidationCommand, dryRun: Boolean, bootstrapped: Boolean, releasesRange: ReleasesRange)
+case class ScriptOptions(validationCommand: ValidationCommand, dryRun: Boolean, bootstrapped: Boolean, releasesRange: ReleasesRange, shouldFail: Boolean)
 object ScriptOptions:
   def fromArgs(args: Seq[String]) =
     val defaultOptions = ScriptOptions(
       validationCommand = null,
       dryRun = false,
       bootstrapped = false,
-      ReleasesRange(first = None, last = None)
+      ReleasesRange(first = None, last = None),
+      shouldFail = false
     )
     parseArgs(args, defaultOptions)
 
@@ -86,6 +92,7 @@ object ScriptOptions:
       case "--releases" :: argsRest =>
         val range = ReleasesRange.tryParse(argsRest.head).get
         parseArgs(argsRest.tail, options.copy(releasesRange = range))
+      case "--should-fail" :: argsRest => parseArgs(argsRest, options.copy(shouldFail = true))
       case _ =>
         val command = ValidationCommand.fromArgs(args)
         options.copy(validationCommand = command)
@@ -182,7 +189,7 @@ case class Release(version: String):
   override def toString: String = version
 
 
-class ReleaseBisect(validationScript: File, allReleases: Vector[Release]):
+class ReleaseBisect(validationScript: File, shouldFail: Boolean, allReleases: Vector[Release]):
   assert(allReleases.length > 1, "Need at least 2 releases to bisect")
 
   private val isGoodReleaseCache = collection.mutable.Map.empty[Release, Boolean]
@@ -217,21 +224,22 @@ class ReleaseBisect(validationScript: File, allReleases: Vector[Release]):
     isGoodReleaseCache.getOrElseUpdate(release, {
       println(s"Testing ${release.version}")
       val result = Seq(validationScript.getAbsolutePath, release.version).!
-      val isGood = result == 0
+      val isGood = if(shouldFail) result != 0 else result == 0 // invert the process status if failure was expected
       println(s"Test result: ${release.version} is a ${if isGood then "good" else "bad"} release\n")
       isGood
     })
 
-class CommitBisect(validationScript: File, bootstrapped: Boolean, lastGoodHash: String, fistBadHash: String):
+class CommitBisect(validationScript: File, shouldFail: Boolean, bootstrapped: Boolean, lastGoodHash: String, fistBadHash: String):
   def bisect(): Unit =
     println(s"Starting bisecting commits $lastGoodHash..$fistBadHash\n")
     val scala3CompilerProject = if bootstrapped then "scala3-compiler-bootstrapped" else "scala3-compiler"
     val scala3Project = if bootstrapped then "scala3-bootstrapped" else "scala3"
+    val validationCommandStatusModifier = if shouldFail then "! " else "" // invert the process status if failure was expected
     val bisectRunScript = s"""
       |scalaVersion=$$(sbt "print ${scala3CompilerProject}/version" | tail -n1)
       |rm -r out
       |sbt "clean; ${scala3Project}/publishLocal"
-      |${validationScript.getAbsolutePath} "$$scalaVersion"
+      |${validationCommandStatusModifier}${validationScript.getAbsolutePath} "$$scalaVersion"
     """.stripMargin
     "git bisect start".!
     s"git bisect bad $fistBadHash".!

From 07dcca1b73800aa3623dce92323c494aad98b055 Mon Sep 17 00:00:00 2001
From: Jan Chyb <jan.chyb.99@gmail.com>
Date: Fri, 27 Jan 2023 09:52:06 +0100
Subject: [PATCH 118/657] Fix crashes of path dependent types in spliced
 Type.of

Previously it was assumed that the type in Type.of could be captured as
a whole, which meant that path dependent types for which a separate
@SplicedType hole definitions were included in a block, would end up
with missing references.

Now when find a block in Type.of, we try to analise all parts of the
type separately, adding additional hole definitions to the block as
necessary.
For types that can be captured as a whole (those which did not have
a block generated previously, meaning they do not include any
@SplicedType hole definitions), old method is used.
---
 .../dotty/tools/dotc/transform/Splicing.scala | 39 ++++++++++++++++---
 tests/pos-macros/i16615.scala                 | 16 ++++++++
 2 files changed, 49 insertions(+), 6 deletions(-)
 create mode 100644 tests/pos-macros/i16615.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/Splicing.scala b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
index ad3f0322130d..799dbc6c09c9 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicing.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
@@ -242,9 +242,14 @@ class Splicing extends MacroTransform:
                 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))
+        case Apply(TypeApply(typeof, List(tpt)), List(quotes))
         if tree.symbol == defn.QuotedTypeModule_of && containsCapturedType(tpt.tpe) =>
-          ref(capturedType(tpt))(using ctx.withSource(tree.source)).withSpan(tree.span)
+          tpt match
+            case block: Block =>
+              val newBlock = capturedBlockPartTypes(block)
+              Apply(TypeApply(typeof, List(newBlock)), List(quotes)).withSpan(tree.span)
+            case _ =>
+              ref(capturedType(tpt))(using ctx.withSource(tree.source)).withSpan(tree.span)
         case CapturedApplication(fn, argss) =>
           transformCapturedApplication(tree, fn, argss)
         case _ =>
@@ -335,17 +340,39 @@ class Splicing extends MacroTransform:
       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(
+    private def newQuotedTypeClassBinding(tpe: Type)(using Context) = 
+      newSymbol(
         spliceOwner,
         UniqueName.fresh(nme.Type).toTermName,
         Param,
         defn.QuotedTypeClass.typeRef.appliedTo(tpe),
       )
-      val bindingSym = refBindingMap.getOrElseUpdate(tree.symbol, (TypeTree(tree.tpe), newBinding))._2
+
+    private def capturedType(tree: Tree)(using Context): Symbol =
+      val tpe = tree.tpe.widenTermRefExpr
+      val bindingSym = refBindingMap
+        .getOrElseUpdate(tree.symbol, (TypeTree(tree.tpe), newQuotedTypeClassBinding(tpe)))._2
       bindingSym
 
+    private def capturedBlockPartTypes(block: Block)(using Context): Tree =
+      val old = healedTypes
+      healedTypes = PCPCheckAndHeal.QuoteTypeTags(block.span)
+      val capturePartTypes = new TypeMap {
+        def apply(tp: Type) = tp match {
+          case typeRef @ TypeRef(prefix, _) if isCaptured(prefix.typeSymbol) || isCaptured(prefix.termSymbol) =>
+            val termRef = refBindingMap
+              .getOrElseUpdate(typeRef.symbol, (TypeTree(typeRef), newQuotedTypeClassBinding(typeRef)))._2.termRef
+            val tagRef = healedTypes.nn.getTagRef(termRef)
+            tagRef
+          case _ =>
+            mapOver(tp)
+        }
+      }
+      val captured = capturePartTypes(block.tpe.widenTermRefExpr)
+      val newHealedTypes = healedTypes.nn.getTypeTags
+      healedTypes = old
+      Block(newHealedTypes ::: block.stats, TypeTree(captured))
+
     private def getTagRefFor(tree: Tree)(using Context): Tree =
       val capturedTypeSym = capturedType(tree)
       TypeTree(healedTypes.nn.getTagRef(capturedTypeSym.termRef))
diff --git a/tests/pos-macros/i16615.scala b/tests/pos-macros/i16615.scala
new file mode 100644
index 000000000000..510994f20423
--- /dev/null
+++ b/tests/pos-macros/i16615.scala
@@ -0,0 +1,16 @@
+import scala.quoted.*
+
+trait Api:
+  type Reader[E]
+
+def bugImpl[T: Type, Q[_]: Type](using Quotes) =
+  '{
+    val p: Api = ???
+    ${
+      Type.of[p.Reader[T]]
+      Type.of[Q[p.Reader[T]]]
+      Type.of[p.Reader[Q[p.Reader[T]]]]
+      Type.of[p.Reader[Q[T]]]
+      Expr(1)
+    }
+  }
\ No newline at end of file

From 90cdb6957a78b14d838a5ec49b707d9b3504f695 Mon Sep 17 00:00:00 2001
From: Jan Chyb <jan.chyb.99@gmail.com>
Date: Wed, 8 Feb 2023 18:06:07 +0100
Subject: [PATCH 119/657] Make holes more consistent and address review
 comments

---
 .../dotty/tools/dotc/transform/Splicing.scala | 27 ++++++++++++-------
 tests/pos-macros/i16615.scala                 |  5 +++-
 2 files changed, 22 insertions(+), 10 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/Splicing.scala b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
index 799dbc6c09c9..393fe46b8438 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicing.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
@@ -244,12 +244,14 @@ class Splicing extends MacroTransform:
               cpy.Apply(tree)(cpy.Select(sel)(cpy.Apply(app)(fn, newArgs), nme.apply), quotesArgs)
         case Apply(TypeApply(typeof, List(tpt)), List(quotes))
         if tree.symbol == defn.QuotedTypeModule_of && containsCapturedType(tpt.tpe) =>
-          tpt match
-            case block: Block =>
-              val newBlock = capturedBlockPartTypes(block)
-              Apply(TypeApply(typeof, List(newBlock)), List(quotes)).withSpan(tree.span)
+          val newContent = capturedPartTypes(tpt)
+          newContent match
+            case block: Block => 
+              inContext(ctx.withSource(tree.source)) {
+                Apply(TypeApply(typeof, List(newContent)), List(quotes)).withSpan(tree.span)
+              }
             case _ =>
-              ref(capturedType(tpt))(using ctx.withSource(tree.source)).withSpan(tree.span)
+              ref(capturedType(newContent))(using ctx.withSource(tree.source)).withSpan(tree.span)
         case CapturedApplication(fn, argss) =>
           transformCapturedApplication(tree, fn, argss)
         case _ =>
@@ -354,9 +356,9 @@ class Splicing extends MacroTransform:
         .getOrElseUpdate(tree.symbol, (TypeTree(tree.tpe), newQuotedTypeClassBinding(tpe)))._2
       bindingSym
 
-    private def capturedBlockPartTypes(block: Block)(using Context): Tree =
+    private def capturedPartTypes(tpt: Tree)(using Context): Tree =
       val old = healedTypes
-      healedTypes = PCPCheckAndHeal.QuoteTypeTags(block.span)
+      healedTypes = PCPCheckAndHeal.QuoteTypeTags(tpt.span)
       val capturePartTypes = new TypeMap {
         def apply(tp: Type) = tp match {
           case typeRef @ TypeRef(prefix, _) if isCaptured(prefix.typeSymbol) || isCaptured(prefix.termSymbol) =>
@@ -368,10 +370,17 @@ class Splicing extends MacroTransform:
             mapOver(tp)
         }
       }
-      val captured = capturePartTypes(block.tpe.widenTermRefExpr)
+      val captured = capturePartTypes(tpt.tpe.widenTermRefExpr)
       val newHealedTypes = healedTypes.nn.getTypeTags
       healedTypes = old
-      Block(newHealedTypes ::: block.stats, TypeTree(captured))
+      tpt match
+        case block: Block =>
+          cpy.Block(block)(newHealedTypes ::: block.stats, TypeTree(captured))
+        case _ => 
+          if newHealedTypes.nonEmpty then
+            cpy.Block(tpt)(newHealedTypes, TypeTree(captured))
+          else
+            tpt
 
     private def getTagRefFor(tree: Tree)(using Context): Tree =
       val capturedTypeSym = capturedType(tree)
diff --git a/tests/pos-macros/i16615.scala b/tests/pos-macros/i16615.scala
index 510994f20423..3cc2d271fa87 100644
--- a/tests/pos-macros/i16615.scala
+++ b/tests/pos-macros/i16615.scala
@@ -10,7 +10,10 @@ def bugImpl[T: Type, Q[_]: Type](using Quotes) =
       Type.of[p.Reader[T]]
       Type.of[Q[p.Reader[T]]]
       Type.of[p.Reader[Q[p.Reader[T]]]]
+      Type.of[List[p.Reader[T]]]
+      Type.of[p.Reader[List[p.Reader[T]]]]
+      Type.of[p.Reader[List[T]]]
       Type.of[p.Reader[Q[T]]]
       Expr(1)
     }
-  }
\ No newline at end of file
+  }

From 7f6a2f752d9059ca3d681e54076100e597a8e4ea Mon Sep 17 00:00:00 2001
From: Tomasz Godzik <tgodzik@virtuslab.com>
Date: Thu, 2 Feb 2023 17:56:12 +0100
Subject: [PATCH 120/657] improvement: Small fixes to allow using Metals with
 scaladoc with sbt

This would require just setting `bspEnabled := true`, but not for sjsJUnitTests which seem to cause inifinite loop of compilations.

I also need to work a bit on Bloop to also make it work.

This still needs https://github.com/scalameta/metals/pull/4938
---
 project/Build.scala | 2 ++
 project/build.sbt   | 3 ---
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/project/Build.scala b/project/Build.scala
index 90f2dc3fe076..097876a63f92 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -360,6 +360,7 @@ 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
     bspEnabled := false,
     (Compile / unmanagedSourceDirectories) += baseDirectory.value / "src-bootstrapped",
 
@@ -1130,6 +1131,7 @@ object Build {
     enablePlugins(DottyJSPlugin).
     dependsOn(`scala3-library-bootstrappedJS`).
     settings(
+      bspEnabled := false,
       scalacOptions --= Seq("-Xfatal-warnings", "-deprecation"),
 
       // Required to run Scala.js tests.
diff --git a/project/build.sbt b/project/build.sbt
index e19492c42022..188dfa5c6702 100644
--- a/project/build.sbt
+++ b/project/build.sbt
@@ -1,7 +1,4 @@
 // Used by VersionUtil to get gitHash and commitDate
 libraryDependencies += "org.eclipse.jgit" % "org.eclipse.jgit" % "4.11.0.201803080745-r"
 
-
-Compile / unmanagedSourceDirectories +=
-  baseDirectory.value / "../language-server/src/dotty/tools/languageserver/config"
 libraryDependencies += Dependencies.`jackson-databind`

From 09ac6c27c7e65d1b23525b5f5c6a229278bd26ef Mon Sep 17 00:00:00 2001
From: Tomasz Godzik <tgodzik@virtuslab.com>
Date: Wed, 8 Feb 2023 18:59:22 +0100
Subject: [PATCH 121/657] bugfix: Make sure symbol exists before calling owner

---
 .../src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala   | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala
index 84bc1e77a1ef..91614aaccad2 100644
--- a/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala
+++ b/compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala
@@ -190,7 +190,7 @@ class ExtractSemanticDB extends Phase:
                 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) =>
+        case tree: Template if tree.symbol != NoSymbol && 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`).
@@ -201,7 +201,7 @@ class ExtractSemanticDB extends Phase:
           val selfSpan = tree.self.span
           if selfSpan.exists && selfSpan.hasLength then
             traverse(tree.self)
-          if tree.symbol.owner.isEnumClass then
+          if tree.symbol != NoSymbol && tree.symbol.owner.isEnumClass then
             tree.body.foreachUntilImport(traverse).foreach(traverse) // the first import statement
           else
             tree.body.foreach(traverse)

From e0f56c8ec98fd18ed2f3f5822022c18ebcd50254 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Wed, 8 Feb 2023 14:31:34 +0100
Subject: [PATCH 122/657] Add regression test

Closes #16008
---
 tests/pos-macros/i16008/Macro_1.scala | 24 ++++++++++++++++++++++++
 tests/pos-macros/i16008/Test_2.scala  |  1 +
 2 files changed, 25 insertions(+)
 create mode 100644 tests/pos-macros/i16008/Macro_1.scala
 create mode 100644 tests/pos-macros/i16008/Test_2.scala

diff --git a/tests/pos-macros/i16008/Macro_1.scala b/tests/pos-macros/i16008/Macro_1.scala
new file mode 100644
index 000000000000..b1cc1e6b2b9d
--- /dev/null
+++ b/tests/pos-macros/i16008/Macro_1.scala
@@ -0,0 +1,24 @@
+import scala.quoted.*
+
+enum MyEnum0:
+  case Marked
+  case Marked2(i: Int)
+
+trait MyMarker
+
+enum MyEnum(val value: String):
+  case Marked extends MyEnum("marked") with MyMarker
+  case Marked2(i: Int) extends MyEnum("marked") with MyMarker
+
+inline def enumMacro: Unit = ${ enumMacroExpr }
+
+private def enumMacroExpr(using Quotes): Expr[Unit] =
+  import quotes.reflect.*
+  assert(TypeRepr.of[MyEnum0].typeSymbol.flags.is(Flags.Enum))
+  assert(TypeRepr.of[MyEnum0.Marked.type].termSymbol.flags.is(Flags.Enum))
+  assert(TypeRepr.of[MyEnum0.Marked2].typeSymbol.flags.is(Flags.Enum))
+  assert(TypeRepr.of[MyEnum].typeSymbol.flags.is(Flags.Enum))
+  assert(TypeRepr.of[MyEnum.Marked.type].termSymbol.flags.is(Flags.Enum))
+  assert(TypeRepr.of[MyEnum.Marked2].typeSymbol.flags.is(Flags.Enum))
+
+  '{}
diff --git a/tests/pos-macros/i16008/Test_2.scala b/tests/pos-macros/i16008/Test_2.scala
new file mode 100644
index 000000000000..43631e59e4b2
--- /dev/null
+++ b/tests/pos-macros/i16008/Test_2.scala
@@ -0,0 +1 @@
+def test = enumMacro

From 94a6c674e017b7b861db84edeb9c8b3bcfb4b31f Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Thu, 9 Feb 2023 11:24:33 +0100
Subject: [PATCH 123/657] Always load REPL classes in macros including the
 output directory

Fixes #15104
---
 .../dotty/tools/dotc/quoted/Interpreter.scala | 19 +++++++++----------
 compiler/test-resources/repl-macros/i15104a   |  7 +++++++
 compiler/test-resources/repl-macros/i15104b   |  5 +++++
 compiler/test-resources/repl-macros/i15104c   |  7 +++++++
 compiler/test-resources/repl-macros/i5551     |  3 +--
 .../test/dotty/tools/repl/ScriptedTests.scala |  4 ++++
 6 files changed, 33 insertions(+), 12 deletions(-)
 create mode 100644 compiler/test-resources/repl-macros/i15104a
 create mode 100644 compiler/test-resources/repl-macros/i15104b
 create mode 100644 compiler/test-resources/repl-macros/i15104c

diff --git a/compiler/src/dotty/tools/dotc/quoted/Interpreter.scala b/compiler/src/dotty/tools/dotc/quoted/Interpreter.scala
index 38cecb7953b8..7c8262ecbf00 100644
--- a/compiler/src/dotty/tools/dotc/quoted/Interpreter.scala
+++ b/compiler/src/dotty/tools/dotc/quoted/Interpreter.scala
@@ -32,10 +32,15 @@ import dotty.tools.dotc.reporting.Message
 import dotty.tools.repl.AbstractFileClassLoader
 
 /** Tree interpreter for metaprogramming constructs */
-class Interpreter(pos: SrcPos, classLoader: ClassLoader)(using Context):
+class Interpreter(pos: SrcPos, classLoader0: ClassLoader)(using Context):
   import Interpreter._
   import tpd._
 
+  val classLoader =
+    if ctx.owner.topLevelClass.name.startsWith(str.REPL_SESSION_LINE) then
+        new AbstractFileClassLoader(ctx.settings.outputDir.value, classLoader0)
+    else classLoader0
+
   /** Local variable environment */
   type Env = Map[Symbol, Object]
   def emptyEnv: Env = Map.empty
@@ -157,18 +162,12 @@ class Interpreter(pos: SrcPos, classLoader: ClassLoader)(using Context):
     args.toSeq
 
   private def interpretedStaticMethodCall(moduleClass: Symbol, fn: Symbol, args: 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)
-        }
+    val inst =
+      try loadModule(moduleClass)
       catch
         case MissingClassDefinedInCurrentRun(sym) =>
           suspendOnMissing(sym, pos)
-
+    val clazz = inst.getClass
     val name = fn.name.asTermName
     val method = getMethod(clazz, name, paramsSig(fn))
     stopIfRuntimeException(method.invoke(inst, args: _*), method)
diff --git a/compiler/test-resources/repl-macros/i15104a b/compiler/test-resources/repl-macros/i15104a
new file mode 100644
index 000000000000..92e82928b509
--- /dev/null
+++ b/compiler/test-resources/repl-macros/i15104a
@@ -0,0 +1,7 @@
+scala> import scala.quoted._
+scala> object Foo { def macroImpl(using Quotes) = Expr(1) }
+// defined object Foo
+scala> inline def foo = ${ Foo.macroImpl }
+def foo: Int
+scala> foo
+val res0: Int = 1
diff --git a/compiler/test-resources/repl-macros/i15104b b/compiler/test-resources/repl-macros/i15104b
new file mode 100644
index 000000000000..ebbdb2402076
--- /dev/null
+++ b/compiler/test-resources/repl-macros/i15104b
@@ -0,0 +1,5 @@
+scala> import scala.quoted._
+scala> object Foo { def macroImpl(using Quotes) = Expr(1); inline def foo = ${ Foo.macroImpl } }
+// defined object Foo
+scala> Foo.foo
+val res0: Int = 1
diff --git a/compiler/test-resources/repl-macros/i15104c b/compiler/test-resources/repl-macros/i15104c
new file mode 100644
index 000000000000..482b9487c9d9
--- /dev/null
+++ b/compiler/test-resources/repl-macros/i15104c
@@ -0,0 +1,7 @@
+scala> import scala.quoted._
+scala> def macroImpl(using Quotes) = Expr(1)
+def macroImpl(using x$1: quoted.Quotes): quoted.Expr[Int]
+scala> inline def foo = ${ macroImpl }
+def foo: Int
+scala> foo
+val res0: Int = 1
diff --git a/compiler/test-resources/repl-macros/i5551 b/compiler/test-resources/repl-macros/i5551
index fb039ed19dd6..d71251e9a824 100644
--- a/compiler/test-resources/repl-macros/i5551
+++ b/compiler/test-resources/repl-macros/i5551
@@ -1,8 +1,7 @@
 scala> import scala.quoted._
 scala> def assertImpl(expr: Expr[Boolean])(using q: Quotes) = '{ if !($expr) then throw new AssertionError("failed assertion")}
 def assertImpl
-  (expr: quoted.Expr[Boolean])
-     (using q: quoted.Quotes): quoted.Expr[Unit]
+  (expr: quoted.Expr[Boolean])(using q: quoted.Quotes): quoted.Expr[Unit]
 scala>   inline def assert(expr: => Boolean): Unit =  ${ assertImpl('{expr}) }
 def assert(expr: => Boolean): Unit
 
diff --git a/compiler/test/dotty/tools/repl/ScriptedTests.scala b/compiler/test/dotty/tools/repl/ScriptedTests.scala
index 5c3a32cd40f8..dc809228e86b 100644
--- a/compiler/test/dotty/tools/repl/ScriptedTests.scala
+++ b/compiler/test/dotty/tools/repl/ScriptedTests.scala
@@ -3,12 +3,16 @@ package tools
 package repl
 
 import org.junit.Test
+import org.junit.experimental.categories.Category
 
 /** Runs all tests contained in `compiler/test-resources/repl/` */
 class ScriptedTests extends ReplTest {
 
   @Test def replTests = scripts("/repl").foreach(testFile)
 
+  @Category(Array(classOf[BootstrappedOnlyTests]))
+  @Test def replMacrosTests = scripts("/repl-macros").foreach(testFile)
+
   @Test def typePrinterTests = scripts("/type-printer").foreach(testFile)
 }
 

From 116a9602cb32fde45329fedc2eaa6a987152e98f Mon Sep 17 00:00:00 2001
From: Som Snytt <som.snytt@gmail.com>
Date: Thu, 9 Feb 2023 08:35:45 -0800
Subject: [PATCH 124/657] Fix comment test number

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

diff --git a/compiler/src/dotty/tools/dotc/typer/Namer.scala b/compiler/src/dotty/tools/dotc/typer/Namer.scala
index 6f85efb0fc8a..dddf7523420a 100644
--- a/compiler/src/dotty/tools/dotc/typer/Namer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Namer.scala
@@ -1335,7 +1335,7 @@ class Namer { typer: Typer =>
        *
        *  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.
+       *  expand the use site reference. Test cases in {neg,pos}/i14966.scala.
        *
        *  @pre Forwarders with the same name are consecutive in `forwarders`.
        */

From f77069a74c4df65c7f69a6476aeb6b52fa8acb48 Mon Sep 17 00:00:00 2001
From: Guillaume Martres <smarter@ubuntu.com>
Date: Fri, 10 Feb 2023 15:36:06 +0100
Subject: [PATCH 125/657] ClassfileParser: Avoid cycle when accessing companion
 in inner class lookup

Previously, the call to `info` on the module val could lead to a cycle since the
module val might be in the process of being completed. This commit fixes this by
only using the module class which is all we need to lookup members.

Fixes #15288.
Fixes #14059.

Co-Authored-By: Tom Grigg <tomegrigg@gmail.com>
---
 .../tools/dotc/core/classfile/ClassfileParser.scala      | 8 ++++----
 sbt-test/java-compat/i15288/QueryRequest.java            | 9 +++++++++
 sbt-test/java-compat/i15288/Test.scala                   | 2 ++
 sbt-test/java-compat/i15288/build.sbt                    | 1 +
 sbt-test/java-compat/i15288/test                         | 5 +++++
 5 files changed, 21 insertions(+), 4 deletions(-)
 create mode 100644 sbt-test/java-compat/i15288/QueryRequest.java
 create mode 100644 sbt-test/java-compat/i15288/Test.scala
 create mode 100644 sbt-test/java-compat/i15288/build.sbt
 create mode 100644 sbt-test/java-compat/i15288/test

diff --git a/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala b/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
index 7702e6a93446..eeeb3767bd34 100644
--- a/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
+++ b/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
@@ -1086,10 +1086,10 @@ class ClassfileParser(
           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
+            var moduleClass = sym.registeredCompanion
+            if (!moduleClass.exists && sym.isAbsent())
+              moduleClass = sym.scalacLinkedClass
+            moduleClass.info.member(name).symbol
           }
         else if (sym == classRoot.symbol)
           instanceScope.lookup(name)
diff --git a/sbt-test/java-compat/i15288/QueryRequest.java b/sbt-test/java-compat/i15288/QueryRequest.java
new file mode 100644
index 000000000000..e43487e09449
--- /dev/null
+++ b/sbt-test/java-compat/i15288/QueryRequest.java
@@ -0,0 +1,9 @@
+interface CopyableBuilder<B, T> {}
+interface ToCopyableBuilder<B, T> {}
+
+public class QueryRequest implements ToCopyableBuilder<QueryRequest.Builder, QueryRequest> {
+    public static Builder builder() { throw new UnsupportedOperationException(); }
+    public interface Builder extends CopyableBuilder<Builder, QueryRequest> {
+        void build();
+    }
+}
diff --git a/sbt-test/java-compat/i15288/Test.scala b/sbt-test/java-compat/i15288/Test.scala
new file mode 100644
index 000000000000..e03617ac4c33
--- /dev/null
+++ b/sbt-test/java-compat/i15288/Test.scala
@@ -0,0 +1,2 @@
+class Test:
+  def makeQuery = QueryRequest.builder().build()
diff --git a/sbt-test/java-compat/i15288/build.sbt b/sbt-test/java-compat/i15288/build.sbt
new file mode 100644
index 000000000000..63e314982c41
--- /dev/null
+++ b/sbt-test/java-compat/i15288/build.sbt
@@ -0,0 +1 @@
+scalaVersion := sys.props("plugin.scalaVersion")
diff --git a/sbt-test/java-compat/i15288/test b/sbt-test/java-compat/i15288/test
new file mode 100644
index 000000000000..ad1a8a5987ee
--- /dev/null
+++ b/sbt-test/java-compat/i15288/test
@@ -0,0 +1,5 @@
+## This could just be a pos test checked by FromTastyTests, but
+## ParallelTesting#compileTastyInDir does not support test with multiple files
+## currently.
+> compile
+> doc

From d6ee51e3d4880737c3a9596bd3773ca5013db4f8 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sat, 11 Feb 2023 13:34:25 +0100
Subject: [PATCH 126/657] Harden tpd.Apply/TypeApply in case of errors

Harden tpd.Apply/TypeApply in case of errors to accept non-sensical terms as
functions.

Fixes #16861
---
 compiler/src/dotty/tools/dotc/ast/tpd.scala | 6 ++++++
 tests/neg/i16861.scala                      | 2 ++
 tests/neg/i16861a.scala                     | 4 ++++
 3 files changed, 12 insertions(+)
 create mode 100644 tests/neg/i16861.scala
 create mode 100644 tests/neg/i16861a.scala

diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
index 1a202ece1e66..aea8cf297ab8 100644
--- a/compiler/src/dotty/tools/dotc/ast/tpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -47,12 +47,18 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       Apply(expr, args)
     case _: RefTree | _: GenericApply | _: Inlined | _: Hole =>
       ta.assignType(untpd.Apply(fn, args), fn, args)
+    case _ =>
+      assert(ctx.reporter.errorsReported)
+      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)
+    case _ =>
+      assert(ctx.reporter.errorsReported)
+      ta.assignType(untpd.TypeApply(fn, args), fn, args)
 
   def Literal(const: Constant)(using Context): Literal =
     ta.assignType(untpd.Literal(const))
diff --git a/tests/neg/i16861.scala b/tests/neg/i16861.scala
new file mode 100644
index 000000000000..50c56974d027
--- /dev/null
+++ b/tests/neg/i16861.scala
@@ -0,0 +1,2 @@
+given foo[T]: Any = summon[bar] // error
+def bar: Nothing = ???
\ No newline at end of file
diff --git a/tests/neg/i16861a.scala b/tests/neg/i16861a.scala
new file mode 100644
index 000000000000..b93f884f5e56
--- /dev/null
+++ b/tests/neg/i16861a.scala
@@ -0,0 +1,4 @@
+import scala.quoted.*
+trait Foo
+object Foo:
+  inline given foo[T <: Foo]: T = summon[Type.of[T]] // error

From 2678e67c2acc6eeee5e0a252a2c19a78bedcd83a Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sat, 11 Feb 2023 15:37:04 +0100
Subject: [PATCH 127/657] Add missing criterion to subtype check

Fixes #16850
---
 compiler/src/dotty/tools/dotc/core/TypeComparer.scala |  1 +
 tests/neg/i16850.check                                | 10 ++++++++++
 tests/neg/i16850.scala                                | 10 ++++++++++
 3 files changed, 21 insertions(+)
 create mode 100644 tests/neg/i16850.check
 create mode 100644 tests/neg/i16850.scala

diff --git a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
index 2a0072590550..9e8d18765352 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
@@ -309,6 +309,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
                 thirdTryNamed(tp2)
               else
                 (  (tp1.name eq tp2.name)
+                && !sym1.is(Private)
                 && tp2.isPrefixDependentMemberRef
                 && isSubPrefix(tp1.prefix, tp2.prefix)
                 && tp1.signature == tp2.signature
diff --git a/tests/neg/i16850.check b/tests/neg/i16850.check
new file mode 100644
index 000000000000..6c9c7f7e0eac
--- /dev/null
+++ b/tests/neg/i16850.check
@@ -0,0 +1,10 @@
+-- [E007] Type Mismatch Error: tests/neg/i16850.scala:7:33 -------------------------------------------------------------
+7 |  def add(elm: Y): Unit = list = elm :: list // error
+  |                                 ^^^
+  |                                 Found:    (elm : Y)
+  |                                 Required: Class.this.Y²
+  |
+  |                                 where:    Y  is a type in class Class
+  |                                           Y² is a type in trait Trait
+  |
+  | longer explanation available when compiling with `-explain`
diff --git a/tests/neg/i16850.scala b/tests/neg/i16850.scala
new file mode 100644
index 000000000000..e7904fcd44e7
--- /dev/null
+++ b/tests/neg/i16850.scala
@@ -0,0 +1,10 @@
+
+trait Trait :
+  type Y
+  var list: List[Y] = Nil
+
+class Class[Y] extends Trait :
+  def add(elm: Y): Unit = list = elm :: list // error
+
+object Object extends Class[Int] :
+  add(42)

From ad675afe873b64ce178ba82d254d64254330a90f Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sat, 11 Feb 2023 19:30:13 +0100
Subject: [PATCH 128/657] Generate toString only for synthetic companions of
 case classes

Don't generate a toString method if the companion is explicitly given.
This matches Scala 2's behavior.

Fixes #16879
---
 compiler/src/dotty/tools/dotc/typer/Namer.scala |  6 +++++-
 tests/run/i16879.scala                          | 16 ++++++++++++++++
 2 files changed, 21 insertions(+), 1 deletion(-)
 create mode 100644 tests/run/i16879.scala

diff --git a/compiler/src/dotty/tools/dotc/typer/Namer.scala b/compiler/src/dotty/tools/dotc/typer/Namer.scala
index 6f85efb0fc8a..cab5dc273f4b 100644
--- a/compiler/src/dotty/tools/dotc/typer/Namer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Namer.scala
@@ -541,7 +541,11 @@ class Namer { typer: Typer =>
           res = cpy.TypeDef(modCls)(
             rhs = cpy.Template(modTempl)(
               derived = if (fromTempl.derived.nonEmpty) fromTempl.derived else modTempl.derived,
-              body = fromTempl.body ++ modTempl.body))
+              body = fromTempl.body.filter {
+                  case stat: DefDef => stat.name != nme.toString_
+                    // toString should only be generated if explicit companion is missing
+                  case _ => true
+                } ++ 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)
diff --git a/tests/run/i16879.scala b/tests/run/i16879.scala
new file mode 100644
index 000000000000..c01b8cb1ed89
--- /dev/null
+++ b/tests/run/i16879.scala
@@ -0,0 +1,16 @@
+trait Companion:
+  final override def toString: String = "Companion"
+
+case class Example(value: Int)
+object Example extends Companion
+
+case class C()
+object C:
+  override def toString = "CC"
+
+case class D()
+
+@main def Test =
+  assert(Example.toString == "Companion")
+  assert(C.toString == "CC")
+  assert(D.toString == "D")

From 4e8e201be4227ec1b13a28d50505ba71f2979454 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sat, 11 Feb 2023 19:48:39 +0100
Subject: [PATCH 129/657] PolyFunction desugar: Don't copy type flags to
 parameter

Fixes #16871

Signed-off-by: odersky <odersky@gmail.com>
---
 compiler/src/dotty/tools/dotc/ast/Desugar.scala | 2 +-
 tests/pos/i16871.scala                          | 3 +++
 2 files changed, 4 insertions(+), 1 deletion(-)
 create mode 100644 tests/pos/i16871.scala

diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index 2cfd292fd6dd..85dd5e6665c6 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -1732,7 +1732,7 @@ object desugar {
 
           val applyVParams = vargs.zipWithIndex.map {
             case (p: ValDef, _) => p.withAddedFlags(mods.flags)
-            case (p, n) => makeSyntheticParameter(n + 1, p).withAddedFlags(mods.flags)
+            case (p, n) => makeSyntheticParameter(n + 1, p).withAddedFlags(mods.flags.toTermFlags)
           }
           RefinedTypeTree(polyFunctionTpt, List(
             DefDef(nme.apply, applyTParams :: applyVParams :: Nil, res, EmptyTree).withFlags(Synthetic)
diff --git a/tests/pos/i16871.scala b/tests/pos/i16871.scala
new file mode 100644
index 000000000000..3251a7135346
--- /dev/null
+++ b/tests/pos/i16871.scala
@@ -0,0 +1,3 @@
+import scala.language.experimental.captureChecking
+
+val f: [X] => Int => Int = [X] => (x: Int) => x
\ No newline at end of file

From afd499bfe1c5cf279a4635a72b98b5ddae2d65fd Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sat, 11 Feb 2023 20:48:30 +0100
Subject: [PATCH 130/657] Update semanticdb expect file

---
 tests/semanticdb/metac.expect | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect
index 32e19e1f9c46..c78d30e00863 100644
--- a/tests/semanticdb/metac.expect
+++ b/tests/semanticdb/metac.expect
@@ -467,7 +467,7 @@ Schema => SemanticDB v4
 Uri => Classes.scala
 Text => empty
 Language => Scala
-Symbols => 109 entries
+Symbols => 108 entries
 Occurrences => 114 entries
 Synthetics => 2 entries
 
@@ -504,10 +504,9 @@ classes/C4#copy$default$1(). => method copy$default$1 => Int @uncheckedVariance
 classes/C4#copy(). => method copy (param x: Int): C4
 classes/C4#copy().(x) => param x: Int
 classes/C4#x. => val method x Int
-classes/C4. => final object C4 extends Object { self: C4.type => +4 decls }
+classes/C4. => final object C4 extends Object { self: C4.type => +3 decls }
 classes/C4.apply(). => method apply (param x: Int): C4
 classes/C4.apply().(x) => param x: Int
-classes/C4.toString(). => method toString => String <: scala/Any#toString().
 classes/C4.unapply(). => method unapply (param x$1: C4): C4
 classes/C4.unapply().(x$1) => param x$1: C4
 classes/C6# => case class C6 extends Object with Product with Serializable { self: C6 => +5 decls }
@@ -4559,7 +4558,7 @@ Schema => SemanticDB v4
 Uri => semanticdb-Types.scala
 Text => empty
 Language => Scala
-Symbols => 144 entries
+Symbols => 143 entries
 Occurrences => 228 entries
 Synthetics => 1 entries
 
@@ -4585,10 +4584,9 @@ types/Foo#copy$default$1(). => method copy$default$1 => "abc" @uncheckedVariance
 types/Foo#copy(). => method copy (param s: "abc"): Foo
 types/Foo#copy().(s) => param s: "abc"
 types/Foo#s. => val method s "abc"
-types/Foo. => final object Foo extends Object { self: Foo.type => +6 decls }
+types/Foo. => final object Foo extends Object { self: Foo.type => +5 decls }
 types/Foo.apply(). => method apply (param s: "abc"): Foo
 types/Foo.apply().(s) => param s: "abc"
-types/Foo.toString(). => method toString => String <: scala/Any#toString().
 types/Foo.unapply(). => method unapply (param x$1: Foo): Foo
 types/Foo.unapply().(x$1) => param x$1: Foo
 types/Foo.x. => val method x "abc" @deprecated

From bdd56dd7073cc87293f96fee23a980140276cf3b Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sun, 12 Feb 2023 10:11:49 +0100
Subject: [PATCH 131/657] Move test to cc directory

This avoids a pickler test failure, since under pickling we don't see language
imports in source when we print the trees for comparisons.
---
 tests/{pos => pos-custom-args/captures}/i16871.scala | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename tests/{pos => pos-custom-args/captures}/i16871.scala (100%)

diff --git a/tests/pos/i16871.scala b/tests/pos-custom-args/captures/i16871.scala
similarity index 100%
rename from tests/pos/i16871.scala
rename to tests/pos-custom-args/captures/i16871.scala

From ae05f998bf118ca72d9e39857092227456c5da13 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sun, 12 Feb 2023 11:49:21 +0100
Subject: [PATCH 132/657] Don't eta expand unary varargs methods

A unary varargs method sits between nullary methods that sometimes get a () argument inferred
(i.e. for methods coming from Java) and other methods that can be eta expanded. The safest
strategy for them is to do neither, and expect either an explicit expected function type,
or an explicit argument. That's also what Scala 2 does.

Fixes #16820

Reclassifies #14567 to be a neg test (with the error message suggested in the original issue
for #14567)
---
 .../src/dotty/tools/dotc/typer/Typer.scala    |  5 ++++-
 tests/neg/i16820.check                        | 22 +++++++++++++++++++
 tests/neg/i16820.scala                        | 13 +++++++++++
 tests/pos/i14367.scala                        |  2 +-
 tests/pos/i14567.scala                        |  2 --
 5 files changed, 40 insertions(+), 4 deletions(-)
 create mode 100644 tests/neg/i16820.check
 create mode 100644 tests/neg/i16820.scala
 delete mode 100644 tests/pos/i14567.scala

diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index a87d6dd7e703..82928894ebca 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -3922,7 +3922,10 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
               else defn.functionArity(ptNorm)
             else
               val nparams = wtp.paramInfos.length
-              if nparams > 0 || pt.eq(AnyFunctionProto) then nparams
+              if nparams > 1
+                  || nparams == 1 && !wtp.isVarArgsMethod
+                  || pt.eq(AnyFunctionProto)
+              then nparams
               else -1 // no eta expansion in this case
           adaptNoArgsUnappliedMethod(wtp, funExpected, arity)
         case _ =>
diff --git a/tests/neg/i16820.check b/tests/neg/i16820.check
new file mode 100644
index 000000000000..5f2e82bbf2ef
--- /dev/null
+++ b/tests/neg/i16820.check
@@ -0,0 +1,22 @@
+-- Error: tests/neg/i16820.scala:5:11 ----------------------------------------------------------------------------------
+5 |  val x1 = f  // error
+  |           ^
+  |           missing arguments for method f in object Test
+-- [E100] Syntax Error: tests/neg/i16820.scala:6:11 --------------------------------------------------------------------
+6 |  val x2 = g  // error
+  |           ^
+  |           method g in object Test must be called with () argument
+  |
+  | longer explanation available when compiling with `-explain`
+-- Error: tests/neg/i16820.scala:8:14 ----------------------------------------------------------------------------------
+8 |  val x3 = "".formatted // error
+  |           ^^^^^^^^^^^^
+  |           missing arguments for method formatted in class String
+-- Error: tests/neg/i16820.scala:9:40 ----------------------------------------------------------------------------------
+9 |  val x4 = java.nio.file.Paths.get(".").toRealPath // error
+  |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  |           missing arguments for method toRealPath in trait Path
+-- Error: tests/neg/i16820.scala:13:14 ---------------------------------------------------------------------------------
+13 |def test = Foo(3)  // error
+   |           ^^^^^^
+   |           missing arguments for method apply in object Foo
diff --git a/tests/neg/i16820.scala b/tests/neg/i16820.scala
new file mode 100644
index 000000000000..7a93f3a5d355
--- /dev/null
+++ b/tests/neg/i16820.scala
@@ -0,0 +1,13 @@
+object Test:
+  def f(xs: Int*) = xs.sum
+  def g() = 1
+
+  val x1 = f  // error
+  val x2 = g  // error
+
+  val x3 = "".formatted // error
+  val x4 = java.nio.file.Paths.get(".").toRealPath // error
+
+// #14567
+case class Foo(x: Int)(xs: String*)
+def test = Foo(3)  // error
diff --git a/tests/pos/i14367.scala b/tests/pos/i14367.scala
index d74f0aa8373e..3319e705b741 100644
--- a/tests/pos/i14367.scala
+++ b/tests/pos/i14367.scala
@@ -1,5 +1,5 @@
 def m(i: Int*) = i.sum
-val f1 = m
+val f1: Seq[Int] => Int = m
 val f2 = i => m(i*)
 
 def n(i: Seq[Int]) = i.sum
diff --git a/tests/pos/i14567.scala b/tests/pos/i14567.scala
deleted file mode 100644
index fe47279c07b1..000000000000
--- a/tests/pos/i14567.scala
+++ /dev/null
@@ -1,2 +0,0 @@
-case class Foo(x: Int)(xs: String*)
-def test = Foo(3)

From 4b8a31fcc092b912caa6fc2a4ee55ebc4a4ac2d6 Mon Sep 17 00:00:00 2001
From: "s.bazarsadaev" <s.bazarsadaev@macbook-s.bazarsadaev>
Date: Sun, 6 Nov 2022 20:49:37 +0300
Subject: [PATCH 133/657] Closes #14340 - add dynamic access to value classes
 field

---
 .../src/dotty/tools/dotc/typer/Dynamic.scala  | 32 +++++++++++++------
 tests/run/i14340.check                        |  4 +++
 tests/run/i14340.scala                        | 20 ++++++++++++
 3 files changed, 46 insertions(+), 10 deletions(-)
 create mode 100644 tests/run/i14340.check
 create mode 100644 tests/run/i14340.scala

diff --git a/compiler/src/dotty/tools/dotc/typer/Dynamic.scala b/compiler/src/dotty/tools/dotc/typer/Dynamic.scala
index 1630ce31e4c6..5de9ca6ab341 100644
--- a/compiler/src/dotty/tools/dotc/typer/Dynamic.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Dynamic.scala
@@ -2,20 +2,22 @@ package dotty.tools
 package dotc
 package typer
 
-import dotty.tools.dotc.ast.Trees._
+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.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.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._
+import util.Spans.*
+import core.Symbols.*
+import ErrorReporting.*
+import dotty.tools.dotc.transform.ValueClasses
+import dotty.tools.dotc.transform.TypeUtils.isPrimitiveValueType
+import reporting.*
 
 object Dynamic {
   private def isDynamicMethod(name: Name): Boolean =
@@ -215,6 +217,12 @@ trait Dynamic {
       errorTree(tree, em"Structural access not allowed on method $name because it $reason")
 
     fun.tpe.widen match {
+      case tpe: ValueType if ValueClasses.isDerivedValueClass(tpe.classSymbol) =>
+        val underlying = ValueClasses.valueClassUnbox(tpe.classSymbol.asClass).info.resultType.asSeenFrom(tpe, tpe.classSymbol)
+        val wrapped = structuralCall(nme.selectDynamic, Nil)
+        val resultTree = if wrapped.tpe.isExactlyAny then New(tpe, wrapped.cast(underlying) :: Nil) else wrapped
+        resultTree.cast(tpe)
+
       case tpe: ValueType =>
         structuralCall(nme.selectDynamic, Nil).cast(tpe)
 
@@ -236,7 +244,11 @@ trait Dynamic {
               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)
+          val finalTpe = tpe.finalResultType
+          if ValueClasses.isDerivedValueClass(finalTpe.classSymbol) then
+            New(finalTpe, structuralCall(nme.applyDynamic, classOfs).cast(finalTpe)
+              .cast(ValueClasses.valueClassUnbox(finalTpe.classSymbol.asClass).info.resultType.asSeenFrom(finalTpe, finalTpe.classSymbol)) :: Nil)
+          else structuralCall(nme.applyDynamic, classOfs).cast(finalTpe)
         }
 
       // (@allanrenucci) I think everything below is dead code
diff --git a/tests/run/i14340.check b/tests/run/i14340.check
new file mode 100644
index 000000000000..db372c9502e9
--- /dev/null
+++ b/tests/run/i14340.check
@@ -0,0 +1,4 @@
+1
+2
+3
+qux
\ No newline at end of file
diff --git a/tests/run/i14340.scala b/tests/run/i14340.scala
new file mode 100644
index 000000000000..e9d8733ccfa5
--- /dev/null
+++ b/tests/run/i14340.scala
@@ -0,0 +1,20 @@
+class Foo(val value: Int) extends AnyVal
+class Bar[A](val value: A) extends AnyVal
+
+class Container1 extends reflect.Selectable
+
+class Container2 extends Selectable:
+  def selectDynamic(name: String) = Bar(name)
+
+val cont1 = new Container1:
+  def foo = new Foo(1)
+  val bar = new Bar(Foo(2))
+  def fooFromInt(i: Int) = new Foo(i)
+
+val cont2 = (new Container2).asInstanceOf[Container2 { def qux: Bar[String] }]
+
+@main def Test: Unit =
+  println(cont1.foo.value)
+  println(cont1.bar.value.value)
+  println(cont1.fooFromInt(3).value)
+  println(cont2.qux.value)
\ No newline at end of file

From d6ae0cbdfa5e19886cadcec3c8ee02d944a36c8f Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sun, 12 Feb 2023 13:01:30 +0100
Subject: [PATCH 134/657] Allow @implicitNotFound messages as explanations

A problem of the @implicitNotFOund mechanism so far was that the user defined
message replaced the compiler-generated one, which might lose valuable information.

This commit adds an alternative where an @implicitNotFound message that starts
with `...` is taken as an explanation (without the ...) enabled under -explain.
The compiler-generated message is then kept as the explicit error message.

We apply the mechanism for an @implicitNotFound message for `boundary.Label`.
This now produces messages like this one:
```
-- [E172] Type Error: tests/neg-custom-args/explain/labelNotFound.scala:2:30 -------------------------------------------
2 |  scala.util.boundary.break(1) // error
  |                              ^
  |No given instance of type scala.util.boundary.Label[Int] was found for parameter label of method break in object boundary
  |---------------------------------------------------------------------------------------------------------------------
  | Explanation (enabled by `-explain`)
  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  | A Label is generated from an enclosing `scala.util.boundary` call.
  | Maybe that boundary is missing?
   ---------------------------------------------------------------------------------------------------------------------
```
---
 .../dotty/tools/dotc/reporting/messages.scala | 193 ++++++++++--------
 .../dotty/tools/dotc/CompilationTests.scala   |   5 +-
 library/src/scala/util/boundary.scala         |   2 +
 .../explain/hidden-type-errors.check          |  23 +++
 .../hidden-type-errors/Macro.scala            |   0
 .../hidden-type-errors/Test.scala             |   0
 .../{ => explain}/i11637.check                |   4 +-
 .../{ => explain}/i11637.scala                |   0
 .../{ => explain}/i15575.check                |   4 +-
 .../{ => explain}/i15575.scala                |   0
 .../{ => explain}/i16601a.check               |   2 +-
 .../{ => explain}/i16601a.scala               |   0
 .../explain/labelNotFound.check               |  10 +
 .../explain/labelNotFound.scala               |   4 +
 .../neg-custom-args/hidden-type-errors.check  |  28 ---
 15 files changed, 148 insertions(+), 127 deletions(-)
 create mode 100644 tests/neg-custom-args/explain/hidden-type-errors.check
 rename tests/neg-custom-args/{ => explain}/hidden-type-errors/Macro.scala (100%)
 rename tests/neg-custom-args/{ => explain}/hidden-type-errors/Test.scala (100%)
 rename tests/neg-custom-args/{ => explain}/i11637.check (92%)
 rename tests/neg-custom-args/{ => explain}/i11637.scala (100%)
 rename tests/neg-custom-args/{ => explain}/i15575.check (87%)
 rename tests/neg-custom-args/{ => explain}/i15575.scala (100%)
 rename tests/neg-custom-args/{ => explain}/i16601a.check (89%)
 rename tests/neg-custom-args/{ => explain}/i16601a.scala (100%)
 create mode 100644 tests/neg-custom-args/explain/labelNotFound.check
 create mode 100644 tests/neg-custom-args/explain/labelNotFound.scala
 delete mode 100644 tests/neg-custom-args/hidden-type-errors.check

diff --git a/compiler/src/dotty/tools/dotc/reporting/messages.scala b/compiler/src/dotty/tools/dotc/reporting/messages.scala
index f41d34b8c17c..fb9eaed094e8 100644
--- a/compiler/src/dotty/tools/dotc/reporting/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/messages.scala
@@ -2562,6 +2562,106 @@ class MissingImplicitArgument(
     case ambi: AmbiguousImplicits => withoutDisambiguation()
     case _ =>
 
+  /** 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])(using Context): 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
+    )
+
+  /** @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)(using Context): String =
+    val substitutableTypesSymbols = substitutableTypeSymbolsInScope(sym)
+    userDefinedErrorString(
+      rawMsg,
+      paramNames = substitutableTypesSymbols.map(_.name.unexpandedName.toString),
+      args = substitutableTypesSymbols.map(_.typeRef).map(substituteType)
+    )
+
+  /** 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)(using Context) =
+    for
+      ann <- sym.getAnnotation(cls)
+      msg <- ann.argumentConstantString(0)
+    yield msg
+
+  def userDefinedImplicitNotFoundTypeMessageFor(sym: Symbol)(using Context): 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)
+
+  /** 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(using Context): 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)
+
+  def userDefinedImplicitNotFoundTypeMessage(using Context): 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)
+
+  /** The implicitNotFound annotation on the parameter, or else on the type.
+   *  implicitNotFound message strings starting with `...` are intended for
+   *  additional explanations, not the message proper. The leading `...` is
+   *  dropped in this case.
+   *  @param explain  The message is used for an additional explanation, not
+   *                  the message proper.
+   */
+  def userDefinedImplicitNotFoundMessage(explain: Boolean)(using Context): Option[String] =
+    def filter(msg: Option[String]) = msg match
+      case Some(str) =>
+        if str.startsWith("...") then
+          if explain then Some(str.drop(3)) else None
+        else if explain then None
+        else msg
+      case None => None
+    filter(userDefinedImplicitNotFoundParamMessage)
+      .orElse(filter(userDefinedImplicitNotFoundTypeMessage))
+
+  object AmbiguousImplicitMsg {
+    def unapply(search: SearchSuccess): Option[String] =
+      userDefinedMsg(search.ref.symbol, defn.ImplicitAmbiguousAnnot)
+  }
+
   def msg(using Context): String =
 
     def formatMsg(shortForm: String)(headline: String = shortForm) = arg match
@@ -2585,29 +2685,6 @@ class MissingImplicitArgument(
               |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) =
@@ -2644,39 +2721,6 @@ class MissingImplicitArgument(
       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")
@@ -2684,37 +2728,6 @@ class MissingImplicitArgument(
      *
      *  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
@@ -2728,8 +2741,7 @@ class MissingImplicitArgument(
         i"""No implicit search was attempted${location("for")}
             |since the expected type $target is not specific enough"""
       case _ =>
-        val shortMessage = userDefinedImplicitNotFoundParamMessage
-          .orElse(userDefinedImplicitNotFoundTypeMessage)
+        val shortMessage = userDefinedImplicitNotFoundMessage(explain = false)
           .getOrElse(defaultImplicitNotFoundMessage)
         formatMsg(shortMessage)()
   end msg
@@ -2758,7 +2770,8 @@ class MissingImplicitArgument(
             .orElse(noChainConversionsNote(ignoredConvertibleImplicits))
             .getOrElse(ctx.typer.importSuggestionAddendum(pt))
 
-  def explain(using Context) = ""
+  def explain(using Context) = userDefinedImplicitNotFoundMessage(explain = true)
+    .getOrElse("")
 end MissingImplicitArgument
 
 class CannotBeAccessed(tpe: NamedType, superAccess: Boolean)(using Context)
diff --git a/compiler/test/dotty/tools/dotc/CompilationTests.scala b/compiler/test/dotty/tools/dotc/CompilationTests.scala
index dee65e404da9..ed531aa404c2 100644
--- a/compiler/test/dotty/tools/dotc/CompilationTests.scala
+++ b/compiler/test/dotty/tools/dotc/CompilationTests.scala
@@ -143,6 +143,7 @@ class CompilationTests {
       compileFilesInDir("tests/neg-custom-args/feature", defaultOptions.and("-Xfatal-warnings", "-feature")),
       compileFilesInDir("tests/neg-custom-args/no-experimental", defaultOptions.and("-Yno-experimental")),
       compileFilesInDir("tests/neg-custom-args/captures", defaultOptions.and("-language:experimental.captureChecking")),
+      compileFilesInDir("tests/neg-custom-args/explain", defaultOptions.and("-explain")),
       compileFile("tests/neg-custom-args/avoid-warn-deprecation.scala", defaultOptions.and("-Xfatal-warnings", "-feature")),
       compileFile("tests/neg-custom-args/i3246.scala", scala2CompatMode),
       compileFile("tests/neg-custom-args/overrideClass.scala", scala2CompatMode),
@@ -155,9 +156,6 @@ class CompilationTests {
       compileFile("tests/neg-custom-args/i1754.scala", allowDeepSubtypes),
       compileFile("tests/neg-custom-args/i12650.scala", allowDeepSubtypes),
       compileFile("tests/neg-custom-args/i9517.scala", defaultOptions.and("-Xprint-types")),
-      compileFile("tests/neg-custom-args/i11637.scala", defaultOptions.and("-explain")),
-      compileFile("tests/neg-custom-args/i15575.scala", defaultOptions.and("-explain")),
-      compileFile("tests/neg-custom-args/i16601a.scala", defaultOptions.and("-explain")),
       compileFile("tests/neg-custom-args/interop-polytypes.scala", allowDeepSubtypes.and("-Yexplicit-nulls")),
       compileFile("tests/neg-custom-args/conditionalWarnings.scala", allowDeepSubtypes.and("-deprecation").and("-Xfatal-warnings")),
       compileFilesInDir("tests/neg-custom-args/isInstanceOf", allowDeepSubtypes and "-Xfatal-warnings"),
@@ -182,7 +180,6 @@ class CompilationTests {
       compileFile("tests/neg-custom-args/matchable.scala", defaultOptions.and("-Xfatal-warnings", "-source", "future")),
       compileFile("tests/neg-custom-args/i7314.scala", defaultOptions.and("-Xfatal-warnings", "-source", "future")),
       compileFile("tests/neg-custom-args/capt-wf.scala", defaultOptions.and("-language:experimental.captureChecking", "-Xfatal-warnings")),
-      compileDir("tests/neg-custom-args/hidden-type-errors", defaultOptions.and("-explain")),
       compileFile("tests/neg-custom-args/i13026.scala", defaultOptions.and("-print-lines")),
       compileFile("tests/neg-custom-args/i13838.scala", defaultOptions.and("-Ximplicit-search-limit", "1000")),
       compileFile("tests/neg-custom-args/jdk-9-app.scala", defaultOptions.and("-release:8")),
diff --git a/library/src/scala/util/boundary.scala b/library/src/scala/util/boundary.scala
index 3c6c6982c7ee..ea21446d9682 100644
--- a/library/src/scala/util/boundary.scala
+++ b/library/src/scala/util/boundary.scala
@@ -1,4 +1,5 @@
 package scala.util
+import scala.annotation.implicitNotFound
 
 /** A boundary that can be exited by `break` calls.
  *  `boundary` and `break` represent a unified and superior alternative for the
@@ -34,6 +35,7 @@ object boundary:
 
   /** Labels are targets indicating which boundary will be exited by a `break`.
    */
+  @implicitNotFound("...A Label is generated from an enclosing `scala.util.boundary` call.\nMaybe that boundary is missing?")
   final class Label[-T]
 
   /** Abort current computation and instead return `value` as the value of
diff --git a/tests/neg-custom-args/explain/hidden-type-errors.check b/tests/neg-custom-args/explain/hidden-type-errors.check
new file mode 100644
index 000000000000..551d1d7b16ba
--- /dev/null
+++ b/tests/neg-custom-args/explain/hidden-type-errors.check
@@ -0,0 +1,23 @@
+-- [E007] Type Mismatch Error: tests/neg-custom-args/explain/hidden-type-errors/Test.scala:6:24 ------------------------
+6 |   val x = X.doSomething("XXX") // error
+  |           ^^^^^^^^^^^^^^^^^^^^
+  |           Found:    String
+  |           Required: Int
+  |---------------------------------------------------------------------------------------------------------------------
+  | Explanation (enabled by `-explain`)
+  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  |
+  | Tree: t12717.A.bar("XXX")
+  | I tried to show that
+  |   String
+  | conforms to
+  |   Int
+  | but the comparison trace ended with `false`:
+  |
+  |   ==> String  <:  Int
+  |     ==> String  <:  Int
+  |     <== String  <:  Int = false
+  |   <== String  <:  Int = false
+  |
+  | The tests were made under the empty constraint
+   ---------------------------------------------------------------------------------------------------------------------
diff --git a/tests/neg-custom-args/hidden-type-errors/Macro.scala b/tests/neg-custom-args/explain/hidden-type-errors/Macro.scala
similarity index 100%
rename from tests/neg-custom-args/hidden-type-errors/Macro.scala
rename to tests/neg-custom-args/explain/hidden-type-errors/Macro.scala
diff --git a/tests/neg-custom-args/hidden-type-errors/Test.scala b/tests/neg-custom-args/explain/hidden-type-errors/Test.scala
similarity index 100%
rename from tests/neg-custom-args/hidden-type-errors/Test.scala
rename to tests/neg-custom-args/explain/hidden-type-errors/Test.scala
diff --git a/tests/neg-custom-args/i11637.check b/tests/neg-custom-args/explain/i11637.check
similarity index 92%
rename from tests/neg-custom-args/i11637.check
rename to tests/neg-custom-args/explain/i11637.check
index 0664a05f4f86..82424396a43b 100644
--- a/tests/neg-custom-args/i11637.check
+++ b/tests/neg-custom-args/explain/i11637.check
@@ -1,4 +1,4 @@
--- [E057] Type Mismatch Error: tests/neg-custom-args/i11637.scala:11:33 ------------------------------------------------
+-- [E057] Type Mismatch Error: tests/neg-custom-args/explain/i11637.scala:11:33 ----------------------------------------
 11 |  var h = new HKT3_1[FunctorImpl]();  // error // error
    |                                 ^
    |       Type argument test2.FunctorImpl does not conform to upper bound [Generic2[T <: String] <: Set[T]] =>> Any
@@ -26,7 +26,7 @@
    |
    | The tests were made under the empty constraint
     --------------------------------------------------------------------------------------------------------------------
--- [E057] Type Mismatch Error: tests/neg-custom-args/i11637.scala:11:21 ------------------------------------------------
+-- [E057] Type Mismatch Error: tests/neg-custom-args/explain/i11637.scala:11:21 ----------------------------------------
 11 |  var h = new HKT3_1[FunctorImpl]();  // error // error
    |                     ^
    |       Type argument test2.FunctorImpl does not conform to upper bound [Generic2[T <: String] <: Set[T]] =>> Any
diff --git a/tests/neg-custom-args/i11637.scala b/tests/neg-custom-args/explain/i11637.scala
similarity index 100%
rename from tests/neg-custom-args/i11637.scala
rename to tests/neg-custom-args/explain/i11637.scala
diff --git a/tests/neg-custom-args/i15575.check b/tests/neg-custom-args/explain/i15575.check
similarity index 87%
rename from tests/neg-custom-args/i15575.check
rename to tests/neg-custom-args/explain/i15575.check
index f69111efeb96..e254e0a5e22e 100644
--- a/tests/neg-custom-args/i15575.check
+++ b/tests/neg-custom-args/explain/i15575.check
@@ -1,4 +1,4 @@
--- [E057] Type Mismatch Error: tests/neg-custom-args/i15575.scala:3:27 -------------------------------------------------
+-- [E057] Type Mismatch Error: tests/neg-custom-args/explain/i15575.scala:3:27 -----------------------------------------
 3 |  def bar[T]: Unit = foo[T & Any] // error
   |                           ^
   |                           Type argument T & Any does not conform to lower bound Any
@@ -18,7 +18,7 @@
   |
   | The tests were made under the empty constraint
    ---------------------------------------------------------------------------------------------------------------------
--- [E057] Type Mismatch Error: tests/neg-custom-args/i15575.scala:7:14 -------------------------------------------------
+-- [E057] Type Mismatch Error: tests/neg-custom-args/explain/i15575.scala:7:14 -----------------------------------------
 7 |  val _ = foo[String]  // error
   |              ^
   |              Type argument String does not conform to lower bound CharSequence
diff --git a/tests/neg-custom-args/i15575.scala b/tests/neg-custom-args/explain/i15575.scala
similarity index 100%
rename from tests/neg-custom-args/i15575.scala
rename to tests/neg-custom-args/explain/i15575.scala
diff --git a/tests/neg-custom-args/i16601a.check b/tests/neg-custom-args/explain/i16601a.check
similarity index 89%
rename from tests/neg-custom-args/i16601a.check
rename to tests/neg-custom-args/explain/i16601a.check
index 604f71993ada..63be0d2cd2b2 100644
--- a/tests/neg-custom-args/i16601a.check
+++ b/tests/neg-custom-args/explain/i16601a.check
@@ -1,4 +1,4 @@
--- [E042] Type Error: tests/neg-custom-args/i16601a.scala:1:27 ---------------------------------------------------------
+-- [E042] Type Error: tests/neg-custom-args/explain/i16601a.scala:1:27 -------------------------------------------------
 1 |@main def Test: Unit = new concurrent.ExecutionContext  // error
   |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |                           ExecutionContext is a trait; it cannot be instantiated
diff --git a/tests/neg-custom-args/i16601a.scala b/tests/neg-custom-args/explain/i16601a.scala
similarity index 100%
rename from tests/neg-custom-args/i16601a.scala
rename to tests/neg-custom-args/explain/i16601a.scala
diff --git a/tests/neg-custom-args/explain/labelNotFound.check b/tests/neg-custom-args/explain/labelNotFound.check
new file mode 100644
index 000000000000..594a838aeeed
--- /dev/null
+++ b/tests/neg-custom-args/explain/labelNotFound.check
@@ -0,0 +1,10 @@
+-- [E172] Type Error: tests/neg-custom-args/explain/labelNotFound.scala:2:30 -------------------------------------------
+2 |  scala.util.boundary.break(1) // error
+  |                              ^
+  |No given instance of type scala.util.boundary.Label[Int] was found for parameter label of method break in object boundary
+  |---------------------------------------------------------------------------------------------------------------------
+  | Explanation (enabled by `-explain`)
+  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  | A Label is generated from an enclosing `scala.util.boundary` call.
+  | Maybe that boundary is missing?
+   ---------------------------------------------------------------------------------------------------------------------
diff --git a/tests/neg-custom-args/explain/labelNotFound.scala b/tests/neg-custom-args/explain/labelNotFound.scala
new file mode 100644
index 000000000000..8eeaed90f331
--- /dev/null
+++ b/tests/neg-custom-args/explain/labelNotFound.scala
@@ -0,0 +1,4 @@
+object Test:
+  scala.util.boundary.break(1) // error
+
+
diff --git a/tests/neg-custom-args/hidden-type-errors.check b/tests/neg-custom-args/hidden-type-errors.check
deleted file mode 100644
index a373e409af2f..000000000000
--- a/tests/neg-custom-args/hidden-type-errors.check
+++ /dev/null
@@ -1,28 +0,0 @@
--- [E007] Type Mismatch Error: tests/neg-custom-args/hidden-type-errors/Test.scala:6:24 --------------------------------
-6 |   val x = X.doSomething("XXX") // error
-  |           ^^^^^^^^^^^^^^^^^^^^
-  |           Found:    String
-  |           Required: Int
-  | This location contains code that was inlined from Test.scala:6
-
-Explanation
-===========
-
-Tree: t12717.A.bar("XXX")
-
-I tried to show that
-  String
-conforms to
-  Int
-but the comparison trace ended with `false`:
-          
-  ==> String  <:  Int
-    ==> String  <:  Int (recurring)
-      ==> String  <:  Int (recurring)
-      <== String  <:  Int (recurring) = false
-    <== String  <:  Int (recurring) = false
-  <== String  <:  Int = false
-
-The tests were made under the empty constraint
-
-1 error found

From 14517886c7acbad688bb14b05fe98078d8c80edf Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sun, 12 Feb 2023 18:51:46 +0100
Subject: [PATCH 135/657] Try to be more subtle when inferring type parameters
 of class parents

The previous scheme was basically like this:

 1. If the parent type is an application, infer type parameters from the
   term parameters during completion of the class.
 2. If the parent type is an Ident or Select and it appears in an anonymous
   class, infer it from the expected type.

It could happen in the second case that we infer Nothing since an expected type
was missing, but if the parent type had been an application, we would have inferred
something else from implicit arguments to the parent constructor. This is a case
handled by Scala 2, but not yet by Dotty.

To deal with this we have to perform a complicated dance:

 - Try step (2) above, but back out if the inferred parent type has Nothing
   as a type argument.
 - During completion, if the inferred parent has missing type arguments, convert
   the parent type to an application with () arguments and try that instead.

I normally would have thought this is too much sophistry but there are valid
use cases that Scala 2 supports and it would be good if we get to parity for these.
---
 .../dotty/tools/dotc/typer/Inferencing.scala  |  9 ++---
 .../src/dotty/tools/dotc/typer/Namer.scala    | 36 +++++++++++++------
 .../src/dotty/tools/dotc/typer/Typer.scala    | 13 +++----
 tests/neg/i1643.scala                         |  4 +--
 tests/neg/i4820.scala                         |  2 --
 tests/neg/i4820b.scala                        |  5 ---
 tests/neg/i4820c.scala                        |  2 --
 tests/pos/i16778.scala                        | 22 ++++++++++++
 tests/pos/i4820.scala                         |  2 ++
 tests/pos/i4820b.scala                        |  5 +++
 10 files changed, 66 insertions(+), 34 deletions(-)
 delete mode 100644 tests/neg/i4820.scala
 delete mode 100644 tests/neg/i4820b.scala
 delete mode 100644 tests/neg/i4820c.scala
 create mode 100644 tests/pos/i16778.scala
 create mode 100644 tests/pos/i4820.scala
 create mode 100644 tests/pos/i4820b.scala

diff --git a/compiler/src/dotty/tools/dotc/typer/Inferencing.scala b/compiler/src/dotty/tools/dotc/typer/Inferencing.scala
index af4174423cbc..c31477d0270e 100644
--- a/compiler/src/dotty/tools/dotc/typer/Inferencing.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Inferencing.scala
@@ -307,16 +307,17 @@ object Inferencing {
   }
 
   /** 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 {
+  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
+      if isFullyDefined(tree1.tpe, force = ForceDegree.failBottom) then
+        tree1
+      else
+        EmptyTree
     case _ =>
       tree
-  }
 
   def isSkolemFree(tp: Type)(using Context): Boolean =
     !tp.existsPart(_.isInstanceOf[SkolemType])
diff --git a/compiler/src/dotty/tools/dotc/typer/Namer.scala b/compiler/src/dotty/tools/dotc/typer/Namer.scala
index 6f85efb0fc8a..af6673086339 100644
--- a/compiler/src/dotty/tools/dotc/typer/Namer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Namer.scala
@@ -1453,27 +1453,41 @@ class Namer { typer: Typer =>
        * 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 {
+
+        def typedParentApplication(parent: untpd.Tree): Type =
+          val (core, targs) = stripApply(parent) match
             case TypeApply(core, targs) => (core, targs)
             case core => (core, Nil)
-          }
-          core match {
+          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 {
+              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
-          }
-        }
+
+        def typedParentType(tree: untpd.Tree): tpd.Tree =
+          val parentTpt = typer.typedType(parent, AnyTypeConstructorProto)
+          val ptpe = parentTpt.tpe
+          if ptpe.typeParams.nonEmpty
+              && ptpe.underlyingClassRef(refinementOK = false).exists
+          then
+            // Try to infer type parameters from a synthetic application.
+            // This might yield new info if implicit parameters are resolved.
+            // A test case is i16778.scala.
+            val app = untpd.Apply(untpd.Select(untpd.New(parentTpt), nme.CONSTRUCTOR), Nil)
+            typedParentApplication(app)
+            app.getAttachment(TypedAhead).getOrElse(parentTpt)
+          else
+            parentTpt
+
+        if parent.isType then typedAhead(parent, typedParentType).tpe
+        else typedParentApplication(parent)
+      end parentType
 
       /** Check parent type tree `parent` for the following well-formedness conditions:
        *  (1) It must be a class type with a stable prefix (@see checkClassTypeWithStablePrefix)
@@ -1607,7 +1621,7 @@ class Namer { typer: Typer =>
       case Some(ttree) => ttree
       case none =>
         val ttree = typed(tree)
-        xtree.putAttachment(TypedAhead, ttree)
+        if !ttree.isEmpty then xtree.putAttachment(TypedAhead, ttree)
         ttree
     }
   }
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index a87d6dd7e703..5752409c51c1 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -843,14 +843,11 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
             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)
+        for case parent: RefTree <- templ1.parents do
+          typedAhead(parent, tree => inferTypeParams(typedType(tree), pt))
+        val anon = tpnme.ANON_CLASS
+        val clsDef = TypeDef(anon, templ1).withFlags(Final | Synthetic)
+        typed(cpy.Block(tree)(clsDef :: Nil, New(Ident(anon), Nil)), pt)
       case _ =>
         var tpt1 = typedType(tree.tpt)
         val tsym = tpt1.tpe.underlyingClassRef(refinementOK = false).typeSymbol
diff --git a/tests/neg/i1643.scala b/tests/neg/i1643.scala
index a10422de6eab..1745539d73f5 100644
--- a/tests/neg/i1643.scala
+++ b/tests/neg/i1643.scala
@@ -1,4 +1,4 @@
-trait T extends Array { // error // error
+trait T extends Array { // error
   def t1(as: String*): Array[String] = { varargs1(as*) } // error
   def t2(as: String*): Array[String] = { super.varargs1(as*) } // error
 }
@@ -7,7 +7,7 @@ class C extends Base_1 { // error
   def c2(as: String*): Array[String] = { super.varargs1(as*) } // error
 }
 object Test extends App {
-  val t = new T {}  // error
+  val t = new T {}
   println(t.t1("a", "b").mkString(","))
   println(t.t2("a", "b").mkString(","))
   val c = new C {}
diff --git a/tests/neg/i4820.scala b/tests/neg/i4820.scala
deleted file mode 100644
index e19183b17b14..000000000000
--- a/tests/neg/i4820.scala
+++ /dev/null
@@ -1,2 +0,0 @@
-class Foo[A]
-class Bar[A] extends Foo  // error
diff --git a/tests/neg/i4820b.scala b/tests/neg/i4820b.scala
deleted file mode 100644
index 4a7b3da3fb1b..000000000000
--- a/tests/neg/i4820b.scala
+++ /dev/null
@@ -1,5 +0,0 @@
-trait SetOps[A, +C <: SetOps[A, C]]  {
-  def concat(that: Iterable[A]): C = ???
-}
-
-class Set1[A] extends SetOps // error: should be SetOps[A, Set1[A]]
diff --git a/tests/neg/i4820c.scala b/tests/neg/i4820c.scala
deleted file mode 100644
index 6956b23363b5..000000000000
--- a/tests/neg/i4820c.scala
+++ /dev/null
@@ -1,2 +0,0 @@
-trait Foo[A]
-class Bar[A] extends Foo // error
\ No newline at end of file
diff --git a/tests/pos/i16778.scala b/tests/pos/i16778.scala
new file mode 100644
index 000000000000..426f3c86c0bd
--- /dev/null
+++ b/tests/pos/i16778.scala
@@ -0,0 +1,22 @@
+final abstract class ForcedRecompilationToken[T]
+
+object ForcedRecompilationToken {
+  implicit def materialize: ForcedRecompilationToken["x"] = null.asInstanceOf[ForcedRecompilationToken["x"]]
+}
+
+class PluginDef[T](implicit val recompilationToken: ForcedRecompilationToken[T])
+
+object X {
+  val no = {
+    final class anon extends PluginDef {} // was: missing type parameters
+    new anon
+  }
+
+  val bad = new PluginDef {} // was: No given instance
+  val good = new PluginDef() {} // ok
+}
+
+object DependingPlugin {
+  class NestedDoublePlugin extends PluginDef
+  object NestedDoublePlugin extends PluginDef
+}
diff --git a/tests/pos/i4820.scala b/tests/pos/i4820.scala
new file mode 100644
index 000000000000..8d368d150a00
--- /dev/null
+++ b/tests/pos/i4820.scala
@@ -0,0 +1,2 @@
+class Foo[A]
+class Bar[A] extends Foo  // was error, now expanded to Foo[Nothing]
diff --git a/tests/pos/i4820b.scala b/tests/pos/i4820b.scala
new file mode 100644
index 000000000000..a1c7d54f0c76
--- /dev/null
+++ b/tests/pos/i4820b.scala
@@ -0,0 +1,5 @@
+trait SetOps[A, +C <: SetOps[A, C]]  {
+  def concat(that: Iterable[A]): C = ???
+}
+
+class Set1[A] extends SetOps // ideally should be SetOps[A, Set1[A]], but SetOps[Nothing, Nothin] is inferred

From 79bad18adb6aad1c4cff1f105c63d24ade73fa4f Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sun, 12 Feb 2023 19:37:51 +0100
Subject: [PATCH 136/657] Fix repl test

---
 compiler/test-resources/repl/i7644 | 13 +++----------
 1 file changed, 3 insertions(+), 10 deletions(-)

diff --git a/compiler/test-resources/repl/i7644 b/compiler/test-resources/repl/i7644
index 8ceaf8b00804..786823073470 100644
--- a/compiler/test-resources/repl/i7644
+++ b/compiler/test-resources/repl/i7644
@@ -5,11 +5,7 @@ scala> class T extends CanEqual
   |       Cannot extend sealed trait CanEqual in a different source file
   |
   | longer explanation available when compiling with `-explain`
--- [E056] Syntax Error: --------------------------------------------------------
-1 | class T extends CanEqual
-  |                 ^^^^^^^^
-  |                 Missing type parameter for CanEqual
-2 errors found
+1 error found
 scala> class T extends CanEqual
 -- [E112] Syntax Error: --------------------------------------------------------
 1 | class T extends CanEqual
@@ -17,8 +13,5 @@ scala> class T extends CanEqual
   |       Cannot extend sealed trait CanEqual in a different source file
   |
   | longer explanation available when compiling with `-explain`
--- [E056] Syntax Error: --------------------------------------------------------
-1 | class T extends CanEqual
-  |                 ^^^^^^^^
-  |                 Missing type parameter for CanEqual
-2 errors found
+1 error found
+

From 2d641ecc48120faf03c9ad0dbc73c637fc8dad5a Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Fri, 3 Feb 2023 13:55:56 +0000
Subject: [PATCH 137/657] Patmat: Use less type variables in prefix inference

In code like:

    class Outer:
      sealed trait Foo
      case class Bar() extends Foo

      def mat(foo: Foo) = foo match
        case Bar() =>

When in the course of decomposing the scrutinee's type, which is
`Outer.this.Foo`, we're trying to instantiate subclass `Outer.this.Bar`,
the `Outer.this` is fixed - it needn't be inferred, via type variables
and type bounds.  Cutting down on type variables, particularly when GADT
symbols are also present, can really speed up the operation, including
making code that used to hang forever compile speedily.
---
 .../src/dotty/tools/dotc/core/TypeOps.scala   | 53 +++++++++++++------
 tests/patmat/i12408.check                     |  2 +-
 tests/pos/i16785.scala                        | 11 ++++
 3 files changed, 50 insertions(+), 16 deletions(-)
 create mode 100644 tests/pos/i16785.scala

diff --git a/compiler/src/dotty/tools/dotc/core/TypeOps.scala b/compiler/src/dotty/tools/dotc/core/TypeOps.scala
index d9da11c561e8..c91412988e82 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeOps.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeOps.scala
@@ -2,7 +2,7 @@ package dotty.tools
 package dotc
 package core
 
-import Contexts._, Types._, Symbols._, Names._, Flags._
+import Contexts._, Types._, Symbols._, Names._, NameKinds.*, Flags._
 import SymDenotations._
 import util.Spans._
 import util.Stats
@@ -839,24 +839,51 @@ object TypeOps:
       }
     }
 
-    // Prefix inference, replace `p.C.this.Child` with `X.Child` where `X <: p.C`
-    // Note: we need to strip ThisType in `p` recursively.
+    /** Gather GADT symbols and `ThisType`s found in `tp2`, ie. the scrutinee. */
+    object TraverseTp2 extends TypeTraverser:
+      val thisTypes = util.HashSet[ThisType]()
+      val gadtSyms  = new mutable.ListBuffer[Symbol]
+
+      def traverse(tp: Type) = {
+        val tpd = tp.dealias
+        if tpd ne tp then traverse(tpd)
+        else tp match
+          case tp: ThisType if !tp.tref.symbol.isStaticOwner && !thisTypes.contains(tp) =>
+            thisTypes += tp
+            traverseChildren(tp.tref)
+          case tp: TypeRef if tp.symbol.isAbstractOrParamType =>
+            gadtSyms += tp.symbol
+            traverseChildren(tp)
+          case _ =>
+            traverseChildren(tp)
+      }
+    TraverseTp2.traverse(tp2)
+    val thisTypes = TraverseTp2.thisTypes
+    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
+    // 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 ThisType(tref: TypeRef) if !tref.symbol.isStaticOwner =>
+        case tp @ ThisType(tref) if !tref.symbol.isStaticOwner =>
           val symbol = tref.symbol
-          if (symbol.is(Module))
+          if thisTypes.contains(tp) then
+            prefixTVar = tp // 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)
           else {
             prefixTVar = WildcardType  // prevent recursive call from assigning it
-            val tvars = tref.typeParams.map { tparam => newTypeVar(tparam.paramInfo.bounds) }
+            // 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))
+            prefixTVar = newTypeVar(TypeBounds.upper(tref2), DepParamName.fresh(tref.name))
             prefixTVar.uncheckedNN
           }
         case tp => mapOver(tp)
@@ -864,15 +891,11 @@ object TypeOps:
     }
 
     val inferThisMap = new InferPrefixMap
-    val tvars = tp1.typeParams.map { tparam => newTypeVar(tparam.paramInfo.bounds) }
+    val tvars = tp1.typeParams.map { tparam => newTypeVar(tparam.paramInfo.bounds, DepParamName.fresh(tparam.paramName)) }
     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.gadtState.addToConstraint(syms2)
+    if gadtSyms.nonEmpty then
+      ctx.gadtState.addToConstraint(gadtSyms)
 
     // If parent contains a reference to an abstract type, then we should
     // refine subtype checking to eliminate abstract types according to
diff --git a/tests/patmat/i12408.check b/tests/patmat/i12408.check
index ada7b8c21fa8..60acc2cba84e 100644
--- a/tests/patmat/i12408.check
+++ b/tests/patmat/i12408.check
@@ -1,2 +1,2 @@
-13: Pattern Match Exhaustivity: X[<?>] & (X.this : X[T]).A(_), X[<?>] & (X.this : X[T]).C(_)
+13: Pattern Match Exhaustivity: A(_), C(_)
 21: Pattern Match
diff --git a/tests/pos/i16785.scala b/tests/pos/i16785.scala
new file mode 100644
index 000000000000..1cfabf5a4312
--- /dev/null
+++ b/tests/pos/i16785.scala
@@ -0,0 +1,11 @@
+class VarImpl[Lbl, A]
+
+class Outer[|*|[_, _], Lbl1]:
+  type Var[A1] = VarImpl[Lbl1, A1]
+
+  sealed trait Foo[G]
+  case class Bar[T, U]()
+    extends Foo[Var[T] |*| Var[U]]
+
+  def go[X](scr: Foo[Var[X]]): Unit = scr match // was: compile hang
+    case Bar() => ()

From ea87c0895c258419218938bf4ac9d811dc051cae Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Mon, 13 Feb 2023 11:29:12 +0100
Subject: [PATCH 138/657] Tweak withDenot for overloaded denotations

When creating a NamedType with a given overloaded denotation, make sure that
the type has a Name as designator. This prevents accidentally overwriting a more
precise symbolic TermRef that refers to one specific alternative of the denotation.

This might be enough to fix #16884.

It would be great if we could maintain the general invariant that NamedTypes with
overloaded denotations always have names as designators. But that looks very hard
when we take into account that we need to update named types to new runs.
A type might have a single denotation in one round and an overloaded one in the
next.
---
 .../src/dotty/tools/dotc/core/Types.scala     | 21 +++++++++++++------
 1 file changed, 15 insertions(+), 6 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index d2fc225ff19d..0908574b0308 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -2644,8 +2644,12 @@ object Types {
       }
 
     /** 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]
+    private def withSym(sym: Symbol)(using Context): ThisType =
+      if designator ne sym then NamedType(prefix, sym).asInstanceOf[ThisType]
+      else this
+
+    private def withName(name: Name)(using Context): ThisType =
+      if designator ne name then NamedType(prefix, name).asInstanceOf[ThisType]
       else this
 
     /** A reference like this one, but with the given denotation, if it exists.
@@ -2656,6 +2660,8 @@ object Types {
      *      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
+     *  Returns a new named type with a name as designator if the denotation is
+     *  overloaded and the name is different from the current designator.
      *  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
@@ -2669,13 +2675,16 @@ object Types {
      */
     final def withDenot(denot: Denotation)(using Context): ThisType =
       if denot.exists then
-        val adapted = withSym(denot.symbol)
+        val adapted =
+          if denot.symbol.exists then withSym(denot.symbol)
+          else if denot.isOverloaded then withName(denot.name)
+          else this
         val result =
-          if (adapted.eq(this)
+          if adapted.eq(this)
               || designator.isInstanceOf[Symbol]
               || !adapted.denotationIsCurrent
-              || adapted.info.eq(denot.info))
-            adapted
+              || adapted.info.eq(denot.info)
+          then adapted
           else this
         val lastDenot = result.lastDenotation
         denot match

From 00d3079f63bc226967294f148b4609e036739aba Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Thu, 9 Feb 2023 10:18:19 +0100
Subject: [PATCH 139/657] Add regression test

Fixes #15475
---
 tests/pos-macros/i15475.scala          | 13 +++++++++++++
 tests/pos-macros/i15475a/Macro_1.scala | 17 +++++++++++++++++
 tests/pos-macros/i15475a/Test_2.scala  | 15 +++++++++++++++
 3 files changed, 45 insertions(+)
 create mode 100644 tests/pos-macros/i15475.scala
 create mode 100644 tests/pos-macros/i15475a/Macro_1.scala
 create mode 100644 tests/pos-macros/i15475a/Test_2.scala

diff --git a/tests/pos-macros/i15475.scala b/tests/pos-macros/i15475.scala
new file mode 100644
index 000000000000..20993cd46d15
--- /dev/null
+++ b/tests/pos-macros/i15475.scala
@@ -0,0 +1,13 @@
+def test =
+  transform {
+    val a: Seq[Generic[?]] = ???
+    a.foreach { to =>
+      to.mthd()
+    }
+  }
+
+transparent inline def transform[T](expr: T): T = ???
+
+trait Generic[+T] {
+  def mthd(): Generic[T] = ???
+}
diff --git a/tests/pos-macros/i15475a/Macro_1.scala b/tests/pos-macros/i15475a/Macro_1.scala
new file mode 100644
index 000000000000..b1bd676e7e17
--- /dev/null
+++ b/tests/pos-macros/i15475a/Macro_1.scala
@@ -0,0 +1,17 @@
+package x
+
+import scala.quoted.*
+
+
+transparent inline def xtransform[T](inline expr:T) = ${
+   X.transform('expr)
+}
+
+object X {
+
+   def transform[T:Type](x: Expr[T])(using Quotes):Expr[T] = {
+      import quotes.reflect.*
+      x
+   }
+
+}
diff --git a/tests/pos-macros/i15475a/Test_2.scala b/tests/pos-macros/i15475a/Test_2.scala
new file mode 100644
index 000000000000..7757a14950de
--- /dev/null
+++ b/tests/pos-macros/i15475a/Test_2.scala
@@ -0,0 +1,15 @@
+package x
+
+def hello = {
+  xtransform {
+    val a: Seq[Generic[?]] = null
+    a
+      .foreach { to =>
+        to.mthd()
+      }
+  }
+}
+
+trait Generic[+T] {
+  def mthd(): Generic[T] = this
+}

From 5c69746d771463924d5a7c0d10393f817865a238 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Marks?= <pmarks@virtuslab.com>
Date: Mon, 13 Feb 2023 17:00:03 +0100
Subject: [PATCH 140/657] Run CI on merge queue

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

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 46a4e6064d07..27314d188df7 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -15,6 +15,7 @@ on:
     ## - or neither of them.
     ## But it's important to not have only one or the other.
   pull_request:
+  merge_group:
   schedule:
     - cron: '0 3 * * *'  # Every day at 3 AM
   workflow_dispatch:

From 46e82dd4bb32faa65c5d85c1f10b91eaca9256eb Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Mon, 13 Feb 2023 17:37:56 +0100
Subject: [PATCH 141/657] Refine infoDependsOnPrefix

Make infoDependsOnPrefix return true even if the prefix is
the ThisType of the enclosing class, in case that class has a selftype
which refines the binding of an abstract type.

This allows to implement withDenot without overwriting a NamedType's state.
---
 .../src/dotty/tools/dotc/core/Types.scala     | 69 ++++++++++---------
 .../dotty/tools/dotc/reporting/messages.scala |  2 +-
 .../test/dotc/pos-test-pickling.blacklist     |  1 +
 3 files changed, 39 insertions(+), 33 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index 0908574b0308..5c16ef05f48f 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -2501,10 +2501,36 @@ object Types {
 
     /** A reference with the initial symbol in `symd` has an info that
      *  might depend on the given prefix.
+     *  Note: If T is an abstract type in trait or class C, its info depends
+     *  even on C.this if class C has a self type that refines the info of T.
+     *  Currently, "refines" means an actual refinement type that constrains the
+     *  name `T`. We should try to extend that also to other classes that introduce
+     *  a new bining for `T`. Furthermore, we should also treat term members
+     *  in this way.
      */
     private def infoDependsOnPrefix(symd: SymDenotation, prefix: Type)(using Context): Boolean =
+
+      def refines(tp: Type, name: Name): Boolean = tp match
+        case AndType(tp1, tp2) => refines(tp1, name) || refines(tp2, name)
+        case RefinedType(parent, rname, _) => rname == name || refines(parent, name)
+        case tp: RecType => refines(tp.parent, name)
+        case _ => false
+
+      def givenSelfTypeOrCompleter(cls: Symbol) = cls.infoOrCompleter match
+        case cinfo: ClassInfo =>
+          cinfo.selfInfo match
+            case sym: Symbol => sym.infoOrCompleter
+            case tpe: Type => tpe
+        case _ => NoType
+
       symd.maybeOwner.membersNeedAsSeenFrom(prefix) && !symd.is(NonMember)
-      || prefix.isInstanceOf[Types.ThisType] && symd.is(Opaque) // see pos/i11277.scala for a test where this matters
+      || prefix.match
+        case prefix: Types.ThisType =>
+          symd.isAbstractType
+          && prefix.sameThis(symd.maybeOwner.thisType)
+          && refines(givenSelfTypeOrCompleter(prefix.cls), symd.name)
+        case _ => false
+    end infoDependsOnPrefix
 
     /** Is this a reference to a class or object member with an info that might depend
      *  on the prefix?
@@ -2653,25 +2679,11 @@ object Types {
       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
-     *  Returns a new named type with a name as designator if the denotation is
-     *  overloaded and the name is different from the current designator.
-     *  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.
+     *  Returns a new named type with the denotation's symbol as designator
+     *  if that symbol exists and it is different from the current designator.
+     *  Returns a new named type with the denotations's name as designator
+     *  if the denotation is overloaded and its name is different from the
+     *  current designator.
      */
     final def withDenot(denot: Denotation)(using Context): ThisType =
       if denot.exists then
@@ -2679,14 +2691,7 @@ object Types {
           if denot.symbol.exists then withSym(denot.symbol)
           else if denot.isOverloaded then withName(denot.name)
           else this
-        val result =
-          if adapted.eq(this)
-              || designator.isInstanceOf[Symbol]
-              || !adapted.denotationIsCurrent
-              || adapted.info.eq(denot.info)
-          then adapted
-          else this
-        val lastDenot = result.lastDenotation
+        val lastDenot = adapted.lastDenotation
         denot match
           case denot: SymDenotation
           if denot.validFor.firstPhaseId < ctx.phase.id
@@ -2696,15 +2701,15 @@ object Types {
             // 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(
+            core.println(i"overwrite ${adapted.toString} / ${adapted.lastDenotation}, ${adapted.lastDenotation.getClass} with $denot at ${ctx.phaseId}")
+            adapted.setDenot(
               UniqueRefDenotation(
                 denot.symbol, denot.info,
                 Period(ctx.runId, ctx.phaseId, denot.validFor.lastPhaseId),
                 this.prefix))
           case _ =>
-            result.setDenot(denot)
-        result.asInstanceOf[ThisType]
+            adapted.setDenot(denot)
+        adapted.asInstanceOf[ThisType]
       else // don't assign NoDenotation, we might need to recover later. Test case is pos/avoid.scala.
         this
 
diff --git a/compiler/src/dotty/tools/dotc/reporting/messages.scala b/compiler/src/dotty/tools/dotc/reporting/messages.scala
index f41d34b8c17c..d7920e1f1b36 100644
--- a/compiler/src/dotty/tools/dotc/reporting/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/messages.scala
@@ -245,7 +245,7 @@ extends NotFoundMsg(MissingIdentID) {
   }
 }
 
-class TypeMismatch(found: Type,  expected: Type, inTree: Option[untpd.Tree],  addenda: => String*)(using Context)
+class TypeMismatch(found: Type, expected: Type, inTree: Option[untpd.Tree], addenda: => String*)(using Context)
   extends TypeMismatchMsg(found, expected)(TypeMismatchID):
 
   def msg(using Context) =
diff --git a/compiler/test/dotc/pos-test-pickling.blacklist b/compiler/test/dotc/pos-test-pickling.blacklist
index cdbad2160f2a..5f7221ee0ce9 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
+t5031_2.scala
 
 # Tree is huge and blows stack for printing Text
 i7034.scala

From c830ad26733a633a6d58b93e9bd66ff7b67b65ed Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Mon, 13 Feb 2023 17:51:53 +0100
Subject: [PATCH 142/657] Also consider bindings in classes when computing
 "refines"

---
 compiler/src/dotty/tools/dotc/core/Types.scala | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index 5c16ef05f48f..dc5165e7ad7c 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -2503,17 +2503,17 @@ object Types {
      *  might depend on the given prefix.
      *  Note: If T is an abstract type in trait or class C, its info depends
      *  even on C.this if class C has a self type that refines the info of T.
-     *  Currently, "refines" means an actual refinement type that constrains the
-     *  name `T`. We should try to extend that also to other classes that introduce
-     *  a new bining for `T`. Furthermore, we should also treat term members
-     *  in this way.
+     *  We should also treat term members in this way.
      */
     private def infoDependsOnPrefix(symd: SymDenotation, prefix: Type)(using Context): Boolean =
 
       def refines(tp: Type, name: Name): Boolean = tp match
         case AndType(tp1, tp2) => refines(tp1, name) || refines(tp2, name)
         case RefinedType(parent, rname, _) => rname == name || refines(parent, name)
-        case tp: RecType => refines(tp.parent, name)
+        case tp: ClassInfo =>
+          val other = tp.cls.infoOrCompleter.nonPrivateMember(name)
+          other.exists && other.symbol != symd.symbol
+        case tp: TypeProxy => refines(tp.underlying, name)
         case _ => false
 
       def givenSelfTypeOrCompleter(cls: Symbol) = cls.infoOrCompleter match

From 5a8e53e06376a60fb55ada66aab9e23a971c5cf0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Marks?= <pmarks@virtuslab.com>
Date: Mon, 13 Feb 2023 19:13:12 +0100
Subject: [PATCH 143/657] Run CI on merge queue

---
 .github/workflows/ci.yaml | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index 27314d188df7..b70cc3bb9e70 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -98,6 +98,7 @@ jobs:
         - ${{ github.workspace }}/../../cache/general:/root/.cache
     if: "github.event_name == 'schedule' && github.repository == 'lampepfl/dotty'
          || github.event_name == 'push'
+         || github.event_name == 'merge_group'
          || (
            github.event_name == 'pull_request'
            && !contains(github.event.pull_request.body, '[skip ci]')
@@ -143,6 +144,7 @@ jobs:
            github.event_name == 'push'
            && github.ref != 'refs/heads/main'
          )
+         || github.event_name == 'merge_group'
          || (
            github.event_name == 'pull_request'
            && !contains(github.event.pull_request.body, '[skip ci]')
@@ -219,6 +221,7 @@ jobs:
         - ${{ github.workspace }}/../../cache/general:/root/.cache
     if: "github.event_name == 'schedule' && github.repository == 'lampepfl/dotty'
          || github.event_name == 'push'
+         || github.event_name == 'merge_group'
          || (
            github.event_name == 'pull_request'
            && !contains(github.event.pull_request.body, '[skip ci]')
@@ -259,6 +262,7 @@ jobs:
         - ${{ github.workspace }}/../../cache/general:/root/.cache
     if: "github.event_name == 'schedule' && github.repository == 'lampepfl/dotty'
          || github.event_name == 'push'
+         || github.event_name == 'merge_group'
          || (
            github.event_name == 'pull_request'
            && !contains(github.event.pull_request.body, '[skip ci]')
@@ -307,6 +311,7 @@ jobs:
         - ${{ github.workspace }}/../../cache/general:/root/.cache
     if: "github.event_name == 'schedule' && github.repository == 'lampepfl/dotty'
          || github.event_name == 'push'
+         || github.event_name == 'merge_group'
          || (
            github.event_name == 'pull_request'
            && !contains(github.event.pull_request.body, '[skip ci]')
@@ -355,6 +360,7 @@ jobs:
         - ${{ github.workspace }}/../../cache/general:/root/.cache
     if: "github.event_name == 'schedule' && github.repository == 'lampepfl/dotty'
          || github.event_name == 'push'
+         || github.event_name == 'merge_group'
          || (
            github.event_name == 'pull_request'
            && !contains(github.event.pull_request.body, '[skip ci]')

From 8d65f197de88e46bcfe7627c06e5d06792decb8e Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Mon, 13 Feb 2023 19:25:25 +0100
Subject: [PATCH 144/657] Also consider non-final term members with self type
 refinements

Also consider non-final term members with self type refinements for infoDependsOnPrefix
---
 .../src/dotty/tools/dotc/core/Types.scala     | 27 ++++++++++++-------
 1 file changed, 17 insertions(+), 10 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index dc5165e7ad7c..5ef6dbd39335 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -2501,20 +2501,24 @@ object Types {
 
     /** A reference with the initial symbol in `symd` has an info that
      *  might depend on the given prefix.
-     *  Note: If T is an abstract type in trait or class C, its info depends
-     *  even on C.this if class C has a self type that refines the info of T.
-     *  We should also treat term members in this way.
+     *  Note: If M is an abstract type or non-final term member in trait or class C,
+     *  its info depends even on C.this if class C has a self type that refines
+     *  the info of M.
      */
     private def infoDependsOnPrefix(symd: SymDenotation, prefix: Type)(using Context): Boolean =
 
       def refines(tp: Type, name: Name): Boolean = tp match
-        case AndType(tp1, tp2) => refines(tp1, name) || refines(tp2, name)
-        case RefinedType(parent, rname, _) => rname == name || refines(parent, name)
+        case AndType(tp1, tp2) =>
+          refines(tp1, name) || refines(tp2, name)
+        case RefinedType(parent, rname, _) =>
+          rname == name || refines(parent, name)
         case tp: ClassInfo =>
-          val other = tp.cls.infoOrCompleter.nonPrivateMember(name)
-          other.exists && other.symbol != symd.symbol
-        case tp: TypeProxy => refines(tp.underlying, name)
-        case _ => false
+          val otherd = tp.cls.nonPrivateMembersNamed(name)
+          otherd.exists && !otherd.containsSym(symd.symbol)
+        case tp: TypeProxy =>
+          refines(tp.underlying, name)
+        case _ =>
+          false
 
       def givenSelfTypeOrCompleter(cls: Symbol) = cls.infoOrCompleter match
         case cinfo: ClassInfo =>
@@ -2526,7 +2530,10 @@ object Types {
       symd.maybeOwner.membersNeedAsSeenFrom(prefix) && !symd.is(NonMember)
       || prefix.match
         case prefix: Types.ThisType =>
-          symd.isAbstractType
+          (symd.isAbstractType
+            || symd.isTerm
+                && !symd.flagsUNSAFE.isOneOf(Module | Final | Param)
+                && !symd.maybeOwner.isEffectivelyFinal)
           && prefix.sameThis(symd.maybeOwner.thisType)
           && refines(givenSelfTypeOrCompleter(prefix.cls), symd.name)
         case _ => false

From 1389bb86df39abf9dbe88a568aee4fd538128cf2 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Mon, 13 Feb 2023 22:23:12 +0000
Subject: [PATCH 145/657] Avoid bidirectional GADT typebounds from fullBounds

---
 .../tools/dotc/core/GadtConstraint.scala      | 22 +++++++-
 .../src/dotty/tools/dotc/typer/Typer.scala    |  2 +-
 tests/pos/i14287.min.scala                    |  7 +++
 tests/pos/i14287.scala                        | 16 ++++++
 tests/pos/i15523.avoid.scala                  |  8 +++
 tests/pos/i15523.scala                        |  7 +++
 tests/pos/i16777.scala                        | 52 +++++++++++++++++++
 7 files changed, 111 insertions(+), 3 deletions(-)
 create mode 100644 tests/pos/i14287.min.scala
 create mode 100644 tests/pos/i14287.scala
 create mode 100644 tests/pos/i15523.avoid.scala
 create mode 100644 tests/pos/i15523.scala
 create mode 100644 tests/pos/i16777.scala

diff --git a/compiler/src/dotty/tools/dotc/core/GadtConstraint.scala b/compiler/src/dotty/tools/dotc/core/GadtConstraint.scala
index a863a982a44d..211c8e637b1f 100644
--- a/compiler/src/dotty/tools/dotc/core/GadtConstraint.scala
+++ b/compiler/src/dotty/tools/dotc/core/GadtConstraint.scala
@@ -71,12 +71,26 @@ class GadtConstraint private (
     externalize(constraint.nonParamBounds(param)).bounds
 
   def fullLowerBound(param: TypeParamRef)(using Context): Type =
-    constraint.minLower(param).foldLeft(nonParamBounds(param).lo) {
+    val self = externalize(param)
+    constraint.minLower(param).filterNot { p =>
+      val sym = paramSymbol(p)
+      sym.name.is(NameKinds.UniqueName) && {
+        val hi = sym.info.hiBound
+        !hi.isExactlyAny && self <:< hi
+      }
+    }.foldLeft(nonParamBounds(param).lo) {
       (t, u) => t | externalize(u)
     }
 
   def fullUpperBound(param: TypeParamRef)(using Context): Type =
-    constraint.minUpper(param).foldLeft(nonParamBounds(param).hi) { (t, u) =>
+    val self = externalize(param)
+    constraint.minUpper(param).filterNot { p =>
+      val sym = paramSymbol(p)
+      sym.name.is(NameKinds.UniqueName) && {
+        val lo = sym.info.loBound
+        !lo.isExactlyNothing && lo <:< self
+      }
+    }.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
@@ -96,6 +110,10 @@ class GadtConstraint private (
   def tvarOrError(sym: Symbol)(using Context): TypeVar =
     mapping(sym).ensuring(_ != null, i"not a constrainable symbol: $sym").uncheckedNN
 
+  private def paramSymbol(p: TypeParamRef): Symbol = reverseMapping(p) match
+    case sym: Symbol => sym
+    case null        => NoSymbol
+
   @tailrec final def stripInternalTypeVar(tp: Type): Type = tp match
     case tv: TypeVar =>
       val inst = constraint.instType(tv)
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index a87d6dd7e703..328039fd8a41 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -1765,7 +1765,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           else report.error(new DuplicateBind(b, cdef), b.srcPos)
           if (!ctx.isAfterTyper) {
             val bounds = ctx.gadt.fullBounds(sym)
-            if (bounds != null) sym.info = bounds
+            if (bounds != null) sym.info = checkNonCyclic(sym, bounds, reportErrors = true)
           }
           b
         case t: UnApply if t.symbol.is(Inline) => Inlines.inlinedUnapply(t)
diff --git a/tests/pos/i14287.min.scala b/tests/pos/i14287.min.scala
new file mode 100644
index 000000000000..8f7773ab0ac8
--- /dev/null
+++ b/tests/pos/i14287.min.scala
@@ -0,0 +1,7 @@
+enum Foo[+F[_]]:
+  case Bar[B[_]](value: Foo[B]) extends Foo[B]
+
+class Test:
+  def test[X[_]](foo: Foo[X]): Foo[X] = foo match
+    case Foo.Bar(Foo.Bar(x)) => Foo.Bar(x)
+    case _                   => foo
diff --git a/tests/pos/i14287.scala b/tests/pos/i14287.scala
new file mode 100644
index 000000000000..1291dc8adefc
--- /dev/null
+++ b/tests/pos/i14287.scala
@@ -0,0 +1,16 @@
+// scalac: -Yno-deep-subtypes
+enum Free[+F[_], A]:
+  case Return(a: A)
+  case Suspend(s: F[A])
+  case FlatMap[F[_], A, B](
+    s: Free[F, A],
+    f: A => Free[F, B]) extends Free[F, B]
+
+  def flatMap[F2[x] >: F[x], B](f: A => Free[F2,B]): Free[F2,B] =
+    FlatMap(this, f)
+
+  @scala.annotation.tailrec
+  final def step: Free[F, A] = this match
+    case FlatMap(FlatMap(fx, f), g) => fx.flatMap(x => f(x).flatMap(y => g(y))).step
+    case FlatMap(Return(x), f) => f(x).step
+    case _ => this
diff --git a/tests/pos/i15523.avoid.scala b/tests/pos/i15523.avoid.scala
new file mode 100644
index 000000000000..afbfc1a69d60
--- /dev/null
+++ b/tests/pos/i15523.avoid.scala
@@ -0,0 +1,8 @@
+// scalac: -Werror
+// like the original, but with a case body `a`
+// which caused type avoidance to infinitely recurse
+sealed trait Parent
+final case class Leaf[A, B >: A](a: A, b: B) extends Parent
+
+def run(x: Parent) = x match
+  case Leaf(a, _) => a
diff --git a/tests/pos/i15523.scala b/tests/pos/i15523.scala
new file mode 100644
index 000000000000..cf63613c29ac
--- /dev/null
+++ b/tests/pos/i15523.scala
@@ -0,0 +1,7 @@
+// scalac: -Werror
+sealed trait Parent
+final case class Leaf[A, B >: A](a: A, b: B) extends Parent
+
+def run(x: Parent): Unit = x match {
+  case Leaf(a, b) =>
+}
diff --git a/tests/pos/i16777.scala b/tests/pos/i16777.scala
new file mode 100644
index 000000000000..4218aea29d9f
--- /dev/null
+++ b/tests/pos/i16777.scala
@@ -0,0 +1,52 @@
+// scalac: -Ykind-projector:underscores
+
+sealed abstract class Free[+S[_, _], +E, +A] {
+  @inline final def flatMap[S1[e, a] >: S[e, a], B, E1 >: E](fun: A => Free[S1, E1, B]): Free[S1, E1, B] = Free.FlatMapped[S1, E, E1, A, B](this, fun)
+  @inline final def map[B](fun: A => B): Free[S, E, B] = flatMap(a => Free.pure[S, B](fun(a)))
+  @inline final def as[B](as: => B): Free[S, E, B] = map(_ => as)
+  @inline final def *>[S1[e, a] >: S[e, a], B, E1 >: E](sc: Free[S1, E1, B]): Free[S1, E1, B] = flatMap(_ => sc)
+  @inline final def <*[S1[e, a] >: S[e, a], B, E1 >: E](sc: Free[S1, E1, B]): Free[S1, E1, A] = flatMap(r => sc.as(r))
+
+  @inline final def void: Free[S, E, Unit] = map(_ => ())
+
+  // FIXME: Scala 3.1.4 bug: false unexhaustive match warning
+  /// @nowarn("msg=pattern case: Free.FlatMapped")
+  @inline final def foldMap[S1[e, a] >: S[e, a], G[+_, +_]](transform: S1 ~>> G)(implicit G: Monad2[G]): G[E, A] = {
+    this match {
+      case Free.Pure(a) => G.pure(a)
+      case Free.Suspend(a) => transform.apply(a)
+      case Free.FlatMapped(sub, cont) =>
+        sub match {
+          case Free.FlatMapped(sub2, cont2) => sub2.flatMap(a => cont2(a).flatMap(cont)).foldMap(transform)
+          case another => G.flatMap(another.foldMap(transform))(cont(_).foldMap(transform))
+        }
+    }
+  }
+}
+
+trait ~>>[-F[_, _], +G[_, _]] {
+  def apply[E, A](f: F[E, A]): G[E, A]
+}
+
+object Free {
+  @inline def pure[S[_, _], A](a: A): Free[S, Nothing, A] = Pure(a)
+  @inline def lift[S[_, _], E, A](s: S[E, A]): Free[S, E, A] = Suspend(s)
+
+  final case class Pure[S[_, _], A](a: A) extends Free[S, Nothing, A] {
+    override def toString: String = s"Pure:[$a]"
+  }
+  final case class Suspend[S[_, _], E, A](a: S[E, A]) extends Free[S, E, A] {
+    override def toString: String = s"Suspend:[$a]"
+  }
+  final case class FlatMapped[S[_, _], E, E1 >: E, A, B](sub: Free[S, E, A], cont: A => Free[S, E1, B]) extends Free[S, E1, B] {
+    override def toString: String = s"FlatMapped:[sub=$sub]"
+  }
+}
+
+type Monad2[F[+_, +_]] = Monad3[λ[(`-R`, `+E`, `+A`) => F[E, A]]]
+
+trait Monad3[F[-_, +_, +_]] {
+  def flatMap[R, E, A, B](r: F[R, E, A])(f: A => F[R, E, B]): F[R, E, B]
+  def flatten[R, E, A](r: F[R, E, F[R, E, A]]): F[R, E, A] = flatMap(r)(identity)
+  def pure[A](a: A): F[Any, Nothing, A]
+}

From 354b5360be90466201f7b401dff2b099f3f2ad84 Mon Sep 17 00:00:00 2001
From: David Hua <d5hua@uwaterloo.ca>
Date: Tue, 14 Feb 2023 02:03:52 -0500
Subject: [PATCH 146/657] Respect cacheResult flag in safe initialization
 cache.

---
 .../tools/dotc/transform/init/Cache.scala     | 51 ++++++++++---------
 tests/init/neg/apply2.scala                   |  4 +-
 2 files changed, 30 insertions(+), 25 deletions(-)
 mode change 100644 => 100755 tests/init/neg/apply2.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/init/Cache.scala b/compiler/src/dotty/tools/dotc/transform/init/Cache.scala
index 14a52d995131..39bf134b0ce3 100644
--- a/compiler/src/dotty/tools/dotc/transform/init/Cache.scala
+++ b/compiler/src/dotty/tools/dotc/transform/init/Cache.scala
@@ -85,12 +85,14 @@ class Cache[Config, Res]:
    *
    *  The algorithmic skeleton is as follows:
    *
+   *      if don't cache result then
+   *        return eval(expr)
    *      if this.current.contains(config, expr) then
    *        return cached value
    *      else
    *        val assumed = this.last(config, expr) or bottom value if absent
    *        this.current(config, expr) = assumed
-   *        val actual = eval(exp)
+   *        val actual = eval(expr)
    *
    *        if assumed != actual then
    *          this.changed = true
@@ -98,28 +100,31 @@ class Cache[Config, Res]:
    *
    */
   def cachedEval(config: Config, expr: Tree, cacheResult: Boolean, default: Res)(eval: Tree => Res): Res =
-    this.get(config, expr) match
-    case Some(value) => value
-    case None =>
-      val assumeValue: Res =
-        this.last.get(config, expr) match
-        case Some(value) => value
-        case None =>
-          this.last = this.last.updatedNested(config, expr, default)
-          default
-
-      this.current = this.current.updatedNested(config, expr, assumeValue)
-
-      val actual = eval(expr)
-      if actual != assumeValue then
-        // println("Changed! from = " + assumeValue + ", to = " + actual)
-        this.changed = true
-        // TODO: respect cacheResult to reduce cache size
-        this.current = this.current.updatedNested(config, expr, actual)
-        // this.current = this.current.removed(config, expr)
-      end if
-
-      actual
+    if !cacheResult then
+      eval(expr)
+    else
+      this.get(config, expr) match
+      case Some(value) => value
+      case None =>
+        val assumeValue: Res =
+          this.last.get(config, expr) match
+          case Some(value) => value
+          case None =>
+            this.last = this.last.updatedNested(config, expr, default)
+            default
+
+        this.current = this.current.updatedNested(config, expr, assumeValue)
+
+        val actual = eval(expr)
+        if actual != assumeValue then
+          // println("Changed! from = " + assumeValue + ", to = " + actual)
+          this.changed = true
+          this.current = this.current.updatedNested(config, expr, actual)
+          // this.current = this.current.removed(config, expr)
+        end if
+
+        actual
+    end if
   end cachedEval
 
   def hasChanged = changed
diff --git a/tests/init/neg/apply2.scala b/tests/init/neg/apply2.scala
old mode 100644
new mode 100755
index 83f64a6dd3c7..c6c7fe5fedd2
--- a/tests/init/neg/apply2.scala
+++ b/tests/init/neg/apply2.scala
@@ -3,8 +3,8 @@ object O:
     println(n)
 
   class B:
-    val a = A(this)
+    val a = A(this)  // error
 
   val b = new B
-  val n = 10  // error
+  val n = 10
 end O

From 9f28641da43ed10aeeaa9aa6b97f572021ed693c Mon Sep 17 00:00:00 2001
From: David Hua <d5hua@uwaterloo.ca>
Date: Tue, 14 Feb 2023 02:34:42 -0500
Subject: [PATCH 147/657] Add tests for clause interleaving to safe
 initialization test suite.

---
 tests/init/neg/interleaving-params.scala   |  9 +++++++++
 tests/init/pos/interleaving-overload.scala | 20 ++++++++++++++++++++
 tests/init/pos/interleaving-params.scala   |  8 ++++++++
 3 files changed, 37 insertions(+)
 create mode 100755 tests/init/neg/interleaving-params.scala
 create mode 100755 tests/init/pos/interleaving-overload.scala
 create mode 100755 tests/init/pos/interleaving-params.scala

diff --git a/tests/init/neg/interleaving-params.scala b/tests/init/neg/interleaving-params.scala
new file mode 100755
index 000000000000..f0f9cbaf3f53
--- /dev/null
+++ b/tests/init/neg/interleaving-params.scala
@@ -0,0 +1,9 @@
+import scala.language.experimental.clauseInterleaving
+
+class Params{
+    def bar[T](x: T)[T]: String = ??? // error
+    def zoo(x: Int)[T, U](x: U): T = ??? // error
+    def bbb[T <: U](x: U)[U]: U = ??? // error // error
+    def f0[T](implicit x: T)[U](y: U) = (x,y) // error
+    def f1[T](implicit x: T)[U] = (x,y) // error
+}
\ No newline at end of file
diff --git a/tests/init/pos/interleaving-overload.scala b/tests/init/pos/interleaving-overload.scala
new file mode 100755
index 000000000000..4d9214bf4d09
--- /dev/null
+++ b/tests/init/pos/interleaving-overload.scala
@@ -0,0 +1,20 @@
+import scala.language.experimental.clauseInterleaving
+
+class A{
+
+    def f1[T](x: Any)[U] = ???
+    def f1[T](x: Int)[U] = ???
+
+    f1(1)
+    f1("hello")
+
+    case class B[U](x: Int)
+    def b[U](x: Int) = B[U](x)
+
+    def f2[T]: [U] => Int => B[U] = [U] => (x: Int) => b[U](x)
+
+    f2(1)
+    f2[Any](1)
+    f2[Any][Any](1)
+
+}
\ No newline at end of file
diff --git a/tests/init/pos/interleaving-params.scala b/tests/init/pos/interleaving-params.scala
new file mode 100755
index 000000000000..08531a84e696
--- /dev/null
+++ b/tests/init/pos/interleaving-params.scala
@@ -0,0 +1,8 @@
+import scala.language.experimental.clauseInterleaving
+
+class Params{
+    type U
+    def foo[T](x: T)[U >: x.type <: T](using U)[L <: List[U]](l: L): L = ???
+    def aaa(x: U): U = ???
+    def bbb[T <: U](x: U)[U]: U = ???
+}
\ No newline at end of file

From 994282177170ca1fab4a0fe3197c0efe4729e06a Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Tue, 14 Feb 2023 09:24:15 +0100
Subject: [PATCH 148/657] Avoid infinite recursion in infoDependsOnPrefix

---
 compiler/src/dotty/tools/dotc/core/Types.scala | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index 5ef6dbd39335..d4fa6a819dc4 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -2508,15 +2508,20 @@ object Types {
     private def infoDependsOnPrefix(symd: SymDenotation, prefix: Type)(using Context): Boolean =
 
       def refines(tp: Type, name: Name): Boolean = tp match
-        case AndType(tp1, tp2) =>
-          refines(tp1, name) || refines(tp2, name)
+        case tp: TypeRef =>
+          tp.symbol match
+            case cls: ClassSymbol =>
+              val otherd = cls.nonPrivateMembersNamed(name)
+              otherd.exists && !otherd.containsSym(symd.symbol)
+            case tsym =>
+              refines(tsym.info.hiBound, name)
+                // avoid going through tp.denot, since that might call infoDependsOnPrefix again
         case RefinedType(parent, rname, _) =>
           rname == name || refines(parent, name)
-        case tp: ClassInfo =>
-          val otherd = tp.cls.nonPrivateMembersNamed(name)
-          otherd.exists && !otherd.containsSym(symd.symbol)
         case tp: TypeProxy =>
           refines(tp.underlying, name)
+        case AndType(tp1, tp2) =>
+          refines(tp1, name) || refines(tp2, name)
         case _ =>
           false
 

From a53b1855f793d59b0e43925697eb769ebbacba4c Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Tue, 14 Feb 2023 12:06:56 +0000
Subject: [PATCH 149/657] Disallow mixins where super calls bind to vals

---
 .../tools/dotc/transform/ResolveSuper.scala     |  3 +++
 tests/neg/t12715.scala                          | 17 +++++++++++++++++
 tests/neg/t12715b.scala                         | 16 ++++++++++++++++
 3 files changed, 36 insertions(+)
 create mode 100644 tests/neg/t12715.scala
 create mode 100644 tests/neg/t12715b.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/ResolveSuper.scala b/compiler/src/dotty/tools/dotc/transform/ResolveSuper.scala
index dd109ce153eb..99b6be1eea8a 100644
--- a/compiler/src/dotty/tools/dotc/transform/ResolveSuper.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ResolveSuper.scala
@@ -119,6 +119,9 @@ object ResolveSuper {
           report.error(IllegalSuperAccessor(base, memberName, targetName, acc, accTp, other.symbol, otherTp), base.srcPos)
       bcs = bcs.tail
     }
+    if sym.is(Accessor) then
+      report.error(
+        em"parent ${acc.owner} has a super call which binds to the value ${sym.showFullName}. Super calls can only target methods.", base)
     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)
diff --git a/tests/neg/t12715.scala b/tests/neg/t12715.scala
new file mode 100644
index 000000000000..b24d51a6e9fa
--- /dev/null
+++ b/tests/neg/t12715.scala
@@ -0,0 +1,17 @@
+trait A              { def f: String }
+trait B extends A    { def f = "B" }
+trait C extends A    { override val f = "C" }
+trait D extends C    { override val f = "D" }
+trait E extends A, B { def d = super.f }
+final class O1 extends B, C, D, E // error: parent trait E has a super call which binds to the value D.f. Super calls can only target methods.
+final class O2 extends B, C, E, D // error: parent trait E has a super call which binds to the value C.f. Super calls can only target methods.
+final class O3 extends B, E, C, D
+
+object Main:
+  def main(args: Array[String]): Unit =
+    println(O1().f) // D
+    println(O2().f) // D
+    println(O3().f) // D
+    println(O3().d) // B
+    O1().d // was: NoSuchMethodError: 'java.lang.String D.f$(D)'
+    O2().d // was: NoSuchMethodError: 'java.lang.String C.f$(C)'
diff --git a/tests/neg/t12715b.scala b/tests/neg/t12715b.scala
new file mode 100644
index 000000000000..da024116d4b3
--- /dev/null
+++ b/tests/neg/t12715b.scala
@@ -0,0 +1,16 @@
+trait B:
+  def f: Float = 1.0f
+
+class A(override val f: Float) extends B
+
+trait C extends B:
+  abstract override val f = super.f + 100.0f
+
+trait D extends B:
+  abstract override val f = super.f + 1000.0f
+
+class ACD10 extends A(10.0f) with C with D // error: parent trait D has a super call to method B.f, which binds to the value C.f. Super calls can only target methods.
+
+object Test:
+  def main(args: Array[String]): Unit =
+    new ACD10 // was: NoSuchMethodError: 'float C.f$(C)'

From fe46a90b703c6f3855000c4bc8c7e62dec77b7bf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Marks?= <pmarks@virtuslab.com>
Date: Tue, 14 Feb 2023 13:17:40 +0100
Subject: [PATCH 150/657] Run CI on merge queue

---
 .github/workflows/cla.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/cla.yml b/.github/workflows/cla.yml
index 3ac31b0994f7..bb1aec1290c0 100644
--- a/.github/workflows/cla.yml
+++ b/.github/workflows/cla.yml
@@ -6,6 +6,7 @@ on:
   push:
     branches:
       - 'language-reference-stable'
+  merge_group:
 permissions:
   contents: write
   pull-requests: write

From 50243538f7596afbd0bb0e79d5bb82aed2b61f85 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 6 Feb 2023 15:11:44 +0100
Subject: [PATCH 151/657] Fix Splicer.isEscapedVariable

Consider that `val macro` expansion in the context can come from
an outer macro that is being expanded (i.e. this is a nested macro).
Nested macro expansion can occur when a macro summons an implicit macro.

Fixes partially #16835
---
 .../dotty/tools/dotc/transform/Splicer.scala  |  7 +-
 tests/pos-macros/i16835/Macro_1.scala         | 79 +++++++++++++++++++
 tests/pos-macros/i16835/Show_1.scala          | 11 +++
 tests/pos-macros/i16835/Test_2.scala          | 30 +++++++
 4 files changed, 125 insertions(+), 2 deletions(-)
 create mode 100644 tests/pos-macros/i16835/Macro_1.scala
 create mode 100644 tests/pos-macros/i16835/Show_1.scala
 create mode 100644 tests/pos-macros/i16835/Test_2.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/Splicer.scala b/compiler/src/dotty/tools/dotc/transform/Splicer.scala
index 3d3cd1f41c84..bc4119ad0cff 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicer.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicer.scala
@@ -86,7 +86,7 @@ object Splicer {
       }
   }
 
-  /** Checks that no symbol that whas generated within the macro expansion has an out of scope reference */
+  /** Checks that no symbol that was 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]
@@ -119,7 +119,10 @@ object Splicer {
         sym.exists && !sym.is(Package)
         && sym.owner.ownersIterator.exists(x =>
           x == expansionOwner || // symbol was generated within this macro expansion
-          isMacroOwner(x) // symbol was generated within another macro expansion
+          { // symbol was generated within another macro expansion
+            isMacroOwner(x) &&
+            !ctx.owner.ownersIterator.contains(x)
+          }
         )
         && !locals.contains(sym) // symbol is not in current scope
     }.traverse(tree)
diff --git a/tests/pos-macros/i16835/Macro_1.scala b/tests/pos-macros/i16835/Macro_1.scala
new file mode 100644
index 000000000000..133d9f38d1da
--- /dev/null
+++ b/tests/pos-macros/i16835/Macro_1.scala
@@ -0,0 +1,79 @@
+import scala.quoted.*
+import scala.deriving.Mirror
+
+// derivation code is a slightly modified version of: https://github.com/lampepfl/dotty-macro-examples/blob/main/macroTypeClassDerivation/src/macro.scala
+object Derivation {
+
+  // Typeclass instance gets constructed as part of a macro
+  inline given deriveFullyConstrucedByMacro[A](using Mirror.ProductOf[A]): Show[A] = Derivation.deriveShow[A]
+
+  // Typeclass instance is built inside as part of a method, only the 'show' impl is filled in by a macro
+  inline given derivePartiallyConstructedByMacro[A](using Mirror.ProductOf[A]): Show[A] =
+    new {
+      def show(value: A): String = Derivation.show(value)
+    }
+
+  inline def show[T](value: T): String = ${ showValue('value) }
+
+  inline def deriveShow[T]: Show[T] = ${ deriveCaseClassShow[T] }
+
+  private def deriveCaseClassShow[T](using quotes: Quotes, tpe: Type[T]): Expr[Show[T]] = {
+    import quotes.reflect.*
+    // Getting the case fields of the case class
+    val fields: List[Symbol] = TypeTree.of[T].symbol.caseFields
+
+    '{
+      new Show[T] {
+        override def show(t: T): String =
+          ${ showValue('t) }
+      }
+    }
+  }
+
+  def showValue[T: Type](value: Expr[T])(using Quotes): Expr[String] = {
+    import quotes.reflect.*
+
+    val fields: List[Symbol] = TypeTree.of[T].symbol.caseFields
+
+    val vTerm: Term = value.asTerm
+    val valuesExprs: List[Expr[String]] = fields.map(showField(vTerm, _))
+    val exprOfList: Expr[List[String]] = Expr.ofList(valuesExprs)
+    '{ "{ " + $exprOfList.mkString(", ") + " }" }
+  }
+
+  /** Create a quoted String representation of a given field of the case class */
+  private def showField(using Quotes)(caseClassTerm: quotes.reflect.Term, field: quotes.reflect.Symbol): Expr[String] = {
+    import quotes.reflect.*
+
+    val fieldValDef: ValDef = field.tree.asInstanceOf[ValDef]
+    val fieldTpe: TypeRepr = fieldValDef.tpt.tpe
+    val fieldName: String = fieldValDef.name
+
+    val tcl: Term = lookupShowFor(fieldTpe) // Show[$fieldTpe]
+    val fieldValue: Term = Select(caseClassTerm, field) // v.field
+    val strRepr: Expr[String] = applyShow(tcl, fieldValue).asExprOf[String]
+    '{ ${ Expr(fieldName) } + ": " + $strRepr } // summon[Show[$fieldTpe]].show(v.field)
+  }
+
+  /** Look up the Show[$t] typeclass for a given type t */
+  private def lookupShowFor(using Quotes)(t: quotes.reflect.TypeRepr): quotes.reflect.Term = {
+    import quotes.reflect.*
+    t.asType match {
+      case '[tpe] =>
+        Implicits.search(TypeRepr.of[Show[tpe]]) match {
+          case res: ImplicitSearchSuccess   => res.tree
+          case failure: DivergingImplicit   => report.errorAndAbort(s"Diverving: ${failure.explanation}")
+          case failure: NoMatchingImplicits => report.errorAndAbort(s"NoMatching: ${failure.explanation}")
+          case failure: AmbiguousImplicits  => report.errorAndAbort(s"Ambiguous: ${failure.explanation}")
+          case failure: ImplicitSearchFailure =>
+            report.errorAndAbort(s"catch all: ${failure.explanation}")
+        }
+    }
+  }
+
+  /** Composes the tree: $tcl.show($arg) */
+  private def applyShow(using Quotes)(tcl: quotes.reflect.Term, arg: quotes.reflect.Term): quotes.reflect.Term = {
+    import quotes.reflect.*
+    Apply(Select.unique(tcl, "show"), arg :: Nil)
+  }
+}
diff --git a/tests/pos-macros/i16835/Show_1.scala b/tests/pos-macros/i16835/Show_1.scala
new file mode 100644
index 000000000000..61f6b2dccd80
--- /dev/null
+++ b/tests/pos-macros/i16835/Show_1.scala
@@ -0,0 +1,11 @@
+trait Show[A] {
+  def show(value: A): String
+}
+
+object Show {
+  given identity: Show[String] = a => a
+
+  given int: Show[Int] = _.toString()
+
+  given list[A](using A: Show[A]): Show[List[A]] = _.map(A.show).toString()
+}
diff --git a/tests/pos-macros/i16835/Test_2.scala b/tests/pos-macros/i16835/Test_2.scala
new file mode 100644
index 000000000000..61019b1417b6
--- /dev/null
+++ b/tests/pos-macros/i16835/Test_2.scala
@@ -0,0 +1,30 @@
+import scala.deriving.*
+
+object usage {
+  final case class Person(name: String, age: Int, otherNames: List[String], p2: Person2)
+
+  final case class Person2(name: String, age: Int, otherNames: List[String])
+
+  locally {
+    import Derivation.deriveFullyConstrucedByMacro
+    // works for case classes without other nested case classes inside
+    summon[Show[Person2]]
+
+    // also derives instances with nested case classes
+    summon[Show[Person]]
+  }
+
+  locally {
+    import Derivation.derivePartiallyConstructedByMacro
+
+    // works for case classes without other nested case classes inside
+    summon[Show[Person2]]
+
+    // fails for case classes with other nested case classes inside,
+    // note how that error is not a `NonMatching', `Diverging` or `Ambiguous` implicit search error but something else
+    /*
+    catch all: given instance deriveWithConstructionOutsideMacro in object Derivation does not match type io.github.arainko.ducktape.issue_repros.Show[Person2]
+    */
+    summon[Show[Person]]
+  }
+}
\ No newline at end of file

From 715bca84aa9787be6bd07502795afb845ce2aa5c Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Tue, 14 Feb 2023 13:26:11 +0000
Subject: [PATCH 152/657] Drop failsafe checkNonCyclic and document GADT
 fullBounds change

---
 compiler/src/dotty/tools/dotc/core/GadtConstraint.scala | 9 ++++++++-
 compiler/src/dotty/tools/dotc/typer/Typer.scala         | 2 +-
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/GadtConstraint.scala b/compiler/src/dotty/tools/dotc/core/GadtConstraint.scala
index 211c8e637b1f..4b580c06d11f 100644
--- a/compiler/src/dotty/tools/dotc/core/GadtConstraint.scala
+++ b/compiler/src/dotty/tools/dotc/core/GadtConstraint.scala
@@ -77,6 +77,13 @@ class GadtConstraint private (
       sym.name.is(NameKinds.UniqueName) && {
         val hi = sym.info.hiBound
         !hi.isExactlyAny && self <:< hi
+        // drop any lower param that is a GADT symbol
+        // and is upper-bounded by a non-Any super-type of the original parameter
+        // e.g. in pos/i14287.min
+        // B$1 had info <: X   and fullBounds >: B$2 <: X, and
+        // B$2 had info <: B$1 and fullBounds <: B$1
+        // We can use the info of B$2 to drop the lower-bound of B$1
+        // and return non-bidirectional bounds B$1 <: X and B$2 <: B$1.
       }
     }.foldLeft(nonParamBounds(param).lo) {
       (t, u) => t | externalize(u)
@@ -88,7 +95,7 @@ class GadtConstraint private (
       val sym = paramSymbol(p)
       sym.name.is(NameKinds.UniqueName) && {
         val lo = sym.info.loBound
-        !lo.isExactlyNothing && lo <:< self
+        !lo.isExactlyNothing && lo <:< self // same as fullLowerBounds
       }
     }.foldLeft(nonParamBounds(param).hi) { (t, u) =>
       val eu = externalize(u)
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 328039fd8a41..a87d6dd7e703 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -1765,7 +1765,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           else report.error(new DuplicateBind(b, cdef), b.srcPos)
           if (!ctx.isAfterTyper) {
             val bounds = ctx.gadt.fullBounds(sym)
-            if (bounds != null) sym.info = checkNonCyclic(sym, bounds, reportErrors = true)
+            if (bounds != null) sym.info = bounds
           }
           b
         case t: UnApply if t.symbol.is(Inline) => Inlines.inlinedUnapply(t)

From 57bfabcff26cdea598391684ecbeeafb0700e125 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Marks?= <pmarks@virtuslab.com>
Date: Tue, 14 Feb 2023 16:21:51 +0100
Subject: [PATCH 153/657] Do not run CI on pushes to github queues

---
 .github/workflows/ci.yaml | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index b70cc3bb9e70..fd2fd85cdce3 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -14,6 +14,10 @@ on:
     ## - both (tags or tags-ignore) and (branches or branches-ignore),
     ## - or neither of them.
     ## But it's important to not have only one or the other.
+    tags:
+      - '*'
+    branches-ignore:
+      - 'gh-readonly-queue/*'
   pull_request:
   merge_group:
   schedule:

From 677991ef8bceb0b7e9a110694f3c6931a34ddbff Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Marks?= <pmarks@virtuslab.com>
Date: Wed, 15 Feb 2023 10:27:41 +0100
Subject: [PATCH 154/657] Fix wildcard used to filter queue

---
 .github/workflows/ci.yaml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml
index fd2fd85cdce3..370b66854051 100644
--- a/.github/workflows/ci.yaml
+++ b/.github/workflows/ci.yaml
@@ -17,7 +17,7 @@ on:
     tags:
       - '*'
     branches-ignore:
-      - 'gh-readonly-queue/*'
+      - 'gh-readonly-queue/**'
   pull_request:
   merge_group:
   schedule:

From 96bfb69c933148ad0561e589a444fab1308d7951 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Wed, 8 Feb 2023 11:58:53 +0100
Subject: [PATCH 155/657] Handle pickled forward references in pickled
 expressions

To compute forward references it was assumed that the owner of that
symbol can be found in the TASTy. This is not always the case with TASTy
expressions of pickled quotes. The owner might be outside the quote, in
this case the context already has the owner of the referenced symbol.
These are local symbols defined at the top-level of the TASTy.

Fixes #16843
---
 .../tools/dotc/core/tasty/TreeUnpickler.scala  |  6 +++++-
 tests/pos-macros/i16843a/Macro_1.scala         | 13 +++++++++++++
 tests/pos-macros/i16843a/Test_2.scala          |  1 +
 tests/pos-macros/i16843b/Macro_1.scala         | 18 ++++++++++++++++++
 tests/pos-macros/i16843b/Test_2.scala          |  1 +
 5 files changed, 38 insertions(+), 1 deletion(-)
 create mode 100644 tests/pos-macros/i16843a/Macro_1.scala
 create mode 100644 tests/pos-macros/i16843a/Test_2.scala
 create mode 100644 tests/pos-macros/i16843b/Macro_1.scala
 create mode 100644 tests/pos-macros/i16843b/Test_2.scala

diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
index 91290b4ddd41..dfe04dbe6d2b 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
@@ -74,6 +74,9 @@ class TreeUnpickler(reader: TastyReader,
    */
   private val typeAtAddr = new mutable.HashMap[Addr, Type]
 
+  /** If this is a pickled quote, the owner of the quote, otherwise NoSymbol. */
+  private var rootOwner: Symbol = NoSymbol
+
   /** The root symbol denotation which are defined by the Tasty file associated with this
    *  TreeUnpickler. Set by `enterTopLevel`.
    */
@@ -106,6 +109,7 @@ class TreeUnpickler(reader: TastyReader,
 
   /** The unpickled trees */
   def unpickle(mode: UnpickleMode)(using Context): List[Tree] = {
+    if mode != UnpickleMode.TopLevel then rootOwner = ctx.owner
     assert(roots != null, "unpickle without previous enterTopLevel")
     val rdr = new TreeReader(reader)
     mode match {
@@ -1635,7 +1639,7 @@ class TreeUnpickler(reader: TastyReader,
             pickling.println(i"no owner for $addr among $cs%, %")
             throw ex
         }
-      try search(children, NoSymbol)
+      try search(children, rootOwner)
       catch {
         case ex: TreeWithoutOwner =>
           pickling.println(s"ownerTree = $ownerTree")
diff --git a/tests/pos-macros/i16843a/Macro_1.scala b/tests/pos-macros/i16843a/Macro_1.scala
new file mode 100644
index 000000000000..98c1505910e6
--- /dev/null
+++ b/tests/pos-macros/i16843a/Macro_1.scala
@@ -0,0 +1,13 @@
+import scala.quoted.*
+
+case class Foo(x: Int)
+
+inline def foo = ${ fooImpl }
+
+def fooImpl(using Quotes) =
+  val tmp = '{
+    1 match
+      case x @ (y: Int) => 0
+  }
+
+  '{}
diff --git a/tests/pos-macros/i16843a/Test_2.scala b/tests/pos-macros/i16843a/Test_2.scala
new file mode 100644
index 000000000000..25406428d0cf
--- /dev/null
+++ b/tests/pos-macros/i16843a/Test_2.scala
@@ -0,0 +1 @@
+val x = foo
diff --git a/tests/pos-macros/i16843b/Macro_1.scala b/tests/pos-macros/i16843b/Macro_1.scala
new file mode 100644
index 000000000000..631bde56f1f1
--- /dev/null
+++ b/tests/pos-macros/i16843b/Macro_1.scala
@@ -0,0 +1,18 @@
+import scala.quoted.*
+
+inline def foo: Int = ${ fooImpl }
+
+def fooImpl(using Quotes): Expr[Int] =
+  '{
+    val b = ${
+      val a = '{
+        (1: Int) match
+          case x @ (y: Int) => 0
+      }
+      a
+    }
+
+    (1: Int) match
+      case x @ (y: Int) => 0
+  }
+
diff --git a/tests/pos-macros/i16843b/Test_2.scala b/tests/pos-macros/i16843b/Test_2.scala
new file mode 100644
index 000000000000..54c769c9618f
--- /dev/null
+++ b/tests/pos-macros/i16843b/Test_2.scala
@@ -0,0 +1 @@
+def test = foo

From 0a7f47e81502e0f9bd37492da9061b0c4dc186e4 Mon Sep 17 00:00:00 2001
From: Paul Coral <paul.coral@epfl.ch>
Date: Wed, 15 Feb 2023 16:44:55 +0100
Subject: [PATCH 156/657] Fix #16822

- Ignore synthetic local private
- Update test suit
---
 .../tools/dotc/transform/CheckUnused.scala    | 19 +++++++--------
 .../fatal-warnings/i15503i.scala              | 23 ++++++++++++++-----
 2 files changed, 27 insertions(+), 15 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index 59878757c39b..6c47c12ac07c 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -81,7 +81,7 @@ class CheckUnused extends MiniPhase:
     ctx
 
   override def prepareForIdent(tree: tpd.Ident)(using Context): Context =
-    if tree.symbol.exists then 
+    if tree.symbol.exists then
       _key.unusedDataApply(_.registerUsed(tree.symbol, Some(tree.name)))
     else if tree.hasType then
       _key.unusedDataApply(_.registerUsed(tree.tpe.classSymbol, Some(tree.name)))
@@ -103,7 +103,7 @@ class CheckUnused extends MiniPhase:
   override def prepareForValDef(tree: tpd.ValDef)(using Context): Context =
     _key.unusedDataApply{ud =>
       // do not register the ValDef generated for `object`
-      if !tree.symbol.is(Module) then 
+      if !tree.symbol.is(Module) then
         ud.registerDef(tree)
       ud.addIgnoredUsage(tree.symbol)
     }
@@ -335,7 +335,7 @@ object CheckUnused:
      * The optional name will be used to target the right import
      * as the same element can be imported with different renaming
      */
-    def registerUsed(sym: Symbol, name: Option[Name])(using Context): Unit =      
+    def registerUsed(sym: Symbol, name: Option[Name])(using Context): Unit =
       if !isConstructorOfSynth(sym) && !doNotRegister(sym) then
         if sym.isConstructor && sym.exists then
           registerUsed(sym.owner, None) // constructor are "implicitly" imported with the class
@@ -371,7 +371,7 @@ object CheckUnused:
             implicitParamInScope += memDef
           else
             explicitParamInScope += memDef
-        else if currScopeType.top == ScopeType.Local then 
+        else if currScopeType.top == ScopeType.Local then
           localDefInScope += memDef
         else if memDef.shouldReportPrivateDef then
           privateDefInScope += memDef
@@ -578,10 +578,10 @@ object CheckUnused:
         else
           false
 
-      private def usedDefContains(using Context): Boolean = 
+      private def usedDefContains(using Context): Boolean =
         sym.everySymbol.exists(usedDef.apply)
 
-      private def everySymbol(using Context): List[Symbol] = 
+      private def everySymbol(using Context): List[Symbol] =
         List(sym, sym.companionClass, sym.companionModule, sym.moduleClass).filter(_.exists)
 
     end extension
@@ -614,10 +614,11 @@ object CheckUnused:
       private def isValidParam(using Context): Boolean =
         val sym = memDef.symbol
         (sym.is(Param) || sym.isAllOf(PrivateParamAccessor | Local, butNot = CaseAccessor)) &&
-        !isSyntheticMainParam(sym)  &&
-        !sym.shouldNotReportParamOwner
+        !isSyntheticMainParam(sym) &&
+        !sym.shouldNotReportParamOwner &&
+        (!sym.exists || !sym.owner.isAllOf(Synthetic | PrivateLocal))
 
-      private def shouldReportPrivateDef(using Context): Boolean = 
+      private def shouldReportPrivateDef(using Context): Boolean =
         currScopeType.top == ScopeType.Template && !memDef.symbol.isConstructor && memDef.symbol.is(Private, butNot = SelfName | Synthetic | CaseAccessor)
 
     extension (imp: tpd.Import)
diff --git a/tests/neg-custom-args/fatal-warnings/i15503i.scala b/tests/neg-custom-args/fatal-warnings/i15503i.scala
index 33e04f34daa8..7eae207d952d 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503i.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503i.scala
@@ -78,13 +78,13 @@ package foo.test.companionprivate:
 package foo.test.i16678:
   def foo(func: Int => String, value: Int): String = func(value) // OK
 
-  def run = 
+  def run =
     println(foo(number => number.toString, value = 5)) // OK
     println(foo(number => "<number>", value = 5)) // error
     println(foo(func = number => "<number>", value = 5)) // error
     println(foo(func = number => number.toString, value = 5)) // OK
     println(foo(func = _.toString, value = 5)) // OK
-    
+
 package foo.test.possibleclasses:
   case class AllCaseClass(
     k: Int, // OK
@@ -93,7 +93,7 @@ package foo.test.possibleclasses:
     s: Int, // error /* But not these */
     val t: Int, // OK
     private val z: Int // error
-  )       
+  )
 
   case class AllCaseUsed(
     k: Int, // OK
@@ -113,7 +113,7 @@ package foo.test.possibleclasses:
     s: Int, // error
     val t: Int, // OK
     private val z: Int // error
-  )      
+  )
 
   class AllUsed(
     k: Int, // OK
@@ -124,10 +124,21 @@ package foo.test.possibleclasses:
     private val z: Int // OK
   ) {
     def a = k + y + s + t + z
-  } 
+  }
 
 package foo.test.from.i16675:
   case class PositiveNumber private (i: Int) // OK
   object PositiveNumber:
-    def make(i: Int): Option[PositiveNumber] = //OK 
+    def make(i: Int): Option[PositiveNumber] = //OK
       Option.when(i >= 0)(PositiveNumber(i)) // OK
+
+package foo.test.i16822:
+  enum ExampleEnum {
+    case Build(context: String) // OK
+    case List // OK
+  }
+
+  def demo = {
+    val x = ExampleEnum.List // OK
+    println(x) // OK
+  }

From 9571b42a2ff63e897cb566c09259f5f8d1e7a021 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 7 Feb 2023 13:27:09 +0100
Subject: [PATCH 157/657] Add reflect `defn.FunctionClass` overloads

The old `FunctionClass` will need to be deprecated as we will remove
`ErasedFunctionN` and `ErasedContextFunctionN`. We will replace this API
with a simpler version that can return `FunctionN` or `ContextFunctionN`,
the only two stable function classes we have in the compiler/TASTy.

Other new function classes will be encoded with the more general refined
function type encoding, generalization of the `PolyFunction` encoding.
This implies that we won't need to add other kind of function classes to
the reflect API.

Part of the fix for #16847
---
 .../quoted/runtime/impl/QuotesImpl.scala      |  5 ++++
 library/src/scala/quoted/Quotes.scala         | 19 ++++++++++++++
 .../stdlibExperimentalDefinitions.scala       |  4 ++-
 tests/run-macros/tasty-definitions-1.check    | 26 +++++++++++++++++++
 .../tasty-definitions-1/quoted_1.scala        |  1 +
 5 files changed, 54 insertions(+), 1 deletion(-)

diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
index 4d08e0582d1d..2daaf749359f 100644
--- a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
+++ b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
@@ -2768,7 +2768,12 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
       def SomeModule: Symbol = dotc.core.Symbols.defn.SomeClass.companionModule
       def ProductClass: Symbol = dotc.core.Symbols.defn.ProductClass
       def FunctionClass(arity: Int, isImplicit: Boolean = false, isErased: Boolean = false): Symbol =
+        if arity < 0 then throw IllegalArgumentException(s"arity: $arity")
         dotc.core.Symbols.defn.FunctionSymbol(arity, isImplicit, isErased)
+      def FunctionClass(arity: Int): Symbol =
+        FunctionClass(arity, false, false)
+      def FunctionClass(arity: Int, isContextual: Boolean): Symbol =
+        FunctionClass(arity, isContextual, false)
       def TupleClass(arity: Int): Symbol =
         dotc.core.Symbols.defn.TupleType(arity).nn.classSymbol.asClass
       def isTupleClass(sym: Symbol): Boolean =
diff --git a/library/src/scala/quoted/Quotes.scala b/library/src/scala/quoted/Quotes.scala
index 22ec107aeae8..321725d4e84c 100644
--- a/library/src/scala/quoted/Quotes.scala
+++ b/library/src/scala/quoted/Quotes.scala
@@ -4254,8 +4254,27 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
       *   -  ...
       *   -  Nth element is `FunctionN`
       */
+      // TODO: deprecate in 3.4 and stabilize FunctionClass(Int)/FunctionClass(Int,Boolean)
+      // @deprecated("Use overload of `FunctionClass` with 1 or 2 arguments","3.4")
       def FunctionClass(arity: Int, isImplicit: Boolean = false, isErased: Boolean = false): Symbol
 
+      /** Class symbol of a function class `scala.FunctionN`.
+       *
+       *  @param arity the arity of the function where `0 <= arity`
+       *  @return class symbol of `scala.FunctionN` where `N == arity`
+       */
+      @experimental
+      def FunctionClass(arity: Int): Symbol
+
+      /** Class symbol of a context function class `scala.FunctionN` or `scala.ContextFunctionN`.
+       *
+       *  @param arity the arity of the function where `0 <= arity`
+       *  @param isContextual if it is a `scala.ContextFunctionN`
+       *  @return class symbol of `scala.FunctionN` or `scala.ContextFunctionN` where `N == arity`
+       */
+      @experimental
+      def FunctionClass(arity: Int, isContextual: Boolean): Symbol
+
       /** Function-like object that maps arity to symbols for classes `scala.TupleX`.
       *   -  0th element is `NoSymbol`
       *   -  1st element is `NoSymbol`
diff --git a/tests/run-custom-args/tasty-inspector/stdlibExperimentalDefinitions.scala b/tests/run-custom-args/tasty-inspector/stdlibExperimentalDefinitions.scala
index 30e7c5af6c2a..eff76720a7e2 100644
--- a/tests/run-custom-args/tasty-inspector/stdlibExperimentalDefinitions.scala
+++ b/tests/run-custom-args/tasty-inspector/stdlibExperimentalDefinitions.scala
@@ -66,7 +66,9 @@ val experimentalDefinitionInLibrary = Set(
   "scala.annotation.MacroAnnotation",
 
    //// New APIs: Quotes
-  // Can be stabilized in 3.3.0 (unsure) or later
+  // Should be stabilized in 3.4.0
+  "scala.quoted.Quotes.reflectModule.defnModule.FunctionClass",
+  // Can be stabilized in 3.4.0 (unsure) or later
   "scala.quoted.Quotes.reflectModule.CompilationInfoModule.XmacroSettings",
   "scala.quoted.Quotes.reflectModule.FlagsModule.JavaAnnotation",
   // Cant be stabilized yet.
diff --git a/tests/run-macros/tasty-definitions-1.check b/tests/run-macros/tasty-definitions-1.check
index 7ee9da3e64e8..c2674c1b7a06 100644
--- a/tests/run-macros/tasty-definitions-1.check
+++ b/tests/run-macros/tasty-definitions-1.check
@@ -57,31 +57,57 @@ Function23
 Function24
 Function25
 ContextFunction0
+ContextFunction0
+ContextFunction1
 ContextFunction1
 ContextFunction2
+ContextFunction2
+ContextFunction3
 ContextFunction3
 ContextFunction4
+ContextFunction4
+ContextFunction5
 ContextFunction5
 ContextFunction6
+ContextFunction6
 ContextFunction7
+ContextFunction7
+ContextFunction8
 ContextFunction8
 ContextFunction9
+ContextFunction9
 ContextFunction10
+ContextFunction10
+ContextFunction11
 ContextFunction11
 ContextFunction12
+ContextFunction12
 ContextFunction13
+ContextFunction13
+ContextFunction14
 ContextFunction14
 ContextFunction15
+ContextFunction15
+ContextFunction16
 ContextFunction16
 ContextFunction17
+ContextFunction17
+ContextFunction18
 ContextFunction18
 ContextFunction19
+ContextFunction19
 ContextFunction20
+ContextFunction20
+ContextFunction21
 ContextFunction21
 ContextFunction22
+ContextFunction22
 ContextFunction23
+ContextFunction23
+ContextFunction24
 ContextFunction24
 ContextFunction25
+ContextFunction25
 ErasedFunction1
 ErasedFunction2
 ErasedFunction3
diff --git a/tests/run-macros/tasty-definitions-1/quoted_1.scala b/tests/run-macros/tasty-definitions-1/quoted_1.scala
index 6ee80daeeb1d..baf0b929f202 100644
--- a/tests/run-macros/tasty-definitions-1/quoted_1.scala
+++ b/tests/run-macros/tasty-definitions-1/quoted_1.scala
@@ -60,6 +60,7 @@ object Macros {
       printout(defn.FunctionClass(i).name)
 
     for (i <- 0 to 25)
+      printout(defn.FunctionClass(i, isContextual = true).name)
       printout(defn.FunctionClass(i, isImplicit = true).name)
 
     for (i <- 1 to 25)

From 22be8026245da199ea37d7721e861036de4834bd Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Wed, 15 Feb 2023 21:39:51 +0000
Subject: [PATCH 158/657] GADT: move dropping GADT symbols into foldLeft

---
 .../tools/dotc/core/GadtConstraint.scala      | 51 ++++++++-----------
 1 file changed, 21 insertions(+), 30 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/GadtConstraint.scala b/compiler/src/dotty/tools/dotc/core/GadtConstraint.scala
index 4b580c06d11f..c98445c61a7e 100644
--- a/compiler/src/dotty/tools/dotc/core/GadtConstraint.scala
+++ b/compiler/src/dotty/tools/dotc/core/GadtConstraint.scala
@@ -3,6 +3,7 @@ package dotc
 package core
 
 import Contexts.*, Decorators.*, Symbols.*, Types.*
+import NameKinds.UniqueName
 import config.Printers.{gadts, gadtsConstr}
 import util.{SimpleIdentitySet, SimpleIdentityMap}
 import printing._
@@ -72,36 +73,30 @@ class GadtConstraint private (
 
   def fullLowerBound(param: TypeParamRef)(using Context): Type =
     val self = externalize(param)
-    constraint.minLower(param).filterNot { p =>
-      val sym = paramSymbol(p)
-      sym.name.is(NameKinds.UniqueName) && {
-        val hi = sym.info.hiBound
-        !hi.isExactlyAny && self <:< hi
-        // drop any lower param that is a GADT symbol
-        // and is upper-bounded by a non-Any super-type of the original parameter
-        // e.g. in pos/i14287.min
-        // B$1 had info <: X   and fullBounds >: B$2 <: X, and
-        // B$2 had info <: B$1 and fullBounds <: B$1
-        // We can use the info of B$2 to drop the lower-bound of B$1
-        // and return non-bidirectional bounds B$1 <: X and B$2 <: B$1.
-      }
-    }.foldLeft(nonParamBounds(param).lo) {
-      (t, u) => t | externalize(u)
+    constraint.minLower(param).foldLeft(nonParamBounds(param).lo) { (acc, p) =>
+      externalize(p) match
+        case tp: TypeRef
+          // drop any lower param that is a GADT symbol
+          // and is upper-bounded by a non-Any super-type of the original parameter
+          // e.g. in pos/i14287.min
+          // B$1 had info <: X   and fullBounds >: B$2 <: X, and
+          // B$2 had info <: B$1 and fullBounds <: B$1
+          // We can use the info of B$2 to drop the lower-bound of B$1
+          // and return non-bidirectional bounds B$1 <: X and B$2 <: B$1.
+          if tp.name.is(UniqueName) && !tp.info.hiBound.isExactlyAny && self <:< tp.info.hiBound => acc
+        case tp => acc | tp
     }
 
   def fullUpperBound(param: TypeParamRef)(using Context): Type =
     val self = externalize(param)
-    constraint.minUpper(param).filterNot { p =>
-      val sym = paramSymbol(p)
-      sym.name.is(NameKinds.UniqueName) && {
-        val lo = sym.info.loBound
-        !lo.isExactlyNothing && lo <:< self // same as fullLowerBounds
-      }
-    }.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
+    constraint.minUpper(param).foldLeft(nonParamBounds(param).hi) { (acc, u) =>
+      externalize(u) match
+        case tp: TypeRef // same as fullLowerBounds
+          if tp.name.is(UniqueName) && !tp.info.loBound.isExactlyNothing && tp.info.loBound <:< self => acc
+        case tp =>
+          // 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 acc.isAny then tp else acc & tp
     }
 
   def externalize(tp: Type, theMap: TypeMap | Null = null)(using Context): Type = tp match
@@ -117,10 +112,6 @@ class GadtConstraint private (
   def tvarOrError(sym: Symbol)(using Context): TypeVar =
     mapping(sym).ensuring(_ != null, i"not a constrainable symbol: $sym").uncheckedNN
 
-  private def paramSymbol(p: TypeParamRef): Symbol = reverseMapping(p) match
-    case sym: Symbol => sym
-    case null        => NoSymbol
-
   @tailrec final def stripInternalTypeVar(tp: Type): Type = tp match
     case tv: TypeVar =>
       val inst = constraint.instType(tv)

From 86d89379e5185dab1ff6978f8caf67f24955a259 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Wed, 15 Feb 2023 22:25:14 +0000
Subject: [PATCH 159/657] GADT: Use isPatternBound, ofc...

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

diff --git a/compiler/src/dotty/tools/dotc/core/GadtConstraint.scala b/compiler/src/dotty/tools/dotc/core/GadtConstraint.scala
index c98445c61a7e..74d668e7ca87 100644
--- a/compiler/src/dotty/tools/dotc/core/GadtConstraint.scala
+++ b/compiler/src/dotty/tools/dotc/core/GadtConstraint.scala
@@ -83,7 +83,7 @@ class GadtConstraint private (
           // B$2 had info <: B$1 and fullBounds <: B$1
           // We can use the info of B$2 to drop the lower-bound of B$1
           // and return non-bidirectional bounds B$1 <: X and B$2 <: B$1.
-          if tp.name.is(UniqueName) && !tp.info.hiBound.isExactlyAny && self <:< tp.info.hiBound => acc
+          if tp.symbol.isPatternBound && !tp.info.hiBound.isExactlyAny && self <:< tp.info.hiBound => acc
         case tp => acc | tp
     }
 
@@ -92,7 +92,7 @@ class GadtConstraint private (
     constraint.minUpper(param).foldLeft(nonParamBounds(param).hi) { (acc, u) =>
       externalize(u) match
         case tp: TypeRef // same as fullLowerBounds
-          if tp.name.is(UniqueName) && !tp.info.loBound.isExactlyNothing && tp.info.loBound <:< self => acc
+          if tp.symbol.isPatternBound && !tp.info.loBound.isExactlyNothing && tp.info.loBound <:< self => acc
         case tp =>
           // 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

From 37aeb3d667a9e77fcfbb78c30112419acc01df9c Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Wed, 15 Feb 2023 22:30:09 +0000
Subject: [PATCH 160/657] GADT: Use =:= instead of Any/Nothing

---
 .../tools/dotc/core/GadtConstraint.scala      | 20 +++++++++----------
 1 file changed, 9 insertions(+), 11 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/GadtConstraint.scala b/compiler/src/dotty/tools/dotc/core/GadtConstraint.scala
index 74d668e7ca87..bb65cce84042 100644
--- a/compiler/src/dotty/tools/dotc/core/GadtConstraint.scala
+++ b/compiler/src/dotty/tools/dotc/core/GadtConstraint.scala
@@ -75,15 +75,14 @@ class GadtConstraint private (
     val self = externalize(param)
     constraint.minLower(param).foldLeft(nonParamBounds(param).lo) { (acc, p) =>
       externalize(p) match
-        case tp: TypeRef
-          // drop any lower param that is a GADT symbol
-          // and is upper-bounded by a non-Any super-type of the original parameter
-          // e.g. in pos/i14287.min
-          // B$1 had info <: X   and fullBounds >: B$2 <: X, and
-          // B$2 had info <: B$1 and fullBounds <: B$1
-          // We can use the info of B$2 to drop the lower-bound of B$1
-          // and return non-bidirectional bounds B$1 <: X and B$2 <: B$1.
-          if tp.symbol.isPatternBound && !tp.info.hiBound.isExactlyAny && self <:< tp.info.hiBound => acc
+        // drop any lower param that is a GADT symbol
+        // and is upper-bounded by a non-Any super-type of the original parameter
+        // e.g. in pos/i14287.min
+        // B$1 had info <: X   and fullBounds >: B$2 <: X, and
+        // B$2 had info <: B$1 and fullBounds <: B$1
+        // We can use the info of B$2 to drop the lower-bound of B$1
+        // and return non-bidirectional bounds B$1 <: X and B$2 <: B$1.
+        case tp: TypeRef if tp.symbol.isPatternBound && self =:= tp.info.hiBound => acc
         case tp => acc | tp
     }
 
@@ -91,8 +90,7 @@ class GadtConstraint private (
     val self = externalize(param)
     constraint.minUpper(param).foldLeft(nonParamBounds(param).hi) { (acc, u) =>
       externalize(u) match
-        case tp: TypeRef // same as fullLowerBounds
-          if tp.symbol.isPatternBound && !tp.info.loBound.isExactlyNothing && tp.info.loBound <:< self => acc
+        case tp: TypeRef if tp.symbol.isPatternBound && self =:= tp.info.loBound => acc // like fullLowerBound
         case tp =>
           // 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

From a0ec2dc1d5d6299409b4273125ead1f9ab57cdf7 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Wed, 15 Feb 2023 13:37:28 +0000
Subject: [PATCH 161/657] Space: Move isSubspace cache to Space instance

This is in preparation for making SpaceEngine an object, so also remove
the other vals too.
---
 .../dotty/tools/dotc/core/Definitions.scala   |  3 ++
 .../tools/dotc/transform/patmat/Space.scala   | 53 ++++++++++---------
 .../transform/patmat/SpaceEngineTest.scala    |  2 +-
 3 files changed, 32 insertions(+), 26 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
index 854608143df9..d6e677547583 100644
--- a/compiler/src/dotty/tools/dotc/core/Definitions.scala
+++ b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -530,9 +530,12 @@ class Definitions {
   })
 
   @tu lazy val ListClass: Symbol       = requiredClass("scala.collection.immutable.List")
+  def ListType: TypeRef                = ListClass.typeRef
   @tu lazy val ListModule: Symbol      = requiredModule("scala.collection.immutable.List")
   @tu lazy val NilModule: Symbol       = requiredModule("scala.collection.immutable.Nil")
+  def NilType: TermRef                 = NilModule.termRef
   @tu lazy val ConsClass: Symbol       = requiredClass("scala.collection.immutable.::")
+  def ConsType: TypeRef                = ConsClass.typeRef
   @tu lazy val SeqFactoryClass: Symbol = requiredClass("scala.collection.SeqFactory")
 
   @tu lazy val SingletonClass: ClassSymbol =
diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index f4c4863d073d..7071e3b46829 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -55,7 +55,16 @@ import collection.mutable
 
 
 /** space definition */
-sealed trait Space
+sealed trait Space:
+  private val isSubspaceCache = mutable.HashMap.empty[Space, Boolean]
+
+  def isSubspace(b: Space)(engine: SpaceEngine)(using Context): Boolean =
+    if this == Empty then true
+    else if b == Empty then false
+    else trace(s"isSubspace(${engine.show(this)}, ${engine.show(b)})", debug) {
+      isSubspaceCache.getOrElseUpdate(b, engine.computeIsSubspace(this, b))
+    }
+end Space
 
 /** Empty space */
 case object Empty extends Space
@@ -349,13 +358,6 @@ object SpaceEngine {
 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
@@ -398,7 +400,7 @@ class SpaceEngine(using Context) extends SpaceLogic {
       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)
+        if (fun.symbol.owner == defn.SeqFactoryClass && defn.ListType.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.
@@ -519,16 +521,16 @@ class SpaceEngine(using Context) extends SpaceLogic {
   /** Space of the pattern: unapplySeq(a, b, c: _*)
    */
   def projectSeq(pats: List[Tree]): Space = {
-    if (pats.isEmpty) return Typ(scalaNilType, false)
+    if (pats.isEmpty) return Typ(defn.NilType, false)
 
     val (items, zero) = if (isWildcardStarArg(pats.last))
-      (pats.init, Typ(scalaListType.appliedTo(pats.last.tpe.elemType), false))
+      (pats.init, Typ(defn.ListType.appliedTo(pats.last.tpe.elemType), false))
     else
-      (pats, Typ(scalaNilType, false))
+      (pats, Typ(defn.NilType, false))
 
-    val unapplyTp = scalaConsType.classSymbol.companionModule.termRef.select(nme.unapply)
+    val unapplyTp = defn.ConsType.classSymbol.companionModule.termRef.select(nme.unapply)
     items.foldRight[Space](zero) { (pat, acc) =>
-      val consTp = scalaConsType.appliedTo(pats.head.tpe.widen)
+      val consTp = defn.ConsType.appliedTo(pats.head.tpe.widen)
       Prod(consTp, unapplyTp, project(pat) :: acc :: Nil)
     }
   }
@@ -538,13 +540,14 @@ class SpaceEngine(using Context) extends SpaceLogic {
 
   private val isSubspaceCache = mutable.HashMap.empty[(Space, Space, Context), Boolean]
 
-  override def isSubspace(a: Space, b: Space)(using Context): Boolean =
-    isSubspaceCache.getOrElseUpdate((a, b, ctx), super.isSubspace(a, b))
+  override def isSubspace(a: Space, b: Space)(using Context): Boolean = a.isSubspace(b)(this)
+
+  def computeIsSubspace(a: Space, b: Space)(using Context): Boolean = 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
+    if tp1 == ConstantType(Constant(null)) && !ctx.mode.is(Mode.SafeNulls)
+    then tp2 == ConstantType(Constant(null))
     else tp1 <:< tp2
   }
 
@@ -593,10 +596,10 @@ class SpaceEngine(using Context) extends SpaceLogic {
 
         if (isUnapplySeq) {
           val (arity, elemTp, resultTp) = unapplySeqInfo(resTp, unappSym.srcPos)
-          if (elemTp.exists) scalaListType.appliedTo(elemTp) :: Nil
+          if (elemTp.exists) defn.ListType.appliedTo(elemTp) :: Nil
           else {
             val sels = productSeqSelectors(resultTp, arity, unappSym.srcPos)
-            sels.init :+ scalaListType.appliedTo(sels.last)
+            sels.init :+ defn.ListType.appliedTo(sels.last)
           }
         }
         else {
@@ -821,7 +824,7 @@ class SpaceEngine(using Context) extends SpaceLogic {
       case Empty => "empty"
       case Typ(c: ConstantType, _) => "" + c.value.value
       case Typ(tp: TermRef, _) =>
-        if (flattenList && tp <:< scalaNilType) ""
+        if (flattenList && tp <:< defn.NilType) ""
         else tp.symbol.showName
       case Typ(tp, decomposed) =>
 
@@ -829,9 +832,9 @@ class SpaceEngine(using Context) extends SpaceLogic {
 
         if (ctx.definitions.isTupleNType(tp))
           params(tp).map(_ => "_").mkString("(", ", ", ")")
-        else if (scalaListType.isRef(sym))
+        else if (defn.ListType.isRef(sym))
           if (flattenList) "_*" else "_: List"
-        else if (scalaConsType.isRef(sym))
+        else if (defn.ConsType.isRef(sym))
           if (flattenList) "_, _*"  else "List(_, _*)"
         else if (tp.classSymbol.is(Sealed) && tp.classSymbol.hasAnonymousChild)
           "_: " + showType(tp) + " (anonymous)"
@@ -843,7 +846,7 @@ class SpaceEngine(using Context) extends SpaceLogic {
       case Prod(tp, fun, params) =>
         if (ctx.definitions.isTupleNType(tp))
           "(" + params.map(doShow(_)).mkString(", ") + ")"
-        else if (tp.isRef(scalaConsType.symbol))
+        else if (tp.isRef(defn.ConsType.symbol))
           if (flattenList) params.map(doShow(_, flattenList)).filter(_.nonEmpty).mkString(", ")
           else params.map(doShow(_, flattenList = true)).filter(!_.isEmpty).mkString("List(", ", ", ")")
         else {
@@ -961,7 +964,7 @@ class SpaceEngine(using Context) extends SpaceLogic {
 
     val isNullable = selTyp.classSymbol.isNullableClass
     val targetSpace = if isNullable
-      then project(OrType(selTyp, constantNullType, soft = false))
+      then project(OrType(selTyp, ConstantType(Constant(null)), soft = false))
       else project(selTyp)
     debug.println(s"targetSpace: ${show(targetSpace)}")
 
diff --git a/compiler/test/dotty/tools/dotc/transform/patmat/SpaceEngineTest.scala b/compiler/test/dotty/tools/dotc/transform/patmat/SpaceEngineTest.scala
index 699b36caa508..13dfb7af668a 100644
--- a/compiler/test/dotty/tools/dotc/transform/patmat/SpaceEngineTest.scala
+++ b/compiler/test/dotty/tools/dotc/transform/patmat/SpaceEngineTest.scala
@@ -20,7 +20,7 @@ class SpaceEngineTest:
     val engine = patmat.SpaceEngine()
     import engine.*
 
-    val tp      = defn.ConsClass.typeRef.appliedTo(defn.AnyType)
+    val tp      = defn.ConsType.appliedTo(defn.AnyType)
     val unappTp = requiredMethod("scala.collection.immutable.::.unapply").termRef
     val params  = List(Empty, Typ(tp))
 

From 5a21922cb75d9dafde9a5f1cb8b1a8ab97f33e44 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Mon, 9 Jan 2023 17:29:16 +0000
Subject: [PATCH 162/657] Space: Remove SpaceLogic and make SpaceEngine
 stateless

---
 .../tools/dotc/transform/PatternMatcher.scala |  13 +-
 .../tools/dotc/transform/patmat/Space.scala   | 136 +++++++-----------
 .../transform/patmat/SpaceEngineTest.scala    |   4 +-
 3 files changed, 60 insertions(+), 93 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala b/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala
index 63ffdffbddef..82828078e586 100644
--- a/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala
@@ -2,11 +2,10 @@ 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 patmat.SpaceEngine
 import util.Spans._
 import typer.Applications.*
 import SymUtils._
@@ -16,9 +15,12 @@ import Decorators._
 import NameKinds.{PatMatStdBinderName, PatMatAltsName, PatMatResultName}
 import config.Printers.patmatch
 import reporting._
-import dotty.tools.dotc.ast._
+import ast._
 import util.Property._
 
+import scala.annotation.tailrec
+import scala.collection.mutable
+
 /** 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
@@ -45,9 +47,8 @@ class PatternMatcher extends MiniPhase {
       val translated = new Translator(matchType, this).translateMatch(tree)
 
       // check exhaustivity and unreachability
-      val engine = new patmat.SpaceEngine
-      engine.checkExhaustivity(tree)
-      engine.checkRedundancy(tree)
+      SpaceEngine.checkExhaustivity(tree)
+      SpaceEngine.checkRedundancy(tree)
 
       translated.ensureConforms(matchType)
     }
diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index 7071e3b46829..b6da5f2dba9c 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -22,9 +22,10 @@ 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
+import scala.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
@@ -53,16 +54,17 @@ import collection.mutable
  *
  */
 
-
 /** space definition */
 sealed trait Space:
+  import SpaceEngine.*
+
   private val isSubspaceCache = mutable.HashMap.empty[Space, Boolean]
 
-  def isSubspace(b: Space)(engine: SpaceEngine)(using Context): Boolean =
+  def isSubspace(b: Space)(using Context): Boolean =
     if this == Empty then true
     else if b == Empty then false
-    else trace(s"isSubspace(${engine.show(this)}, ${engine.show(b)})", debug) {
-      isSubspaceCache.getOrElseUpdate(b, engine.computeIsSubspace(this, b))
+    else trace(s"isSubspace(${show(this)}, ${show(b)})", debug) {
+      isSubspaceCache.getOrElseUpdate(b, computeIsSubspace(this, b))
     }
 end Space
 
@@ -83,44 +85,8 @@ 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
+object SpaceEngine {
+  import tpd._
 
   /** 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 {
@@ -174,7 +140,9 @@ trait SpaceLogic {
   }
 
   /** Is `a` a subspace of `b`? Equivalent to `simplify(simplify(a) - simplify(b)) == Empty`, but faster */
-  def isSubspace(a: Space, b: Space)(using Context): Boolean = trace(s"isSubspace(${show(a)}, ${show(b)})", debug) {
+  def isSubspace(a: Space, b: Space)(using Context): Boolean = a.isSubspace(b)
+
+  def computeIsSubspace(a: Space, b: Space)(using Context): Boolean = {
     def tryDecompose1(tp: Type) = canDecompose(tp) && isSubspace(Or(decompose(tp)), b)
     def tryDecompose2(tp: Type) = canDecompose(tp) && isSubspace(a, Or(decompose(tp)))
 
@@ -302,9 +270,6 @@ trait SpaceLogic {
           Or(spaces)
     }
   }
-}
-
-object SpaceEngine {
 
   /** Is the unapply or unapplySeq irrefutable?
    *  @param  unapp   The unapply function reference
@@ -352,13 +317,13 @@ object SpaceEngine {
 
       case _ => false
   }
-}
-
-/** Scala implementation of space logic */
-class SpaceEngine(using Context) extends SpaceLogic {
-  import tpd._
 
-  override def intersectUnrelatedAtomicTypes(tp1: Type, tp2: Type): Space = trace(s"atomic intersection: ${AndType(tp1, tp2).show}", debug) {
+  /** 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)(using Context): Space = trace(i"atomic intersection: ${AndType(tp1, tp2)}", 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.
@@ -373,7 +338,7 @@ class SpaceEngine(using Context) extends SpaceLogic {
   }
 
   /** Return the space that represents the pattern `pat` */
-  def project(pat: Tree): Space = pat match {
+  def project(pat: Tree)(using Context): Space = pat match {
     case Literal(c) =>
       if (c.value.isInstanceOf[Symbol])
         Typ(c.value.asInstanceOf[Symbol].termRef, decomposed = false)
@@ -436,12 +401,12 @@ class SpaceEngine(using Context) extends SpaceLogic {
       Typ(pat.tpe.narrow, decomposed = false)
   }
 
-  private def project(tp: Type): Space = tp match {
+  private def project(tp: Type)(using Context): 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) = {
+  private def unapplySeqInfo(resTp: Type, pos: SrcPos)(using Context): (Int, Type, Type) = {
     var resultTp = resTp
     var elemTp = unapplySeqTypeElemTp(resultTp)
     var arity = productArity(resultTp, pos)
@@ -488,7 +453,7 @@ class SpaceEngine(using Context) extends SpaceLogic {
    *  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) {
+  private def erase(tp: Type, inArray: Boolean = false, isValue: Boolean = false)(using Context): Type = trace(i"$tp erased to", debug) {
 
     tp match {
       case tp @ AppliedType(tycon, args) if tycon.typeSymbol.isPatternBound =>
@@ -520,7 +485,7 @@ class SpaceEngine(using Context) extends SpaceLogic {
 
   /** Space of the pattern: unapplySeq(a, b, c: _*)
    */
-  def projectSeq(pats: List[Tree]): Space = {
+  def projectSeq(pats: List[Tree])(using Context): Space = {
     if (pats.isEmpty) return Typ(defn.NilType, false)
 
     val (items, zero) = if (isWildcardStarArg(pats.last))
@@ -535,29 +500,30 @@ class SpaceEngine(using Context) extends SpaceLogic {
     }
   }
 
-  def isPrimToBox(tp: Type, pt: Type): Boolean =
+  def isPrimToBox(tp: Type, pt: Type)(using Context): Boolean =
     tp.isPrimitiveValueType && (defn.boxedType(tp).classSymbol eq pt.classSymbol)
 
-  private val isSubspaceCache = mutable.HashMap.empty[(Space, Space, Context), Boolean]
-
-  override def isSubspace(a: Space, b: Space)(using Context): Boolean = a.isSubspace(b)(this)
-
-  def computeIsSubspace(a: Space, b: Space)(using Context): Boolean = super.isSubspace(a, b)
-
   /** Is `tp1` a subtype of `tp2`?  */
-  def isSubType(tp1: Type, tp2: Type): Boolean = trace(i"$tp1 <:< $tp2", debug, show = true) {
+  def isSubType(tp1: Type, tp2: Type)(using Context): Boolean = trace(i"$tp1 <:< $tp2", debug, show = true) {
     if tp1 == ConstantType(Constant(null)) && !ctx.mode.is(Mode.SafeNulls)
     then tp2 == ConstantType(Constant(null))
     else tp1 <:< tp2
   }
 
-  def isSameUnapply(tp1: TermRef, tp2: TermRef): 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)(using Context): 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] = {
+  /** Return term parameter types of the extractor `unapp`.
+   *  Parameter types of the case class type `tp`. Adapted from `unapplyPlan` in patternMatcher  */
+  def signature(unapp: TermRef, scrutineeTp: Type, argLen: Int)(using Context): List[Type] = {
     val unappSym = unapp.symbol
 
     // println("scrutineeTp = " + scrutineeTp.show)
@@ -620,14 +586,14 @@ class SpaceEngine(using Context) extends SpaceLogic {
   }
 
   /** Whether the extractor covers the given type */
-  def covers(unapp: TermRef, scrutineeTp: Type, argLen: Int): Boolean =
+  def covers(unapp: TermRef, scrutineeTp: Type, argLen: Int)(using Context): 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] = trace(i"decompose($tp)", debug, show(_: Seq[Space])) {
+  def decompose(tp: Type)(using Context): List[Typ] = trace(i"decompose($tp)", debug, showSpaces) {
     def rec(tp: Type, mixins: List[Type]): List[Typ] = tp.dealias match {
       case AndType(tp1, tp2) =>
         def decomposeComponent(tpA: Type, tpB: Type): List[Typ] =
@@ -708,7 +674,7 @@ class SpaceEngine(using Context) extends SpaceLogic {
   }
 
   /** Abstract sealed types, or-types, Boolean and Java enums can be decomposed */
-  def canDecompose(tp: Type): Boolean =
+  def canDecompose(tp: Type)(using Context): Boolean =
     val res = tp.dealias match
       case AppliedType(tycon, _) if canDecompose(tycon) => true
       case tp: NamedType if canDecompose(tp.prefix) => true
@@ -735,7 +701,7 @@ class SpaceEngine(using Context) extends SpaceLogic {
    *          C            -->  C     if current owner is C !!!
    *
    */
-  def showType(tp: Type, showTypeArgs: Boolean = false): String = {
+  def showType(tp: Type, showTypeArgs: Boolean = false)(using Context): String = {
     val enclosingCls = ctx.owner.enclosingClass
 
     def isOmittable(sym: Symbol) =
@@ -776,7 +742,7 @@ class SpaceEngine(using Context) extends SpaceLogic {
   }
 
   /** Whether the counterexample is satisfiable. The space is flattened and non-empty. */
-  def satisfiable(sp: Space): Boolean = {
+  def satisfiable(sp: Space)(using Context): Boolean = {
     def impossible: Nothing = throw new AssertionError("`satisfiable` only accepts flattened space.")
 
     def genConstraint(space: Space): List[(Type, Type)] = space match {
@@ -807,10 +773,10 @@ class SpaceEngine(using Context) extends SpaceLogic {
     checkConstraint(genConstraint(sp))(using ctx.fresh.setNewTyperState())
   }
 
-  def show(ss: Seq[Space]): String = ss.map(show).mkString(", ")
+  def showSpaces(ss: Seq[Space])(using Context): String = ss.map(show).mkString(", ")
 
   /** Display spaces */
-  def show(s: Space): String = {
+  def show(s: Space)(using Context): String = {
     def params(tp: Type): List[Type] = tp.classSymbol.primaryConstructor.info.firstParamTypes
 
     /** does the companion object of the given symbol have custom unapply */
@@ -862,7 +828,7 @@ class SpaceEngine(using Context) extends SpaceLogic {
     doShow(s, flattenList = false)
   }
 
-  private def exhaustivityCheckable(sel: Tree): Boolean = {
+  private def exhaustivityCheckable(sel: Tree)(using Context): Boolean = {
     val seen = collection.mutable.Set.empty[Type]
 
     // Possible to check everything, but be compatible with scalac by default
@@ -891,8 +857,8 @@ class SpaceEngine(using Context) extends SpaceLogic {
     res
   }
 
-  /** Whehter counter-examples should be further checked? True for GADTs. */
-  private def shouldCheckExamples(tp: Type): Boolean =
+  /** Whether counter-examples should be further checked? True for GADTs. */
+  private def shouldCheckExamples(tp: Type)(using Context): 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
@@ -903,7 +869,7 @@ class SpaceEngine(using Context) extends SpaceLogic {
   /** 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 {
+  def toUnderlying(tp: Type)(using Context): 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
@@ -913,7 +879,7 @@ class SpaceEngine(using Context) extends SpaceLogic {
     case _                                          => tp
   })
 
-  def checkExhaustivity(_match: Match): Unit = {
+  def checkExhaustivity(_match: Match)(using Context): Unit = {
     val Match(sel, cases) = _match
     debug.println(i"checking exhaustivity of ${_match}")
 
@@ -939,10 +905,10 @@ class SpaceEngine(using Context) extends SpaceLogic {
     if uncovered.nonEmpty then
       val hasMore = uncovered.lengthCompare(6) > 0
       val deduped = dedup(uncovered.take(6))
-      report.warning(PatternMatchExhaustivity(show(deduped), hasMore), sel.srcPos)
+      report.warning(PatternMatchExhaustivity(showSpaces(deduped), hasMore), sel.srcPos)
   }
 
-  private def redundancyCheckable(sel: Tree): Boolean =
+  private def redundancyCheckable(sel: Tree)(using Context): 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
@@ -952,7 +918,7 @@ class SpaceEngine(using Context) extends SpaceLogic {
     && !sel.tpe.widen.isRef(defn.QuotedExprClass)
     && !sel.tpe.widen.isRef(defn.QuotedTypeClass)
 
-  def checkRedundancy(_match: Match): Unit = {
+  def checkRedundancy(_match: Match)(using Context): Unit = {
     val Match(sel, _) = _match
     val cases = _match.cases.toIndexedSeq
     debug.println(i"checking redundancy in $_match")
diff --git a/compiler/test/dotty/tools/dotc/transform/patmat/SpaceEngineTest.scala b/compiler/test/dotty/tools/dotc/transform/patmat/SpaceEngineTest.scala
index 13dfb7af668a..c13ef0532348 100644
--- a/compiler/test/dotty/tools/dotc/transform/patmat/SpaceEngineTest.scala
+++ b/compiler/test/dotty/tools/dotc/transform/patmat/SpaceEngineTest.scala
@@ -11,14 +11,14 @@ import vulpix.TestConfiguration, TestConfiguration.basicClasspath
 import org.junit, junit.Test, junit.Assert.*
 
 class SpaceEngineTest:
+  import SpaceEngine.*
+
   @Test def isSubspaceTest1: Unit = inCompilerContext(basicClasspath) {
     // Testing the property of `isSubspace` that:
     // isSubspace(a, b)  <=>  simplify(simplify(a) - simplify(a)) == Empty
     // Previously there were no simplify calls,
     // and this is a counter-example,
     // for which you need either to simplify(b) or simplify the minus result.
-    val engine = patmat.SpaceEngine()
-    import engine.*
 
     val tp      = defn.ConsType.appliedTo(defn.AnyType)
     val unappTp = requiredMethod("scala.collection.immutable.::.unapply").termRef

From 53a782751ac5eb21d84b137e8d23d4d49bd422f0 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Mon, 9 Jan 2023 20:34:44 +0000
Subject: [PATCH 163/657] Space: dedupe into intersectUnrelatedAtomicTypes

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

diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index b6da5f2dba9c..d903d9e122a4 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -187,25 +187,19 @@ object SpaceEngine {
         else if (isSubType(tp2, tp1)) b
         else if (canDecompose(tp1)) tryDecompose1(tp1)
         else if (canDecompose(tp2)) tryDecompose2(tp2)
-        else intersectUnrelatedAtomicTypes(tp1, tp2)
+        else intersectUnrelatedAtomicTypes(tp1, tp2)(a)
       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
+        else intersectUnrelatedAtomicTypes(tp1, tp2)(b)
       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
+        else intersectUnrelatedAtomicTypes(tp1, tp2)(a)
       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
+        if (!isSameUnapply(fun1, fun2)) intersectUnrelatedAtomicTypes(tp1, tp2)(a)
         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))
     }
@@ -323,13 +317,15 @@ object SpaceEngine {
    * The types should be atomic (non-decomposable) and unrelated (neither
    * should be a subtype of the other).
    */
-  def intersectUnrelatedAtomicTypes(tp1: Type, tp2: Type)(using Context): Space = trace(i"atomic intersection: ${AndType(tp1, tp2)}", debug) {
+  def intersectUnrelatedAtomicTypes(tp1: Type, tp2: Type)(sp: Space)(using Context): Space = trace(i"atomic intersection: ${AndType(tp1, tp2)}", 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)
+      val intersection = sp match
+        case sp: Prod => sp.copy(AndType(tp1, tp2))
+        case _        => 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

From 23cee40af14f625c607e96e1bc31f092cc16715d Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Thu, 16 Feb 2023 10:58:36 +0000
Subject: [PATCH 164/657] Space: Prep for caching decompose/canDecompose on Typ

---
 .../tools/dotc/transform/patmat/Space.scala   | 157 ++++++++----------
 1 file changed, 67 insertions(+), 90 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index d903d9e122a4..3003bea962ca 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -92,16 +92,16 @@ object SpaceEngine {
   def simplify(space: Space)(using Context): Space = trace(s"simplify ${show(space)} --> ", debug, show)(space match {
     case Prod(tp, fun, spaces) =>
       val sps = spaces.mapconserve(simplify)
-      if (sps.contains(Empty)) Empty
-      else if (canDecompose(tp) && decompose(tp).isEmpty) Empty
+      if sps.contains(Empty) then Empty
+      else if canDecompose(tp) && decompose(tp).isEmpty then Empty
       else if sps eq spaces then space else Prod(tp, fun, sps)
     case Or(spaces) =>
       val spaces2 = spaces.map(simplify).filter(_ != Empty)
       if spaces2.isEmpty then Empty
       else if spaces2.lengthIs == 1 then spaces2.head
       else if spaces2.corresponds(spaces)(_ eq _) then space else Or(spaces2)
-    case Typ(tp, _) =>
-      if (canDecompose(tp) && decompose(tp).isEmpty) Empty
+    case typ: Typ =>
+      if canDecompose(typ.tp) && decompose(typ.tp).isEmpty then Empty
       else space
     case _ => space
   })
@@ -143,25 +143,21 @@ object SpaceEngine {
   def isSubspace(a: Space, b: Space)(using Context): Boolean = a.isSubspace(b)
 
   def computeIsSubspace(a: Space, b: Space)(using Context): Boolean = {
-    def tryDecompose1(tp: Type) = canDecompose(tp) && isSubspace(Or(decompose(tp)), b)
-    def tryDecompose2(tp: Type) = canDecompose(tp) && isSubspace(a, Or(decompose(tp)))
-
     val a2 = simplify(a)
     val b2 = simplify(b)
     if (a ne a2) || (b ne b2) then isSubspace(a2, b2)
     else (a, b) match {
       case (Empty, _) => true
       case (_, Empty) => false
-      case (Or(ss), _) =>
-        ss.forall(isSubspace(_, b))
-      case (Typ(tp1, _), Typ(tp2, _)) =>
+      case (Or(ss), _) => ss.forall(isSubspace(_, b))
+      case (a @ Typ(tp1, _), Or(ss)) =>  // optimization: don't go to subtraction too early
+        ss.exists(isSubspace(a, _))
+        || canDecompose(tp1) && isSubspace(Or(decompose(tp1)), b)
+      case (_, Or(_))  => simplify(minus(a, b)) == Empty
+      case (a @ Typ(tp1, _), b @ 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
+        || canDecompose(tp1) && isSubspace(Or(decompose(tp1)), b)
+        || canDecompose(tp2) && isSubspace(a, Or(decompose(tp2)))
       case (Prod(tp1, _, _), Typ(tp2, _)) =>
         isSubType(tp1, tp2)
       case (Typ(tp1, _), Prod(tp2, fun, ss)) =>
@@ -169,90 +165,74 @@ object SpaceEngine {
         && covers(fun, tp1, ss.length)
         && isSubspace(Prod(tp2, fun, signature(fun, tp1, ss.length).map(Typ(_, false))), b)
       case (Prod(_, fun1, ss1), Prod(_, fun2, ss2)) =>
-        isSameUnapply(fun1, fun2) && ss1.zip(ss2).forall((isSubspace _).tupled)
+        isSameUnapply(fun1, fun2) && ss1.lazyZip(ss2).forall(isSubspace)
     }
   }
 
   /** 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)
+      case (a @ Typ(tp1, _), b @ Typ(tp2, _)) =>
+        if isSubType(tp1, tp2) then a
+        else if isSubType(tp2, tp1) then b
+        else if canDecompose(tp1) then intersect(Or(decompose(tp1)), b)
+        else if canDecompose(tp2) then intersect(a, Or(decompose(tp2)))
         else intersectUnrelatedAtomicTypes(tp1, tp2)(a)
-      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
+      case (a @ Typ(tp1, _), Prod(tp2, fun, ss)) =>
+        if isSubType(tp2, tp1) then b
+        else if canDecompose(tp1) then intersect(Or(decompose(tp1)), b)
+        else if isSubType(tp1, tp2) then a // problematic corner case: inheriting a case class
         else intersectUnrelatedAtomicTypes(tp1, tp2)(b)
-      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
+      case (Prod(tp1, fun, ss), b @ Typ(tp2, _)) =>
+        if isSubType(tp1, tp2) then a
+        else if canDecompose(tp2) then intersect(a, Or(decompose(tp2)))
+        else if isSubType(tp2, tp1) then a  // problematic corner case: inheriting a case class
         else intersectUnrelatedAtomicTypes(tp1, tp2)(a)
-      case (Prod(tp1, fun1, ss1), Prod(tp2, fun2, ss2)) =>
-        if (!isSameUnapply(fun1, fun2)) intersectUnrelatedAtomicTypes(tp1, tp2)(a)
-        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))
+      case (a @ Prod(tp1, fun1, ss1), Prod(tp2, fun2, ss2)) =>
+        if !isSameUnapply(fun1, fun2) then intersectUnrelatedAtomicTypes(tp1, tp2)(a)
+        else if ss1.lazyZip(ss2).exists((a, b) => simplify(intersect(a, b)) == Empty) then Empty
+        else Prod(tp1, fun1, ss1.lazyZip(ss2).map(intersect))
     }
   }
 
   /** 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)
+      case (Or(ss), _) => Or(ss.map(minus(_, b)))
+      case (_, Or(ss)) => ss.foldLeft(a)(minus)
+      case (a @ Typ(tp1, _), b @ Typ(tp2, _)) =>
+        if isSubType(tp1, tp2) then Empty
+        else if canDecompose(tp1) then minus(Or(decompose(tp1)), b)
+        else if canDecompose(tp2) then minus(a, Or(decompose(tp2)))
         else a
-      case (Typ(tp1, _), Prod(tp2, fun, ss)) =>
+      case (a @ 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, _)) =>
+        else if canDecompose(tp1) then minus(Or(decompose(tp1)), b)
+        else a
+      case (Prod(tp1, fun, ss), b @ 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
+        if isSubType(tp1, tp2) then Empty
+        else if simplify(a) == Empty then Empty
+        else if canDecompose(tp2) then minus(a, Or(decompose(tp2)))
+        else a
       case (Prod(tp1, fun1, ss1), Prod(tp2, fun2, ss2))
-        if (!isSameUnapply(fun1, fun2)) => a
+          if !isSameUnapply(fun1, fun2) => a
       case (Prod(tp1, fun1, ss1), Prod(tp2, fun2, ss2))
-        if (fun1.symbol.name == nme.unapply && ss1.length != ss2.length) => a
-      case (Prod(tp1, fun1, ss1), Prod(tp2, fun2, ss2)) =>
-
-        val range = (0 until ss1.size).toList
+          if fun1.symbol.name == nme.unapply && ss1.length != ss2.length => a
+      case (a @ Prod(tp1, fun1, ss1), Prod(tp2, fun2, ss2)) =>
+        val range = ss1.indices.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
@@ -610,26 +590,26 @@ object SpaceEngine {
         else
           decomposeComponent(tp2, tp1)
 
-      case OrType(tp1, tp2) => List(Typ(tp1, true), Typ(tp2, true))
+      case OrType(tp1, tp2) => List(Typ(tp1, decomposed = true), Typ(tp2, decomposed = true))
       case tp if tp.isRef(defn.BooleanClass) =>
         List(
-          Typ(ConstantType(Constant(true)), true),
-          Typ(ConstantType(Constant(false)), true)
+          Typ(ConstantType(Constant(true)), decomposed = true),
+          Typ(ConstantType(Constant(false)), decomposed = true)
         )
       case tp if tp.isRef(defn.UnitClass) =>
-        Typ(ConstantType(Constant(())), true) :: Nil
+        Typ(ConstantType(Constant(())), decomposed = true) :: Nil
       case tp if tp.classSymbol.isAllOf(JavaEnumTrait) =>
-        tp.classSymbol.children.map(sym => Typ(sym.termRef, true))
+        tp.classSymbol.children.map(sym => Typ(sym.termRef, decomposed = true))
 
       case tp @ AppliedType(tycon, targs) if tp.classSymbol.children.isEmpty && canDecompose(tycon) =>
         // It might not obvious that it's OK to apply the type arguments of a parent type to child types.
         // But this is guarded by `tp.classSymbol.children.isEmpty`,
         // meaning we'll decompose to the same class, just not the same type.
         // For instance, from i15029, `decompose((X | Y).Field[T]) = [X.Field[T], Y.Field[T]]`.
-        rec(tycon, Nil).map(typ => Typ(tp.derivedAppliedType(typ.tp, targs)))
+        rec(tycon, Nil).map(typ => Typ(tp.derivedAppliedType(typ.tp, targs), decomposed = true))
 
       case tp: NamedType if canDecompose(tp.prefix) =>
-        rec(tp.prefix, Nil).map(typ => Typ(tp.derivedSelect(typ.tp)))
+        rec(tp.prefix, Nil).map(typ => Typ(tp.derivedSelect(typ.tp), decomposed = true))
 
       case tp =>
         def getChildren(sym: Symbol): List[Symbol] =
@@ -641,30 +621,27 @@ object SpaceEngine {
             else List(child)
           }
         val children = getChildren(tp.classSymbol)
-        debug.println(s"candidates for ${tp.show} : [${children.map(_.show).mkString(", ")}]")
+        debug.println(i"candidates for $tp : $children")
 
         val parts = children.map { sym =>
           val sym1 = if (sym.is(ModuleClass)) sym.sourceModule else sym
           val refined = TypeOps.refineUsingParent(tp, sym1, mixins)
+          debug.println(i"$sym1 refined to $refined")
 
-          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
-            }
+          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
+          if inhabited(refined) then refined
           else NoType
-        } filter(_.exists)
+        }.filter(_.exists)
 
-        debug.println(s"${tp.show} decomposes to [${parts.map(_.show).mkString(", ")}]")
+        debug.println(i"$tp decomposes to $parts")
 
-        parts.map(Typ(_, true))
+        parts.map(Typ(_, decomposed = true))
     }
     rec(tp, Nil)
   }

From e316f65a54e17c86bf06d83ff6c447f27a72c690 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Thu, 16 Feb 2023 11:07:05 +0000
Subject: [PATCH 165/657] Space: Cache decompose/canDecompose on Typ

---
 .../tools/dotc/transform/patmat/Space.scala   | 40 +++++++++++++------
 1 file changed, 27 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 3003bea962ca..d10fb537cb3a 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -77,7 +77,18 @@ case object Empty extends Space
  * @param decomposed: does the space result from decomposition? Used for pretty print
  *
  */
-case class Typ(tp: Type, decomposed: Boolean = true) extends Space
+case class Typ(tp: Type, decomposed: Boolean = true) extends Space:
+  private var myCanDecompose: java.lang.Boolean = _
+  private var myDecompose: List[Typ] = _
+
+  def canDecompose(using Context): Boolean =
+    if myCanDecompose == null then myCanDecompose = SpaceEngine.canDecompose(tp)
+    myCanDecompose
+
+  def decompose(using Context): List[Typ] =
+    if myDecompose == null then myDecompose = SpaceEngine.decompose(tp)
+    myDecompose
+end Typ
 
 /** Space representing an extractor pattern */
 case class Prod(tp: Type, unappTp: TermRef, params: List[Space]) extends Space
@@ -101,7 +112,7 @@ object SpaceEngine {
       else if spaces2.lengthIs == 1 then spaces2.head
       else if spaces2.corresponds(spaces)(_ eq _) then space else Or(spaces2)
     case typ: Typ =>
-      if canDecompose(typ.tp) && decompose(typ.tp).isEmpty then Empty
+      if canDecompose(typ) && decompose(typ).isEmpty then Empty
       else space
     case _ => space
   })
@@ -152,12 +163,12 @@ object SpaceEngine {
       case (Or(ss), _) => ss.forall(isSubspace(_, b))
       case (a @ Typ(tp1, _), Or(ss)) =>  // optimization: don't go to subtraction too early
         ss.exists(isSubspace(a, _))
-        || canDecompose(tp1) && isSubspace(Or(decompose(tp1)), b)
+        || canDecompose(a) && isSubspace(Or(decompose(a)), b)
       case (_, Or(_))  => simplify(minus(a, b)) == Empty
       case (a @ Typ(tp1, _), b @ Typ(tp2, _)) =>
         isSubType(tp1, tp2)
-        || canDecompose(tp1) && isSubspace(Or(decompose(tp1)), b)
-        || canDecompose(tp2) && isSubspace(a, Or(decompose(tp2)))
+        || canDecompose(a) && isSubspace(Or(decompose(a)), b)
+        || canDecompose(b) && isSubspace(a, Or(decompose(b)))
       case (Prod(tp1, _, _), Typ(tp2, _)) =>
         isSubType(tp1, tp2)
       case (Typ(tp1, _), Prod(tp2, fun, ss)) =>
@@ -178,17 +189,17 @@ object SpaceEngine {
       case (a @ Typ(tp1, _), b @ Typ(tp2, _)) =>
         if isSubType(tp1, tp2) then a
         else if isSubType(tp2, tp1) then b
-        else if canDecompose(tp1) then intersect(Or(decompose(tp1)), b)
-        else if canDecompose(tp2) then intersect(a, Or(decompose(tp2)))
+        else if canDecompose(a) then intersect(Or(decompose(a)), b)
+        else if canDecompose(b) then intersect(a, Or(decompose(b)))
         else intersectUnrelatedAtomicTypes(tp1, tp2)(a)
       case (a @ Typ(tp1, _), Prod(tp2, fun, ss)) =>
         if isSubType(tp2, tp1) then b
-        else if canDecompose(tp1) then intersect(Or(decompose(tp1)), b)
+        else if canDecompose(a) then intersect(Or(decompose(a)), b)
         else if isSubType(tp1, tp2) then a // problematic corner case: inheriting a case class
         else intersectUnrelatedAtomicTypes(tp1, tp2)(b)
       case (Prod(tp1, fun, ss), b @ Typ(tp2, _)) =>
         if isSubType(tp1, tp2) then a
-        else if canDecompose(tp2) then intersect(a, Or(decompose(tp2)))
+        else if canDecompose(b) then intersect(a, Or(decompose(b)))
         else if isSubType(tp2, tp1) then a  // problematic corner case: inheriting a case class
         else intersectUnrelatedAtomicTypes(tp1, tp2)(a)
       case (a @ Prod(tp1, fun1, ss1), Prod(tp2, fun2, ss2)) =>
@@ -207,20 +218,20 @@ object SpaceEngine {
       case (_, Or(ss)) => ss.foldLeft(a)(minus)
       case (a @ Typ(tp1, _), b @ Typ(tp2, _)) =>
         if isSubType(tp1, tp2) then Empty
-        else if canDecompose(tp1) then minus(Or(decompose(tp1)), b)
-        else if canDecompose(tp2) then minus(a, Or(decompose(tp2)))
+        else if canDecompose(a) then minus(Or(decompose(a)), b)
+        else if canDecompose(b) then minus(a, Or(decompose(b)))
         else a
       case (a @ 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 minus(Or(decompose(tp1)), b)
+        else if canDecompose(a) then minus(Or(decompose(a)), b)
         else a
       case (Prod(tp1, fun, ss), b @ Typ(tp2, _)) =>
         // uncovered corner case: tp2 :< tp1, may happen when inheriting case class
         if isSubType(tp1, tp2) then Empty
         else if simplify(a) == Empty then Empty
-        else if canDecompose(tp2) then minus(a, Or(decompose(tp2)))
+        else if canDecompose(b) then minus(a, Or(decompose(b)))
         else a
       case (Prod(tp1, fun1, ss1), Prod(tp2, fun2, ss2))
           if !isSameUnapply(fun1, fun2) => a
@@ -568,6 +579,9 @@ object SpaceEngine {
       scrutineeTp <:< tp
     }
 
+  def canDecompose(typ: Typ)(using Context): Boolean = typ.canDecompose
+  def decompose(typ: Typ)(using Context): List[Typ]  = typ.decompose
+
   /** Decompose a type into subspaces -- assume the type can be decomposed */
   def decompose(tp: Type)(using Context): List[Typ] = trace(i"decompose($tp)", debug, showSpaces) {
     def rec(tp: Type, mixins: List[Type]): List[Typ] = tp.dealias match {

From 512a3073ac7b0a46a7571dcfcce9f7dfd9c8509f Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Thu, 16 Feb 2023 11:44:24 +0000
Subject: [PATCH 166/657] Space: Move out Typ-wrapping in decompose

---
 .../tools/dotc/transform/patmat/Space.scala   | 36 ++++++++-----------
 1 file changed, 15 insertions(+), 21 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index d10fb537cb3a..de92a3c01076 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -584,19 +584,13 @@ object SpaceEngine {
 
   /** Decompose a type into subspaces -- assume the type can be decomposed */
   def decompose(tp: Type)(using Context): List[Typ] = trace(i"decompose($tp)", debug, showSpaces) {
-    def rec(tp: Type, mixins: List[Type]): List[Typ] = tp.dealias match {
+    def rec(tp: Type, mixins: List[Type]): List[Type] = tp.dealias match {
       case AndType(tp1, tp2) =>
-        def decomposeComponent(tpA: Type, tpB: Type): List[Typ] =
-          rec(tpA, tpB :: mixins).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
+        def decomposeComponent(tpA: Type, tpB: Type): List[Type] =
+          rec(tpA, tpB :: mixins).collect {
+            case tp if tp <:< tpB                              => tp
+            case tp if tpB <:< tp                              => tpB
+            case tp if !TypeComparer.provablyDisjoint(tp, tpB) => AndType(tp, tpB)
           }
 
         if canDecompose(tp1) then
@@ -604,26 +598,26 @@ object SpaceEngine {
         else
           decomposeComponent(tp2, tp1)
 
-      case OrType(tp1, tp2) => List(Typ(tp1, decomposed = true), Typ(tp2, decomposed = true))
+      case OrType(tp1, tp2) => List(tp1, tp2)
       case tp if tp.isRef(defn.BooleanClass) =>
         List(
-          Typ(ConstantType(Constant(true)), decomposed = true),
-          Typ(ConstantType(Constant(false)), decomposed = true)
+          ConstantType(Constant(true)),
+          ConstantType(Constant(false))
         )
       case tp if tp.isRef(defn.UnitClass) =>
-        Typ(ConstantType(Constant(())), decomposed = true) :: Nil
+        ConstantType(Constant(())) :: Nil
       case tp if tp.classSymbol.isAllOf(JavaEnumTrait) =>
-        tp.classSymbol.children.map(sym => Typ(sym.termRef, decomposed = true))
+        tp.classSymbol.children.map(_.termRef)
 
       case tp @ AppliedType(tycon, targs) if tp.classSymbol.children.isEmpty && canDecompose(tycon) =>
         // It might not obvious that it's OK to apply the type arguments of a parent type to child types.
         // But this is guarded by `tp.classSymbol.children.isEmpty`,
         // meaning we'll decompose to the same class, just not the same type.
         // For instance, from i15029, `decompose((X | Y).Field[T]) = [X.Field[T], Y.Field[T]]`.
-        rec(tycon, Nil).map(typ => Typ(tp.derivedAppliedType(typ.tp, targs), decomposed = true))
+        rec(tycon, Nil).map(tp.derivedAppliedType(_, targs))
 
       case tp: NamedType if canDecompose(tp.prefix) =>
-        rec(tp.prefix, Nil).map(typ => Typ(tp.derivedSelect(typ.tp), decomposed = true))
+        rec(tp.prefix, Nil).map(tp.derivedSelect)
 
       case tp =>
         def getChildren(sym: Symbol): List[Symbol] =
@@ -655,9 +649,9 @@ object SpaceEngine {
 
         debug.println(i"$tp decomposes to $parts")
 
-        parts.map(Typ(_, decomposed = true))
+        parts
     }
-    rec(tp, Nil)
+    rec(tp, Nil).map(Typ(_, decomposed = true))
   }
 
   /** Abstract sealed types, or-types, Boolean and Java enums can be decomposed */

From 7f4009b891da72a3fe1fa3d44a16ba5f7105c761 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Thu, 16 Feb 2023 14:59:55 +0000
Subject: [PATCH 167/657] Space: Redefine canDecompose in terms of decompose

---
 .../tools/dotc/transform/patmat/Space.scala   | 113 ++++++++----------
 1 file changed, 52 insertions(+), 61 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index de92a3c01076..cffe6a378649 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -78,15 +78,12 @@ case object Empty extends Space
  *
  */
 case class Typ(tp: Type, decomposed: Boolean = true) extends Space:
-  private var myCanDecompose: java.lang.Boolean = _
   private var myDecompose: List[Typ] = _
 
-  def canDecompose(using Context): Boolean =
-    if myCanDecompose == null then myCanDecompose = SpaceEngine.canDecompose(tp)
-    myCanDecompose
+  def canDecompose(using Context): Boolean = decompose != SpaceEngine.ListOfTypNoType
 
   def decompose(using Context): List[Typ] =
-    if myDecompose == null then myDecompose = SpaceEngine.decompose(tp)
+    if myDecompose == null then myDecompose = SpaceEngine.decompose(tp).map(Typ(_, decomposed = true))
     myDecompose
 end Typ
 
@@ -104,7 +101,7 @@ object SpaceEngine {
     case Prod(tp, fun, spaces) =>
       val sps = spaces.mapconserve(simplify)
       if sps.contains(Empty) then Empty
-      else if canDecompose(tp) && decompose(tp).isEmpty then Empty
+      else if decompose(tp).isEmpty then Empty
       else if sps eq spaces then space else Prod(tp, fun, sps)
     case Or(spaces) =>
       val spaces2 = spaces.map(simplify).filter(_ != Empty)
@@ -112,7 +109,7 @@ object SpaceEngine {
       else if spaces2.lengthIs == 1 then spaces2.head
       else if spaces2.corresponds(spaces)(_ eq _) then space else Or(spaces2)
     case typ: Typ =>
-      if canDecompose(typ) && decompose(typ).isEmpty then Empty
+      if decompose(typ).isEmpty then Empty
       else space
     case _ => space
   })
@@ -583,43 +580,53 @@ object SpaceEngine {
   def decompose(typ: Typ)(using Context): List[Typ]  = typ.decompose
 
   /** Decompose a type into subspaces -- assume the type can be decomposed */
-  def decompose(tp: Type)(using Context): List[Typ] = trace(i"decompose($tp)", debug, showSpaces) {
-    def rec(tp: Type, mixins: List[Type]): List[Type] = tp.dealias match {
+  def decompose(tp: Type)(using Context): List[Type] = trace(i"decompose($tp)", debug) {
+    var lastType:  Type       = NoType
+    var lastParts: List[Type] = Nil
+    def dec(tp: Type)    =
+      if tp eq lastType then lastParts
+      else
+        lastType = tp
+        lastParts = decompose(tp)
+        lastParts
+    def canDec(tp: Type) =
+      lastParts = dec(tp)
+      lastParts != ListOfNoType
+
+    def rec(tp: Type, mixins: List[Type]): List[Type] = tp.dealias match
       case AndType(tp1, tp2) =>
-        def decomposeComponent(tpA: Type, tpB: Type): List[Type] =
-          rec(tpA, tpB :: mixins).collect {
-            case tp if tp <:< tpB                              => tp
-            case tp if tpB <:< tp                              => tpB
-            case tp if !TypeComparer.provablyDisjoint(tp, tpB) => AndType(tp, tpB)
-          }
-
-        if canDecompose(tp1) then
-          decomposeComponent(tp1, tp2)
-        else
-          decomposeComponent(tp2, tp1)
-
-      case OrType(tp1, tp2) => List(tp1, tp2)
-      case tp if tp.isRef(defn.BooleanClass) =>
-        List(
-          ConstantType(Constant(true)),
-          ConstantType(Constant(false))
-        )
-      case tp if tp.isRef(defn.UnitClass) =>
-        ConstantType(Constant(())) :: Nil
-      case tp if tp.classSymbol.isAllOf(JavaEnumTrait) =>
-        tp.classSymbol.children.map(_.termRef)
-
-      case tp @ AppliedType(tycon, targs) if tp.classSymbol.children.isEmpty && canDecompose(tycon) =>
+        var tpB   = tp2
+        var parts = rec(tp1, tp2 :: mixins)
+        if parts == ListOfNoType then
+          tpB   = tp1
+          parts = rec(tp2, tp1 :: mixins)
+        if parts == ListOfNoType then ListOfNoType
+        else parts.collect:
+          case tp if tp <:< tpB                              => tp
+          case tp if tpB <:< tp                              => tpB
+          case tp if !TypeComparer.provablyDisjoint(tp, tpB) => AndType(tp, tpB)
+
+      case OrType(tp1, tp2)                            => List(tp1, tp2)
+      case _: SingletonType                            => ListOfNoType
+      case tp if tp.isRef(defn.BooleanClass)           => List(ConstantType(Constant(true)), ConstantType(Constant(false)))
+      case tp if tp.isRef(defn.UnitClass)              => ConstantType(Constant(())) :: Nil
+      case tp if tp.classSymbol.isAllOf(JavaEnumTrait) => tp.classSymbol.children.map(_.termRef)
+      case tp: NamedType if canDec(tp.prefix)          => dec(tp.prefix).map(tp.derivedSelect)
+
+      case tp @ AppliedType(tycon, targs) if tp.classSymbol.children.isEmpty && canDec(tycon) =>
         // It might not obvious that it's OK to apply the type arguments of a parent type to child types.
         // But this is guarded by `tp.classSymbol.children.isEmpty`,
         // meaning we'll decompose to the same class, just not the same type.
         // For instance, from i15029, `decompose((X | Y).Field[T]) = [X.Field[T], Y.Field[T]]`.
-        rec(tycon, Nil).map(tp.derivedAppliedType(_, targs))
-
-      case tp: NamedType if canDecompose(tp.prefix) =>
-        rec(tp.prefix, Nil).map(tp.derivedSelect)
+        dec(tycon).map(tp.derivedAppliedType(_, targs))
 
-      case tp =>
+      case tp if {
+        val cls = tp.classSymbol
+        cls.is(Sealed)
+        && cls.isOneOf(AbstractOrTrait)
+        && !cls.hasAnonymousChild
+        && cls.children.nonEmpty
+      } =>
         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...
@@ -646,33 +653,17 @@ object SpaceEngine {
           if inhabited(refined) then refined
           else NoType
         }.filter(_.exists)
-
         debug.println(i"$tp decomposes to $parts")
-
         parts
-    }
-    rec(tp, Nil).map(Typ(_, decomposed = true))
+
+      case _ => ListOfNoType
+    end rec
+
+    rec(tp, Nil)
   }
 
-  /** Abstract sealed types, or-types, Boolean and Java enums can be decomposed */
-  def canDecompose(tp: Type)(using Context): Boolean =
-    val res = tp.dealias match
-      case AppliedType(tycon, _) if canDecompose(tycon) => true
-      case tp: NamedType if canDecompose(tp.prefix) => true
-      case _: SingletonType => false
-      case _: OrType => true
-      case AndType(tp1, tp2) => canDecompose(tp1) || canDecompose(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
+  val ListOfNoType    = List(NoType)
+  val ListOfTypNoType = ListOfNoType.map(Typ(_, decomposed = true))
 
   /** Show friendly type name with current scope in mind
    *

From 917b6ea7658f4b8e1536b3f6c3d4fcd2b6a326c9 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Thu, 16 Feb 2023 15:08:38 +0000
Subject: [PATCH 168/657] Space: Use a custom Parts extractor

---
 .../tools/dotc/transform/patmat/Space.scala   | 28 ++++++++-----------
 1 file changed, 12 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 cffe6a378649..64e0d9a94a1a 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -83,7 +83,9 @@ case class Typ(tp: Type, decomposed: Boolean = true) extends Space:
   def canDecompose(using Context): Boolean = decompose != SpaceEngine.ListOfTypNoType
 
   def decompose(using Context): List[Typ] =
-    if myDecompose == null then myDecompose = SpaceEngine.decompose(tp).map(Typ(_, decomposed = true))
+    if myDecompose == null then myDecompose = tp match
+      case SpaceEngine.Parts(parts) => parts.map(Typ(_, decomposed = true))
+      case _                        => SpaceEngine.ListOfTypNoType
     myDecompose
 end Typ
 
@@ -581,18 +583,6 @@ object SpaceEngine {
 
   /** Decompose a type into subspaces -- assume the type can be decomposed */
   def decompose(tp: Type)(using Context): List[Type] = trace(i"decompose($tp)", debug) {
-    var lastType:  Type       = NoType
-    var lastParts: List[Type] = Nil
-    def dec(tp: Type)    =
-      if tp eq lastType then lastParts
-      else
-        lastType = tp
-        lastParts = decompose(tp)
-        lastParts
-    def canDec(tp: Type) =
-      lastParts = dec(tp)
-      lastParts != ListOfNoType
-
     def rec(tp: Type, mixins: List[Type]): List[Type] = tp.dealias match
       case AndType(tp1, tp2) =>
         var tpB   = tp2
@@ -611,14 +601,14 @@ object SpaceEngine {
       case tp if tp.isRef(defn.BooleanClass)           => List(ConstantType(Constant(true)), ConstantType(Constant(false)))
       case tp if tp.isRef(defn.UnitClass)              => ConstantType(Constant(())) :: Nil
       case tp if tp.classSymbol.isAllOf(JavaEnumTrait) => tp.classSymbol.children.map(_.termRef)
-      case tp: NamedType if canDec(tp.prefix)          => dec(tp.prefix).map(tp.derivedSelect)
+      case tp @ TypeRef(Parts(parts), _)               => parts.map(tp.derivedSelect)
 
-      case tp @ AppliedType(tycon, targs) if tp.classSymbol.children.isEmpty && canDec(tycon) =>
+      case tp @ AppliedType(Parts(parts), targs) if tp.classSymbol.children.isEmpty =>
         // It might not obvious that it's OK to apply the type arguments of a parent type to child types.
         // But this is guarded by `tp.classSymbol.children.isEmpty`,
         // meaning we'll decompose to the same class, just not the same type.
         // For instance, from i15029, `decompose((X | Y).Field[T]) = [X.Field[T], Y.Field[T]]`.
-        dec(tycon).map(tp.derivedAppliedType(_, targs))
+        parts.map(tp.derivedAppliedType(_, targs))
 
       case tp if {
         val cls = tp.classSymbol
@@ -665,6 +655,12 @@ object SpaceEngine {
   val ListOfNoType    = List(NoType)
   val ListOfTypNoType = ListOfNoType.map(Typ(_, decomposed = true))
 
+  object Parts:
+    def unapply(tp: Type)(using Context): PartsExtractor = PartsExtractor(decompose(tp))
+
+  final class PartsExtractor(val get: List[Type]) extends AnyVal:
+    def isEmpty: Boolean = get == ListOfNoType
+
   /** Show friendly type name with current scope in mind
    *
    *  E.g.    C.this.B     -->  B     if current owner is C

From f5bc2a00b0d4dae90b5ac433d88313767e0e65c5 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Thu, 16 Feb 2023 16:32:07 +0100
Subject: [PATCH 169/657] Fix beta-reduction with `Nothing` and `null` args

Fixes part of #15165
---
 compiler/src/dotty/tools/dotc/transform/BetaReduce.scala | 5 ++++-
 tests/pos/i15165.scala                                   | 6 ++++++
 2 files changed, 10 insertions(+), 1 deletion(-)
 create mode 100644 tests/pos/i15165.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala b/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala
index 97dc4697db6d..c586bb06cc29 100644
--- a/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala
+++ b/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala
@@ -128,7 +128,10 @@ object BetaReduce:
             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 tpe =
+              if arg.tpe.isBottomType then param.tpe.widenTermRefExpr
+              else 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)
             if !(tpe.isInstanceOf[ConstantType] && isPureExpr(arg)) then
               bindings += binding
diff --git a/tests/pos/i15165.scala b/tests/pos/i15165.scala
new file mode 100644
index 000000000000..15e89c90e900
--- /dev/null
+++ b/tests/pos/i15165.scala
@@ -0,0 +1,6 @@
+def test1 = { (y: Int) => y + 1 }.apply(???)
+
+class C:
+  def x: Int = 8
+
+def test2 = { (c: C) => c.x }.apply(null)

From 82feb9bfb69d189c0b917f07f26ef2f4c9cab17c Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Thu, 16 Feb 2023 15:53:07 +0100
Subject: [PATCH 170/657] Register usage of symbols in non-inferred type trees
 in CheckUnused

fixes lampepfl#16930
---
 .../tools/dotc/transform/CheckUnused.scala    | 59 ++++++++++---------
 .../fatal-warnings/i16930.scala               | 22 +++++++
 2 files changed, 54 insertions(+), 27 deletions(-)
 create mode 100644 tests/neg-custom-args/fatal-warnings/i16930.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index 6c47c12ac07c..663f7f15b96f 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -46,12 +46,11 @@ class CheckUnused extends MiniPhase:
    */
   private val _key = Property.Key[UnusedData]
 
-  extension (k: Property.Key[UnusedData])
-    private def unusedDataApply[U](f: UnusedData => U)(using Context): Context =
-      ctx.property(_key).foreach(f)
-      ctx
-    private def getUnusedData(using Context): Option[UnusedData] =
-      ctx.property(_key)
+  private def unusedDataApply[U](f: UnusedData => U)(using Context): Context =
+    ctx.property(_key).foreach(f)
+    ctx
+  private def getUnusedData(using Context): Option[UnusedData] =
+    ctx.property(_key)
 
   override def phaseName: String = CheckUnused.phaseName
 
@@ -71,7 +70,7 @@ class CheckUnused extends MiniPhase:
   // ========== END + REPORTING ==========
 
   override def transformUnit(tree: tpd.Tree)(using Context): tpd.Tree =
-    _key.unusedDataApply(ud => reportUnused(ud.getUnused))
+    unusedDataApply(ud => reportUnused(ud.getUnused))
     tree
 
   // ========== MiniPhase Prepare ==========
@@ -81,15 +80,15 @@ class CheckUnused extends MiniPhase:
     ctx
 
   override def prepareForIdent(tree: tpd.Ident)(using Context): Context =
-    if tree.symbol.exists then
-      _key.unusedDataApply(_.registerUsed(tree.symbol, Some(tree.name)))
+    if tree.symbol.exists then 
+      unusedDataApply(_.registerUsed(tree.symbol, Some(tree.name)))
     else if tree.hasType then
-      _key.unusedDataApply(_.registerUsed(tree.tpe.classSymbol, Some(tree.name)))
+      unusedDataApply(_.registerUsed(tree.tpe.classSymbol, Some(tree.name)))
     else
       ctx
 
   override def prepareForSelect(tree: tpd.Select)(using Context): Context =
-    _key.unusedDataApply(_.registerUsed(tree.symbol, Some(tree.name)))
+    unusedDataApply(_.registerUsed(tree.symbol, Some(tree.name)))
 
   override def prepareForBlock(tree: tpd.Block)(using Context): Context =
     pushInBlockTemplatePackageDef(tree)
@@ -101,7 +100,7 @@ class CheckUnused extends MiniPhase:
     pushInBlockTemplatePackageDef(tree)
 
   override def prepareForValDef(tree: tpd.ValDef)(using Context): Context =
-    _key.unusedDataApply{ud =>
+    unusedDataApply{ud =>
       // do not register the ValDef generated for `object`
       if !tree.symbol.is(Module) then
         ud.registerDef(tree)
@@ -109,7 +108,7 @@ class CheckUnused extends MiniPhase:
     }
 
   override def prepareForDefDef(tree: tpd.DefDef)(using Context): Context =
-    _key.unusedDataApply{ ud =>
+    unusedDataApply{ ud =>
       import ud.registerTrivial
       tree.registerTrivial
       ud.registerDef(tree)
@@ -117,17 +116,17 @@ class CheckUnused extends MiniPhase:
     }
 
   override def prepareForTypeDef(tree: tpd.TypeDef)(using Context): Context =
-    _key.unusedDataApply{ ud =>
+    unusedDataApply{ ud =>
       if !tree.symbol.is(Param) then // Ignore type parameter (as Scala 2)
         ud.registerDef(tree)
         ud.addIgnoredUsage(tree.symbol)
     }
 
   override def prepareForBind(tree: tpd.Bind)(using Context): Context =
-    _key.unusedDataApply(_.registerPatVar(tree))
+    unusedDataApply(_.registerPatVar(tree))
 
   override def prepareForTypeTree(tree: tpd.TypeTree)(using Context): Context =
-    typeTraverser(_key.unusedDataApply).traverse(tree.tpe)
+    if !tree.isInstanceOf[tpd.InferredTypeTree] then typeTraverser(unusedDataApply).traverse(tree.tpe)
     ctx
 
   // ========== MiniPhase Transform ==========
@@ -145,27 +144,27 @@ class CheckUnused extends MiniPhase:
     tree
 
   override def transformValDef(tree: tpd.ValDef)(using Context): tpd.Tree =
-    _key.unusedDataApply(_.removeIgnoredUsage(tree.symbol))
+    unusedDataApply(_.removeIgnoredUsage(tree.symbol))
     tree
 
   override def transformDefDef(tree: tpd.DefDef)(using Context): tpd.Tree =
-    _key.unusedDataApply(_.removeIgnoredUsage(tree.symbol))
+    unusedDataApply(_.removeIgnoredUsage(tree.symbol))
     tree
 
   override def transformTypeDef(tree: tpd.TypeDef)(using Context): tpd.Tree =
-    _key.unusedDataApply(_.removeIgnoredUsage(tree.symbol))
+    unusedDataApply(_.removeIgnoredUsage(tree.symbol))
     tree
 
   // ---------- MiniPhase HELPERS -----------
 
   private def pushInBlockTemplatePackageDef(tree: tpd.Block | tpd.Template | tpd.PackageDef)(using Context): Context =
-    _key.unusedDataApply { ud =>
+    unusedDataApply { ud =>
       ud.pushScope(UnusedData.ScopeType.fromTree(tree))
     }
     ctx
 
   private def popOutBlockTemplatePackageDef()(using Context): Context =
-    _key.unusedDataApply { ud =>
+    unusedDataApply { ud =>
       ud.popScope()
     }
     ctx
@@ -188,7 +187,7 @@ class CheckUnused extends MiniPhase:
       val newCtx = if tree.symbol.exists then ctx.withOwner(tree.symbol) else ctx
       tree match
         case imp:tpd.Import =>
-          _key.unusedDataApply(_.registerImport(imp))
+          unusedDataApply(_.registerImport(imp))
           traverseChildren(tree)(using newCtx)
         case ident: Ident =>
           prepareForIdent(ident)
@@ -198,7 +197,7 @@ class CheckUnused extends MiniPhase:
           traverseChildren(tree)(using newCtx)
         case _: (tpd.Block | tpd.Template | tpd.PackageDef) =>
           //! DIFFERS FROM MINIPHASE
-          _key.unusedDataApply { ud =>
+          unusedDataApply { ud =>
             ud.inNewScope(ScopeType.fromTree(tree))(traverseChildren(tree)(using newCtx))
           }
         case t:tpd.ValDef =>
@@ -216,9 +215,10 @@ class CheckUnused extends MiniPhase:
         case t: tpd.Bind =>
           prepareForBind(t)
           traverseChildren(tree)(using newCtx)
+        case _: tpd.InferredTypeTree =>
         case t@tpd.TypeTree() =>
           //! DIFFERS FROM MINIPHASE
-          typeTraverser(_key.unusedDataApply).traverse(t.tpe)
+          typeTraverser(unusedDataApply).traverse(t.tpe)
           traverseChildren(tree)(using newCtx)
         case _ =>
           //! DIFFERS FROM MINIPHASE
@@ -228,9 +228,14 @@ class CheckUnused extends MiniPhase:
 
   /** This is a type traverser which catch some special Types not traversed by the term traverser above */
   private def typeTraverser(dt: (UnusedData => Any) => Unit)(using Context) = new TypeTraverser:
-    override def traverse(tp: Type): Unit = tp match
-      case AnnotatedType(_, annot) => dt(_.registerUsed(annot.symbol, None))
-      case _ => traverseChildren(tp)
+    override def traverse(tp: Type): Unit =
+      if tp.typeSymbol.exists then dt(_.registerUsed(tp.typeSymbol, Some(tp.typeSymbol.name)))
+      tp match
+        case AnnotatedType(_, annot) =>
+          dt(_.registerUsed(annot.symbol, None))
+          traverseChildren(tp)
+        case _ =>
+          traverseChildren(tp)
 
   /** Do the actual reporting given the result of the anaylsis */
   private def reportUnused(res: UnusedData.UnusedResult)(using Context): Unit =
diff --git a/tests/neg-custom-args/fatal-warnings/i16930.scala b/tests/neg-custom-args/fatal-warnings/i16930.scala
new file mode 100644
index 000000000000..1f6c5bf1a09f
--- /dev/null
+++ b/tests/neg-custom-args/fatal-warnings/i16930.scala
@@ -0,0 +1,22 @@
+// scalac: -Wunused:imports
+
+trait Outer:
+  trait Used
+  trait Unused
+
+object Test {
+  val outer: Outer = ???
+  import outer.{Used, Unused} // error
+  def foo(x: Any): Used = x.asInstanceOf[Used]
+}
+
+trait Outer1:
+  trait UnusedToo1
+  trait Unused1
+  def unusedToo1: UnusedToo1
+
+object Test1 {
+  val outer1: Outer1 = ???
+  import outer1.{Unused1, UnusedToo1} // error // error
+  def foo() = outer1.unusedToo1 // in this case UnusedToo1 is not used explicitly, only inferred
+}

From 4cc4339ed4c727dfd8039002ebdc48fc6bbf0b50 Mon Sep 17 00:00:00 2001
From: Paul Coral <paul.coral@epfl.ch>
Date: Sat, 18 Feb 2023 16:41:59 +0100
Subject: [PATCH 171/657] Traverse annotations instead of just registering

- Traverse the tree of annotations
- Update test suits
---
 .../tools/dotc/transform/CheckUnused.scala     | 18 +++++++++---------
 .../fatal-warnings/i15503i.scala               |  9 +++++++++
 2 files changed, 18 insertions(+), 9 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index 6c47c12ac07c..f66412e16d36 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -28,6 +28,7 @@ import dotty.tools.dotc.core.Types.ConstantType
 import dotty.tools.dotc.core.NameKinds.WildcardParamName
 import dotty.tools.dotc.core.Types.TermRef
 import dotty.tools.dotc.core.Types.NameFilter
+import dotty.tools.dotc.core.Symbols.Symbol
 
 
 
@@ -103,6 +104,7 @@ class CheckUnused extends MiniPhase:
   override def prepareForValDef(tree: tpd.ValDef)(using Context): Context =
     _key.unusedDataApply{ud =>
       // do not register the ValDef generated for `object`
+      traverseAnnotations(tree.symbol)
       if !tree.symbol.is(Module) then
         ud.registerDef(tree)
       ud.addIgnoredUsage(tree.symbol)
@@ -112,6 +114,7 @@ class CheckUnused extends MiniPhase:
     _key.unusedDataApply{ ud =>
       import ud.registerTrivial
       tree.registerTrivial
+      traverseAnnotations(tree.symbol)
       ud.registerDef(tree)
       ud.addIgnoredUsage(tree.symbol)
     }
@@ -119,11 +122,13 @@ class CheckUnused extends MiniPhase:
   override def prepareForTypeDef(tree: tpd.TypeDef)(using Context): Context =
     _key.unusedDataApply{ ud =>
       if !tree.symbol.is(Param) then // Ignore type parameter (as Scala 2)
+        traverseAnnotations(tree.symbol)
         ud.registerDef(tree)
         ud.addIgnoredUsage(tree.symbol)
     }
 
   override def prepareForBind(tree: tpd.Bind)(using Context): Context =
+    traverseAnnotations(tree.symbol)
     _key.unusedDataApply(_.registerPatVar(tree))
 
   override def prepareForTypeTree(tree: tpd.TypeTree)(using Context): Context =
@@ -232,6 +237,10 @@ class CheckUnused extends MiniPhase:
       case AnnotatedType(_, annot) => dt(_.registerUsed(annot.symbol, None))
       case _ => traverseChildren(tp)
 
+  /** This traverse the annotations of the symbol */
+  private def traverseAnnotations(sym: Symbol)(using Context): Unit =
+    sym.denot.annotations.foreach(annot => traverser.traverse(annot.tree))
+
   /** Do the actual reporting given the result of the anaylsis */
   private def reportUnused(res: UnusedData.UnusedResult)(using Context): Unit =
     import CheckUnused.WarnTypes
@@ -274,7 +283,6 @@ object CheckUnused:
   private class UnusedData:
     import dotty.tools.dotc.transform.CheckUnused.UnusedData.UnusedResult
     import collection.mutable.{Set => MutSet, Map => MutMap, Stack => MutStack}
-    import dotty.tools.dotc.core.Symbols.Symbol
     import UnusedData.ScopeType
 
     /** The current scope during the tree traversal */
@@ -324,11 +332,6 @@ object CheckUnused:
       execInNewScope
       popScope()
 
-    /** Register all annotations of this symbol's denotation */
-    def registerUsedAnnotation(sym: Symbol)(using Context): Unit =
-      val annotSym = sym.denot.annotations.map(_.symbol)
-      annotSym.foreach(s => registerUsed(s, None))
-
     /**
      * Register a found (used) symbol along with its name
      *
@@ -363,8 +366,6 @@ object CheckUnused:
 
     /** Register (or not) some `val` or `def` according to the context, scope and flags */
     def registerDef(memDef: tpd.MemberDef)(using Context): Unit =
-      // register the annotations for usage
-      registerUsedAnnotation(memDef.symbol)
       if memDef.isValidMemberDef then
         if memDef.isValidParam then
           if memDef.symbol.isOneOf(GivenOrImplicit) then
@@ -378,7 +379,6 @@ object CheckUnused:
 
     /** Register pattern variable */
     def registerPatVar(patvar: tpd.Bind)(using Context): Unit =
-      registerUsedAnnotation(patvar.symbol)
       if !patvar.symbol.isUnusedAnnot then
         patVarsInScope += patvar
 
diff --git a/tests/neg-custom-args/fatal-warnings/i15503i.scala b/tests/neg-custom-args/fatal-warnings/i15503i.scala
index 7eae207d952d..ccf9344319d2 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503i.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503i.scala
@@ -142,3 +142,12 @@ package foo.test.i16822:
     val x = ExampleEnum.List // OK
     println(x) // OK
   }
+
+package foo.test.i16877:
+  import scala.collection.immutable.HashMap // OK
+  import scala.annotation.StaticAnnotation // OK
+
+  class ExampleAnnotation(val a: Object) extends StaticAnnotation // OK
+
+  @ExampleAnnotation(new HashMap()) // OK
+  class Test //OK

From d5fd114a52f4e7f591c44f5acf07603d819a201d Mon Sep 17 00:00:00 2001
From: Paul Coral <paul.coral@epfl.ch>
Date: Sat, 18 Feb 2023 17:16:38 +0100
Subject: [PATCH 172/657] Ignore parameter of accessors

- Do not report parameter of accessors
- Update test suit
---
 .../tools/dotc/transform/CheckUnused.scala    |  4 +-
 .../fatal-warnings/i15503e.scala              |  3 ++
 .../fatal-warnings/i15503i.scala              | 43 +++++++++++++++++++
 3 files changed, 48 insertions(+), 2 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index 663f7f15b96f..2f1804ad9218 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -80,7 +80,7 @@ class CheckUnused extends MiniPhase:
     ctx
 
   override def prepareForIdent(tree: tpd.Ident)(using Context): Context =
-    if tree.symbol.exists then 
+    if tree.symbol.exists then
       unusedDataApply(_.registerUsed(tree.symbol, Some(tree.name)))
     else if tree.hasType then
       unusedDataApply(_.registerUsed(tree.tpe.classSymbol, Some(tree.name)))
@@ -621,7 +621,7 @@ object CheckUnused:
         (sym.is(Param) || sym.isAllOf(PrivateParamAccessor | Local, butNot = CaseAccessor)) &&
         !isSyntheticMainParam(sym) &&
         !sym.shouldNotReportParamOwner &&
-        (!sym.exists || !sym.owner.isAllOf(Synthetic | PrivateLocal))
+        (!sym.exists || !(sym.owner.isAllOf(Synthetic | PrivateLocal) || sym.owner.is(Accessor)))
 
       private def shouldReportPrivateDef(using Context): Boolean =
         currScopeType.top == ScopeType.Template && !memDef.symbol.isConstructor && memDef.symbol.is(Private, butNot = SelfName | Synthetic | CaseAccessor)
diff --git a/tests/neg-custom-args/fatal-warnings/i15503e.scala b/tests/neg-custom-args/fatal-warnings/i15503e.scala
index 79112942a205..cd56587327cd 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503e.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503e.scala
@@ -52,3 +52,6 @@ package foo.test.trivial:
     def f77(x: Int) = foo // error
   }
   object Y
+
+package foo.test.i16955:
+  class S(var r: String) // OK
\ No newline at end of file
diff --git a/tests/neg-custom-args/fatal-warnings/i15503i.scala b/tests/neg-custom-args/fatal-warnings/i15503i.scala
index 7eae207d952d..bedf9a8f4791 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503i.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503i.scala
@@ -126,6 +126,49 @@ package foo.test.possibleclasses:
     def a = k + y + s + t + z
   }
 
+package foo.test.possibleclasses.withvar:
+  case class AllCaseClass(
+    k: Int, // OK
+    private var y: Int // OK /* Kept as it can be taken from pattern */
+  )(
+    s: Int, // error /* But not these */
+    var t: Int, // OK
+    private var z: Int // error
+  )
+
+  case class AllCaseUsed(
+    k: Int, // OK
+    private var y: Int // OK
+  )(
+    s: Int, // OK
+    var t: Int, // OK
+    private var z: Int // OK
+  ) {
+    def a = k + y + s + t + z
+  }
+
+  class AllClass(
+    k: Int, // error
+    private var y: Int // error
+  )(
+    s: Int, // error
+    var t: Int, // OK
+    private var z: Int // error
+  )
+
+  class AllUsed(
+    k: Int, // OK
+    private var y: Int // OK
+  )(
+    s: Int, // OK
+    var t: Int, // OK
+    private var z: Int // OK
+  ) {
+    def a = k + y + s + t + z
+  }
+
+
+
 package foo.test.from.i16675:
   case class PositiveNumber private (i: Int) // OK
   object PositiveNumber:

From f18961558e06289eb33ee0632b6ce61ec4efb619 Mon Sep 17 00:00:00 2001
From: Som Snytt <som.snytt@gmail.com>
Date: Mon, 3 Oct 2022 23:10:38 -0700
Subject: [PATCH 173/657] Clarify ambiguous reference error message

---
 .../dotty/tools/dotc/reporting/messages.scala | 30 ++++++++-----
 tests/neg/ambiref.check                       | 16 +++----
 tests/neg/i12682.check                        | 45 +++++++++++++++++++
 tests/neg/i12682.scala                        | 13 ++++++
 tests/neg/i13558.check                        |  8 ++--
 tests/neg/i9803.check                         |  4 +-
 6 files changed, 91 insertions(+), 25 deletions(-)
 create mode 100644 tests/neg/i12682.check
 create mode 100644 tests/neg/i12682.scala

diff --git a/compiler/src/dotty/tools/dotc/reporting/messages.scala b/compiler/src/dotty/tools/dotc/reporting/messages.scala
index d7920e1f1b36..92ee1b44def0 100644
--- a/compiler/src/dotty/tools/dotc/reporting/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/messages.scala
@@ -1328,21 +1328,29 @@ class AmbiguousReference(name: Name, newPrec: BindingPrec, prevPrec: BindingPrec
   }
 
   def msg(using Context) =
-    i"""|Reference to $name is ambiguous,
-        |it is both ${bindingString(newPrec, ctx)}
+    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
+    val precedent =
+      if newPrec == prevPrec then                 """two bindings of equal precedence
+        |were introduced in the same scope.""".stripMargin
+      else                                        """a binding of lower precedence
+        |in an inner scope cannot shadow a binding with higher precedence in
+        |an outer scope.""".stripMargin
+
+    i"""|The identifier $name is ambiguous because $precedent
+        |
+        |The precedence of the different kinds of bindings, from highest to lowest, is:
+        | - Definitions in an enclosing scope
+        | - Inherited definitions and top-level definitions in packages
+        | - Names introduced by imports
         | - Named imports take precedence over wildcard imports
-        | - You may replace a name when imported using
-        |   ${hl("import")} scala.{ $name => ${name.show + "Tick"} }
+        | - Definitions from packages in other files
+        |Note:
+        | - When importing, you can avoid naming conflicts by renaming:
+        |   ${hl("import")} scala.{$name => ${name.show}Tick}
         |"""
 }
 
diff --git a/tests/neg/ambiref.check b/tests/neg/ambiref.check
index 95b542c7aae3..5d701b3b3b71 100644
--- a/tests/neg/ambiref.check
+++ b/tests/neg/ambiref.check
@@ -1,32 +1,32 @@
 -- [E049] Reference Error: tests/neg/ambiref.scala:8:14 ----------------------------------------------------------------
 8 |      println(x)  // error
   |              ^
-  |              Reference to x is ambiguous,
-  |              it is both defined in object Test
+  |              Reference to x is ambiguous.
+  |              It is both defined in object Test
   |              and inherited subsequently in class D
   |
   | longer explanation available when compiling with `-explain`
 -- [E049] Reference Error: tests/neg/ambiref.scala:10:14 ---------------------------------------------------------------
 10 |      println(x)  // error
    |              ^
-   |              Reference to x is ambiguous,
-   |              it is both defined in object Test
+   |              Reference to x is ambiguous.
+   |              It is both defined in object Test
    |              and inherited subsequently in anonymous class test1.C {...}
    |
    | longer explanation available when compiling with `-explain`
 -- [E049] Reference Error: tests/neg/ambiref.scala:17:14 ---------------------------------------------------------------
 17 |      println(y)  // error
    |              ^
-   |              Reference to y is ambiguous,
-   |              it is both defined in method c
+   |              Reference to y is ambiguous.
+   |              It is both defined in method c
    |              and inherited subsequently in anonymous class D {...}
    |
    | longer explanation available when compiling with `-explain`
 -- [E049] Reference Error: tests/neg/ambiref.scala:25:16 ---------------------------------------------------------------
 25 |        println(y)  // error
    |                ^
-   |                Reference to y is ambiguous,
-   |                it is both defined in method c
+   |                Reference to y is ambiguous.
+   |                It is both defined in method c
    |                and inherited subsequently in class E
    |
    | longer explanation available when compiling with `-explain`
diff --git a/tests/neg/i12682.check b/tests/neg/i12682.check
new file mode 100644
index 000000000000..3b421b44ebe5
--- /dev/null
+++ b/tests/neg/i12682.check
@@ -0,0 +1,45 @@
+-- [E049] Reference Error: tests/neg/i12682.scala:6:12 -----------------------------------------------------------------
+6 |    val x = m(1)  // error
+  |            ^
+  |            Reference to m is ambiguous.
+  |            It is both defined in object C
+  |            and inherited subsequently in object T
+  |---------------------------------------------------------------------------------------------------------------------
+  | Explanation (enabled by `-explain`)
+  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  | The identifier m is ambiguous because a binding of lower precedence
+  | in an inner scope cannot shadow a binding with higher precedence in
+  | an outer scope.
+  |
+  | The precedence of the different kinds of bindings, from highest to lowest, is:
+  |  - Definitions in an enclosing scope
+  |  - Inherited definitions and top-level definitions in packages
+  |  - Names introduced by imports
+  |  - Named imports take precedence over wildcard imports
+  |  - Definitions from packages in other files
+  | Note:
+  |  - When importing, you can avoid naming conflicts by renaming:
+  |    import scala.{m => mTick}
+   ---------------------------------------------------------------------------------------------------------------------
+-- [E049] Reference Error: tests/neg/i12682.scala:13:10 ----------------------------------------------------------------
+13 |  def d = m(42) // error
+   |          ^
+   |          Reference to m is ambiguous.
+   |          It is both imported by import X._
+   |          and imported subsequently by import Y._
+   |--------------------------------------------------------------------------------------------------------------------
+   | Explanation (enabled by `-explain`)
+   |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   | The identifier m is ambiguous because two bindings of equal precedence
+   | were introduced in the same scope.
+   |
+   | The precedence of the different kinds of bindings, from highest to lowest, is:
+   |  - Definitions in an enclosing scope
+   |  - Inherited definitions and top-level definitions in packages
+   |  - Names introduced by imports
+   |  - Named imports take precedence over wildcard imports
+   |  - Definitions from packages in other files
+   | Note:
+   |  - When importing, you can avoid naming conflicts by renaming:
+   |    import scala.{m => mTick}
+    --------------------------------------------------------------------------------------------------------------------
diff --git a/tests/neg/i12682.scala b/tests/neg/i12682.scala
new file mode 100644
index 000000000000..0b37816ef0df
--- /dev/null
+++ b/tests/neg/i12682.scala
@@ -0,0 +1,13 @@
+// scalac: -explain
+
+object C:
+  def m(x: Int) = 1
+  object T extends K:
+    val x = m(1)  // error
+class K:
+  def m(i: Int) = 2
+object X extends K
+object Y extends K
+object D:
+  import X.*, Y.*
+  def d = m(42) // error
diff --git a/tests/neg/i13558.check b/tests/neg/i13558.check
index ab10a42cdd32..7b4b5215a0a3 100644
--- a/tests/neg/i13558.check
+++ b/tests/neg/i13558.check
@@ -8,8 +8,8 @@
    |
    |                failed with:
    |
-   |                    Reference to id is ambiguous,
-   |                    it is both imported by import testcode.ExtensionB._
+   |                    Reference to id is ambiguous.
+   |                    It is both imported by import testcode.ExtensionB._
    |                    and imported subsequently by import testcode.ExtensionA._
 -- [E008] Not Found Error: tests/neg/i13558.scala:29:14 ----------------------------------------------------------------
 29 |    println(a.id) // error
@@ -21,6 +21,6 @@
    |
    |                failed with:
    |
-   |                    Reference to id is ambiguous,
-   |                    it is both imported by import testcode.ExtensionA._
+   |                    Reference to id is ambiguous.
+   |                    It is both imported by import testcode.ExtensionA._
    |                    and imported subsequently by import testcode.ExtensionB._
diff --git a/tests/neg/i9803.check b/tests/neg/i9803.check
index cc7d56d585b0..20225f1f5bc5 100644
--- a/tests/neg/i9803.check
+++ b/tests/neg/i9803.check
@@ -1,8 +1,8 @@
 -- [E049] Reference Error: tests/neg/i9803.scala:15:10 -----------------------------------------------------------------
 15 |  println(f421()) // error
    |          ^^^^
-   |          Reference to f421 is ambiguous,
-   |          it is both imported by name by import bugs.shadowing.x.f421
+   |          Reference to f421 is ambiguous.
+   |          It is both imported by name by import bugs.shadowing.x.f421
    |          and imported by name subsequently by import bugs.shadowing.y.f421
    |
    | longer explanation available when compiling with `-explain`

From 363996c3cafab13f7ef3988aee0a6be69a1a9f19 Mon Sep 17 00:00:00 2001
From: Som Snytt <som.snytt@gmail.com>
Date: Sat, 18 Feb 2023 10:07:07 -0800
Subject: [PATCH 174/657] Retain and expand new rule help, add more words

---
 .../dotty/tools/dotc/reporting/messages.scala | 13 ++++++-----
 tests/neg/i12682.check                        | 22 ++++++++++++-------
 2 files changed, 22 insertions(+), 13 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/reporting/messages.scala b/compiler/src/dotty/tools/dotc/reporting/messages.scala
index 92ee1b44def0..a82e49a048ab 100644
--- a/compiler/src/dotty/tools/dotc/reporting/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/messages.scala
@@ -1334,21 +1334,24 @@ class AmbiguousReference(name: Name, newPrec: BindingPrec, prevPrec: BindingPrec
 
   def explain(using Context) =
     val precedent =
-      if newPrec == prevPrec then                 """two bindings of equal precedence
+      if newPrec == prevPrec then                 """two name bindings of equal precedence
         |were introduced in the same scope.""".stripMargin
-      else                                        """a binding of lower precedence
+      else                                        """a name binding of lower precedence
         |in an inner scope cannot shadow a binding with higher precedence in
         |an outer scope.""".stripMargin
 
     i"""|The identifier $name is ambiguous because $precedent
         |
-        |The precedence of the different kinds of bindings, from highest to lowest, is:
+        |The precedence of the different kinds of name bindings, from highest to lowest, is:
         | - Definitions in an enclosing scope
         | - Inherited definitions and top-level definitions in packages
-        | - Names introduced by imports
-        | - Named imports take precedence over wildcard imports
+        | - Names introduced by import of a specific name
+        | - Names introduced by wildcard import
         | - Definitions from packages in other files
         |Note:
+        | - As a rule, definitions take precedence over imports.
+        | - Definitions in an enclosing scope take precedence over inherited definitions,
+        |   which can result in ambiguities in nested classes.
         | - When importing, you can avoid naming conflicts by renaming:
         |   ${hl("import")} scala.{$name => ${name.show}Tick}
         |"""
diff --git a/tests/neg/i12682.check b/tests/neg/i12682.check
index 3b421b44ebe5..605414938529 100644
--- a/tests/neg/i12682.check
+++ b/tests/neg/i12682.check
@@ -7,17 +7,20 @@
   |---------------------------------------------------------------------------------------------------------------------
   | Explanation (enabled by `-explain`)
   |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-  | The identifier m is ambiguous because a binding of lower precedence
+  | The identifier m is ambiguous because a name binding of lower precedence
   | in an inner scope cannot shadow a binding with higher precedence in
   | an outer scope.
   |
-  | The precedence of the different kinds of bindings, from highest to lowest, is:
+  | The precedence of the different kinds of name bindings, from highest to lowest, is:
   |  - Definitions in an enclosing scope
   |  - Inherited definitions and top-level definitions in packages
-  |  - Names introduced by imports
-  |  - Named imports take precedence over wildcard imports
+  |  - Names introduced by import of a specific name
+  |  - Names introduced by wildcard import
   |  - Definitions from packages in other files
   | Note:
+  |  - As a rule, definitions take precedence over imports.
+  |  - Definitions in an enclosing scope take precedence over inherited definitions,
+  |    which can result in ambiguities in nested classes.
   |  - When importing, you can avoid naming conflicts by renaming:
   |    import scala.{m => mTick}
    ---------------------------------------------------------------------------------------------------------------------
@@ -30,16 +33,19 @@
    |--------------------------------------------------------------------------------------------------------------------
    | Explanation (enabled by `-explain`)
    |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-   | The identifier m is ambiguous because two bindings of equal precedence
+   | The identifier m is ambiguous because two name bindings of equal precedence
    | were introduced in the same scope.
    |
-   | The precedence of the different kinds of bindings, from highest to lowest, is:
+   | The precedence of the different kinds of name bindings, from highest to lowest, is:
    |  - Definitions in an enclosing scope
    |  - Inherited definitions and top-level definitions in packages
-   |  - Names introduced by imports
-   |  - Named imports take precedence over wildcard imports
+   |  - Names introduced by import of a specific name
+   |  - Names introduced by wildcard import
    |  - Definitions from packages in other files
    | Note:
+   |  - As a rule, definitions take precedence over imports.
+   |  - Definitions in an enclosing scope take precedence over inherited definitions,
+   |    which can result in ambiguities in nested classes.
    |  - When importing, you can avoid naming conflicts by renaming:
    |    import scala.{m => mTick}
     --------------------------------------------------------------------------------------------------------------------

From b50910452d6f77ce32acbb913c3f131e432c336e Mon Sep 17 00:00:00 2001
From: Paul Coral <paul.coral@epfl.ch>
Date: Sun, 19 Feb 2023 12:35:23 +0100
Subject: [PATCH 175/657] Improve override detection in CheckUnused

- CheckUnused detects override from base type in addition of `override` flag
- Update test suit
---
 .../tools/dotc/transform/CheckUnused.scala    | 19 +++++++++++++------
 .../fatal-warnings/i15503e.scala              | 14 +++++++++++++-
 2 files changed, 26 insertions(+), 7 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index a1ccccdb12e2..49ce64b00b88 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -574,12 +574,14 @@ object CheckUnused:
       private def shouldNotReportParamOwner(using Context): Boolean =
         if sym.exists then
           val owner = sym.owner
-          trivialDefs(owner) ||
-          owner.is(Flags.Override) ||
+          trivialDefs(owner) || // is a trivial def
           owner.isPrimaryConstructor ||
-          owner.annotations.exists (
+          owner.annotations.exists ( // @depreacated
             _.symbol == ctx.definitions.DeprecatedAnnot
-          )
+          ) ||
+          owner.isAllOf(Synthetic | PrivateLocal) ||
+          owner.is(Accessor) ||
+          owner.isOverriden
         else
           false
 
@@ -589,6 +591,11 @@ object CheckUnused:
       private def everySymbol(using Context): List[Symbol] =
         List(sym, sym.companionClass, sym.companionModule, sym.moduleClass).filter(_.exists)
 
+      /** A function is overriden. Either has `override flags` or parent has a matching member (type and name) */
+      private def isOverriden(using Context): Boolean =
+        sym.is(Flags.Override) ||
+        (if sym.exists then sym.owner.thisType.parents.exists(p => sym.matchingMember(p).exists) else false)
+
     end extension
 
     extension (defdef: tpd.DefDef)
@@ -620,8 +627,8 @@ object CheckUnused:
         val sym = memDef.symbol
         (sym.is(Param) || sym.isAllOf(PrivateParamAccessor | Local, butNot = CaseAccessor)) &&
         !isSyntheticMainParam(sym) &&
-        !sym.shouldNotReportParamOwner &&
-        (!sym.exists || !(sym.owner.isAllOf(Synthetic | PrivateLocal) || sym.owner.is(Accessor)))
+        !sym.shouldNotReportParamOwner
+
 
       private def shouldReportPrivateDef(using Context): Boolean =
         currScopeType.top == ScopeType.Template && !memDef.symbol.isConstructor && memDef.symbol.is(Private, butNot = SelfName | Synthetic | CaseAccessor)
diff --git a/tests/neg-custom-args/fatal-warnings/i15503e.scala b/tests/neg-custom-args/fatal-warnings/i15503e.scala
index cd56587327cd..56aec702a39e 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503e.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503e.scala
@@ -54,4 +54,16 @@ package foo.test.trivial:
   object Y
 
 package foo.test.i16955:
-  class S(var r: String) // OK
\ No newline at end of file
+  class S(var r: String) // OK
+
+package foo.test.i16865:
+  trait Foo:
+    def fn(a: Int, b: Int): Int // OK
+  trait Bar extends Foo
+
+  object Ex extends Bar:
+    def fn(a: Int, b: Int): Int = b + 3 // OK
+
+  object Ex2 extends Bar:
+    override def fn(a: Int, b: Int): Int = b + 3 // OK
+

From c5038b7d18d316c7e30e112a74c6054255f37336 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Mon, 20 Feb 2023 14:25:28 +0100
Subject: [PATCH 176/657] Fix race condition in new LazyVals

---
 library/src/scala/runtime/LazyVals.scala |  2 +-
 tests/run/i16806.check                   |  2 ++
 tests/run/i16806.scala                   | 42 ++++++++++++++++++++++++
 3 files changed, 45 insertions(+), 1 deletion(-)
 create mode 100644 tests/run/i16806.check
 create mode 100644 tests/run/i16806.scala

diff --git a/library/src/scala/runtime/LazyVals.scala b/library/src/scala/runtime/LazyVals.scala
index 5d1e8e74b89d..416ffc91d34a 100644
--- a/library/src/scala/runtime/LazyVals.scala
+++ b/library/src/scala/runtime/LazyVals.scala
@@ -45,7 +45,7 @@ object LazyVals {
 
   /* ------------- Start of public API ------------- */
 
-  sealed trait LazyValControlState
+  sealed trait LazyValControlState extends Serializable
 
   /**
    * Used to indicate the state of a lazy val that is being
diff --git a/tests/run/i16806.check b/tests/run/i16806.check
new file mode 100644
index 000000000000..af917347162a
--- /dev/null
+++ b/tests/run/i16806.check
@@ -0,0 +1,2 @@
+Success
+Success
\ No newline at end of file
diff --git a/tests/run/i16806.scala b/tests/run/i16806.scala
new file mode 100644
index 000000000000..f45652080458
--- /dev/null
+++ b/tests/run/i16806.scala
@@ -0,0 +1,42 @@
+import java.util.concurrent.Semaphore
+import scala.runtime.LazyVals.Evaluating
+
+object Repro {
+
+  case object DFBit
+  final class DFError extends Exception("")
+  final class DFType[+T](val value: T | DFError) extends AnyVal
+
+  def asIR(dfType: DFType[DFBit.type]): DFBit.type = dfType.value match
+  case dfTypeIR: DFBit.type => dfTypeIR
+  case err: DFError         => throw new DFError
+
+  object Holder {
+    val s = new Semaphore(1, false)
+    final lazy val Bit = {
+      s.release()
+      new DFType[DFBit.type](DFBit)
+    }
+  }
+
+  @main
+  def Test =
+    val a = new Thread() {
+      override def run(): Unit =
+        Holder.s.acquire()
+        val x = Holder.Bit.value
+        assert(!x.isInstanceOf[Evaluating.type])
+        println("Success")
+    }
+    val b = new Thread() {
+      override def run(): Unit =
+        Holder.s.acquire()
+        val x = Holder.Bit.value
+        assert(!x.isInstanceOf[Evaluating.type])
+        println("Success")
+    }
+    a.start()
+    b.start()
+    a.join(300)
+    b.join(300)
+}
\ No newline at end of file

From fd3d0e69f3176167ceab1e7afc79ddacf887fe74 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Mon, 20 Feb 2023 14:54:23 +0100
Subject: [PATCH 177/657] Add MiMA exceptions

---
 project/MiMaFilters.scala | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/project/MiMaFilters.scala b/project/MiMaFilters.scala
index 8af2de7058ee..49e18db3fccb 100644
--- a/project/MiMaFilters.scala
+++ b/project/MiMaFilters.scala
@@ -26,6 +26,11 @@ object MiMaFilters {
     ProblemFilters.exclude[MissingFieldProblem]("scala.runtime.stdLibPatches.language#experimental.into"),
     ProblemFilters.exclude[MissingClassProblem]("scala.runtime.stdLibPatches.language$experimental$into$"),
     // end of New experimental features in 3.3.X
+
+    // Added java.io.Serializable as LazyValControlState supertype
+    ProblemFilters.exclude[MissingTypesProblem]("scala.runtime.LazyVals$LazyValControlState"),
+    ProblemFilters.exclude[MissingTypesProblem]("scala.runtime.LazyVals$Waiting"),
+
   )
   val TastyCore: Seq[ProblemFilter] = Seq(
     ProblemFilters.exclude[DirectMissingMethodProblem]("dotty.tools.tasty.TastyBuffer.reset"),

From 3dd600de4cafa9926d4b17bba1050f1ce5196ade Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Mon, 21 Nov 2022 04:52:46 +0100
Subject: [PATCH 178/657] Port -Wnonunit-statement setting for dotty

---
 .../tools/dotc/config/ScalaSettings.scala     |   1 +
 .../tools/dotc/reporting/ErrorMessageID.scala |   1 +
 .../dotty/tools/dotc/reporting/messages.scala |   6 +
 .../dotty/tools/dotc/typer/RefChecks.scala    |   3 +-
 .../src/dotty/tools/dotc/typer/Typer.scala    |  56 ++++-
 .../fatal-warnings/nonunit-statement.scala    | 198 ++++++++++++++++++
 6 files changed, 262 insertions(+), 3 deletions(-)
 create mode 100644 tests/neg-custom-args/fatal-warnings/nonunit-statement.scala

diff --git a/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala b/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala
index 5ae99ec7e6fa..8606d72546ef 100644
--- a/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala
+++ b/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala
@@ -160,6 +160,7 @@ private sealed trait WarningSettings:
   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 WvalueDiscard: Setting[Boolean] = BooleanSetting("-Wvalue-discard", "Warn when non-Unit expression results are unused.")
+  val WNonUnitStatement = BooleanSetting("-Wnonunit-statement", "Warn when block statements are non-Unit expressions.")
 
   val Wunused: Setting[List[ChoiceWithHelp[String]]] = MultiChoiceHelpSetting(
     name = "-Wunused",
diff --git a/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala b/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
index 9f0d71645833..b72ec2a19d76 100644
--- a/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
@@ -189,6 +189,7 @@ enum ErrorMessageID(val isActive: Boolean = true) extends java.lang.Enum[ErrorMe
   case CannotBeAccessedID // errorNumber 173
   case InlineGivenShouldNotBeFunctionID // errorNumber 174
   case ValueDiscardingID // errorNumber 175
+  case UnusedNonUnitValueID // errorNumber 176
 
   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 f41d34b8c17c..5f42ac3b1452 100644
--- a/compiler/src/dotty/tools/dotc/reporting/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/messages.scala
@@ -2806,3 +2806,9 @@ class ValueDiscarding(tp: Type)(using Context)
     def kind = MessageKind.PotentialIssue
     def msg(using Context) = i"discarded non-Unit value of type $tp"
     def explain(using Context) = ""
+
+class UnusedNonUnitValue(tp: Type)(using Context)
+  extends Message(UnusedNonUnitValueID):
+    def kind = MessageKind.PotentialIssue
+    def msg(using Context) = i"unused value of type $tp"
+    def explain(using Context) = ""
diff --git a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
index 3d53371e603e..4ca00ce6366f 100644
--- a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
+++ b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
@@ -1163,8 +1163,7 @@ class RefChecks extends MiniPhase { thisPhase =>
     checkAllOverrides(cls)
     checkImplicitNotFoundAnnotation.template(cls.classDenot)
     tree
-  }
-  catch {
+  } catch {
     case ex: TypeError =>
       report.error(ex, tree.srcPos)
       tree
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 5752409c51c1..be4ebc11de26 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -1102,6 +1102,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     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
@@ -3128,7 +3129,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         traverse(xtree :: rest)
       case stat :: rest =>
         val stat1 = typed(stat)(using ctx.exprContext(stat, exprOwner))
-        checkStatementPurity(stat1)(stat, exprOwner)
+        if !checkInterestingResultInStatement(stat1) then checkStatementPurity(stat1)(stat, exprOwner)
         buf += stat1
         traverse(rest)(using stat1.nullableContext)
       case nil =>
@@ -4212,6 +4213,59 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           typedExpr(cmp, defn.BooleanType)
       case _ =>
 
+  private def checkInterestingResultInStatement(t: Tree)(using Context): Boolean = {
+    def isUninterestingSymbol(sym: Symbol): Boolean =
+      sym == NoSymbol ||
+      sym.isConstructor ||
+      sym.is(Package) ||
+      sym.isPackageObject ||
+      sym == defn.BoxedUnitClass ||
+      sym == defn.AnyClass ||
+      sym == defn.AnyRefAlias ||
+      sym == defn.AnyValClass
+    def isUninterestingType(tpe: Type): Boolean =
+      tpe == NoType ||
+      tpe.typeSymbol == defn.UnitClass ||
+      defn.isBottomClass(tpe.typeSymbol) ||
+      tpe =:= defn.UnitType ||
+      tpe.typeSymbol == defn.BoxedUnitClass ||
+      tpe =:= defn.AnyValType ||
+      tpe =:= defn.AnyType ||
+      tpe =:= defn.AnyRefType
+    def isJavaApplication(t: Tree): Boolean = t match {
+      case Apply(f, _) => f.symbol.is(JavaDefined) && !defn.ObjectClass.isSubClass(f.symbol.owner)
+      case _ => false
+    }
+    def checkInterestingShapes(t: Tree): Boolean = t match {
+      case If(_, thenpart, elsepart) => checkInterestingShapes(thenpart) || checkInterestingShapes(elsepart)
+      case Block(_, res) => checkInterestingShapes(res)
+      case Match(_, cases) => cases.exists(k => checkInterestingShapes(k.body))
+      case _ => checksForInterestingResult(t)
+    }
+    def checksForInterestingResult(t: Tree): Boolean = (
+         !t.isDef                               // ignore defs
+      && !isUninterestingSymbol(t.symbol)       // ctors, package, Unit, Any
+      && !isUninterestingType(t.tpe)            // bottom types, Unit, Any
+      && !isThisTypeResult(t)                   // buf += x
+      && !isSuperConstrCall(t)                  // just a thing
+      && !isJavaApplication(t)                  // Java methods are inherently side-effecting
+      // && !treeInfo.hasExplicitUnit(t)           // suppressed by explicit expr: Unit // TODO Should explicit `: Unit` be added as warning suppression?
+    )
+    if ctx.settings.WNonUnitStatement.value && !ctx.isAfterTyper && checkInterestingShapes(t) then
+      val where = t match {
+        case Block(_, res) => res
+        case If(_, thenpart, Literal(Constant(()))) =>
+          thenpart match {
+            case Block(_, res) => res
+            case _ => thenpart
+          }
+        case _ => t
+      }
+      report.warning(UnusedNonUnitValue(where.tpe), t.srcPos)
+      true
+    else false
+  }
+
   private def checkStatementPurity(tree: tpd.Tree)(original: untpd.Tree, exprOwner: Symbol)(using Context): Unit =
     if !tree.tpe.isErroneous
       && !ctx.isAfterTyper
diff --git a/tests/neg-custom-args/fatal-warnings/nonunit-statement.scala b/tests/neg-custom-args/fatal-warnings/nonunit-statement.scala
new file mode 100644
index 000000000000..399d132edfae
--- /dev/null
+++ b/tests/neg-custom-args/fatal-warnings/nonunit-statement.scala
@@ -0,0 +1,198 @@
+// scalac: -Wnonunit-statement -Wvalue-discard
+import collection.ArrayOps
+import collection.mutable.{ArrayBuilder, LinkedHashSet, ListBuffer}
+import concurrent._
+import scala.reflect.ClassTag
+
+class C {
+  import ExecutionContext.Implicits._
+  def c = {
+    def improved = Future(42)
+    def stale = Future(27)
+    improved              // error
+    stale
+  }
+}
+class D {
+  def d = {
+    class E
+    new E().toString      // error
+    new E().toString * 2
+  }
+}
+class F {
+  import ExecutionContext.Implicits._
+  Future(42)              // error
+}
+// unused template expression uses synthetic method of class
+case class K(s: String) {
+  copy()                  // error
+}
+// mutations returning this are ok
+class Mutate {
+  val b = ListBuffer.empty[Int]
+  b += 42                 // nowarn, returns this.type
+  val xs = List(42)
+  27 +: xs                // error
+
+  def f(x: Int): this.type = this
+  def g(): Unit = f(42)   // nowarn
+}
+// some uninteresting expressions may warn for other reasons
+class WhoCares {
+  null                    // error for purity
+  ???                     // nowarn for impurity
+}
+// explicit Unit ascription to opt out of warning, even for funky applies
+class Absolution {
+  def f(i: Int): Int = i+1
+  import ExecutionContext.Implicits._
+  // Future(42): Unit        // nowarn { F(42)(ctx) }: Unit where annot is on F(42)
+  // f(42): Unit             // nowarn
+}
+// warn uni-branched unless user disables it with -Wnonunit-if:false
+class Boxed[A](a: A) {
+  def isEmpty = false
+  def foreach[U](f: A => U): Unit =
+    if (!isEmpty) f(a)      // error (if)
+  def forall(f: A => Boolean): Unit =
+    if (!isEmpty) {
+      println(".")
+      f(a)                  // error (if)
+    }
+  def take(p: A => Boolean): Option[A] = {
+    while (isEmpty || !p(a)) ()
+    Some(a).filter(p)
+  }
+}
+class Unibranch[A, B] {
+  def runWith[U](action: B => U): A => Boolean = { x =>
+    val z = null.asInstanceOf[B]
+    val fellback = false
+    if (!fellback) action(z)  // error (if)
+    !fellback
+  }
+  def f(i: Int): Int = {
+    def g = 17
+    if (i < 42) {
+      g   // error block statement
+      println("uh oh")
+      g   // error (if)
+    }
+    while (i < 42) {
+      g   // error
+      println("uh oh")
+      g   // error
+    }
+    42
+  }
+}
+class Dibranch {
+  def i: Int = ???
+  def j: Int = ???
+  def f(b: Boolean): Int = {
+    // if-expr might have an uninteresting LUB
+    if (b) {          // error, at least one branch looks interesting
+      println("true")
+      i
+    }
+    else {
+      println("false")
+      j
+    }
+    42
+  }
+}
+class Next[A] {
+  val all = ListBuffer.empty[A]
+  def f(it: Iterator[A], g: A => A): Unit =
+    while (it.hasNext)
+      all += g(it.next())   // nowarn
+}
+class Setting[A] {
+  def set = LinkedHashSet.empty[A]
+  def f(a: A): Unit = {
+    set += a     // error because cannot know whether the `set` was supposed to be consumed or assigned
+    println(set)
+  }
+}
+// neither StringBuilder warns, because either append is Java method or returns this.type
+// while loop looks like if branch with block1(block2, jump to label), where block2 typed as non-unit
+class Strung {
+  def iterator = Iterator.empty[String]
+  def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder = {
+    val jsb = b.underlying
+    if (start.length != 0) jsb.append(start) // error (value-discard)
+    val it = iterator
+    if (it.hasNext) {
+      jsb.append(it.next())
+      while (it.hasNext) {
+        jsb.append(sep) // nowarn (java)
+        jsb.append(it.next()) // error (value-discard)
+      }
+    }
+    if (end.length != 0) jsb.append(end) // error (value-discard)
+    b
+  }
+  def f(b: java.lang.StringBuilder, it: Iterator[String]): String = {
+    while (it.hasNext) {
+      b.append("\n") // nowarn (java)
+      b.append(it.next()) // error (value-discard)
+    }
+    b.toString
+  }
+  def g(b: java.lang.StringBuilder, it: Iterator[String]): String = {
+    while (it.hasNext) it.next()  // error
+    b.toString
+  }
+}
+class J {
+  import java.util.Collections
+  def xs: java.util.List[Int] = ???
+  def f(): Int = {
+    Collections.checkedList[Int](xs, classOf[Int])
+    42
+  }
+}
+class Variant {
+  var bs = ListBuffer.empty[Int]
+  val xs = ListBuffer.empty[Int]
+  private[this] val ys = ListBuffer.empty[Int]
+  private[this] var zs = ListBuffer.empty[Int]
+  def f(i: Int): Unit = {
+    bs.addOne(i)
+    xs.addOne(i)
+    ys.addOne(i)
+    zs.addOne(i)
+    println("done")
+  }
+}
+final class ArrayOops[A](private val xs: Array[A]) extends AnyVal {
+  def other: ArrayOps[A] = ???
+  def transpose[B](implicit asArray: A => Array[B]): Array[Array[B]] = {
+    val aClass = xs.getClass.getComponentType
+    val bb = new ArrayBuilder.ofRef[Array[B]]()(ClassTag[Array[B]](aClass))
+    if (xs.length == 0) bb.result()
+    else {
+      def mkRowBuilder() = ArrayBuilder.make[B](ClassTag[B](aClass.getComponentType))
+      val bs = new ArrayOps(asArray(xs(0))).map((x: B) => mkRowBuilder())
+      for (xs <- other) {
+        var i = 0
+        for (x <- new ArrayOps(asArray(xs))) {
+          bs(i) += x
+          i += 1
+        }
+      }
+      for (b <- new ArrayOps(bs)) bb += b.result()
+      bb.result()
+    }
+  }
+}
+class Depends {
+  def f[A](a: A): a.type = a
+  def g() = {
+    val d = new Depends
+    f(d)
+    ()
+  }
+}

From 0ce5c32b7bf0e8ad8768011de71329be73ab6d3f Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 14 Feb 2023 10:36:21 +0100
Subject: [PATCH 179/657] Fix HK quoted pattern type variables

The issue was in the encoding into `{ExprMatchModule,TypeMatchModule}.unapply`.
Specifically with the `TypeBindings` argument. This arguments holds the
list of type variable definitions (`tpd.Bind` trees). We used a `Tuple`
to list all the types inside. The problem is that higher-kinded type
variables do not conform with the upper bounds of the tuple elements.
The solution is to use an HList with any-kinded elements.
---
 compiler/src/dotty/tools/dotc/ast/tpd.scala     |  8 ++++++--
 .../src/dotty/tools/dotc/core/Definitions.scala |  3 +++
 .../tools/dotc/typer/QuotesAndSplices.scala     |  4 ++--
 .../quoted/runtime/impl/QuoteMatcher.scala      |  4 ++--
 .../scala/quoted/runtime/impl/QuotesImpl.scala  |  4 ++--
 .../scala/quoted/runtime/QuoteMatching.scala    | 11 ++++++++---
 project/MiMaFilters.scala                       |  1 +
 .../hk-quoted-type-patterns/Macro_1.scala       | 17 +++++++++++++++++
 .../hk-quoted-type-patterns/Test_2.scala        |  5 +++++
 9 files changed, 46 insertions(+), 11 deletions(-)
 create mode 100644 tests/pos-macros/hk-quoted-type-patterns/Macro_1.scala
 create mode 100644 tests/pos-macros/hk-quoted-type-patterns/Test_2.scala

diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
index 1a202ece1e66..56cfbefabbfe 100644
--- a/compiler/src/dotty/tools/dotc/ast/tpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -1502,7 +1502,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     }
   }
 
-  /** Creates the tuple type tree repesentation of the type trees in `ts` */
+  /** Creates the tuple type tree representation of the type trees in `ts` */
   def tupleTypeTree(elems: List[Tree])(using Context): Tree = {
     val arity = elems.length
     if arity <= Definitions.MaxTupleArity then
@@ -1513,10 +1513,14 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     else nestedPairsTypeTree(elems)
   }
 
-  /** Creates the nested pairs type tree repesentation of the type trees in `ts` */
+  /** Creates the nested pairs type tree representation 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))
 
+  /** Creates the nested higher-kinded pairs type tree representation of the type trees in `ts` */
+  def hkNestedPairsTypeTree(ts: List[Tree])(using Context): Tree =
+    ts.foldRight[Tree](TypeTree(defn.QuoteMatching_KNil.typeRef))((x, acc) => AppliedTypeTree(TypeTree(defn.QuoteMatching_KCons.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 {
diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
index 854608143df9..74d210a4bbad 100644
--- a/compiler/src/dotty/tools/dotc/core/Definitions.scala
+++ b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -865,6 +865,9 @@ class Definitions {
     @tu lazy val QuoteMatching_ExprMatchModule: Symbol = QuoteMatchingClass.requiredClass("ExprMatchModule")
     @tu lazy val QuoteMatching_TypeMatch: Symbol = QuoteMatchingClass.requiredMethod("TypeMatch")
     @tu lazy val QuoteMatching_TypeMatchModule: Symbol = QuoteMatchingClass.requiredClass("TypeMatchModule")
+  @tu lazy val QuoteMatchingModule: Symbol = requiredModule("scala.quoted.runtime.QuoteMatching")
+    @tu lazy val QuoteMatching_KNil: Symbol = QuoteMatchingModule.requiredType("KNil")
+    @tu lazy val QuoteMatching_KCons: Symbol = QuoteMatchingModule.requiredType("KCons")
 
   @tu lazy val ToExprModule: Symbol = requiredModule("scala.quoted.ToExpr")
     @tu lazy val ToExprModule_BooleanToExpr: Symbol = ToExprModule.requiredMethod("BooleanToExpr")
diff --git a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
index 2fe5770c5b4b..65d8abfdf6a7 100644
--- a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
+++ b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
@@ -364,7 +364,7 @@ trait QuotesAndSplices {
    *
    *  ```
    *  case scala.internal.quoted.Expr.unapply[
-   *          Tuple1[t @ _], // Type binging definition
+   *          KList[t @ _, KNil], // Type binging definition
    *          Tuple2[Type[t], Expr[List[t]]] // Typing the result of the pattern match
    *        ](
    *          Tuple2.unapply
@@ -411,7 +411,7 @@ trait QuotesAndSplices {
     val replaceBindings = new ReplaceBindings
     val patType = defn.tupleType(splices.tpes.map(tpe => replaceBindings(tpe.widen)))
 
-    val typeBindingsTuple = tpd.tupleTypeTree(typeBindings.values.toList)
+    val typeBindingsTuple = tpd.hkNestedPairsTypeTree(typeBindings.values.toList)
 
     val replaceBindingsInTree = new TreeMap {
       private var bindMap = Map.empty[Symbol, Symbol]
diff --git a/compiler/src/scala/quoted/runtime/impl/QuoteMatcher.scala b/compiler/src/scala/quoted/runtime/impl/QuoteMatcher.scala
index d85d92de5455..7c952dbbe142 100644
--- a/compiler/src/scala/quoted/runtime/impl/QuoteMatcher.scala
+++ b/compiler/src/scala/quoted/runtime/impl/QuoteMatcher.scala
@@ -121,9 +121,9 @@ object QuoteMatcher {
 
   private def withEnv[T](env: Env)(body: Env ?=> T): T = body(using env)
 
-  def treeMatch(scrutineeTerm: Tree, patternTerm: Tree)(using Context): Option[Tuple] =
+  def treeMatch(scrutineeTree: Tree, patternTree: Tree)(using Context): Option[Tuple] =
     given Env = Map.empty
-    scrutineeTerm =?= patternTerm
+    scrutineeTree =?= patternTree
 
   /** Check that all trees match with `mtch` and concatenate the results with &&& */
   private def matchLists[T](l1: List[T], l2: List[T])(mtch: (T, T) => Matching): Matching = (l1, l2) match {
diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
index 9ccec4683747..df118793a2f3 100644
--- a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
+++ b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
@@ -3092,14 +3092,14 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
     new TypeImpl(tree, SpliceScope.getCurrent).asInstanceOf[scala.quoted.Type[T]]
 
   object ExprMatch extends ExprMatchModule:
-    def unapply[TypeBindings <: Tuple, Tup <: Tuple](scrutinee: scala.quoted.Expr[Any])(using pattern: scala.quoted.Expr[Any]): Option[Tup] =
+    def unapply[TypeBindings, Tup <: Tuple](scrutinee: scala.quoted.Expr[Any])(using pattern: scala.quoted.Expr[Any]): Option[Tup] =
       val scrutineeTree = reflect.asTerm(scrutinee)
       val patternTree = reflect.asTerm(pattern)
       treeMatch(scrutineeTree, patternTree).asInstanceOf[Option[Tup]]
   end ExprMatch
 
   object TypeMatch extends TypeMatchModule:
-    def unapply[TypeBindings <: Tuple, Tup <: Tuple](scrutinee: scala.quoted.Type[?])(using pattern: scala.quoted.Type[?]): Option[Tup] =
+    def unapply[TypeBindings, Tup <: Tuple](scrutinee: scala.quoted.Type[?])(using pattern: scala.quoted.Type[?]): Option[Tup] =
       val scrutineeTree = reflect.TypeTree.of(using scrutinee)
       val patternTree = reflect.TypeTree.of(using pattern)
       treeMatch(scrutineeTree, patternTree).asInstanceOf[Option[Tup]]
diff --git a/library/src/scala/quoted/runtime/QuoteMatching.scala b/library/src/scala/quoted/runtime/QuoteMatching.scala
index 2a76143e9868..c95ffe87b5dc 100644
--- a/library/src/scala/quoted/runtime/QuoteMatching.scala
+++ b/library/src/scala/quoted/runtime/QuoteMatching.scala
@@ -17,7 +17,7 @@ trait QuoteMatching:
     *    - `ExprMatch.unapply('{ f(0, myInt) })('{ f(patternHole[Int], patternHole[Int]) }, _)`
     *       will return `Some(Tuple2('{0}, '{ myInt }))`
     *    - `ExprMatch.unapply('{ f(0, "abc") })('{ f(0, patternHole[Int]) }, _)`
-    *       will return `None` due to the missmatch of types in the hole
+    *       will return `None` due to the mismatch of types in the hole
     *
     *  Holes:
     *    - scala.quoted.runtime.Patterns.patternHole[T]: hole that matches an expression `x` of type `Expr[U]`
@@ -27,7 +27,7 @@ trait QuoteMatching:
     *  @param pattern `Expr[Any]` containing the pattern tree
     *  @return None if it did not match, `Some(tup)` if it matched where `tup` contains `Expr[Ti]``
     */
-    def unapply[TypeBindings <: Tuple, Tup <: Tuple](scrutinee: Expr[Any])(using pattern: Expr[Any]): Option[Tup]
+    def unapply[TypeBindings, Tup <: Tuple](scrutinee: Expr[Any])(using pattern: Expr[Any]): Option[Tup]
   }
 
   val TypeMatch: TypeMatchModule
@@ -40,5 +40,10 @@ trait QuoteMatching:
      *  @param pattern `Type[?]` containing the pattern tree
      *  @return None if it did not match, `Some(tup)` if it matched where `tup` contains `Type[Ti]``
      */
-    def unapply[TypeBindings <: Tuple, Tup <: Tuple](scrutinee: Type[?])(using pattern: Type[?]): Option[Tup]
+    def unapply[TypeBindings, Tup <: Tuple](scrutinee: Type[?])(using pattern: Type[?]): Option[Tup]
   }
+
+object QuoteMatching:
+  type KList
+  type KCons[+H <: AnyKind, +T <: KList] <: KList
+  type KNil <: KList
diff --git a/project/MiMaFilters.scala b/project/MiMaFilters.scala
index 8af2de7058ee..cf344fe8ca33 100644
--- a/project/MiMaFilters.scala
+++ b/project/MiMaFilters.scala
@@ -16,6 +16,7 @@ object MiMaFilters {
     ProblemFilters.exclude[MissingClassProblem]("scala.util.boundary$"),
     ProblemFilters.exclude[MissingClassProblem]("scala.util.boundary$Break"),
     ProblemFilters.exclude[MissingClassProblem]("scala.util.boundary$Label"),
+    ProblemFilters.exclude[MissingClassProblem]("scala.quoted.runtime.QuoteMatching$"),
 
     // Scala.js only: new runtime support class in 3.2.3; not available to users
     ProblemFilters.exclude[MissingClassProblem]("scala.scalajs.runtime.AnonFunctionXXL"),
diff --git a/tests/pos-macros/hk-quoted-type-patterns/Macro_1.scala b/tests/pos-macros/hk-quoted-type-patterns/Macro_1.scala
new file mode 100644
index 000000000000..0d2df1504918
--- /dev/null
+++ b/tests/pos-macros/hk-quoted-type-patterns/Macro_1.scala
@@ -0,0 +1,17 @@
+import scala.quoted._
+
+private def impl(x: Expr[Any])(using Quotes): Expr[Unit] = {
+  x match
+    case '{ foo[x] } =>
+      assert(Type.show[x] == "scala.Int", Type.show[x])
+    case '{ type f[X]; foo[`f`] } =>
+      assert(Type.show[f] == "[A >: scala.Nothing <: scala.Any] => scala.collection.immutable.List[A]", Type.show[f])
+    case '{ type f <: AnyKind; foo[`f`] } =>
+      assert(Type.show[f] == "[K >: scala.Nothing <: scala.Any, V >: scala.Nothing <: scala.Any] => scala.collection.immutable.Map[K, V]", Type.show[f])
+    case x => throw MatchError(x.show)
+  '{}
+}
+
+inline def test(inline x: Any): Unit = ${ impl('x) }
+
+def foo[T <: AnyKind]: Any = ???
diff --git a/tests/pos-macros/hk-quoted-type-patterns/Test_2.scala b/tests/pos-macros/hk-quoted-type-patterns/Test_2.scala
new file mode 100644
index 000000000000..3cb9113f2452
--- /dev/null
+++ b/tests/pos-macros/hk-quoted-type-patterns/Test_2.scala
@@ -0,0 +1,5 @@
+@main
+def Test =
+  test(foo[Int])
+  test(foo[List])
+  test(foo[Map])

From 9344e514246e9cbdf119c94a1871cc4dfc18ad19 Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wojciech.mazur95@gmail.com>
Date: Mon, 20 Feb 2023 15:51:54 +0100
Subject: [PATCH 180/657] Remove usage of JDK version dependent method from
 neg/i16820 test. `formatted` is a deprecated Scala extension method and a
 function with a the same was added to String in JDK15

---
 tests/neg/i16820.check | 12 ++++--------
 tests/neg/i16820.scala |  4 +---
 2 files changed, 5 insertions(+), 11 deletions(-)

diff --git a/tests/neg/i16820.check b/tests/neg/i16820.check
index 5f2e82bbf2ef..f51bfafef899 100644
--- a/tests/neg/i16820.check
+++ b/tests/neg/i16820.check
@@ -8,15 +8,11 @@
   |           method g in object Test must be called with () argument
   |
   | longer explanation available when compiling with `-explain`
--- Error: tests/neg/i16820.scala:8:14 ----------------------------------------------------------------------------------
-8 |  val x3 = "".formatted // error
-  |           ^^^^^^^^^^^^
-  |           missing arguments for method formatted in class String
--- Error: tests/neg/i16820.scala:9:40 ----------------------------------------------------------------------------------
-9 |  val x4 = java.nio.file.Paths.get(".").toRealPath // error
+-- Error: tests/neg/i16820.scala:7:40 ----------------------------------------------------------------------------------
+7 |  val x3 = java.nio.file.Paths.get(".").toRealPath // error
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |           missing arguments for method toRealPath in trait Path
--- Error: tests/neg/i16820.scala:13:14 ---------------------------------------------------------------------------------
-13 |def test = Foo(3)  // error
+-- Error: tests/neg/i16820.scala:11:14 ---------------------------------------------------------------------------------
+11 |def test = Foo(3)  // error
    |           ^^^^^^
    |           missing arguments for method apply in object Foo
diff --git a/tests/neg/i16820.scala b/tests/neg/i16820.scala
index 7a93f3a5d355..abdc741b9f0e 100644
--- a/tests/neg/i16820.scala
+++ b/tests/neg/i16820.scala
@@ -4,9 +4,7 @@ object Test:
 
   val x1 = f  // error
   val x2 = g  // error
-
-  val x3 = "".formatted // error
-  val x4 = java.nio.file.Paths.get(".").toRealPath // error
+  val x3 = java.nio.file.Paths.get(".").toRealPath // error
 
 // #14567
 case class Foo(x: Int)(xs: String*)

From 4ee457469b30b39f1e650b4a382a585033f4f385 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Mon, 20 Feb 2023 16:51:05 +0100
Subject: [PATCH 181/657] Do not depend on runtime lib in tests

---
 tests/run/i16806.scala | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/tests/run/i16806.scala b/tests/run/i16806.scala
index f45652080458..0b0dfe1f6b35 100644
--- a/tests/run/i16806.scala
+++ b/tests/run/i16806.scala
@@ -1,5 +1,4 @@
 import java.util.concurrent.Semaphore
-import scala.runtime.LazyVals.Evaluating
 
 object Repro {
 
@@ -25,14 +24,14 @@ object Repro {
       override def run(): Unit =
         Holder.s.acquire()
         val x = Holder.Bit.value
-        assert(!x.isInstanceOf[Evaluating.type])
+        assert(x.isInstanceOf[DFBit.type])
         println("Success")
     }
     val b = new Thread() {
       override def run(): Unit =
         Holder.s.acquire()
         val x = Holder.Bit.value
-        assert(!x.isInstanceOf[Evaluating.type])
+        assert(x.isInstanceOf[DFBit.type])
         println("Success")
     }
     a.start()

From bc00ea104788715cbf2bfc7854fdb4d3a43d3e37 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Mon, 20 Feb 2023 16:00:01 +0000
Subject: [PATCH 182/657] Fix use of accessibleFrom when finding default arg
 getters

---
 compiler/src/dotty/tools/dotc/typer/Applications.scala | 2 +-
 tests/pos/i16814.scala                                 | 2 ++
 2 files changed, 3 insertions(+), 1 deletion(-)
 create mode 100644 tests/pos/i16814.scala

diff --git a/compiler/src/dotty/tools/dotc/typer/Applications.scala b/compiler/src/dotty/tools/dotc/typer/Applications.scala
index 36e3618d30f7..a8abd868fdef 100644
--- a/compiler/src/dotty/tools/dotc/typer/Applications.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Applications.scala
@@ -272,7 +272,7 @@ object Applications {
     else
       def selectGetter(qual: Tree): Tree =
         val getterDenot = qual.tpe.member(getterName)
-          .accessibleFrom(qual.tpe.widenIfUnstable) // to reset Local
+          .accessibleFrom(qual.tpe.widenIfUnstable, superAccess = true) // to reset Local
         if (getterDenot.exists) qual.select(TermRef(qual.tpe, getterName, getterDenot))
         else EmptyTree
       if !meth.isClassConstructor then
diff --git a/tests/pos/i16814.scala b/tests/pos/i16814.scala
new file mode 100644
index 000000000000..bffbb5788c0b
--- /dev/null
+++ b/tests/pos/i16814.scala
@@ -0,0 +1,2 @@
+class Foo protected (foo: Int = 0) { }
+class Bar extends Foo

From 4386f3f75a0eb05b523ec205281849c2c93c1222 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 20 Feb 2023 11:15:33 +0100
Subject: [PATCH 183/657] Fix reflect.LambdaType type test

Fixes #16961
---
 .../src/scala/quoted/runtime/impl/QuotesImpl.scala     |  4 ++--
 .../src/dotty/tools/scaladoc/tasty/TypesSupport.scala  |  4 ++--
 tests/pos-macros/i16961/Macro_1.scala                  | 10 ++++++++++
 tests/pos-macros/i16961/Test_2.scala                   |  1 +
 4 files changed, 15 insertions(+), 4 deletions(-)
 create mode 100644 tests/pos-macros/i16961/Macro_1.scala
 create mode 100644 tests/pos-macros/i16961/Test_2.scala

diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
index 965a3e907878..6688d6e81a89 100644
--- a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
+++ b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
@@ -2167,11 +2167,11 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
       end extension
     end PolyTypeMethods
 
-    type TypeLambda = dotc.core.Types.TypeLambda
+    type TypeLambda = dotc.core.Types.HKTypeLambda
 
     object TypeLambdaTypeTest extends TypeTest[TypeRepr, TypeLambda]:
       def unapply(x: TypeRepr): Option[TypeLambda & x.type] = x match
-        case tpe: (Types.TypeLambda & x.type) => Some(tpe)
+        case tpe: (Types.HKTypeLambda & x.type) => Some(tpe)
         case _ => None
     end TypeLambdaTypeTest
 
diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/TypesSupport.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/TypesSupport.scala
index 0cf2669407c8..c94eda9409b2 100644
--- a/scaladoc/src/dotty/tools/scaladoc/tasty/TypesSupport.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/tasty/TypesSupport.scala
@@ -290,10 +290,10 @@ trait TypesSupport:
         }
         inner(sc) ++ keyword(" match ").l ++ plain("{\n").l ++ casesTexts ++ plain(spaces + "}").l
 
-      case ParamRef(TypeLambda(names, _, _), i) => tpe(names.apply(i)).l
-
       case ParamRef(m: MethodType, i) => tpe(m.paramNames(i)).l ++ plain(".type").l
 
+      case ParamRef(binder: LambdaType, i) => tpe(binder.paramNames(i)).l
+
       case RecursiveType(tp) => inner(tp)
 
       case MatchCase(pattern, rhs) =>
diff --git a/tests/pos-macros/i16961/Macro_1.scala b/tests/pos-macros/i16961/Macro_1.scala
new file mode 100644
index 000000000000..20ec6b439ec8
--- /dev/null
+++ b/tests/pos-macros/i16961/Macro_1.scala
@@ -0,0 +1,10 @@
+import scala.quoted.*
+
+inline def myMacro = ${ myMacroImpl }
+
+def myMacroImpl(using Quotes) =
+  import quotes.reflect.*
+
+  PolyType(List("arg"))(_ => List(TypeBounds.empty), _ => TypeRepr.of[Any]) match
+    case _: TypeLambda => quotes.reflect.report.errorAndAbort("PolyType should not be a TypeLambda")
+    case _ => '{ () } // Ok
diff --git a/tests/pos-macros/i16961/Test_2.scala b/tests/pos-macros/i16961/Test_2.scala
new file mode 100644
index 000000000000..76a9e17659db
--- /dev/null
+++ b/tests/pos-macros/i16961/Test_2.scala
@@ -0,0 +1 @@
+def test = myMacro

From 9161b114dc0bfa92d0a72ea78ef674644dce8077 Mon Sep 17 00:00:00 2001
From: Guillaume Martres <smarter@ubuntu.com>
Date: Tue, 21 Feb 2023 19:01:42 +0100
Subject: [PATCH 184/657] Fix caching issue caused by incorrect isProvisional
 check

A static TypeRef can still be provisional if it's currently being completed (see
the logic in `Namer#TypeDefCompleter#typeSig`).

Fixes #16950.
---
 compiler/src/dotty/tools/dotc/core/Types.scala |  5 ++---
 tests/pos/i16950.scala                         | 11 +++++++++++
 2 files changed, 13 insertions(+), 3 deletions(-)
 create mode 100644 tests/pos/i16950.scala

diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index d4fa6a819dc4..b9f4ce48092b 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -118,10 +118,9 @@ object Types {
         if t.mightBeProvisional then
           t.mightBeProvisional = t match
             case t: TypeRef =>
-              !t.currentSymbol.isStatic && {
+              t.currentSymbol.isProvisional || !t.currentSymbol.isStatic && {
                 (t: Type).mightBeProvisional = false // break cycles
-                t.symbol.isProvisional
-                || test(t.prefix, theAcc)
+                test(t.prefix, theAcc)
                 || t.denot.infoOrCompleter.match
                     case info: LazyType => true
                     case info: AliasingBounds => test(info.alias, theAcc)
diff --git a/tests/pos/i16950.scala b/tests/pos/i16950.scala
new file mode 100644
index 000000000000..ac95a477136e
--- /dev/null
+++ b/tests/pos/i16950.scala
@@ -0,0 +1,11 @@
+object Foo:
+  def bar(x : Bar.YOf[Any]): Unit = ???
+
+trait K:
+  type CType <: Bar.YOf[Any]
+  def foo : K =
+    val x : CType = ???
+    x // was: error: Found: CType, Expected: K
+
+object Bar:
+  type YOf[T] = K { type M }

From e0ccff0484187a5fcbfd21cc850294bb83f0fb40 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Sun, 15 Jan 2023 17:57:34 +0000
Subject: [PATCH 185/657] Space: Cache simplify

---
 .../tools/dotc/transform/patmat/Space.scala    | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index 64e0d9a94a1a..b5cc9a034812 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -66,6 +66,12 @@ sealed trait Space:
     else trace(s"isSubspace(${show(this)}, ${show(b)})", debug) {
       isSubspaceCache.getOrElseUpdate(b, computeIsSubspace(this, b))
     }
+
+  private var mySimplified: Space = _
+
+  def simplify(using Context): Space =
+    if mySimplified == null then mySimplified = SpaceEngine.computeSimplify(this)
+    mySimplified
 end Space
 
 /** Empty space */
@@ -98,8 +104,13 @@ case class Or(spaces: Seq[Space]) extends Space
 object SpaceEngine {
   import tpd._
 
+  def simplify(space: Space)(using Context): Space           = space.simplify
+  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
+
   /** 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 {
+  def computeSimplify(space: Space)(using Context): Space = trace(s"simplify ${show(space)} --> ", debug, show)(space match {
     case Prod(tp, fun, spaces) =>
       val sps = spaces.mapconserve(simplify)
       if sps.contains(Empty) then Empty
@@ -150,8 +161,6 @@ object SpaceEngine {
   }
 
   /** Is `a` a subspace of `b`? Equivalent to `simplify(simplify(a) - simplify(b)) == Empty`, but faster */
-  def isSubspace(a: Space, b: Space)(using Context): Boolean = a.isSubspace(b)
-
   def computeIsSubspace(a: Space, b: Space)(using Context): Boolean = {
     val a2 = simplify(a)
     val b2 = simplify(b)
@@ -578,9 +587,6 @@ object SpaceEngine {
       scrutineeTp <:< tp
     }
 
-  def canDecompose(typ: Typ)(using Context): Boolean = typ.canDecompose
-  def decompose(typ: Typ)(using Context): List[Typ]  = typ.decompose
-
   /** Decompose a type into subspaces -- assume the type can be decomposed */
   def decompose(tp: Type)(using Context): List[Type] = trace(i"decompose($tp)", debug) {
     def rec(tp: Type, mixins: List[Type]): List[Type] = tp.dealias match

From d58805d2d4999249f552eaa10e70a45f5b3e0136 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Sun, 19 Feb 2023 16:00:16 +0000
Subject: [PATCH 186/657] Space: make code pass -Yexplicit-nulls

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

diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index b5cc9a034812..3fd3064d2168 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -67,11 +67,15 @@ sealed trait Space:
       isSubspaceCache.getOrElseUpdate(b, computeIsSubspace(this, b))
     }
 
-  private var mySimplified: Space = _
+  private var mySimplified: Space | Null = _
 
   def simplify(using Context): Space =
-    if mySimplified == null then mySimplified = SpaceEngine.computeSimplify(this)
-    mySimplified
+    val simplified = mySimplified
+    if simplified == null then
+      val simplified = SpaceEngine.computeSimplify(this)
+      mySimplified = simplified
+      simplified
+    else simplified
 end Space
 
 /** Empty space */
@@ -84,15 +88,19 @@ case object Empty extends Space
  *
  */
 case class Typ(tp: Type, decomposed: Boolean = true) extends Space:
-  private var myDecompose: List[Typ] = _
+  private var myDecompose: List[Typ] | Null = _
 
   def canDecompose(using Context): Boolean = decompose != SpaceEngine.ListOfTypNoType
 
   def decompose(using Context): List[Typ] =
-    if myDecompose == null then myDecompose = tp match
-      case SpaceEngine.Parts(parts) => parts.map(Typ(_, decomposed = true))
-      case _                        => SpaceEngine.ListOfTypNoType
-    myDecompose
+    val decompose = myDecompose
+    if decompose == null then
+      val decompose = tp match
+        case SpaceEngine.Parts(parts) => parts.map(Typ(_, decomposed = true))
+        case _                        => SpaceEngine.ListOfTypNoType
+      myDecompose = decompose
+      decompose
+    else decompose
 end Typ
 
 /** Space representing an extractor pattern */

From 2a4aef069461e25da1821605f9ddd59df470ce72 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Mon, 20 Feb 2023 10:28:41 +0000
Subject: [PATCH 187/657] Space: Fix decomposable prefixes of TermRefs

---
 compiler/src/dotty/tools/dotc/core/Types.scala             | 5 ++++-
 compiler/src/dotty/tools/dotc/transform/patmat/Space.scala | 4 ++--
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index d2fc225ff19d..e8cbced423bc 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -2182,7 +2182,7 @@ object Types {
 
 // --- NamedTypes ------------------------------------------------------------------
 
-  abstract class NamedType extends CachedProxyType, ValueType { self =>
+  abstract class NamedType extends CachedProxyType, ValueType, Product { self =>
 
     type ThisType >: this.type <: NamedType
     type ThisName <: Name
@@ -2190,6 +2190,8 @@ object Types {
     val prefix: Type
     def designator: Designator
     protected def designator_=(d: Designator): Unit
+    def _1: Type
+    def _2: Designator
 
     assert(NamedType.validPrefix(prefix), s"invalid prefix $prefix")
 
@@ -2905,6 +2907,7 @@ object Types {
     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 unapply(tp: NamedType): NamedType = tp
 
     def validPrefix(prefix: Type): Boolean = prefix.isValueType || (prefix eq NoPrefix)
   }
diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index 3fd3064d2168..859528e72e89 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -611,11 +611,11 @@ object SpaceEngine {
           case tp if !TypeComparer.provablyDisjoint(tp, tpB) => AndType(tp, tpB)
 
       case OrType(tp1, tp2)                            => List(tp1, tp2)
-      case _: SingletonType                            => ListOfNoType
       case tp if tp.isRef(defn.BooleanClass)           => List(ConstantType(Constant(true)), ConstantType(Constant(false)))
       case tp if tp.isRef(defn.UnitClass)              => ConstantType(Constant(())) :: Nil
       case tp if tp.classSymbol.isAllOf(JavaEnumTrait) => tp.classSymbol.children.map(_.termRef)
-      case tp @ TypeRef(Parts(parts), _)               => parts.map(tp.derivedSelect)
+      case tp @ NamedType(Parts(parts), _)             => parts.map(tp.derivedSelect)
+      case _: SingletonType                            => ListOfNoType
 
       case tp @ AppliedType(Parts(parts), targs) if tp.classSymbol.children.isEmpty =>
         // It might not obvious that it's OK to apply the type arguments of a parent type to child types.

From fbead6cc5e1da619eac968951aadfb6366c6fd10 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Mon, 20 Feb 2023 14:22:39 +0000
Subject: [PATCH 188/657] Space: Fix decomposable, dont recurse on Java enums

---
 .../src/dotty/tools/dotc/transform/patmat/Space.scala     | 3 ++-
 tests/patmat/java-enum1/ParameterModifier.java            | 8 ++++++++
 tests/patmat/java-enum1/Test.scala                        | 6 ++++++
 3 files changed, 16 insertions(+), 1 deletion(-)
 create mode 100644 tests/patmat/java-enum1/ParameterModifier.java
 create mode 100644 tests/patmat/java-enum1/Test.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index 859528e72e89..93800df6eeb8 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -613,9 +613,10 @@ object SpaceEngine {
       case OrType(tp1, tp2)                            => List(tp1, tp2)
       case tp if tp.isRef(defn.BooleanClass)           => List(ConstantType(Constant(true)), ConstantType(Constant(false)))
       case tp if tp.isRef(defn.UnitClass)              => ConstantType(Constant(())) :: Nil
-      case tp if tp.classSymbol.isAllOf(JavaEnumTrait) => tp.classSymbol.children.map(_.termRef)
       case tp @ NamedType(Parts(parts), _)             => parts.map(tp.derivedSelect)
       case _: SingletonType                            => ListOfNoType
+      case tp if tp.classSymbol.isAllOf(JavaEnumTrait) => tp.classSymbol.children.map(_.termRef)
+        // the class of a java enum value is the enum class, so this must follow SingletonType to not loop infinitely
 
       case tp @ AppliedType(Parts(parts), targs) if tp.classSymbol.children.isEmpty =>
         // It might not obvious that it's OK to apply the type arguments of a parent type to child types.
diff --git a/tests/patmat/java-enum1/ParameterModifier.java b/tests/patmat/java-enum1/ParameterModifier.java
new file mode 100644
index 000000000000..c9ddc157ba7e
--- /dev/null
+++ b/tests/patmat/java-enum1/ParameterModifier.java
@@ -0,0 +1,8 @@
+public enum ParameterModifier {
+    Repeated,
+    Plain,
+    ByName;
+
+    private ParameterModifier() {
+    }
+}
diff --git a/tests/patmat/java-enum1/Test.scala b/tests/patmat/java-enum1/Test.scala
new file mode 100644
index 000000000000..b6ea483d8fb4
--- /dev/null
+++ b/tests/patmat/java-enum1/Test.scala
@@ -0,0 +1,6 @@
+class Test:
+  private def showParameterModifier(base: String, pm: ParameterModifier): String = pm match {
+    case ParameterModifier.Plain    => base
+    case ParameterModifier.Repeated => base + "*"
+    case ParameterModifier.ByName   => "=> " + base
+  }

From 24cc7236edad681d94c951add27554b33219ae53 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Mon, 20 Feb 2023 21:16:21 +0000
Subject: [PATCH 189/657] Space: Fix isSubspace invariant by using simplify

---
 .../src/dotty/tools/dotc/transform/patmat/Space.scala     | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index 93800df6eeb8..0c1ead0e71cb 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -61,10 +61,14 @@ sealed trait Space:
   private val isSubspaceCache = mutable.HashMap.empty[Space, Boolean]
 
   def isSubspace(b: Space)(using Context): Boolean =
-    if this == Empty then true
+    val a = this
+    val a2 = a.simplify
+    val b2 = b.simplify
+    if (a ne a2) || (b ne b2) then a2.isSubspace(b2)
+    else if a == Empty then true
     else if b == Empty then false
     else trace(s"isSubspace(${show(this)}, ${show(b)})", debug) {
-      isSubspaceCache.getOrElseUpdate(b, computeIsSubspace(this, b))
+      isSubspaceCache.getOrElseUpdate(b, computeIsSubspace(a, b))
     }
 
   private var mySimplified: Space | Null = _

From 1f57accfa3af2b620ec0e39b589afeebe8ebbe3b Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Tue, 21 Feb 2023 09:19:15 +0000
Subject: [PATCH 190/657] Space: Make new mutation `@sharable`

---
 compiler/src/dotty/tools/dotc/transform/patmat/Space.scala | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index 0c1ead0e71cb..87c8d3760067 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -23,6 +23,7 @@ import reporting._
 import config.Printers.{exhaustivity => debug}
 import util.{SrcPos, NoSourcePosition}
 
+import scala.annotation.internal.sharable
 import scala.collection.mutable
 
 /* Space logic for checking exhaustivity and unreachability of pattern matching
@@ -58,7 +59,7 @@ import scala.collection.mutable
 sealed trait Space:
   import SpaceEngine.*
 
-  private val isSubspaceCache = mutable.HashMap.empty[Space, Boolean]
+  @sharable private val isSubspaceCache = mutable.HashMap.empty[Space, Boolean]
 
   def isSubspace(b: Space)(using Context): Boolean =
     val a = this
@@ -71,7 +72,7 @@ sealed trait Space:
       isSubspaceCache.getOrElseUpdate(b, computeIsSubspace(a, b))
     }
 
-  private var mySimplified: Space | Null = _
+  @sharable private var mySimplified: Space | Null = _
 
   def simplify(using Context): Space =
     val simplified = mySimplified

From a5858985e8170b5fede85217a9f7d607dec160cc Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Wed, 22 Feb 2023 11:31:52 +0000
Subject: [PATCH 191/657] Space: Extract & document isDecomposableToChildren

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

diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index 87c8d3760067..b33719063a3f 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -630,13 +630,7 @@ object SpaceEngine {
         // For instance, from i15029, `decompose((X | Y).Field[T]) = [X.Field[T], Y.Field[T]]`.
         parts.map(tp.derivedAppliedType(_, targs))
 
-      case tp if {
-        val cls = tp.classSymbol
-        cls.is(Sealed)
-        && cls.isOneOf(AbstractOrTrait)
-        && !cls.hasAnonymousChild
-        && cls.children.nonEmpty
-      } =>
+      case tp if tp.classSymbol.isDecomposableToChildren =>
         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...
@@ -672,6 +666,18 @@ object SpaceEngine {
     rec(tp, Nil)
   }
 
+  extension (cls: Symbol)
+    /** A type is decomposable to children if it's sealed,
+      * abstract (or a trait) - so its not a sealed concrete class that can be instantiated on its own,
+      * has no anonymous children, which we wouldn't be able to name as counter-examples,
+      * but does have children.
+      *
+      * A sealed trait with no subclasses is considered not decomposable and thus is treated as an opaque type.
+      * A sealed trait with subclasses that then get removed after `refineUsingParent`, decomposes to the empty list.
+      * So that's why we consider whether a type has children. */
+    def isDecomposableToChildren(using Context): Boolean =
+      cls.is(Sealed) && cls.isOneOf(AbstractOrTrait) && !cls.hasAnonymousChild && cls.children.nonEmpty
+
   val ListOfNoType    = List(NoType)
   val ListOfTypNoType = ListOfNoType.map(Typ(_, decomposed = true))
 

From daef636b9431e4cdd3439489c6b2f1890e89dcaf Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Wed, 22 Feb 2023 11:36:24 +0000
Subject: [PATCH 192/657] Space: Initialise caches with null

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

diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index b33719063a3f..d69371520413 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -72,7 +72,7 @@ sealed trait Space:
       isSubspaceCache.getOrElseUpdate(b, computeIsSubspace(a, b))
     }
 
-  @sharable private var mySimplified: Space | Null = _
+  @sharable private var mySimplified: Space | Null = null
 
   def simplify(using Context): Space =
     val simplified = mySimplified
@@ -93,7 +93,7 @@ case object Empty extends Space
  *
  */
 case class Typ(tp: Type, decomposed: Boolean = true) extends Space:
-  private var myDecompose: List[Typ] | Null = _
+  private var myDecompose: List[Typ] | Null = null
 
   def canDecompose(using Context): Boolean = decompose != SpaceEngine.ListOfTypNoType
 

From 1a6224b8ced3b926733044e1c7700212303b3880 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Pa=C5=82ka?= <prolativus@gmail.com>
Date: Wed, 15 Feb 2023 17:15:46 +0100
Subject: [PATCH 193/657] Preserve correct behaviour of structural selection
 for reflective and non-reflective access

---
 .../dotty/tools/dotc/core/Definitions.scala   |  2 +
 .../src/dotty/tools/dotc/typer/Dynamic.scala  | 38 ++++++++----
 tests/run/i14340.check                        | 10 +++-
 tests/run/i14340.scala                        | 59 +++++++++++++++----
 4 files changed, 84 insertions(+), 25 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
index 174244b4a456..5416c0719467 100644
--- a/compiler/src/dotty/tools/dotc/core/Definitions.scala
+++ b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -808,6 +808,8 @@ class Definitions {
   @tu lazy val ClassTagModule: Symbol = ClassTagClass.companionModule
     @tu lazy val ClassTagModule_apply: Symbol = ClassTagModule.requiredMethod(nme.apply)
 
+  @tu lazy val ReflectSelectableTypeRef: TypeRef = requiredClassRef("scala.reflect.Selectable")
+
   @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)
diff --git a/compiler/src/dotty/tools/dotc/typer/Dynamic.scala b/compiler/src/dotty/tools/dotc/typer/Dynamic.scala
index 5de9ca6ab341..92d4f678b15c 100644
--- a/compiler/src/dotty/tools/dotc/typer/Dynamic.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Dynamic.scala
@@ -216,15 +216,33 @@ trait Dynamic {
     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 if ValueClasses.isDerivedValueClass(tpe.classSymbol) =>
-        val underlying = ValueClasses.valueClassUnbox(tpe.classSymbol.asClass).info.resultType.asSeenFrom(tpe, tpe.classSymbol)
-        val wrapped = structuralCall(nme.selectDynamic, Nil)
-        val resultTree = if wrapped.tpe.isExactlyAny then New(tpe, wrapped.cast(underlying) :: Nil) else wrapped
-        resultTree.cast(tpe)
+    extension (tree: Tree)
+      /** The implementations of `selectDynamic` and `applyDynamic` in `scala.reflect.SelectDynamic` have no information about the expected return type of a value/method which was declared in the refinement,
+       *  only the JVM type after erasure can be obtained through reflection, e.g.
+       *  
+       *  class Foo(val i: Int) extends AnyVal
+       *  class Reflective extends reflect.Selectable
+       *  val reflective = new Reflective {
+       *    def foo = Foo(1) // Foo at compile time, java.lang.Integer in reflection
+       *  }
+       * 
+       *  Because of that reflective access cannot be implemented properly in `scala.reflect.SelectDynamic` itself
+       *  because it's not known there if the value should be wrapped in a value class constructor call or not.
+       *  Hence the logic of wrapping is performed here, relying on the fact that the implementations of `selectDynamic` and `applyDynamic` in `scala.reflect.SelectDynamic` are final.
+       */
+      def maybeBoxingCast(tpe: Type) =
+        val maybeBoxed = 
+          if ValueClasses.isDerivedValueClass(tpe.classSymbol) && qual.tpe <:< defn.ReflectSelectableTypeRef then
+            val genericUnderlying = ValueClasses.valueClassUnbox(tpe.classSymbol.asClass)
+            val underlying = tpe.select(genericUnderlying).widen.resultType
+            New(tpe, tree.cast(underlying) :: Nil)
+          else
+            tree
+        maybeBoxed.cast(tpe)
 
+    fun.tpe.widen match {
       case tpe: ValueType =>
-        structuralCall(nme.selectDynamic, Nil).cast(tpe)
+        structuralCall(nme.selectDynamic, Nil).maybeBoxingCast(tpe)
 
       case tpe: MethodType =>
         def isDependentMethod(tpe: Type): Boolean = tpe match {
@@ -244,11 +262,7 @@ trait Dynamic {
               fail(i"has a parameter type with an unstable erasure") :: Nil
             else
               TypeErasure.erasure(tpe).asInstanceOf[MethodType].paramInfos.map(clsOf(_))
-          val finalTpe = tpe.finalResultType
-          if ValueClasses.isDerivedValueClass(finalTpe.classSymbol) then
-            New(finalTpe, structuralCall(nme.applyDynamic, classOfs).cast(finalTpe)
-              .cast(ValueClasses.valueClassUnbox(finalTpe.classSymbol.asClass).info.resultType.asSeenFrom(finalTpe, finalTpe.classSymbol)) :: Nil)
-          else structuralCall(nme.applyDynamic, classOfs).cast(finalTpe)
+          structuralCall(nme.applyDynamic, classOfs).maybeBoxingCast(tpe.finalResultType)
         }
 
       // (@allanrenucci) I think everything below is dead code
diff --git a/tests/run/i14340.check b/tests/run/i14340.check
index db372c9502e9..e96afd98e6e9 100644
--- a/tests/run/i14340.check
+++ b/tests/run/i14340.check
@@ -1,4 +1,10 @@
 1
+1
+2
 2
-3
-qux
\ No newline at end of file
+10
+10
+20
+20
+100
+100
\ No newline at end of file
diff --git a/tests/run/i14340.scala b/tests/run/i14340.scala
index e9d8733ccfa5..0670c7e471ac 100644
--- a/tests/run/i14340.scala
+++ b/tests/run/i14340.scala
@@ -1,20 +1,57 @@
+class Container1 extends reflect.Selectable
+
+class Container2(values: Map[String, Any], methods: Map[String, Int => Any]) extends Selectable:
+  def selectDynamic(name: String) = values(name)
+  def applyDynamic(name: String)(arg: Int) = methods(name)(arg)
+
 class Foo(val value: Int) extends AnyVal
 class Bar[A](val value: A) extends AnyVal
 
-class Container1 extends reflect.Selectable
+object Helpers:
+  def foo = Foo(1)
+  def bar = Bar(Foo(2))
+  def qux1 = Bar(new Container1 { def foo = Foo(10) })
+  def qux2 = Bar(new Container2(Map("foo" -> Foo(20)), Map.empty).asInstanceOf[Container2 { def foo: Foo }])
+
+@main def Test: Unit =
+  val cont1 = new Container1:
+    def foo = Helpers.foo
+    val bar = Helpers.bar
+    def qux1 = Helpers.qux1
+    def qux2 = Helpers.qux2
+    def fooFromInt(i: Int) = Foo(i)
 
-class Container2 extends Selectable:
-  def selectDynamic(name: String) = Bar(name)
+  val cont2values = Map(
+    "foo" -> Helpers.foo,
+    "bar" -> Helpers.bar,
+    "qux1" -> Helpers.qux1,
+    "qux2" -> Helpers.qux2
+  )
 
-val cont1 = new Container1:
-  def foo = new Foo(1)
-  val bar = new Bar(Foo(2))
-  def fooFromInt(i: Int) = new Foo(i)
+  val cont2methods = Map(
+    "fooFromInt" -> { (i: Int) => Foo(i) }
+  )
 
-val cont2 = (new Container2).asInstanceOf[Container2 { def qux: Bar[String] }]
+  val cont2 = Container2(cont2values, cont2methods).asInstanceOf[Container2 {
+    def foo: Foo
+    def bar: Bar[Foo]
+    def qux1: Bar[Container1 { def foo: Foo }]
+    def qux2: Bar[Container2 { def foo: Foo }]
+    def fooFromInt(i: Int): Foo
+  }]
+  
 
-@main def Test: Unit =
   println(cont1.foo.value)
+  println(cont2.foo.value)
+
   println(cont1.bar.value.value)
-  println(cont1.fooFromInt(3).value)
-  println(cont2.qux.value)
\ No newline at end of file
+  println(cont2.bar.value.value)
+
+  println(cont1.qux1.value.foo.value)
+  println(cont2.qux1.value.foo.value)
+  
+  println(cont1.qux2.value.foo.value)
+  println(cont2.qux2.value.foo.value)
+
+  println(cont1.fooFromInt(100).value)
+  println(cont2.fooFromInt(100).value)

From 7622bb154dc2c79290fb00f6dec1aa6425184253 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 20 Feb 2023 11:47:33 +0100
Subject: [PATCH 194/657] Add way to debug -Xcheck-macros tree checking

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

diff --git a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
index 2daac7cdd604..133651fe08b2 100644
--- a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
@@ -729,6 +729,11 @@ object TreeChecker {
       try treeChecker.typed(expansion)(using checkingCtx)
       catch
         case err: java.lang.AssertionError =>
+          val stack =
+            if !ctx.settings.Ydebug.value then "\nstacktrace available when compiling with `-Ydebug`"
+            else if err.getStackTrace == null then "  no stacktrace"
+            else err.getStackTrace.nn.mkString("  ", "  \n", "")
+
           report.error(
             s"""Malformed tree was found while expanding macro with -Xcheck-macros.
                |The tree does not conform to the compiler's tree invariants.
@@ -741,7 +746,7 @@ object TreeChecker {
                |
                |Error:
                |${err.getMessage}
-               |
+               |$stack
                |""",
             original
           )

From 7f0fe63d5488b6b95fe304e0a6cb2c9455d4f425 Mon Sep 17 00:00:00 2001
From: Guillaume Martres <smarter@ubuntu.com>
Date: Wed, 22 Feb 2023 17:52:13 +0100
Subject: [PATCH 195/657] Fix under-compilation when the method type in a SAM
 changes

A lambda that implements a SAM type desugars (either at compile-time or runtime
via invokedynamic) into a class that extends the SAM type, therefore we need to
register an inheritance relationship to get the proper invalidation logic.

Fixes sbt/zinc#830.
---
 .../src/dotty/tools/dotc/sbt/ExtractDependencies.scala   | 9 +++++++++
 sbt-test/source-dependencies/sam/A.scala                 | 3 +++
 sbt-test/source-dependencies/sam/B.scala                 | 2 ++
 sbt-test/source-dependencies/sam/build.sbt               | 1 +
 sbt-test/source-dependencies/sam/changes/A.scala         | 3 +++
 sbt-test/source-dependencies/sam/test                    | 7 +++++++
 6 files changed, 25 insertions(+)
 create mode 100644 sbt-test/source-dependencies/sam/A.scala
 create mode 100644 sbt-test/source-dependencies/sam/B.scala
 create mode 100644 sbt-test/source-dependencies/sam/build.sbt
 create mode 100644 sbt-test/source-dependencies/sam/changes/A.scala
 create mode 100644 sbt-test/source-dependencies/sam/test

diff --git a/compiler/src/dotty/tools/dotc/sbt/ExtractDependencies.scala b/compiler/src/dotty/tools/dotc/sbt/ExtractDependencies.scala
index 3fb7a66dc89e..fe5c8d061c78 100644
--- a/compiler/src/dotty/tools/dotc/sbt/ExtractDependencies.scala
+++ b/compiler/src/dotty/tools/dotc/sbt/ExtractDependencies.scala
@@ -306,6 +306,13 @@ private class ExtractDependenciesCollector extends tpd.TreeTraverser { thisTreeT
       }
     }
 
+  private def addInheritanceDependencies(tree: Closure)(using Context): Unit =
+    // If the tpt is empty, this is a non-SAM lambda, so no need to register
+    // an inheritance relationship.
+    if !tree.tpt.isEmpty then
+      val from = resolveDependencySource
+      _dependencies += ClassDependency(from, tree.tpt.tpe.classSymbol, LocalDependencyByInheritance)
+
   private def addInheritanceDependencies(tree: Template)(using Context): Unit =
     if (tree.parents.nonEmpty) {
       val depContext = depContextOf(tree.symbol.owner)
@@ -369,6 +376,8 @@ private class ExtractDependenciesCollector extends tpd.TreeTraverser { thisTreeT
       case ref: RefTree =>
         addMemberRefDependency(ref.symbol)
         addTypeDependency(ref.tpe)
+      case t: Closure =>
+        addInheritanceDependencies(t)
       case t: Template =>
         addInheritanceDependencies(t)
       case _ =>
diff --git a/sbt-test/source-dependencies/sam/A.scala b/sbt-test/source-dependencies/sam/A.scala
new file mode 100644
index 000000000000..eb870b8332b6
--- /dev/null
+++ b/sbt-test/source-dependencies/sam/A.scala
@@ -0,0 +1,3 @@
+trait A {
+  def foo(): Int
+}
diff --git a/sbt-test/source-dependencies/sam/B.scala b/sbt-test/source-dependencies/sam/B.scala
new file mode 100644
index 000000000000..87dfb28cdb33
--- /dev/null
+++ b/sbt-test/source-dependencies/sam/B.scala
@@ -0,0 +1,2 @@
+class B:
+  val f: A = () => 1
diff --git a/sbt-test/source-dependencies/sam/build.sbt b/sbt-test/source-dependencies/sam/build.sbt
new file mode 100644
index 000000000000..63e314982c41
--- /dev/null
+++ b/sbt-test/source-dependencies/sam/build.sbt
@@ -0,0 +1 @@
+scalaVersion := sys.props("plugin.scalaVersion")
diff --git a/sbt-test/source-dependencies/sam/changes/A.scala b/sbt-test/source-dependencies/sam/changes/A.scala
new file mode 100644
index 000000000000..e9b339f2d1a4
--- /dev/null
+++ b/sbt-test/source-dependencies/sam/changes/A.scala
@@ -0,0 +1,3 @@
+trait A {
+  def foo(): String
+}
diff --git a/sbt-test/source-dependencies/sam/test b/sbt-test/source-dependencies/sam/test
new file mode 100644
index 000000000000..3c4c9a0f001b
--- /dev/null
+++ b/sbt-test/source-dependencies/sam/test
@@ -0,0 +1,7 @@
+> compile
+
+# change the SAM type
+$ copy-file changes/A.scala A.scala
+
+# Both A.scala and B.scala should be recompiled, producing a compile error
+-> compile

From b889dbf6de279551141b34df3a78a305588db695 Mon Sep 17 00:00:00 2001
From: Seth Tisue <seth@tisue.net>
Date: Thu, 23 Feb 2023 07:53:43 -0800
Subject: [PATCH 196/657] add regression test for pattern match on
 path-dependent type

this was fixed recently (by #16827), but the test case is simpler
than the one in the PR. minimized from user code on the Typelevel
Discord
---
 tests/pos/t16827.scala | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 tests/pos/t16827.scala

diff --git a/tests/pos/t16827.scala b/tests/pos/t16827.scala
new file mode 100644
index 000000000000..17122fd9b580
--- /dev/null
+++ b/tests/pos/t16827.scala
@@ -0,0 +1,9 @@
+// scalac: -Werror
+
+trait Outer[F[_]]:
+  sealed trait Inner
+  trait Inner1 extends Inner
+  def foo(rv: Either[Inner, Int]) =
+    rv match
+      case Right(_) =>
+      case Left(_) =>

From 92118c4201b96653f25d06f031a221a8a8e48559 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Tue, 21 Feb 2023 19:05:06 +0000
Subject: [PATCH 197/657] Avoid in ConstantTypes

---
 compiler/src/dotty/tools/dotc/core/Types.scala |  6 ++++++
 .../dotty/tools/dotc/printing/Formatting.scala | 10 ++++++++++
 tests/pos/i16954.scala                         | 18 ++++++++++++++++++
 3 files changed, 34 insertions(+)
 create mode 100644 tests/pos/i16954.scala

diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index d005cabebcfb..f53763cdf0bf 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -5736,6 +5736,12 @@ object Types {
         case tp @ SuperType(thistp, supertp) =>
           derivedSuperType(tp, this(thistp), this(supertp))
 
+        case tp @ ConstantType(const @ Constant(_: Type)) =>
+          val classType = const.tpe
+          val classType1 = this(classType)
+          if classType eq classType1 then tp
+          else classType1
+
         case tp: LazyRef =>
           LazyRef { refCtx =>
             given Context = refCtx
diff --git a/compiler/src/dotty/tools/dotc/printing/Formatting.scala b/compiler/src/dotty/tools/dotc/printing/Formatting.scala
index 0acfd06de433..3f32b29654c9 100644
--- a/compiler/src/dotty/tools/dotc/printing/Formatting.scala
+++ b/compiler/src/dotty/tools/dotc/printing/Formatting.scala
@@ -71,6 +71,16 @@ object Formatting {
       given Show[TypeComparer.ApproxState] with
         def show(x: TypeComparer.ApproxState) = TypeComparer.ApproxState.Repr.show(x)
 
+      given Show[ast.TreeInfo.PurityLevel] with
+        def show(x: ast.TreeInfo.PurityLevel) = x match
+          case ast.TreeInfo.Path           => "PurityLevel.Path"
+          case ast.TreeInfo.Pure           => "PurityLevel.Pure"
+          case ast.TreeInfo.Idempotent     => "PurityLevel.Idempotent"
+          case ast.TreeInfo.Impure         => "PurityLevel.Impure"
+          case ast.TreeInfo.PurePath       => "PurityLevel.PurePath"
+          case ast.TreeInfo.IdempotentPath => "PurityLevel.IdempotentPath"
+          case _                           => s"PurityLevel(${x.x})"
+
       given Show[Showable]                            = ShowAny
       given Show[Shown]                               = ShowAny
       given Show[Int]                                 = ShowAny
diff --git a/tests/pos/i16954.scala b/tests/pos/i16954.scala
new file mode 100644
index 000000000000..ce7418e5e5e2
--- /dev/null
+++ b/tests/pos/i16954.scala
@@ -0,0 +1,18 @@
+class Test:
+  def test =
+    classOf[Test]
+
+  def blck =
+    class Blck
+    val cls = classOf[Blck]
+    cls
+
+  def expr =
+    class Expr
+    classOf[Expr] // was: "assertion failed: leak: Expr in { [..] }" crash
+
+object Test extends Test:
+  def main(args: Array[String]): Unit =
+    assert(test.getName == "Test",        test.getName)
+    assert(blck.getName == "Test$Blck$1", blck.getName)
+    assert(expr.getName == "Test$Expr$1", expr.getName)

From b75a4e9ec2f3f926d226684423bca6d816ed10e8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Marks?= <pmarks@virtuslab.com>
Date: Mon, 27 Feb 2023 12:05:40 +0100
Subject: [PATCH 198/657] Set reference version to 3.3.0-RC3

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

diff --git a/project/Build.scala b/project/Build.scala
index 097876a63f92..82b7fee64879 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -80,7 +80,7 @@ object DottyJSPlugin extends AutoPlugin {
 object Build {
   import ScaladocConfigs._
 
-  val referenceVersion = "3.3.0-RC2"
+  val referenceVersion = "3.3.0-RC3"
 
   val baseVersion = "3.3.1-RC1"
 

From 6f75016212a9bed2e85a834c59fd23ba45a602b1 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Mon, 27 Feb 2023 12:11:24 +0100
Subject: [PATCH 199/657] Disable test for Scalajs

---
 tests/run/i16806.scala | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/run/i16806.scala b/tests/run/i16806.scala
index 0b0dfe1f6b35..16c0fb0d3ef5 100644
--- a/tests/run/i16806.scala
+++ b/tests/run/i16806.scala
@@ -1,3 +1,4 @@
+//scalajs: --skip
 import java.util.concurrent.Semaphore
 
 object Repro {

From a43787af3eba1d155f1b107972658daedf6e68d8 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Mon, 27 Feb 2023 12:40:41 +0100
Subject: [PATCH 200/657] Add comment describing why LazyValControlState
 extends Serializable

---
 library/src/scala/runtime/LazyVals.scala | 1 +
 1 file changed, 1 insertion(+)

diff --git a/library/src/scala/runtime/LazyVals.scala b/library/src/scala/runtime/LazyVals.scala
index 416ffc91d34a..d8c89c7abf28 100644
--- a/library/src/scala/runtime/LazyVals.scala
+++ b/library/src/scala/runtime/LazyVals.scala
@@ -45,6 +45,7 @@ object LazyVals {
 
   /* ------------- Start of public API ------------- */
 
+  // This trait extends Serializable to fix #16806 that caused a race condition
   sealed trait LazyValControlState extends Serializable
 
   /**

From 02ee89b695242d513c428ec269a0c9156862f44f Mon Sep 17 00:00:00 2001
From: Lucas <leblanc.lucas29@gmail.com>
Date: Mon, 27 Feb 2023 14:51:57 +0100
Subject: [PATCH 201/657] Add padding and width to the mobile menu #16834

---
 scaladoc/resources/dotty_res/styles/theme/layout/header.css     | 1 +
 scaladoc/resources/dotty_res/styles/theme/layout/mobileMenu.css | 2 ++
 2 files changed, 3 insertions(+)

diff --git a/scaladoc/resources/dotty_res/styles/theme/layout/header.css b/scaladoc/resources/dotty_res/styles/theme/layout/header.css
index 034f9ed43087..2e33023d0701 100644
--- a/scaladoc/resources/dotty_res/styles/theme/layout/header.css
+++ b/scaladoc/resources/dotty_res/styles/theme/layout/header.css
@@ -89,6 +89,7 @@
   #mobile-menu-toggle {
     margin-left: calc(3 * var(--base-spacing));
     display: block;
+    padding: 16px;
   }
 
   .header-container-right .text-button {
diff --git a/scaladoc/resources/dotty_res/styles/theme/layout/mobileMenu.css b/scaladoc/resources/dotty_res/styles/theme/layout/mobileMenu.css
index a7c08eedb4be..6fa692ab4662 100644
--- a/scaladoc/resources/dotty_res/styles/theme/layout/mobileMenu.css
+++ b/scaladoc/resources/dotty_res/styles/theme/layout/mobileMenu.css
@@ -154,6 +154,8 @@
 
 #mobile-menu-close {
   margin-left: auto;
+  width: 48px;
+  height: 48px;
 }
 
 #mobile-menu-close:disabled {

From 1f51d1cd32a92cd16669a8b75b12d25a0236489d Mon Sep 17 00:00:00 2001
From: Lucas <leblanc.lucas29@gmail.com>
Date: Mon, 27 Feb 2023 15:04:59 +0100
Subject: [PATCH 202/657] Reduction of the padding top in mobile version #16833

---
 scaladoc/resources/dotty_res/styles/theme/layout/content.css | 1 +
 1 file changed, 1 insertion(+)

diff --git a/scaladoc/resources/dotty_res/styles/theme/layout/content.css b/scaladoc/resources/dotty_res/styles/theme/layout/content.css
index e09aa2697762..1c1554c8a75d 100644
--- a/scaladoc/resources/dotty_res/styles/theme/layout/content.css
+++ b/scaladoc/resources/dotty_res/styles/theme/layout/content.css
@@ -91,6 +91,7 @@
 @media (max-width: 768px) {
 
   #content {
+    padding-top: calc(5 * var(--base-spacing));
     padding-bottom: calc(6 * var(--base-spacing));
   }
 

From 0d663477f0f08afadf4fa427c018b2354ac16f04 Mon Sep 17 00:00:00 2001
From: Lucas <leblanc.lucas29@gmail.com>
Date: Mon, 27 Feb 2023 15:49:25 +0100
Subject: [PATCH 203/657] Correction of the value

---
 scaladoc/resources/dotty_res/styles/theme/layout/content.css | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scaladoc/resources/dotty_res/styles/theme/layout/content.css b/scaladoc/resources/dotty_res/styles/theme/layout/content.css
index 1c1554c8a75d..e46e66cba9e5 100644
--- a/scaladoc/resources/dotty_res/styles/theme/layout/content.css
+++ b/scaladoc/resources/dotty_res/styles/theme/layout/content.css
@@ -91,7 +91,7 @@
 @media (max-width: 768px) {
 
   #content {
-    padding-top: calc(5 * var(--base-spacing));
+    padding-top: calc(10 * var(--base-spacing));
     padding-bottom: calc(6 * var(--base-spacing));
   }
 

From 67df3e5efeea2e592a85dd62b94041061b32020e Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Mon, 27 Feb 2023 16:03:10 +0100
Subject: [PATCH 204/657] WUnused: Fix unused warnining in synthetic symbols

---
 compiler/src/dotty/tools/dotc/transform/CheckUnused.scala | 8 ++++++--
 tests/neg-custom-args/fatal-warnings/i16925.scala         | 8 ++++++++
 tests/neg-custom-args/fatal-warnings/i16926.scala         | 7 +++++++
 3 files changed, 21 insertions(+), 2 deletions(-)
 create mode 100644 tests/neg-custom-args/fatal-warnings/i16925.scala
 create mode 100644 tests/neg-custom-args/fatal-warnings/i16926.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index 49ce64b00b88..9f3f5aded50c 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -7,13 +7,13 @@ import dotty.tools.dotc.ast.untpd.ImportSelector
 import dotty.tools.dotc.config.ScalaSettings
 import dotty.tools.dotc.core.Contexts.*
 import dotty.tools.dotc.core.Decorators.{em, i}
-import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.Flags.*
 import dotty.tools.dotc.core.Phases.Phase
 import dotty.tools.dotc.core.StdNames
 import dotty.tools.dotc.report
 import dotty.tools.dotc.reporting.Message
 import dotty.tools.dotc.typer.ImportInfo
-import dotty.tools.dotc.util.Property
+import dotty.tools.dotc.util.{Property, SourcePosition, SrcPos}
 import dotty.tools.dotc.core.Mode
 import dotty.tools.dotc.core.Types.TypeTraverser
 import dotty.tools.dotc.core.Types.Type
@@ -302,6 +302,7 @@ object CheckUnused:
      * See the `isAccessibleAsIdent` extension method below in the file
      */
     private val usedInScope = MutStack(MutSet[(Symbol,Boolean, Option[Name])]())
+    private val usedInPosition = MutSet[(SrcPos, Name)]()
     /* unused import collected during traversal */
     private val unusedImport = MutSet[ImportSelector]()
 
@@ -351,6 +352,7 @@ object CheckUnused:
           usedInScope.top += ((sym, sym.isAccessibleAsIdent, name))
           usedInScope.top += ((sym.companionModule, sym.isAccessibleAsIdent, name))
           usedInScope.top += ((sym.companionClass, sym.isAccessibleAsIdent, name))
+          name.map(n => usedInPosition += ((sym.sourcePos, n)))
 
     /** Register a symbol that should be ignored */
     def addIgnoredUsage(sym: Symbol)(using Context): Unit =
@@ -455,6 +457,7 @@ object CheckUnused:
         if ctx.settings.WunusedHas.locals then
           localDefInScope
             .filterNot(d => d.symbol.usedDefContains)
+            .filterNot(d => usedInPosition.exists { case (pos, name) => d.span.contains(pos.span) && name == d.symbol.name})
             .map(d => d.namePos -> WarnTypes.LocalDefs).toList
         else
           Nil
@@ -483,6 +486,7 @@ object CheckUnused:
         if ctx.settings.WunusedHas.patvars then
           patVarsInScope
             .filterNot(d => d.symbol.usedDefContains)
+            .filterNot(d => usedInPosition.exists { case (pos, name) => d.span.contains(pos.span) && name == d.symbol.name})
             .map(d => d.namePos -> WarnTypes.PatVars).toList
         else
           Nil
diff --git a/tests/neg-custom-args/fatal-warnings/i16925.scala b/tests/neg-custom-args/fatal-warnings/i16925.scala
new file mode 100644
index 000000000000..5cc94f53cdd4
--- /dev/null
+++ b/tests/neg-custom-args/fatal-warnings/i16925.scala
@@ -0,0 +1,8 @@
+// scalac: -Wunused:all
+
+def hello =
+  for {
+    i <- 1 to 2 if true
+    _ = println(i) // OK
+  } yield ()
+
diff --git a/tests/neg-custom-args/fatal-warnings/i16926.scala b/tests/neg-custom-args/fatal-warnings/i16926.scala
new file mode 100644
index 000000000000..23f167f4ce30
--- /dev/null
+++ b/tests/neg-custom-args/fatal-warnings/i16926.scala
@@ -0,0 +1,7 @@
+// scalac: -Wunused:all
+
+def hello(): Unit =
+  for {
+    i <- (0 to 10).toList
+    (a, b) = "hello" -> "world" // OK
+  } yield println(s"$a $b")

From 9886ef36c93bb4cbfffb119bcf75d93d2cfb0b48 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Tue, 28 Feb 2023 12:55:33 +0100
Subject: [PATCH 205/657] Move tests

---
 tests/neg-custom-args/fatal-warnings/i15503i.scala | 14 ++++++++++++++
 tests/neg-custom-args/fatal-warnings/i16925.scala  |  8 --------
 tests/neg-custom-args/fatal-warnings/i16926.scala  |  7 -------
 3 files changed, 14 insertions(+), 15 deletions(-)
 delete mode 100644 tests/neg-custom-args/fatal-warnings/i16925.scala
 delete mode 100644 tests/neg-custom-args/fatal-warnings/i16926.scala

diff --git a/tests/neg-custom-args/fatal-warnings/i15503i.scala b/tests/neg-custom-args/fatal-warnings/i15503i.scala
index 82fb9acf7ace..ab83e1dafb3b 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503i.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503i.scala
@@ -194,3 +194,17 @@ package foo.test.i16877:
 
   @ExampleAnnotation(new HashMap()) // OK
   class Test //OK
+
+package foo.test.i16926:
+  def hello(): Unit =
+    for {
+      i <- (0 to 10).toList
+      (a, b) = "hello" -> "world" // OK
+    } yield println(s"$a $b")
+
+package foo.test.i16925:
+  def hello =
+    for {
+      i <- 1 to 2 if true
+      _ = println(i) // OK
+    } yield ()
\ No newline at end of file
diff --git a/tests/neg-custom-args/fatal-warnings/i16925.scala b/tests/neg-custom-args/fatal-warnings/i16925.scala
deleted file mode 100644
index 5cc94f53cdd4..000000000000
--- a/tests/neg-custom-args/fatal-warnings/i16925.scala
+++ /dev/null
@@ -1,8 +0,0 @@
-// scalac: -Wunused:all
-
-def hello =
-  for {
-    i <- 1 to 2 if true
-    _ = println(i) // OK
-  } yield ()
-
diff --git a/tests/neg-custom-args/fatal-warnings/i16926.scala b/tests/neg-custom-args/fatal-warnings/i16926.scala
deleted file mode 100644
index 23f167f4ce30..000000000000
--- a/tests/neg-custom-args/fatal-warnings/i16926.scala
+++ /dev/null
@@ -1,7 +0,0 @@
-// scalac: -Wunused:all
-
-def hello(): Unit =
-  for {
-    i <- (0 to 10).toList
-    (a, b) = "hello" -> "world" // OK
-  } yield println(s"$a $b")

From 6b36cd97bf276b57c392cf63e281f283345610cc Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Fri, 17 Feb 2023 11:46:53 +0000
Subject: [PATCH 206/657] Make unchecked cases non-`@unchecked` and
 non-unreachable

---
 .../src/dotty/tools/dotc/core/TypeOps.scala   |  8 ++-
 .../tools/dotc/transform/ExpandSAMs.scala     | 16 +++--
 .../tools/dotc/transform/patmat/Space.scala   | 59 +++++++++----------
 .../src/dotty/tools/dotc/typer/Typer.scala    |  4 +-
 .../fatal-warnings/i15662.scala               |  1 -
 .../suppressed-type-test-warnings.scala       |  2 -
 .../isInstanceOf/enum-approx2.scala           |  4 +-
 .../neg-custom-args/isInstanceOf/i11178.scala |  3 +-
 .../neg-custom-args/isInstanceOf/i8932.scala  |  3 +-
 tests/neg/i16451.check                        | 24 ++++++++
 tests/neg/i16451.scala                        | 44 ++++++++++++++
 tests/pos/i16451.CanForward.scala             | 34 +++++++++++
 tests/pos/i16451.DiffUtil.scala               | 15 +++++
 tests/pos/i16451.default.scala                | 22 +++++++
 tests/run-macros/i7898.check                  |  2 +-
 15 files changed, 187 insertions(+), 54 deletions(-)
 create mode 100644 tests/neg/i16451.check
 create mode 100644 tests/neg/i16451.scala
 create mode 100644 tests/pos/i16451.CanForward.scala
 create mode 100644 tests/pos/i16451.DiffUtil.scala
 create mode 100644 tests/pos/i16451.default.scala

diff --git a/compiler/src/dotty/tools/dotc/core/TypeOps.scala b/compiler/src/dotty/tools/dotc/core/TypeOps.scala
index c91412988e82..6809e4b9083c 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeOps.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeOps.scala
@@ -765,7 +765,7 @@ object TypeOps:
    *
    *  Otherwise, return NoType.
    */
-  private def instantiateToSubType(tp1: NamedType, tp2: Type, mixins: List[Type])(using Context): Type = {
+  private def instantiateToSubType(tp1: NamedType, tp2: Type, mixins: List[Type])(using Context): Type = trace(i"instantiateToSubType($tp1, $tp2, $mixins)", typr) {
     // 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.
     //
@@ -854,6 +854,12 @@ object TypeOps:
           case tp: TypeRef if tp.symbol.isAbstractOrParamType =>
             gadtSyms += tp.symbol
             traverseChildren(tp)
+            val owners = Iterator.iterate(tp.symbol)(_.maybeOwner).takeWhile(_.exists)
+            for sym <- owners do
+              // add ThisType's for the classes symbols in the ownership of `tp`
+              // for example, i16451.CanForward.scala, add `Namer.this`, as one of the owners of the type parameter `A1`
+              if sym.isClass && !sym.isAnonymousClass && !sym.isStaticOwner then
+                traverse(sym.thisType)
           case _ =>
             traverseChildren(tp)
       }
diff --git a/compiler/src/dotty/tools/dotc/transform/ExpandSAMs.scala b/compiler/src/dotty/tools/dotc/transform/ExpandSAMs.scala
index 0552fe31f8a2..0bfc444e0997 100644
--- a/compiler/src/dotty/tools/dotc/transform/ExpandSAMs.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ExpandSAMs.scala
@@ -145,15 +145,13 @@ class ExpandSAMs extends MiniPhase:
 
       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)
+        val cases1 = if cases.exists(isDefaultCase) then cases
+        else
+          val selectorTpe = selector.tpe.widen
+          val defaultSym = newSymbol(pfParam.owner, nme.WILDCARD, SyntheticCase, selectorTpe)
+          val defaultCase = CaseDef(Bind(defaultSym, Underscore(selectorTpe)), EmptyTree, defaultValue)
+          cases :+ defaultCase
+        cpy.Match(tree)(selector, cases1)
           .subst(param.symbol :: Nil, pfParam :: Nil)
             // Needed because  a partial function can be written as:
             // param => param match { case "foo" if foo(param) => param }
diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index d69371520413..3e05310d7249 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -9,7 +9,7 @@ import TypeUtils._
 import Contexts._
 import Flags._
 import ast._
-import Decorators._
+import Decorators.{ show => _, * }
 import Symbols._
 import StdNames._
 import NameOps._
@@ -26,6 +26,8 @@ import util.{SrcPos, NoSourcePosition}
 import scala.annotation.internal.sharable
 import scala.collection.mutable
 
+import SpaceEngine.*
+
 /* 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
@@ -57,7 +59,6 @@ import scala.collection.mutable
 
 /** space definition */
 sealed trait Space:
-  import SpaceEngine.*
 
   @sharable private val isSubspaceCache = mutable.HashMap.empty[Space, Boolean]
 
@@ -95,14 +96,14 @@ case object Empty extends Space
 case class Typ(tp: Type, decomposed: Boolean = true) extends Space:
   private var myDecompose: List[Typ] | Null = null
 
-  def canDecompose(using Context): Boolean = decompose != SpaceEngine.ListOfTypNoType
+  def canDecompose(using Context): Boolean = decompose != ListOfTypNoType
 
   def decompose(using Context): List[Typ] =
     val decompose = myDecompose
     if decompose == null then
       val decompose = tp match
-        case SpaceEngine.Parts(parts) => parts.map(Typ(_, decomposed = true))
-        case _                        => SpaceEngine.ListOfTypNoType
+        case Parts(parts) => parts.map(Typ(_, decomposed = true))
+        case _            => ListOfTypNoType
       myDecompose = decompose
       decompose
     else decompose
@@ -346,7 +347,7 @@ object SpaceEngine {
   }
 
   /** Return the space that represents the pattern `pat` */
-  def project(pat: Tree)(using Context): Space = pat match {
+  def project(pat: Tree)(using Context): Space = trace(i"project($pat ${pat.className} ${pat.tpe})", debug, show)(pat match {
     case Literal(c) =>
       if (c.value.isInstanceOf[Symbol])
         Typ(c.value.asInstanceOf[Symbol].termRef, decomposed = false)
@@ -407,7 +408,7 @@ object SpaceEngine {
     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)(using Context): Space = tp match {
     case OrType(tp1, tp2) => Or(project(tp1) :: project(tp2) :: Nil)
@@ -461,16 +462,23 @@ object SpaceEngine {
    *  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)(using Context): Type = trace(i"$tp erased to", debug) {
-
-    tp match {
+  private def erase(tp: Type, inArray: Boolean = false, isValue: Boolean = false)(using Context): Type =
+    trace(i"erase($tp${if inArray then " inArray" else ""}${if isValue then " isValue" else ""})", debug)(tp match {
       case tp @ AppliedType(tycon, args) if tycon.typeSymbol.isPatternBound =>
         WildcardType
 
       case tp @ AppliedType(tycon, args) =>
         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))
+          if tycon.isRef(defn.ArrayClass) then
+            args.map(arg => erase(arg, inArray = true, isValue = false))
+          else tycon.typeParams.lazyZip(args).map { (tparam, arg) =>
+            if isValue && tparam.paramVarianceSign == 0 then
+              // when matching against a value,
+              // any type argument for an invariant type parameter will be unchecked,
+              // meaning it won't fail to match against anything; thus the wildcard replacement
+              WildcardType
+            else erase(arg, inArray = false, isValue = false)
+          }
         tp.derivedAppliedType(erase(tycon, inArray, isValue = false), args2)
 
       case tp @ OrType(tp1, tp2) =>
@@ -488,8 +496,7 @@ object SpaceEngine {
         else WildcardType
 
       case _ => tp
-    }
-  }
+    })
 
   /** Space of the pattern: unapplySeq(a, b, c: _*)
    */
@@ -873,16 +880,11 @@ object SpaceEngine {
     case _                                          => tp
   })
 
-  def checkExhaustivity(_match: Match)(using Context): Unit = {
-    val Match(sel, cases) = _match
-    debug.println(i"checking exhaustivity of ${_match}")
-
-    if (!exhaustivityCheckable(sel)) return
-
-    val selTyp = toUnderlying(sel.tpe).dealias
+  def checkExhaustivity(m: Match)(using Context): Unit = if exhaustivityCheckable(m.selector) then trace(i"checkExhaustivity($m)", debug) {
+    val selTyp = toUnderlying(m.selector.tpe).dealias
     debug.println(i"selTyp = $selTyp")
 
-    val patternSpace = Or(cases.foldLeft(List.empty[Space]) { (acc, x) =>
+    val patternSpace = Or(m.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
@@ -899,7 +901,7 @@ object SpaceEngine {
     if uncovered.nonEmpty then
       val hasMore = uncovered.lengthCompare(6) > 0
       val deduped = dedup(uncovered.take(6))
-      report.warning(PatternMatchExhaustivity(showSpaces(deduped), hasMore), sel.srcPos)
+      report.warning(PatternMatchExhaustivity(showSpaces(deduped), hasMore), m.selector)
   }
 
   private def redundancyCheckable(sel: Tree)(using Context): Boolean =
@@ -912,14 +914,10 @@ object SpaceEngine {
     && !sel.tpe.widen.isRef(defn.QuotedExprClass)
     && !sel.tpe.widen.isRef(defn.QuotedTypeClass)
 
-  def checkRedundancy(_match: Match)(using Context): Unit = {
-    val Match(sel, _) = _match
-    val cases = _match.cases.toIndexedSeq
-    debug.println(i"checking redundancy in $_match")
-
-    if (!redundancyCheckable(sel)) return
+  def checkRedundancy(m: Match)(using Context): Unit = if redundancyCheckable(m.selector) then trace(i"checkRedundancy($m)", debug) {
+    val cases = m.cases.toIndexedSeq
 
-    val selTyp = toUnderlying(sel.tpe).dealias
+    val selTyp = toUnderlying(m.selector.tpe).dealias
     debug.println(i"selTyp = $selTyp")
 
     val isNullable = selTyp.classSymbol.isNullableClass
@@ -953,6 +951,7 @@ object SpaceEngine {
         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, prev)
         then {
           val nullOnly = isNullable && i == len - 1 && isWildcardArg(pat)
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 9d8fdcc006c9..b39116f971f8 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -1618,9 +1618,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         }
         else {
           val (protoFormals, _) = decomposeProtoFunction(pt, 1, tree.srcPos)
-          val checkMode =
-            if (pt.isRef(defn.PartialFunctionClass)) desugar.MatchCheck.None
-            else desugar.MatchCheck.Exhaustive
+          val checkMode = desugar.MatchCheck.Exhaustive
           typed(desugar.makeCaseLambda(tree.cases, checkMode, protoFormals.length).withSpan(tree.span), pt)
         }
       case _ =>
diff --git a/tests/neg-custom-args/fatal-warnings/i15662.scala b/tests/neg-custom-args/fatal-warnings/i15662.scala
index 1d5ff21eb3ba..afe505922603 100644
--- a/tests/neg-custom-args/fatal-warnings/i15662.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15662.scala
@@ -3,7 +3,6 @@ case class Composite[T](v: T)
 def m(composite: Composite[_]): Unit =
   composite match {
     case Composite[Int](v) => println(v)  // error: cannot be checked at runtime
-    case _ => println("OTHER")
   }
 
 def m2(composite: Composite[_]): Unit =
diff --git a/tests/neg-custom-args/fatal-warnings/suppressed-type-test-warnings.scala b/tests/neg-custom-args/fatal-warnings/suppressed-type-test-warnings.scala
index 92d86b3307e5..175096fc6b21 100644
--- a/tests/neg-custom-args/fatal-warnings/suppressed-type-test-warnings.scala
+++ b/tests/neg-custom-args/fatal-warnings/suppressed-type-test-warnings.scala
@@ -18,12 +18,10 @@ object Test {
   def err2[A, B](value: Foo[A, B], a: A => Int): B = value match {
     case b: Bar[B] => // spurious // error
       b.x
-    case _ => ??? // avoid fatal inexhaustivity warnings suppressing the uncheckable warning
   }
 
   def fail[A, B](value: Foo[A, B], a: A => Int): B = value match {
     case b: Bar[Int] => // error
       b.x
-    case _ => ??? // avoid fatal inexhaustivity warnings suppressing the uncheckable warning
   }
 }
diff --git a/tests/neg-custom-args/isInstanceOf/enum-approx2.scala b/tests/neg-custom-args/isInstanceOf/enum-approx2.scala
index 516b765ec64b..5e3bdef7553d 100644
--- a/tests/neg-custom-args/isInstanceOf/enum-approx2.scala
+++ b/tests/neg-custom-args/isInstanceOf/enum-approx2.scala
@@ -4,7 +4,5 @@ case class Fun[A, B](f: Exp[A => B]) extends Exp[A => B]
 class Test {
   def eval(e: Fun[Int, Int]) = e match {
     case Fun(x: Fun[Int, Double]) => ???          // error
-    case Fun(x: Exp[Int => String]) => ???        // error
-    case _ =>
   }
-}
\ No newline at end of file
+}
diff --git a/tests/neg-custom-args/isInstanceOf/i11178.scala b/tests/neg-custom-args/isInstanceOf/i11178.scala
index 0d6867eba75f..71bc346e5743 100644
--- a/tests/neg-custom-args/isInstanceOf/i11178.scala
+++ b/tests/neg-custom-args/isInstanceOf/i11178.scala
@@ -12,7 +12,6 @@ object Test1 {
   def test[A](bar: Bar[A]) =
     bar match {
       case _: Bar[Boolean] => ??? // error
-      case _ => ???
     }
 }
 
@@ -36,4 +35,4 @@ object Test3 {
       case _: Bar[Boolean] => ??? // error
       case _ => ???
     }
-}
\ No newline at end of file
+}
diff --git a/tests/neg-custom-args/isInstanceOf/i8932.scala b/tests/neg-custom-args/isInstanceOf/i8932.scala
index f77c28c7b0a7..e070fdae518c 100644
--- a/tests/neg-custom-args/isInstanceOf/i8932.scala
+++ b/tests/neg-custom-args/isInstanceOf/i8932.scala
@@ -6,7 +6,6 @@ class Dummy extends Bar[Nothing] with Foo[String]
 def bugReport[A](foo: Foo[A]): Foo[A] =
   foo match {
     case bar: Bar[A] => bar    // error
-    case dummy: Dummy => ???
   }
 
-def test = bugReport(new Dummy: Foo[String])
\ No newline at end of file
+def test = bugReport(new Dummy: Foo[String])
diff --git a/tests/neg/i16451.check b/tests/neg/i16451.check
new file mode 100644
index 000000000000..e53085e8eafa
--- /dev/null
+++ b/tests/neg/i16451.check
@@ -0,0 +1,24 @@
+-- Error: tests/neg/i16451.scala:13:9 ----------------------------------------------------------------------------------
+13 |    case x: Wrapper[Color.Red.type] => Some(x) // error
+   |         ^
+   |the type test for Wrapper[(Color.Red : Color)] cannot be checked at runtime because its type arguments can't be determined from Wrapper[Color]
+-- Error: tests/neg/i16451.scala:21:9 ----------------------------------------------------------------------------------
+21 |    case x: Wrapper[Color.Red.type] => Some(x) // error
+   |         ^
+   |the type test for Wrapper[(Color.Red : Color)] cannot be checked at runtime because its type arguments can't be determined from Any
+-- Error: tests/neg/i16451.scala:25:9 ----------------------------------------------------------------------------------
+25 |    case x: Wrapper[Color.Red.type] => Some(x) // error
+   |         ^
+   |the type test for Wrapper[(Color.Red : Color)] cannot be checked at runtime because its type arguments can't be determined from Wrapper[Color]
+-- Error: tests/neg/i16451.scala:29:9 ----------------------------------------------------------------------------------
+29 |    case x: Wrapper[Color.Red.type] => Some(x) // error
+   |         ^
+   |the type test for Wrapper[(Color.Red : Color)] cannot be checked at runtime because its type arguments can't be determined from A1
+-- Error: tests/neg/i16451.scala:34:11 ---------------------------------------------------------------------------------
+34 |      case x: Wrapper[Color.Red.type] => x // error
+   |           ^
+   |the type test for Wrapper[(Color.Red : Color)] cannot be checked at runtime because its type arguments can't be determined from Wrapper[Color]
+-- Error: tests/neg/i16451.scala:39:11 ---------------------------------------------------------------------------------
+39 |      case x: Wrapper[Color.Red.type] => x // error
+   |           ^
+   |the type test for Wrapper[(Color.Red : Color)] cannot be checked at runtime because its type arguments can't be determined from Wrapper[Color]
diff --git a/tests/neg/i16451.scala b/tests/neg/i16451.scala
new file mode 100644
index 000000000000..685b79477bbe
--- /dev/null
+++ b/tests/neg/i16451.scala
@@ -0,0 +1,44 @@
+// scalac: -Werror
+enum Color:
+  case Red, Green
+//sealed trait Color
+//object Color:
+//  case object Red   extends Color
+//  case object Green extends Color
+
+case class Wrapper[A](value: A)
+
+object Test:
+  def test_correct(x: Wrapper[Color]): Option[Wrapper[Color.Red.type]] = x match
+    case x: Wrapper[Color.Red.type] => Some(x) // error
+    case null                       => None
+
+  def test_different(x: Wrapper[Color]): Option[Wrapper[Color]] = x match
+    case x @ Wrapper(_: Color.Red.type)   => Some(x)
+    case x @ Wrapper(_: Color.Green.type) => None
+
+  def test_any(x: Any): Option[Wrapper[Color.Red.type]] = x match
+    case x: Wrapper[Color.Red.type] => Some(x) // error
+    case _                          => None
+
+  def test_wrong(x: Wrapper[Color]): Option[Wrapper[Color.Red.type]] = x match
+    case x: Wrapper[Color.Red.type] => Some(x) // error
+    case null                       => None
+
+  def t2[A1 <: Wrapper[Color]](x: A1): Option[Wrapper[Color.Red.type]] = x match
+    case x: Wrapper[Color.Red.type] => Some(x) // error
+    case null                       => None
+
+  def test_wrong_seq(xs: Seq[Wrapper[Color]]): Seq[Wrapper[Color.Red.type]] =
+    xs.collect {
+      case x: Wrapper[Color.Red.type] => x // error
+    }
+
+  def test_wrong_seq2(xs: Seq[Wrapper[Color]]): Seq[Wrapper[Color.Red.type]] =
+    xs.collect { x => x match
+      case x: Wrapper[Color.Red.type] => x // error
+    }
+
+  def main(args: Array[String]): Unit =
+    println(test_wrong_seq(Seq(Wrapper(Color.Red), Wrapper(Color.Green))))
+    // outputs: List(Wrapper(Red), Wrapper(Green))
diff --git a/tests/pos/i16451.CanForward.scala b/tests/pos/i16451.CanForward.scala
new file mode 100644
index 000000000000..a09a26f22acc
--- /dev/null
+++ b/tests/pos/i16451.CanForward.scala
@@ -0,0 +1,34 @@
+// scalac: -Werror
+abstract class Namer:
+  private enum CanForward:
+    case Yes
+    case No(whyNot: String)
+    case Skip  // for members that have never forwarders
+
+  class Mbr
+  private def canForward(mbr: Mbr): CanForward = CanForward.Yes
+
+  private def applyOrElse[A1 <: CanForward, B1 >: String](x: A1, default: A1 => B1): B1 = x match
+    case CanForward.No(whyNot @ _) => whyNot
+    case _ => ""
+
+  def addForwardersNamed(mbrs: List[Mbr]) =
+    val reason = mbrs.map(canForward).collect {
+      case CanForward.No(whyNot) => whyNot
+    }.headOption.getOrElse("")
+
+  class ClassCompleter:
+    def addForwardersNamed(mbrs: List[Mbr]) =
+      val reason = mbrs.map(canForward).collect {
+        case CanForward.No(whyNot) => whyNot
+      }.headOption.getOrElse("")
+
+    private def exportForwarders =
+      def addForwardersNamed(mbrs: List[Mbr]) =
+        val reason = mbrs.map(canForward).collect {
+          case CanForward.No(whyNot) => whyNot
+        }.headOption.getOrElse("")
+        if mbrs.size == 4 then
+          val reason = mbrs.map(canForward).collect {
+            case CanForward.No(whyNot) => whyNot
+          }.headOption.getOrElse("")
diff --git a/tests/pos/i16451.DiffUtil.scala b/tests/pos/i16451.DiffUtil.scala
new file mode 100644
index 000000000000..3ade8bb73aa7
--- /dev/null
+++ b/tests/pos/i16451.DiffUtil.scala
@@ -0,0 +1,15 @@
+// scalac: -Werror
+object DiffUtil:
+  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 test(diff: Array[Patch]) =
+    diff.collect {
+      case Unmodified(str)     => str
+      case Inserted(str)       => s"+$str"
+      case Modified(orig, str) => s"{$orig,$str}"
+      case Deleted(str)        => s"-$str"
+    }.mkString
diff --git a/tests/pos/i16451.default.scala b/tests/pos/i16451.default.scala
new file mode 100644
index 000000000000..2751f4901b5f
--- /dev/null
+++ b/tests/pos/i16451.default.scala
@@ -0,0 +1,22 @@
+// scalac: -Werror
+
+import java.lang.reflect.*
+import scala.annotation.tailrec
+
+class Test:
+  @tailrec private def unwrapThrowable(x: Throwable): Throwable = x match {
+    case  _: InvocationTargetException |      // thrown by reflectively invoked method or constructor
+          _: ExceptionInInitializerError |    // thrown when running a static initializer (e.g. a scala module constructor)
+          _: UndeclaredThrowableException |   // invocation on a proxy instance if its invocation handler's `invoke` throws an exception
+          _: ClassNotFoundException |         // no definition for a class instantiated by name
+          _: NoClassDefFoundError             // the definition existed when the executing class was compiled, but can no longer be found
+      if x.getCause != null =>
+      unwrapThrowable(x.getCause)
+    case _ => x
+  }
+
+  private def unwrapHandler[T](pf: PartialFunction[Throwable, T]): PartialFunction[Throwable, T] =
+    pf.compose({ case ex => unwrapThrowable(ex) })
+
+  def test =
+    unwrapHandler({ case ex => throw ex })
diff --git a/tests/run-macros/i7898.check b/tests/run-macros/i7898.check
index 64da4a308f63..044c101dc772 100644
--- a/tests/run-macros/i7898.check
+++ b/tests/run-macros/i7898.check
@@ -1,4 +1,4 @@
-scala.List.apply[scala.PartialFunction[scala.Int, scala.Predef.String]](((x$1: scala.Int) => (x$1: @scala.unchecked) match {
+scala.List.apply[scala.PartialFunction[scala.Int, scala.Predef.String]](((x$1: scala.Int) => x$1 match {
   case 1 =>
     "x"
 }))

From 7de74bd2a2689af1a33fabc9bdd5e58d5f5d7668 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 28 Feb 2023 14:16:32 +0100
Subject: [PATCH 207/657] Use "explain=" to tag an -explain message in an
 implicitNotFound

This approach mirrors the format used in `@noWarn`. There it is possible
to tag encode the category and message in the string.
```
@nowarn("cat=deprecation&msg=Implementation ...")
```

The current implementation for `explain=` only allows this tag at the
start of the string. Making the message either a old-style message or an
message in the explain.

We could extend this to support `msg=` to be able to have both a custom
message and an explain. Furthermore we could insert some flags to
explicitly state how to display the original message (for example:
not-found=hidden, not-found=in-message, not-found=in-explain).
---
 compiler/src/dotty/tools/dotc/reporting/messages.scala | 9 +++++----
 library/src/scala/util/boundary.scala                  | 2 +-
 tests/neg-custom-args/explain/labelNotFound.scala      | 2 --
 3 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/reporting/messages.scala b/compiler/src/dotty/tools/dotc/reporting/messages.scala
index fb9eaed094e8..2652102eb02c 100644
--- a/compiler/src/dotty/tools/dotc/reporting/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/messages.scala
@@ -2640,17 +2640,18 @@ class MissingImplicitArgument(
     recur(pt)
 
   /** The implicitNotFound annotation on the parameter, or else on the type.
-   *  implicitNotFound message strings starting with `...` are intended for
-   *  additional explanations, not the message proper. The leading `...` is
+   *  implicitNotFound message strings starting with `explain=` are intended for
+   *  additional explanations, not the message proper. The leading `explain=` is
    *  dropped in this case.
    *  @param explain  The message is used for an additional explanation, not
    *                  the message proper.
    */
   def userDefinedImplicitNotFoundMessage(explain: Boolean)(using Context): Option[String] =
+    val explainTag = "explain="
     def filter(msg: Option[String]) = msg match
       case Some(str) =>
-        if str.startsWith("...") then
-          if explain then Some(str.drop(3)) else None
+        if str.startsWith(explainTag) then
+          if explain then Some(str.drop(explainTag.length)) else None
         else if explain then None
         else msg
       case None => None
diff --git a/library/src/scala/util/boundary.scala b/library/src/scala/util/boundary.scala
index ea21446d9682..2edd754bbb93 100644
--- a/library/src/scala/util/boundary.scala
+++ b/library/src/scala/util/boundary.scala
@@ -35,7 +35,7 @@ object boundary:
 
   /** Labels are targets indicating which boundary will be exited by a `break`.
    */
-  @implicitNotFound("...A Label is generated from an enclosing `scala.util.boundary` call.\nMaybe that boundary is missing?")
+  @implicitNotFound("explain=A Label is generated from an enclosing `scala.util.boundary` call.\nMaybe that boundary is missing?")
   final class Label[-T]
 
   /** Abort current computation and instead return `value` as the value of
diff --git a/tests/neg-custom-args/explain/labelNotFound.scala b/tests/neg-custom-args/explain/labelNotFound.scala
index 8eeaed90f331..2618600702da 100644
--- a/tests/neg-custom-args/explain/labelNotFound.scala
+++ b/tests/neg-custom-args/explain/labelNotFound.scala
@@ -1,4 +1,2 @@
 object Test:
   scala.util.boundary.break(1) // error
-
-

From 821023547864dfba0662965dd1f895edf08728f4 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 28 Feb 2023 14:32:56 +0100
Subject: [PATCH 208/657] Helpful implicit not found message for `Quotes`

Fixes #16888
---
 library/src/scala/quoted/Quotes.scala      | 19 +++++++++++++++++++
 tests/neg-custom-args/explain/i16888.check | 14 ++++++++++++++
 tests/neg-custom-args/explain/i16888.scala |  1 +
 tests/neg-macros/i6436.check               |  2 ++
 4 files changed, 36 insertions(+)
 create mode 100644 tests/neg-custom-args/explain/i16888.check
 create mode 100644 tests/neg-custom-args/explain/i16888.scala

diff --git a/library/src/scala/quoted/Quotes.scala b/library/src/scala/quoted/Quotes.scala
index 22ec107aeae8..05c253a76fd3 100644
--- a/library/src/scala/quoted/Quotes.scala
+++ b/library/src/scala/quoted/Quotes.scala
@@ -1,6 +1,7 @@
 package scala.quoted
 
 import scala.annotation.experimental
+import scala.annotation.implicitNotFound
 import scala.reflect.TypeTest
 
 /** Current Quotes in scope
@@ -21,7 +22,25 @@ transparent inline def quotes(using q: Quotes): q.type = q
  *
  *  It contains the low-level Typed AST API metaprogramming API.
  *  This API does not have the static type guarantees that `Expr` and `Type` provide.
+ *  `Quotes` are generated from an enclosing `${ ... }` or `scala.staging.run`. For example:
+ *  ```scala sc:nocompile
+ *  import scala.quoted._
+ *  inline def myMacro: Expr[T] =
+ *    ${ /* (quotes: Quotes) ?=> */ myExpr }
+ *  def myExpr(using Quotes): Expr[T] =
+ *    '{ f(${ /* (quotes: Quotes) ?=> */ myOtherExpr }) }
+ *  }
+ *  def myOtherExpr(using Quotes): Expr[U] = '{ ... }
+ *  ```
  */
+
+@implicitNotFound("""explain=Maybe this methods is missing a `(using Quotes)` parameter.
+
+Maybe that splice `$ { ... }` is missing?
+Given instances of `Quotes` are generated from an enclosing splice `$ { ... }` (or `scala.staging.run` call).
+A splice can be thought as a method with the following signature.
+  def $[T](body: Quotes ?=> Expr[T]): T
+""")
 trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
 
   // Extension methods for `Expr[T]`
diff --git a/tests/neg-custom-args/explain/i16888.check b/tests/neg-custom-args/explain/i16888.check
new file mode 100644
index 000000000000..e184ea418a94
--- /dev/null
+++ b/tests/neg-custom-args/explain/i16888.check
@@ -0,0 +1,14 @@
+-- [E172] Type Error: tests/neg-custom-args/explain/i16888.scala:1:38 --------------------------------------------------
+1 |def test = summon[scala.quoted.Quotes] // error
+  |                                      ^
+  |               No given instance of type quoted.Quotes was found for parameter x of method summon in object Predef
+  |---------------------------------------------------------------------------------------------------------------------
+  | Explanation (enabled by `-explain`)
+  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  | Maybe this methods is missing a `(using Quotes)` parameter.
+  |
+  | Maybe that splice `$ { ... }` is missing?
+  | Given instances of `Quotes` are generated from an enclosing splice `$ { ... }` (or `scala.staging.run` call).
+  | A splice can be thought as a method with the following signature.
+  |   def $[T](body: Quotes ?=> Expr[T]): T
+   ---------------------------------------------------------------------------------------------------------------------
diff --git a/tests/neg-custom-args/explain/i16888.scala b/tests/neg-custom-args/explain/i16888.scala
new file mode 100644
index 000000000000..9d3fd0f2f57e
--- /dev/null
+++ b/tests/neg-custom-args/explain/i16888.scala
@@ -0,0 +1 @@
+def test = summon[scala.quoted.Quotes] // error
diff --git a/tests/neg-macros/i6436.check b/tests/neg-macros/i6436.check
index 43e93b2e64e5..d563abb5424c 100644
--- a/tests/neg-macros/i6436.check
+++ b/tests/neg-macros/i6436.check
@@ -2,6 +2,8 @@
 5 |    case '{ StringContext(${Varargs(parts)}*) } => // error
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |         No given instance of type scala.quoted.Quotes was found
+  |
+  | longer explanation available when compiling with `-explain`
 -- [E006] Not Found Error: tests/neg-macros/i6436.scala:6:34 -----------------------------------------------------------
 6 |      val ps: Seq[Expr[String]] = parts // error
   |                                  ^^^^^

From dbdca17b01eef9e9d3ee0d46f36ffe97883c4a65 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Fri, 17 Feb 2023 22:38:25 +0100
Subject: [PATCH 209/657] Simplify QuoteMatcher using optional

---
 .../src/dotty/tools/dotc/util/optional.scala  | 19 +++++++
 .../quoted/runtime/impl/QuoteMatcher.scala    | 55 +++++++------------
 .../quoted/runtime/impl/QuotesImpl.scala      | 22 ++++----
 3 files changed, 49 insertions(+), 47 deletions(-)
 create mode 100644 compiler/src/dotty/tools/dotc/util/optional.scala

diff --git a/compiler/src/dotty/tools/dotc/util/optional.scala b/compiler/src/dotty/tools/dotc/util/optional.scala
new file mode 100644
index 000000000000..cb62315d3c98
--- /dev/null
+++ b/compiler/src/dotty/tools/dotc/util/optional.scala
@@ -0,0 +1,19 @@
+package dotty.tools.dotc.util
+
+import scala.util.boundary
+
+/** Return type that indicates that the method returns a T or aborts to the enclosing boundary with a `None` */
+type optional[T] = boundary.Label[None.type] ?=> T
+
+/** A prompt for `Option`, which establishes a boundary which `_.?` on `Option` can return */
+object optional:
+  inline def apply[T](inline body: optional[T]): Option[T] =
+    boundary(Some(body))
+
+  extension [T](r: Option[T])
+    inline def ? (using label: boundary.Label[None.type]): T = r match
+      case Some(x) => x
+      case None => boundary.break(None)
+
+  inline def break()(using label: boundary.Label[None.type]): Nothing =
+    boundary.break(None)
diff --git a/compiler/src/scala/quoted/runtime/impl/QuoteMatcher.scala b/compiler/src/scala/quoted/runtime/impl/QuoteMatcher.scala
index 7c952dbbe142..9a77cba97400 100644
--- a/compiler/src/scala/quoted/runtime/impl/QuoteMatcher.scala
+++ b/compiler/src/scala/quoted/runtime/impl/QuoteMatcher.scala
@@ -1,7 +1,6 @@
 package scala.quoted
 package runtime.impl
 
-
 import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.core.Contexts.*
 import dotty.tools.dotc.core.Flags.*
@@ -9,6 +8,7 @@ import dotty.tools.dotc.core.Names.*
 import dotty.tools.dotc.core.Types.*
 import dotty.tools.dotc.core.StdNames.nme
 import dotty.tools.dotc.core.Symbols.*
+import dotty.tools.dotc.util.optional
 
 /** Matches a quoted tree against a quoted pattern tree.
  *  A quoted pattern tree may have type and term holes in addition to normal terms.
@@ -103,12 +103,13 @@ import dotty.tools.dotc.core.Symbols.*
 object QuoteMatcher {
   import tpd.*
 
-  // TODO improve performance
-
   // TODO use flag from Context. Maybe -debug or add -debug-macros
   private inline val debug = false
 
-  import Matching._
+  /** Sequence of matched expressions.
+   *  These expressions are part of the scrutinee and will be bound to the quote pattern term splices.
+   */
+  type MatchingExprs = Seq[Expr[Any]]
 
   /** A map relating equivalent symbols from the scrutinee and the pattern
     *  For example in
@@ -121,19 +122,20 @@ object QuoteMatcher {
 
   private def withEnv[T](env: Env)(body: Env ?=> T): T = body(using env)
 
-  def treeMatch(scrutineeTree: Tree, patternTree: Tree)(using Context): Option[Tuple] =
+  def treeMatch(scrutineeTree: Tree, patternTree: Tree)(using Context): Option[MatchingExprs] =
     given Env = Map.empty
-    scrutineeTree =?= patternTree
+    optional:
+      scrutineeTree =?= patternTree
 
   /** Check that all trees match with `mtch` and concatenate the results with &&& */
-  private def matchLists[T](l1: List[T], l2: List[T])(mtch: (T, T) => Matching): Matching = (l1, l2) match {
+  private def matchLists[T](l1: List[T], l2: List[T])(mtch: (T, T) => MatchingExprs): optional[MatchingExprs] = (l1, l2) match {
     case (x :: xs, y :: ys) => mtch(x, y) &&& matchLists(xs, ys)(mtch)
     case (Nil, Nil) => matched
     case _ => notMatched
   }
 
   extension (scrutinees: List[Tree])
-    private def =?= (patterns: List[Tree])(using Env, Context): Matching =
+    private def =?= (patterns: List[Tree])(using Env, Context): optional[MatchingExprs] =
       matchLists(scrutinees, patterns)(_ =?= _)
 
   extension (scrutinee0: Tree)
@@ -144,9 +146,9 @@ object QuoteMatcher {
       *  @param scrutinee The tree being matched
       *  @param pattern The pattern tree that the scrutinee should match. Contains `patternHole` holes.
       *  @param `summon[Env]` Set of tuples containing pairs of symbols (s, p) where s defines a symbol in `scrutinee` which corresponds to symbol p in `pattern`.
-      *  @return `None` if it did not match or `Some(tup: Tuple)` if it matched where `tup` contains the contents of the holes.
+      *  @return `None` if it did not match or `Some(tup: MatchingExprs)` if it matched where `tup` contains the contents of the holes.
       */
-    private def =?= (pattern0: Tree)(using Env, Context): Matching =
+    private def =?= (pattern0: Tree)(using Env, Context): optional[MatchingExprs] =
 
       /* Match block flattening */ // TODO move to cases
       /** Normalize the tree */
@@ -431,7 +433,6 @@ object QuoteMatcher {
       case _ => scrutinee
     val pattern = patternTree.symbol
 
-
     devirtualizedScrutinee == pattern
     || summon[Env].get(devirtualizedScrutinee).contains(pattern)
     || devirtualizedScrutinee.allOverriddenSymbols.contains(pattern)
@@ -452,32 +453,16 @@ object QuoteMatcher {
       accumulator.apply(Set.empty, term)
   }
 
-  /** Result of matching a part of an expression */
-  private type Matching = Option[Tuple]
-
-  private object Matching {
-
-    def notMatched: Matching = None
+  private inline def notMatched: optional[MatchingExprs] =
+    optional.break()
 
-    val matched: Matching = Some(Tuple())
+  private inline def matched: MatchingExprs =
+    Seq.empty
 
-    def matched(tree: Tree)(using Context): Matching =
-      Some(Tuple1(new ExprImpl(tree, SpliceScope.getCurrent)))
+  private inline def matched(tree: Tree)(using Context): MatchingExprs =
+    Seq(new ExprImpl(tree, SpliceScope.getCurrent))
 
-    extension (self: Matching)
-      def asOptionOfTuple: Option[Tuple] = self
-
-      /** Concatenates the contents of two successful matchings or return a `notMatched` */
-      def &&& (that: => Matching): Matching = self match {
-        case Some(x) =>
-          that match {
-            case Some(y) => Some(x ++ y)
-            case _ => None
-          }
-        case _ => None
-      }
-    end extension
-
-  }
+  extension (self: MatchingExprs)
+    private inline def &&& (that: MatchingExprs): MatchingExprs = self ++ that
 
 }
diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
index 965a3e907878..378f3f6a5c40 100644
--- a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
+++ b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
@@ -3139,18 +3139,16 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     val matchings = QuoteMatcher.treeMatch(scrutinee, pat1)(using ctx1)
 
-    if typeHoles.isEmpty then matchings
-    else {
-      // After matching and doing all subtype checks, we have to approximate all the type bindings
-      // that we have found, seal them in a quoted.Type and add them to the result
-      def typeHoleApproximation(sym: Symbol) =
-        val fromAboveAnnot = sym.hasAnnotation(dotc.core.Symbols.defn.QuotedRuntimePatterns_fromAboveAnnot)
-        val fullBounds = ctx1.gadt.fullBounds(sym)
-        val tp = if fromAboveAnnot then fullBounds.hi else fullBounds.lo
-        reflect.TypeReprMethods.asType(tp)
-      matchings.map { tup =>
-        Tuple.fromIArray(typeHoles.map(typeHoleApproximation).toArray.asInstanceOf[IArray[Object]]) ++ tup
-      }
+    // After matching and doing all subtype checks, we have to approximate all the type bindings
+    // that we have found, seal them in a quoted.Type and add them to the result
+    def typeHoleApproximation(sym: Symbol) =
+      val fromAboveAnnot = sym.hasAnnotation(dotc.core.Symbols.defn.QuotedRuntimePatterns_fromAboveAnnot)
+      val fullBounds = ctx1.gadt.fullBounds(sym)
+      val tp = if fromAboveAnnot then fullBounds.hi else fullBounds.lo
+      reflect.TypeReprMethods.asType(tp)
+    matchings.map { tup =>
+      val results = typeHoles.map(typeHoleApproximation) ++ tup
+      Tuple.fromIArray(results.toArray.asInstanceOf[IArray[Object]])
     }
   }
 

From fa5df056172e2a25f72103720218daa94a19e115 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Tue, 28 Feb 2023 17:54:21 +0100
Subject: [PATCH 210/657] Remove unused import

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

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index 9f3f5aded50c..e7e6e1c4952c 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -13,7 +13,7 @@ import dotty.tools.dotc.core.StdNames
 import dotty.tools.dotc.report
 import dotty.tools.dotc.reporting.Message
 import dotty.tools.dotc.typer.ImportInfo
-import dotty.tools.dotc.util.{Property, SourcePosition, SrcPos}
+import dotty.tools.dotc.util.{Property, SrcPos}
 import dotty.tools.dotc.core.Mode
 import dotty.tools.dotc.core.Types.TypeTraverser
 import dotty.tools.dotc.core.Types.Type

From e7e0df0e1ef6242a12a98544c5b034c7cafed678 Mon Sep 17 00:00:00 2001
From: Guillaume Martres <smarter@ubuntu.com>
Date: Mon, 27 Feb 2023 13:47:08 +0100
Subject: [PATCH 211/657] Generate kind-correct wildcards when selecting from a
 wildcard

Previously, derivedSelect would incorrectly approximate `fn.R` by `? >: Nothing
<: Any` in `i16997.min.scala`, which subsequently lead to a kind-incorrect
type application `Any[Y]` that broke type inference. #16999 proposed to fix this
by changing type inference, but it seems like we don't need to do that if we
make sure our wildcards are always kind-correct.

Note that the wildcard logic in lookupRefined could be removed: it seems like
it was supposed to be used by `reduceProjection` according to its documentation,
but the constructor of `NamedType` disallows wildcards as prefixes so it didn't
actually do anything there.

Co-Authored-By: Dale Wijnand <dale.wijnand@gmail.com>
---
 .../src/dotty/tools/dotc/core/Types.scala     | 16 ++---
 .../test/dotc/pos-test-pickling.blacklist     |  1 +
 tests/pos/i16997.min.scala                    | 12 ++++
 tests/pos/i16997.scala                        | 63 +++++++++++++++++++
 4 files changed, 85 insertions(+), 7 deletions(-)
 create mode 100644 tests/pos/i16997.min.scala
 create mode 100644 tests/pos/i16997.scala

diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index d005cabebcfb..840f49a19cc2 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -1574,8 +1574,6 @@ object Types {
           else NoType
         case SkolemType(tp) =>
           loop(tp)
-        case pre: WildcardType =>
-          WildcardType
         case pre: TypeRef =>
           pre.info match {
             case TypeAlias(alias) => loop(alias)
@@ -2554,10 +2552,7 @@ object Types {
       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`
+    /** 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; ... }`
      */
@@ -2679,7 +2674,7 @@ object Types {
               case _ =>
             }
         }
-        if (prefix.isInstanceOf[WildcardType]) WildcardType
+        if (prefix.isInstanceOf[WildcardType]) WildcardType.sameKindAs(this)
         else withPrefix(prefix)
       }
 
@@ -5253,6 +5248,10 @@ object Types {
       else
         result
     def emptyPolyKind(using Context): TypeBounds = apply(defn.NothingType, defn.AnyKindType)
+    /** An interval covering all types of the same kind as `tp`. */
+    def emptySameKindAs(tp: Type)(using Context): TypeBounds =
+      val top = tp.topType
+      if top.isExactlyAny then empty else apply(defn.NothingType, top)
     def upper(hi: Type)(using Context): TypeBounds = apply(defn.NothingType, hi)
     def lower(lo: Type)(using Context): TypeBounds = apply(lo, defn.AnyType)
   }
@@ -5428,6 +5427,9 @@ object Types {
         else
           result
       else unique(CachedWildcardType(bounds))
+    /** A wildcard matching any type of the same kind as `tp`. */
+    def sameKindAs(tp: Type)(using Context): WildcardType =
+      apply(TypeBounds.emptySameKindAs(tp))
   }
 
   /** An extractor for single abstract method types.
diff --git a/compiler/test/dotc/pos-test-pickling.blacklist b/compiler/test/dotc/pos-test-pickling.blacklist
index 5f7221ee0ce9..d1dd83f36ff7 100644
--- a/compiler/test/dotc/pos-test-pickling.blacklist
+++ b/compiler/test/dotc/pos-test-pickling.blacklist
@@ -20,6 +20,7 @@ i13871.scala
 i15181.scala
 i15922.scala
 t5031_2.scala
+i16997.scala
 
 # Tree is huge and blows stack for printing Text
 i7034.scala
diff --git a/tests/pos/i16997.min.scala b/tests/pos/i16997.min.scala
new file mode 100644
index 000000000000..abac648bdfd5
--- /dev/null
+++ b/tests/pos/i16997.min.scala
@@ -0,0 +1,12 @@
+class Fn:
+  class R[Y]
+
+case class Foo[F[_]](nest: Foo[F]):
+  case class Bar[G[_], R[_]](value: Foo[G])
+
+  def bar[G[_]](using fn: Fn): Bar[G, fn.R] = ???
+
+  def part[G[_]](using fn: Fn): Bar[G, fn.R] =
+    (bar[G], ()) match
+      case (Bar(value), ()) =>
+        Bar(Foo(value))
diff --git a/tests/pos/i16997.scala b/tests/pos/i16997.scala
new file mode 100644
index 000000000000..cd7b1ac8ab91
--- /dev/null
+++ b/tests/pos/i16997.scala
@@ -0,0 +1,63 @@
+class Funs {
+  sealed trait ->[A, B]
+}
+
+/**
+ * Binary tree with leafs holding values of types `F[X]`, `F[Y]`, ...
+ * The complete structure of the tree is expressed by the type `A`, using the tags for branches and leafs.
+ *
+ * @tparam <*> tag for branches
+ * @tparam T tag for leafs.
+ * @tparam F value type of leafs. Each leaf holds a value of type `F[T]`, for some type `T`.
+ * @tparam A captures the complete structure of the tree
+ */
+enum Tree[<*>[_, _], T[_], F[_], A] {
+  case Branch[<*>[_, _], T[_], F[_], A, B](
+    l: Tree[<*>, T, F, A],
+    r: Tree[<*>, T, F, B],
+  ) extends Tree[<*>, T, F, A <*> B]
+
+  case Leaf[<*>[_, _], T[_], F[_], A](
+    value: F[A],
+  ) extends Tree[<*>, T, F, T[A]]
+
+  def <*>[B](that: Tree[<*>, T, F, B]): Tree[<*>, T, F, A <*> B] =
+    Branch(this, that)
+
+  def partition[G[_], H[_]](
+    f: [x] => F[x] => Either[G[x], H[x]],
+  )(using
+    funs: Funs,
+  ): Partitioned[G, H, funs.->] =
+    this match {
+      case Leaf(a) =>
+        f(a) match
+          case Left(a)  => Partitioned.Left(Leaf(a))
+          case Right(a) => Partitioned.Right(Leaf(a))
+      case Branch(l, r) =>
+        import Partitioned.{Both, Left, Right}
+        import l.Partitioned.{Both => LBoth, Left => LLeft, Right => LRight}
+        import r.Partitioned.{Both => RBoth, Left => RLeft, Right => RRight}
+
+        (l.partition(f), r.partition(f)) match
+          case (LLeft(lg),     RLeft(rg))     => Left(lg <*> rg)
+          case (LLeft(lg),     RRight(rh))    => Both(lg, rh)
+          case (LLeft(lg),     RBoth(rg, rh)) => Both(lg <*> rg, rh)
+          case (LRight(lh),    RLeft(rg))     => Both(rg, lh)
+          case (LRight(lh),    RRight(rh))    => Right(lh <*> rh)
+          case (LRight(lh),    RBoth(rg, rh)) => Both(rg, lh <*> rh)
+          case (LBoth(lg, lh), RLeft(rg))     => Both(lg <*> rg, lh)
+          case (LBoth(lg, lh), RRight(rh))    => Both(lg, lh <*> rh)
+          case (LBoth(lg, lh), RBoth(rg, rh)) => Both(lg <*> rg, lh <*> rh)
+    }
+
+  // note that `->` is never even used, to keep this reproduction case small
+  enum Partitioned[G[_], H[_], ->[_, _]] {
+    case Left(value: Tree[<*>, T, G, A])
+    case Right(value: Tree[<*>, T, H, A])
+    case Both[G[_], H[_], X, Y, ->[_, _]](
+      l: Tree[<*>, T, G, X],
+      r: Tree[<*>, T, H, Y],
+    ) extends Partitioned[G, H, ->]
+  }
+}

From 0f9a6724736acb3c19edf15b9615d189f3dfdfbf Mon Sep 17 00:00:00 2001
From: David Hua <d5hua@uwaterloo.ca>
Date: Tue, 28 Feb 2023 22:41:07 -0500
Subject: [PATCH 212/657] Add missing cacheResult flags.

---
 compiler/src/dotty/tools/dotc/transform/init/Semantic.scala | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
index 286e3a124d12..11376f427158 100644
--- a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
+++ b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
@@ -893,7 +893,7 @@ object Semantic:
 
               case Cold => Cold
 
-              case ref: Ref => eval(vdef.rhs, ref, enclosingClass)
+              case ref: Ref => eval(vdef.rhs, ref, enclosingClass, cacheResult = true)
 
               case _ =>
                  report.error("[Internal error] unexpected this value when accessing local variable, sym = " + sym.show + ", thisValue = " + thisValue2.show + Trace.show, Trace.position)
@@ -989,7 +989,7 @@ object Semantic:
             val errors = Reporter.stopEarly {
               val res = {
                 given Trace = Trace.empty
-                eval(body, thisV, klass)
+                eval(body, thisV, klass, cacheResult = true)
               }
               given Trace = Trace.empty.add(body)
               res.promote("The function return value is not hot. Found = " + res.show + ".")

From 294fae8969fcb8e6bc46132234900c60822604b3 Mon Sep 17 00:00:00 2001
From: David Hua <d5hua@uwaterloo.ca>
Date: Tue, 28 Feb 2023 23:42:51 -0500
Subject: [PATCH 213/657] Added method calls to clause positive clause
 interleaving init tests

---
 tests/init/pos/interleaving-overload.scala |  4 ++++
 tests/init/pos/interleaving-params.scala   | 11 +++++++++++
 2 files changed, 15 insertions(+)

diff --git a/tests/init/pos/interleaving-overload.scala b/tests/init/pos/interleaving-overload.scala
index 4d9214bf4d09..260b3538214a 100755
--- a/tests/init/pos/interleaving-overload.scala
+++ b/tests/init/pos/interleaving-overload.scala
@@ -7,6 +7,8 @@ class A{
 
     f1(1)
     f1("hello")
+    f1[Boolean]("a")[Int]
+    f1[Boolean](1)[Int]
 
     case class B[U](x: Int)
     def b[U](x: Int) = B[U](x)
@@ -17,4 +19,6 @@ class A{
     f2[Any](1)
     f2[Any][Any](1)
 
+    b[Int](5)
+
 }
\ No newline at end of file
diff --git a/tests/init/pos/interleaving-params.scala b/tests/init/pos/interleaving-params.scala
index 08531a84e696..9f98b5f35d5b 100755
--- a/tests/init/pos/interleaving-params.scala
+++ b/tests/init/pos/interleaving-params.scala
@@ -1,3 +1,5 @@
+import scala.collection.mutable.AbstractSet
+import scala.collection.mutable.BitSet
 import scala.language.experimental.clauseInterleaving
 
 class Params{
@@ -5,4 +7,13 @@ class Params{
     def foo[T](x: T)[U >: x.type <: T](using U)[L <: List[U]](l: L): L = ???
     def aaa(x: U): U = ???
     def bbb[T <: U](x: U)[U]: U = ???
+
+    foo[AbstractSet[Int]](BitSet())[AbstractSet[Int]](using BitSet())[List[AbstractSet[Int]]](List[AbstractSet[Int]]())
+}
+
+class Param2 extends Params {
+    type U = AbstractSet[Int]
+
+    aaa(BitSet())
+    bbb[BitSet](BitSet())[AbstractSet[Int]]
 }
\ No newline at end of file

From 0f7c3abc3706b2054c48f3b16991741edb3a4610 Mon Sep 17 00:00:00 2001
From: Natsu Kagami <nki@nkagami.me>
Date: Tue, 20 Sep 2022 10:17:13 +0200
Subject: [PATCH 214/657] Implement individual erased parameters

Breaking change for erasedDefinitions: this effectively makes the
current `erased` marker in parameter list apply to only the first
parameter.

    def f(erased a: int, b: int)

should now be written as

    def f(erased a: int, erased b: int)

    type Function1 = (x: Int, erased y: Int) => Int
    type Function2 = (Int, erased Int) => Int

Use refined traits for erased functions

- Function types with erased parameters are now always `ErasedFunction` refined with the correct `apply` definition,
  for example:

    scala.runtime.ErasedFunction {
        def apply(x1: Int, erased x2: Int): Int
    }
  where ErasedFunction is an @experimental empty trait.
- Polymorphic functions cannot take erased parameters.
- By-name parameters cannot be erased.
- Internally, use the @ErasedParam annotation as a marker for an erased parameter.
- Parameters that are erased classes are now marked `erased` at Typer phase (with an annotation),
  and in later phases, they are not taken into account when considering erasedness.
- Erased parameters/functions quotes API are changed:
    - `isErased` => `erasedArgs`/`erasedParams` and `hasErasedArgs`/`hasErasedParams`
    - `FunctionClass` now fails when `isErased = true`. Add `ErasedFunctionClass`.
- Added tests and test-fixes for `erasedDefinitions` feature
- Updated specs and internal syntax
- Aside, reject normal tuples with ValDefs in them. This comes up when trying to parse parameters out of tuples.
  In practice they don't show up.

Co-authored-by: Nicolas Stucki <nicolas.stucki@gmail.com>
---
 .../src/dotty/tools/dotc/ast/Desugar.scala    |  29 +++-
 .../src/dotty/tools/dotc/ast/TreeInfo.scala   |   2 +-
 compiler/src/dotty/tools/dotc/ast/tpd.scala   |  10 +-
 compiler/src/dotty/tools/dotc/ast/untpd.scala |  10 +-
 .../src/dotty/tools/dotc/cc/CaptureOps.scala  |   1 -
 .../dotty/tools/dotc/cc/CheckCaptures.scala   |  20 +--
 compiler/src/dotty/tools/dotc/cc/Setup.scala  |  16 +-
 .../dotty/tools/dotc/core/Definitions.scala   | 124 ++++++++-------
 .../dotty/tools/dotc/core/Denotations.scala   |   3 +-
 .../src/dotty/tools/dotc/core/NameOps.scala   |  10 +-
 .../src/dotty/tools/dotc/core/NamerOps.scala  |   8 +-
 .../src/dotty/tools/dotc/core/StdNames.scala  |   1 +
 .../tools/dotc/core/TypeApplications.scala    |  10 ++
 .../dotty/tools/dotc/core/TypeComparer.scala  |   5 +-
 .../dotty/tools/dotc/core/TypeErasure.scala   |  21 ++-
 .../src/dotty/tools/dotc/core/Types.scala     |  62 ++++----
 .../tools/dotc/core/tasty/TreePickler.scala   |   1 -
 .../tools/dotc/core/tasty/TreeUnpickler.scala |   3 -
 .../dotty/tools/dotc/parsing/Parsers.scala    | 147 ++++++++++++------
 .../tools/dotc/printing/PlainPrinter.scala    |  12 +-
 .../tools/dotc/printing/RefinedPrinter.scala  |  30 ++--
 .../dotty/tools/dotc/quoted/Interpreter.scala |   4 +-
 .../dotty/tools/dotc/transform/Bridges.scala  |   7 +-
 .../transform/ContextFunctionResults.scala    |  20 +--
 .../tools/dotc/transform/ElimByName.scala     |  10 +-
 .../dotty/tools/dotc/transform/Erasure.scala  |   9 +-
 .../dotc/transform/GenericSignatures.scala    |   4 +-
 .../tools/dotc/transform/PickleQuotes.scala   |   2 +-
 .../tools/dotc/transform/PostTyper.scala      |  24 +--
 .../dotc/transform/PruneErasedDefs.scala      |   8 +-
 .../dotc/transform/SpecializeFunctions.scala  |   2 +-
 .../tools/dotc/transform/TreeChecker.scala    |   4 +-
 .../dotty/tools/dotc/typer/Applications.scala |   6 +-
 .../dotty/tools/dotc/typer/EtaExpansion.scala |   5 +-
 .../dotty/tools/dotc/typer/ProtoTypes.scala   |   4 +-
 .../dotty/tools/dotc/typer/Synthesizer.scala  |   8 +-
 .../src/dotty/tools/dotc/typer/Typer.scala    | 146 ++++++++++-------
 .../quoted/runtime/impl/QuotesImpl.scala      |  18 ++-
 docs/_docs/internals/syntax.md                |  16 +-
 .../experimental/erased-defs-spec.md          |  20 +--
 .../reference/experimental/erased-defs.md     |  18 +--
 library/src/scala/quoted/Quotes.scala         |  25 ++-
 .../src/scala/runtime/ErasedFunction.scala    |  11 ++
 tests/neg-custom-args/erased/by-name.scala    |   4 +
 .../erased/erased-in-tuples.scala             |  16 ++
 .../neg-custom-args/erased/lambda-infer.scala |  23 +++
 .../erased/multiple-args-consume.scala        |  13 ++
 .../erased/multiple-args.scala                |  11 ++
 .../erased/poly-functions.scala               |  16 ++
 tests/neg/safeThrowsStrawman2.scala           |   2 +-
 .../erased/erased-class-as-args.scala         |  22 +++
 .../erased/erased-soft-keyword.scala          |  18 +++
 tests/run-custom-args/erased/erased-15.scala  |   4 +-
 tests/run-custom-args/erased/erased-27.check  |   1 -
 tests/run-custom-args/erased/erased-28.check  |   2 -
 .../erased/erased-class-are-erased.check      |   1 +
 .../erased/erased-class-are-erased.scala      |  14 ++
 tests/run-custom-args/erased/lambdas.scala    |  38 +++++
 .../erased/quotes-add-erased.check            |   1 +
 .../erased/quotes-add-erased/Macro_1.scala    |  26 ++++
 .../erased/quotes-add-erased/Test_2.scala     |  12 ++
 .../erased/quotes-reflection.check            |  10 ++
 .../erased/quotes-reflection/Macros_1.scala   |  35 +++++
 .../erased/quotes-reflection/Test_2.scala     |  20 +++
 .../run-macros-erased/macro-erased/1.scala    |   4 +-
 .../stdlibExperimentalDefinitions.scala       |  16 ++
 tests/run-macros/i12021.check                 |   8 +-
 tests/run-macros/i12021/Macro_1.scala         |   2 +-
 tests/run-macros/i12021/Test_2.scala          |   8 +-
 tests/run-macros/tasty-definitions-1.check    |  52 +------
 .../tasty-definitions-1/quoted_1.scala        |   7 +-
 71 files changed, 879 insertions(+), 403 deletions(-)
 create mode 100644 library/src/scala/runtime/ErasedFunction.scala
 create mode 100644 tests/neg-custom-args/erased/by-name.scala
 create mode 100644 tests/neg-custom-args/erased/erased-in-tuples.scala
 create mode 100644 tests/neg-custom-args/erased/lambda-infer.scala
 create mode 100644 tests/neg-custom-args/erased/multiple-args-consume.scala
 create mode 100644 tests/neg-custom-args/erased/multiple-args.scala
 create mode 100644 tests/neg-custom-args/erased/poly-functions.scala
 create mode 100644 tests/pos-custom-args/erased/erased-class-as-args.scala
 create mode 100644 tests/pos-custom-args/erased/erased-soft-keyword.scala
 create mode 100644 tests/run-custom-args/erased/erased-class-are-erased.check
 create mode 100644 tests/run-custom-args/erased/erased-class-are-erased.scala
 create mode 100644 tests/run-custom-args/erased/lambdas.scala
 create mode 100644 tests/run-custom-args/erased/quotes-add-erased.check
 create mode 100644 tests/run-custom-args/erased/quotes-add-erased/Macro_1.scala
 create mode 100644 tests/run-custom-args/erased/quotes-add-erased/Test_2.scala
 create mode 100644 tests/run-custom-args/erased/quotes-reflection.check
 create mode 100644 tests/run-custom-args/erased/quotes-reflection/Macros_1.scala
 create mode 100644 tests/run-custom-args/erased/quotes-reflection/Test_2.scala

diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index 85dd5e6665c6..c1dd78451bae 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -1498,10 +1498,10 @@ object desugar {
       case vd: ValDef => vd
     }
 
-  def makeContextualFunction(formals: List[Tree], body: Tree, isErased: Boolean)(using Context): Function = {
-    val mods = if (isErased) Given | Erased else Given
+  def makeContextualFunction(formals: List[Tree], body: Tree, erasedParams: List[Boolean])(using Context): Function = {
+    val mods = Given
     val params = makeImplicitParameters(formals, mods)
-    FunctionWithMods(params, body, Modifiers(mods))
+    FunctionWithMods(params, body, Modifiers(mods), erasedParams)
   }
 
   private def derivedValDef(original: Tree, named: NameTree, tpt: Tree, rhs: Tree, mods: Modifiers)(using Context) = {
@@ -1834,6 +1834,7 @@ object desugar {
             cpy.ByNameTypeTree(parent)(annotate(tpnme.retainsByName, restpt))
           case _ =>
             annotate(tpnme.retains, parent)
+      case f: FunctionWithMods if f.hasErasedParams => makeFunctionWithValDefs(f, pt)
     }
     desugared.withSpan(tree.span)
   }
@@ -1909,6 +1910,28 @@ object desugar {
     TypeDef(tpnme.REFINE_CLASS, impl).withFlags(Trait)
   }
 
+  /** Ensure the given function tree use only ValDefs for parameters.
+   *  For example,
+   *      FunctionWithMods(List(TypeTree(A), TypeTree(B)), body, mods, erasedParams)
+   *  gets converted to
+   *      FunctionWithMods(List(ValDef(x$1, A), ValDef(x$2, B)), body, mods, erasedParams)
+   */
+  def makeFunctionWithValDefs(tree: Function, pt: Type)(using Context): Function = {
+    val Function(args, result) = tree
+    args match {
+      case (_ : ValDef) :: _ => tree // ValDef case can be easily handled
+      case _ if !ctx.mode.is(Mode.Type) => tree
+      case _ =>
+        val applyVParams = args.zipWithIndex.map {
+          case (p, n) => makeSyntheticParameter(n + 1, p)
+        }
+        tree match
+          case tree: FunctionWithMods =>
+            untpd.FunctionWithMods(applyVParams, tree.body, tree.mods, tree.erasedParams)
+          case _ => untpd.Function(applyVParams, result)
+    }
+  }
+
   /** Returns list of all pattern variables, possibly with their types,
    *  without duplicates
    */
diff --git a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
index 9b55db600d3d..73f45bd7369b 100644
--- a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
+++ b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
@@ -960,7 +960,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
       && tree.isTerm
       && {
         val qualType = tree.qualifier.tpe
-        hasRefinement(qualType) && !qualType.derivesFrom(defn.PolyFunctionClass)
+        hasRefinement(qualType) && !defn.isRefinedFunctionType(qualType)
       }
     def loop(tree: Tree): Boolean = tree match
       case TypeApply(fun, _) =>
diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
index 5b0061b5d036..d1b1cdf607b5 100644
--- a/compiler/src/dotty/tools/dotc/ast/tpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -260,12 +260,12 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
           // 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 =
+        def valueParam(name: TermName, origInfo: Type, isErased: Boolean): 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
+          val maybeErased = if isErased then Erased else EmptyFlags
 
           def makeSym(info: Type) = newSymbol(sym, name, TermParam | maybeImplicit | maybeErased, info, coord = sym.coord)
 
@@ -283,7 +283,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
               assert(vparams.hasSameLengthAs(tp.paramNames) && vparams.head.isTerm)
               (vparams.asInstanceOf[List[TermSymbol]], remaining1)
             case nil =>
-              (tp.paramNames.lazyZip(tp.paramInfos).map(valueParam), Nil)
+              (tp.paramNames.lazyZip(tp.paramInfos).lazyZip(tp.erasedParams).map(valueParam), Nil)
         val (rtp, paramss) = recur(tp.instantiate(vparams.map(_.termRef)), remaining1)
         (rtp, vparams :: paramss)
       case _ =>
@@ -1140,10 +1140,10 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
     def etaExpandCFT(using Context): Tree =
       def expand(target: Tree, tp: Type)(using Context): Tree = tp match
-        case defn.ContextFunctionType(argTypes, resType, isErased) =>
+        case defn.ContextFunctionType(argTypes, resType, _) =>
           val anonFun = newAnonFun(
             ctx.owner,
-            MethodType.companion(isContextual = true, isErased = isErased)(argTypes, resType),
+            MethodType.companion(isContextual = true)(argTypes, resType),
             coord = ctx.owner.coord)
           def lambdaBody(refss: List[List[Tree]]) =
             expand(target.select(nme.apply).appliedToArgss(refss), resType)(
diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
index aeebb1f203e8..a262c3658399 100644
--- a/compiler/src/dotty/tools/dotc/ast/untpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -76,9 +76,13 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     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 function type or closure with `implicit` or `given` modifiers and information on which parameters are `erased` */
+  class FunctionWithMods(args: List[Tree], body: Tree, val mods: Modifiers, val erasedParams: List[Boolean])(implicit @constructorOnly src: SourceFile)
+    extends Function(args, body) {
+      assert(args.length == erasedParams.length)
+
+      def hasErasedParams = erasedParams.contains(true)
+    }
 
   /** A polymorphic function type */
   case class PolyFunction(targs: List[Tree], body: Tree)(implicit @constructorOnly src: SourceFile) extends Tree {
diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
index e4533aa73ce0..decd428f5365 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
@@ -146,7 +146,6 @@ extension (tp: Type)
       defn.FunctionType(
         fname.functionArity,
         isContextual = fname.isContextFunction,
-        isErased = fname.isErasedFunction,
         isImpure = true).appliedTo(args)
     case _ =>
       tp
diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index 77363a165f64..f9401a0c509f 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -336,8 +336,8 @@ class CheckCaptures extends Recheck, SymTransformer:
         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)
+          case defn.FunctionOf(paramtpe :: Nil, restpe, isContectual) =>
+            defn.FunctionOf(paramtpe.forceBoxStatus(true) :: Nil, restpe, isContectual)
         }
       else
         super.recheckApply(tree, pt) match
@@ -430,7 +430,7 @@ class CheckCaptures extends Recheck, SymTransformer:
       block match
         case closureDef(mdef) =>
           pt.dealias match
-            case defn.FunctionOf(ptformals, _, _, _)
+            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 `*`
@@ -598,8 +598,8 @@ class CheckCaptures extends Recheck, SymTransformer:
       //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)
+    private def toDepFun(args: List[Type], resultType: Type, isContextual: Boolean)(using Context): Type =
+      MethodType.companion(isContextual = isContextual)(args, resultType)
         .toFunctionType(isJava = false, alwaysDependent = true)
 
     /** Turn `expected` into a dependent function when `actual` is dependent. */
@@ -607,9 +607,9 @@ class CheckCaptures extends Recheck, SymTransformer:
       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)
+        case expected @ defn.FunctionOf(args, resultType, isContextual)
           if defn.isNonRefinedFunction(expected) && defn.isFunctionType(actual) && !defn.isNonRefinedFunction(actual) =>
-          val expected1 = toDepFun(args, resultType, isContextual, isErased)
+          val expected1 = toDepFun(args, resultType, isContextual)
           expected1
         case _ =>
           expected
@@ -675,7 +675,7 @@ class CheckCaptures extends Recheck, SymTransformer:
 
         try
           val (eargs, eres) = expected.dealias.stripCapturing match
-            case defn.FunctionOf(eargs, eres, _, _) => (eargs, eres)
+            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)
@@ -739,7 +739,7 @@ class CheckCaptures extends Recheck, SymTransformer:
             case actual @ AppliedType(tycon, args) if defn.isNonRefinedFunction(actual) =>
               adaptFun(actual, args.init, args.last, expected, covariant, insertBox,
                   (aargs1, ares1) => actual.derivedAppliedType(tycon, aargs1 :+ ares1))
-            case actual @ RefinedType(_, _, rinfo: MethodType) if defn.isFunctionType(actual) =>
+            case actual @ RefinedType(_, _, rinfo: MethodType) if defn.isFunctionOrPolyType(actual) =>
               // TODO Find a way to combine handling of generic and dependent function types (here and elsewhere)
               adaptFun(actual, rinfo.paramInfos, rinfo.resType, expected, covariant, insertBox,
                 (aargs1, ares1) =>
@@ -962,7 +962,7 @@ class CheckCaptures extends Recheck, SymTransformer:
             case CapturingType(parent, refs) =>
               healCaptureSet(refs)
               traverse(parent)
-            case tp @ RefinedType(parent, rname, rinfo: MethodType) if defn.isFunctionType(tp) =>
+            case tp @ RefinedType(parent, rname, rinfo: MethodType) if defn.isFunctionOrPolyType(tp) =>
               traverse(rinfo)
             case tp: TermLambda =>
               val saved = allowed
diff --git a/compiler/src/dotty/tools/dotc/cc/Setup.scala b/compiler/src/dotty/tools/dotc/cc/Setup.scala
index 461c18ea0980..5642ea99de1a 100644
--- a/compiler/src/dotty/tools/dotc/cc/Setup.scala
+++ b/compiler/src/dotty/tools/dotc/cc/Setup.scala
@@ -12,6 +12,7 @@ import transform.Recheck.*
 import CaptureSet.IdentityCaptRefMap
 import Synthetics.isExcluded
 import util.Property
+import dotty.tools.dotc.core.Annotations.Annotation
 
 /** A tree traverser that prepares a compilation unit to be capture checked.
  *  It does the following:
@@ -38,7 +39,6 @@ extends tpd.TreeTraverser:
   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)
 
@@ -54,7 +54,7 @@ extends tpd.TreeTraverser:
         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) =>
+      case tp1 @ RefinedType(_, _, rinfo: MethodType) if defn.isFunctionOrPolyType(tp1) =>
         val boxedRinfo = recur(rinfo)
         if boxedRinfo eq rinfo then tp
         else boxedRinfo.toFunctionType(isJava = false, alwaysDependent = true)
@@ -231,7 +231,7 @@ extends tpd.TreeTraverser:
                 tp.derivedAppliedType(tycon1, args1 :+ res1)
           else
             tp.derivedAppliedType(tycon1, args.mapConserve(arg => this(arg)))
-        case tp @ RefinedType(core, rname, rinfo) if defn.isFunctionType(tp) =>
+        case tp @ RefinedType(core, rname, rinfo: MethodType) if defn.isFunctionOrPolyType(tp) =>
           val rinfo1 = apply(rinfo)
           if rinfo1 ne rinfo then rinfo1.toFunctionType(isJava = false, alwaysDependent = true)
           else tp
@@ -260,7 +260,13 @@ extends tpd.TreeTraverser:
   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)
+      defn.FunctionOf(
+        AnnotatedType(
+          defn.CanThrowClass.typeRef.appliedTo(exc), 
+          Annotation(defn.ErasedParamAnnot, defn.CanThrowClass.span)) :: Nil,
+        res,
+        isContextual = true
+      )
     case _ => tp
 
   private def expandThrowsAliases(using Context) = new TypeMap:
@@ -323,7 +329,7 @@ extends tpd.TreeTraverser:
               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) =>
+      case tp @ RefinedType(parent, nme.apply, rinfo: MethodType) if defn.isFunctionOrPolyType(tp) =>
         propagateDepFunctionResult(mapOver(tp), currentCs ++ outerCs)
           .capturing(outerCs)
       case _ =>
diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
index 8c3f2ad89ca1..20a1d59316eb 100644
--- a/compiler/src/dotty/tools/dotc/core/Definitions.scala
+++ b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -86,7 +86,7 @@ class Definitions {
     newPermanentClassSymbol(ScalaPackageClass, name, Artifact, completer).entered
   }
 
-  /** The trait FunctionN, ContextFunctionN, ErasedFunctionN or ErasedContextFunction, for some N
+  /** The trait FunctionN and ContextFunctionN for some N
    *  @param  name   The name of the trait to be created
    *
    *  FunctionN traits follow this template:
@@ -104,21 +104,6 @@ class Definitions {
    *      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]
@@ -149,8 +134,7 @@ class Definitions {
           val resParamRef = enterTypeParam(cls, paramNamePrefix ++ "R", Covariant, decls).typeRef
           val methodType = MethodType.companion(
             isContextual = name.isContextFunction,
-            isImplicit = false,
-            isErased = name.isErasedFunction)
+            isImplicit = false)
           decls.enter(newMethod(cls, nme.apply, methodType(argParamRefs, resParamRef), Deferred))
           denot.info =
             ClassInfo(ScalaPackageClass.thisType, cls, ObjectType :: Nil, decls)
@@ -1109,15 +1093,23 @@ class Definitions {
     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
+    def apply(args: List[Type], resultType: Type, isContextual: Boolean = false)(using Context): Type =
+      val mt = MethodType.companion(isContextual, false)(args, resultType)
+      if mt.hasErasedParams then
+        RefinedType(ErasedFunctionClass.typeRef, nme.apply, mt)
+      else
+        FunctionType(args.length, isContextual).appliedTo(args ::: resultType :: Nil)
+    def unapply(ft: Type)(using Context): Option[(List[Type], Type, Boolean)] = {
+      ft.dealias match
+        case RefinedType(parent, nme.apply, mt: MethodType) if isErasedFunctionType(parent) =>
+          Some(mt.paramInfos, mt.resType, mt.isContextualMethod)
+        case _ =>
+          val tsym = ft.dealias.typeSymbol
+          if isFunctionSymbol(tsym) && ft.isRef(tsym) then
+            val targs = ft.dealias.argInfos
+            if (targs.isEmpty) None
+            else Some(targs.init, targs.last, tsym.name.isContextFunction)
+          else None
     }
   }
 
@@ -1436,24 +1428,22 @@ class Definitions {
       classRefs(n).nn
   end FunType
 
-  private def funTypeIdx(isContextual: Boolean, isErased: Boolean, isImpure: Boolean): Int =
+  private def funTypeIdx(isContextual: Boolean, isImpure: Boolean): Int =
       (if isContextual then 1 else 0)
-    + (if isErased     then 2 else 0)
-    + (if isImpure     then 4 else 0)
+    + (if isImpure     then 2 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
+    for contxt <- 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)
+      arr(funTypeIdx(contxt, 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
+  def FunctionSymbol(n: Int, isContextual: Boolean = false, isImpure: Boolean = false)(using Context): Symbol =
+    funTypeArray(funTypeIdx(isContextual, isImpure))(n).symbol
 
   @tu lazy val Function0_apply: Symbol = Function0.requiredMethod(nme.apply)
   @tu lazy val ContextFunction0_apply: Symbol = ContextFunction0.requiredMethod(nme.apply)
@@ -1463,12 +1453,14 @@ class Definitions {
   @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
+  def FunctionType(n: Int, isContextual: Boolean = false, isImpure: Boolean = false)(using Context): TypeRef =
+    FunctionSymbol(n, isContextual && !ctx.erasedTypes, isImpure).typeRef
 
   lazy val PolyFunctionClass = requiredClass("scala.PolyFunction")
   def PolyFunctionType = PolyFunctionClass.typeRef
 
+  lazy val ErasedFunctionClass = requiredClass("scala.runtime.ErasedFunction")
+
   /** 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 =>
@@ -1501,8 +1493,6 @@ class Definitions {
    *   - 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
 
@@ -1521,12 +1511,6 @@ class Definitions {
    */
   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
@@ -1563,8 +1547,7 @@ class Definitions {
    */
   def functionTypeErasure(cls: Symbol): Type =
     val arity = scalaClassName(cls).functionArity
-    if cls.name.isErasedFunction then FunctionType(0)
-    else if arity > 22 then FunctionXXLClass.typeRef
+    if arity > 22 then FunctionXXLClass.typeRef
     else if arity >= 0 then FunctionType(arity)
     else NoType
 
@@ -1704,16 +1687,29 @@ class Definitions {
     arity >= 0
     && isFunctionClass(sym)
     && tp.isRef(
-        FunctionType(arity, sym.name.isContextFunction, sym.name.isErasedFunction).typeSymbol,
+        FunctionType(arity, sym.name.isContextFunction).typeSymbol,
         skipRefined = false)
   end isNonRefinedFunction
 
-  /** Is `tp` a representation of a (possibly dependent) function type or an alias of such? */
+  /** Returns whether `tp` is an instance or a refined instance of:
+   *  - scala.FunctionN
+   *  - scala.ContextFunctionN
+   */
   def isFunctionType(tp: Type)(using Context): Boolean =
     isNonRefinedFunction(tp.dropDependentRefinement)
 
+  /** Is `tp` a specialized, refined function type? Either an `ErasedFunction` or a `PolyFunction`. */
+  def isRefinedFunctionType(tp: Type)(using Context): Boolean =
+    tp.derivesFrom(defn.PolyFunctionClass) || isErasedFunctionType(tp)
+
+  /** Returns whether `tp` is an instance or a refined instance of:
+   *  - scala.FunctionN
+   *  - scala.ContextFunctionN
+   *  - ErasedFunction
+   *  - PolyFunction
+   */
   def isFunctionOrPolyType(tp: Type)(using Context): Boolean =
-    isFunctionType(tp) || (tp.typeSymbol eq defn.PolyFunctionClass)
+    isFunctionType(tp) || isRefinedFunctionType(tp)
 
   private def withSpecMethods(cls: ClassSymbol, bases: List[Name], paramTypes: Set[TypeRef]) =
     for base <- bases; tp <- paramTypes do
@@ -1802,7 +1798,7 @@ class Definitions {
   @tu lazy val FunctionSpecializedApplyNames: collection.Set[Name] =
     Function0SpecializedApplyNames ++ Function1SpecializedApplyNames ++ Function2SpecializedApplyNames
 
-  def functionArity(tp: Type)(using Context): Int = tp.dropDependentRefinement.dealias.argInfos.length - 1
+  def functionArity(tp: Type)(using Context): Int = tp.functionArgInfos.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:
@@ -1814,6 +1810,8 @@ class Definitions {
     tp.stripTypeVar.dealias match
       case tp1: TypeParamRef if ctx.typerState.constraint.contains(tp1) =>
         asContextFunctionType(TypeComparer.bounds(tp1).hiBound)
+      case tp1 @ RefinedType(parent, nme.apply, mt: MethodType) if isErasedFunctionType(parent) && mt.isContextualMethod =>
+        tp1
       case tp1 =>
         if tp1.typeSymbol.name.isContextFunction && isFunctionType(tp1) then tp1
         else NoType
@@ -1827,18 +1825,28 @@ class Definitions {
    *  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)] =
+    def unapply(tp: Type)(using Context): Option[(List[Type], Type, List[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
+        asContextFunctionType(tp) match
+          case RefinedType(parent, nme.apply, mt: MethodType) if isErasedFunctionType(parent) =>
+            Some((mt.paramInfos, mt.resType, mt.erasedParams))
+          case tp1 if tp1.exists =>
+            val args = tp1.functionArgInfos
+            val erasedParams = erasedFunctionParameters(tp1)
+            Some((args.init, args.last, erasedParams))
+          case _ => None
+
+  /* Returns a list of erased booleans marking whether parameters are erased, for a function type. */
+  def erasedFunctionParameters(tp: Type)(using Context): List[Boolean] = tp.dealias match {
+    case RefinedType(parent, nme.apply, mt: MethodType) => mt.erasedParams
+    case tp if isFunctionType(tp) => List.fill(functionArity(tp)) { false }
+    case _ => Nil
+  }
 
   def isErasedFunctionType(tp: Type)(using Context): Boolean =
-    tp.dealias.typeSymbol.name.isErasedFunction && isFunctionType(tp)
+    tp.derivesFrom(defn.ErasedFunctionClass)
 
   /** A whitelist of Scala-2 classes that are known to be pure */
   def isAssuredNoInits(sym: Symbol): Boolean =
diff --git a/compiler/src/dotty/tools/dotc/core/Denotations.scala b/compiler/src/dotty/tools/dotc/core/Denotations.scala
index 723f9408d805..82368fd4dbf5 100644
--- a/compiler/src/dotty/tools/dotc/core/Denotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/Denotations.scala
@@ -545,8 +545,7 @@ object Denotations {
         tp2 match
           case tp2: MethodType
           if TypeComparer.matchingMethodParams(tp1, tp2)
-             && tp1.isImplicitMethod == tp2.isImplicitMethod
-             && tp1.isErasedMethod == tp2.isErasedMethod =>
+             && tp1.isImplicitMethod == tp2.isImplicitMethod =>
             val resType = infoMeet(tp1.resType, tp2.resType.subst(tp2, tp1), safeIntersection)
             if resType.exists then
               tp1.derivedLambdaType(mergeParamNames(tp1, tp2), tp1.paramInfos, resType)
diff --git a/compiler/src/dotty/tools/dotc/core/NameOps.scala b/compiler/src/dotty/tools/dotc/core/NameOps.scala
index 4e075953d7fa..04440c9e9b39 100644
--- a/compiler/src/dotty/tools/dotc/core/NameOps.scala
+++ b/compiler/src/dotty/tools/dotc/core/NameOps.scala
@@ -214,7 +214,7 @@ object NameOps {
             if str == mustHave then found = true
             idx + str.length
           else idx
-        skip(skip(skip(0, "Impure"), "Erased"), "Context") == suffixStart
+        skip(skip(0, "Impure"), "Context") == suffixStart
         && found
       }
 
@@ -225,10 +225,11 @@ object NameOps {
     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
+    /** Is a function name, i.e one of FunctionXXL, FunctionN, ContextFunctionN, ImpureFunctionN, ImpureContextFunctionN for N >= 0
      */
     def isFunction(using Context): Boolean =
-      (name eq tpnme.FunctionXXL) || checkedFunArity(functionSuffixStart) >= 0
+      (name eq tpnme.FunctionXXL)
+      || checkedFunArity(functionSuffixStart) >= 0
 
     /** Is a function name
      *    - FunctionN for N >= 0
@@ -241,14 +242,11 @@ object NameOps {
       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
diff --git a/compiler/src/dotty/tools/dotc/core/NamerOps.scala b/compiler/src/dotty/tools/dotc/core/NamerOps.scala
index db6f72590818..dc09edd79781 100644
--- a/compiler/src/dotty/tools/dotc/core/NamerOps.scala
+++ b/compiler/src/dotty/tools/dotc/core/NamerOps.scala
@@ -42,10 +42,10 @@ object NamerOps:
       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)
+        val (isContextual, isImplicit) =
+          if params.isEmpty then (false, false)
+          else (params.head.is(Given), params.head.is(Implicit))
+        val make = MethodType.companion(isContextual = isContextual, isImplicit = isImplicit)
         if isJava then
           for param <- params do
             if param.info.isDirectRef(defn.ObjectClass) then param.info = defn.AnyType
diff --git a/compiler/src/dotty/tools/dotc/core/StdNames.scala b/compiler/src/dotty/tools/dotc/core/StdNames.scala
index 92f2e55a49bf..27e97a92b48e 100644
--- a/compiler/src/dotty/tools/dotc/core/StdNames.scala
+++ b/compiler/src/dotty/tools/dotc/core/StdNames.scala
@@ -212,6 +212,7 @@ object StdNames {
     final val Throwable: N           = "Throwable"
     final val IOOBException: N       = "IndexOutOfBoundsException"
     final val FunctionXXL: N         = "FunctionXXL"
+    final val ErasedFunction: N      = "ErasedFunction"
 
     final val Abs: N                  = "Abs"
     final val And: N                  = "&&"
diff --git a/compiler/src/dotty/tools/dotc/core/TypeApplications.scala b/compiler/src/dotty/tools/dotc/core/TypeApplications.scala
index 7c25ecd21ebf..2e8aee4df96c 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeApplications.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeApplications.scala
@@ -9,9 +9,11 @@ import SymDenotations.LazyType
 import Decorators._
 import util.Stats._
 import Names._
+import StdNames.nme
 import Flags.{Module, Provisional}
 import dotty.tools.dotc.config.Config
 import cc.boxedUnlessFun
+import dotty.tools.dotc.transform.TypeUtils.isErasedValueType
 
 object TypeApplications {
 
@@ -503,6 +505,14 @@ class TypeApplications(val self: Type) extends AnyVal {
     case AppliedType(tycon, args) => args.boxedUnlessFun(tycon)
     case _ => Nil
 
+  /** If this is an encoding of a function type, return its arguments, otherwise return Nil.
+   *  Handles `ErasedFunction`s and poly functions gracefully.
+   */
+  final def functionArgInfos(using Context): List[Type] = self.dealias match
+    case RefinedType(parent, nme.apply, mt: MethodType) if defn.isErasedFunctionType(parent) => (mt.paramInfos :+ mt.resultType)
+    case RefinedType(parent, nme.apply, mt: MethodType) if parent.typeSymbol eq defn.PolyFunctionClass => (mt.paramInfos :+ mt.resultType)
+    case _ => self.dropDependentRefinement.dealias.argInfos
+
   /** Argument types where existential types in arguments are disallowed */
   def argTypes(using Context): List[Type] = argInfos mapConserve noBounds
 
diff --git a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
index 9e8d18765352..f097bd160fdd 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
@@ -2119,7 +2119,10 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
       case nil =>
         formals2.isEmpty
     }
-    loop(tp1.paramInfos, tp2.paramInfos)
+    // If methods have erased parameters, then the erased parameters must match
+    val erasedValid = (!tp1.hasErasedParams && !tp2.hasErasedParams) || (tp1.erasedParams == tp2.erasedParams)
+
+    erasedValid && loop(tp1.paramInfos, tp2.paramInfos)
   }
 
   /** Do the parameter types of `tp1` and `tp2` match in a way that allows `tp1`
diff --git a/compiler/src/dotty/tools/dotc/core/TypeErasure.scala b/compiler/src/dotty/tools/dotc/core/TypeErasure.scala
index 67839d10c8cd..9bcb3eca36bb 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeErasure.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeErasure.scala
@@ -536,7 +536,14 @@ object TypeErasure {
     val paramss = res.paramNamess
     assert(paramss.length == 1)
     erasure(defn.FunctionType(paramss.head.length,
-      isContextual = res.isImplicitMethod, isErased = res.isErasedMethod))
+      isContextual = res.isImplicitMethod))
+
+  def eraseErasedFunctionApply(erasedFn: MethodType)(using Context): Type =
+    val fnType = defn.FunctionType(
+      n = erasedFn.erasedParams.count(_ == false),
+      isContextual = erasedFn.isContextualMethod,
+    )
+    erasure(fnType)
 }
 
 import TypeErasure._
@@ -613,6 +620,8 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
       defn.FunctionType(0)
     case RefinedType(parent, nme.apply, refinedInfo) if parent.typeSymbol eq defn.PolyFunctionClass =>
       erasePolyFunctionApply(refinedInfo)
+    case RefinedType(parent, nme.apply, refinedInfo: MethodType) if defn.isErasedFunctionType(parent) =>
+      eraseErasedFunctionApply(refinedInfo)
     case tp: TypeProxy =>
       this(tp.underlying)
     case tp @ AndType(tp1, tp2) =>
@@ -639,7 +648,13 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
     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 (names, formals0) = if tp.hasErasedParams then
+        tp.paramNames
+          .zip(tp.paramInfos)
+          .zip(tp.erasedParams)
+          .collect{ case (param, isErased) if !isErased => param }
+          .unzip
+      else (tp.paramNames, tp.paramInfos)
       val formals = formals0.mapConserve(paramErasure)
       eraseResult(tp.resultType) match {
         case rt: MethodType =>
@@ -871,6 +886,8 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
         // because RefinedTypes <: TypeProxy and it would be caught by
         // the case immediately below
         sigName(this(tp))
+      case tp @ RefinedType(parent, nme.apply, refinedInfo) if defn.isErasedFunctionType(parent) =>
+        sigName(this(tp))
       case tp: TypeProxy =>
         sigName(tp.underlying)
       case tp: WildcardType =>
diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index c05bb164834d..c660ef657b13 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -43,6 +43,7 @@ import scala.annotation.internal.sharable
 import scala.annotation.threadUnsafe
 
 import dotty.tools.dotc.transform.SymUtils._
+import dotty.tools.dotc.transform.TypeUtils.isErasedClass
 
 object Types {
 
@@ -425,7 +426,7 @@ object Types {
     def isContextualMethod: Boolean = false
 
     /** Is this a MethodType for which the parameters will not be used? */
-    def isErasedMethod: Boolean = false
+    def hasErasedParams(using Context): Boolean = false
 
     /** Is this a match type or a higher-kinded abstraction of one?
      */
@@ -1180,7 +1181,8 @@ object Types {
 
     /** Remove all AnnotatedTypes wrapping this type.
      */
-    def stripAnnots(using Context): Type = this
+    def stripAnnots(keep: Annotation => Context ?=> Boolean)(using Context): Type = this
+    final def stripAnnots(using Context): Type = stripAnnots(_ => false)
 
     /** Strip TypeVars and Annotation and CapturingType wrappers */
     def stripped(using Context): Type = this
@@ -1470,7 +1472,7 @@ object Types {
 
     /** 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 RefinedType(parent, nme.apply, mt) if defn.isNonRefinedFunction(parent) => parent
       case tp => tp
     }
 
@@ -1712,6 +1714,8 @@ object Types {
         else NoType
       case t if defn.isNonRefinedFunction(t) =>
         t
+      case t if defn.isErasedFunctionType(t) =>
+        t
       case t @ SAMType(_) =>
         t
       case _ =>
@@ -1839,15 +1843,15 @@ object Types {
       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)
+          result1, isContextual)
+        if alwaysDependent || mt.isResultDependent then
+          RefinedType(funType, nme.apply, mt)
         else funType
     }
 
@@ -3648,6 +3652,8 @@ object Types {
 
     def companion: LambdaTypeCompanion[ThisName, PInfo, This]
 
+    def erasedParams(using Context) = List.fill(paramInfos.size)(false)
+
     /** The type `[tparams := paramRefs] tp`, where `tparams` can be
      *  either a list of type parameter symbols or a list of lambda parameters
      *
@@ -3725,7 +3731,11 @@ object Types {
             else Signature(tp, sourceLanguage)
         this match
           case tp: MethodType =>
-            val params = if (isErasedMethod) Nil else tp.paramInfos
+            val params = if (hasErasedParams)
+              tp.paramInfos
+                .zip(tp.erasedParams)
+                .collect { case (param, isErased) if !isErased => param }
+            else tp.paramInfos
             resultSignature.prependTermParams(params, sourceLanguage)
           case tp: PolyType =>
             resultSignature.prependTypeParams(tp.paramNames.length)
@@ -3932,16 +3942,14 @@ object Types {
     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)
+      companion.eq(ImplicitMethodType) || isContextualMethod
+    final override def hasErasedParams(using Context): Boolean =
+      erasedParams.contains(true)
     final override def isContextualMethod: Boolean =
-      companion.eq(ContextualMethodType) ||
-      companion.eq(ErasedContextualMethodType)
+      companion.eq(ContextualMethodType)
+
+    override def erasedParams(using Context): List[Boolean] =
+      paramInfos.map(p => p.hasAnnotation(defn.ErasedParamAnnot))
 
     protected def prefixString: String = companion.prefixString
   }
@@ -4038,7 +4046,7 @@ object Types {
          tl => tl.integrate(params, resultType))
     end fromSymbols
 
-    final def apply(paramNames: List[TermName])(paramInfosExp: MethodType => List[Type], resultTypeExp: MethodType => Type)(using Context): MethodType =
+    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 = {
@@ -4053,19 +4061,14 @@ object Types {
   }
 
   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
+    def companion(isContextual: Boolean = false, isImplicit: Boolean = false): MethodTypeCompanion =
+      if (isContextual) ContextualMethodType
+      else if (isImplicit) ImplicitMethodType
+      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 {
@@ -5280,7 +5283,10 @@ object Types {
     override def stripTypeVar(using Context): Type =
       derivedAnnotatedType(parent.stripTypeVar, annot)
 
-    override def stripAnnots(using Context): Type = parent.stripAnnots
+    override def stripAnnots(keep: Annotation => (Context) ?=> Boolean)(using Context): Type =
+      val p = parent.stripAnnots(keep)
+      if keep(annot) then derivedAnnotatedType(p, annot)
+      else p
 
     override def stripped(using Context): Type = parent.stripped
 
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
index bef28545592a..8a396921f32b 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -287,7 +287,6 @@ class TreePickler(pickler: TastyPickler) {
       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")
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
index dfe04dbe6d2b..9078a8959112 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
@@ -249,7 +249,6 @@ class TreeUnpickler(reader: TastyReader,
       while currentAddr != end do // avoid boxing the mods
         readByte() match
           case IMPLICIT => mods |= Implicit
-          case ERASED   => mods |= Erased
           case GIVEN    => mods |= Given
       (names, mods)
 
@@ -406,9 +405,7 @@ class TreeUnpickler(reader: TastyReader,
             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 =>
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 479ae1fa9095..d1b0c6cba097 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -190,6 +190,8 @@ object Parsers {
     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
+    // Are we seeing an `erased` soft keyword that will not be an identifier?
+    def isErasedKw = isErased && in.isSoftModifierInParamModifierPosition
     def isSimpleLiteral =
       simpleLiteralTokens.contains(in.token)
       || isIdent(nme.raw.MINUS) && numericLitTokens.contains(in.lookahead.token)
@@ -463,6 +465,15 @@ object Parsers {
         case _ =>
           fail()
 
+    /** Checks that tuples don't contain a parameter. */
+    def checkNonParamTuple(t: Tree) = t match
+      case Tuple(ts) => ts.collectFirst {
+        case param: ValDef =>
+          syntaxError(em"invalid parameter definition syntax in tuple value", param.span)
+      }
+      case _ =>
+
+
     /** Convert (qual)ident to type identifier
      */
     def convertToTypeId(tree: Tree): Tree = tree match {
@@ -1425,13 +1436,30 @@ object Parsers {
      */
     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
+    private def getFunction(tree: Tree): Option[Function] = tree match {
+      case Parens(tree1) => getFunction(tree1)
+      case Block(Nil, tree1) => getFunction(tree1)
+      case t: Function => Some(t)
+      case _ => None
     }
 
+    private def checkFunctionNotErased(f: Function, context: String) =
+      def fail(span: Span) =
+        syntaxError(em"Implementation restriction: erased parameters are not supported in $context", span)
+      // erased parameter in type
+      val hasErasedParam = f match
+        case f: FunctionWithMods => f.hasErasedParams
+        case _ => false
+      if hasErasedParam then
+        fail(f.span)
+      // erased parameter in term
+      val hasErasedMods = f.args.collectFirst {
+        case v: ValDef if v.mods.is(Flags.Erased) => v
+      }
+      hasErasedMods match
+        case Some(param) => fail(param.span)
+        case _ =>
+
     /** CaptureRef  ::=  ident | `this`
      */
     def captureRef(): Tree =
@@ -1464,6 +1492,7 @@ object Parsers {
     def typ(): Tree =
       val start = in.offset
       var imods = Modifiers()
+      var erasedArgs: ListBuffer[Boolean] = ListBuffer()
       def functionRest(params: List[Tree]): Tree =
         val paramSpan = Span(start, in.lastOffset)
         atSpan(start, in.offset) {
@@ -1495,10 +1524,10 @@ object Parsers {
               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
+          else if imods.isOneOf(Given | Impure) || erasedArgs.contains(true) then
             if imods.is(Given) && params.isEmpty then
               syntaxError(em"context function types require at least one parameter", paramSpan)
-            FunctionWithMods(params, resultType, imods)
+            FunctionWithMods(params, resultType, imods, erasedArgs.toList)
           else if !ctx.settings.YkindProjector.isDefault then
             val (newParams :+ newResultType, tparams) = replaceKindProjectorPlaceholders(params :+ resultType): @unchecked
             lambdaAbstract(tparams, Function(newParams, newResultType))
@@ -1516,17 +1545,30 @@ object Parsers {
             functionRest(Nil)
           }
           else {
-            if isErased then imods = addModifier(imods)
             val paramStart = in.offset
+            def addErased() =
+              erasedArgs.addOne(isErasedKw)
+              if isErasedKw then { in.skipToken(); }
+            addErased()
             val ts = in.currentRegion.withCommasExpected {
               funArgType() match
                 case Ident(name) if name != tpnme.WILDCARD && in.isColon =>
                   isValParamList = true
+                  def funParam(start: Offset, mods: Modifiers) = {
+                    atSpan(start) {
+                      addErased()
+                      typedFunParam(in.offset, ident(), imods)
+                    }
+                  }
                   commaSeparatedRest(
                     typedFunParam(paramStart, name.toTermName, imods),
-                    () => typedFunParam(in.offset, ident(), imods))
+                    () => funParam(in.offset, imods))
                 case t =>
-                  commaSeparatedRest(t, funArgType)
+                  def funParam() = {
+                      addErased()
+                      funArgType()
+                  }
+                  commaSeparatedRest(t, funParam)
             }
             accept(RPAREN)
             if isValParamList || in.isArrow || isPureArrow then
@@ -1557,11 +1599,13 @@ object Parsers {
             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)
+              getFunction(body) match {
+                case Some(f) =>
+                  checkFunctionNotErased(f, "poly function")
+                  PolyFunction(tparams, body)
+                case None =>
+                  syntaxError(em"Implementation restriction: polymorphic function types must have a value parameter", arrowOffset)
+                  Ident(nme.ERROR.toTypeName)
               }
             }
           }
@@ -1573,14 +1617,17 @@ object Parsers {
         else infixType()
 
       in.token match
-        case ARROW | CTXARROW => functionRest(t :: Nil)
+        case ARROW | CTXARROW =>
+          erasedArgs.addOne(false)
+          functionRest(t :: Nil)
         case MATCH => matchType(t)
         case FORSOME => syntaxError(ExistentialTypesNoLongerSupported()); t
         case _ =>
           if isPureArrow then
+            erasedArgs.addOne(false)
             functionRest(t :: Nil)
           else
-            if (imods.is(Erased) && !t.isInstanceOf[FunctionWithMods])
+            if (erasedArgs.contains(true) && !t.isInstanceOf[FunctionWithMods])
               syntaxError(ErasedTypesCanOnlyBeFunctionTypes(), implicitKwPos(start))
             t
     end typ
@@ -2078,24 +2125,22 @@ object Parsers {
 
     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)
-            }
+            getFunction(body) match
+              case Some(f) =>
+                checkFunctionNotErased(f, "poly function")
+                PolyFunction(tparams, f)
+              case None =>
+                syntaxError(em"Implementation restriction: polymorphic function literals must have a value parameter", arrowOffset)
+                errorTermTree(arrowOffset)
           }
         case _ =>
           val saved = placeholderParams
@@ -2113,7 +2158,9 @@ object Parsers {
           else if isWildcard(t) then
             placeholderParams = placeholderParams ::: saved
             t
-          else wrapPlaceholders(t)
+          else
+            checkNonParamTuple(t)
+            wrapPlaceholders(t)
     }
 
     def expr1(location: Location = Location.ElseWhere): Tree = in.token match
@@ -2305,10 +2352,8 @@ object Parsers {
         if in.token == RPAREN then
           Nil
         else
-          var mods1 = mods
-          if isErased then mods1 = addModifier(mods1)
           try
-            commaSeparated(() => binding(mods1))
+            commaSeparated(() => binding(mods))
           finally
             accept(RPAREN)
       else {
@@ -2332,10 +2377,13 @@ object Parsers {
         (atSpan(start) { makeParameter(name, t, mods) }) :: Nil
       }
 
-    /**  Binding           ::= (id | `_') [`:' Type]
+    /**  Binding           ::= [`erased`] (id | `_') [`:' Type]
      */
     def binding(mods: Modifiers): Tree =
-      atSpan(in.offset) { makeParameter(bindingName(), typedOpt(), mods) }
+      atSpan(in.offset) {
+        val mods1 = if isErasedKw then addModifier(mods) else mods
+        makeParameter(bindingName(), typedOpt(), mods1)
+      }
 
     def bindingName(): TermName =
       if (in.token == USCORE) {
@@ -2532,6 +2580,7 @@ object Parsers {
       else in.currentRegion.withCommasExpected {
         var isFormalParams = false
         def exprOrBinding() =
+          if isErasedKw then isFormalParams = true
           if isFormalParams then binding(Modifiers())
           else
             val t = exprInParens()
@@ -3175,7 +3224,7 @@ object Parsers {
       val paramFlags = if ofClass then LocalParamAccessor else Param
       tps.map(makeSyntheticParameter(nextIdx, _, paramFlags | Synthetic | impliedMods.flags))
 
-    /** ClsTermParamClause    ::=  ‘(’ [‘erased’] ClsParams ‘)’ | UsingClsTermParamClause
+    /** ClsTermParamClause    ::=  ‘(’ ClsParams ‘)’ | UsingClsTermParamClause
      *  UsingClsTermParamClause::= ‘(’ ‘using’ [‘erased’] (ClsParams | ContextTypes) ‘)’
      *  ClsParams         ::=  ClsParam {‘,’ ClsParam}
      *  ClsParam          ::=  {Annotation}
@@ -3184,10 +3233,10 @@ object Parsers {
      *                      | UsingParamClause
      *
      *  DefTermParamClause::= [nl] ‘(’ [DefTermParams] ‘)’
-     *  UsingParamClause  ::=  ‘(’ ‘using’ [‘erased’] (DefTermParams | ContextTypes) ‘)’
+     *  UsingParamClause  ::=  ‘(’ ‘using’ (DefTermParams | ContextTypes) ‘)’
      *  DefImplicitClause ::=  [nl] ‘(’ ‘implicit’ DefTermParams ‘)’
      *  DefTermParams     ::=  DefTermParam {‘,’ DefTermParam}
-     *  DefTermParam      ::=  {Annotation} [‘inline’] Param
+     *  DefTermParam      ::=  {Annotation} [‘erased’] [‘inline’] Param
      *
      *  Param             ::=  id `:' ParamType [`=' Expr]
      *
@@ -3211,12 +3260,12 @@ object Parsers {
         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 isErasedKw then
+          mods = addModifier(mods)
         if (ofClass) {
           mods = addFlag(modifiers(start = mods), ParamAccessor)
           mods =
@@ -3227,7 +3276,7 @@ object Parsers {
               val mod = atSpan(in.skipToken()) { Mod.Var() }
               addMod(mods, mod)
             else
-              if (!(mods.flags &~ (ParamAccessor | Inline | impliedMods.flags)).isEmpty)
+              if (!(mods.flags &~ (ParamAccessor | Inline | Erased | impliedMods.flags)).isEmpty)
                 syntaxError(em"`val` or `var` expected")
               if (firstClause && ofCaseClass) mods
               else mods | PrivateLocal
@@ -3275,12 +3324,22 @@ object Parsers {
               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, numLeadParams, impliedMods)
+              val (firstParamMod, isParams) =
+                var mods = EmptyModifiers
+                if in.lookahead.isColon then
+                  (mods, true)
+                else
+                  if isErased then mods = addModifier(mods)
+                  val isParams =
+                    !impliedMods.is(Given)
+                    || startParamTokens.contains(in.token)
+                    || isIdent && (in.name == nme.inline || in.lookahead.isColon)
+                  (mods, isParams)
+              (if isParams then commaSeparated(() => param())
+              else contextTypes(ofClass, numLeadParams, impliedMods)) match {
+                case Nil => Nil
+                case (h :: t) => h.withAddedFlags(firstParamMod.flags) :: t
+              }
           checkVarArgsRules(clause)
           clause
       }
diff --git a/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala b/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
index 0da1993310c6..ee0062f77dcd 100644
--- a/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
@@ -120,10 +120,10 @@ class PlainPrinter(_ctx: Context) extends Printer {
     }
     (keyword ~ refinementNameString(rt) ~ toTextRHS(rt.refinedInfo)).close
 
-  protected def argText(arg: Type): Text = homogenizeArg(arg) match {
+  protected def argText(arg: Type, isErased: Boolean = false): Text = keywordText("erased ").provided(isErased) ~ (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).
@@ -235,7 +235,6 @@ class PlainPrinter(_ctx: Context) extends Printer {
         changePrec(GlobalPrec) {
           "("
           ~ keywordText("using ").provided(tp.isContextualMethod)
-          ~ keywordText("erased ").provided(tp.isErasedMethod)
           ~ keywordText("implicit ").provided(tp.isImplicitMethod && !tp.isContextualMethod)
           ~ paramsText(tp)
           ~ ")"
@@ -296,9 +295,10 @@ class PlainPrinter(_ctx: Context) extends Printer {
     "(" ~ 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), ", ")
+    val erasedParams = lam.erasedParams
+    def paramText(name: Name, tp: Type, erased: Boolean) =
+      keywordText("erased ").provided(erased) ~ toText(name) ~ lambdaHash(lam) ~ toTextRHS(tp, isParameter = true)
+    Text(lam.paramNames.lazyZip(lam.paramInfos).lazyZip(erasedParams).map(paramText), ", ")
   }
 
   protected def ParamRefNameString(name: Name): String = nameString(name)
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index 8ffb99f073fb..014e5ddf0d66 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -148,17 +148,16 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     def toTextTuple(args: List[Type]): Text =
       "(" ~ argsText(args) ~ ")"
 
-    def toTextFunction(args: List[Type], isGiven: Boolean, isErased: Boolean, isPure: Boolean): Text =
+    def toTextFunction(args: List[Type], isGiven: Boolean, isPure: Boolean): Text =
       changePrec(GlobalPrec) {
         val argStr: Text =
           if args.length == 2
              && !defn.isTupleNType(args.head)
-             && !isGiven && !isErased
+             && !isGiven
           then
             atPrec(InfixPrec) { argText(args.head) }
           else
             "("
-            ~ keywordText("erased ").provided(isErased)
             ~ argsText(args.init)
             ~ ")"
         argStr ~ " " ~ arrow(isGiven, isPure) ~ " " ~ argText(args.last)
@@ -168,7 +167,6 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case info: MethodType =>
         changePrec(GlobalPrec) {
           "("
-          ~ keywordText("erased ").provided(info.isErasedMethod)
           ~ paramsText(info)
           ~ ") "
           ~ arrow(info.isImplicitMethod, isPure)
@@ -226,7 +224,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
             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,
+              toTextFunction(args, tsym.name.isContextFunction,
                 isPure = Feature.pureFunsEnabled && !tsym.name.isImpureFunction)
             else if isInfixType(tp) then
               val l :: r :: Nil = args: @unchecked
@@ -289,7 +287,6 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case tp @ FunProto(args, resultType) =>
         "[applied to ("
         ~ keywordText("using ").provided(tp.isContextualMethod)
-        ~ keywordText("erased ").provided(tp.isErasedMethod)
         ~ argsTreeText(args)
         ~ ") returning "
         ~ toText(resultType)
@@ -650,27 +647,29 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           case str: Literal => strText(str)
         }
         toText(id) ~ "\"" ~ Text(segments map segmentText, "") ~ "\""
-      case Function(args, body) =>
+      case fn @ Function(args, body) =>
         var implicitSeen: Boolean = false
         var isGiven: Boolean = false
-        var isErased: Boolean = false
-        def argToText(arg: Tree) = arg match {
+        val erasedParams = fn match {
+          case fn: FunctionWithMods => fn.erasedParams
+          case _ => fn.args.map(_ => false)
+        }
+        def argToText(arg: Tree, isErased: Boolean) = 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)
+            val erasedText = if isErased then keywordStr("erased ") else ""
+            implicitText ~ erasedText ~ toText(name) ~ optAscription(tpt)
           case _ =>
             toText(arg)
         }
         val argsText = args match {
-          case (arg @ ValDef(_, tpt, _)) :: Nil if tpt.isEmpty => argToText(arg)
+          case (arg @ ValDef(_, tpt, _)) :: Nil if tpt.isEmpty => argToText(arg, erasedParams(0))
           case _ =>
             "("
-            ~ keywordText("erased ").provided(isErased)
-            ~ Text(args.map(argToText), ", ")
+            ~ Text(args.zip(erasedParams).map(argToText), ", ")
             ~ ")"
         }
         val isPure =
@@ -870,7 +869,6 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       "()"
     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, ", ") ~ "]"
@@ -1032,7 +1030,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       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
+    if (rawFlags.is(Param)) flagMask = flagMask &~ Given
     val flags = rawFlags & flagMask
     var flagsText = toTextFlags(sym, flags)
     val annotTexts =
diff --git a/compiler/src/dotty/tools/dotc/quoted/Interpreter.scala b/compiler/src/dotty/tools/dotc/quoted/Interpreter.scala
index 851e3c422460..aadfedd2417c 100644
--- a/compiler/src/dotty/tools/dotc/quoted/Interpreter.scala
+++ b/compiler/src/dotty/tools/dotc/quoted/Interpreter.scala
@@ -128,7 +128,7 @@ class Interpreter(pos: SrcPos, classLoader0: ClassLoader)(using Context):
       view.toList
 
     fnType.dealias match
-      case fnType: MethodType if fnType.isErasedMethod => interpretArgs(argss, fnType.resType)
+      case fnType: MethodType if fnType.hasErasedParams => interpretArgs(argss, fnType.resType)
       case fnType: MethodType =>
         val argTypes = fnType.paramInfos
         assert(argss.head.size == argTypes.size)
@@ -342,7 +342,7 @@ object Interpreter:
         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))
+          if (f.tpe.widenDealias.hasErasedParams) Some((fn, args1))
           else Some((fn, args2 :: args1))
         case TypeApply(Call0(fn, args), _) => Some((fn, args))
         case _ => None
diff --git a/compiler/src/dotty/tools/dotc/transform/Bridges.scala b/compiler/src/dotty/tools/dotc/transform/Bridges.scala
index e302170991f9..569b16681cde 100644
--- a/compiler/src/dotty/tools/dotc/transform/Bridges.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Bridges.scala
@@ -129,9 +129,12 @@ class Bridges(root: ClassSymbol, thisPhase: DenotTransformer)(using Context) {
           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 defn.ContextFunctionType(argTypes, resType, erasedParams) = tp: @unchecked
           val anonFun = newAnonFun(ctx.owner,
-            MethodType(if isErased then Nil else argTypes, resType),
+            MethodType(
+              argTypes.zip(erasedParams.padTo(argTypes.length, false))
+                      .flatMap((t, e) => if e then None else Some(t)),
+              resType),
             coord = ctx.owner.coord)
           anonFun.info = transformInfo(anonFun, anonFun.info)
 
diff --git a/compiler/src/dotty/tools/dotc/transform/ContextFunctionResults.scala b/compiler/src/dotty/tools/dotc/transform/ContextFunctionResults.scala
index 2ab910f6d06e..5863c360e728 100644
--- a/compiler/src/dotty/tools/dotc/transform/ContextFunctionResults.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ContextFunctionResults.scala
@@ -20,7 +20,7 @@ object ContextFunctionResults:
    */
   def annotateContextResults(mdef: DefDef)(using Context): Unit =
     def contextResultCount(rhs: Tree, tp: Type): Int = tp match
-      case defn.ContextFunctionType(_, resTpe, _) =>
+      case defn.ContextFunctionType(_, resTpe, erasedParams) if !erasedParams.contains(true) /* Only enable for non-erased functions */ =>
         rhs match
           case closureDef(meth) => 1 + contextResultCount(meth.rhs, resTpe)
           case _ => 0
@@ -58,7 +58,7 @@ object ContextFunctionResults:
    */
   def contextResultsAreErased(sym: Symbol)(using Context): Boolean =
     def allErased(tp: Type): Boolean = tp.dealias match
-      case defn.ContextFunctionType(_, resTpe, isErased) => isErased && allErased(resTpe)
+      case defn.ContextFunctionType(_, resTpe, erasedParams) => !erasedParams.contains(false) && allErased(resTpe)
       case _ => true
     contextResultCount(sym) > 0 && allErased(sym.info.finalResultType)
 
@@ -72,10 +72,8 @@ object ContextFunctionResults:
         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))
+      case defn.ContextFunctionType(argTypes, resType, erasedParams) =>
+        MethodType(argTypes, integrateContextResults(resType, crCount - 1))
 
   /** The total number of parameters of method `sym`, not counting
    *  erased parameters, but including context result parameters.
@@ -85,14 +83,16 @@ object ContextFunctionResults:
     def contextParamCount(tp: Type, crCount: Int): Int =
       if crCount == 0 then 0
       else
-        val defn.ContextFunctionType(params, resTpe, isErased) = tp: @unchecked
+        val defn.ContextFunctionType(params, resTpe, erasedParams) = tp: @unchecked
         val rest = contextParamCount(resTpe, crCount - 1)
-        if isErased then rest else params.length + rest
+        if erasedParams.contains(true) then erasedParams.count(_ == false) + 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
+        if mt.hasErasedParams then
+          mt.erasedParams.count(_ == false) + rest
+        else pnames.length + rest
       case _ => contextParamCount(tp, contextResultCount(sym))
 
     normalParamCount(sym.info)
@@ -133,4 +133,4 @@ object ContextFunctionResults:
       case _ =>
         false
 
-end ContextFunctionResults
\ No newline at end of file
+end ContextFunctionResults
diff --git a/compiler/src/dotty/tools/dotc/transform/ElimByName.scala b/compiler/src/dotty/tools/dotc/transform/ElimByName.scala
index 479a455b4aea..151e841f0e48 100644
--- a/compiler/src/dotty/tools/dotc/transform/ElimByName.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ElimByName.scala
@@ -15,6 +15,7 @@ import MegaPhase.*
 import Decorators.*
 import typer.RefChecks
 import reporting.trace
+import dotty.tools.dotc.core.Names.Name
 
 /** This phase implements the following transformations:
  *
@@ -79,11 +80,14 @@ class ElimByName extends MiniPhase, InfoTransformer:
     case ExprType(rt) if exprBecomesFunction(sym) =>
       defn.ByNameFunction(rt)
     case tp: MethodType =>
-      def exprToFun(tp: Type) = tp match
-        case ExprType(rt) => defn.ByNameFunction(rt)
+      def exprToFun(tp: Type, name: Name) = tp match
+        case ExprType(rt) =>
+          if rt.hasAnnotation(defn.ErasedParamAnnot) then
+            report.error(em"By-name parameter cannot be erased: $name", sym.srcPos)
+          defn.ByNameFunction(rt)
         case tp => tp
       tp.derivedLambdaType(
-        paramInfos = tp.paramInfos.mapConserve(exprToFun),
+        paramInfos = tp.paramInfos.zipWithConserve(tp.paramNames)(exprToFun),
         resType = transformInfo(tp.resType, sym))
     case tp: PolyType =>
       tp.derivedLambdaType(resType = transformInfo(tp.resType, sym))
diff --git a/compiler/src/dotty/tools/dotc/transform/Erasure.scala b/compiler/src/dotty/tools/dotc/transform/Erasure.scala
index 60affae38ad5..981dd5f60aea 100644
--- a/compiler/src/dotty/tools/dotc/transform/Erasure.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Erasure.scala
@@ -500,7 +500,7 @@ object Erasure {
         if isFunction && !ctx.settings.scalajs.value then
           val arity = implParamTypes.length
           val specializedFunctionalInterface =
-            if defn.isSpecializableFunctionSAM(implParamTypes, implResultType) then
+            if !implType.hasErasedParams && 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.
@@ -679,6 +679,8 @@ object Erasure {
             val qualTp = tree.qualifier.typeOpt.widen
             if qualTp.derivesFrom(defn.PolyFunctionClass) then
               erasePolyFunctionApply(qualTp.select(nme.apply).widen).classSymbol
+            else if defn.isErasedFunctionType(qualTp) then
+              eraseErasedFunctionApply(qualTp.select(nme.apply).widen.asInstanceOf[MethodType]).classSymbol
             else
               NoSymbol
           }
@@ -827,7 +829,10 @@ object Erasure {
       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 ownArgs = origFunType match
+        case mt: MethodType if mt.hasErasedParams =>
+          args.zip(mt.erasedParams).collect { case (arg, false) => arg }
+        case _ => args
       val fun1 = typedExpr(fun, AnyFunctionProto)
       fun1.tpe.widen match
         case mt: MethodType =>
diff --git a/compiler/src/dotty/tools/dotc/transform/GenericSignatures.scala b/compiler/src/dotty/tools/dotc/transform/GenericSignatures.scala
index 050abf7f3cb7..a1baeac272b9 100644
--- a/compiler/src/dotty/tools/dotc/transform/GenericSignatures.scala
+++ b/compiler/src/dotty/tools/dotc/transform/GenericSignatures.scala
@@ -311,7 +311,9 @@ object GenericSignatures {
         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 if t.hasErasedParams =>
+              t.paramInfos.zip(t.erasedParams).collect{ case (i, false) => i }
+                :: effectiveParamInfoss(t.resType)
             case t: MethodType => t.paramInfos :: effectiveParamInfoss(t.resType)
             case _ => Nil
           }
diff --git a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
index c56bac4d66af..87c6e294c104 100644
--- a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
@@ -315,7 +315,7 @@ object PickleQuotes {
               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 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)
diff --git a/compiler/src/dotty/tools/dotc/transform/PostTyper.scala b/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
index 2039a8f19558..574db18c9c7f 100644
--- a/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
@@ -296,19 +296,21 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
         case tree: Apply =>
           val methType = tree.fun.tpe.widen.asInstanceOf[MethodType]
           val app =
-            if (methType.isErasedMethod)
+            if (methType.hasErasedParams)
               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)))
+                tree.args.zip(methType.erasedParams).map((arg, isErased) =>
+                  if !isErased then arg
+                  else
+                    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 =
diff --git a/compiler/src/dotty/tools/dotc/transform/PruneErasedDefs.scala b/compiler/src/dotty/tools/dotc/transform/PruneErasedDefs.scala
index 568512207fde..17f2d11ccfec 100644
--- a/compiler/src/dotty/tools/dotc/transform/PruneErasedDefs.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PruneErasedDefs.scala
@@ -13,6 +13,7 @@ import ast.tpd
 import SymUtils._
 import config.Feature
 import Decorators.*
+import dotty.tools.dotc.core.Types.MethodType
 
 /** 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
@@ -38,8 +39,11 @@ class PruneErasedDefs extends MiniPhase with SymTransformer { thisTransform =>
     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))
+    tree.fun.tpe.widen match
+      case mt: MethodType if mt.hasErasedParams =>
+        cpy.Apply(tree)(tree.fun, tree.args.zip(mt.erasedParams).map((a, e) => if e then trivialErasedTree(a) else a))
+      case _ =>
+        tree
 
   override def transformValDef(tree: ValDef)(using Context): Tree =
     checkErasedInExperimental(tree.symbol)
diff --git a/compiler/src/dotty/tools/dotc/transform/SpecializeFunctions.scala b/compiler/src/dotty/tools/dotc/transform/SpecializeFunctions.scala
index c1f891d6293a..2248fbc8d570 100644
--- a/compiler/src/dotty/tools/dotc/transform/SpecializeFunctions.scala
+++ b/compiler/src/dotty/tools/dotc/transform/SpecializeFunctions.scala
@@ -70,7 +70,7 @@ class SpecializeFunctions extends MiniPhase {
   /** 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 =>
+      case Apply(fun: NameTree, args) if fun.name == nme.apply && args.size <= 3 && fun.symbol.maybeOwner.isType =>
         val argTypes = fun.tpe.widen.firstParamTypes.map(_.widenSingleton.dealias)
         val retType  = tree.tpe.widenSingleton.dealias
         val isSpecializable =
diff --git a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
index 133651fe08b2..52942ea719f9 100644
--- a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
@@ -445,10 +445,12 @@ object TreeChecker {
 
       // Polymorphic apply methods stay structural until Erasure
       val isPolyFunctionApply = (tree.name eq nme.apply) && tree.qualifier.typeOpt.derivesFrom(defn.PolyFunctionClass)
+      // Erased functions stay structural until Erasure
+      val isErasedFunctionApply = (tree.name eq nme.apply) && tree.qualifier.typeOpt.derivesFrom(defn.ErasedFunctionClass)
       // 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
+      if !(tree.isType || isPolyFunctionApply || isErasedFunctionApply || 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}")
diff --git a/compiler/src/dotty/tools/dotc/typer/Applications.scala b/compiler/src/dotty/tools/dotc/typer/Applications.scala
index a8abd868fdef..345a8693063b 100644
--- a/compiler/src/dotty/tools/dotc/typer/Applications.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Applications.scala
@@ -1978,7 +1978,7 @@ trait Applications extends Compatibility {
           val formals = ref.widen.firstParamTypes
           if formals.length > idx then
             formals(idx) match
-              case defn.FunctionOf(args, _, _, _) => args.length
+              case defn.FunctionOf(args, _, _) => args.length
               case _ => -1
           else -1
 
@@ -2062,7 +2062,7 @@ trait Applications extends Compatibility {
           if isDetermined(alts2) then alts2
           else resolveMapped(alts1, _.widen.appliedTo(targs1.tpes), pt1)
 
-      case defn.FunctionOf(args, resultType, _, _) =>
+      case defn.FunctionOf(args, resultType, _) =>
         narrowByTypes(alts, args, resultType)
 
       case pt =>
@@ -2225,7 +2225,7 @@ trait Applications extends Compatibility {
         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.FunctionOf(args, result, isImplicit) => args
             case defn.PartialFunctionOf(arg, result) => arg :: Nil
             case _ => Nil
           }
diff --git a/compiler/src/dotty/tools/dotc/typer/EtaExpansion.scala b/compiler/src/dotty/tools/dotc/typer/EtaExpansion.scala
index 46725f0fa6b2..b1513df777ec 100644
--- a/compiler/src/dotty/tools/dotc/typer/EtaExpansion.scala
+++ b/compiler/src/dotty/tools/dotc/typer/EtaExpansion.scala
@@ -285,8 +285,9 @@ object EtaExpansion extends LiftImpure {
     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))
+      if (mt.isContextualMethod) new untpd.FunctionWithMods(params, body, Modifiers(Given), mt.erasedParams)
+      else if (mt.isImplicitMethod) new untpd.FunctionWithMods(params, body, Modifiers(Implicit), mt.erasedParams)
+      else if (mt.hasErasedParams) new untpd.FunctionWithMods(params, body, Modifiers(), mt.erasedParams)
       else untpd.Function(params, body)
     if (defs.nonEmpty) untpd.Block(defs.toList map (untpd.TypedSplice(_)), fn) else fn
   }
diff --git a/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala b/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
index da785e32865a..bde279c582e6 100644
--- a/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
+++ b/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
@@ -372,7 +372,7 @@ object ProtoTypes {
 
     private def isUndefined(tp: Type): Boolean = tp match {
       case _: WildcardType => true
-      case defn.FunctionOf(args, result, _, _) => args.exists(isUndefined) || isUndefined(result)
+      case defn.FunctionOf(args, result, _) => args.exists(isUndefined) || isUndefined(result)
       case _ => false
     }
 
@@ -842,7 +842,7 @@ object ProtoTypes {
         normalize(et.resultType, pt)
       case wtp =>
         val iftp = defn.asContextFunctionType(wtp)
-        if iftp.exists && followIFT then normalize(iftp.dropDependentRefinement.argInfos.last, pt)
+        if iftp.exists && followIFT then normalize(iftp.functionArgInfos.last, pt)
         else tp
     }
   }
diff --git a/compiler/src/dotty/tools/dotc/typer/Synthesizer.scala b/compiler/src/dotty/tools/dotc/typer/Synthesizer.scala
index 1a7a4b97855b..103961b68c29 100644
--- a/compiler/src/dotty/tools/dotc/typer/Synthesizer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Synthesizer.scala
@@ -103,12 +103,12 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
         def functionTypeEqual(baseFun: Type, actualArgs: List[Type],
             actualRet: Type, expected: Type) =
           expected =:= defn.FunctionOf(actualArgs, actualRet,
-            defn.isContextFunctionType(baseFun), defn.isErasedFunctionType(baseFun))
+            defn.isContextFunctionType(baseFun))
         val arity: Int =
-          if defn.isErasedFunctionType(fun) || defn.isErasedFunctionType(fun) then -1 // TODO support?
+          if defn.isErasedFunctionType(fun) then -1 // TODO support?
           else if defn.isFunctionType(fun) then
             // TupledFunction[(...) => R, ?]
-            fun.dropDependentRefinement.dealias.argInfos match
+            fun.functionArgInfos match
               case funArgs :+ funRet
               if functionTypeEqual(fun, defn.tupleType(funArgs) :: Nil, funRet, tupled) =>
                 // TupledFunction[(...funArgs...) => funRet, ?]
@@ -116,7 +116,7 @@ class Synthesizer(typer: Typer)(using @constructorOnly c: Context):
               case _ => -1
           else if defn.isFunctionType(tupled) then
             // TupledFunction[?, (...) => R]
-            tupled.dropDependentRefinement.dealias.argInfos match
+            tupled.functionArgInfos match
               case tupledArgs :: funRet :: Nil =>
                 defn.tupleTypes(tupledArgs.dealias) match
                   case Some(funArgs) if functionTypeEqual(tupled, funArgs, funRet, fun) =>
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 9d8fdcc006c9..4c6ec98ba9ba 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -1262,7 +1262,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
 
           (pt1.argInfos.init, typeTree(interpolateWildcards(pt1.argInfos.last.hiBound)))
         case RefinedType(parent, nme.apply, mt @ MethodTpe(_, formals, restpe))
-        if defn.isNonRefinedFunction(parent) && formals.length == defaultArity =>
+        if (defn.isNonRefinedFunction(parent) || defn.isErasedFunctionType(parent)) && formals.length == defaultArity =>
           (formals, untpd.DependentTypeTree(syms => restpe.substParams(mt, syms.map(_.termRef))))
         case SAMType(mt @ MethodTpe(_, formals, restpe)) =>
           (formals,
@@ -1293,16 +1293,18 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
    *  If both attempts fail, return `NoType`.
    */
   def inferredFromTarget(
-      param: untpd.ValDef, formal: Type, calleeType: Type, paramIndex: Name => Int)(using Context): Type =
+      param: untpd.ValDef, formal: Type, calleeType: Type, isErased: Boolean, 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)
+          val tp = 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.
+          // Strip inferred erased annotation, to avoid accidentally inferring erasedness
+          if !isErased then tp.stripAnnots(_.symbol != defn.ErasedParamAnnot) else tp
         else NoType
       case _ => NoType
     if target.exists then formal <:< target
@@ -1316,32 +1318,14 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
 
   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
+    var (funFlags, erasedParams) = tree match {
+      case tree: untpd.FunctionWithMods => (tree.mods.flags, tree.erasedParams)
+      case _ => (EmptyFlags, args.map(_ => false))
     }
 
-    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 =
@@ -1356,16 +1340,29 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         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)
+      val params3 = params2.zipWithConserve(erasedParams) { (arg, isErased) =>
+        if isErased then arg.withAddedFlags(Erased) else arg
+      }
+      val appDef0 = untpd.DefDef(nme.apply, List(params3), 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)
+      // Restart typechecking if there are erased classes that we want to mark erased
+      if mt.erasedParams.zip(mt.paramInfos.map(_.isErasedClass)).exists((paramErased, classErased) => classErased && !paramErased) then
+        val newParams = params3.zipWithConserve(mt.paramInfos.map(_.isErasedClass)) { (arg, isErasedClass) =>
+          if isErasedClass then arg.withAddedFlags(Erased) else arg
+        }
+        return typedDependent(newParams)
       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))
+      val core =
+        if mt.hasErasedParams then TypeTree(defn.ErasedFunctionClass.typeRef)
+        else
+          val funSym = defn.FunctionSymbol(numArgs, isContextual, isImpure)
+          val tycon = TypeTree(funSym.typeRef)
+          AppliedTypeTree(tycon, typeArgs)
       RefinedTypeTree(core, List(appDef), ctx.owner.asClass)
     end typedDependent
 
@@ -1374,17 +1371,25 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         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))
+        if erasedParams.contains(true) then
+          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)
+          // if there are any erased classes, we need to re-do the typecheck.
+          result match
+            case r: AppliedTypeTree if r.args.exists(_.tpe.isErasedClass) =>
+              typedFunctionType(desugar.makeFunctionWithValDefs(tree, pt), pt)
+            case _ => result
     }
   }
 
   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
+    val (isContextual, isDefinedErased) = tree match {
+      case tree: untpd.FunctionWithMods => (tree.mods.is(Given), tree.erasedParams)
+      case _ => (false, tree.args.map(_ => false))
     }
 
     /** The function body to be returned in the closure. Can become a TypedSplice
@@ -1485,9 +1490,10 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
 
     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)
+    /** Returns the type and whether the parameter is erased */
+    def protoFormal(i: Int): (Type, Boolean) =
+      if (protoFormals.length == params.length) (protoFormals(i), isDefinedErased(i))
+      else (errorType(WrongNumberOfParameters(protoFormals.length), tree.srcPos), false)
 
     /** Is `formal` a product type which is elementwise compatible with `params`? */
     def ptIsCorrectProduct(formal: Type) =
@@ -1525,28 +1531,32 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     if desugared.isEmpty then
       val inferredParams: List[untpd.ValDef] =
         for ((param, i) <- params.zipWithIndex) yield
-          if (!param.tpt.isEmpty) param
-          else
-            val formalBounds = protoFormal(i)
-            val formal = formalBounds.loBound
-            val isBottomFromWildcard = (formalBounds ne formal) && formal.isExactlyNothing
-            val knownFormal = isFullyDefined(formal, ForceDegree.failBottom)
-            // If the expected formal is a TypeBounds wildcard argument with Nothing as lower bound,
-            // try to prioritize inferring from target. See issue 16405 (tests/run/16405.scala)
-            val paramType =
-              if knownFormal && !isBottomFromWildcard then
-                formal
-              else
-                inferredFromTarget(param, formal, calleeType, paramIndex).orElse(
-                  if knownFormal then formal
-                  else errorType(AnonymousFunctionMissingParamType(param, tree, formal), param.srcPos)
+          val (formalBounds, isErased) = protoFormal(i)
+          val param0 =
+            if (!param.tpt.isEmpty) param
+            else
+              val formal = formalBounds.loBound
+              val isBottomFromWildcard = (formalBounds ne formal) && formal.isExactlyNothing
+              val knownFormal = isFullyDefined(formal, ForceDegree.failBottom)
+              // If the expected formal is a TypeBounds wildcard argument with Nothing as lower bound,
+              // try to prioritize inferring from target. See issue 16405 (tests/run/16405.scala)
+              val paramType =
+                // Strip inferred erased annotation, to avoid accidentally inferring erasedness
+                val formal0 = if !isErased then formal.stripAnnots(_.symbol != defn.ErasedParamAnnot) else formal
+                if knownFormal && !isBottomFromWildcard then
+                  formal0
+                else
+                  inferredFromTarget(param, formal, calleeType, isErased, paramIndex).orElse(
+                    if knownFormal then formal0
+                    else 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)
                 )
-            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)
+              cpy.ValDef(param)(tpt = paramTpt)
+          if isErased then param0.withAddedFlags(Flags.Erased) else param0
       desugared = desugar.makeClosure(inferredParams, fnBody, resultTpt, isContextual, tree.span)
 
     typed(desugared, pt)
@@ -1585,7 +1595,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
                         |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))
+                  TypeTree(defn.FunctionOf(Nil, mt.resType, isContextual = true))
                 else if hasCaptureConversionArg(mt.resType) then
                   errorTree(tree,
                     em"""cannot turn method type $mt into closure
@@ -2605,6 +2615,19 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       // check value class constraints
       checkDerivedValueClass(cls, body1)
 
+      // check PolyFunction constraints (no erased functions!)
+      if parents1.exists(_.tpe.classSymbol eq defn.PolyFunctionClass) then
+        body1.foreach {
+          case ddef: DefDef =>
+            ddef.paramss.foreach { params =>
+              val erasedParam = params.collectFirst { case vdef: ValDef if vdef.symbol.is(Erased) => vdef }
+              erasedParam.foreach { p =>
+                report.error(em"Implementation restriction: erased classes are not allowed in a poly function definition", p.srcPos)
+              }
+            }
+          case _ =>
+        }
+
       val effectiveOwner = cls.owner.skipWeakOwner
       if !cls.isRefinementClass
          && !cls.isAllOf(PrivateLocal)
@@ -3031,7 +3054,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     tree
 
   protected def makeContextualFunction(tree: untpd.Tree, pt: Type)(using Context): Tree = {
-    val defn.FunctionOf(formals, _, true, _) = pt.dropDependentRefinement: @unchecked
+    val defn.FunctionOf(formals, _, true) = pt.dropDependentRefinement: @unchecked
 
     // The getter of default parameters may reach here.
     // Given the code below
@@ -3059,7 +3082,12 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       else formals.map(untpd.TypeTree)
     }
 
-    val ifun = desugar.makeContextualFunction(paramTypes, tree, defn.isErasedFunctionType(pt))
+    val erasedParams = pt.dealias match {
+      case RefinedType(parent, nme.apply, mt: MethodType) => mt.erasedParams
+      case _ => paramTypes.map(_ => false)
+    }
+
+    val ifun = desugar.makeContextualFunction(paramTypes, tree, erasedParams)
     typr.println(i"make contextual function $tree / $pt ---> $ifun")
     typedFunctionValue(ifun, pt)
   }
diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
index 6688d6e81a89..f43c051ebf60 100644
--- a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
+++ b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
@@ -1581,8 +1581,12 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
           self.nonEmpty && self.head.symbol.is(dotc.core.Flags.Implicit)
         def isGiven: Boolean =
           self.nonEmpty && self.head.symbol.is(dotc.core.Flags.Given)
-        def isErased: Boolean =
-          self.nonEmpty && self.head.symbol.is(dotc.core.Flags.Erased)
+        def isErased: Boolean = false
+
+        def erasedArgs: List[Boolean] =
+          self.map(_.symbol.is(dotc.core.Flags.Erased))
+        def hasErasedArgs: Boolean =
+          self.exists(_.symbol.is(dotc.core.Flags.Erased))
     end TermParamClauseMethods
 
     type TypeParamClause = List[tpd.TypeDef]
@@ -2139,9 +2143,12 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     given MethodTypeMethods: MethodTypeMethods with
       extension (self: MethodType)
-        def isErased: Boolean = self.isErasedMethod
+        def isErased: Boolean = false
         def isImplicit: Boolean = self.isImplicitMethod
         def param(idx: Int): TypeRepr = self.newParamRef(idx)
+
+        def erasedParams: List[Boolean] = self.erasedParams
+        def hasErasedParams: Boolean = self.hasErasedParams
       end extension
     end MethodTypeMethods
 
@@ -2768,11 +2775,14 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
       def ProductClass: Symbol = dotc.core.Symbols.defn.ProductClass
       def FunctionClass(arity: Int, isImplicit: Boolean = false, isErased: Boolean = false): Symbol =
         if arity < 0 then throw IllegalArgumentException(s"arity: $arity")
-        dotc.core.Symbols.defn.FunctionSymbol(arity, isImplicit, isErased)
+        if isErased then
+          throw new Exception("Erased function classes are not supported. Use a refined `scala.runtime.ErasedFunction`")
+        else dotc.core.Symbols.defn.FunctionSymbol(arity, isImplicit)
       def FunctionClass(arity: Int): Symbol =
         FunctionClass(arity, false, false)
       def FunctionClass(arity: Int, isContextual: Boolean): Symbol =
         FunctionClass(arity, isContextual, false)
+      def ErasedFunctionClass = dotc.core.Symbols.defn.ErasedFunctionClass
       def TupleClass(arity: Int): Symbol =
         dotc.core.Symbols.defn.TupleType(arity).nn.classSymbol.asClass
       def isTupleClass(sym: Symbol): Boolean =
diff --git a/docs/_docs/internals/syntax.md b/docs/_docs/internals/syntax.md
index 1fbb7a34b078..445e86ee2408 100644
--- a/docs/_docs/internals/syntax.md
+++ b/docs/_docs/internals/syntax.md
@@ -140,7 +140,7 @@ type      val       var       while     with      yield
 ### Soft keywords
 
 ```
-as  derives  end  extension  infix  inline  opaque  open  throws transparent  using  |  *  +  -
+as  derives  end  erased  extension  infix  inline  opaque  open  throws transparent  using  |  *  +  -
 ```
 
 See the [separate section on soft keywords](../reference/soft-modifier.md) for additional
@@ -180,13 +180,13 @@ Type              ::=  FunType
                     |  FunParamClause ‘=>>’ Type                                TermLambdaTypeTree(ps, t)
                     |  MatchType
                     |  InfixType
-FunType           ::=  FunTypeArgs (‘=>’ | ‘?=>’) Type                          Function(ts, t)
+FunType           ::=  FunTypeArgs (‘=>’ | ‘?=>’) Type                          Function(ts, t) | FunctionWithMods(ts, t, mods, erasedParams)
                     |  HKTypeParamClause '=>' Type                              PolyFunction(ps, t)
 FunTypeArgs       ::=  InfixType
                     |  ‘(’ [ FunArgTypes ] ‘)’
                     |  FunParamClause
 FunParamClause    ::=  ‘(’ TypedFunParam {‘,’ TypedFunParam } ‘)’
-TypedFunParam     ::=  id ‘:’ Type
+TypedFunParam     ::=  [`erased`] id ‘:’ Type
 MatchType         ::=  InfixType `match` <<< TypeCaseClauses >>>
 InfixType         ::=  RefinedType {id [nl] RefinedType}                        InfixOp(t1, op, t2)
 RefinedType       ::=  AnnotType {[nl] Refinement}                              RefinedTypeTree(t, ds)
@@ -207,8 +207,8 @@ Singleton         ::=  SimpleRef
                     |  SimpleLiteral
                     |  Singleton ‘.’ id
 Singletons        ::=  Singleton { ‘,’ Singleton }
-FunArgType        ::=  Type
-                    |  ‘=>’ Type                                                PrefixOp(=>, t)
+FunArgType        ::=  [`erased`] Type
+                    |  [`erased`] ‘=>’ Type                                     PrefixOp(=>, t)
 FunArgTypes       ::=  FunArgType { ‘,’ FunArgType }
 ParamType         ::=  [‘=>’] ParamValueType
 ParamValueType    ::=  [‘into’] ExactParamType                                  Into(t)
@@ -229,7 +229,7 @@ BlockResult       ::=  FunParams (‘=>’ | ‘?=>’) Block
                     |  HkTypeParamClause ‘=>’ Block
                     |  Expr1
 FunParams         ::=  Bindings
-                    |  id
+                    |  [`erased`] id
                     |  ‘_’
 Expr1             ::=  [‘inline’] ‘if’ ‘(’ Expr ‘)’ {nl} Expr [[semi] ‘else’ Expr] If(Parens(cond), thenp, elsep?)
                     |  [‘inline’] ‘if’  Expr ‘then’ Expr [[semi] ‘else’ Expr]    If(cond, thenp, elsep?)
@@ -376,13 +376,13 @@ UsingParamClause  ::=  [nl] ‘(’ ‘using’ (DefTermParams | FunArgTypes) 
 DefImplicitClause ::=  [nl] ‘(’ ‘implicit’ DefTermParams ‘)’
 
 DefTermParams     ::= DefTermParam {‘,’ DefTermParam}
-DefTermParam      ::= {Annotation} [‘inline’] Param                         ValDef(mods, id, tpe, expr) -- point of mods at id.
+DefTermParam      ::= {Annotation} [`erased`] [‘inline’] Param                    ValDef(mods, id, tpe, expr) -- point of mods at id.
 Param             ::=  id ‘:’ ParamType [‘=’ Expr]
 ```
 
 ### Bindings and Imports
 ```ebnf
-Bindings          ::=  ‘(’ [Binding {‘,’ Binding}] ‘)’
+Bindings          ::=  ‘(’[`erased`] [Binding {‘,’ [`erased`] Binding}] ‘)’
 Binding           ::=  (id | ‘_’) [‘:’ Type]                                    ValDef(_, id, tpe, EmptyTree)
 
 Modifier          ::=  LocalModifier
diff --git a/docs/_docs/reference/experimental/erased-defs-spec.md b/docs/_docs/reference/experimental/erased-defs-spec.md
index 24ae89c7e28b..59dfed92da2a 100644
--- a/docs/_docs/reference/experimental/erased-defs-spec.md
+++ b/docs/_docs/reference/experimental/erased-defs-spec.md
@@ -19,8 +19,8 @@ TODO: complete
 
     def g(erased x: Int) = ...
 
-    (erased x: Int) => ...
-    def h(x: (erased Int) => Int) = ...
+    (erased x: Int, y: Int) => ...
+    def h(x: (Int, erased Int) => Int) = ...
 
     class K(erased x: Int) { ... }
     erased class E {}
@@ -34,12 +34,12 @@ TODO: complete
 
 3. Functions
    * `(erased x1: T1, x2: T2, ..., xN: TN) => y : (erased T1, T2, ..., TN) => R`
-   * `(given erased x1: T1, x2: T2, ..., xN: TN) => y: (given erased T1, T2, ..., TN) => R`
+   * `(given x1: T1, erased x2: T2, ..., xN: TN) => y: (given T1, erased T2, ..., TN) => R`
    * `(given erased T1) => R  <:<  erased T1 => R`
-   * `(given erased T1, T2) => R  <:< (erased T1, T2) => R`
+   * `(given T1, erased T2) => R  <:< (T1, erased T2) => R`
    *  ...
 
-   Note that there is no subtype relation between `(erased T) => R` and `T => R` (or `(given erased T) => R` and `(given T) => R`)
+   Note that there is no subtype relation between `(erased T) => R` and `T => R` (or `(given erased T) => R` and `(given T) => R`). The `erased` parameters must match exactly in their respective positions.
 
 
 4. Eta expansion
@@ -51,7 +51,8 @@ TODO: complete
    * All `erased` parameters are removed from the function
    * All argument to `erased` parameters are not passed to the function
    * All `erased` definitions are removed
-   * All `(erased T1, T2, ..., TN) => R` and `(given erased T1, T2, ..., TN) => R` become `() => R`
+   * `(erased ET1, erased ET2, T1, ..., erased ETN, TM) => R` are erased to `(T1, ..., TM) => R`.
+   * `(given erased ET1, erased ET2, T1, ..., erased ETN, TM) => R` are erased to `(given T1, ..., TM) => R`.
 
 
 6. Overloading
@@ -60,11 +61,10 @@ TODO: complete
 
 
 7. Overriding
-   * Member definitions overriding each other must both be `erased` or not be `erased`
-   * `def foo(x: T): U` cannot be overridden by `def foo(erased x: T): U` and vice-versa
-   *
-
+   * Member definitions overriding each other must both be `erased` or not be `erased`.
+   * `def foo(x: T): U` cannot be overridden by `def foo(erased x: T): U` and vice-versa.
 
 8. Type Restrictions
    * For dependent functions, `erased` parameters are limited to realizable types, that is, types that are inhabited by non-null values.
      This restriction stops us from using a bad bound introduced by an erased value, which leads to unsoundness (see #4060).
+   * Polymorphic functions with erased parameters are currently not supported, and will be rejected by the compiler. This is purely an implementation restriction, and might be lifted in the future.
diff --git a/docs/_docs/reference/experimental/erased-defs.md b/docs/_docs/reference/experimental/erased-defs.md
index 28455f26cdc0..ef4f02e33dd4 100644
--- a/docs/_docs/reference/experimental/erased-defs.md
+++ b/docs/_docs/reference/experimental/erased-defs.md
@@ -54,13 +54,13 @@ semantics and they are completely erased.
 ## How to define erased terms?
 
 Parameters of methods and functions can be declared as erased, placing `erased`
-in front of a parameter list (like `given`).
+in front of each erased parameter (like `inline`).
 
 ```scala
-def methodWithErasedEv(erased ev: Ev): Int = 42
+def methodWithErasedEv(erased ev: Ev, x: Int): Int = x + 2
 
-val lambdaWithErasedEv: erased Ev => Int =
-  (erased ev: Ev) => 42
+val lambdaWithErasedEv: (erased Ev, Int) => Int =
+  (erased ev, x) => x + 2
 ```
 
 `erased` parameters will not be usable for computations, though they can be used
@@ -80,7 +80,7 @@ parameters.
 
 ```scala
 erased val erasedEvidence: Ev = ...
-methodWithErasedEv(erasedEvidence)
+methodWithErasedEv(erasedEvidence, 40) // 42
 ```
 
 ## What happens with erased values at runtime?
@@ -89,15 +89,15 @@ As `erased` are guaranteed not to be used in computations, they can and will be
 erased.
 
 ```scala
-// becomes def methodWithErasedEv(): Int at runtime
-def methodWithErasedEv(erased ev: Ev): Int = ...
+// becomes def methodWithErasedEv(x: Int): Int at runtime
+def methodWithErasedEv(x: Int, erased ev: Ev): Int = ...
 
 def evidence1: Ev = ...
 erased def erasedEvidence2: Ev = ... // does not exist at runtime
 erased val erasedEvidence3: Ev = ... // does not exist at runtime
 
-// evidence1 is not evaluated and no value is passed to methodWithErasedEv
-methodWithErasedEv(evidence1)
+// evidence1 is not evaluated and only `x` is passed to methodWithErasedEv
+methodWithErasedEv(x, evidence1)
 ```
 
 ## State machine with erased evidence example
diff --git a/library/src/scala/quoted/Quotes.scala b/library/src/scala/quoted/Quotes.scala
index 321725d4e84c..79a4ea039ab5 100644
--- a/library/src/scala/quoted/Quotes.scala
+++ b/library/src/scala/quoted/Quotes.scala
@@ -2374,7 +2374,16 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
         /** Is this a given parameter clause `(using X1, ..., Xn)` or `(using x1: X1, ..., xn: Xn)` */
         def isGiven: Boolean
         /** Is this a erased parameter clause `(erased x1: X1, ..., xn: Xn)` */
+        // TODO:deprecate in 3.4 and stabilize `erasedArgs` and `hasErasedArgs`.
+        // @deprecated("Use `hasErasedArgs`","3.4")
         def isErased: Boolean
+
+        /** List of `erased` flags for each parameter of the clause */
+        @experimental
+        def erasedArgs: List[Boolean]
+        /** Whether the clause has any erased parameters */
+        @experimental
+        def hasErasedArgs: Boolean
     end TermParamClauseMethods
 
     /** A type parameter clause `[X1, ..., Xn]` */
@@ -2650,7 +2659,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
         */
         def isContextFunctionType: Boolean
 
-        /** Is this type an erased function type?
+        /** Is this type a function type with erased parameters?
         *
         *  @see `isFunctionType`
         */
@@ -3145,7 +3154,17 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
       extension (self: MethodType)
         /** Is this the type of using parameter clause `(implicit X1, ..., Xn)`, `(using X1, ..., Xn)` or `(using x1: X1, ..., xn: Xn)` */
         def isImplicit: Boolean
+        /** Is this the type of erased parameter clause `(erased x1: X1, ..., xn: Xn)` */
+        // TODO:deprecate in 3.4 and stabilize `erasedParams` and `hasErasedParams`.
+        // @deprecated("Use `hasErasedParams`","3.4")
         def isErased: Boolean
+
+        /** List of `erased` flags for each parameters of the clause */
+        @experimental
+        def erasedParams: List[Boolean]
+        /** Whether the clause has any erased parameters */
+        @experimental
+        def hasErasedParams: Boolean
         def param(idx: Int): TypeRepr
       end extension
     end MethodTypeMethods
@@ -4275,6 +4294,10 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
       @experimental
       def FunctionClass(arity: Int, isContextual: Boolean): Symbol
 
+      /** The `scala.runtime.ErasedFunction` built-in trait. */
+      @experimental
+      def ErasedFunctionClass: Symbol
+
       /** Function-like object that maps arity to symbols for classes `scala.TupleX`.
       *   -  0th element is `NoSymbol`
       *   -  1st element is `NoSymbol`
diff --git a/library/src/scala/runtime/ErasedFunction.scala b/library/src/scala/runtime/ErasedFunction.scala
new file mode 100644
index 000000000000..7e9211bba75a
--- /dev/null
+++ b/library/src/scala/runtime/ErasedFunction.scala
@@ -0,0 +1,11 @@
+package scala.runtime
+
+import scala.annotation.experimental
+
+/** Marker trait for function types with erased parameters.
+ *
+ *  This trait will be refined with an `apply` method with erased parameters:
+ *      ErasedFunction { def apply([erased] x_1: P_1, ..., [erased] x_N: P_N): R }
+ *  This type will be erased to FunctionL, where L = N - count(erased).
+ */
+@experimental trait ErasedFunction
diff --git a/tests/neg-custom-args/erased/by-name.scala b/tests/neg-custom-args/erased/by-name.scala
new file mode 100644
index 000000000000..707cfd96734b
--- /dev/null
+++ b/tests/neg-custom-args/erased/by-name.scala
@@ -0,0 +1,4 @@
+def f(x: => Int, erased y: => Int) = x // error
+def g(erased x: => Int, y: => Int) = y // error
+
+val h: (erased => Int, Int) => Int = (erased x, y) => y // error
diff --git a/tests/neg-custom-args/erased/erased-in-tuples.scala b/tests/neg-custom-args/erased/erased-in-tuples.scala
new file mode 100644
index 000000000000..11a251c3bd4d
--- /dev/null
+++ b/tests/neg-custom-args/erased/erased-in-tuples.scala
@@ -0,0 +1,16 @@
+@main def Test() =
+  val x = 5
+  val y = 7
+
+  val t1 = (x, erased y) // error
+  val t2 = (erased x, y) // error
+  val t1a = (x: Int, erased y: Int) // error
+  val t2a = (erased x: Int, y: Int) // error
+
+  val nest = (x, (x, erased y)) // error
+
+  def use(f: (Int, Int) => Any) = f(5, 6)
+
+  use((_, erased _)) // error
+
+  (x, erased y) // error
diff --git a/tests/neg-custom-args/erased/lambda-infer.scala b/tests/neg-custom-args/erased/lambda-infer.scala
new file mode 100644
index 000000000000..2eebf8186b0d
--- /dev/null
+++ b/tests/neg-custom-args/erased/lambda-infer.scala
@@ -0,0 +1,23 @@
+type F = (Int, erased Int) => Int
+
+erased class A
+
+@main def Test() =
+  val a: F = (x, y) => x + 1 // error: Expected F got (Int, Int) => Int
+  val b: F = (x, erased y) => x + 1 // ok
+  val c: F = (_, _) => 5 // error: Expected F got (Int, Int) => Int
+  val d: F = (_, erased _) => 5 // ok
+
+  def use(f: F) = f(5, 6)
+
+  use { (x, y) => x } // error: Expected F got (Int, Int) => Int
+
+  def singleParam(f: (erased Int) => Int) = f(5)
+
+  singleParam(x => 5) // error: Expected (erased Int) => Int got Int => Int
+  singleParam((erased x) => 5) // ok
+
+  def erasedClass(f: A => Int) = f(new A)
+
+  erasedClass(_ => 5) // ok since A is implicitly erased
+
diff --git a/tests/neg-custom-args/erased/multiple-args-consume.scala b/tests/neg-custom-args/erased/multiple-args-consume.scala
new file mode 100644
index 000000000000..e4aaacca8969
--- /dev/null
+++ b/tests/neg-custom-args/erased/multiple-args-consume.scala
@@ -0,0 +1,13 @@
+def foo(erased x: Int, y: Int) = y
+def bar(x: Int, erased y: Int) = x
+
+def consumeFoo(f: (erased x: Int, y: Int) => Int) = f(0, 1)
+
+val fooF: (erased x: Int, y: Int) => Int = foo
+val barF: (x: Int, erased y: Int) => Int = bar
+
+val a = consumeFoo(foo) // ok
+val b = consumeFoo(bar) // error
+
+val c = consumeFoo(fooF) // ok
+val d = consumeFoo(barF) // error
diff --git a/tests/neg-custom-args/erased/multiple-args.scala b/tests/neg-custom-args/erased/multiple-args.scala
new file mode 100644
index 000000000000..fb9bce8e4573
--- /dev/null
+++ b/tests/neg-custom-args/erased/multiple-args.scala
@@ -0,0 +1,11 @@
+def foo(x: Int, erased y: Int): Int = x
+def bar(erased x: Int, y: Int): Int = y
+
+val fooF: (x: Int, erased y: Int) => Int = foo
+
+val fooG: (erased x: Int, y: Int) => Int = foo // error
+
+val barF: (x: Int, erased y: Int) => Int = bar // error
+
+val barG: (erased x: Int, y: Int) => Int = bar
+
diff --git a/tests/neg-custom-args/erased/poly-functions.scala b/tests/neg-custom-args/erased/poly-functions.scala
new file mode 100644
index 000000000000..000a2ca49cc9
--- /dev/null
+++ b/tests/neg-custom-args/erased/poly-functions.scala
@@ -0,0 +1,16 @@
+object Test:
+  // Poly functions with erased parameters are disallowed as an implementation restriction
+
+  type T1 = [X] => (erased x: X, y: Int) => Int // error
+  type T2 = [X] => (x: X, erased y: Int) => X // error
+
+  val t1 = [X] => (erased x: X, y: Int) => y // error
+  val t2 = [X] => (x: X, erased y: Int) => x // error
+
+  // Erased classes should be detected too
+  erased class A
+
+  type T3 = [X] => (x: A, y: X) => X // error
+
+  val t3 = [X] => (x: A, y: X) => y // error
+
diff --git a/tests/neg/safeThrowsStrawman2.scala b/tests/neg/safeThrowsStrawman2.scala
index 7d87baad6fa4..8d95494e30e0 100644
--- a/tests/neg/safeThrowsStrawman2.scala
+++ b/tests/neg/safeThrowsStrawman2.scala
@@ -24,7 +24,7 @@ def bar(x: Boolean)(using CanThrow[Fail]): Int =
     val x = new CanThrow[Fail]()      // OK, x is erased
     val y: Any = new CanThrow[Fail]() // error: illegal reference to erased class CanThrow
     val y2: Any = new CTF()       // error: illegal reference to erased class CanThrow
-    println(foo(true, ctf))       // error: ctf is declared as erased, but is in fact used
+    println(foo(true, ctf))       // not error: ctf will be erased at erasure
     val a = (1, new CanThrow[Fail]()) // error: illegal reference to erased class CanThrow
     def b: (Int, CanThrow[Fail]) = ???
     def c = b._2                  // ok; we only check creation sites
diff --git a/tests/pos-custom-args/erased/erased-class-as-args.scala b/tests/pos-custom-args/erased/erased-class-as-args.scala
new file mode 100644
index 000000000000..74c827fbd54b
--- /dev/null
+++ b/tests/pos-custom-args/erased/erased-class-as-args.scala
@@ -0,0 +1,22 @@
+erased class A
+
+erased class B(val x: Int) extends A
+
+type T = (x: A, y: Int) => Int
+
+type TSub[-T <: A] = (erased x: T, y: Int) => Int
+
+def useT(f: T) = f(new A, 5)
+
+def useTSub(f: TSub[B]) = f(new B(5), 5)
+
+@main def Test() =
+  val tInfer = (x: A, y: Int) => y + 1
+  val tExpl: T = (x, y) => y + 1
+  assert(useT((erased x, y) => y + 1) == 6)
+  assert(useT(tInfer) == 6)
+  assert(useT(tExpl) == 6)
+
+  val tSub: TSub[A] = (x, y) => y + 1
+  assert(useT(tSub) == 6)
+  assert(useTSub(tSub) == 6)
diff --git a/tests/pos-custom-args/erased/erased-soft-keyword.scala b/tests/pos-custom-args/erased/erased-soft-keyword.scala
new file mode 100644
index 000000000000..fdb884628c7d
--- /dev/null
+++ b/tests/pos-custom-args/erased/erased-soft-keyword.scala
@@ -0,0 +1,18 @@
+def f1(x: Int, erased y: Int) = 0
+def f2(x: Int, erased: Int) = 0
+inline def f3(x: Int, inline erased: Int) = 0
+def f4(x: Int, erased inline: Int) = 0
+// inline def f5(x: Int, erased inline y: Int) = 0 // should parse but rejected later
+
+def f6(using erased y: Int) = 0
+def f7(using erased: Int) = 0
+inline def f8(using inline erased: Int) = 0
+def f9(using erased inline: Int) = 0
+// inline def f10(using erased inline x: Int) = 0 // should parse but rejected later
+def f11(using erased Int) = 0
+
+val v1 = (erased: Int) => 0
+val v2: Int => Int = erased => 0
+val v3 = (erased x: Int) => 0
+val v4: (erased Int) => Int = (erased x) => 0
+val v5: (erased: Int) => Int = x => 0
diff --git a/tests/run-custom-args/erased/erased-15.scala b/tests/run-custom-args/erased/erased-15.scala
index b879ee4c54d8..02b70f9125d6 100644
--- a/tests/run-custom-args/erased/erased-15.scala
+++ b/tests/run-custom-args/erased/erased-15.scala
@@ -1,3 +1,5 @@
+import scala.runtime.ErasedFunction
+
 object Test {
 
   def main(args: Array[String]): Unit = {
@@ -10,7 +12,7 @@ object Test {
   }
 }
 
-class Foo extends ErasedFunction1[Int, Int] {
+class Foo extends ErasedFunction {
   def apply(erased x: Int): Int = {
     println("Foo.apply")
     42
diff --git a/tests/run-custom-args/erased/erased-27.check b/tests/run-custom-args/erased/erased-27.check
index 4413863feead..1c255dd5419f 100644
--- a/tests/run-custom-args/erased/erased-27.check
+++ b/tests/run-custom-args/erased/erased-27.check
@@ -1,3 +1,2 @@
 block
-x
 foo
diff --git a/tests/run-custom-args/erased/erased-28.check b/tests/run-custom-args/erased/erased-28.check
index 85733f6db2d7..3bd1f0e29744 100644
--- a/tests/run-custom-args/erased/erased-28.check
+++ b/tests/run-custom-args/erased/erased-28.check
@@ -1,4 +1,2 @@
-x
 foo
-x
 bar
diff --git a/tests/run-custom-args/erased/erased-class-are-erased.check b/tests/run-custom-args/erased/erased-class-are-erased.check
new file mode 100644
index 000000000000..f64f5d8d85ac
--- /dev/null
+++ b/tests/run-custom-args/erased/erased-class-are-erased.check
@@ -0,0 +1 @@
+27
diff --git a/tests/run-custom-args/erased/erased-class-are-erased.scala b/tests/run-custom-args/erased/erased-class-are-erased.scala
new file mode 100644
index 000000000000..b48e0265c521
--- /dev/null
+++ b/tests/run-custom-args/erased/erased-class-are-erased.scala
@@ -0,0 +1,14 @@
+object Test {
+  erased class Erased() {
+    println("Oh no!!!")
+  }
+
+  def f(x: Erased, y: Int = 0): Int = y + 5
+
+  def g() = Erased()
+
+  def main(args: Array[String]) =
+    val y = Erased()
+    val z = 10
+    println(f(Erased()) + z + f(g(), 7))
+}
diff --git a/tests/run-custom-args/erased/lambdas.scala b/tests/run-custom-args/erased/lambdas.scala
new file mode 100644
index 000000000000..4c1746283099
--- /dev/null
+++ b/tests/run-custom-args/erased/lambdas.scala
@@ -0,0 +1,38 @@
+// lambdas should parse and work
+
+type F = (erased Int, String) => String
+type S = (Int, erased String) => Int
+
+def useF(f: F) = f(5, "a")
+def useS(f: S) = f(5, "a")
+
+val ff: F = (erased x, y) => y
+
+val fs: S = (x, erased y) => x
+val fsExpl = (x: Int, erased y: String) => x
+
+// contextual lambdas should work
+
+type FC = (Int, erased String) ?=> Int
+
+def useCtx(f: FC) = f(using 5, "a")
+
+val fCv: FC = (x, erased y) ?=> x
+val fCvExpl = (x: Int, erased y: String) ?=> x
+
+// nested lambdas should work
+
+val nested: Int => (String, erased Int) => FC = a => (_, erased _) => (c, erased d) ?=> a + c
+
+@main def Test() =
+  assert("a" == useF(ff))
+
+  assert(5 == useS(fs))
+  assert(5 == useS(fsExpl))
+  assert(5 == useS { (x, erased y) => x })
+
+  assert(5 == useCtx(fCv))
+  assert(5 == useCtx(fCvExpl))
+  assert(5 == useCtx { (x, erased y) ?=> x })
+
+  assert(6 == useCtx(nested(1)("b", 2)))
diff --git a/tests/run-custom-args/erased/quotes-add-erased.check b/tests/run-custom-args/erased/quotes-add-erased.check
new file mode 100644
index 000000000000..d00491fd7e5b
--- /dev/null
+++ b/tests/run-custom-args/erased/quotes-add-erased.check
@@ -0,0 +1 @@
+1
diff --git a/tests/run-custom-args/erased/quotes-add-erased/Macro_1.scala b/tests/run-custom-args/erased/quotes-add-erased/Macro_1.scala
new file mode 100644
index 000000000000..66f8475da96d
--- /dev/null
+++ b/tests/run-custom-args/erased/quotes-add-erased/Macro_1.scala
@@ -0,0 +1,26 @@
+import scala.annotation.MacroAnnotation
+import scala.annotation.internal.ErasedParam
+import scala.quoted._
+
+class NewAnnotation extends scala.annotation.Annotation
+
+class erasedParamsMethod extends MacroAnnotation:
+  def transform(using Quotes)(tree: quotes.reflect.Definition): List[quotes.reflect.Definition] =
+    import quotes.reflect._
+    tree match
+      case ClassDef(name, ctr, parents, self, body) =>
+        val erasedInt = AnnotatedType(TypeRepr.of[Int], '{ new ErasedParam }.asTerm)
+        val methType = MethodType(List("x", "y"))(_ => List(erasedInt, TypeRepr.of[Int]), _ => TypeRepr.of[Int])
+
+        assert(methType.hasErasedParams)
+        assert(methType.erasedParams == List(true, false))
+
+        val methSym = Symbol.newMethod(tree.symbol, "takesErased", methType, Flags.EmptyFlags, Symbol.noSymbol)
+        val methDef = DefDef(methSym, _ => Some(Literal(IntConstant(1))))
+
+        val clsDef = ClassDef.copy(tree)(name, ctr, parents, self, methDef :: body)
+
+        List(clsDef)
+      case _ =>
+        report.error("Annotation only supports `class`")
+        List(tree)
diff --git a/tests/run-custom-args/erased/quotes-add-erased/Test_2.scala b/tests/run-custom-args/erased/quotes-add-erased/Test_2.scala
new file mode 100644
index 000000000000..107fa0833e95
--- /dev/null
+++ b/tests/run-custom-args/erased/quotes-add-erased/Test_2.scala
@@ -0,0 +1,12 @@
+import scala.language.experimental.erasedDefinitions
+
+class TakesErased {
+  def takesErased(erased x: Int, y: Int): Int = ???
+}
+
+@erasedParamsMethod class Foo extends TakesErased
+
+@main def Test() =
+  val foo = Foo()
+  val v = foo.takesErased(1, 2)
+  println(v)
diff --git a/tests/run-custom-args/erased/quotes-reflection.check b/tests/run-custom-args/erased/quotes-reflection.check
new file mode 100644
index 000000000000..838479e0b7af
--- /dev/null
+++ b/tests/run-custom-args/erased/quotes-reflection.check
@@ -0,0 +1,10 @@
+method <init>: () isGiven=false isImplicit=false erasedArgs=List()
+method m1: (i: scala.Int) isGiven=true isImplicit=false erasedArgs=List(false)
+method m2: (i: scala.Int) isGiven=false isImplicit=false erasedArgs=List(true)
+method m3: (i: scala.Int, j: scala.Int) isGiven=false isImplicit=false erasedArgs=List(false, true)
+method m4: (i: EC) isGiven=false isImplicit=false erasedArgs=List(true)
+val l1: scala.ContextFunction1[scala.Int, scala.Int]
+val l2: scala.runtime.ErasedFunction with apply: (x$0: scala.Int @scala.annotation.internal.ErasedParam) isImplicit=false erasedParams=List(true)
+val l3: scala.runtime.ErasedFunction with apply: (x$0: scala.Int @scala.annotation.internal.ErasedParam) isImplicit=true erasedParams=List(true)
+val l4: scala.runtime.ErasedFunction with apply: (x$0: scala.Int, x$1: scala.Int @scala.annotation.internal.ErasedParam) isImplicit=false erasedParams=List(false, true)
+val l5: scala.runtime.ErasedFunction with apply: (x$0: EC @scala.annotation.internal.ErasedParam) isImplicit=false erasedParams=List(true)
diff --git a/tests/run-custom-args/erased/quotes-reflection/Macros_1.scala b/tests/run-custom-args/erased/quotes-reflection/Macros_1.scala
new file mode 100644
index 000000000000..f7b1187433f0
--- /dev/null
+++ b/tests/run-custom-args/erased/quotes-reflection/Macros_1.scala
@@ -0,0 +1,35 @@
+import scala.quoted.*
+
+inline def inspect[A]: String =
+  ${ inspect2[A] }
+
+def inspect2[A: Type](using Quotes): Expr[String] = {
+  import quotes.reflect.*
+
+  val methods = TypeRepr.of[A].typeSymbol.declarations
+  val names = methods.map { m =>
+    m.tree match
+      case dd @ DefDef(name, params, r, body) =>
+        val paramStr =
+          params.map {
+            case ps: TermParamClause =>
+              val params = ps.params.map(p => s"${p.name}: ${p.tpt.show}").mkString("(", ", ", ")")
+              s"$params isGiven=${ps.isGiven} isImplicit=${ps.isImplicit} erasedArgs=${ps.erasedArgs}"
+            case ps: TypeParamClause => ps.params.map(_.show).mkString("[", ", ", "]")
+          }.mkString("")
+        s"method $name: $paramStr"
+      case vd @ ValDef(name, tpt, body) =>
+        tpt.tpe match
+          case Refinement(parent, "apply", tpe: MethodType) if parent == defn.ErasedFunctionClass.typeRef =>
+            assert(tpt.tpe.isErasedFunctionType)
+
+            val params = tpe.paramNames.zip(tpe.paramTypes).map((n, t) => s"$n: ${t.show}").mkString("(", ", ", ")")
+            s"val $name: ${parent.show} with apply: ${params} isImplicit=${tpe.isImplicit} erasedParams=${tpe.erasedParams}"
+          case _ =>
+            s"val $name: ${tpt.show}"
+      case td @ TypeDef(name, tpt) => s"type $name: ${tpt.show}"
+      case _ => s"something else: $m"
+  }
+
+  Expr(names.mkString("\n"))
+}
diff --git a/tests/run-custom-args/erased/quotes-reflection/Test_2.scala b/tests/run-custom-args/erased/quotes-reflection/Test_2.scala
new file mode 100644
index 000000000000..ce1cc8d3dff1
--- /dev/null
+++ b/tests/run-custom-args/erased/quotes-reflection/Test_2.scala
@@ -0,0 +1,20 @@
+import scala.language.experimental.erasedDefinitions
+
+erased class EC
+
+trait X {
+  def m1(using i: Int): Int
+  def m2(erased i: Int): Int
+  def m3(i: Int, erased j: Int): Int
+  def m4(i: EC): Int
+
+  val l1 = (x: Int) ?=> 5
+  val l2 = (erased x: Int) => 5
+  val l3 = (erased x: Int) ?=> 5
+  val l4 = (x: Int, erased y: Int) => 5
+  val l5 = (x: EC) => 5
+}
+
+@main def Test = {
+  println(inspect[X])
+}
diff --git a/tests/run-custom-args/run-macros-erased/macro-erased/1.scala b/tests/run-custom-args/run-macros-erased/macro-erased/1.scala
index 567ef57b1c06..36f583a7dc91 100644
--- a/tests/run-custom-args/run-macros-erased/macro-erased/1.scala
+++ b/tests/run-custom-args/run-macros-erased/macro-erased/1.scala
@@ -13,8 +13,8 @@ object Macro {
   def case1(erased i: Expr[Int])(using Quotes): Expr[Int] = '{ 0 }
   def case2 (i: Int)(erased j: Expr[Int])(using Quotes): Expr[Int] = '{ 0 }
   def case3(erased i: Expr[Int]) (j: Int)(using Quotes): Expr[Int] = '{ 0 }
-  def case4 (h: Int)(erased i: Expr[Int], j: Expr[Int])(using Quotes): Expr[Int] = '{ 0 }
-  def case5(erased i: Expr[Int], j: Expr[Int]) (h: Int)(using Quotes): Expr[Int] = '{ 0 }
+  def case4 (h: Int)(erased i: Expr[Int], erased j: Expr[Int])(using Quotes): Expr[Int] = '{ 0 }
+  def case5(erased i: Expr[Int], erased j: Expr[Int]) (h: Int)(using Quotes): Expr[Int] = '{ 0 }
   def case6 (h: Int)(erased i: Expr[Int])(erased j: Expr[Int])(using Quotes): Expr[Int] = '{ 0 }
   def case7(erased i: Expr[Int]) (h: Int)(erased j: Expr[Int])(using Quotes): Expr[Int] = '{ 0 }
   def case8(erased i: Expr[Int])(erased j: Expr[Int]) (h: Int)(using Quotes): Expr[Int] = '{ 0 }
diff --git a/tests/run-custom-args/tasty-inspector/stdlibExperimentalDefinitions.scala b/tests/run-custom-args/tasty-inspector/stdlibExperimentalDefinitions.scala
index eff76720a7e2..2c49ca46349e 100644
--- a/tests/run-custom-args/tasty-inspector/stdlibExperimentalDefinitions.scala
+++ b/tests/run-custom-args/tasty-inspector/stdlibExperimentalDefinitions.scala
@@ -1,5 +1,6 @@
 import scala.quoted.*
 import scala.tasty.inspector.*
+import scala.language.experimental.erasedDefinitions
 
 val experimentalDefinitionInLibrary = Set(
 
@@ -80,6 +81,21 @@ val experimentalDefinitionInLibrary = Set(
   "scala.quoted.Quotes.reflectModule.SymbolModule.newModule",
   "scala.quoted.Quotes.reflectModule.SymbolModule.freshName",
   "scala.quoted.Quotes.reflectModule.SymbolMethods.info",
+  // Quotes for functions with erased parameters.
+  "scala.quoted.Quotes.reflectModule.MethodTypeMethods.erasedParams",
+  "scala.quoted.Quotes.reflectModule.MethodTypeMethods.hasErasedParams",
+  "scala.quoted.Quotes.reflectModule.TermParamClauseMethods.erasedArgs",
+  "scala.quoted.Quotes.reflectModule.TermParamClauseMethods.hasErasedArgs",
+  "scala.quoted.Quotes.reflectModule.defnModule.ErasedFunctionClass",
+
+  // New feature: functions with erased parameters.
+  // Need erasedDefinitions enabled.
+  "scala.runtime.ErasedFunction",
+  "scala.quoted.Quotes.reflectModule.MethodTypeMethods.erasedParams",
+  "scala.quoted.Quotes.reflectModule.MethodTypeMethods.hasErasedParams",
+  "scala.quoted.Quotes.reflectModule.TermParamClauseMethods.erasedArgs",
+  "scala.quoted.Quotes.reflectModule.TermParamClauseMethods.hasErasedArgs",
+  "scala.quoted.Quotes.reflectModule.defnModule.ErasedFunctionClass"
 )
 
 
diff --git a/tests/run-macros/i12021.check b/tests/run-macros/i12021.check
index b244dce80b34..ef998c725209 100644
--- a/tests/run-macros/i12021.check
+++ b/tests/run-macros/i12021.check
@@ -1,3 +1,5 @@
-X1: (i: scala.Int) isImplicit=true, isGiven=false, isErased=false
-X2: (i: scala.Int) isImplicit=false, isGiven=true, isErased=false
-X3: (i: scala.Int) isImplicit=false, isGiven=false, isErased=true
+X1: (i: scala.Int) isImplicit=true, isGiven=false, erasedArgs=List(false)
+X2: (i: scala.Int) isImplicit=false, isGiven=true, erasedArgs=List(false)
+X3: (i: scala.Int) isImplicit=false, isGiven=false, erasedArgs=List(true)
+X4: (i: scala.Int, j: scala.Int) isImplicit=false, isGiven=false, erasedArgs=List(false, true)
+X5: (i: EC) isImplicit=false, isGiven=false, erasedArgs=List(true)
diff --git a/tests/run-macros/i12021/Macro_1.scala b/tests/run-macros/i12021/Macro_1.scala
index 81703dfbab3d..25cab1786146 100644
--- a/tests/run-macros/i12021/Macro_1.scala
+++ b/tests/run-macros/i12021/Macro_1.scala
@@ -14,5 +14,5 @@ def inspect2[A: Type](using Quotes): Expr[String] = {
 
   val names = ps.params.map(p => s"${p.name}: ${p.tpt.show}").mkString("(", ", ", ")")
 
-  Expr(s"${Type.show[A]}: $names isImplicit=${ps.isImplicit}, isGiven=${ps.isGiven}, isErased=${ps.isErased}")
+  Expr(s"${Type.show[A]}: $names isImplicit=${ps.isImplicit}, isGiven=${ps.isGiven}, erasedArgs=${ps.erasedArgs}")
 }
diff --git a/tests/run-macros/i12021/Test_2.scala b/tests/run-macros/i12021/Test_2.scala
index 17f74792ece4..a542b14f1175 100644
--- a/tests/run-macros/i12021/Test_2.scala
+++ b/tests/run-macros/i12021/Test_2.scala
@@ -1,11 +1,17 @@
 import scala.language.experimental.erasedDefinitions
 
+erased class EC
+
 class X1(implicit i: Int)
 class X2(using i: Int)
 class X3(erased i: Int)
+class X4(i: Int, erased j: Int)
+class X5(i: EC)
 
 @main def Test = {
   println(inspect[X1])
   println(inspect[X2])
   println(inspect[X3])
-}
\ No newline at end of file
+  println(inspect[X4])
+  println(inspect[X5])
+}
diff --git a/tests/run-macros/tasty-definitions-1.check b/tests/run-macros/tasty-definitions-1.check
index c2674c1b7a06..ce7251d7d3ee 100644
--- a/tests/run-macros/tasty-definitions-1.check
+++ b/tests/run-macros/tasty-definitions-1.check
@@ -108,56 +108,8 @@ ContextFunction24
 ContextFunction24
 ContextFunction25
 ContextFunction25
-ErasedFunction1
-ErasedFunction2
-ErasedFunction3
-ErasedFunction4
-ErasedFunction5
-ErasedFunction6
-ErasedFunction7
-ErasedFunction8
-ErasedFunction9
-ErasedFunction10
-ErasedFunction11
-ErasedFunction12
-ErasedFunction13
-ErasedFunction14
-ErasedFunction15
-ErasedFunction16
-ErasedFunction17
-ErasedFunction18
-ErasedFunction19
-ErasedFunction20
-ErasedFunction21
-ErasedFunction22
-ErasedFunction23
-ErasedFunction24
-ErasedFunction25
-ErasedContextFunction1
-ErasedContextFunction2
-ErasedContextFunction3
-ErasedContextFunction4
-ErasedContextFunction5
-ErasedContextFunction6
-ErasedContextFunction7
-ErasedContextFunction8
-ErasedContextFunction9
-ErasedContextFunction10
-ErasedContextFunction11
-ErasedContextFunction12
-ErasedContextFunction13
-ErasedContextFunction14
-ErasedContextFunction15
-ErasedContextFunction16
-ErasedContextFunction17
-ErasedContextFunction18
-ErasedContextFunction19
-ErasedContextFunction20
-ErasedContextFunction21
-ErasedContextFunction22
-ErasedContextFunction23
-ErasedContextFunction24
-ErasedContextFunction25
+class java.lang.Exception: Erased function classes are not supported. Use a refined `scala.runtime.ErasedFunction`
+ErasedFunction
 Tuple2
 Tuple3
 Tuple4
diff --git a/tests/run-macros/tasty-definitions-1/quoted_1.scala b/tests/run-macros/tasty-definitions-1/quoted_1.scala
index baf0b929f202..bf9e28288486 100644
--- a/tests/run-macros/tasty-definitions-1/quoted_1.scala
+++ b/tests/run-macros/tasty-definitions-1/quoted_1.scala
@@ -63,11 +63,10 @@ object Macros {
       printout(defn.FunctionClass(i, isContextual = true).name)
       printout(defn.FunctionClass(i, isImplicit = true).name)
 
-    for (i <- 1 to 25)
-      printout(defn.FunctionClass(i, isErased = true).name)
+    // should fail
+    printout(defn.FunctionClass(1, isErased = true).name)
 
-    for (i <- 1 to 25)
-      printout(defn.FunctionClass(i, isImplicit = true, isErased = true).name)
+    printout(defn.ErasedFunctionClass.name)
 
     for (i <- 2 to 22)
       printout(defn.TupleClass(i).name)

From da1b0289a68c7f3ccfb26494d5f107173fd96892 Mon Sep 17 00:00:00 2001
From: David Hua <d5hua@uwaterloo.ca>
Date: Wed, 1 Mar 2023 04:55:00 -0500
Subject: [PATCH 215/657] Reword error messages to be more user friendly.

---
 .../tools/dotc/transform/init/Errors.scala    |  8 ++---
 .../tools/dotc/transform/init/Semantic.scala  | 36 ++++++++++---------
 2 files changed, 24 insertions(+), 20 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/init/Errors.scala b/compiler/src/dotty/tools/dotc/transform/init/Errors.scala
index 762e029ba36f..366fd6be96a2 100644
--- a/compiler/src/dotty/tools/dotc/transform/init/Errors.scala
+++ b/compiler/src/dotty/tools/dotc/transform/init/Errors.scala
@@ -47,11 +47,11 @@ object Errors:
 
   case class AccessCold(field: Symbol)(val trace: Trace) extends Error:
     def show(using Context): String =
-      "Access field " + field.show +  " on a cold object." + stacktrace
+      "Access field " + field.show +  " on an uninitialized (Cold) object." + stacktrace
 
   case class CallCold(meth: Symbol)(val trace: Trace) extends Error:
     def show(using Context): String =
-      "Call method " + meth.show + " on a cold object." + stacktrace
+      "Call method " + meth.show + " on an uninitialized (Cold) object." + stacktrace
 
   case class CallUnknown(meth: Symbol)(val trace: Trace) extends Error:
     def show(using Context): String =
@@ -62,7 +62,7 @@ object Errors:
   case class UnsafePromotion(msg: String, error: Error)(val trace: Trace) extends Error:
     def show(using Context): String =
       msg + stacktrace + "\n" +
-        "Promoting the value to hot (transitively initialized) failed due to the following problem:\n" + {
+        "Promoting the value to transitively initialized (Hot) failed due to the following problem:\n" + {
           val ctx2 = ctx.withProperty(IsFromPromotion, Some(true))
           error.show(using ctx2)
         }
@@ -96,5 +96,5 @@ object Errors:
           acc + text2
         }
       val verb = if multiple then " are " else " is "
-      val adjective = "not hot (transitively initialized)."
+      val adjective = "not transitively initialized (Hot)."
       subject + verb + adjective
diff --git a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
index 286e3a124d12..a53a032f9fce 100644
--- a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
+++ b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
@@ -64,16 +64,18 @@ object Semantic:
   sealed abstract class Value:
     def show(using Context): String = this match
       case ThisRef(klass) =>
-        "ThisRef[" + klass.show + "]"
+        "the original object of type " + klass.show + " that started this trace"
       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 + " }"
+        "an initialized (Warm) object of type " + klass.show + "{ outer = " + outer.show + argsText + " }"
       case Fun(expr, thisV, klass) =>
-        "Fun { this = " + thisV.show + ", owner = " + klass.show + " }"
+        "a function { this = " + thisV.show + ", owner = " + klass.show + " }"
       case RefSet(values) =>
         values.map(_.show).mkString("Set { ", ", ", " }")
-      case _ =>
-        this.toString()
+      case Hot =>
+        "a transitively initialized (Hot) object"
+      case Cold =>
+        "an uninitialized (Cold) object"
 
     def isHot = this == Hot
     def isCold = this == Cold
@@ -470,7 +472,7 @@ object Semantic:
     def widenArg: Contextual[Value] =
       a match
       case _: Ref | _: Fun =>
-        val hasError = Reporter.hasErrors { a.promote("Argument cannot be promoted to hot") }
+        val hasError = Reporter.hasErrors { a.promote("Argument cannot be promoted to transitively initialized (Hot)") }
         if hasError then Cold else Hot
 
       case RefSet(refs) =>
@@ -707,7 +709,9 @@ object Semantic:
               // no source code available
               promoteArgs()
               // try promoting the receiver as last resort
-              val hasErrors = Reporter.hasErrors { ref.promote("try promote value to hot") }
+              val hasErrors = Reporter.hasErrors {
+                ref.promote(ref.show + " has no source code and could not be proven to be transitively initialized (Hot).")
+              }
               if hasErrors then
                 val error = CallUnknown(target)(trace)
                 reporter.report(error)
@@ -992,7 +996,7 @@ object Semantic:
                 eval(body, thisV, klass)
               }
               given Trace = Trace.empty.add(body)
-              res.promote("The function return value is not hot. Found = " + res.show + ".")
+              res.promote("Only transitively initialized (Hot) values can be returned by functions. The function " + fun.show + " returned " + res.show + ".")
             }
             if errors.nonEmpty then
               reporter.report(UnsafePromotion(msg, errors.head)(trace))
@@ -1036,7 +1040,7 @@ object Semantic:
         //
         // 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 +
+          report.error("[Internal error] Expect current segment to be transitively initialized (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
@@ -1053,12 +1057,12 @@ object Semantic:
                 val args = member.info.paramInfoss.flatten.map(_ => new ArgInfo(Hot: Value, 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 + ".")
+                  res.promote("Could not verify that the return value of " + member.show + " is transitively initialized (Hot). It was found to be " + 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 + ".")
+                  res.promote("Could not verify that the field " + member.show + " is transitively initialized (Hot). It was found to be " + res.show + ".")
                 }
           end for
 
@@ -1144,7 +1148,7 @@ object Semantic:
 
   extension (arg: ArgInfo)
     def promote: Contextual[Unit] = withTrace(arg.trace) {
-      arg.value.promote("Cannot prove the method argument is hot. Only hot values are safe to leak.\nFound = " + arg.value.show + ".")
+      arg.value.promote("Could not verify that the method argument is transitively initialized (Hot). It was found to be " + arg.value.show + ". Only transitively initialized arguments may be passed to methods outside the analyzed initialization region.")
     }
 
   /** Evaluate an expression with the given value for `this` in a given class `klass`
@@ -1285,12 +1289,12 @@ object Semantic:
           eval(qual, thisV, klass)
           val res = eval(rhs, thisV, klass)
           extendTrace(expr) {
-            res.ensureHot("The RHS of reassignment must be hot. Found = " + res.show + ". ")
+            res.ensureHot("The RHS of reassignment must be transitively initialized (Hot). It was found to be " + 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 + ". ")
+            res.ensureHot("The RHS of reassignment must be transitively initialized (Hot). It was found to be " + res.show + ". ")
           }
 
       case closureDef(ddef) =>
@@ -1313,14 +1317,14 @@ object Semantic:
       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 + ". ")
+          res.ensureHot("The value to be matched needs to be transitively initialized (Hot). It was found to be " + 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 + ". ")
+          res.ensureHot("return expression must be transitively initialized (Hot). It was found to be " + res.show + ". ")
         }
 
       case WhileDo(cond, body) =>

From 09b389b356f3baf6b6d8fa39bd50fb1a789874d5 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Wed, 1 Mar 2023 17:22:57 +0000
Subject: [PATCH 216/657] Change trytoShow's to not use raw string

---
 .../dotty/tools/dotc/core/Decorators.scala    |  5 +----
 .../tools/dotc/core/ShowDecoratorTest.scala   | 21 +++++++++++++++++++
 2 files changed, 22 insertions(+), 4 deletions(-)
 create mode 100644 compiler/test/dotty/tools/dotc/core/ShowDecoratorTest.scala

diff --git a/compiler/src/dotty/tools/dotc/core/Decorators.scala b/compiler/src/dotty/tools/dotc/core/Decorators.scala
index 9f55e29c0f59..4ef0dbc9a43b 100644
--- a/compiler/src/dotty/tools/dotc/core/Decorators.scala
+++ b/compiler/src/dotty/tools/dotc/core/Decorators.scala
@@ -280,10 +280,7 @@ object Decorators {
           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]"
+            s"... (cannot display due to ${ex.className} ${ex.getMessage}) ..."
       case _ => String.valueOf(x).nn
 
     /** Returns the simple class name of `x`. */
diff --git a/compiler/test/dotty/tools/dotc/core/ShowDecoratorTest.scala b/compiler/test/dotty/tools/dotc/core/ShowDecoratorTest.scala
new file mode 100644
index 000000000000..acc9d1914bf6
--- /dev/null
+++ b/compiler/test/dotty/tools/dotc/core/ShowDecoratorTest.scala
@@ -0,0 +1,21 @@
+package dotty.tools
+package dotc
+package core
+
+import Contexts.*, Decorators.*, Denotations.*, SymDenotations.*, Symbols.*, Types.*
+import printing.Formatting.Show
+
+import org.junit.Test
+import org.junit.Assert.*
+
+class ShowDecoratorTest extends DottyTest:
+  import ShowDecoratorTest.*
+
+  @Test def t1 = assertEquals("... (cannot display due to FooException boom) ...", Foo().tryToShow)
+end ShowDecoratorTest
+
+object ShowDecoratorTest:
+  import printing.*, Texts.*
+  class FooException extends Exception("boom")
+  case class Foo() extends Showable:
+    def toText(printer: Printer): Text = throw new FooException

From 378f5ff17f76c6370e9cba2f1c9775a055e0d377 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Wed, 1 Mar 2023 18:32:25 +0000
Subject: [PATCH 217/657] Add an enrichedErrorMessage on Run, so to only handle
 the first exception

---
 compiler/src/dotty/tools/dotc/Driver.scala    | 10 +--
 compiler/src/dotty/tools/dotc/Run.scala       | 32 +++++++---
 .../src/dotty/tools/dotc/core/Phases.scala    |  4 +-
 compiler/src/dotty/tools/dotc/report.scala    | 63 ++++++++++++++++++-
 .../src/dotty/tools/dotc/typer/ReTyper.scala  | 10 ++-
 5 files changed, 97 insertions(+), 22 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/Driver.scala b/compiler/src/dotty/tools/dotc/Driver.scala
index 5a2c8b7be56e..e548cae55ddd 100644
--- a/compiler/src/dotty/tools/dotc/Driver.scala
+++ b/compiler/src/dotty/tools/dotc/Driver.scala
@@ -30,18 +30,20 @@ class Driver {
 
   protected def doCompile(compiler: Compiler, files: List[AbstractFile])(using Context): Reporter =
     if files.nonEmpty then
+      var runOrNull = ctx.run
       try
         val run = compiler.newRun
+        runOrNull = run
         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(", ")}")
+        case ex: TypeError if !runOrNull.enrichedErrorMessage =>
+          println(runOrNull.enrichErrorMessage(s"${ex.toMessage} while compiling ${files.map(_.path).mkString(", ")}"))
           throw ex
-        case ex: Throwable =>
-          println(s"$ex while compiling ${files.map(_.path).mkString(", ")}")
+        case ex: Throwable if !runOrNull.enrichedErrorMessage =>
+          println(runOrNull.enrichErrorMessage(s"Exception while compiling ${files.map(_.path).mkString(", ")}"))
           throw ex
     ctx.reporter
 
diff --git a/compiler/src/dotty/tools/dotc/Run.scala b/compiler/src/dotty/tools/dotc/Run.scala
index 8cd1d160b42c..a46ded5d948b 100644
--- a/compiler/src/dotty/tools/dotc/Run.scala
+++ b/compiler/src/dotty/tools/dotc/Run.scala
@@ -173,15 +173,22 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
    */
   var ccImportEncountered = false
 
+  private var myEnrichedErrorMessage = false
+
+  def enrichedErrorMessage: Boolean = myEnrichedErrorMessage
+
+  def enrichErrorMessage(errorMessage: String)(using Context): String =
+    if enrichedErrorMessage then errorMessage
+    else
+      myEnrichedErrorMessage = true
+      report.enrichErrorMessage(errorMessage)
+
   def compile(files: List[AbstractFile]): Unit =
-    try
-      val sources = files.map(runContext.getSource(_))
-      compileSources(sources)
-    catch
-      case NonFatal(ex) =>
-        if units.nonEmpty then report.echo(i"exception occurred while compiling $units%, %")
-        else report.echo(s"exception occurred while compiling ${files.map(_.name).mkString(", ")}")
-        throw ex
+    try compileSources(files.map(runContext.getSource(_)))
+    catch case NonFatal(ex) if !enrichedErrorMessage =>
+      val files1 = if units.isEmpty then files else units.map(_.source.file)
+      report.echo(enrichErrorMessage(s"exception occurred while compiling ${files1.map(_.path)}"))
+      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
@@ -398,3 +405,12 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
   given runContext[Dummy_so_its_a_def]: Context = myCtx.nn
   assert(runContext.runId <= Periods.MaxPossibleRunId)
 }
+
+object Run {
+  extension (run: Run | Null)
+    def enrichedErrorMessage: Boolean = if run == null then false else run.enrichedErrorMessage
+    def enrichErrorMessage(errorMessage: String)(using Context): String =
+      if run == null
+      then report.enrichErrorMessage(errorMessage)
+      else run.enrichErrorMessage(errorMessage)
+}
diff --git a/compiler/src/dotty/tools/dotc/core/Phases.scala b/compiler/src/dotty/tools/dotc/core/Phases.scala
index 205554e418ed..00e017430a5f 100644
--- a/compiler/src/dotty/tools/dotc/core/Phases.scala
+++ b/compiler/src/dotty/tools/dotc/core/Phases.scala
@@ -322,8 +322,8 @@ object Phases {
       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")
+        catch case ex: Throwable if !ctx.run.enrichedErrorMessage =>
+          println(ctx.run.enrichErrorMessage(s"unhandled exception while running $phaseName on $unit"))
           throw ex
         unitCtx.compilationUnit
       }
diff --git a/compiler/src/dotty/tools/dotc/report.scala b/compiler/src/dotty/tools/dotc/report.scala
index c92fbe5daa56..38f2ab347c4c 100644
--- a/compiler/src/dotty/tools/dotc/report.scala
+++ b/compiler/src/dotty/tools/dotc/report.scala
@@ -4,13 +4,12 @@ import reporting._
 import Diagnostic._
 import util.{SourcePosition, NoSourcePosition, SrcPos}
 import core._
-import Contexts._, Symbols._, Decorators._
+import Contexts._, Flags.*, Symbols._, Decorators._
 import config.SourceVersion
 import ast._
 import config.Feature.sourceVersion
 import java.lang.System.currentTimeMillis
 
-
 object report:
 
   /** For sending messages that are printed only if -verbose is set */
@@ -129,4 +128,64 @@ object report:
       case Nil => pos
     recur(pos.sourcePos, tpd.enclosingInlineds)
 
+  private object messageRendering extends MessageRendering
+
+  // Should only be called from Run#enrichErrorMessage.
+  def enrichErrorMessage(errorMessage: String)(using Context): String = try {
+    def formatExplain(pairs: List[(String, Any)]) = pairs.map((k, v) => f"$k%20s: $v").mkString("\n")
+
+    val settings = ctx.settings.userSetSettings(ctx.settingsState).sortBy(_.name)
+    val tree     = ctx.tree
+    val sym      = tree.symbol
+    val pos      = tree.sourcePos
+    val path     = pos.source.path
+    val site     = ctx.outersIterator.map(_.owner).filter(sym => !sym.exists || sym.isClass || sym.is(Method)).next()
+
+    import untpd.*
+    extension (tree: Tree) def summaryString: String = tree match
+      case Literal(const)     => s"Literal($const)"
+      case Ident(name)        => s"Ident(${name.decode})"
+      case Select(qual, name) => s"Select(${qual.summaryString}, ${name.decode})"
+      case tree: NameTree     => (if tree.isType then "type " else "") + tree.name.decode
+      case tree               => s"${tree.className}${if tree.symbol.exists then s"(${tree.symbol})" else ""}"
+
+    val info1 = formatExplain(List(
+      "while compiling"    -> ctx.compilationUnit,
+      "during phase"       -> ctx.phase.prevMega,
+      "mode"               -> ctx.mode,
+      "library version"    -> scala.util.Properties.versionString,
+      "compiler version"   -> dotty.tools.dotc.config.Properties.versionString,
+      "settings"           -> settings.map(s => if s.value == "" then s"${s.name} \"\"" else s"${s.name} ${s.value}").mkString(" "),
+    ))
+    val symbolInfos = if sym eq NoSymbol then List("symbol" -> sym) else List(
+      "symbol"             -> sym.showLocated,
+      "symbol definition"  -> s"${sym.showDcl} (a ${sym.className})",
+      "symbol package"     -> sym.enclosingPackageClass.fullName,
+      "symbol owners"      -> sym.showExtendedLocation,
+    )
+    val info2 = formatExplain(List(
+      "tree"               -> tree.summaryString,
+      "tree position"      -> (if pos.exists then s"$path:${pos.line + 1}:${pos.column}" else s"$path:<unknown>"),
+      "tree type"          -> tree.typeOpt.show,
+    ) ::: symbolInfos ::: List(
+      "call site"          -> s"${site.showLocated} in ${site.enclosingPackageClass}"
+    ))
+    val context_s = try
+      s"""  == Source file context for tree position ==
+         |
+         |${messageRendering.messageAndPos(Diagnostic.Error("", pos))}""".stripMargin
+    catch case _: Exception => "<Cannot read source file>"
+    s"""
+       |  $errorMessage
+       |
+       |  An unhandled exception was thrown in the compiler.
+       |  Please file a crash report here:
+       |  https://github.com/lampepfl/dotty/issues/new/choose
+       |
+       |$info1
+       |
+       |$info2
+       |
+       |$context_s""".stripMargin
+  } catch case _: Throwable => errorMessage // don't introduce new errors trying to report errors, so swallow exceptions
 end report
diff --git a/compiler/src/dotty/tools/dotc/typer/ReTyper.scala b/compiler/src/dotty/tools/dotc/typer/ReTyper.scala
index b53b2f9ec57a..c64f541fd811 100644
--- a/compiler/src/dotty/tools/dotc/typer/ReTyper.scala
+++ b/compiler/src/dotty/tools/dotc/typer/ReTyper.scala
@@ -124,12 +124,10 @@ class ReTyper(nestingLevel: Int = 0) extends Typer(nestingLevel) with ReChecking
 
   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
-    }
+    catch case NonFatal(ex) if ctx.phase != Phases.typerPhase && ctx.phase != Phases.inliningPhase && !ctx.run.enrichedErrorMessage =>
+      val treeStr = tree.show(using ctx.withPhase(ctx.phase.prevMega))
+      println(ctx.run.enrichErrorMessage(s"exception while retyping $treeStr of class ${tree.className} # ${tree.uniqueId}"))
+      throw ex
 
   override def inlineExpansion(mdef: DefDef)(using Context): List[Tree] = mdef :: Nil
 

From 8020c77733b999259faf3fad342526de417c98d9 Mon Sep 17 00:00:00 2001
From: Lucas Leblanc <44496264+Dedelweiss@users.noreply.github.com>
Date: Thu, 2 Mar 2023 11:17:44 +0100
Subject: [PATCH 218/657] Fix: Correct the nightly version cut off in scaladoc
 (#17024)

In this commit I corrected the cut off of the nightly version by
changing :
- The width in auto for desktop version
- The max-width in `calc(12 * var(--base-spacing));` for better
responsiveness

Desktop
Before:
<img width="994" alt="Screenshot 2023-03-01 at 11 04 44"
src="https://user-images.githubusercontent.com/44496264/222109159-79249ec2-359c-4782-9dcc-88c75ca10454.png">

After:
<img width="1001" alt="Screenshot 2023-03-01 at 11 04 27"
src="https://user-images.githubusercontent.com/44496264/222109141-630a85ef-d2c2-4312-b143-d54f97c2506e.png">

Mobile
Before:
<img width="409" alt="Screenshot 2023-03-01 at 11 13 07"
src="https://user-images.githubusercontent.com/44496264/222109747-253c685e-44ea-4e5d-8330-f2576c729895.png">

After:
<img width="409" alt="Screenshot 2023-03-01 at 11 07 12"
src="https://user-images.githubusercontent.com/44496264/222108968-ae3cc503-cca2-4a65-a76d-9d7e1006e131.png">

Fixes: #16588
---
 scaladoc/resources/dotty_res/styles/theme/layout/header.css | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/scaladoc/resources/dotty_res/styles/theme/layout/header.css b/scaladoc/resources/dotty_res/styles/theme/layout/header.css
index 2e33023d0701..cf3b91db2698 100644
--- a/scaladoc/resources/dotty_res/styles/theme/layout/header.css
+++ b/scaladoc/resources/dotty_res/styles/theme/layout/header.css
@@ -72,7 +72,7 @@
   overflow: hidden;
   white-space: nowrap;
   text-overflow: ellipsis;
-  width: calc(9 * var(--base-spacing));
+  width: auto;
 }
 
 .single {
@@ -103,6 +103,10 @@
   #search-toggle {
     display: none;
   }
+
+  .projectVersion{
+    max-width: calc(12 * var(--base-spacing));
+  }
 }
 
 

From 20174d7d15a43918a1424c7e8eabfdaeb2703331 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Fri, 17 Feb 2023 15:07:47 +0100
Subject: [PATCH 219/657] Replace quoted type variables in signature of HOAS
 pattern result

To be able to construct the lambda returned by the HOAS pattern we need:
first resolve the type variables and then use the result to construct the
signature of the lambdas.

To simplify this transformation, `QuoteMatcher` returns a `Seq[MatchResult]`
instead of an untyped `Tuple` containing `Expr[?]`. The tuple is created
once we have accumulated and processed all extracted values.

Fixes #15165
---
 .../quoted/runtime/impl/QuoteMatcher.scala    | 87 +++++++++++++------
 .../quoted/runtime/impl/QuotesImpl.scala      | 23 +++--
 tests/pos-macros/i15165a/Macro_1.scala        |  9 ++
 tests/pos-macros/i15165a/Test_2.scala         |  4 +
 tests/pos-macros/i15165b/Macro_1.scala        | 16 ++++
 tests/pos-macros/i15165b/Test_2.scala         |  4 +
 tests/pos-macros/i15165c/Macro_1.scala        |  9 ++
 tests/pos-macros/i15165c/Test_2.scala         |  4 +
 8 files changed, 122 insertions(+), 34 deletions(-)
 create mode 100644 tests/pos-macros/i15165a/Macro_1.scala
 create mode 100644 tests/pos-macros/i15165a/Test_2.scala
 create mode 100644 tests/pos-macros/i15165b/Macro_1.scala
 create mode 100644 tests/pos-macros/i15165b/Test_2.scala
 create mode 100644 tests/pos-macros/i15165c/Macro_1.scala
 create mode 100644 tests/pos-macros/i15165c/Test_2.scala

diff --git a/compiler/src/scala/quoted/runtime/impl/QuoteMatcher.scala b/compiler/src/scala/quoted/runtime/impl/QuoteMatcher.scala
index 9a77cba97400..5477628a30a3 100644
--- a/compiler/src/scala/quoted/runtime/impl/QuoteMatcher.scala
+++ b/compiler/src/scala/quoted/runtime/impl/QuoteMatcher.scala
@@ -109,7 +109,7 @@ object QuoteMatcher {
   /** Sequence of matched expressions.
    *  These expressions are part of the scrutinee and will be bound to the quote pattern term splices.
    */
-  type MatchingExprs = Seq[Expr[Any]]
+  type MatchingExprs = Seq[MatchResult]
 
   /** A map relating equivalent symbols from the scrutinee and the pattern
     *  For example in
@@ -141,12 +141,13 @@ object QuoteMatcher {
   extension (scrutinee0: Tree)
 
     /** Check that the trees match and return the contents from the pattern holes.
-      *  Return None if the trees do not match otherwise return Some of a tuple containing all the contents in the holes.
+      *  Return a sequence containing all the contents in the holes.
+      *  If it does not match, continues to the `optional` with `None`.
       *
       *  @param scrutinee The tree being matched
       *  @param pattern The pattern tree that the scrutinee should match. Contains `patternHole` holes.
       *  @param `summon[Env]` Set of tuples containing pairs of symbols (s, p) where s defines a symbol in `scrutinee` which corresponds to symbol p in `pattern`.
-      *  @return `None` if it did not match or `Some(tup: MatchingExprs)` if it matched where `tup` contains the contents of the holes.
+      *  @return The sequence with the contents of the holes of the matched expression.
       */
     private def =?= (pattern0: Tree)(using Env, Context): optional[MatchingExprs] =
 
@@ -205,31 +206,12 @@ object QuoteMatcher {
         // Matches an open term and wraps it into a lambda that provides the free variables
         case Apply(TypeApply(Ident(_), List(TypeTree())), SeqLiteral(args, _) :: Nil)
             if pattern.symbol.eq(defn.QuotedRuntimePatterns_higherOrderHole) =>
-          def hoasClosure = {
-            val names: List[TermName] = args.map {
-              case Block(List(DefDef(nme.ANON_FUN, _, _, Apply(Ident(name), _))), _) => name.asTermName
-              case arg => arg.symbol.name.asTermName
-            }
-            val argTypes = args.map(x => x.tpe.widenTermRefExpr)
-            val methTpe = MethodType(names)(_ => argTypes, _ => pattern.tpe)
-            val meth = newAnonFun(ctx.owner, methTpe)
-            def bodyFn(lambdaArgss: List[List[Tree]]): Tree = {
-              val argsMap = args.map(_.symbol).zip(lambdaArgss.head).toMap
-              val body = new TreeMap {
-                override def transform(tree: Tree)(using Context): Tree =
-                  tree match
-                    case tree: Ident => summon[Env].get(tree.symbol).flatMap(argsMap.get).getOrElse(tree)
-                    case tree => super.transform(tree)
-              }.transform(scrutinee)
-              TreeOps(body).changeNonLocalOwners(meth)
-            }
-            Closure(meth, bodyFn)
-          }
+          val env = summon[Env]
           val capturedArgs = args.map(_.symbol)
-          val captureEnv = summon[Env].filter((k, v) => !capturedArgs.contains(v))
+          val captureEnv = env.filter((k, v) => !capturedArgs.contains(v))
           withEnv(captureEnv) {
             scrutinee match
-              case ClosedPatternTerm(scrutinee) => matched(hoasClosure)
+              case ClosedPatternTerm(scrutinee) => matchedOpen(scrutinee, pattern.tpe, args, env)
               case _ => notMatched
           }
 
@@ -453,6 +435,52 @@ object QuoteMatcher {
       accumulator.apply(Set.empty, term)
   }
 
+  enum MatchResult:
+    /** Closed pattern extracted value
+     *  @param tree Scrutinee sub-tree that matched
+     */
+    case ClosedTree(tree: Tree)
+    /** HOAS pattern extracted value
+     *
+     *  @param tree Scrutinee sub-tree that matched
+     *  @param patternTpe Type of the pattern hole (from the pattern)
+     *  @param args HOAS arguments (from the pattern)
+     *  @param env Mapping between scrutinee and pattern variables
+     */
+    case OpenTree(tree: Tree, patternTpe: Type, args: List[Tree], env: Env)
+
+    /** Return the expression that was extracted from a hole.
+     *
+     *  If it was a closed expression it returns that expression. Otherwise,
+     *  if it is a HOAS pattern, the surrounding lambda is generated using
+     *  `mapTypeHoles` to create the signature of the lambda.
+     *
+     *  This expression is assumed to be a valid expression in the given splice scope.
+     */
+    def toExpr(mapTypeHoles: TypeMap, spliceScope: Scope)(using Context): Expr[Any] = this match
+      case MatchResult.ClosedTree(tree) =>
+        new ExprImpl(tree, spliceScope)
+      case MatchResult.OpenTree(tree, patternTpe, args, env) =>
+        val names: List[TermName] = args.map {
+          case Block(List(DefDef(nme.ANON_FUN, _, _, Apply(Ident(name), _))), _) => name.asTermName
+          case arg => arg.symbol.name.asTermName
+        }
+        val paramTypes = args.map(x => mapTypeHoles(x.tpe.widenTermRefExpr))
+        val methTpe = MethodType(names)(_ => paramTypes, _ => mapTypeHoles(patternTpe))
+        val meth = newAnonFun(ctx.owner, methTpe)
+        def bodyFn(lambdaArgss: List[List[Tree]]): Tree = {
+          val argsMap = args.view.map(_.symbol).zip(lambdaArgss.head).toMap
+          val body = new TreeMap {
+            override def transform(tree: Tree)(using Context): Tree =
+              tree match
+                case tree: Ident => env.get(tree.symbol).flatMap(argsMap.get).getOrElse(tree)
+                case tree => super.transform(tree)
+          }.transform(tree)
+          TreeOps(body).changeNonLocalOwners(meth)
+        }
+        val hoasClosure = Closure(meth, bodyFn)
+        new ExprImpl(hoasClosure, spliceScope)
+
   private inline def notMatched: optional[MatchingExprs] =
     optional.break()
 
@@ -460,9 +488,14 @@ object QuoteMatcher {
     Seq.empty
 
   private inline def matched(tree: Tree)(using Context): MatchingExprs =
-    Seq(new ExprImpl(tree, SpliceScope.getCurrent))
+    Seq(MatchResult.ClosedTree(tree))
+
+  private def matchedOpen(tree: Tree, patternTpe: Type, args: List[Tree], env: Env)(using Context): MatchingExprs =
+    Seq(MatchResult.OpenTree(tree, patternTpe, args, env))
 
   extension (self: MatchingExprs)
-    private inline def &&& (that: MatchingExprs): MatchingExprs = self ++ that
+      /** Concatenates the contents of two successful matchings */
+      def &&& (that: MatchingExprs): MatchingExprs = self ++ that
+  end extension
 
 }
diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
index 378f3f6a5c40..a94f40a8d068 100644
--- a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
+++ b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
@@ -3137,18 +3137,27 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
         ctx1.gadtState.addToConstraint(typeHoles)
         ctx1
 
-    val matchings = QuoteMatcher.treeMatch(scrutinee, pat1)(using ctx1)
-
     // After matching and doing all subtype checks, we have to approximate all the type bindings
     // that we have found, seal them in a quoted.Type and add them to the result
     def typeHoleApproximation(sym: Symbol) =
       val fromAboveAnnot = sym.hasAnnotation(dotc.core.Symbols.defn.QuotedRuntimePatterns_fromAboveAnnot)
       val fullBounds = ctx1.gadt.fullBounds(sym)
-      val tp = if fromAboveAnnot then fullBounds.hi else fullBounds.lo
-      reflect.TypeReprMethods.asType(tp)
-    matchings.map { tup =>
-      val results = typeHoles.map(typeHoleApproximation) ++ tup
-      Tuple.fromIArray(results.toArray.asInstanceOf[IArray[Object]])
+      if fromAboveAnnot then fullBounds.hi else fullBounds.lo
+
+    QuoteMatcher.treeMatch(scrutinee, pat1)(using ctx1).map { matchings =>
+      import QuoteMatcher.MatchResult.*
+      lazy val spliceScope = SpliceScope.getCurrent
+      val typeHoleApproximations = typeHoles.map(typeHoleApproximation)
+      val typeHoleMapping = Map(typeHoles.zip(typeHoleApproximations)*)
+      val typeHoleMap = new Types.TypeMap {
+          def apply(tp: Types.Type): Types.Type = tp match
+            case Types.TypeRef(Types.NoPrefix, _) => typeHoleMapping.getOrElse(tp.typeSymbol, tp)
+            case _ => mapOver(tp)
+      }
+      val matchedExprs = matchings.map(_.toExpr(typeHoleMap, spliceScope))
+      val matchedTypes = typeHoleApproximations.map(reflect.TypeReprMethods.asType)
+      val results = matchedTypes ++ matchedExprs
+      Tuple.fromIArray(IArray.unsafeFromArray(results.toArray))
     }
   }
 
diff --git a/tests/pos-macros/i15165a/Macro_1.scala b/tests/pos-macros/i15165a/Macro_1.scala
new file mode 100644
index 000000000000..8838d4c06bd1
--- /dev/null
+++ b/tests/pos-macros/i15165a/Macro_1.scala
@@ -0,0 +1,9 @@
+import scala.quoted.*
+
+inline def valToFun[T](inline expr: T): T =
+  ${ impl('expr) }
+
+def impl[T: Type](expr: Expr[T])(using quotes: Quotes): Expr[T] =
+  expr match
+    case '{ { val ident = ($a: α); $rest(ident): T } } =>
+      '{ { (y: α) => $rest(y) }.apply(???) }
diff --git a/tests/pos-macros/i15165a/Test_2.scala b/tests/pos-macros/i15165a/Test_2.scala
new file mode 100644
index 000000000000..f7caa67b2df7
--- /dev/null
+++ b/tests/pos-macros/i15165a/Test_2.scala
@@ -0,0 +1,4 @@
+def test = valToFun {
+  val a: Int = 1
+  a + 1
+}
diff --git a/tests/pos-macros/i15165b/Macro_1.scala b/tests/pos-macros/i15165b/Macro_1.scala
new file mode 100644
index 000000000000..5d62db37e313
--- /dev/null
+++ b/tests/pos-macros/i15165b/Macro_1.scala
@@ -0,0 +1,16 @@
+import scala.quoted.*
+
+inline def valToFun[T](inline expr: T): T =
+  ${ impl('expr) }
+
+def impl[T: Type](expr: Expr[T])(using quotes: Quotes): Expr[T] =
+  expr match
+    case '{ { val ident = ($a: α); $rest(ident): T } } =>
+      '{
+        { (y: α) =>
+          ${
+            val bound   = '{ ${ rest }(y) }
+            Expr.betaReduce(bound)
+          }
+        }.apply($a)
+      }
diff --git a/tests/pos-macros/i15165b/Test_2.scala b/tests/pos-macros/i15165b/Test_2.scala
new file mode 100644
index 000000000000..f7caa67b2df7
--- /dev/null
+++ b/tests/pos-macros/i15165b/Test_2.scala
@@ -0,0 +1,4 @@
+def test = valToFun {
+  val a: Int = 1
+  a + 1
+}
diff --git a/tests/pos-macros/i15165c/Macro_1.scala b/tests/pos-macros/i15165c/Macro_1.scala
new file mode 100644
index 000000000000..036363bf274f
--- /dev/null
+++ b/tests/pos-macros/i15165c/Macro_1.scala
@@ -0,0 +1,9 @@
+import scala.quoted.*
+
+inline def valToFun[T](inline expr: T): T =
+  ${ impl('expr) }
+
+def impl[T: Type](expr: Expr[T])(using quotes: Quotes): Expr[T] =
+  expr match
+    case '{ type α; { val ident = ($a: `α`); $rest(ident): `α` & T } } =>
+      '{ { (y: α) => $rest(y) }.apply(???) }
diff --git a/tests/pos-macros/i15165c/Test_2.scala b/tests/pos-macros/i15165c/Test_2.scala
new file mode 100644
index 000000000000..f7caa67b2df7
--- /dev/null
+++ b/tests/pos-macros/i15165c/Test_2.scala
@@ -0,0 +1,4 @@
+def test = valToFun {
+  val a: Int = 1
+  a + 1
+}

From f02f7dda6476a499858576a15c6edb2498650e1b Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Fri, 3 Mar 2023 11:46:35 +0100
Subject: [PATCH 220/657] Cleanup test that prints onto the `compilationTest`
 output

---
 tests/neg-macros/i16582/Macro_1.scala | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tests/neg-macros/i16582/Macro_1.scala b/tests/neg-macros/i16582/Macro_1.scala
index dea58b89f017..c28c83166607 100644
--- a/tests/neg-macros/i16582/Macro_1.scala
+++ b/tests/neg-macros/i16582/Macro_1.scala
@@ -11,7 +11,6 @@ def ownerWorksImpl(in: Expr[Int])(using Quotes): Expr[String] =
   val position = Position.ofMacroExpansion
   val file = position.sourceFile
   val owner0 = Symbol.spliceOwner.maybeOwner
-  println("owner0 = " + owner0)
   val ownerName = owner0.tree match {
     case ValDef(name, _, _) =>
       name

From cf18183c6b6edd0e4949ab1e07713d62ca295ab2 Mon Sep 17 00:00:00 2001
From: kenji yoshida <6b656e6a69@gmail.com>
Date: Sat, 4 Mar 2023 10:11:41 +0900
Subject: [PATCH 221/657] remove unnecessary cast in `transformStatement`

---
 library/src/scala/quoted/Quotes.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/src/scala/quoted/Quotes.scala b/library/src/scala/quoted/Quotes.scala
index 79a4ea039ab5..7668617fa71c 100644
--- a/library/src/scala/quoted/Quotes.scala
+++ b/library/src/scala/quoted/Quotes.scala
@@ -4893,7 +4893,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
                 case self: ValDef => self
             }
             val body = tree.body.map(transformStatement(_)(tree.symbol))
-            ClassDef.copy(tree)(tree.name, constructor.asInstanceOf[DefDef], parents, self, body) // cast as workaround for lampepfl/dotty#14821. TODO remove when referenceVersion >= 3.2.0-RC1
+            ClassDef.copy(tree)(tree.name, constructor, parents, self, body)
           case tree: Import =>
             Import.copy(tree)(transformTerm(tree.expr)(owner), tree.selectors)
           case tree: Export =>

From c417db0bf370ddc4a3e24f5b193c5c7f21d77aea Mon Sep 17 00:00:00 2001
From: Arman Bilge <armanbilge@gmail.com>
Date: Sat, 4 Mar 2023 02:09:44 -0800
Subject: [PATCH 222/657] Set `target="_blank"` for Source links in Scaladoc
 (#16282)

Context:
- https://github.com/erikerlandson/coulomb/issues/368

This seems to be necessary so that the source links work with
javadoc.io. Note that Scaladoc 2 sets `target="_blank"`.
---
 .../src/dotty/tools/scaladoc/renderers/MemberRenderer.scala     | 2 +-
 scaladoc/src/dotty/tools/scaladoc/util/html.scala               | 1 +
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/scaladoc/src/dotty/tools/scaladoc/renderers/MemberRenderer.scala b/scaladoc/src/dotty/tools/scaladoc/renderers/MemberRenderer.scala
index f2501378bf72..7133fe6d657f 100644
--- a/scaladoc/src/dotty/tools/scaladoc/renderers/MemberRenderer.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/renderers/MemberRenderer.scala
@@ -72,7 +72,7 @@ class MemberRenderer(signatureRenderer: SignatureRenderer)(using DocContext) ext
 
   def source(m: Member): Seq[AppliedTag] =
     summon[DocContext].sourceLinks.pathTo(m).fold(Nil){ link =>
-      tableRow("Source", a(href := link)(m.sources.fold("(source)")(_.path.getFileName().toString())))
+      tableRow("Source", a(href := link, target := "_blank")(m.sources.fold("(source)")(_.path.getFileName().toString())))
     }
 
   def deprecation(m: Member): Seq[AppliedTag] = m.deprecated.fold(Nil){ a =>
diff --git a/scaladoc/src/dotty/tools/scaladoc/util/html.scala b/scaladoc/src/dotty/tools/scaladoc/util/html.scala
index e66ba3a4b706..72776a7413aa 100644
--- a/scaladoc/src/dotty/tools/scaladoc/util/html.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/util/html.scala
@@ -108,6 +108,7 @@ object HTML:
   val onclick=Attr("onclick")
   val titleAttr =Attr("title")
   val onkeyup = Attr("onkeyup")
+  val target = Attr("target")
 
   def raw(content: String): AppliedTag = new AppliedTag(content)
   def raw(content: StringBuilder): AppliedTag = content

From 137a6842181c353e8d76a9872be996dbc6d6f850 Mon Sep 17 00:00:00 2001
From: Ondra Pelech <ondra.pelech@gmail.com>
Date: Sun, 5 Mar 2023 02:12:56 +0100
Subject: [PATCH 223/657] Documentation: principle of optional braces

---
 docs/_docs/reference/syntax.md | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/docs/_docs/reference/syntax.md b/docs/_docs/reference/syntax.md
index 8da41c7e6d0c..6abc3b2011d1 100644
--- a/docs/_docs/reference/syntax.md
+++ b/docs/_docs/reference/syntax.md
@@ -105,7 +105,10 @@ semi             ::=  ‘;’ |  nl {nl}
 
 ## Optional Braces
 
-The lexical analyzer also inserts `indent` and `outdent` tokens that represent regions of indented code [at certain points](./other-new-features/indentation.md).
+The principle of optional braces is that any keyword that can be followed by `{` can also be followed by an indented block, without needing an intervening `:`.
+(Allowing an optional `:` would be counterproductive since it would introduce several ways to do the same thing.)
+
+The lexical analyzer inserts `indent` and `outdent` tokens that represent regions of indented code [at certain points](./other-new-features/indentation.md).
 
 In the context-free productions below we use the notation `<<< ts >>>`
 to indicate a token sequence `ts` that is either enclosed in a pair of braces `{ ts }` or that constitutes an indented region `indent ts outdent`. Analogously, the

From a30176966dc7ec948284ab91a7e96a2420463f1e Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Sun, 5 Mar 2023 20:23:34 +0100
Subject: [PATCH 224/657] Scaladoc: Fix expand icon not changing on anchor link

---
 scaladoc/resources/dotty_res/scripts/ux.js | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/scaladoc/resources/dotty_res/scripts/ux.js b/scaladoc/resources/dotty_res/scripts/ux.js
index 304f2af9e129..0ead006af84d 100644
--- a/scaladoc/resources/dotty_res/scripts/ux.js
+++ b/scaladoc/resources/dotty_res/scripts/ux.js
@@ -309,6 +309,10 @@ document
       var selected = document.getElementById(location.hash.substring(1));
       if (selected) {
         selected.classList.toggle("expand");
+        selected.classList.toggle("expanded");
+        const btn = selected.querySelector(".icon-button");
+        btn.classList.toggle("expand");
+        btn.classList.toggle("expanded");
       }
     }
   }

From 353d964842b5aa5028f605ffd523b3c031da3591 Mon Sep 17 00:00:00 2001
From: David Hua <d5hua@uwaterloo.ca>
Date: Mon, 6 Mar 2023 01:54:18 -0500
Subject: [PATCH 225/657] Remove unnecessary cacheResult=false, add test case.

---
 .../src/dotty/tools/dotc/transform/init/Semantic.scala   | 2 +-
 tests/init/pos/recursion.scala                           | 9 +++++++++
 2 files changed, 10 insertions(+), 1 deletion(-)
 create mode 100644 tests/init/pos/recursion.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
index 11376f427158..74e14691a45e 100644
--- a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
+++ b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
@@ -893,7 +893,7 @@ object Semantic:
 
               case Cold => Cold
 
-              case ref: Ref => eval(vdef.rhs, ref, enclosingClass, cacheResult = true)
+              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)
diff --git a/tests/init/pos/recursion.scala b/tests/init/pos/recursion.scala
new file mode 100644
index 000000000000..394092945cb3
--- /dev/null
+++ b/tests/init/pos/recursion.scala
@@ -0,0 +1,9 @@
+class A {
+
+  val f: Int => Int = {
+    x => f(x)
+  }
+
+  f(5)
+
+}

From ff4610474e40960cf6354bd4afb4bb621b947b0c Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 6 Mar 2023 09:16:14 +0100
Subject: [PATCH 226/657] Add regression test

Closes #16943
---
 tests/run/i16943.scala | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 tests/run/i16943.scala

diff --git a/tests/run/i16943.scala b/tests/run/i16943.scala
new file mode 100644
index 000000000000..68e1f8fb5aa3
--- /dev/null
+++ b/tests/run/i16943.scala
@@ -0,0 +1,6 @@
+@main
+@annotation.experimental
+def Test(): Unit = fail(compiletime.erasedValue, 1)
+
+@annotation.experimental
+def fail(dumb: CanThrow[Exception], x: Int) = println(x)

From 0a1ceb9c2e4bccc26c1af4ed65c89046c380795c Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 6 Mar 2023 09:31:15 +0100
Subject: [PATCH 227/657] Fix splice type variable pattern detection

Fixes #17039
---
 compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala | 2 +-
 tests/pos-macros/i17039.scala                              | 7 +++++++
 2 files changed, 8 insertions(+), 1 deletion(-)
 create mode 100644 tests/pos-macros/i17039.scala

diff --git a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
index 65d8abfdf6a7..b00c10503b70 100644
--- a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
+++ b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
@@ -249,7 +249,7 @@ trait QuotesAndSplices {
             val pat1 = if (patType eq patType1) pat else pat.withType(patType1)
             patBuf += pat1
           }
-        case Select(pat, _) if tree.symbol.isTypeSplice =>
+        case Select(pat: Bind, _) if tree.symbol.isTypeSplice =>
           val sym = tree.tpe.dealias.typeSymbol
           if sym.exists then
             val tdef = TypeDef(sym.asType).withSpan(sym.span)
diff --git a/tests/pos-macros/i17039.scala b/tests/pos-macros/i17039.scala
new file mode 100644
index 000000000000..6f983b138526
--- /dev/null
+++ b/tests/pos-macros/i17039.scala
@@ -0,0 +1,7 @@
+import scala.quoted.*
+
+def macroImpl(using Quotes) =
+  val t = summon[Type[Int]]
+  Type.of[Int] match
+    case '[t.Underlying] => '{true}
+    case _ => '{false}

From bb5c0987d25ca1063ee15ca2c0060a6c1ec679b0 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 6 Mar 2023 10:14:32 +0100
Subject: [PATCH 228/657] Dealias type references when healing types in quotes

We where only doing the dealiasing if the type had no prefix but missed
it if the type reference was on some path.

Fixes #17037
---
 .../dotc/transform/PCPCheckAndHeal.scala      | 19 ++++++++++++++-----
 tests/pos-macros/i17037.scala                 |  8 ++++++++
 tests/pos-macros/i17037b.scala                | 10 ++++++++++
 tests/pos-macros/i17037c.scala                |  7 +++++++
 4 files changed, 39 insertions(+), 5 deletions(-)
 create mode 100644 tests/pos-macros/i17037.scala
 create mode 100644 tests/pos-macros/i17037b.scala
 create mode 100644 tests/pos-macros/i17037c.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala b/compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala
index e2e494a95074..6d3b62357d7f 100644
--- a/compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala
@@ -192,11 +192,9 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
         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)
+              tryHealTypeOfType(tp.symbol, tp, pos)
             case prefix: ThisType if !tp.symbol.isStatic && level > levelOf(prefix.cls) =>
-              tryHeal(tp.symbol, tp, pos)
+              tryHealTypeOfType(tp.symbol, tp, pos)
             case prefix: TermRef if tp.symbol.isTypeSplice =>
               prefix.symbol.info.argInfos match
                 case (tb: TypeBounds) :: _ =>
@@ -205,7 +203,7 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
               // 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)
+              tryHealTypeOfType(prefix.symbol, tp, pos)
             case _ =>
               mapOver(tp)
         case tp @ TermRef(NoPrefix, _) if !tp.symbol.isStatic && level > levelOf(tp.symbol) =>
@@ -217,6 +215,17 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
           derivedAnnotatedType(tp, apply(tp.parent), tp.annot.derivedAnnotation(newAnnotTree))
         case _ =>
           mapOver(tp)
+
+    /** Try to dealias or 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`.
+     */
+    private def tryHealTypeOfType(sym: Symbol, tp: TypeRef, pos: SrcPos)(using Context): Type = {
+      val tp1 = tp.dealias
+      if tp1 != tp then apply(tp1)
+      else tryHeal(tp.symbol, tp, pos)
+    }
   }
 
   /** Check phase consistency of terms and heal inconsistent type references. */
diff --git a/tests/pos-macros/i17037.scala b/tests/pos-macros/i17037.scala
new file mode 100644
index 000000000000..1048d84ffe96
--- /dev/null
+++ b/tests/pos-macros/i17037.scala
@@ -0,0 +1,8 @@
+import scala.quoted.*
+
+class Foo:
+  type Bar = Int
+
+def macroImpl(using Quotes) =
+  val foo = new Foo
+  Type.of[foo.Bar]
diff --git a/tests/pos-macros/i17037b.scala b/tests/pos-macros/i17037b.scala
new file mode 100644
index 000000000000..60d2bec33330
--- /dev/null
+++ b/tests/pos-macros/i17037b.scala
@@ -0,0 +1,10 @@
+import scala.quoted.*
+
+class Foo:
+  type Bar = Int
+
+def macroImpl(using Quotes) =
+  val foo = Foo()
+  Type.of[foo.Bar] match
+    case '[foo.Bar] => '{true}
+    case _ => '{false}
diff --git a/tests/pos-macros/i17037c.scala b/tests/pos-macros/i17037c.scala
new file mode 100644
index 000000000000..56cd8f7a2d41
--- /dev/null
+++ b/tests/pos-macros/i17037c.scala
@@ -0,0 +1,7 @@
+import scala.quoted.*
+
+class Foo:
+  type Bar = Int
+  def macroImpl(using Quotes) =
+    val foo = new Foo
+    Type.of[this.Bar]

From 585409a4d16aea90e60d2445595fa3c2798cc2c9 Mon Sep 17 00:00:00 2001
From: David Hua <d5hua@uwaterloo.ca>
Date: Mon, 6 Mar 2023 04:20:17 -0500
Subject: [PATCH 229/657] Update check files, minor wording changes to error
 messages

---
 .../tools/dotc/transform/init/Semantic.scala  |  8 ++--
 tests/init/neg/closureLeak.check              | 22 +++++------
 tests/init/neg/cycle-structure.check          |  8 ++--
 tests/init/neg/default-this.check             | 21 +++++-----
 tests/init/neg/i15363.check                   |  4 +-
 tests/init/neg/i15459.check                   | 17 ++++-----
 tests/init/neg/inherit-non-hot.check          | 26 ++++++-------
 tests/init/neg/inlined-method.check           | 17 ++++-----
 tests/init/neg/inner-first.check              | 13 +++----
 tests/init/neg/leak-warm.check                |  2 +-
 tests/init/neg/promotion-loop.check           | 21 +++++-----
 tests/init/neg/promotion-segment3.check       | 15 ++++----
 tests/init/neg/secondary-ctor4.check          |  8 ++--
 tests/init/neg/t3273.check                    | 38 +++++++++----------
 tests/init/neg/unsound1.check                 |  2 +-
 tests/init/neg/unsound2.check                 |  2 +-
 tests/init/neg/unsound3.check                 |  2 +-
 17 files changed, 108 insertions(+), 118 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
index a53a032f9fce..727e54833063 100644
--- a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
+++ b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
@@ -64,7 +64,7 @@ object Semantic:
   sealed abstract class Value:
     def show(using Context): String = this match
       case ThisRef(klass) =>
-        "the original object of type " + klass.show + " that started this trace"
+        "the original object of type \"" + klass.show + "\" that started this trace"
       case Warm(klass, outer, ctor, args) =>
         val argsText = if args.nonEmpty then ", args = " + args.map(_.show).mkString("(", ", ", ")") else ""
         "an initialized (Warm) object of type " + klass.show + "{ outer = " + outer.show + argsText + " }"
@@ -472,7 +472,7 @@ object Semantic:
     def widenArg: Contextual[Value] =
       a match
       case _: Ref | _: Fun =>
-        val hasError = Reporter.hasErrors { a.promote("Argument cannot be promoted to transitively initialized (Hot)") }
+        val hasError = Reporter.hasErrors { a.promote("Argument cannot be proven to be transitively initialized (Hot)") }
         if hasError then Cold else Hot
 
       case RefSet(refs) =>
@@ -996,7 +996,7 @@ object Semantic:
                 eval(body, thisV, klass)
               }
               given Trace = Trace.empty.add(body)
-              res.promote("Only transitively initialized (Hot) values can be returned by functions. The function " + fun.show + " returned " + res.show + ".")
+              res.promote("Only transitively initialized (Hot) values can be returned by functions. The function " + fun.show + " returns " + res.show + ".")
             }
             if errors.nonEmpty then
               reporter.report(UnsafePromotion(msg, errors.head)(trace))
@@ -1040,7 +1040,7 @@ object Semantic:
         //
         // 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 be transitively initialized (hot) in promotion, current klass = " + klass.show +
+          report.error("[Internal error] Expect current segment to be transitively initialized (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
diff --git a/tests/init/neg/closureLeak.check b/tests/init/neg/closureLeak.check
index 7019f2274ab6..c4e85d7db4b0 100644
--- a/tests/init/neg/closureLeak.check
+++ b/tests/init/neg/closureLeak.check
@@ -1,16 +1,14 @@
 -- Error: tests/init/neg/closureLeak.scala:11:14 -----------------------------------------------------------------------
 11 |    l.foreach(a => a.addX(this)) // error
    |              ^^^^^^^^^^^^^^^^^
-   |              Cannot prove the method argument is hot. Only hot values are safe to leak.
-   |              Found = Fun { this = ThisRef[class Outer], owner = class Outer }. Calling trace:
-   |              -> class Outer {	[ closureLeak.scala:1 ]
-   |                 ^
-   |              -> l.foreach(a => a.addX(this)) // error	[ closureLeak.scala:11 ]
-   |                           ^^^^^^^^^^^^^^^^^
+   |Could not verify that the method argument is transitively initialized (Hot). It was found to be a function { this = the original object of type "class Outer" that started this trace, owner = class Outer }. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region. Calling trace:
+   |-> class Outer {	[ closureLeak.scala:1 ]
+   |   ^
+   |-> l.foreach(a => a.addX(this)) // error	[ closureLeak.scala:11 ]
+   |             ^^^^^^^^^^^^^^^^^
    |
-   |              Promoting the value to hot (transitively initialized) failed due to the following problem:
-   |              Cannot prove the method argument is hot. Only hot values are safe to leak.
-   |              Found = ThisRef[class Outer].
-   |              Non initialized field(s): value p. Promotion trace:
-   |              -> l.foreach(a => a.addX(this)) // error	[ closureLeak.scala:11 ]
-   |                                       ^^^^
+   |Promoting the value to transitively initialized (Hot) failed due to the following problem:
+   |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type "class Outer" that started this trace. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region.
+   |Non initialized field(s): value p. Promotion trace:
+   |-> l.foreach(a => a.addX(this)) // error	[ closureLeak.scala:11 ]
+   |                         ^^^^
diff --git a/tests/init/neg/cycle-structure.check b/tests/init/neg/cycle-structure.check
index fb7b54c7cac2..dfe7c9b85e2f 100644
--- a/tests/init/neg/cycle-structure.check
+++ b/tests/init/neg/cycle-structure.check
@@ -1,14 +1,14 @@
 -- Error: tests/init/neg/cycle-structure.scala:3:13 --------------------------------------------------------------------
 3 |    val x = B(this)   // error
   |            ^^^^^^^
-  |            Problematic object instantiation: arg 1 is not hot (transitively initialized). Calling trace:
+  |            Problematic object instantiation: arg 1 is not transitively initialized (Hot). Calling trace:
   |            -> case class A(b: B) {	[ cycle-structure.scala:1 ]
   |               ^
   |            -> val x = B(this)   // error	[ cycle-structure.scala:3 ]
   |                       ^^^^^^^
   |
   |            It leads to the following error during object initialization:
-  |            Access field value x on a cold object. Calling trace:
+  |            Access field value x on an uninitialized (Cold) object. Calling trace:
   |            -> case class B(a: A) {	[ cycle-structure.scala:7 ]
   |               ^
   |            -> val x1 = a.x	[ cycle-structure.scala:8 ]
@@ -16,14 +16,14 @@
 -- Error: tests/init/neg/cycle-structure.scala:9:13 --------------------------------------------------------------------
 9 |    val x = A(this)   // error
   |            ^^^^^^^
-  |            Problematic object instantiation: arg 1 is not hot (transitively initialized). Calling trace:
+  |            Problematic object instantiation: arg 1 is not transitively initialized (Hot). Calling trace:
   |            -> case class B(a: A) {	[ cycle-structure.scala:7 ]
   |               ^
   |            -> val x = A(this)   // error	[ cycle-structure.scala:9 ]
   |                       ^^^^^^^
   |
   |            It leads to the following error during object initialization:
-  |            Access field value x on a cold object. Calling trace:
+  |            Access field value x on an uninitialized (Cold) object. Calling trace:
   |            -> case class A(b: B) {	[ cycle-structure.scala:1 ]
   |               ^
   |            -> val x1 = b.x	[ cycle-structure.scala:2 ]
diff --git a/tests/init/neg/default-this.check b/tests/init/neg/default-this.check
index 6d08a64450d4..873a83427aed 100644
--- a/tests/init/neg/default-this.check
+++ b/tests/init/neg/default-this.check
@@ -1,14 +1,13 @@
 -- Error: tests/init/neg/default-this.scala:9:8 ------------------------------------------------------------------------
 9 |        compare() // error
   |        ^^^^^^^
-  |        Cannot prove the method argument is hot. Only hot values are safe to leak.
-  |        Found = ThisRef[class B].
-  |        Non initialized field(s): value result. Calling trace:
-  |        -> class B extends A {	[ default-this.scala:6 ]
-  |           ^
-  |        -> val result = updateThenCompare(5)	[ default-this.scala:11 ]
-  |                        ^^^^^^^^^^^^^^^^^^^^
-  |        -> def updateThenCompare(c: Int): Boolean = {	[ default-this.scala:7 ]
-  |           ^
-  |        -> compare() // error	[ default-this.scala:9 ]
-  |           ^^^^^^^
+  |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type "class B" that started this trace. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region.
+  |Non initialized field(s): value result. Calling trace:
+  |-> class B extends A {	[ default-this.scala:6 ]
+  |   ^
+  |-> val result = updateThenCompare(5)	[ default-this.scala:11 ]
+  |                ^^^^^^^^^^^^^^^^^^^^
+  |-> def updateThenCompare(c: Int): Boolean = {	[ default-this.scala:7 ]
+  |   ^
+  |-> compare() // error	[ default-this.scala:9 ]
+  |   ^^^^^^^
diff --git a/tests/init/neg/i15363.check b/tests/init/neg/i15363.check
index 84cf268ef8a1..9912aa186a5b 100644
--- a/tests/init/neg/i15363.check
+++ b/tests/init/neg/i15363.check
@@ -1,14 +1,14 @@
 -- Error: tests/init/neg/i15363.scala:3:10 -----------------------------------------------------------------------------
 3 |  val b = new B(this) // error
   |          ^^^^^^^^^^^
-  |          Problematic object instantiation: arg 1 is not hot (transitively initialized). Calling trace:
+  |          Problematic object instantiation: arg 1 is not transitively initialized (Hot). Calling trace:
   |          -> class A:	[ i15363.scala:1 ]
   |             ^
   |          -> val b = new B(this) // error	[ i15363.scala:3 ]
   |                     ^^^^^^^^^^^
   |
   |          It leads to the following error during object initialization:
-  |          Access field value m on a cold object. Calling trace:
+  |          Access field value m on an uninitialized (Cold) object. Calling trace:
   |          -> class B(a: A):	[ i15363.scala:7 ]
   |             ^
   |          -> val x = a.m	[ i15363.scala:8 ]
diff --git a/tests/init/neg/i15459.check b/tests/init/neg/i15459.check
index 93ba28554895..a4ba1bacf3a2 100644
--- a/tests/init/neg/i15459.check
+++ b/tests/init/neg/i15459.check
@@ -1,12 +1,11 @@
 -- Error: tests/init/neg/i15459.scala:3:10 -----------------------------------------------------------------------------
 3 |  println(this)  // error
   |          ^^^^
-  |          Cannot prove the method argument is hot. Only hot values are safe to leak.
-  |          Found = ThisRef[class Sub].
-  |          Non initialized field(s): value b. Calling trace:
-  |          -> class Sub extends Sup:	[ i15459.scala:5 ]
-  |             ^
-  |          -> class Sup:	[ i15459.scala:1 ]
-  |             ^
-  |          -> println(this)  // error	[ i15459.scala:3 ]
-  |                     ^^^^
+  |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type "class Sub" that started this trace. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region.
+  |Non initialized field(s): value b. Calling trace:
+  |-> class Sub extends Sup:	[ i15459.scala:5 ]
+  |   ^
+  |-> class Sup:	[ i15459.scala:1 ]
+  |   ^
+  |-> println(this)  // error	[ i15459.scala:3 ]
+  |           ^^^^
diff --git a/tests/init/neg/inherit-non-hot.check b/tests/init/neg/inherit-non-hot.check
index 408196333a27..a62641473ab2 100644
--- a/tests/init/neg/inherit-non-hot.check
+++ b/tests/init/neg/inherit-non-hot.check
@@ -1,17 +1,17 @@
 -- Error: tests/init/neg/inherit-non-hot.scala:6:32 --------------------------------------------------------------------
 6 |            if b == null then b = new B(this) // error
   |                              ^^^^^^^^^^^^^^^
-  |        The RHS of reassignment must be hot. Found = Warm[class B] { outer = Hot, args = (Cold) }.  Calling trace:
-  |        -> class C extends A {	[ inherit-non-hot.scala:15 ]
-  |           ^
-  |        -> val bAgain = toB.getBAgain	[ inherit-non-hot.scala:16 ]
-  |                        ^^^
-  |        -> def toB: B =	[ inherit-non-hot.scala:5 ]
-  |           ^
-  |        -> if b == null then b = new B(this) // error	[ inherit-non-hot.scala:6 ]
-  |                             ^^^^^^^^^^^^^^^
+  |The RHS of reassignment must be transitively initialized (Hot). It was found to be an initialized (Warm) object of type class B{ outer = a transitively initialized (Hot) object, args = (an uninitialized (Cold) object) }.  Calling trace:
+  |-> class C extends A {	[ inherit-non-hot.scala:15 ]
+  |   ^
+  |-> val bAgain = toB.getBAgain	[ inherit-non-hot.scala:16 ]
+  |                ^^^
+  |-> def toB: B =	[ inherit-non-hot.scala:5 ]
+  |   ^
+  |-> if b == null then b = new B(this) // error	[ inherit-non-hot.scala:6 ]
+  |                     ^^^^^^^^^^^^^^^
   |
-  |        Promoting the value to hot (transitively initialized) failed due to the following problem:
-  |        Cannot prove that the field value a is hot. Found = Cold. Promotion trace:
-  |        -> class B(a: A) {	[ inherit-non-hot.scala:10 ]
-  |                   ^^^^
+  |Promoting the value to transitively initialized (Hot) failed due to the following problem:
+  |Could not verify that the field value a is transitively initialized (Hot). It was found to be an uninitialized (Cold) object. Promotion trace:
+  |-> class B(a: A) {	[ inherit-non-hot.scala:10 ]
+  |           ^^^^
diff --git a/tests/init/neg/inlined-method.check b/tests/init/neg/inlined-method.check
index 62bec184b825..d202c668b9b4 100644
--- a/tests/init/neg/inlined-method.check
+++ b/tests/init/neg/inlined-method.check
@@ -1,12 +1,11 @@
 -- Error: tests/init/neg/inlined-method.scala:8:45 ---------------------------------------------------------------------
 8 |    scala.runtime.Scala3RunTime.assertFailed(message) // error
   |                                             ^^^^^^^
-  |                          Cannot prove the method argument is hot. Only hot values are safe to leak.
-  |                          Found = ThisRef[class InlineError].
-  |                          Non initialized field(s): value v. Calling trace:
-  |                          -> class InlineError {	[ inlined-method.scala:1 ]
-  |                             ^
-  |                          -> Assertion.failAssert(this)	[ inlined-method.scala:2 ]
-  |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^
-  |                          -> scala.runtime.Scala3RunTime.assertFailed(message) // error	[ inlined-method.scala:8 ]
-  |                                                                      ^^^^^^^
+  |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type "class InlineError" that started this trace. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region.
+  |Non initialized field(s): value v. Calling trace:
+  |-> class InlineError {	[ inlined-method.scala:1 ]
+  |   ^
+  |-> Assertion.failAssert(this)	[ inlined-method.scala:2 ]
+  |   ^^^^^^^^^^^^^^^^^^^^^^^^^^
+  |-> scala.runtime.Scala3RunTime.assertFailed(message) // error	[ inlined-method.scala:8 ]
+  |                                            ^^^^^^^
diff --git a/tests/init/neg/inner-first.check b/tests/init/neg/inner-first.check
index e1df69fbd4a2..5719cf56d9aa 100644
--- a/tests/init/neg/inner-first.check
+++ b/tests/init/neg/inner-first.check
@@ -1,10 +1,9 @@
 -- Error: tests/init/neg/inner-first.scala:3:12 ------------------------------------------------------------------------
 3 |    println(this)           // error
   |            ^^^^
-  |            Cannot prove the method argument is hot. Only hot values are safe to leak.
-  |            Found = ThisRef[class B].
-  |            Non initialized field(s): value n. Calling trace:
-  |            -> class B:	[ inner-first.scala:2 ]
-  |               ^
-  |            -> println(this)           // error	[ inner-first.scala:3 ]
-  |                       ^^^^
+  |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type "class B" that started this trace. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region.
+  |Non initialized field(s): value n. Calling trace:
+  |-> class B:	[ inner-first.scala:2 ]
+  |   ^
+  |-> println(this)           // error	[ inner-first.scala:3 ]
+  |           ^^^^
diff --git a/tests/init/neg/leak-warm.check b/tests/init/neg/leak-warm.check
index d4d563fc456e..c2fc561a3668 100644
--- a/tests/init/neg/leak-warm.check
+++ b/tests/init/neg/leak-warm.check
@@ -1,7 +1,7 @@
 -- Error: tests/init/neg/leak-warm.scala:19:18 -------------------------------------------------------------------------
 19 |    val l2 = l.map(_.m()) // error
    |             ^^^^^^^^^^^^
-   |             Call method method map on a cold object. Calling trace:
+   |             Call method method map on an uninitialized (Cold) object. Calling trace:
    |             -> object leakWarm {	[ leak-warm.scala:1 ]
    |                ^
    |             -> val l2 = l.map(_.m()) // error	[ leak-warm.scala:19 ]
diff --git a/tests/init/neg/promotion-loop.check b/tests/init/neg/promotion-loop.check
index 3d1eb7e74aec..9f67434be26a 100644
--- a/tests/init/neg/promotion-loop.check
+++ b/tests/init/neg/promotion-loop.check
@@ -1,15 +1,14 @@
 -- Error: tests/init/neg/promotion-loop.scala:16:10 --------------------------------------------------------------------
 16 |  println(b)      // error
    |          ^
-   |          Cannot prove the method argument is hot. Only hot values are safe to leak.
-   |          Found = Warm[class B] { outer = ThisRef[class Test] }. Calling trace:
-   |          -> class Test { test =>	[ promotion-loop.scala:1 ]
-   |             ^
-   |          -> println(b)      // error	[ promotion-loop.scala:16 ]
-   |                     ^
+   |Could not verify that the method argument is transitively initialized (Hot). It was found to be an initialized (Warm) object of type class B{ outer = the original object of type "class Test" that started this trace }. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region. Calling trace:
+   |-> class Test { test =>	[ promotion-loop.scala:1 ]
+   |   ^
+   |-> println(b)      // error	[ promotion-loop.scala:16 ]
+   |           ^
    |
-   |          Promoting the value to hot (transitively initialized) failed due to the following problem:
-   |          Cannot prove that the field value outer is hot. Found = ThisRef[class Test].
-   |          Non initialized field(s): value n. Promotion trace:
-   |          -> val outer = test	[ promotion-loop.scala:12 ]
-   |             ^^^^^^^^^^^^^^^^
+   |Promoting the value to transitively initialized (Hot) failed due to the following problem:
+   |Could not verify that the field value outer is transitively initialized (Hot). It was found to be the original object of type "class Test" that started this trace.
+   |Non initialized field(s): value n. Promotion trace:
+   |-> val outer = test	[ promotion-loop.scala:12 ]
+   |   ^^^^^^^^^^^^^^^^
diff --git a/tests/init/neg/promotion-segment3.check b/tests/init/neg/promotion-segment3.check
index 220af18bd29a..b334439b4168 100644
--- a/tests/init/neg/promotion-segment3.check
+++ b/tests/init/neg/promotion-segment3.check
@@ -1,12 +1,11 @@
 -- Error: tests/init/neg/promotion-segment3.scala:9:6 ------------------------------------------------------------------
 9 |  bar(new B)  // error
   |      ^^^^^
-  |      Cannot prove the method argument is hot. Only hot values are safe to leak.
-  |      Found = Warm[class B] { outer = ThisRef[class A] }. Calling trace:
-  |      -> class A:	[ promotion-segment3.scala:2 ]
-  |         ^
-  |      -> bar(new B)  // error	[ promotion-segment3.scala:9 ]
-  |             ^^^^^
+  |Could not verify that the method argument is transitively initialized (Hot). It was found to be an initialized (Warm) object of type class B{ outer = the original object of type "class A" that started this trace }. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region. Calling trace:
+  |-> class A:	[ promotion-segment3.scala:2 ]
+  |   ^
+  |-> bar(new B)  // error	[ promotion-segment3.scala:9 ]
+  |       ^^^^^
   |
-  |      Promoting the value to hot (transitively initialized) failed due to the following problem:
-  |      Promotion cancelled as the value contains inner class C.
+  |Promoting the value to transitively initialized (Hot) failed due to the following problem:
+  |Promotion cancelled as the value contains inner class C.
diff --git a/tests/init/neg/secondary-ctor4.check b/tests/init/neg/secondary-ctor4.check
index 1bf1a7286357..e867ba65ded5 100644
--- a/tests/init/neg/secondary-ctor4.check
+++ b/tests/init/neg/secondary-ctor4.check
@@ -1,14 +1,14 @@
 -- Error: tests/init/neg/secondary-ctor4.scala:54:14 -------------------------------------------------------------------
 54 |      val c = new C(b, 5)   // error
    |              ^^^^^^^^^^^
-   |              Problematic object instantiation: arg 1 is not hot (transitively initialized). Calling trace:
+   |              Problematic object instantiation: arg 1 is not transitively initialized (Hot). Calling trace:
    |              -> class D {	[ secondary-ctor4.scala:52 ]
    |                 ^
    |              -> val c = new C(b, 5)   // error	[ secondary-ctor4.scala:54 ]
    |                         ^^^^^^^^^^^
    |
    |              It leads to the following error during object initialization:
-   |              Access field value n on a cold object. Calling trace:
+   |              Access field value n on an uninitialized (Cold) object. Calling trace:
    |              -> def this(b: B, x: Int) = this(b)	[ secondary-ctor4.scala:49 ]
    |                                          ^^^^^^^
    |              -> class C(b: B) extends A(b) with T {	[ secondary-ctor4.scala:48 ]
@@ -24,7 +24,7 @@
 -- Error: tests/init/neg/secondary-ctor4.scala:42:4 --------------------------------------------------------------------
 42 |    new A(new B(new D))  // error
    |    ^^^^^^^^^^^^^^^^^^^
-   |Problematic object instantiation: the outer M.this and arg 1 are not hot (transitively initialized). Calling trace:
+   |Problematic object instantiation: the outer M.this and arg 1 are not transitively initialized (Hot). Calling trace:
    |-> class N(d: D) extends M(d) {	[ secondary-ctor4.scala:59 ]
    |   ^
    |-> def this(d: D) = {	[ secondary-ctor4.scala:7 ]
@@ -33,7 +33,7 @@
    |   ^^^^^^^^^^^^^^^^^^^
    |
    |It leads to the following error during object initialization:
-   |Access field value n on a cold object. Calling trace:
+   |Access field value n on an uninitialized (Cold) object. Calling trace:
    |-> def this(b: B) = {	[ secondary-ctor4.scala:17 ]
    |   ^
    |-> Inner().foo()	[ secondary-ctor4.scala:26 ]
diff --git a/tests/init/neg/t3273.check b/tests/init/neg/t3273.check
index e548a5964cac..b5d4c30822a7 100644
--- a/tests/init/neg/t3273.check
+++ b/tests/init/neg/t3273.check
@@ -1,28 +1,26 @@
 -- Error: tests/init/neg/t3273.scala:4:42 ------------------------------------------------------------------------------
 4 |  val num1: LazyList[Int] = 1 #:: num1.map(_ + 1)                        // error
   |                                  ^^^^^^^^^^^^^^^
-  |              Cannot prove the method argument is hot. Only hot values are safe to leak.
-  |              Found = Fun { this = ThisRef[object Test], owner = object Test }. Calling trace:
-  |              -> object Test {	[ t3273.scala:3 ]
-  |                 ^
-  |              -> val num1: LazyList[Int] = 1 #:: num1.map(_ + 1)                        // error	[ t3273.scala:4 ]
-  |                                                 ^^^^^^^^^^^^^^^
+  |Could not verify that the method argument is transitively initialized (Hot). It was found to be a function { this = the original object of type "object Test" that started this trace, owner = object Test }. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region. Calling trace:
+  |-> object Test {	[ t3273.scala:3 ]
+  |   ^
+  |-> val num1: LazyList[Int] = 1 #:: num1.map(_ + 1)                        // error	[ t3273.scala:4 ]
+  |                                   ^^^^^^^^^^^^^^^
   |
-  |              Promoting the value to hot (transitively initialized) failed due to the following problem:
-  |              Access non-initialized value num1. Promotion trace:
-  |              -> val num1: LazyList[Int] = 1 #:: num1.map(_ + 1)                        // error	[ t3273.scala:4 ]
-  |                                                 ^^^^
+  |Promoting the value to transitively initialized (Hot) failed due to the following problem:
+  |Access non-initialized value num1. Promotion trace:
+  |-> val num1: LazyList[Int] = 1 #:: num1.map(_ + 1)                        // error	[ t3273.scala:4 ]
+  |                                   ^^^^
 -- Error: tests/init/neg/t3273.scala:5:61 ------------------------------------------------------------------------------
 5 |  val num2: LazyList[Int] = 1 #:: num2.iterator.map(_ + 1).to(LazyList)  // error
   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  |              Cannot prove the method argument is hot. Only hot values are safe to leak.
-  |              Found = Fun { this = ThisRef[object Test], owner = object Test }. Calling trace:
-  |              -> object Test {	[ t3273.scala:3 ]
-  |                 ^
-  |              -> val num2: LazyList[Int] = 1 #:: num2.iterator.map(_ + 1).to(LazyList)  // error	[ t3273.scala:5 ]
-  |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  |Could not verify that the method argument is transitively initialized (Hot). It was found to be a function { this = the original object of type "object Test" that started this trace, owner = object Test }. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region. Calling trace:
+  |-> object Test {	[ t3273.scala:3 ]
+  |   ^
+  |-> val num2: LazyList[Int] = 1 #:: num2.iterator.map(_ + 1).to(LazyList)  // error	[ t3273.scala:5 ]
+  |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
-  |              Promoting the value to hot (transitively initialized) failed due to the following problem:
-  |              Access non-initialized value num2. Promotion trace:
-  |              -> val num2: LazyList[Int] = 1 #:: num2.iterator.map(_ + 1).to(LazyList)  // error	[ t3273.scala:5 ]
-  |                                                 ^^^^
+  |Promoting the value to transitively initialized (Hot) failed due to the following problem:
+  |Access non-initialized value num2. Promotion trace:
+  |-> val num2: LazyList[Int] = 1 #:: num2.iterator.map(_ + 1).to(LazyList)  // error	[ t3273.scala:5 ]
+  |                                   ^^^^
diff --git a/tests/init/neg/unsound1.check b/tests/init/neg/unsound1.check
index c3057a6a6067..d114ba072db6 100644
--- a/tests/init/neg/unsound1.check
+++ b/tests/init/neg/unsound1.check
@@ -1,7 +1,7 @@
 -- Error: tests/init/neg/unsound1.scala:2:35 ---------------------------------------------------------------------------
 2 |  if (m > 0) println(foo(m - 1).a2.n) // error
   |                     ^^^^^^^^^^^^^^^
-  |                     Access field variable n on a cold object. Calling trace:
+  |                     Access field variable n on an uninitialized (Cold) object. Calling trace:
   |                     -> class A(m: Int) {	[ unsound1.scala:1 ]
   |                        ^
   |                     -> if (m > 0) println(foo(m - 1).a2.n) // error	[ unsound1.scala:2 ]
diff --git a/tests/init/neg/unsound2.check b/tests/init/neg/unsound2.check
index a90b16c8bf71..69d1278e94df 100644
--- a/tests/init/neg/unsound2.check
+++ b/tests/init/neg/unsound2.check
@@ -1,7 +1,7 @@
 -- Error: tests/init/neg/unsound2.scala:5:26 ---------------------------------------------------------------------------
 5 |        def getN: Int = a.n // error
   |                        ^^^
-  |   Access field value n on a cold object. Calling trace:
+  |   Access field value n on an uninitialized (Cold) object. Calling trace:
   |   -> case class A(x: Int) {	[ unsound2.scala:1 ]
   |      ^
   |   -> println(foo(x).getB)	[ unsound2.scala:8 ]
diff --git a/tests/init/neg/unsound3.check b/tests/init/neg/unsound3.check
index d62b97e1abaf..c32e66272d1a 100644
--- a/tests/init/neg/unsound3.check
+++ b/tests/init/neg/unsound3.check
@@ -1,7 +1,7 @@
 -- Error: tests/init/neg/unsound3.scala:10:38 --------------------------------------------------------------------------
 10 |        if (x < 12) then foo().getC().b else newB // error
    |                         ^^^^^^^^^^^^^^
-   |                         Access field value b on a cold object. Calling trace:
+   |                         Access field value b on an uninitialized (Cold) object. Calling trace:
    |                         -> class C {	[ unsound3.scala:5 ]
    |                            ^
    |                         -> val b = foo()	[ unsound3.scala:12 ]

From 099f9f2b4b84aeca7fd9ca5782e80e5ef8fa3912 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Mon, 6 Mar 2023 14:28:22 +0000
Subject: [PATCH 230/657] Unduplicate enrich{,ed}ErrorMessage

Having a same-named enrichement will cause the original to be called
if/when explicit nulls is switched off - which leads to the original
method to be called, meaning an NPE will be thrown.

So, instead, move all the functionality as an extension method, so we
don't need mangled names.
---
 compiler/src/dotty/tools/dotc/Run.scala | 24 ++++++++++--------------
 1 file changed, 10 insertions(+), 14 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/Run.scala b/compiler/src/dotty/tools/dotc/Run.scala
index a46ded5d948b..944ae794c94f 100644
--- a/compiler/src/dotty/tools/dotc/Run.scala
+++ b/compiler/src/dotty/tools/dotc/Run.scala
@@ -175,19 +175,11 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
 
   private var myEnrichedErrorMessage = false
 
-  def enrichedErrorMessage: Boolean = myEnrichedErrorMessage
-
-  def enrichErrorMessage(errorMessage: String)(using Context): String =
-    if enrichedErrorMessage then errorMessage
-    else
-      myEnrichedErrorMessage = true
-      report.enrichErrorMessage(errorMessage)
-
   def compile(files: List[AbstractFile]): Unit =
     try compileSources(files.map(runContext.getSource(_)))
-    catch case NonFatal(ex) if !enrichedErrorMessage =>
+    catch case NonFatal(ex) if !this.enrichedErrorMessage =>
       val files1 = if units.isEmpty then files else units.map(_.source.file)
-      report.echo(enrichErrorMessage(s"exception occurred while compiling ${files1.map(_.path)}"))
+      report.echo(this.enrichErrorMessage(s"exception occurred while compiling ${files1.map(_.path)}"))
       throw ex
 
   /** TODO: There's a fundamental design problem here: We assemble phases using `fusePhases`
@@ -408,9 +400,13 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
 
 object Run {
   extension (run: Run | Null)
-    def enrichedErrorMessage: Boolean = if run == null then false else run.enrichedErrorMessage
+    def enrichedErrorMessage: Boolean = if run == null then false else run.myEnrichedErrorMessage
     def enrichErrorMessage(errorMessage: String)(using Context): String =
-      if run == null
-      then report.enrichErrorMessage(errorMessage)
-      else run.enrichErrorMessage(errorMessage)
+      if run == null then
+        report.enrichErrorMessage(errorMessage)
+      else if !run.enrichedErrorMessage then
+        run.myEnrichedErrorMessage = true
+        report.enrichErrorMessage(errorMessage)
+      else
+        errorMessage
 }

From 8595d951a9adcc2c57f7ea17b83fb854cae1cf7a Mon Sep 17 00:00:00 2001
From: David Hua <d5hua@uwaterloo.ca>
Date: Mon, 6 Mar 2023 22:02:01 -0500
Subject: [PATCH 231/657] Add optimization to reduce extra iterations of the
 safe init checker.

---
 .../src/dotty/tools/dotc/transform/init/Cache.scala |  9 ++++++++-
 .../dotty/tools/dotc/transform/init/Semantic.scala  | 13 ++++++++++---
 2 files changed, 18 insertions(+), 4 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/init/Cache.scala b/compiler/src/dotty/tools/dotc/transform/init/Cache.scala
index 14a52d995131..080c56d6fb5f 100644
--- a/compiler/src/dotty/tools/dotc/transform/init/Cache.scala
+++ b/compiler/src/dotty/tools/dotc/transform/init/Cache.scala
@@ -75,6 +75,8 @@ class Cache[Config, Res]:
    */
   protected var changed: Boolean = false
 
+  protected var cacheUsed: Boolean = false
+
   /** Used to avoid allocation, its state does not matter */
   protected given MutableTreeWrapper = new MutableTreeWrapper
 
@@ -99,7 +101,9 @@ class Cache[Config, Res]:
    */
   def cachedEval(config: Config, expr: Tree, cacheResult: Boolean, default: Res)(eval: Tree => Res): Res =
     this.get(config, expr) match
-    case Some(value) => value
+    case Some(value) =>
+      cacheUsed = true
+      value
     case None =>
       val assumeValue: Res =
         this.last.get(config, expr) match
@@ -124,6 +128,8 @@ class Cache[Config, Res]:
 
   def hasChanged = changed
 
+  def isUsed = cacheUsed
+
   /** Prepare cache for the next iteration
    *
    *  1. Reset changed flag.
@@ -132,6 +138,7 @@ class Cache[Config, Res]:
    */
   def prepareForNextIteration()(using Context) =
     this.changed = false
+    this.cacheUsed = false
     this.last = this.current
     this.current = Map.empty
 end Cache
diff --git a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
index 286e3a124d12..49d9ae4d2b2a 100644
--- a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
+++ b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
@@ -1101,12 +1101,15 @@ object Semantic:
    *
    *  The class to be checked must be an instantiable concrete class.
    */
-  private def checkClass(classSym: ClassSymbol)(using Cache.Data, Context): Unit =
+  private def checkClass(classSym: ClassSymbol)(using Cache.Data, Context): Int =
     val thisRef = ThisRef(classSym)
     val tpl = classSym.defTree.asInstanceOf[TypeDef].rhs.asInstanceOf[Template]
 
+    var accum = 0
+
     @tailrec
     def iterate(): Unit = {
+      accum += 1
       given Promoted = Promoted.empty(classSym)
       given Trace = Trace.empty.add(classSym.defTree)
       given reporter: Reporter.BufferedReporter = new Reporter.BufferedReporter
@@ -1120,7 +1123,7 @@ object Semantic:
       log("checking " + classSym) { eval(tpl, thisRef, classSym) }
       reporter.errors.foreach(_.issue)
 
-      if cache.hasChanged && reporter.errors.isEmpty then
+      if cache.hasChanged && reporter.errors.isEmpty && cache.isUsed then
         // code to prepare cache and heap for next iteration
         cache.prepareForNextIteration()
         iterate()
@@ -1129,15 +1132,19 @@ object Semantic:
     }
 
     iterate()
+
+    accum - 1
   end checkClass
 
   /**
    * Check the specified concrete classes
    */
   def checkClasses(classes: List[ClassSymbol])(using Context): Unit =
+    var total = 0
     given Cache.Data()
     for classSym <- classes if isConcreteClass(classSym) do
-      checkClass(classSym)
+      total += checkClass(classSym)
+    System.err.nn.println(total)
 
 // ----- Semantic definition --------------------------------
   type ArgInfo = TraceValue[Value]

From 4cc629ec06ea6bbd678bd06294eae16ce86a6186 Mon Sep 17 00:00:00 2001
From: David Hua <d5hua@uwaterloo.ca>
Date: Mon, 6 Mar 2023 23:00:09 -0500
Subject: [PATCH 232/657] Reword the stringified versions of some objects

---
 compiler/src/dotty/tools/dotc/transform/init/Semantic.scala | 4 ++--
 tests/init/neg/closureLeak.check                            | 4 ++--
 tests/init/neg/default-this.check                           | 2 +-
 tests/init/neg/i15459.check                                 | 2 +-
 tests/init/neg/inlined-method.check                         | 2 +-
 tests/init/neg/inner-first.check                            | 2 +-
 tests/init/neg/promotion-loop.check                         | 4 ++--
 tests/init/neg/promotion-segment3.check                     | 2 +-
 tests/init/neg/t3273.check                                  | 4 ++--
 9 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
index 727e54833063..60f0266d7ede 100644
--- a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
+++ b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
@@ -64,12 +64,12 @@ object Semantic:
   sealed abstract class Value:
     def show(using Context): String = this match
       case ThisRef(klass) =>
-        "the original object of type \"" + klass.show + "\" that started this trace"
+        "the original object of type \"" + klass.show + "\" where initialization checking started"
       case Warm(klass, outer, ctor, args) =>
         val argsText = if args.nonEmpty then ", args = " + args.map(_.show).mkString("(", ", ", ")") else ""
         "an initialized (Warm) object of type " + klass.show + "{ outer = " + outer.show + argsText + " }"
       case Fun(expr, thisV, klass) =>
-        "a function { this = " + thisV.show + ", owner = " + klass.show + " }"
+        "a function where \"this\" is " + thisV.show + " and the function owner is an object of type " + klass.show
       case RefSet(values) =>
         values.map(_.show).mkString("Set { ", ", ", " }")
       case Hot =>
diff --git a/tests/init/neg/closureLeak.check b/tests/init/neg/closureLeak.check
index c4e85d7db4b0..19292f535fd1 100644
--- a/tests/init/neg/closureLeak.check
+++ b/tests/init/neg/closureLeak.check
@@ -1,14 +1,14 @@
 -- Error: tests/init/neg/closureLeak.scala:11:14 -----------------------------------------------------------------------
 11 |    l.foreach(a => a.addX(this)) // error
    |              ^^^^^^^^^^^^^^^^^
-   |Could not verify that the method argument is transitively initialized (Hot). It was found to be a function { this = the original object of type "class Outer" that started this trace, owner = class Outer }. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region. Calling trace:
+   |Could not verify that the method argument is transitively initialized (Hot). It was found to be a function where "this" is the original object of type "class Outer" where initialization checking started and the function owner is an object of type class Outer. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region. Calling trace:
    |-> class Outer {	[ closureLeak.scala:1 ]
    |   ^
    |-> l.foreach(a => a.addX(this)) // error	[ closureLeak.scala:11 ]
    |             ^^^^^^^^^^^^^^^^^
    |
    |Promoting the value to transitively initialized (Hot) failed due to the following problem:
-   |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type "class Outer" that started this trace. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region.
+   |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type "class Outer" where initialization checking started. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region.
    |Non initialized field(s): value p. Promotion trace:
    |-> l.foreach(a => a.addX(this)) // error	[ closureLeak.scala:11 ]
    |                         ^^^^
diff --git a/tests/init/neg/default-this.check b/tests/init/neg/default-this.check
index 873a83427aed..384efdf5414e 100644
--- a/tests/init/neg/default-this.check
+++ b/tests/init/neg/default-this.check
@@ -1,7 +1,7 @@
 -- Error: tests/init/neg/default-this.scala:9:8 ------------------------------------------------------------------------
 9 |        compare() // error
   |        ^^^^^^^
-  |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type "class B" that started this trace. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region.
+  |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type "class B" where initialization checking started. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region.
   |Non initialized field(s): value result. Calling trace:
   |-> class B extends A {	[ default-this.scala:6 ]
   |   ^
diff --git a/tests/init/neg/i15459.check b/tests/init/neg/i15459.check
index a4ba1bacf3a2..e25d7efadda2 100644
--- a/tests/init/neg/i15459.check
+++ b/tests/init/neg/i15459.check
@@ -1,7 +1,7 @@
 -- Error: tests/init/neg/i15459.scala:3:10 -----------------------------------------------------------------------------
 3 |  println(this)  // error
   |          ^^^^
-  |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type "class Sub" that started this trace. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region.
+  |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type "class Sub" where initialization checking started. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region.
   |Non initialized field(s): value b. Calling trace:
   |-> class Sub extends Sup:	[ i15459.scala:5 ]
   |   ^
diff --git a/tests/init/neg/inlined-method.check b/tests/init/neg/inlined-method.check
index d202c668b9b4..dce46d3d7b5a 100644
--- a/tests/init/neg/inlined-method.check
+++ b/tests/init/neg/inlined-method.check
@@ -1,7 +1,7 @@
 -- Error: tests/init/neg/inlined-method.scala:8:45 ---------------------------------------------------------------------
 8 |    scala.runtime.Scala3RunTime.assertFailed(message) // error
   |                                             ^^^^^^^
-  |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type "class InlineError" that started this trace. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region.
+  |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type "class InlineError" where initialization checking started. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region.
   |Non initialized field(s): value v. Calling trace:
   |-> class InlineError {	[ inlined-method.scala:1 ]
   |   ^
diff --git a/tests/init/neg/inner-first.check b/tests/init/neg/inner-first.check
index 5719cf56d9aa..62bc8c3c4668 100644
--- a/tests/init/neg/inner-first.check
+++ b/tests/init/neg/inner-first.check
@@ -1,7 +1,7 @@
 -- Error: tests/init/neg/inner-first.scala:3:12 ------------------------------------------------------------------------
 3 |    println(this)           // error
   |            ^^^^
-  |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type "class B" that started this trace. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region.
+  |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type "class B" where initialization checking started. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region.
   |Non initialized field(s): value n. Calling trace:
   |-> class B:	[ inner-first.scala:2 ]
   |   ^
diff --git a/tests/init/neg/promotion-loop.check b/tests/init/neg/promotion-loop.check
index 9f67434be26a..73adb08e282c 100644
--- a/tests/init/neg/promotion-loop.check
+++ b/tests/init/neg/promotion-loop.check
@@ -1,14 +1,14 @@
 -- Error: tests/init/neg/promotion-loop.scala:16:10 --------------------------------------------------------------------
 16 |  println(b)      // error
    |          ^
-   |Could not verify that the method argument is transitively initialized (Hot). It was found to be an initialized (Warm) object of type class B{ outer = the original object of type "class Test" that started this trace }. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region. Calling trace:
+   |Could not verify that the method argument is transitively initialized (Hot). It was found to be an initialized (Warm) object of type class B{ outer = the original object of type "class Test" where initialization checking started }. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region. Calling trace:
    |-> class Test { test =>	[ promotion-loop.scala:1 ]
    |   ^
    |-> println(b)      // error	[ promotion-loop.scala:16 ]
    |           ^
    |
    |Promoting the value to transitively initialized (Hot) failed due to the following problem:
-   |Could not verify that the field value outer is transitively initialized (Hot). It was found to be the original object of type "class Test" that started this trace.
+   |Could not verify that the field value outer is transitively initialized (Hot). It was found to be the original object of type "class Test" where initialization checking started.
    |Non initialized field(s): value n. Promotion trace:
    |-> val outer = test	[ promotion-loop.scala:12 ]
    |   ^^^^^^^^^^^^^^^^
diff --git a/tests/init/neg/promotion-segment3.check b/tests/init/neg/promotion-segment3.check
index b334439b4168..40747b94f41d 100644
--- a/tests/init/neg/promotion-segment3.check
+++ b/tests/init/neg/promotion-segment3.check
@@ -1,7 +1,7 @@
 -- Error: tests/init/neg/promotion-segment3.scala:9:6 ------------------------------------------------------------------
 9 |  bar(new B)  // error
   |      ^^^^^
-  |Could not verify that the method argument is transitively initialized (Hot). It was found to be an initialized (Warm) object of type class B{ outer = the original object of type "class A" that started this trace }. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region. Calling trace:
+  |Could not verify that the method argument is transitively initialized (Hot). It was found to be an initialized (Warm) object of type class B{ outer = the original object of type "class A" where initialization checking started }. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region. Calling trace:
   |-> class A:	[ promotion-segment3.scala:2 ]
   |   ^
   |-> bar(new B)  // error	[ promotion-segment3.scala:9 ]
diff --git a/tests/init/neg/t3273.check b/tests/init/neg/t3273.check
index b5d4c30822a7..4b8d3e2521e0 100644
--- a/tests/init/neg/t3273.check
+++ b/tests/init/neg/t3273.check
@@ -1,7 +1,7 @@
 -- Error: tests/init/neg/t3273.scala:4:42 ------------------------------------------------------------------------------
 4 |  val num1: LazyList[Int] = 1 #:: num1.map(_ + 1)                        // error
   |                                  ^^^^^^^^^^^^^^^
-  |Could not verify that the method argument is transitively initialized (Hot). It was found to be a function { this = the original object of type "object Test" that started this trace, owner = object Test }. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region. Calling trace:
+  |Could not verify that the method argument is transitively initialized (Hot). It was found to be a function where "this" is the original object of type "object Test" where initialization checking started and the function owner is an object of type object Test. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region. Calling trace:
   |-> object Test {	[ t3273.scala:3 ]
   |   ^
   |-> val num1: LazyList[Int] = 1 #:: num1.map(_ + 1)                        // error	[ t3273.scala:4 ]
@@ -14,7 +14,7 @@
 -- Error: tests/init/neg/t3273.scala:5:61 ------------------------------------------------------------------------------
 5 |  val num2: LazyList[Int] = 1 #:: num2.iterator.map(_ + 1).to(LazyList)  // error
   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  |Could not verify that the method argument is transitively initialized (Hot). It was found to be a function { this = the original object of type "object Test" that started this trace, owner = object Test }. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region. Calling trace:
+  |Could not verify that the method argument is transitively initialized (Hot). It was found to be a function where "this" is the original object of type "object Test" where initialization checking started and the function owner is an object of type object Test. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region. Calling trace:
   |-> object Test {	[ t3273.scala:3 ]
   |   ^
   |-> val num2: LazyList[Int] = 1 #:: num2.iterator.map(_ + 1).to(LazyList)  // error	[ t3273.scala:5 ]

From 6f229802cf1eb128c0128c5bf5e59c5422739634 Mon Sep 17 00:00:00 2001
From: David Hua <d5hua@uwaterloo.ca>
Date: Mon, 6 Mar 2023 23:08:19 -0500
Subject: [PATCH 233/657] Add parentheses to make warnings more clear

---
 compiler/src/dotty/tools/dotc/transform/init/Semantic.scala | 6 +++---
 tests/init/neg/closureLeak.check                            | 4 ++--
 tests/init/neg/default-this.check                           | 2 +-
 tests/init/neg/i15459.check                                 | 2 +-
 tests/init/neg/inherit-non-hot.check                        | 2 +-
 tests/init/neg/inlined-method.check                         | 2 +-
 tests/init/neg/inner-first.check                            | 2 +-
 tests/init/neg/promotion-loop.check                         | 4 ++--
 tests/init/neg/promotion-segment3.check                     | 2 +-
 tests/init/neg/t3273.check                                  | 4 ++--
 10 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
index 60f0266d7ede..7981153f46a7 100644
--- a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
+++ b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
@@ -64,12 +64,12 @@ object Semantic:
   sealed abstract class Value:
     def show(using Context): String = this match
       case ThisRef(klass) =>
-        "the original object of type \"" + klass.show + "\" where initialization checking started"
+        "the original object of type (" + klass.show + ") where initialization checking started"
       case Warm(klass, outer, ctor, args) =>
         val argsText = if args.nonEmpty then ", args = " + args.map(_.show).mkString("(", ", ", ")") else ""
-        "an initialized (Warm) object of type " + klass.show + "{ outer = " + outer.show + argsText + " }"
+        "an initialized (Warm) object of type (" + klass.show + ") { outer = " + outer.show + argsText + " }"
       case Fun(expr, thisV, klass) =>
-        "a function where \"this\" is " + thisV.show + " and the function owner is an object of type " + klass.show
+        "a function where \"this\" is (" + thisV.show + ") and the function owner is an object of type (" + klass.show + ")"
       case RefSet(values) =>
         values.map(_.show).mkString("Set { ", ", ", " }")
       case Hot =>
diff --git a/tests/init/neg/closureLeak.check b/tests/init/neg/closureLeak.check
index 19292f535fd1..d4ea2ec8ef47 100644
--- a/tests/init/neg/closureLeak.check
+++ b/tests/init/neg/closureLeak.check
@@ -1,14 +1,14 @@
 -- Error: tests/init/neg/closureLeak.scala:11:14 -----------------------------------------------------------------------
 11 |    l.foreach(a => a.addX(this)) // error
    |              ^^^^^^^^^^^^^^^^^
-   |Could not verify that the method argument is transitively initialized (Hot). It was found to be a function where "this" is the original object of type "class Outer" where initialization checking started and the function owner is an object of type class Outer. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region. Calling trace:
+   |Could not verify that the method argument is transitively initialized (Hot). It was found to be a function where "this" is (the original object of type (class Outer) where initialization checking started) and the function owner is an object of type (class Outer). Only transitively initialized arguments may be passed to methods outside the analyzed initialization region. Calling trace:
    |-> class Outer {	[ closureLeak.scala:1 ]
    |   ^
    |-> l.foreach(a => a.addX(this)) // error	[ closureLeak.scala:11 ]
    |             ^^^^^^^^^^^^^^^^^
    |
    |Promoting the value to transitively initialized (Hot) failed due to the following problem:
-   |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type "class Outer" where initialization checking started. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region.
+   |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type (class Outer) where initialization checking started. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region.
    |Non initialized field(s): value p. Promotion trace:
    |-> l.foreach(a => a.addX(this)) // error	[ closureLeak.scala:11 ]
    |                         ^^^^
diff --git a/tests/init/neg/default-this.check b/tests/init/neg/default-this.check
index 384efdf5414e..84556f0a9d82 100644
--- a/tests/init/neg/default-this.check
+++ b/tests/init/neg/default-this.check
@@ -1,7 +1,7 @@
 -- Error: tests/init/neg/default-this.scala:9:8 ------------------------------------------------------------------------
 9 |        compare() // error
   |        ^^^^^^^
-  |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type "class B" where initialization checking started. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region.
+  |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type (class B) where initialization checking started. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region.
   |Non initialized field(s): value result. Calling trace:
   |-> class B extends A {	[ default-this.scala:6 ]
   |   ^
diff --git a/tests/init/neg/i15459.check b/tests/init/neg/i15459.check
index e25d7efadda2..fffeabd560e1 100644
--- a/tests/init/neg/i15459.check
+++ b/tests/init/neg/i15459.check
@@ -1,7 +1,7 @@
 -- Error: tests/init/neg/i15459.scala:3:10 -----------------------------------------------------------------------------
 3 |  println(this)  // error
   |          ^^^^
-  |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type "class Sub" where initialization checking started. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region.
+  |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type (class Sub) where initialization checking started. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region.
   |Non initialized field(s): value b. Calling trace:
   |-> class Sub extends Sup:	[ i15459.scala:5 ]
   |   ^
diff --git a/tests/init/neg/inherit-non-hot.check b/tests/init/neg/inherit-non-hot.check
index a62641473ab2..2c195bcacf1d 100644
--- a/tests/init/neg/inherit-non-hot.check
+++ b/tests/init/neg/inherit-non-hot.check
@@ -1,7 +1,7 @@
 -- Error: tests/init/neg/inherit-non-hot.scala:6:32 --------------------------------------------------------------------
 6 |            if b == null then b = new B(this) // error
   |                              ^^^^^^^^^^^^^^^
-  |The RHS of reassignment must be transitively initialized (Hot). It was found to be an initialized (Warm) object of type class B{ outer = a transitively initialized (Hot) object, args = (an uninitialized (Cold) object) }.  Calling trace:
+  |The RHS of reassignment must be transitively initialized (Hot). It was found to be an initialized (Warm) object of type (class B) { outer = a transitively initialized (Hot) object, args = (an uninitialized (Cold) object) }.  Calling trace:
   |-> class C extends A {	[ inherit-non-hot.scala:15 ]
   |   ^
   |-> val bAgain = toB.getBAgain	[ inherit-non-hot.scala:16 ]
diff --git a/tests/init/neg/inlined-method.check b/tests/init/neg/inlined-method.check
index dce46d3d7b5a..9751ef09b0c1 100644
--- a/tests/init/neg/inlined-method.check
+++ b/tests/init/neg/inlined-method.check
@@ -1,7 +1,7 @@
 -- Error: tests/init/neg/inlined-method.scala:8:45 ---------------------------------------------------------------------
 8 |    scala.runtime.Scala3RunTime.assertFailed(message) // error
   |                                             ^^^^^^^
-  |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type "class InlineError" where initialization checking started. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region.
+  |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type (class InlineError) where initialization checking started. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region.
   |Non initialized field(s): value v. Calling trace:
   |-> class InlineError {	[ inlined-method.scala:1 ]
   |   ^
diff --git a/tests/init/neg/inner-first.check b/tests/init/neg/inner-first.check
index 62bc8c3c4668..9340479f79a9 100644
--- a/tests/init/neg/inner-first.check
+++ b/tests/init/neg/inner-first.check
@@ -1,7 +1,7 @@
 -- Error: tests/init/neg/inner-first.scala:3:12 ------------------------------------------------------------------------
 3 |    println(this)           // error
   |            ^^^^
-  |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type "class B" where initialization checking started. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region.
+  |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type (class B) where initialization checking started. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region.
   |Non initialized field(s): value n. Calling trace:
   |-> class B:	[ inner-first.scala:2 ]
   |   ^
diff --git a/tests/init/neg/promotion-loop.check b/tests/init/neg/promotion-loop.check
index 73adb08e282c..28562aa0effb 100644
--- a/tests/init/neg/promotion-loop.check
+++ b/tests/init/neg/promotion-loop.check
@@ -1,14 +1,14 @@
 -- Error: tests/init/neg/promotion-loop.scala:16:10 --------------------------------------------------------------------
 16 |  println(b)      // error
    |          ^
-   |Could not verify that the method argument is transitively initialized (Hot). It was found to be an initialized (Warm) object of type class B{ outer = the original object of type "class Test" where initialization checking started }. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region. Calling trace:
+   |Could not verify that the method argument is transitively initialized (Hot). It was found to be an initialized (Warm) object of type (class B) { outer = the original object of type (class Test) where initialization checking started }. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region. Calling trace:
    |-> class Test { test =>	[ promotion-loop.scala:1 ]
    |   ^
    |-> println(b)      // error	[ promotion-loop.scala:16 ]
    |           ^
    |
    |Promoting the value to transitively initialized (Hot) failed due to the following problem:
-   |Could not verify that the field value outer is transitively initialized (Hot). It was found to be the original object of type "class Test" where initialization checking started.
+   |Could not verify that the field value outer is transitively initialized (Hot). It was found to be the original object of type (class Test) where initialization checking started.
    |Non initialized field(s): value n. Promotion trace:
    |-> val outer = test	[ promotion-loop.scala:12 ]
    |   ^^^^^^^^^^^^^^^^
diff --git a/tests/init/neg/promotion-segment3.check b/tests/init/neg/promotion-segment3.check
index 40747b94f41d..1765f08d872a 100644
--- a/tests/init/neg/promotion-segment3.check
+++ b/tests/init/neg/promotion-segment3.check
@@ -1,7 +1,7 @@
 -- Error: tests/init/neg/promotion-segment3.scala:9:6 ------------------------------------------------------------------
 9 |  bar(new B)  // error
   |      ^^^^^
-  |Could not verify that the method argument is transitively initialized (Hot). It was found to be an initialized (Warm) object of type class B{ outer = the original object of type "class A" where initialization checking started }. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region. Calling trace:
+  |Could not verify that the method argument is transitively initialized (Hot). It was found to be an initialized (Warm) object of type (class B) { outer = the original object of type (class A) where initialization checking started }. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region. Calling trace:
   |-> class A:	[ promotion-segment3.scala:2 ]
   |   ^
   |-> bar(new B)  // error	[ promotion-segment3.scala:9 ]
diff --git a/tests/init/neg/t3273.check b/tests/init/neg/t3273.check
index 4b8d3e2521e0..a63f7bc7a5ea 100644
--- a/tests/init/neg/t3273.check
+++ b/tests/init/neg/t3273.check
@@ -1,7 +1,7 @@
 -- Error: tests/init/neg/t3273.scala:4:42 ------------------------------------------------------------------------------
 4 |  val num1: LazyList[Int] = 1 #:: num1.map(_ + 1)                        // error
   |                                  ^^^^^^^^^^^^^^^
-  |Could not verify that the method argument is transitively initialized (Hot). It was found to be a function where "this" is the original object of type "object Test" where initialization checking started and the function owner is an object of type object Test. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region. Calling trace:
+  |Could not verify that the method argument is transitively initialized (Hot). It was found to be a function where "this" is (the original object of type (object Test) where initialization checking started) and the function owner is an object of type (object Test). Only transitively initialized arguments may be passed to methods outside the analyzed initialization region. Calling trace:
   |-> object Test {	[ t3273.scala:3 ]
   |   ^
   |-> val num1: LazyList[Int] = 1 #:: num1.map(_ + 1)                        // error	[ t3273.scala:4 ]
@@ -14,7 +14,7 @@
 -- Error: tests/init/neg/t3273.scala:5:61 ------------------------------------------------------------------------------
 5 |  val num2: LazyList[Int] = 1 #:: num2.iterator.map(_ + 1).to(LazyList)  // error
   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  |Could not verify that the method argument is transitively initialized (Hot). It was found to be a function where "this" is the original object of type "object Test" where initialization checking started and the function owner is an object of type object Test. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region. Calling trace:
+  |Could not verify that the method argument is transitively initialized (Hot). It was found to be a function where "this" is (the original object of type (object Test) where initialization checking started) and the function owner is an object of type (object Test). Only transitively initialized arguments may be passed to methods outside the analyzed initialization region. Calling trace:
   |-> object Test {	[ t3273.scala:3 ]
   |   ^
   |-> val num2: LazyList[Int] = 1 #:: num2.iterator.map(_ + 1).to(LazyList)  // error	[ t3273.scala:5 ]

From 1b5a2fff06d66b463105643c15e2a0dfa7dd3359 Mon Sep 17 00:00:00 2001
From: David Hua <d5hua@uwaterloo.ca>
Date: Mon, 6 Mar 2023 23:14:41 -0500
Subject: [PATCH 234/657] Remove benchmarking output

---
 .../src/dotty/tools/dotc/transform/init/Semantic.scala   | 9 +--------
 1 file changed, 1 insertion(+), 8 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
index 49d9ae4d2b2a..6a0c8cd4216d 100644
--- a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
+++ b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
@@ -1101,15 +1101,12 @@ object Semantic:
    *
    *  The class to be checked must be an instantiable concrete class.
    */
-  private def checkClass(classSym: ClassSymbol)(using Cache.Data, Context): Int =
+  private def checkClass(classSym: ClassSymbol)(using Cache.Data, Context): Unit =
     val thisRef = ThisRef(classSym)
     val tpl = classSym.defTree.asInstanceOf[TypeDef].rhs.asInstanceOf[Template]
 
-    var accum = 0
-
     @tailrec
     def iterate(): Unit = {
-      accum += 1
       given Promoted = Promoted.empty(classSym)
       given Trace = Trace.empty.add(classSym.defTree)
       given reporter: Reporter.BufferedReporter = new Reporter.BufferedReporter
@@ -1132,19 +1129,15 @@ object Semantic:
     }
 
     iterate()
-
-    accum - 1
   end checkClass
 
   /**
    * Check the specified concrete classes
    */
   def checkClasses(classes: List[ClassSymbol])(using Context): Unit =
-    var total = 0
     given Cache.Data()
     for classSym <- classes if isConcreteClass(classSym) do
       total += checkClass(classSym)
-    System.err.nn.println(total)
 
 // ----- Semantic definition --------------------------------
   type ArgInfo = TraceValue[Value]

From 170b36d04530fd9596494250041dd47513c62941 Mon Sep 17 00:00:00 2001
From: David Hua <d5hua@uwaterloo.ca>
Date: Mon, 6 Mar 2023 23:16:36 -0500
Subject: [PATCH 235/657] Add documentation for new field.

---
 compiler/src/dotty/tools/dotc/transform/init/Cache.scala    | 4 ++++
 compiler/src/dotty/tools/dotc/transform/init/Semantic.scala | 2 +-
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/init/Cache.scala b/compiler/src/dotty/tools/dotc/transform/init/Cache.scala
index 080c56d6fb5f..2dcd6360554a 100644
--- a/compiler/src/dotty/tools/dotc/transform/init/Cache.scala
+++ b/compiler/src/dotty/tools/dotc/transform/init/Cache.scala
@@ -75,6 +75,10 @@ class Cache[Config, Res]:
    */
   protected var changed: Boolean = false
 
+  /** Whether any value in the cache was accessed after being added.
+  *   If no cached values are used after they are added for the first time
+  *   then another iteration of analysis is not needed.
+  */
   protected var cacheUsed: Boolean = false
 
   /** Used to avoid allocation, its state does not matter */
diff --git a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
index 6a0c8cd4216d..1aa38e1429df 100644
--- a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
+++ b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
@@ -1137,7 +1137,7 @@ object Semantic:
   def checkClasses(classes: List[ClassSymbol])(using Context): Unit =
     given Cache.Data()
     for classSym <- classes if isConcreteClass(classSym) do
-      total += checkClass(classSym)
+      checkClass(classSym)
 
 // ----- Semantic definition --------------------------------
   type ArgInfo = TraceValue[Value]

From fe1620bb2362e8ca359899765de4904a5bcdc49c Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Tue, 7 Mar 2023 08:40:36 +0000
Subject: [PATCH 236/657] Dupe fix when finding default arg getters

Duplicate of i16814.
---
 tests/pos/i17008.scala | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 tests/pos/i17008.scala

diff --git a/tests/pos/i17008.scala b/tests/pos/i17008.scala
new file mode 100644
index 000000000000..2bf0f155afbc
--- /dev/null
+++ b/tests/pos/i17008.scala
@@ -0,0 +1,9 @@
+abstract class A {
+  protected def foo(text: String, bar: () => Unit = () => ()): Unit = println(s"$text, $bar")
+}
+
+class B extends A {
+  def f1(): Unit = {
+    super.foo("X")
+  }
+}

From ff9961702c37bea80514660cc3023ad81f8a8fc6 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Tue, 7 Mar 2023 14:41:40 +0100
Subject: [PATCH 237/657] Update library/src/scala/quoted/Quotes.scala

---
 library/src/scala/quoted/Quotes.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/library/src/scala/quoted/Quotes.scala b/library/src/scala/quoted/Quotes.scala
index 05c253a76fd3..ddd7eb7d66fe 100644
--- a/library/src/scala/quoted/Quotes.scala
+++ b/library/src/scala/quoted/Quotes.scala
@@ -34,7 +34,7 @@ transparent inline def quotes(using q: Quotes): q.type = q
  *  ```
  */
 
-@implicitNotFound("""explain=Maybe this methods is missing a `(using Quotes)` parameter.
+@implicitNotFound("""explain=Maybe this method is missing a `(using Quotes)` parameter.
 
 Maybe that splice `$ { ... }` is missing?
 Given instances of `Quotes` are generated from an enclosing splice `$ { ... }` (or `scala.staging.run` call).

From 3cb01d6cbd549c11f71556ee7d8a592e354afd46 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Tue, 7 Mar 2023 13:52:50 +0000
Subject: [PATCH 238/657] Drop incorrect super accessor in trait subclass

When a trait extends a class and accesses a protected member (while in a
different package), we would emitted a super accessor and call that
instead.  That breaks the semantics because if the protected member is
overridden, that implementation won't be called, as the call is to the
super method instead.

In addition to that, the call to the super accessor was causing a false
positive error as we don't allow super calls to bind to vals.
---
 .../tools/dotc/transform/AccessProxies.scala  |  2 +-
 .../dotc/transform/ProtectedAccessors.scala   | 12 +++------
 .../tools/dotc/transform/SuperAccessors.scala | 26 +++++++------------
 tests/{neg => pos}/i11170a.scala              |  4 +--
 tests/run/i17021.defs.scala                   | 16 ++++++++++++
 tests/run/i17021.scala                        | 18 +++++++++++++
 6 files changed, 50 insertions(+), 28 deletions(-)
 rename tests/{neg => pos}/i11170a.scala (82%)
 create mode 100644 tests/run/i17021.defs.scala
 create mode 100644 tests/run/i17021.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/AccessProxies.scala b/compiler/src/dotty/tools/dotc/transform/AccessProxies.scala
index 14362260d032..3175ffceae49 100644
--- a/compiler/src/dotty/tools/dotc/transform/AccessProxies.scala
+++ b/compiler/src/dotty/tools/dotc/transform/AccessProxies.scala
@@ -71,7 +71,7 @@ abstract class AccessProxies {
     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}")
+      assert(false, i"no host found for $reference with ${reference.symbol.showLocated} from ${ctx.owner}")
       reference
     }
 
diff --git a/compiler/src/dotty/tools/dotc/transform/ProtectedAccessors.scala b/compiler/src/dotty/tools/dotc/transform/ProtectedAccessors.scala
index 6d8f7bdb32cb..c675938b86f7 100644
--- a/compiler/src/dotty/tools/dotc/transform/ProtectedAccessors.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ProtectedAccessors.scala
@@ -33,17 +33,11 @@ object ProtectedAccessors {
       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) &&
+    sym.isTerm && sym.is(Protected) &&
+    !sym.owner.is(Trait) && // trait methods need to be handled specially, are currently always public
+    !insideBoundaryOf(sym) &&
     !ctx.owner.enclosingClass.derivesFrom(sym.owner)
 }
 
diff --git a/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala b/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala
index 2307f759b571..5d7210a59a96 100644
--- a/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala
+++ b/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala
@@ -174,26 +174,20 @@ class SuperAccessors(thisPhase: DenotTransformer) {
     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) &&
+      ProtectedAccessors.needsAccessor(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.
-          */
+        /* Given a protected member m defined in class C,
+         * and a trait T that calls m.
+         *
+         * If T extends C, then we can access it by casting
+         * the qualifier of the select to C.
+         *
+         * Otherwise, we need to go through an accessor,
+         * which the implementing class will provide an implementation for.
+         */
         superAccessorCall(sel)
       case Super(_, mix) =>
         transformSuperSelect(sel)
diff --git a/tests/neg/i11170a.scala b/tests/pos/i11170a.scala
similarity index 82%
rename from tests/neg/i11170a.scala
rename to tests/pos/i11170a.scala
index 5268c506f33f..bbf627ce8864 100644
--- a/tests/neg/i11170a.scala
+++ b/tests/pos/i11170a.scala
@@ -23,6 +23,6 @@ package cpackage {
   import apackage._
   import bpackage._
 
-  case class C(override protected val x: Int) extends A with B  // error
+  case class C(override protected val x: Int) extends A with B
   case class C2(override val x: Int) extends A2 with B2
-}
\ No newline at end of file
+}
diff --git a/tests/run/i17021.defs.scala b/tests/run/i17021.defs.scala
new file mode 100644
index 000000000000..126759b5d268
--- /dev/null
+++ b/tests/run/i17021.defs.scala
@@ -0,0 +1,16 @@
+// Derives from run/i17021, but with defs instead of vals
+package p1:
+  class A:
+    protected def foo: Int = 1
+
+package p2:
+  trait B extends p1.A:
+    def bar: Int = foo
+
+  class C extends B:
+    override def foo: Int = 2
+
+object Test:
+  def main(args: Array[String]): Unit =
+    val n = new p2.C().bar
+    assert(n == 2, n) // was: assertion failed: 1
diff --git a/tests/run/i17021.scala b/tests/run/i17021.scala
new file mode 100644
index 000000000000..7465508e7f0a
--- /dev/null
+++ b/tests/run/i17021.scala
@@ -0,0 +1,18 @@
+package p1:
+  class A:
+    protected val foo: Int = 1
+
+package p2:
+  trait B extends p1.A:
+    def bar: Int = foo
+
+  class C extends B: // was: error: parent trait B has a super call which binds to the value p1.A.foo. Super calls can only target methods.
+    override val foo: Int = 2
+
+// Also, assert that the access continues to delegate:
+// i.e. B#bar delegates to this.foo and so C#bar returns 2,
+// not B#bar delegates to super.foo and so C#bar returns 1.
+object Test:
+  def main(args: Array[String]): Unit =
+    val n = new p2.C().bar
+    assert(n == 2, n) // was: assertion failed: 1

From 4b83f1ff392340b5829ef5ea67453ed159600241 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Tue, 7 Mar 2023 17:21:21 +0100
Subject: [PATCH 239/657] Update tests/neg-custom-args/explain/i16888.check

---
 tests/neg-custom-args/explain/i16888.check | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/neg-custom-args/explain/i16888.check b/tests/neg-custom-args/explain/i16888.check
index e184ea418a94..53103576d158 100644
--- a/tests/neg-custom-args/explain/i16888.check
+++ b/tests/neg-custom-args/explain/i16888.check
@@ -5,7 +5,7 @@
   |---------------------------------------------------------------------------------------------------------------------
   | Explanation (enabled by `-explain`)
   |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-  | Maybe this methods is missing a `(using Quotes)` parameter.
+  | Maybe this method is missing a `(using Quotes)` parameter.
   |
   | Maybe that splice `$ { ... }` is missing?
   | Given instances of `Quotes` are generated from an enclosing splice `$ { ... }` (or `scala.staging.run` call).

From 9b15b2ed0205ed6e273c3cfbad9ed9a24e8bc2f1 Mon Sep 17 00:00:00 2001
From: Matt Bovel <matthieu@bovel.net>
Date: Tue, 7 Mar 2023 17:24:15 +0100
Subject: [PATCH 240/657] Remove extra spaces in error messages

---
 .../tools/dotc/core/MatchTypeTrace.scala      | 10 ++--
 tests/neg/6570-1.check                        |  4 +-
 tests/neg/6571.check                          |  4 +-
 tests/neg/i11982a.check                       |  6 +-
 tests/neg/i12049.check                        | 14 ++---
 tests/neg/i13780.check                        |  4 +-
 tests/neg/i15618.check                        |  2 +-
 tests/neg/matchtype-seq.check                 | 58 +++++++++----------
 8 files changed, 51 insertions(+), 51 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/MatchTypeTrace.scala b/compiler/src/dotty/tools/dotc/core/MatchTypeTrace.scala
index 062ddd5e846c..60ebc95e7bed 100644
--- a/compiler/src/dotty/tools/dotc/core/MatchTypeTrace.scala
+++ b/compiler/src/dotty/tools/dotc/core/MatchTypeTrace.scala
@@ -100,16 +100,16 @@ object MatchTypeTrace:
     case TryReduce(scrut: Type) =>
       i"  trying to reduce  $scrut"
     case NoMatches(scrut, cases) =>
-      i"""  failed since selector  $scrut
+      i"""  failed since selector $scrut
          |  matches none of the cases
          |
          |    ${casesText(cases)}"""
     case EmptyScrutinee(scrut) =>
-      i"""  failed since selector  $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
+        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
@@ -121,14 +121,14 @@ object MatchTypeTrace:
            |    ${casesText(otherCases)}"""
     case NoInstance(scrut, stuckCase, fails) =>
       def params = if fails.length == 1 then "parameter" else "parameters"
-      i"""  failed since selector  $scrut
+      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
+    i"""failed since selector $scrut
        |matches none of the cases
        |
        |    ${casesText(cases)}"""
diff --git a/tests/neg/6570-1.check b/tests/neg/6570-1.check
index fa53e71cbb6b..bdbadd0f752a 100644
--- a/tests/neg/6570-1.check
+++ b/tests/neg/6570-1.check
@@ -7,7 +7,7 @@
    |                           Note: a match type could not be fully reduced:
    |
    |                             trying to reduce  N[Box[Int & String]]
-   |                             failed since selector  Box[Int & String]
+   |                             failed since selector Box[Int & String]
    |                             is uninhabited (there are no values of that type).
    |
    | longer explanation available when compiling with `-explain`
@@ -23,7 +23,7 @@
    |                                                Note: a match type could not be fully reduced:
    |
    |                                                  trying to reduce  M[T]
-   |                                                  failed since selector  T
+   |                                                  failed since selector T
    |                                                  does not uniquely determine parameter x in
    |                                                    case Cov[x] => N[x]
    |                                                  The computed bounds for the parameter are:
diff --git a/tests/neg/6571.check b/tests/neg/6571.check
index 42997407765f..4172abb2919b 100644
--- a/tests/neg/6571.check
+++ b/tests/neg/6571.check
@@ -7,7 +7,7 @@
   |                                       Note: a match type could not be fully reduced:
   |
   |                                         trying to reduce  Test.M[Test.Inv[Int] & Test.Inv[String]]
-  |                                         failed since selector  Test.Inv[Int] & Test.Inv[String]
+  |                                         failed since selector Test.Inv[Int] & Test.Inv[String]
   |                                         is uninhabited (there are no values of that type).
   |
   | longer explanation available when compiling with `-explain`
@@ -20,7 +20,7 @@
   |                                       Note: a match type could not be fully reduced:
   |
   |                                         trying to reduce  Test.M[Test.Inv[String] & Test.Inv[Int]]
-  |                                         failed since selector  Test.Inv[String] & Test.Inv[Int]
+  |                                         failed since selector Test.Inv[String] & Test.Inv[Int]
   |                                         is uninhabited (there are no values of that type).
   |
   | longer explanation available when compiling with `-explain`
diff --git a/tests/neg/i11982a.check b/tests/neg/i11982a.check
index bc07c82059cc..1977aa30e8b5 100644
--- a/tests/neg/i11982a.check
+++ b/tests/neg/i11982a.check
@@ -6,7 +6,7 @@
   |                                  Note: a match type could not be fully reduced:
   |
   |                                    trying to reduce  Tuple.Tail[X]
-  |                                    failed since selector  X
+  |                                    failed since selector X
   |                                    does not uniquely determine parameter xs in
   |                                      case _ *: xs => xs
   |                                    The computed bounds for the parameter are:
@@ -21,7 +21,7 @@
    |                                      Note: a match type could not be fully reduced:
    |
    |                                        trying to reduce  Tuple.Tail[X]
-   |                                        failed since selector  X
+   |                                        failed since selector X
    |                                        does not uniquely determine parameter xs in
    |                                          case _ *: xs => xs
    |                                        The computed bounds for the parameter are:
@@ -36,7 +36,7 @@
    |                         Note: a match type could not be fully reduced:
    |
    |                           trying to reduce  Tuple.Tail[X]
-   |                           failed since selector  X
+   |                           failed since selector X
    |                           does not uniquely determine parameter xs in
    |                             case _ *: xs => xs
    |                           The computed bounds for the parameter are:
diff --git a/tests/neg/i12049.check b/tests/neg/i12049.check
index a58624ec6778..11c648e35a57 100644
--- a/tests/neg/i12049.check
+++ b/tests/neg/i12049.check
@@ -7,7 +7,7 @@
   |                Note: a match type could not be fully reduced:
   |
   |                  trying to reduce  M[B]
-  |                  failed since selector  B
+  |                  failed since selector B
   |                  does not match  case A => Int
   |                  and cannot be shown to be disjoint from it either.
   |                  Therefore, reduction cannot advance to the remaining case
@@ -18,7 +18,7 @@
 -- Error: tests/neg/i12049.scala:14:23 ---------------------------------------------------------------------------------
 14 |val y3: String = ??? : Last[Int *: Int *: Boolean *: String *: EmptyTuple]  // error
    |                       ^
-   |                       Match type reduction failed since selector  EmptyTuple.type
+   |                       Match type reduction failed since selector EmptyTuple.type
    |                       matches none of the cases
    |
    |                           case _ *: _ *: t => Last[t]
@@ -26,7 +26,7 @@
 -- Error: tests/neg/i12049.scala:22:26 ---------------------------------------------------------------------------------
 22 |val z3: (A, B, A) = ??? : Reverse[(A, B, A)] // error
    |                          ^
-   |                          Match type reduction failed since selector  A *: EmptyTuple.type
+   |                          Match type reduction failed since selector A *: EmptyTuple.type
    |                          matches none of the cases
    |
    |                              case t1 *: t2 *: ts => Tuple.Concat[Reverse[ts], (t2, t1)]
@@ -39,7 +39,7 @@
    |                    Note: a match type could not be fully reduced:
    |
    |                      trying to reduce  M[B]
-   |                      failed since selector  B
+   |                      failed since selector B
    |                      does not match  case A => Int
    |                      and cannot be shown to be disjoint from it either.
    |                      Therefore, reduction cannot advance to the remaining case
@@ -48,7 +48,7 @@
 -- Error: tests/neg/i12049.scala:25:26 ---------------------------------------------------------------------------------
 25 |val _ = summon[String =:= Last[Int *: Int *: Boolean *: String *: EmptyTuple]] // error
    |                          ^
-   |                          Match type reduction failed since selector  EmptyTuple.type
+   |                          Match type reduction failed since selector EmptyTuple.type
    |                          matches none of the cases
    |
    |                              case _ *: _ *: t => Last[t]
@@ -56,7 +56,7 @@
 -- Error: tests/neg/i12049.scala:26:29 ---------------------------------------------------------------------------------
 26 |val _ = summon[(A, B, A) =:= Reverse[(A, B, A)]] // error
    |                             ^
-   |                             Match type reduction failed since selector  A *: EmptyTuple.type
+   |                             Match type reduction failed since selector A *: EmptyTuple.type
    |                             matches none of the cases
    |
    |                                 case t1 *: t2 *: ts => Tuple.Concat[Reverse[ts], (t2, t1)]
@@ -69,7 +69,7 @@
    |        Note: a match type could not be fully reduced:
    |
    |          trying to reduce  M[B]
-   |          failed since selector  B
+   |          failed since selector B
    |          does not match  case A => Int
    |          and cannot be shown to be disjoint from it either.
    |          Therefore, reduction cannot advance to the remaining case
diff --git a/tests/neg/i13780.check b/tests/neg/i13780.check
index 56b6a67ac8e7..aa0a47db5737 100644
--- a/tests/neg/i13780.check
+++ b/tests/neg/i13780.check
@@ -10,7 +10,7 @@
    |                         Note: a match type could not be fully reduced:
    |
    |                           trying to reduce  Head[X]
-   |                           failed since selector  X
+   |                           failed since selector X
    |                           does not uniquely determine parameters a, b in
    |                             case (a, b) => a
    |                           The computed bounds for the parameters are:
@@ -30,7 +30,7 @@
    |                               Note: a match type could not be fully reduced:
    |
    |                                 trying to reduce  Head[X]
-   |                                 failed since selector  X
+   |                                 failed since selector X
    |                                 does not uniquely determine parameters a, b in
    |                                   case (a, b) => a
    |                                 The computed bounds for the parameters are:
diff --git a/tests/neg/i15618.check b/tests/neg/i15618.check
index 16fadcd9b886..099e3fe0a0b7 100644
--- a/tests/neg/i15618.check
+++ b/tests/neg/i15618.check
@@ -9,7 +9,7 @@
    |                                            Note: a match type could not be fully reduced:
    |
    |                                              trying to reduce  ScalaType[T]
-   |                                              failed since selector  T
+   |                                              failed since selector T
    |                                              does not match  case Float16 => Float
    |                                              and cannot be shown to be disjoint from it either.
    |                                              Therefore, reduction cannot advance to the remaining cases
diff --git a/tests/neg/matchtype-seq.check b/tests/neg/matchtype-seq.check
index aba1e312da01..9c37fc08c4df 100644
--- a/tests/neg/matchtype-seq.check
+++ b/tests/neg/matchtype-seq.check
@@ -1,7 +1,7 @@
 -- Error: tests/neg/matchtype-seq.scala:9:11 ---------------------------------------------------------------------------
 9 |  identity[T1[3]]("") // error
   |           ^
-  |           Match type reduction failed since selector  (3 : Int)
+  |           Match type reduction failed since selector (3 : Int)
   |           matches none of the cases
   |
   |               case (1 : Int) => Int
@@ -9,7 +9,7 @@
 -- Error: tests/neg/matchtype-seq.scala:10:11 --------------------------------------------------------------------------
 10 |  identity[T1[3]](1) // error
    |           ^
-   |           Match type reduction failed since selector  (3 : Int)
+   |           Match type reduction failed since selector (3 : Int)
    |           matches none of the cases
    |
    |               case (1 : Int) => Int
@@ -23,7 +23,7 @@
    |                    Note: a match type could not be fully reduced:
    |
    |                      trying to reduce  Test.T1[Int]
-   |                      failed since selector  Int
+   |                      failed since selector Int
    |                      does not match  case (1 : Int) => Int
    |                      and cannot be shown to be disjoint from it either.
    |                      Therefore, reduction cannot advance to the remaining case
@@ -40,7 +40,7 @@
    |                    Note: a match type could not be fully reduced:
    |
    |                      trying to reduce  Test.T1[Int]
-   |                      failed since selector  Int
+   |                      failed since selector Int
    |                      does not match  case (1 : Int) => Int
    |                      and cannot be shown to be disjoint from it either.
    |                      Therefore, reduction cannot advance to the remaining case
@@ -57,7 +57,7 @@
    |                    Note: a match type could not be fully reduced:
    |
    |                      trying to reduce  Test.T2[Int]
-   |                      failed since selector  Int
+   |                      failed since selector Int
    |                      does not match  case (1 : Int) => Int
    |                      and cannot be shown to be disjoint from it either.
    |                      Therefore, reduction cannot advance to the remaining case
@@ -81,7 +81,7 @@
    |                    Note: a match type could not be fully reduced:
    |
    |                      trying to reduce  Test.T2[Int]
-   |                      failed since selector  Int
+   |                      failed since selector Int
    |                      does not match  case (1 : Int) => Int
    |                      and cannot be shown to be disjoint from it either.
    |                      Therefore, reduction cannot advance to the remaining case
@@ -98,7 +98,7 @@
    |                  Note: a match type could not be fully reduced:
    |
    |                    trying to reduce  Test.T3[Test.A]
-   |                    failed since selector  Test.A
+   |                    failed since selector Test.A
    |                    does not match  case Test.B => Int
    |                    and cannot be shown to be disjoint from it either.
    |                    Therefore, reduction cannot advance to the remaining case
@@ -115,7 +115,7 @@
    |                  Note: a match type could not be fully reduced:
    |
    |                    trying to reduce  Test.T3[Test.A]
-   |                    failed since selector  Test.A
+   |                    failed since selector Test.A
    |                    does not match  case Test.B => Int
    |                    and cannot be shown to be disjoint from it either.
    |                    Therefore, reduction cannot advance to the remaining case
@@ -132,7 +132,7 @@
    |                  Note: a match type could not be fully reduced:
    |
    |                    trying to reduce  Test.T5[Test.A]
-   |                    failed since selector  Test.A
+   |                    failed since selector Test.A
    |                    does not match  case Test.C => String
    |                    and cannot be shown to be disjoint from it either.
    |                    Therefore, reduction cannot advance to the remaining case
@@ -149,7 +149,7 @@
    |                  Note: a match type could not be fully reduced:
    |
    |                    trying to reduce  Test.T5[Test.A]
-   |                    failed since selector  Test.A
+   |                    failed since selector Test.A
    |                    does not match  case Test.C => String
    |                    and cannot be shown to be disjoint from it either.
    |                    Therefore, reduction cannot advance to the remaining case
@@ -166,7 +166,7 @@
    |                  Note: a match type could not be fully reduced:
    |
    |                    trying to reduce  Test.T7[Test.D]
-   |                    failed since selector  Test.D
+   |                    failed since selector Test.D
    |                    does not match  case Test.A2 => Int
    |                    and cannot be shown to be disjoint from it either.
    |                    Therefore, reduction cannot advance to the remaining case
@@ -183,7 +183,7 @@
    |                  Note: a match type could not be fully reduced:
    |
    |                    trying to reduce  Test.T7[Test.D]
-   |                    failed since selector  Test.D
+   |                    failed since selector Test.D
    |                    does not match  case Test.A2 => Int
    |                    and cannot be shown to be disjoint from it either.
    |                    Therefore, reduction cannot advance to the remaining case
@@ -200,7 +200,7 @@
    |                   Note: a match type could not be fully reduced:
    |
    |                     trying to reduce  Test.T8[Test.E2]
-   |                     failed since selector  Test.E2
+   |                     failed since selector Test.E2
    |                     does not match  case Test.E1 => Int
    |                     and cannot be shown to be disjoint from it either.
    |                     Therefore, reduction cannot advance to the remaining case
@@ -224,7 +224,7 @@
    |                   Note: a match type could not be fully reduced:
    |
    |                     trying to reduce  Test.T8[Test.E2]
-   |                     failed since selector  Test.E2
+   |                     failed since selector Test.E2
    |                     does not match  case Test.E1 => Int
    |                     and cannot be shown to be disjoint from it either.
    |                     Therefore, reduction cannot advance to the remaining case
@@ -241,7 +241,7 @@
     |                                        Note: a match type could not be fully reduced:
     |
     |                                          trying to reduce  Test.T9[(Nothing, String)]
-    |                                          failed since selector  (Nothing, String)
+    |                                          failed since selector (Nothing, String)
     |                                          is uninhabited (there are no values of that type).
     |
     | longer explanation available when compiling with `-explain`
@@ -254,7 +254,7 @@
     |                                        Note: a match type could not be fully reduced:
     |
     |                                          trying to reduce  Test.T9[(String, Nothing)]
-    |                                          failed since selector  (String, Nothing)
+    |                                          failed since selector (String, Nothing)
     |                                          is uninhabited (there are no values of that type).
     |
     | longer explanation available when compiling with `-explain`
@@ -267,7 +267,7 @@
     |                                     Note: a match type could not be fully reduced:
     |
     |                                       trying to reduce  Test.T9[(Int, Nothing)]
-    |                                       failed since selector  (Int, Nothing)
+    |                                       failed since selector (Int, Nothing)
     |                                       is uninhabited (there are no values of that type).
     |
     | longer explanation available when compiling with `-explain`
@@ -280,7 +280,7 @@
     |                                     Note: a match type could not be fully reduced:
     |
     |                                       trying to reduce  Test.T9[(Nothing, Int)]
-    |                                       failed since selector  (Nothing, Int)
+    |                                       failed since selector (Nothing, Int)
     |                                       is uninhabited (there are no values of that type).
     |
     | longer explanation available when compiling with `-explain`
@@ -293,7 +293,7 @@
     |                             Note: a match type could not be fully reduced:
     |
     |                               trying to reduce  Test.T9[(?, ?)]
-    |                               failed since selector  (?, ?)
+    |                               failed since selector (?, ?)
     |                               does not match  case (Int, String) => Int
     |                               and cannot be shown to be disjoint from it either.
     |                               Therefore, reduction cannot advance to the remaining case
@@ -310,7 +310,7 @@
     |                             Note: a match type could not be fully reduced:
     |
     |                               trying to reduce  Test.T9[(?, ?)]
-    |                               failed since selector  (?, ?)
+    |                               failed since selector (?, ?)
     |                               does not match  case (Int, String) => Int
     |                               and cannot be shown to be disjoint from it either.
     |                               Therefore, reduction cannot advance to the remaining case
@@ -327,7 +327,7 @@
     |                                 Note: a match type could not be fully reduced:
     |
     |                                   trying to reduce  Test.T9[(Any, Any)]
-    |                                   failed since selector  (Any, Any)
+    |                                   failed since selector (Any, Any)
     |                                   does not match  case (Int, String) => Int
     |                                   and cannot be shown to be disjoint from it either.
     |                                   Therefore, reduction cannot advance to the remaining case
@@ -344,7 +344,7 @@
     |                                 Note: a match type could not be fully reduced:
     |
     |                                   trying to reduce  Test.T9[(Any, Any)]
-    |                                   failed since selector  (Any, Any)
+    |                                   failed since selector (Any, Any)
     |                                   does not match  case (Int, String) => Int
     |                                   and cannot be shown to be disjoint from it either.
     |                                   Therefore, reduction cannot advance to the remaining case
@@ -361,7 +361,7 @@
     |                                       Note: a match type could not be fully reduced:
     |
     |                                         trying to reduce  Test.TA[Test.Box2[Int, Int, String]]
-    |                                         failed since selector  Test.Box2[Int, Int, String]
+    |                                         failed since selector Test.Box2[Int, Int, String]
     |                                         does not match  case Test.Box2[Int, Int, Int] => Int
     |                                         and cannot be shown to be disjoint from it either.
     |                                         Therefore, reduction cannot advance to the remaining case
@@ -378,7 +378,7 @@
     |                                       Note: a match type could not be fully reduced:
     |
     |                                         trying to reduce  Test.TA[Test.Box2[Int, Int, String]]
-    |                                         failed since selector  Test.Box2[Int, Int, String]
+    |                                         failed since selector Test.Box2[Int, Int, String]
     |                                         does not match  case Test.Box2[Int, Int, Int] => Int
     |                                         and cannot be shown to be disjoint from it either.
     |                                         Therefore, reduction cannot advance to the remaining case
@@ -395,7 +395,7 @@
     |                                         Note: a match type could not be fully reduced:
     |
     |                                           trying to reduce  Test.TD[Test.Box2_C[Int, Int, String]]
-    |                                           failed since selector  Test.Box2_C[Int, Int, String]
+    |                                           failed since selector Test.Box2_C[Int, Int, String]
     |                                           does not match  case Test.Box2_C[Int, Int, Int] => Int
     |                                           and cannot be shown to be disjoint from it either.
     |                                           Therefore, reduction cannot advance to the remaining case
@@ -412,7 +412,7 @@
     |                         Note: a match type could not be fully reduced:
     |
     |                           trying to reduce  Test2.M[Some[A]]
-    |                           failed since selector  Some[A]
+    |                           failed since selector Some[A]
     |                           does not match  case Option[Int] => String
     |                           and cannot be shown to be disjoint from it either.
     |                           Therefore, reduction cannot advance to the remaining case
@@ -429,7 +429,7 @@
     |                         Note: a match type could not be fully reduced:
     |
     |                           trying to reduce  Test2.M[Some[A]]
-    |                           failed since selector  Some[A]
+    |                           failed since selector Some[A]
     |                           does not match  case Option[Int] => String
     |                           and cannot be shown to be disjoint from it either.
     |                           Therefore, reduction cannot advance to the remaining case
@@ -446,7 +446,7 @@
     |                       Note: a match type could not be fully reduced:
     |
     |                         trying to reduce  Test3.M[Test3.Inv[A]]
-    |                         failed since selector  Test3.Inv[A]
+    |                         failed since selector Test3.Inv[A]
     |                         does not match  case Test3.Inv[Int] => String
     |                         and cannot be shown to be disjoint from it either.
     |                         Therefore, reduction cannot advance to the remaining case
@@ -463,7 +463,7 @@
     |                         Note: a match type could not be fully reduced:
     |
     |                           trying to reduce  Test4.M[Test4.Inv[Foo.this.A]]
-    |                           failed since selector  Test4.Inv[Foo.this.A]
+    |                           failed since selector Test4.Inv[Foo.this.A]
     |                           does not match  case Test4.Inv[Int] => String
     |                           and cannot be shown to be disjoint from it either.
     |                           Therefore, reduction cannot advance to the remaining case

From 50ff0475510cb2364bc4b0d42cabf50421a69f6b Mon Sep 17 00:00:00 2001
From: Matt Bovel <matthieu@bovel.net>
Date: Tue, 7 Mar 2023 17:47:48 +0100
Subject: [PATCH 241/657] Consider TypeBounds not fully instantiated

---
 .../src/dotty/tools/dotc/core/TypeComparer.scala    |  2 +-
 tests/pos/i16869.scala                              | 13 +++++++++++++
 2 files changed, 14 insertions(+), 1 deletion(-)
 create mode 100644 tests/pos/i16869.scala

diff --git a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
index f097bd160fdd..9dda18c72f26 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
@@ -2725,7 +2725,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
         x && {
           t.dealias match {
             case tp: TypeRef if !tp.symbol.isClass => false
-            case _: SkolemType | _: TypeVar | _: TypeParamRef => false
+            case _: SkolemType | _: TypeVar | _: TypeParamRef | _: TypeBounds => false
             case _ => foldOver(x, t)
           }
         }
diff --git a/tests/pos/i16869.scala b/tests/pos/i16869.scala
new file mode 100644
index 000000000000..4067e34ac8ef
--- /dev/null
+++ b/tests/pos/i16869.scala
@@ -0,0 +1,13 @@
+class C[T]
+
+type Foo[T] = T match
+  case C[true] => true
+  case C[false] => false
+
+class W[T] extends C[Foo[T]]
+
+def f[T <: C[?]](t: T) = W[T]()
+
+def test =
+  val b = C[true]()
+  f(b): C[true]

From 7d4e103a941a30306ddde28a11f8bc3a8841acf8 Mon Sep 17 00:00:00 2001
From: Lukas Rytz <lukas.rytz@gmail.com>
Date: Thu, 2 Mar 2023 11:47:27 +0100
Subject: [PATCH 242/657] Include top-level symbols from same file in outer
 ambiguity error

When checking if an inherited definition is ambiguous with an
outer definition, include top-level outer definitions defined
in the same compilation unit.
---
 .../src/dotty/tools/dotc/typer/Typer.scala    | 19 ++++++++++++----
 tests/neg/ambiref.check                       | 16 ++++++++++++++
 tests/neg/ambiref.scala                       | 22 ++++++++++++++++++-
 tests/pos-special/fatal-warnings/i9260.scala  |  2 +-
 tests/run/protectedacc.scala                  |  2 +-
 5 files changed, 54 insertions(+), 7 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 9d8fdcc006c9..02a432d1fd9e 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -366,11 +366,16 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           // 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
+              !mbr.symbol.exists || mbr.symbol.owner == ctx.owner || ctx.owner.is(Package)
             denot match
               case denot: SingleDenotation => !isCurrent(denot)
               case denot => !denot.hasAltWith(isCurrent)
 
+          /* It is an error if an identifier x is available as an inherited member in an inner scope
+           * and the same name x is defined in an outer scope in the same source file, unless
+           * the inherited member (has an overloaded alternative that) coincides with
+           * (an overloaded alternative of) the definition x.
+           */
           def checkNoOuterDefs(denot: Denotation, last: Context, prevCtx: Context): Unit =
             def sameTermOrType(d1: SingleDenotation, d2: Denotation) =
               d2.containsSym(d1.symbol) || d2.hasUniqueSym && {
@@ -387,9 +392,15 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
             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)
+            else if !owner.isRoot then
+              val found =
+                if owner.is(Package) then
+                  owner.denot.asClass.membersNamed(name)
+                    .filterWithPredicate(d => !d.symbol.is(Package) && d.symbol.source == denot.symbol.source)
+                else
+                  val scope = if owner.isClass then owner.info.decls else outer.scope
+                  scope.denotsNamed(name)
+              val competing = found.filterWithFlags(required, excluded | Synthetic)
               if competing.exists then
                 val symsMatch = competing
                   .filterWithPredicate(sd => sameTermOrType(sd, denot))
diff --git a/tests/neg/ambiref.check b/tests/neg/ambiref.check
index 5d701b3b3b71..32b4078f1346 100644
--- a/tests/neg/ambiref.check
+++ b/tests/neg/ambiref.check
@@ -30,3 +30,19 @@
    |                and inherited subsequently in class E
    |
    | longer explanation available when compiling with `-explain`
+-- [E049] Reference Error: tests/neg/ambiref.scala:43:10 ---------------------------------------------------------------
+43 |  println(global)    // error
+   |          ^^^^^^
+   |          Reference to global is ambiguous.
+   |          It is both defined in package <empty>
+   |          and inherited subsequently in object D
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E049] Reference Error: tests/neg/ambiref.scala:49:16 ---------------------------------------------------------------
+49 |    def t = new T { } // error
+   |                ^
+   |                Reference to T is ambiguous.
+   |                It is both defined in package p
+   |                and inherited subsequently in class C
+   |
+   | longer explanation available when compiling with `-explain`
diff --git a/tests/neg/ambiref.scala b/tests/neg/ambiref.scala
index e7a5d5efbd7e..bb48997cd465 100644
--- a/tests/neg/ambiref.scala
+++ b/tests/neg/ambiref.scala
@@ -40,4 +40,24 @@ val global = 0
 class C:
   val global = 1
 object D extends C:
-  println(global)    // OK, since global is defined in package
\ No newline at end of file
+  println(global)    // error
+
+package p:
+  class T
+  trait P { trait T }
+  class C extends P:
+    def t = new T { } // error
+
+package scala:
+  trait P { trait Option[+A] }
+  class C extends P:
+    def t = new Option[String] { } // OK, competing scala.Option is not defined in the same compilation unit
+
+object test5:
+  class Mu // generates a synthetic companion object with an apply method
+  trait A {
+    val Mu = 1
+  }
+  trait B extends A {
+    def t = Mu // don't warn about synthetic companion
+  }
diff --git a/tests/pos-special/fatal-warnings/i9260.scala b/tests/pos-special/fatal-warnings/i9260.scala
index df548f393eea..0392c1c96fa8 100644
--- a/tests/pos-special/fatal-warnings/i9260.scala
+++ b/tests/pos-special/fatal-warnings/i9260.scala
@@ -10,7 +10,7 @@ end AstImpl
 
 object untpd extends AstImpl[Null]:
 
-  def DefDef(ast: Ast): DefDef = ast match
+  def DefDef(ast: this.Ast): DefDef = ast match
     case ast: DefDef => ast
 
 end untpd
diff --git a/tests/run/protectedacc.scala b/tests/run/protectedacc.scala
index a08e7201fd15..85aa3438faa3 100644
--- a/tests/run/protectedacc.scala
+++ b/tests/run/protectedacc.scala
@@ -134,7 +134,7 @@ package p {
 
     abstract class X[T] extends PolyA[T] {
 
-      trait Inner extends B {
+      trait Inner extends this.B {
         def self: T;
         def self2: Node;
         def getB: Inner;

From 36298a2dd4c988771c8e4093113da3edca5137de Mon Sep 17 00:00:00 2001
From: David Hua <d5hua@uwaterloo.ca>
Date: Wed, 8 Mar 2023 20:43:20 -0500
Subject: [PATCH 243/657] Address feedback.

---
 compiler/src/dotty/tools/dotc/transform/init/Semantic.scala | 6 +++---
 tests/init/neg/inherit-non-hot.check                        | 2 +-
 tests/init/neg/promotion-loop.check                         | 2 +-
 tests/init/neg/promotion-segment3.check                     | 2 +-
 4 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
index 7981153f46a7..1b7e1266ac13 100644
--- a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
+++ b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
@@ -67,7 +67,7 @@ object Semantic:
         "the original object of type (" + klass.show + ") where initialization checking started"
       case Warm(klass, outer, ctor, args) =>
         val argsText = if args.nonEmpty then ", args = " + args.map(_.show).mkString("(", ", ", ")") else ""
-        "an initialized (Warm) object of type (" + klass.show + ") { outer = " + outer.show + argsText + " }"
+        "a non-transitively initialized (Warm) object of type (" + klass.show + ") { outer = " + outer.show + argsText + " }"
       case Fun(expr, thisV, klass) =>
         "a function where \"this\" is (" + thisV.show + ") and the function owner is an object of type (" + klass.show + ")"
       case RefSet(values) =>
@@ -472,7 +472,7 @@ object Semantic:
     def widenArg: Contextual[Value] =
       a match
       case _: Ref | _: Fun =>
-        val hasError = Reporter.hasErrors { a.promote("Argument cannot be proven to be transitively initialized (Hot)") }
+        val hasError = Reporter.hasErrors { a.promote("Argument is not provably transitively initialized (Hot)") }
         if hasError then Cold else Hot
 
       case RefSet(refs) =>
@@ -710,7 +710,7 @@ object Semantic:
               promoteArgs()
               // try promoting the receiver as last resort
               val hasErrors = Reporter.hasErrors {
-                ref.promote(ref.show + " has no source code and could not be proven to be transitively initialized (Hot).")
+                ref.promote(ref.show + " has no source code and is not provably transitively initialized (Hot).")
               }
               if hasErrors then
                 val error = CallUnknown(target)(trace)
diff --git a/tests/init/neg/inherit-non-hot.check b/tests/init/neg/inherit-non-hot.check
index 2c195bcacf1d..068ba9662fd1 100644
--- a/tests/init/neg/inherit-non-hot.check
+++ b/tests/init/neg/inherit-non-hot.check
@@ -1,7 +1,7 @@
 -- Error: tests/init/neg/inherit-non-hot.scala:6:32 --------------------------------------------------------------------
 6 |            if b == null then b = new B(this) // error
   |                              ^^^^^^^^^^^^^^^
-  |The RHS of reassignment must be transitively initialized (Hot). It was found to be an initialized (Warm) object of type (class B) { outer = a transitively initialized (Hot) object, args = (an uninitialized (Cold) object) }.  Calling trace:
+  |The RHS of reassignment must be transitively initialized (Hot). It was found to be a non-transitively initialized (Warm) object of type (class B) { outer = a transitively initialized (Hot) object, args = (an uninitialized (Cold) object) }.  Calling trace:
   |-> class C extends A {	[ inherit-non-hot.scala:15 ]
   |   ^
   |-> val bAgain = toB.getBAgain	[ inherit-non-hot.scala:16 ]
diff --git a/tests/init/neg/promotion-loop.check b/tests/init/neg/promotion-loop.check
index 28562aa0effb..ec0a6854bbac 100644
--- a/tests/init/neg/promotion-loop.check
+++ b/tests/init/neg/promotion-loop.check
@@ -1,7 +1,7 @@
 -- Error: tests/init/neg/promotion-loop.scala:16:10 --------------------------------------------------------------------
 16 |  println(b)      // error
    |          ^
-   |Could not verify that the method argument is transitively initialized (Hot). It was found to be an initialized (Warm) object of type (class B) { outer = the original object of type (class Test) where initialization checking started }. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region. Calling trace:
+   |Could not verify that the method argument is transitively initialized (Hot). It was found to be a non-transitively initialized (Warm) object of type (class B) { outer = the original object of type (class Test) where initialization checking started }. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region. Calling trace:
    |-> class Test { test =>	[ promotion-loop.scala:1 ]
    |   ^
    |-> println(b)      // error	[ promotion-loop.scala:16 ]
diff --git a/tests/init/neg/promotion-segment3.check b/tests/init/neg/promotion-segment3.check
index 1765f08d872a..bc7a076d7d72 100644
--- a/tests/init/neg/promotion-segment3.check
+++ b/tests/init/neg/promotion-segment3.check
@@ -1,7 +1,7 @@
 -- Error: tests/init/neg/promotion-segment3.scala:9:6 ------------------------------------------------------------------
 9 |  bar(new B)  // error
   |      ^^^^^
-  |Could not verify that the method argument is transitively initialized (Hot). It was found to be an initialized (Warm) object of type (class B) { outer = the original object of type (class A) where initialization checking started }. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region. Calling trace:
+  |Could not verify that the method argument is transitively initialized (Hot). It was found to be a non-transitively initialized (Warm) object of type (class B) { outer = the original object of type (class A) where initialization checking started }. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region. Calling trace:
   |-> class A:	[ promotion-segment3.scala:2 ]
   |   ^
   |-> bar(new B)  // error	[ promotion-segment3.scala:9 ]

From eb0d8176658eece2fc77887b4543b6b39b473bc3 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Wed, 8 Mar 2023 17:56:16 +0100
Subject: [PATCH 244/657] Optimize captured type in splice hole

If we have a quote that defined a type `T` and use it in the contents of
the splice we want to pass a `Type[T]` to the hole.

This improves a case where we had a `List[T]` and the hole could end up
with a `Type[T]` and `Type[List[T]]`. We should only pass the `Type[T]`.
---
 compiler/src/dotty/tools/dotc/transform/Splicing.scala    | 8 ++++----
 compiler/src/dotty/tools/dotc/transform/TreeChecker.scala | 5 +++++
 tests/pos-macros/i12440.scala                             | 6 ++++++
 3 files changed, 15 insertions(+), 4 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/Splicing.scala b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
index 393fe46b8438..deea32dba6ca 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicing.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
@@ -246,7 +246,7 @@ class Splicing extends MacroTransform:
         if tree.symbol == defn.QuotedTypeModule_of && containsCapturedType(tpt.tpe) =>
           val newContent = capturedPartTypes(tpt)
           newContent match
-            case block: Block => 
+            case block: Block =>
               inContext(ctx.withSource(tree.source)) {
                 Apply(TypeApply(typeof, List(newContent)), List(quotes)).withSpan(tree.span)
               }
@@ -342,7 +342,7 @@ class Splicing extends MacroTransform:
       val bindingSym = refBindingMap.getOrElseUpdate(tree.symbol, (tree, newBinding))._2
       ref(bindingSym)
 
-    private def newQuotedTypeClassBinding(tpe: Type)(using Context) = 
+    private def newQuotedTypeClassBinding(tpe: Type)(using Context) =
       newSymbol(
         spliceOwner,
         UniqueName.fresh(nme.Type).toTermName,
@@ -361,7 +361,7 @@ class Splicing extends MacroTransform:
       healedTypes = PCPCheckAndHeal.QuoteTypeTags(tpt.span)
       val capturePartTypes = new TypeMap {
         def apply(tp: Type) = tp match {
-          case typeRef @ TypeRef(prefix, _) if isCaptured(prefix.typeSymbol) || isCaptured(prefix.termSymbol) =>
+          case typeRef: TypeRef if containsCapturedType(typeRef) =>
             val termRef = refBindingMap
               .getOrElseUpdate(typeRef.symbol, (TypeTree(typeRef), newQuotedTypeClassBinding(typeRef)))._2.termRef
             val tagRef = healedTypes.nn.getTagRef(termRef)
@@ -376,7 +376,7 @@ class Splicing extends MacroTransform:
       tpt match
         case block: Block =>
           cpy.Block(block)(newHealedTypes ::: block.stats, TypeTree(captured))
-        case _ => 
+        case _ =>
           if newHealedTypes.nonEmpty then
             cpy.Block(tpt)(newHealedTypes, TypeTree(captured))
           else
diff --git a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
index 52942ea719f9..5d2d3c7e2df8 100644
--- a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
@@ -655,6 +655,11 @@ object TreeChecker {
     override def typedHole(tree: untpd.Hole, pt: Type)(using Context): Tree = {
       val tree1 @ Hole(isTermHole, _, args, content, tpt) = super.typedHole(tree, pt): @unchecked
 
+      // Check that we only add the captured type `T` instead of a more complex type like `List[T]`.
+      // If we have `F[T]` with captured `F` and `T`, we should list `F` and `T` separately in the args.
+      for arg <- args do
+        assert(arg.isTerm || arg.tpe.isInstanceOf[TypeRef], "Expected TypeRef in Hole type args but got: " + arg.tpe)
+
       // Check result type of the hole
       if isTermHole then assert(tpt.typeOpt <:< pt)
       else assert(tpt.typeOpt =:= pt)
diff --git a/tests/pos-macros/i12440.scala b/tests/pos-macros/i12440.scala
index 4b4c56fef568..02122be28deb 100644
--- a/tests/pos-macros/i12440.scala
+++ b/tests/pos-macros/i12440.scala
@@ -5,6 +5,12 @@ trait Mirror:
 
 class Eq:
 
+  def test0(using Quotes): Unit = '{
+    type T
+    ${ summonType[T]; ??? }
+    ${ summonType[List[T]]; ??? }
+  }
+
   def test1(using Quotes): Unit = '{
     val m: Mirror = ???
     ${ summonType[m.ElemTypes]; ??? }

From 6eeea197158f7e22970bbb7cf74de5195b945a11 Mon Sep 17 00:00:00 2001
From: Guillaume Martres <smarter@ubuntu.com>
Date: Sat, 11 Mar 2023 18:02:19 +0100
Subject: [PATCH 245/657] Include `P` in the implicit scope of `P.this.type`

Before this commit, `one` compiled but `two` didn't in:

    class Foo[+T]
    class Elem:
      def one(a: Elem, x: Foo[a.type]): Int = x.ext
      def two(x: Foo[Elem.this.type]): Int  = x.ext
    object Elem:
      extension (x: Foo[Elem]) def ext: Int = 1

This happened because the anchors of the singleton reference `a.type` includes
its underlying type `Elem`, but `Elem.this.type` has no anchors at all. This
commit changes the definition of anchors to rectify this, which also brings us
closer to how Scala 2 behaves.
---
 compiler/src/dotty/tools/dotc/typer/Implicits.scala         | 3 +++
 .../_docs/reference/changed-features/implicit-resolution.md | 3 ++-
 tests/pos/this-implicit-scope.scala                         | 6 ++++++
 3 files changed, 11 insertions(+), 1 deletion(-)
 create mode 100644 tests/pos/this-implicit-scope.scala

diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
index 7d185d335218..c37da9fcf701 100644
--- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -622,6 +622,8 @@ trait ImplicitRunInfo:
                 traverse(t.prefix)
             case t: ThisType if t.cls.is(Module) && t.cls.isStaticOwner =>
               traverse(t.cls.sourceModule.termRef)
+            case t: ThisType =>
+              traverse(t.tref)
             case t: ConstantType =>
               traverse(t.underlying)
             case t: TypeParamRef =>
@@ -743,6 +745,7 @@ trait ImplicitRunInfo:
    *   - 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 this-type `P.this.type`, the anchors of `P`.
    *   - 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)
diff --git a/docs/_docs/reference/changed-features/implicit-resolution.md b/docs/_docs/reference/changed-features/implicit-resolution.md
index bf15baa3299c..6a898690b565 100644
--- a/docs/_docs/reference/changed-features/implicit-resolution.md
+++ b/docs/_docs/reference/changed-features/implicit-resolution.md
@@ -67,7 +67,8 @@ Opaque type aliases count as anchors only outside the scope where their alias is
   1. If _T_ is a reference to a type parameter, the union of the anchors of both of its bounds.
   1. 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_.
-  1. If _T_ is the this-type _o.this_ of a static object _o_, the anchors of a term reference _o.type_ to that object.
+  1. If _T_ is the this-type _o.this_ of a static object _o_, the anchors of a term reference _o.type_ to that object,
+  1. If _T_ is some other this-type _P.this.type_, the anchors of _P_.
   1. If _T_ is some other type, the union of the anchors of each constituent type of _T_.
 
  **Definition:** The _implicit scope_ of a type _T_ is the smallest set _S_ of term references such that
diff --git a/tests/pos/this-implicit-scope.scala b/tests/pos/this-implicit-scope.scala
new file mode 100644
index 000000000000..ead235e53bce
--- /dev/null
+++ b/tests/pos/this-implicit-scope.scala
@@ -0,0 +1,6 @@
+class Foo[+T]
+class Elem:
+  def one(a: Elem, x: Foo[a.type]): Int = x.ext
+  def two(x: Foo[Elem.this.type]): Int  = x.ext
+object Elem:
+  extension (x: Foo[Elem]) def ext: Int = 1

From f22420fea5662f883a5daa5ec00921fea74bb218 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sun, 12 Mar 2023 13:16:09 +0100
Subject: [PATCH 246/657] Handle @companionClass and @companionMethod
 meta-annotations

Fixes #17002
---
 .../dotty/tools/dotc/core/Definitions.scala   |  4 +++-
 .../tools/dotc/core/SymDenotations.scala      |  9 ++++++---
 .../dotty/tools/dotc/transform/Memoize.scala  |  4 ++--
 .../tools/dotc/transform/PostTyper.scala      | 16 +++++++++++----
 tests/neg/i17002.scala                        | 20 +++++++++++++++++++
 tests/pos/i17002.scala                        | 10 ++++++++++
 6 files changed, 53 insertions(+), 10 deletions(-)
 create mode 100644 tests/neg/i17002.scala
 create mode 100644 tests/pos/i17002.scala

diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
index 20a1d59316eb..148b314220a8 100644
--- a/compiler/src/dotty/tools/dotc/core/Definitions.scala
+++ b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -1028,6 +1028,8 @@ class Definitions {
   @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 CompanionClassMetaAnnot: ClassSymbol = requiredClass("scala.annotation.meta.companionClass")
+  @tu lazy val CompanionMethodMetaAnnot: ClassSymbol = requiredClass("scala.annotation.meta.companionMethod")
   @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")
@@ -1041,7 +1043,7 @@ class Definitions {
 
   // A list of meta-annotations that are relevant for fields and accessors
   @tu lazy val NonBeanMetaAnnots: Set[Symbol] =
-    Set(FieldMetaAnnot, GetterMetaAnnot, ParamMetaAnnot, SetterMetaAnnot)
+    Set(FieldMetaAnnot, GetterMetaAnnot, ParamMetaAnnot, SetterMetaAnnot, CompanionClassMetaAnnot, CompanionMethodMetaAnnot)
   @tu lazy val MetaAnnots: Set[Symbol] =
     NonBeanMetaAnnots + BeanGetterMetaAnnot + BeanSetterMetaAnnot
 
diff --git a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
index 9d7a3945a1ca..0f94d52f5be9 100644
--- a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -255,10 +255,13 @@ object SymDenotations {
     def annotationsCarrying(meta: Set[Symbol], orNoneOf: Set[Symbol] = Set.empty)(using Context): List[Annotation] =
       annotations.filterConserve(_.hasOneOfMetaAnnotation(meta, orNoneOf = orNoneOf))
 
-    def copyAndKeepAnnotationsCarrying(phase: DenotTransformer, meta: Set[Symbol], orNoneOf: Set[Symbol] = Set.empty)(using Context): Unit =
-      if annotations.nonEmpty then
+    def keepAnnotationsCarrying(phase: DenotTransformer, meta: Set[Symbol], orNoneOf: Set[Symbol] = Set.empty)(using Context): Unit =
+      updateAnnotationsAfter(phase, annotationsCarrying(meta, orNoneOf = orNoneOf))
+
+    def updateAnnotationsAfter(phase: DenotTransformer, annots: List[Annotation])(using Context): Unit =
+      if annots ne annotations then
         val cpy = copySymDenotation()
-        cpy.annotations = annotationsCarrying(meta, orNoneOf = orNoneOf)
+        cpy.annotations = annots
         cpy.installAfter(phase)
 
     /** Optionally, the annotation matching the given class symbol */
diff --git a/compiler/src/dotty/tools/dotc/transform/Memoize.scala b/compiler/src/dotty/tools/dotc/transform/Memoize.scala
index 5a2eda4101a4..1392d00011a2 100644
--- a/compiler/src/dotty/tools/dotc/transform/Memoize.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Memoize.scala
@@ -167,7 +167,7 @@ class Memoize extends MiniPhase with IdentityDenotTransformer { thisPhase =>
             if isErasableBottomField(field, rhsClass) then erasedBottomTree(rhsClass)
             else transformFollowingDeep(ref(field))(using ctx.withOwner(sym))
           val getterDef = cpy.DefDef(tree)(rhs = getterRhs)
-          sym.copyAndKeepAnnotationsCarrying(thisPhase, Set(defn.GetterMetaAnnot))
+          sym.keepAnnotationsCarrying(thisPhase, Set(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
@@ -193,7 +193,7 @@ class Memoize extends MiniPhase with IdentityDenotTransformer { thisPhase =>
             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)))
-          sym.copyAndKeepAnnotationsCarrying(thisPhase, Set(defn.SetterMetaAnnot))
+          sym.keepAnnotationsCarrying(thisPhase, Set(defn.SetterMetaAnnot))
           setterDef
       else
         // Curiously, some accessors from Scala2 have ' ' suffixes.
diff --git a/compiler/src/dotty/tools/dotc/transform/PostTyper.scala b/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
index 574db18c9c7f..7f3e47c14732 100644
--- a/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
@@ -157,14 +157,20 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
           checkInferredWellFormed(tree.tpt)
           if sym.is(Method) then
             if sym.isSetter then
-              sym.copyAndKeepAnnotationsCarrying(thisPhase, Set(defn.SetterMetaAnnot))
+              sym.keepAnnotationsCarrying(thisPhase, Set(defn.SetterMetaAnnot))
+            if sym.isOneOf(GivenOrImplicit) then
+              val cls = sym.info.finalResultType.classSymbol
+              if cls.isOneOf(GivenOrImplicit) then
+                sym.updateAnnotationsAfter(thisPhase,
+                  atPhase(thisPhase)(cls.annotationsCarrying(Set(defn.CompanionMethodMetaAnnot)))
+                    ++ sym.annotations)
           else
             if sym.is(Param) then
-              sym.copyAndKeepAnnotationsCarrying(thisPhase, Set(defn.ParamMetaAnnot), orNoneOf = defn.NonBeanMetaAnnots)
+              sym.keepAnnotationsCarrying(thisPhase, Set(defn.ParamMetaAnnot), orNoneOf = defn.NonBeanMetaAnnots)
             else if sym.is(ParamAccessor) then
-              sym.copyAndKeepAnnotationsCarrying(thisPhase, Set(defn.GetterMetaAnnot, defn.FieldMetaAnnot))
+              sym.keepAnnotationsCarrying(thisPhase, Set(defn.GetterMetaAnnot, defn.FieldMetaAnnot))
             else
-              sym.copyAndKeepAnnotationsCarrying(thisPhase, Set(defn.GetterMetaAnnot, defn.FieldMetaAnnot), orNoneOf = defn.NonBeanMetaAnnots)
+              sym.keepAnnotationsCarrying(thisPhase, Set(defn.GetterMetaAnnot, defn.FieldMetaAnnot), orNoneOf = defn.NonBeanMetaAnnots)
           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
@@ -388,6 +394,8 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
             VarianceChecker.check(tree)
             annotateExperimental(sym)
             checkMacroAnnotation(sym)
+            if sym.isOneOf(GivenOrImplicit) then
+              sym.keepAnnotationsCarrying(thisPhase, Set(defn.CompanionClassMetaAnnot), orNoneOf = defn.MetaAnnots)
             tree.rhs match
               case impl: Template =>
                 for parent <- impl.parents do
diff --git a/tests/neg/i17002.scala b/tests/neg/i17002.scala
new file mode 100644
index 000000000000..c2a21dd3d415
--- /dev/null
+++ b/tests/neg/i17002.scala
@@ -0,0 +1,20 @@
+import scala.annotation.compileTimeOnly
+
+sealed trait Test[T]
+
+object Test:
+  @compileTimeOnly("Error")
+  given test0[T]: Test[T] = ???
+
+  @compileTimeOnly("Error")
+  given test1[T]: Test[T]()
+
+  @compileTimeOnly("Error")
+  implicit class ic(x: Int):
+    def foo = 2
+
+  test0 // error
+
+  test1 // error
+
+  2.foo // error
\ No newline at end of file
diff --git a/tests/pos/i17002.scala b/tests/pos/i17002.scala
new file mode 100644
index 000000000000..d33c1bd386d9
--- /dev/null
+++ b/tests/pos/i17002.scala
@@ -0,0 +1,10 @@
+import scala.annotation.meta.companionMethod
+
+@companionMethod
+class methOnly extends annotation.Annotation
+
+class Test
+object Test:
+
+  @methOnly
+  given test2[T]: Test with {}

From 2ac2315d1550b807fea3c0ec3fab74e8642a3d39 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sun, 12 Mar 2023 18:25:52 +0100
Subject: [PATCH 247/657] Better comparisons for type projections
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

We already implemented in essence the rule suggested in lampepfl/dotty-feature-requests#14:

```
Γ ⊨ p : T
------------------------ (Sel-<:-Proj)
Γ ⊨ p.A <: T#A
```

This rule is implemented in `isSubPrefix`. But we did not get to check that since we concluded prematurely that
an alias type would never match. The alias type in question in i17064.scala was

```scala
Outer#Inner
```
Since `Outer` is not a path, the asSeenFrom to recover the info of `Outer#Inner this got approximated with
a `Nothing` argument and therefore the alias failed. It is important in this case that we could still succeed
with a `isSubPrefix` test, which comes later. So we should not return `false` when the prefix is not a singleton.

Fixes #17064
---
 .../dotty/tools/dotc/core/TypeComparer.scala    | 17 ++++++++++++++---
 tests/neg/i15525.scala                          |  2 +-
 tests/pos/i17064.scala                          | 10 ++++++++++
 3 files changed, 25 insertions(+), 4 deletions(-)
 create mode 100644 tests/pos/i17064.scala

diff --git a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
index 9dda18c72f26..07a573e9169d 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
@@ -283,17 +283,28 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
           val ctx = comparerContext
           given Context = ctx // optimization for performance
           val info2 = tp2.info
+
+          /** Does `tp2` have a singleton type or NoPrefix as a prefix?
+           *  If that's not the case, following an alias via asSeenFrom could be lossy
+           *  so we should not conclude `false` if comparing aliases fails.
+           *  See pos/i17064.scala for a test case
+           */
+          def hasPrecisePrefix(tp: NamedType) =
+            tp.prefix.isSingleton || tp.prefix == NoPrefix
+
           info2 match
             case info2: TypeAlias =>
               if recur(tp1, info2.alias) then return true
-              if tp2.asInstanceOf[TypeRef].canDropAlias then return false
+              if tp2.asInstanceOf[TypeRef].canDropAlias && hasPrecisePrefix(tp2) 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
+                  if tp1.asInstanceOf[TypeRef].canDropAlias && hasPrecisePrefix(tp2) then
+                    return false
                 case _ =>
               }
               val sym2 = tp2.symbol
@@ -302,7 +313,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
                 // 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))
+              if (sym1 ne NoSymbol) && (sym1 eq sym2) then
                 ctx.erasedTypes ||
                 sym1.isStaticOwner ||
                 isSubPrefix(tp1.prefix, tp2.prefix) ||
diff --git a/tests/neg/i15525.scala b/tests/neg/i15525.scala
index b14c244b43c8..0813d7c82435 100644
--- a/tests/neg/i15525.scala
+++ b/tests/neg/i15525.scala
@@ -37,7 +37,7 @@ def element22(
       transmittable20.Type / transmittable21.Type
   } = ???
 
-def test22 = // error
+def test22 =
   Resolution(
     element22(
       Resolution(element0), Resolution(element0), // error // error
diff --git a/tests/pos/i17064.scala b/tests/pos/i17064.scala
new file mode 100644
index 000000000000..e5a1f636f56c
--- /dev/null
+++ b/tests/pos/i17064.scala
@@ -0,0 +1,10 @@
+class HiddenInner[+O<:Outer](val outer:O){
+}
+
+class Outer{
+  type Inner = HiddenInner[this.type]
+}
+
+val o : Outer       = new Outer
+def a : o.Inner     = new o.Inner(o)
+val b : Outer#Inner = a // DOES NOT COMPILE
\ No newline at end of file

From 37e4fe703a883098a4c0e02c91faf23a5681ccf0 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sun, 12 Mar 2023 20:01:12 +0100
Subject: [PATCH 248/657] Check trait constructor for accessibility even if not
 called at Typer

This allows to restrict inheritance of traits even if the constructor is not
called, or not called at Typer.

Fixes #17089
---
 compiler/src/dotty/tools/dotc/typer/Typer.scala | 3 +++
 tests/neg/i17089.scala                          | 4 ++++
 2 files changed, 7 insertions(+)
 create mode 100644 tests/neg/i17089.scala

diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 96149caf215d..f6048f6fb156 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -2511,6 +2511,9 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           checkSimpleKinded(parent)
             // allow missing type parameters if there are implicit arguments to pass
             // since we can infer type arguments from them
+        val constr = psym.primaryConstructor
+        if constr.exists then
+          ensureAccessible(constr.termRef, superAccess = true, tree.srcPos)
       else
         checkParentCall(result, cls)
       if cls is Case then
diff --git a/tests/neg/i17089.scala b/tests/neg/i17089.scala
new file mode 100644
index 000000000000..46968aa6f093
--- /dev/null
+++ b/tests/neg/i17089.scala
@@ -0,0 +1,4 @@
+object o:
+  trait T private[o]()
+
+def test = new o.T { } // error

From 603822ec7e80b524033d10b05cb326bb9e347adc Mon Sep 17 00:00:00 2001
From: David Hua <d5hua@uwaterloo.ca>
Date: Mon, 13 Mar 2023 02:18:43 -0400
Subject: [PATCH 249/657] Make warning message more accurate.

---
 compiler/src/dotty/tools/dotc/transform/init/Semantic.scala | 2 +-
 tests/init/neg/closureLeak.check                            | 4 ++--
 tests/init/neg/default-this.check                           | 2 +-
 tests/init/neg/i15459.check                                 | 2 +-
 tests/init/neg/inlined-method.check                         | 2 +-
 tests/init/neg/inner-first.check                            | 2 +-
 tests/init/neg/promotion-loop.check                         | 2 +-
 tests/init/neg/promotion-segment3.check                     | 2 +-
 tests/init/neg/t3273.check                                  | 4 ++--
 9 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
index 1b7e1266ac13..b8d867e96a7e 100644
--- a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
+++ b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
@@ -1148,7 +1148,7 @@ object Semantic:
 
   extension (arg: ArgInfo)
     def promote: Contextual[Unit] = withTrace(arg.trace) {
-      arg.value.promote("Could not verify that the method argument is transitively initialized (Hot). It was found to be " + arg.value.show + ". Only transitively initialized arguments may be passed to methods outside the analyzed initialization region.")
+      arg.value.promote("Could not verify that the method argument is transitively initialized (Hot). It was found to be " + arg.value.show + ". Only transitively initialized arguments may be passed to methods (except constructors).")
     }
 
   /** Evaluate an expression with the given value for `this` in a given class `klass`
diff --git a/tests/init/neg/closureLeak.check b/tests/init/neg/closureLeak.check
index d4ea2ec8ef47..2437509faa73 100644
--- a/tests/init/neg/closureLeak.check
+++ b/tests/init/neg/closureLeak.check
@@ -1,14 +1,14 @@
 -- Error: tests/init/neg/closureLeak.scala:11:14 -----------------------------------------------------------------------
 11 |    l.foreach(a => a.addX(this)) // error
    |              ^^^^^^^^^^^^^^^^^
-   |Could not verify that the method argument is transitively initialized (Hot). It was found to be a function where "this" is (the original object of type (class Outer) where initialization checking started) and the function owner is an object of type (class Outer). Only transitively initialized arguments may be passed to methods outside the analyzed initialization region. Calling trace:
+   |Could not verify that the method argument is transitively initialized (Hot). It was found to be a function where "this" is (the original object of type (class Outer) where initialization checking started) and the function owner is an object of type (class Outer). Only transitively initialized arguments may be passed to methods (except constructors). Calling trace:
    |-> class Outer {	[ closureLeak.scala:1 ]
    |   ^
    |-> l.foreach(a => a.addX(this)) // error	[ closureLeak.scala:11 ]
    |             ^^^^^^^^^^^^^^^^^
    |
    |Promoting the value to transitively initialized (Hot) failed due to the following problem:
-   |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type (class Outer) where initialization checking started. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region.
+   |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type (class Outer) where initialization checking started. Only transitively initialized arguments may be passed to methods (except constructors).
    |Non initialized field(s): value p. Promotion trace:
    |-> l.foreach(a => a.addX(this)) // error	[ closureLeak.scala:11 ]
    |                         ^^^^
diff --git a/tests/init/neg/default-this.check b/tests/init/neg/default-this.check
index 84556f0a9d82..f64f36304e9b 100644
--- a/tests/init/neg/default-this.check
+++ b/tests/init/neg/default-this.check
@@ -1,7 +1,7 @@
 -- Error: tests/init/neg/default-this.scala:9:8 ------------------------------------------------------------------------
 9 |        compare() // error
   |        ^^^^^^^
-  |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type (class B) where initialization checking started. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region.
+  |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type (class B) where initialization checking started. Only transitively initialized arguments may be passed to methods (except constructors).
   |Non initialized field(s): value result. Calling trace:
   |-> class B extends A {	[ default-this.scala:6 ]
   |   ^
diff --git a/tests/init/neg/i15459.check b/tests/init/neg/i15459.check
index fffeabd560e1..a8c9972276db 100644
--- a/tests/init/neg/i15459.check
+++ b/tests/init/neg/i15459.check
@@ -1,7 +1,7 @@
 -- Error: tests/init/neg/i15459.scala:3:10 -----------------------------------------------------------------------------
 3 |  println(this)  // error
   |          ^^^^
-  |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type (class Sub) where initialization checking started. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region.
+  |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type (class Sub) where initialization checking started. Only transitively initialized arguments may be passed to methods (except constructors).
   |Non initialized field(s): value b. Calling trace:
   |-> class Sub extends Sup:	[ i15459.scala:5 ]
   |   ^
diff --git a/tests/init/neg/inlined-method.check b/tests/init/neg/inlined-method.check
index 9751ef09b0c1..f3061bcb63ed 100644
--- a/tests/init/neg/inlined-method.check
+++ b/tests/init/neg/inlined-method.check
@@ -1,7 +1,7 @@
 -- Error: tests/init/neg/inlined-method.scala:8:45 ---------------------------------------------------------------------
 8 |    scala.runtime.Scala3RunTime.assertFailed(message) // error
   |                                             ^^^^^^^
-  |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type (class InlineError) where initialization checking started. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region.
+  |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type (class InlineError) where initialization checking started. Only transitively initialized arguments may be passed to methods (except constructors).
   |Non initialized field(s): value v. Calling trace:
   |-> class InlineError {	[ inlined-method.scala:1 ]
   |   ^
diff --git a/tests/init/neg/inner-first.check b/tests/init/neg/inner-first.check
index 9340479f79a9..fe90423c828f 100644
--- a/tests/init/neg/inner-first.check
+++ b/tests/init/neg/inner-first.check
@@ -1,7 +1,7 @@
 -- Error: tests/init/neg/inner-first.scala:3:12 ------------------------------------------------------------------------
 3 |    println(this)           // error
   |            ^^^^
-  |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type (class B) where initialization checking started. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region.
+  |Could not verify that the method argument is transitively initialized (Hot). It was found to be the original object of type (class B) where initialization checking started. Only transitively initialized arguments may be passed to methods (except constructors).
   |Non initialized field(s): value n. Calling trace:
   |-> class B:	[ inner-first.scala:2 ]
   |   ^
diff --git a/tests/init/neg/promotion-loop.check b/tests/init/neg/promotion-loop.check
index ec0a6854bbac..bc05640d10d2 100644
--- a/tests/init/neg/promotion-loop.check
+++ b/tests/init/neg/promotion-loop.check
@@ -1,7 +1,7 @@
 -- Error: tests/init/neg/promotion-loop.scala:16:10 --------------------------------------------------------------------
 16 |  println(b)      // error
    |          ^
-   |Could not verify that the method argument is transitively initialized (Hot). It was found to be a non-transitively initialized (Warm) object of type (class B) { outer = the original object of type (class Test) where initialization checking started }. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region. Calling trace:
+   |Could not verify that the method argument is transitively initialized (Hot). It was found to be a non-transitively initialized (Warm) object of type (class B) { outer = the original object of type (class Test) where initialization checking started }. Only transitively initialized arguments may be passed to methods (except constructors). Calling trace:
    |-> class Test { test =>	[ promotion-loop.scala:1 ]
    |   ^
    |-> println(b)      // error	[ promotion-loop.scala:16 ]
diff --git a/tests/init/neg/promotion-segment3.check b/tests/init/neg/promotion-segment3.check
index bc7a076d7d72..a7320b5c3ed3 100644
--- a/tests/init/neg/promotion-segment3.check
+++ b/tests/init/neg/promotion-segment3.check
@@ -1,7 +1,7 @@
 -- Error: tests/init/neg/promotion-segment3.scala:9:6 ------------------------------------------------------------------
 9 |  bar(new B)  // error
   |      ^^^^^
-  |Could not verify that the method argument is transitively initialized (Hot). It was found to be a non-transitively initialized (Warm) object of type (class B) { outer = the original object of type (class A) where initialization checking started }. Only transitively initialized arguments may be passed to methods outside the analyzed initialization region. Calling trace:
+  |Could not verify that the method argument is transitively initialized (Hot). It was found to be a non-transitively initialized (Warm) object of type (class B) { outer = the original object of type (class A) where initialization checking started }. Only transitively initialized arguments may be passed to methods (except constructors). Calling trace:
   |-> class A:	[ promotion-segment3.scala:2 ]
   |   ^
   |-> bar(new B)  // error	[ promotion-segment3.scala:9 ]
diff --git a/tests/init/neg/t3273.check b/tests/init/neg/t3273.check
index a63f7bc7a5ea..2e4d8db50ebb 100644
--- a/tests/init/neg/t3273.check
+++ b/tests/init/neg/t3273.check
@@ -1,7 +1,7 @@
 -- Error: tests/init/neg/t3273.scala:4:42 ------------------------------------------------------------------------------
 4 |  val num1: LazyList[Int] = 1 #:: num1.map(_ + 1)                        // error
   |                                  ^^^^^^^^^^^^^^^
-  |Could not verify that the method argument is transitively initialized (Hot). It was found to be a function where "this" is (the original object of type (object Test) where initialization checking started) and the function owner is an object of type (object Test). Only transitively initialized arguments may be passed to methods outside the analyzed initialization region. Calling trace:
+  |Could not verify that the method argument is transitively initialized (Hot). It was found to be a function where "this" is (the original object of type (object Test) where initialization checking started) and the function owner is an object of type (object Test). Only transitively initialized arguments may be passed to methods (except constructors). Calling trace:
   |-> object Test {	[ t3273.scala:3 ]
   |   ^
   |-> val num1: LazyList[Int] = 1 #:: num1.map(_ + 1)                        // error	[ t3273.scala:4 ]
@@ -14,7 +14,7 @@
 -- Error: tests/init/neg/t3273.scala:5:61 ------------------------------------------------------------------------------
 5 |  val num2: LazyList[Int] = 1 #:: num2.iterator.map(_ + 1).to(LazyList)  // error
   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  |Could not verify that the method argument is transitively initialized (Hot). It was found to be a function where "this" is (the original object of type (object Test) where initialization checking started) and the function owner is an object of type (object Test). Only transitively initialized arguments may be passed to methods outside the analyzed initialization region. Calling trace:
+  |Could not verify that the method argument is transitively initialized (Hot). It was found to be a function where "this" is (the original object of type (object Test) where initialization checking started) and the function owner is an object of type (object Test). Only transitively initialized arguments may be passed to methods (except constructors). Calling trace:
   |-> object Test {	[ t3273.scala:3 ]
   |   ^
   |-> val num2: LazyList[Int] = 1 #:: num2.iterator.map(_ + 1).to(LazyList)  // error	[ t3273.scala:5 ]

From ddafb7819c0f36b8583224174bf6de87a1a90c0c Mon Sep 17 00:00:00 2001
From: David Hua <d5hua@uwaterloo.ca>
Date: Mon, 13 Mar 2023 03:01:21 -0400
Subject: [PATCH 250/657] Implement suggested change.

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

diff --git a/compiler/src/dotty/tools/dotc/transform/init/Cache.scala b/compiler/src/dotty/tools/dotc/transform/init/Cache.scala
index 2dcd6360554a..4d091d88eefd 100644
--- a/compiler/src/dotty/tools/dotc/transform/init/Cache.scala
+++ b/compiler/src/dotty/tools/dotc/transform/init/Cache.scala
@@ -85,7 +85,9 @@ class Cache[Config, Res]:
   protected given MutableTreeWrapper = new MutableTreeWrapper
 
   def get(config: Config, expr: Tree): Option[Res] =
-    current.get(config, expr)
+    val res = current.get(config, expr)
+    cacheUsed = cacheUsed || res.nonEmpty
+    res
 
   /** Evaluate an expression with cache
    *
@@ -105,9 +107,7 @@ class Cache[Config, Res]:
    */
   def cachedEval(config: Config, expr: Tree, cacheResult: Boolean, default: Res)(eval: Tree => Res): Res =
     this.get(config, expr) match
-    case Some(value) =>
-      cacheUsed = true
-      value
+    case Some(value) => value
     case None =>
       val assumeValue: Res =
         this.last.get(config, expr) match

From 7a7f144afba36015d345342241cc38f8804e6df7 Mon Sep 17 00:00:00 2001
From: David Hua <d5hua@uwaterloo.ca>
Date: Mon, 13 Mar 2023 03:23:29 -0400
Subject: [PATCH 251/657] Fix test case to error when missing cacheResult flag

---
 .../src/dotty/tools/dotc/transform/init/Semantic.scala   | 2 +-
 tests/init/pos/recursion.scala                           | 9 ---------
 tests/init/pos/self-ref.scala                            | 9 +++++++++
 3 files changed, 10 insertions(+), 10 deletions(-)
 delete mode 100644 tests/init/pos/recursion.scala
 create mode 100644 tests/init/pos/self-ref.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
index 74e14691a45e..82bb45851f72 100644
--- a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
+++ b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
@@ -893,7 +893,7 @@ object Semantic:
 
               case Cold => Cold
 
-              case ref: Ref => eval(vdef.rhs, ref, enclosingClass)
+              case ref: Ref => eval(vdef.rhs, ref, enclosingClass, cacheResult = sym.is(Flags.Lazy))
 
               case _ =>
                  report.error("[Internal error] unexpected this value when accessing local variable, sym = " + sym.show + ", thisValue = " + thisValue2.show + Trace.show, Trace.position)
diff --git a/tests/init/pos/recursion.scala b/tests/init/pos/recursion.scala
deleted file mode 100644
index 394092945cb3..000000000000
--- a/tests/init/pos/recursion.scala
+++ /dev/null
@@ -1,9 +0,0 @@
-class A {
-
-  val f: Int => Int = {
-    x => f(x)
-  }
-
-  f(5)
-
-}
diff --git a/tests/init/pos/self-ref.scala b/tests/init/pos/self-ref.scala
new file mode 100644
index 000000000000..1a9f199b9f7a
--- /dev/null
+++ b/tests/init/pos/self-ref.scala
@@ -0,0 +1,9 @@
+class A {
+  def foo(a: Int) = {
+    lazy val x: Int = if (a == 0) x else 0
+    println(x)
+  }
+  foo(0)
+
+  val y = 5
+}

From 4172269bf12e22b314cdabe8825d2d31f195c981 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 13 Mar 2023 09:17:17 +0100
Subject: [PATCH 252/657] Strip annotations from the type of a quoted
 expression

These annotations may contain spliced expression that would leak out of
the quote if not stripped. See `tests/pos-macros/i7519b.scala`.
---
 .../src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala     | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala b/compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala
index 6d3b62357d7f..df9e780cd388 100644
--- a/compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala
@@ -103,6 +103,9 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
     if (ctx.property(InAnnotation).isDefined)
       report.error("Cannot have a quote in an annotation", quote.srcPos)
 
+    val stripAnnotsDeep: TypeMap = new TypeMap:
+      def apply(tp: Type): Type = mapOver(tp.stripAnnots)
+
     val contextWithQuote =
       if level == 0 then contextWithQuoteTypeTags(taggedTypes)(using quoteContext)
       else quoteContext
@@ -115,7 +118,7 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
     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)))
+      val targs2 = targs.map(targ => TypeTree(healTypeOfTerm(quote.fun.srcPos)(stripAnnotsDeep(targ.tpe))))
       cpy.Apply(quote)(cpy.TypeApply(quote.fun)(fun, targs2), body2 :: Nil)
     else
       val quotes = quote.args.mapConserve(transform)

From 7347e03680f7d436f3c4817101e89f2e37da467c Mon Sep 17 00:00:00 2001
From: David Hua <d5hua@uwaterloo.ca>
Date: Mon, 13 Mar 2023 04:31:39 -0400
Subject: [PATCH 253/657] Fix * alignment in comment.

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

diff --git a/compiler/src/dotty/tools/dotc/transform/init/Cache.scala b/compiler/src/dotty/tools/dotc/transform/init/Cache.scala
index 4d091d88eefd..36c0d8c175f8 100644
--- a/compiler/src/dotty/tools/dotc/transform/init/Cache.scala
+++ b/compiler/src/dotty/tools/dotc/transform/init/Cache.scala
@@ -75,10 +75,10 @@ class Cache[Config, Res]:
    */
   protected var changed: Boolean = false
 
-  /** Whether any value in the cache was accessed after being added.
-  *   If no cached values are used after they are added for the first time
-  *   then another iteration of analysis is not needed.
-  */
+  /** Whether any value in the output cache (this.current) was accessed
+   *  after being added. If no cached values are used after they are added
+   *  for the first time then another iteration of analysis is not needed.
+   */
   protected var cacheUsed: Boolean = false
 
   /** Used to avoid allocation, its state does not matter */

From 391730ae4df3c1a046b57734cb19b19fdbb5f4c8 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Mon, 13 Mar 2023 10:34:50 +0100
Subject: [PATCH 254/657] Don't check parents of refinement classes for
 accessibility

Only check trait constructor accessibility if the trait is a parent of some
other class or trait. Refinements don't fall into this category.
---
 compiler/src/dotty/tools/dotc/typer/Typer.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index f6048f6fb156..d45e24bf30e5 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -2512,7 +2512,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
             // allow missing type parameters if there are implicit arguments to pass
             // since we can infer type arguments from them
         val constr = psym.primaryConstructor
-        if constr.exists then
+        if psym.is(Trait) && constr.exists && !cls.isRefinementClass then
           ensureAccessible(constr.termRef, superAccess = true, tree.srcPos)
       else
         checkParentCall(result, cls)

From 121af881cf3f66d291cb4343330c905781c91dd9 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Mon, 13 Mar 2023 11:22:31 +0000
Subject: [PATCH 255/657] Add a Java protected member case, which can only call
 super

---
 .../tools/dotc/transform/ProtectedAccessors.scala  |  2 +-
 tests/run/i17021.ext-java/A.java                   |  6 ++++++
 tests/run/i17021.ext-java/Test.scala               | 14 ++++++++++++++
 3 files changed, 21 insertions(+), 1 deletion(-)
 create mode 100644 tests/run/i17021.ext-java/A.java
 create mode 100644 tests/run/i17021.ext-java/Test.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/ProtectedAccessors.scala b/compiler/src/dotty/tools/dotc/transform/ProtectedAccessors.scala
index c675938b86f7..2b150d321812 100644
--- a/compiler/src/dotty/tools/dotc/transform/ProtectedAccessors.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ProtectedAccessors.scala
@@ -38,7 +38,7 @@ object ProtectedAccessors {
     sym.isTerm && sym.is(Protected) &&
     !sym.owner.is(Trait) && // trait methods need to be handled specially, are currently always public
     !insideBoundaryOf(sym) &&
-    !ctx.owner.enclosingClass.derivesFrom(sym.owner)
+    (sym.is(JavaDefined) || !ctx.owner.enclosingClass.derivesFrom(sym.owner))
 }
 
 class ProtectedAccessors extends MiniPhase {
diff --git a/tests/run/i17021.ext-java/A.java b/tests/run/i17021.ext-java/A.java
new file mode 100644
index 000000000000..536e9caa4a38
--- /dev/null
+++ b/tests/run/i17021.ext-java/A.java
@@ -0,0 +1,6 @@
+// Derives from run/i17021.defs, but with a Java protected member
+package p1;
+
+public class A {
+  protected int foo() { return 1; }
+}
diff --git a/tests/run/i17021.ext-java/Test.scala b/tests/run/i17021.ext-java/Test.scala
new file mode 100644
index 000000000000..80dbca9fdd5d
--- /dev/null
+++ b/tests/run/i17021.ext-java/Test.scala
@@ -0,0 +1,14 @@
+// Derives from run/i17021.defs
+// but with a Java protected member
+// which changes the behaviour
+package p2:
+  trait B extends p1.A:
+    def bar: Int = foo
+
+  class C extends B:
+    override def foo: Int = 2
+
+object Test:
+  def main(args: Array[String]): Unit =
+    val n = new p2.C().bar
+    assert(n == 1, n) // B can only call super.foo

From 8362d14c77d33fa597d94d6d46b18d9c6b3f3cb9 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Fri, 10 Mar 2023 17:32:33 +0100
Subject: [PATCH 256/657] Refactor level checking / type healing logic

Disentangle level checking from type healing.
---
 .../dotc/transform/PCPCheckAndHeal.scala      | 98 +++++++++----------
 .../tools/dotc/transform/TreeChecker.scala    |  2 +-
 2 files changed, 49 insertions(+), 51 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala b/compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala
index df9e780cd388..23ad3cadf1a4 100644
--- a/compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala
@@ -61,24 +61,26 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
       super.transform(tree)
     else tree match {
 
-      case _: TypeTree | _: RefTree if tree.isType  =>
+      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 tree: Ident if isWildcardArg(tree) =>
+        tree.withType(healType(tree.srcPos)(tree.tpe))
+      case tree: Ident => // this is a term Ident
+        checkLevelConsistency(tree)
+        tree
+      case tree: This =>
+        checkLevelConsistency(tree)
+        tree
       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
-
+        EmptyTree // Remove inline defs in quoted code. Already fully inlined.
       case tree: ValOrDefDef =>
         checkAnnotations(tree)
         healInfo(tree, tree.tpt.srcPos)
@@ -88,7 +90,7 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
         healInfo(tree, tree.srcPos)
         super.transform(tree)
       case tree: UnApply =>
-        super.transform(tree).withType(healTypeOfTerm(tree.srcPos)(tree.tpe))
+        super.transform(tree).withType(healType(tree.srcPos)(tree.tpe))
       case tree: TypeDef if tree.symbol.is(Case) && level > 0 =>
         report.error(reporting.CaseClassInInlinedCode(tree), tree)
         super.transform(tree)
@@ -118,7 +120,7 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
     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)(stripAnnotsDeep(targ.tpe))))
+      val targs2 = targs.map(targ => TypeTree(healType(quote.fun.srcPos)(stripAnnotsDeep(targ.tpe))))
       cpy.Apply(quote)(cpy.TypeApply(quote.fun)(fun, targs2), body2 :: Nil)
     else
       val quotes = quote.args.mapConserve(transform)
@@ -193,61 +195,57 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
     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) =>
-              tryHealTypeOfType(tp.symbol, tp, pos)
-            case prefix: ThisType if !tp.symbol.isStatic && level > levelOf(prefix.cls) =>
-              tryHealTypeOfType(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) =>
-              tryHealTypeOfType(prefix.symbol, tp, pos)
-            case _ =>
-              mapOver(tp)
+          healTypeRef(tp)
         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 =>
           val newAnnotTree = transform(tp.annot.tree)
           derivedAnnotatedType(tp, apply(tp.parent), tp.annot.derivedAnnotation(newAnnotTree))
         case _ =>
           mapOver(tp)
 
-    /** Try to dealias or 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`.
-     */
-    private def tryHealTypeOfType(sym: Symbol, tp: TypeRef, pos: SrcPos)(using Context): Type = {
+    private def healTypeRef(tp: TypeRef): Type =
+      tp.prefix match
+        case prefix: TermRef if tp.symbol.isTypeSplice =>
+          checkNotWildcardSplice(tp)
+          if level == 0 then tp else getQuoteTypeTags.getTagRef(prefix)
+        case prefix: TermRef if !prefix.symbol.isStatic && level > levelOf(prefix.symbol) =>
+          dealiasAndTryHeal(prefix.symbol, tp, pos)
+        case NoPrefix if level > levelOf(tp.symbol) && !tp.typeSymbol.hasAnnotation(defn.QuotedRuntime_SplicedTypeAnnot) =>
+          dealiasAndTryHeal(tp.symbol, tp, pos)
+        case prefix: ThisType if level > levelOf(prefix.cls) && !tp.symbol.isStatic =>
+          dealiasAndTryHeal(tp.symbol, tp, pos)
+        case _ =>
+          mapOver(tp)
+
+    private def dealiasAndTryHeal(sym: Symbol, tp: TypeRef, pos: SrcPos)(using Context): Type =
       val tp1 = tp.dealias
       if tp1 != tp then apply(tp1)
       else tryHeal(tp.symbol, tp, pos)
-    }
-  }
 
-  /** Check phase consistency of terms and heal inconsistent type references. */
-  private def healTypeOfTerm(pos: SrcPos)(using Context) = new TypeMap {
-    def apply(tp: Type): Type =
-      tp match
-        case tp @ TypeRef(NoPrefix, _) if level > levelOf(tp.symbol) =>
-          tryHeal(tp.symbol, tp, pos)
-        case tp @ TermRef(NoPrefix, _) if !tp.symbol.isStatic && level != levelOf(tp.symbol) =>
-          levelError(tp.symbol, tp, pos)
-        case tp: ThisType if level != -1 && level != levelOf(tp.cls) =>
-          levelError(tp.cls, tp, pos)
-        case tp: AnnotatedType =>
-          derivedAnnotatedType(tp, apply(tp.parent), tp.annot)
+    private def checkNotWildcardSplice(splice: TypeRef)(using Context): Unit =
+      splice.prefix.termSymbol.info.argInfos match
+        case (tb: TypeBounds) :: _ => report.error(em"Cannot splice $splice because it is a wildcard type", pos)
         case _ =>
-          if tp.typeSymbol.is(Package) then tp
-          else mapOver(tp)
   }
 
+  /** Check level consistency of terms references */
+  private def checkLevelConsistency(tree: Ident | This)(using Context): Unit =
+    new TypeTraverser {
+      def traverse(tp: Type): Unit =
+        tp match
+          case tp @ TermRef(NoPrefix, _) if !tp.symbol.isStatic && level != levelOf(tp.symbol) =>
+            levelError(tp.symbol, tp, tree.srcPos)
+          case tp: ThisType if level != -1 && level != levelOf(tp.cls) =>
+            levelError(tp.cls, tp, tree.srcPos)
+          case tp: AnnotatedType =>
+            traverse(tp.parent)
+          case _ if tp.typeSymbol.is(Package) =>
+            // OK
+          case _ =>
+             traverseChildren(tp)
+    }.traverse(tree.tpe)
+
   /** 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]]}`.
diff --git a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
index 52942ea719f9..309c61f5c7d6 100644
--- a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
@@ -678,7 +678,7 @@ object TreeChecker {
         defn.FunctionOf(List(defn.QuotesClass.typeRef), expectedResultType, isContextual = true)
       val expectedContentType =
         defn.FunctionOf(argQuotedTypes, contextualResult)
-      assert(content.typeOpt =:= expectedContentType)
+      assert(content.typeOpt =:= expectedContentType, i"expected content of the hole to be ${expectedContentType} but got ${content.typeOpt}")
 
       tree1
     }

From 67a647543d91ea60fb67fa4fbba6de24f4d3c8bc Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 13 Mar 2023 10:10:51 +0100
Subject: [PATCH 257/657] Extract StagingLevel from TreeMapWithStages

---
 .../dotc/inlines/PrepareInlineable.scala      |  4 +-
 .../dotty/tools/dotc/quoted/Interpreter.scala |  1 -
 .../tools/dotc/staging/StagingLevel.scala     | 38 +++++++++++++++++++
 .../dotc/transform/PCPCheckAndHeal.scala      |  5 +--
 .../tools/dotc/transform/PickleQuotes.scala   |  4 +-
 .../tools/dotc/transform/ReifiedReflect.scala |  1 -
 .../dotty/tools/dotc/transform/Splicing.scala | 10 ++---
 .../dotty/tools/dotc/transform/Staging.scala  | 10 ++---
 .../dotc/transform/TreeMapWithStages.scala    | 29 ++------------
 9 files changed, 58 insertions(+), 44 deletions(-)
 create mode 100644 compiler/src/dotty/tools/dotc/staging/StagingLevel.scala

diff --git a/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala b/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
index 85293d4a82d7..f1bef77f684b 100644
--- a/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
@@ -21,7 +21,7 @@ import transform.{AccessProxies, PCPCheckAndHeal, Splicer}
 import transform.SymUtils.*
 import config.Printers.inlining
 import util.Property
-import dotty.tools.dotc.transform.TreeMapWithStages._
+import dotty.tools.dotc.staging.StagingLevel.freshStagingLevelContext
 
 object PrepareInlineable {
   import tpd._
@@ -293,7 +293,7 @@ object PrepareInlineable {
           if (code.symbol.flags.is(Inline))
             report.error("Macro cannot be implemented with an `inline` method", code.srcPos)
           Splicer.checkValidMacroBody(code)
-          new PCPCheckAndHeal(freshStagingContext).transform(body) // Ignore output, only check PCP
+          (new PCPCheckAndHeal).transform(body)(using freshStagingLevelContext) // Ignore output, only check PCP
         case Block(List(stat), Literal(Constants.Constant(()))) => checkMacro(stat)
         case Block(Nil, expr) => checkMacro(expr)
         case Typed(expr, _) => checkMacro(expr)
diff --git a/compiler/src/dotty/tools/dotc/quoted/Interpreter.scala b/compiler/src/dotty/tools/dotc/quoted/Interpreter.scala
index aadfedd2417c..7153c17e30ed 100644
--- a/compiler/src/dotty/tools/dotc/quoted/Interpreter.scala
+++ b/compiler/src/dotty/tools/dotc/quoted/Interpreter.scala
@@ -25,7 +25,6 @@ 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
diff --git a/compiler/src/dotty/tools/dotc/staging/StagingLevel.scala b/compiler/src/dotty/tools/dotc/staging/StagingLevel.scala
new file mode 100644
index 000000000000..356c157f7f57
--- /dev/null
+++ b/compiler/src/dotty/tools/dotc/staging/StagingLevel.scala
@@ -0,0 +1,38 @@
+package dotty.tools.dotc.staging
+
+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
+
+object StagingLevel {
+
+  /** 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 freshStagingLevelContext(using Context): Context =
+    ctx.fresh.setProperty(LevelOfKey, new mutable.HashMap[Symbol, Int])
+
+  /** The quotation level of the definition of the locally defined symbol */
+  def levelOf(sym: Symbol)(using Context): Int =
+    ctx.property(LevelOfKey).get.getOrElse(sym, 0)
+
+  def removeLevelOf(sym: Symbol)(using Context): Unit =
+    val levelOfMap = ctx.property(LevelOfKey).get
+    levelOfMap -= sym
+
+  /** Enter staging level of symbol defined by `tree` */
+  def markSymbol(sym: Symbol)(using Context): Boolean =
+    val levelOfMap = ctx.property(LevelOfKey).get
+    if level != 0 && !levelOfMap.contains(sym) then
+      levelOfMap(sym) = level
+      true
+    else
+      false
+}
\ No newline at end of file
diff --git a/compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala b/compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala
index 23ad3cadf1a4..1f6621558a45 100644
--- a/compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala
@@ -17,11 +17,10 @@ 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.staging.StagingLevel.*
 
 import dotty.tools.dotc.util.Property
 
-import scala.annotation.constructorOnly
-
 /** Checks that the Phase Consistency Principle (PCP) holds and heals types.
  *
  *  Local term references are phase consistent if and only if they are used at the same level as their definition.
@@ -48,7 +47,7 @@ import scala.annotation.constructorOnly
  *     }
  *
  */
-class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(ictx) with Checking {
+class PCPCheckAndHeal extends TreeMapWithStages with Checking {
   import tpd._
 
   private val InAnnotation = Property.Key[Unit]()
diff --git a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
index 87c6e294c104..9a381eaafa66 100644
--- a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
@@ -19,7 +19,7 @@ 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.staging.StagingLevel.freshStagingLevelContext
 import dotty.tools.dotc.inlines.Inlines
 
 import scala.annotation.constructorOnly
@@ -93,7 +93,7 @@ class PickleQuotes extends MacroTransform {
       case _ =>
 
   override def run(using Context): Unit =
-    if (ctx.compilationUnit.needsStaging) super.run(using freshStagingContext)
+    if (ctx.compilationUnit.needsStaging) super.run(using freshStagingLevelContext)
 
   protected def newTransformer(using Context): Transformer = new Transformer {
     override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
diff --git a/compiler/src/dotty/tools/dotc/transform/ReifiedReflect.scala b/compiler/src/dotty/tools/dotc/transform/ReifiedReflect.scala
index e462f82b1dad..b2059195b8e4 100644
--- a/compiler/src/dotty/tools/dotc/transform/ReifiedReflect.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ReifiedReflect.scala
@@ -17,7 +17,6 @@ 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
 
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicing.scala b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
index 393fe46b8438..8e0535e3af50 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicing.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
@@ -21,7 +21,7 @@ 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.staging.StagingLevel.freshStagingLevelContext
 import dotty.tools.dotc.config.ScalaRelease.*
 
 import scala.annotation.constructorOnly
@@ -77,7 +77,7 @@ class Splicing extends MacroTransform:
 
   override def run(using Context): Unit =
     if ctx.compilationUnit.needsStaging then
-      super.run(using freshStagingContext)
+      super.run(using freshStagingLevelContext)
 
   protected def newTransformer(using Context): Transformer = Level0QuoteTransformer
 
@@ -246,7 +246,7 @@ class Splicing extends MacroTransform:
         if tree.symbol == defn.QuotedTypeModule_of && containsCapturedType(tpt.tpe) =>
           val newContent = capturedPartTypes(tpt)
           newContent match
-            case block: Block => 
+            case block: Block =>
               inContext(ctx.withSource(tree.source)) {
                 Apply(TypeApply(typeof, List(newContent)), List(quotes)).withSpan(tree.span)
               }
@@ -342,7 +342,7 @@ class Splicing extends MacroTransform:
       val bindingSym = refBindingMap.getOrElseUpdate(tree.symbol, (tree, newBinding))._2
       ref(bindingSym)
 
-    private def newQuotedTypeClassBinding(tpe: Type)(using Context) = 
+    private def newQuotedTypeClassBinding(tpe: Type)(using Context) =
       newSymbol(
         spliceOwner,
         UniqueName.fresh(nme.Type).toTermName,
@@ -376,7 +376,7 @@ class Splicing extends MacroTransform:
       tpt match
         case block: Block =>
           cpy.Block(block)(newHealedTypes ::: block.stats, TypeTree(captured))
-        case _ => 
+        case _ =>
           if newHealedTypes.nonEmpty then
             cpy.Block(tpt)(newHealedTypes, TypeTree(captured))
           else
diff --git a/compiler/src/dotty/tools/dotc/transform/Staging.scala b/compiler/src/dotty/tools/dotc/transform/Staging.scala
index 1de050a9a6c1..ea7c8d1b39b7 100644
--- a/compiler/src/dotty/tools/dotc/transform/Staging.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Staging.scala
@@ -11,7 +11,7 @@ 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._
+import dotty.tools.dotc.staging.StagingLevel.*
 
 
 
@@ -35,7 +35,7 @@ class Staging extends MacroTransform {
       // Recheck that PCP holds but do not heal any inconsistent types as they should already have been heald
       tree match {
         case PackageDef(pid, _) if tree.symbol.owner == defn.RootClass =>
-          val checker = new PCPCheckAndHeal(freshStagingContext) {
+          val checker = new PCPCheckAndHeal {
             override protected def tryHeal(sym: Symbol, tp: TypeRef, pos: SrcPos)(using Context): TypeRef = {
               def symStr =
                 if (sym.is(ModuleClass)) sym.sourceModule.show
@@ -51,7 +51,7 @@ class Staging extends MacroTransform {
               tp
             }
           }
-          checker.transform(tree)
+          checker.transform(tree)(using freshStagingLevelContext)
         case _ =>
       }
 
@@ -66,11 +66,11 @@ class Staging extends MacroTransform {
     }
 
   override def run(using Context): Unit =
-    if (ctx.compilationUnit.needsStaging) super.run(using freshStagingContext)
+    if (ctx.compilationUnit.needsStaging) super.run(using freshStagingLevelContext)
 
   protected def newTransformer(using Context): Transformer = new Transformer {
     override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
-      new PCPCheckAndHeal(ctx).transform(tree)
+      (new PCPCheckAndHeal).transform(tree)
   }
 }
 
diff --git a/compiler/src/dotty/tools/dotc/transform/TreeMapWithStages.scala b/compiler/src/dotty/tools/dotc/transform/TreeMapWithStages.scala
index b514b8a7bf11..1046194a04e4 100644
--- a/compiler/src/dotty/tools/dotc/transform/TreeMapWithStages.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TreeMapWithStages.scala
@@ -8,9 +8,9 @@ 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 dotty.tools.dotc.staging.StagingLevel
 
 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.
@@ -18,13 +18,8 @@ import scala.annotation.constructorOnly
  *                     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 {
-
+abstract class TreeMapWithStages extends TreeMapWithImplicits {
   import tpd._
-  import TreeMapWithStages._
-
-  /** A map from locally defined symbols to their definition quotation level */
-  private[this] val levelOfMap: mutable.HashMap[Symbol, Int] = ictx.property(LevelOfKey).get
 
   /** A stack of entered symbols, to be unwound after scope exit */
   private[this] var enteredSyms: List[Symbol] = Nil
@@ -32,9 +27,6 @@ abstract class TreeMapWithStages(@constructorOnly ictx: Context) extends TreeMap
   /** 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
 
@@ -43,8 +35,7 @@ abstract class TreeMapWithStages(@constructorOnly ictx: Context) extends TreeMap
 
   /** 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
+    if StagingLevel.markSymbol(sym) then
       enteredSyms = sym :: enteredSyms
 
   /** Enter staging level of symbol defined by `tree`, if applicable. */
@@ -79,7 +70,7 @@ abstract class TreeMapWithStages(@constructorOnly ictx: Context) extends TreeMap
         try super.transform(tree)
         finally
           while (enteredSyms ne lastEntered) {
-            levelOfMap -= enteredSyms.head
+            StagingLevel.removeLevelOf(enteredSyms.head)
             enteredSyms = enteredSyms.tail
           }
 
@@ -150,15 +141,3 @@ abstract class TreeMapWithStages(@constructorOnly ictx: Context) extends TreeMap
       }
     }
 }
-
-
-object TreeMapWithStages {
-
-  /** A key to be used in a context property that caches the `levelOf` mapping */
-  private val LevelOfKey = new Property.Key[mutable.HashMap[Symbol, Int]]
-
-  /** Initial context for a StagingTransformer transformation. */
-  def freshStagingContext(using Context): Context =
-    ctx.fresh.setProperty(LevelOfKey, new mutable.HashMap[Symbol, Int])
-
-}

From 527a9ec83642aef046a72eba91c49134755e3e89 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 13 Mar 2023 11:34:24 +0100
Subject: [PATCH 258/657] Remove mutable state from StagingLevel

---
 .../dotc/inlines/PrepareInlineable.scala      |  3 +-
 .../tools/dotc/staging/StagingLevel.scala     | 28 ++++-----
 .../tools/dotc/transform/PickleQuotes.scala   |  3 +-
 .../dotty/tools/dotc/transform/Splicing.scala |  3 +-
 .../dotty/tools/dotc/transform/Staging.scala  |  4 +-
 .../dotc/transform/TreeMapWithStages.scala    | 60 ++++++-------------
 6 files changed, 33 insertions(+), 68 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala b/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
index f1bef77f684b..837f9a60d6ea 100644
--- a/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
@@ -21,7 +21,6 @@ import transform.{AccessProxies, PCPCheckAndHeal, Splicer}
 import transform.SymUtils.*
 import config.Printers.inlining
 import util.Property
-import dotty.tools.dotc.staging.StagingLevel.freshStagingLevelContext
 
 object PrepareInlineable {
   import tpd._
@@ -293,7 +292,7 @@ object PrepareInlineable {
           if (code.symbol.flags.is(Inline))
             report.error("Macro cannot be implemented with an `inline` method", code.srcPos)
           Splicer.checkValidMacroBody(code)
-          (new PCPCheckAndHeal).transform(body)(using freshStagingLevelContext) // Ignore output, only check PCP
+          (new PCPCheckAndHeal).transform(body) // Ignore output, only check PCP
         case Block(List(stat), Literal(Constants.Constant(()))) => checkMacro(stat)
         case Block(Nil, expr) => checkMacro(expr)
         case Typed(expr, _) => checkMacro(expr)
diff --git a/compiler/src/dotty/tools/dotc/staging/StagingLevel.scala b/compiler/src/dotty/tools/dotc/staging/StagingLevel.scala
index 356c157f7f57..4cf57d28ed8c 100644
--- a/compiler/src/dotty/tools/dotc/staging/StagingLevel.scala
+++ b/compiler/src/dotty/tools/dotc/staging/StagingLevel.scala
@@ -13,26 +13,20 @@ import scala.collection.mutable
 object StagingLevel {
 
   /** 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 freshStagingLevelContext(using Context): Context =
-    ctx.fresh.setProperty(LevelOfKey, new mutable.HashMap[Symbol, Int])
+  private val LevelOfKey = new Property.Key[Map[Symbol, Int]]
 
   /** The quotation level of the definition of the locally defined symbol */
   def levelOf(sym: Symbol)(using Context): Int =
-    ctx.property(LevelOfKey).get.getOrElse(sym, 0)
-
-  def removeLevelOf(sym: Symbol)(using Context): Unit =
-    val levelOfMap = ctx.property(LevelOfKey).get
-    levelOfMap -= sym
+    ctx.property(LevelOfKey) match
+      case Some(map) => map.getOrElse(sym, 0)
+      case None => 0
 
-  /** Enter staging level of symbol defined by `tree` */
-  def markSymbol(sym: Symbol)(using Context): Boolean =
-    val levelOfMap = ctx.property(LevelOfKey).get
-    if level != 0 && !levelOfMap.contains(sym) then
-      levelOfMap(sym) = level
-      true
+  /** Context with the current staging level set for the symbols */
+  def symbolsInCurrentLevel(syms: List[Symbol])(using Context): Context =
+    if level == 0 then ctx
     else
-      false
+      val levelOfMap = ctx.property(LevelOfKey).getOrElse(Map.empty)
+      val syms1 = syms//.filter(sym => !levelOfMap.contains(sym))
+      val newMap = syms1.foldLeft(levelOfMap)((acc, sym) => acc.updated(sym, level))
+      ctx.fresh.setProperty(LevelOfKey, newMap)
 }
\ No newline at end of file
diff --git a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
index 9a381eaafa66..728ee9552c81 100644
--- a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
@@ -19,7 +19,6 @@ 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.staging.StagingLevel.freshStagingLevelContext
 import dotty.tools.dotc.inlines.Inlines
 
 import scala.annotation.constructorOnly
@@ -93,7 +92,7 @@ class PickleQuotes extends MacroTransform {
       case _ =>
 
   override def run(using Context): Unit =
-    if (ctx.compilationUnit.needsStaging) super.run(using freshStagingLevelContext)
+    if (ctx.compilationUnit.needsStaging) super.run
 
   protected def newTransformer(using Context): Transformer = new Transformer {
     override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicing.scala b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
index 8e0535e3af50..d31b92fc17db 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicing.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
@@ -21,7 +21,6 @@ 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.staging.StagingLevel.freshStagingLevelContext
 import dotty.tools.dotc.config.ScalaRelease.*
 
 import scala.annotation.constructorOnly
@@ -77,7 +76,7 @@ class Splicing extends MacroTransform:
 
   override def run(using Context): Unit =
     if ctx.compilationUnit.needsStaging then
-      super.run(using freshStagingLevelContext)
+      super.run
 
   protected def newTransformer(using Context): Transformer = Level0QuoteTransformer
 
diff --git a/compiler/src/dotty/tools/dotc/transform/Staging.scala b/compiler/src/dotty/tools/dotc/transform/Staging.scala
index ea7c8d1b39b7..2e8964c8b1b4 100644
--- a/compiler/src/dotty/tools/dotc/transform/Staging.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Staging.scala
@@ -51,7 +51,7 @@ class Staging extends MacroTransform {
               tp
             }
           }
-          checker.transform(tree)(using freshStagingLevelContext)
+          checker.transform(tree)
         case _ =>
       }
 
@@ -66,7 +66,7 @@ class Staging extends MacroTransform {
     }
 
   override def run(using Context): Unit =
-    if (ctx.compilationUnit.needsStaging) super.run(using freshStagingLevelContext)
+    if (ctx.compilationUnit.needsStaging) super.run
 
   protected def newTransformer(using Context): Transformer = new Transformer {
     override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
diff --git a/compiler/src/dotty/tools/dotc/transform/TreeMapWithStages.scala b/compiler/src/dotty/tools/dotc/transform/TreeMapWithStages.scala
index 1046194a04e4..a4535a639c13 100644
--- a/compiler/src/dotty/tools/dotc/transform/TreeMapWithStages.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TreeMapWithStages.scala
@@ -8,42 +8,20 @@ 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 dotty.tools.dotc.staging.StagingLevel
+import dotty.tools.dotc.staging.StagingLevel.*
 
 import scala.collection.mutable
 
-/** 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
- */
+/** TreeMap that keeps track of staging levels using StagingLevel. */
 abstract class TreeMapWithStages extends TreeMapWithImplicits {
   import tpd._
 
-  /** 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
 
-  /** 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 StagingLevel.markSymbol(sym) then
-      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>)`
@@ -66,14 +44,6 @@ abstract class TreeMapWithStages extends TreeMapWithImplicits {
     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) {
-            StagingLevel.removeLevelOf(enteredSyms.head)
-            enteredSyms = enteredSyms.tail
-          }
-
       def dropEmptyBlocks(tree: Tree): Tree = tree match {
         case Block(Nil, expr) => dropEmptyBlocks(expr)
         case _ => tree
@@ -118,26 +88,30 @@ abstract class TreeMapWithStages extends TreeMapWithImplicits {
           finally inQuoteOrSplice = old
 
         case Block(stats, _) =>
-          val last = enteredSyms
-          stats.foreach(markDef)
-          mapOverTree(last)
+          val defSyms = stats.collect { case defTree: DefTree => defTree.symbol }
+          super.transform(tree)(using symbolsInCurrentLevel(defSyms))
 
         case CaseDef(pat, guard, body) =>
-          val last = enteredSyms
-          tpd.patVars(pat).foreach(markSymbol)
-          mapOverTree(last)
+          super.transform(tree)(using symbolsInCurrentLevel(tpd.patVars(pat)))
 
         case (_:Import | _:Export) =>
           tree
 
         case _: Template =>
-          val last = enteredSyms
-          tree.symbol.owner.info.decls.foreach(markSymbol)
-          mapOverTree(last)
+          val decls = tree.symbol.owner.info.decls.toList
+          super.transform(tree)(using symbolsInCurrentLevel(decls))
+
+        case LambdaTypeTree(tparams, body) =>
+          super.transform(tree)(using symbolsInCurrentLevel(tparams.map(_.symbol)))
+
+        case tree: DefTree =>
+          val paramSyms = tree match
+            case tree: DefDef => tree.paramss.flatten.map(_.symbol)
+            case _ => Nil
+          super.transform(tree)(using symbolsInCurrentLevel(tree.symbol :: paramSyms))
 
         case _ =>
-          markDef(tree)
-          mapOverTree(enteredSyms)
+          super.transform(tree)
       }
     }
 }

From 6d351f985f0a53e97779c06d62bf852bea9e930f Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 13 Mar 2023 11:43:25 +0100
Subject: [PATCH 259/657] Move PCPCheckAndHeal to dotty.tools.dotc.staging

---
 compiler/src/dotty/tools/dotc/core/StagingContext.scala        | 2 +-
 compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala  | 3 ++-
 .../tools/dotc/{transform => staging}/PCPCheckAndHeal.scala    | 3 ++-
 compiler/src/dotty/tools/dotc/transform/Splicing.scala         | 1 +
 compiler/src/dotty/tools/dotc/transform/Staging.scala          | 3 +--
 5 files changed, 7 insertions(+), 5 deletions(-)
 rename compiler/src/dotty/tools/dotc/{transform => staging}/PCPCheckAndHeal.scala (99%)

diff --git a/compiler/src/dotty/tools/dotc/core/StagingContext.scala b/compiler/src/dotty/tools/dotc/core/StagingContext.scala
index 41e77655d5d6..f6d81582dc97 100644
--- a/compiler/src/dotty/tools/dotc/core/StagingContext.scala
+++ b/compiler/src/dotty/tools/dotc/core/StagingContext.scala
@@ -4,7 +4,7 @@ import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.core.Contexts._
 import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.util.Property
-import dotty.tools.dotc.transform.PCPCheckAndHeal
+import dotty.tools.dotc.staging.PCPCheckAndHeal
 
 object StagingContext {
 
diff --git a/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala b/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
index 837f9a60d6ea..619e36d942b3 100644
--- a/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
@@ -17,7 +17,8 @@ import NameKinds.{InlineAccessorName, UniqueInlineName}
 import inlines.Inlines
 import NameOps._
 import Annotations._
-import transform.{AccessProxies, PCPCheckAndHeal, Splicer}
+import transform.{AccessProxies, Splicer}
+import staging.PCPCheckAndHeal
 import transform.SymUtils.*
 import config.Printers.inlining
 import util.Property
diff --git a/compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala b/compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala
similarity index 99%
rename from compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala
rename to compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala
index 1f6621558a45..4768113a0f90 100644
--- a/compiler/src/dotty/tools/dotc/transform/PCPCheckAndHeal.scala
+++ b/compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala
@@ -1,5 +1,5 @@
 package dotty.tools.dotc
-package transform
+package staging
 
 import dotty.tools.dotc.ast.{tpd, untpd}
 import dotty.tools.dotc.core.Annotations.BodyAnnotation
@@ -14,6 +14,7 @@ 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.transform.TreeMapWithStages
 import dotty.tools.dotc.typer.Checking
 import dotty.tools.dotc.typer.Implicits.SearchFailureType
 import dotty.tools.dotc.core.Annotations._
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicing.scala b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
index d31b92fc17db..22c95d56c688 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicing.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
@@ -22,6 +22,7 @@ import dotty.tools.dotc.core.Names._
 import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.quoted._
 import dotty.tools.dotc.config.ScalaRelease.*
+import dotty.tools.dotc.staging.PCPCheckAndHeal
 
 import scala.annotation.constructorOnly
 
diff --git a/compiler/src/dotty/tools/dotc/transform/Staging.scala b/compiler/src/dotty/tools/dotc/transform/Staging.scala
index 2e8964c8b1b4..37640cbb265d 100644
--- a/compiler/src/dotty/tools/dotc/transform/Staging.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Staging.scala
@@ -12,8 +12,7 @@ import dotty.tools.dotc.core.Types._
 import dotty.tools.dotc.util.SrcPos
 import dotty.tools.dotc.transform.SymUtils._
 import dotty.tools.dotc.staging.StagingLevel.*
-
-
+import dotty.tools.dotc.staging.PCPCheckAndHeal
 
 /** Checks that the Phase Consistency Principle (PCP) holds and heals types.
  *

From aa73a7051005a0d89b51cc686f79ffd8741b56f4 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 13 Mar 2023 11:45:55 +0100
Subject: [PATCH 260/657] Move TreeMapWithStages to dotty.tools.dotc.staging

---
 compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala     | 1 -
 .../tools/dotc/{transform => staging}/TreeMapWithStages.scala   | 2 +-
 2 files changed, 1 insertion(+), 2 deletions(-)
 rename compiler/src/dotty/tools/dotc/{transform => staging}/TreeMapWithStages.scala (99%)

diff --git a/compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala b/compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala
index 4768113a0f90..9ae6862945ee 100644
--- a/compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala
+++ b/compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala
@@ -14,7 +14,6 @@ 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.transform.TreeMapWithStages
 import dotty.tools.dotc.typer.Checking
 import dotty.tools.dotc.typer.Implicits.SearchFailureType
 import dotty.tools.dotc.core.Annotations._
diff --git a/compiler/src/dotty/tools/dotc/transform/TreeMapWithStages.scala b/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
similarity index 99%
rename from compiler/src/dotty/tools/dotc/transform/TreeMapWithStages.scala
rename to compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
index a4535a639c13..49c5b4c12747 100644
--- a/compiler/src/dotty/tools/dotc/transform/TreeMapWithStages.scala
+++ b/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
@@ -1,5 +1,5 @@
 package dotty.tools.dotc
-package transform
+package staging
 
 import dotty.tools.dotc.ast.{TreeMapWithImplicits, tpd}
 import dotty.tools.dotc.config.Printers.staging

From bd5e3b0fec03aa094ea7c084596c8ca879a3a917 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 13 Mar 2023 11:57:09 +0100
Subject: [PATCH 261/657] Remove Checking from PCPCheckAndHeal

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

diff --git a/compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala b/compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala
index 9ae6862945ee..ab78e078c194 100644
--- a/compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala
+++ b/compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala
@@ -47,7 +47,7 @@ import dotty.tools.dotc.util.Property
  *     }
  *
  */
-class PCPCheckAndHeal extends TreeMapWithStages with Checking {
+class PCPCheckAndHeal extends TreeMapWithStages {
   import tpd._
 
   private val InAnnotation = Property.Key[Unit]()
@@ -256,7 +256,7 @@ class PCPCheckAndHeal extends TreeMapWithStages with Checking {
     tag.tpe match
 
       case tp: TermRef =>
-        checkStable(tp, pos, "type witness")
+        ctx.typer.checkStable(tp, pos, "type witness")
         getQuoteTypeTags.getTagRef(tp)
       case _: SearchFailureType =>
         report.error(

From f32e204a768fbe39ee1f51c67c316b3e6ba4d6fa Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 13 Mar 2023 13:22:50 +0100
Subject: [PATCH 262/657] Split annotation splice transformation from type
 healing

---
 .../tools/dotc/staging/PCPCheckAndHeal.scala  | 20 +++++++++++++++----
 1 file changed, 16 insertions(+), 4 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala b/compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala
index ab78e078c194..43cd44869a25 100644
--- a/compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala
+++ b/compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala
@@ -59,8 +59,12 @@ class PCPCheckAndHeal extends TreeMapWithStages {
       checkAnnotations(tree)
       super.transform(tree)
     else tree match {
-
-      case _: TypeTree | _: RefTree if tree.isType =>
+      case _: TypeTree =>
+        val tp1 = transformTypeAnnotationSplices(tree.tpe)
+        val healedType = healType(tree.srcPos)(tp1)
+        if healedType == tree.tpe then tree
+        else TypeTree(healedType).withSpan(tree.span)
+      case _: RefTree if tree.isType =>
         val healedType = healType(tree.srcPos)(tree.tpe)
         if healedType == tree.tpe then tree
         else TypeTree(healedType).withSpan(tree.span)
@@ -163,6 +167,15 @@ class PCPCheckAndHeal extends TreeMapWithStages {
       ref(tagRef).withSpan(splice.span)
   }
 
+  def transformTypeAnnotationSplices(tp: Type)(using Context) = new TypeMap {
+    def apply(tp: Type): Type = tp match
+      case tp: AnnotatedType =>
+        val newAnnotTree = transform(tp.annot.tree)
+        derivedAnnotatedType(tp, apply(tp.parent), tp.annot.derivedAnnotation(newAnnotTree))
+      case _ =>
+        mapOver(tp)
+  }.apply(tp)
+
   /** Check that annotations do not contain quotes and and that splices are valid */
   private def checkAnnotations(tree: Tree)(using Context): Unit =
     tree match
@@ -198,8 +211,7 @@ class PCPCheckAndHeal extends TreeMapWithStages {
         case tp @ TermRef(NoPrefix, _) if !tp.symbol.isStatic && level > levelOf(tp.symbol) =>
           levelError(tp.symbol, tp, pos)
         case tp: AnnotatedType =>
-          val newAnnotTree = transform(tp.annot.tree)
-          derivedAnnotatedType(tp, apply(tp.parent), tp.annot.derivedAnnotation(newAnnotTree))
+          derivedAnnotatedType(tp, apply(tp.parent), tp.annot)
         case _ =>
           mapOver(tp)
 

From 247b2c709b5e35acece0fe2a554373f1d3db0f0e Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Mon, 13 Mar 2023 15:11:53 +0100
Subject: [PATCH 263/657] Fix WUnused with indents in derived code

---
 .../tools/dotc/transform/CheckUnused.scala    | 14 +++++++-------
 .../fatal-warnings/i15503i.scala              | 19 ++++++++++++++++++-
 2 files changed, 25 insertions(+), 8 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index e7e6e1c4952c..c0ea483efea9 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -15,19 +15,14 @@ import dotty.tools.dotc.reporting.Message
 import dotty.tools.dotc.typer.ImportInfo
 import dotty.tools.dotc.util.{Property, SrcPos}
 import dotty.tools.dotc.core.Mode
-import dotty.tools.dotc.core.Types.TypeTraverser
-import dotty.tools.dotc.core.Types.Type
-import dotty.tools.dotc.core.Types.AnnotatedType
+import dotty.tools.dotc.core.Types.{AnnotatedType, ConstantType, NoType, TermRef, Type, TypeTraverser}
 import dotty.tools.dotc.core.Flags.flagsString
 import dotty.tools.dotc.core.Flags
 import dotty.tools.dotc.core.Names.Name
 import dotty.tools.dotc.transform.MegaPhase.MiniPhase
 import dotty.tools.dotc.core.Annotations
 import dotty.tools.dotc.core.Definitions
-import dotty.tools.dotc.core.Types.ConstantType
 import dotty.tools.dotc.core.NameKinds.WildcardParamName
-import dotty.tools.dotc.core.Types.TermRef
-import dotty.tools.dotc.core.Types.NameFilter
 import dotty.tools.dotc.core.Symbols.Symbol
 
 
@@ -82,6 +77,12 @@ class CheckUnused extends MiniPhase:
 
   override def prepareForIdent(tree: tpd.Ident)(using Context): Context =
     if tree.symbol.exists then
+      val prefixes = LazyList.iterate(tree.typeOpt.normalizedPrefix)(_.normalizedPrefix).takeWhile(_ != NoType)
+      for {
+        prefix <- prefixes
+      } {
+        unusedDataApply(_.registerUsed(prefix.classSymbol, None))
+      }
       unusedDataApply(_.registerUsed(tree.symbol, Some(tree.name)))
     else if tree.hasType then
       unusedDataApply(_.registerUsed(tree.tpe.classSymbol, Some(tree.name)))
@@ -409,7 +410,6 @@ object CheckUnused:
       val kept = used.filterNot { t =>
         val (sym, isAccessible, optName) = t
         // keep the symbol for outer scope, if it matches **no** import
-
         // This is the first matching wildcard selector
         var selWildCard: Option[ImportSelector] = None
 
diff --git a/tests/neg-custom-args/fatal-warnings/i15503i.scala b/tests/neg-custom-args/fatal-warnings/i15503i.scala
index ab83e1dafb3b..9f8416146af4 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503i.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503i.scala
@@ -207,4 +207,21 @@ package foo.test.i16925:
     for {
       i <- 1 to 2 if true
       _ = println(i) // OK
-    } yield ()
\ No newline at end of file
+    } yield ()
+
+package foo.test.i16679:
+  object myPackage:
+    trait CaseClassName[A]:
+      def name: String
+    object CaseClassName:
+      trait CaseClassByStringName[A] extends CaseClassName[A]
+      import scala.deriving.Mirror
+      object CaseClassByStringName:
+        inline final def derived[A](using inline A: Mirror.Of[A]): CaseClassByStringName[A] =
+          new CaseClassByStringName[A]:
+            def name: String = A.toString
+
+  object secondPackage:
+    import myPackage.CaseClassName // OK
+    case class CoolClass(i: Int) derives CaseClassName.CaseClassByStringName
+    println(summon[CaseClassName[CoolClass]].name)

From d9c7f2915c9dd764e214d5f960b3a38c1484c1fb Mon Sep 17 00:00:00 2001
From: Lucas <leblanc.lucas29@gmail.com>
Date: Mon, 13 Mar 2023 15:35:00 +0100
Subject: [PATCH 264/657] Remove the duplicate parameter when generating the
 scaladoc.

---
 .../src/dotty/tools/scaladoc/renderers/MemberRenderer.scala     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scaladoc/src/dotty/tools/scaladoc/renderers/MemberRenderer.scala b/scaladoc/src/dotty/tools/scaladoc/renderers/MemberRenderer.scala
index 7133fe6d657f..47f6bb4b9728 100644
--- a/scaladoc/src/dotty/tools/scaladoc/renderers/MemberRenderer.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/renderers/MemberRenderer.scala
@@ -414,7 +414,7 @@ class MemberRenderer(signatureRenderer: SignatureRenderer)(using DocContext) ext
           val argsSig = SignatureBuilder()
             .functionTermParameters(on.argsLists)
             .content
-          val sig = typeSig ++ Signature(Plain(s"(${on.name}: ")) ++ on.signature ++ Signature(Plain(")")) ++ argsSig
+          val sig = typeSig ++ argsSig
           MGroup(span(cls := "groupHeader")(sig.map(renderElement(_))), members.sortBy(_.name).toSeq, on.name) -> on.position
       }.toSeq.sortBy(_._2).map(_._1)
 

From 7f5aa62c36d8fa7e6d5ad6531242bf4ae08225ec Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Mon, 13 Mar 2023 15:38:12 +0100
Subject: [PATCH 265/657] Add failsafe for a case where prefixes in
 CheckUnused/prepareIndent formed an infinite cycle

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

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index c0ea483efea9..66b0876668be 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -78,6 +78,7 @@ class CheckUnused extends MiniPhase:
   override def prepareForIdent(tree: tpd.Ident)(using Context): Context =
     if tree.symbol.exists then
       val prefixes = LazyList.iterate(tree.typeOpt.normalizedPrefix)(_.normalizedPrefix).takeWhile(_ != NoType)
+        .take(10) // Failsafe for the odd case if there was an infinite cycle
       for {
         prefix <- prefixes
       } {

From 790051e6d4cca04c22cf6ab6d640f0459ad3dbb0 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Mon, 13 Mar 2023 15:39:19 +0100
Subject: [PATCH 266/657] Fix isJavaOverride test

Fixes #17066
---
 compiler/src/dotty/tools/dotc/transform/ElimRepeated.scala | 3 ++-
 tests/pos/i17066/Bar.scala                                 | 2 ++
 tests/pos/i17066/Foo.java                                  | 3 +++
 3 files changed, 7 insertions(+), 1 deletion(-)
 create mode 100644 tests/pos/i17066/Bar.scala
 create mode 100644 tests/pos/i17066/Foo.java

diff --git a/compiler/src/dotty/tools/dotc/transform/ElimRepeated.scala b/compiler/src/dotty/tools/dotc/transform/ElimRepeated.scala
index 78baec70bee6..359b882ef26b 100644
--- a/compiler/src/dotty/tools/dotc/transform/ElimRepeated.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ElimRepeated.scala
@@ -87,7 +87,8 @@ class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase =>
    *  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 =>
+    sym.memberCanMatchInheritedSymbols
+    && sym.owner.info.baseClasses.drop(1).exists { bc =>
       bc.is(JavaDefined) && {
         val other = bc.info.nonPrivateDecl(sym.name)
         other.hasAltWith { alt =>
diff --git a/tests/pos/i17066/Bar.scala b/tests/pos/i17066/Bar.scala
new file mode 100644
index 000000000000..7d3e67f85387
--- /dev/null
+++ b/tests/pos/i17066/Bar.scala
@@ -0,0 +1,2 @@
+class Bar extends Foo:
+  def this(xs: String*) = this()
diff --git a/tests/pos/i17066/Foo.java b/tests/pos/i17066/Foo.java
new file mode 100644
index 000000000000..cb4335c7d444
--- /dev/null
+++ b/tests/pos/i17066/Foo.java
@@ -0,0 +1,3 @@
+public class Foo {
+  public Foo(String... xs) { }
+}

From 915c44c1f36af0594c86186f9aee5aa2a09edb09 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 13 Mar 2023 20:59:10 +0100
Subject: [PATCH 267/657] Extract HealType from PCPCheckAndHeal

---
 .../dotty/tools/dotc/staging/HealType.scala   | 98 +++++++++++++++++++
 .../tools/dotc/staging/PCPCheckAndHeal.scala  | 77 +--------------
 .../tools/dotc/staging/StagingLevel.scala     | 12 ++-
 .../dotty/tools/dotc/transform/Staging.scala  | 27 ++---
 4 files changed, 125 insertions(+), 89 deletions(-)
 create mode 100644 compiler/src/dotty/tools/dotc/staging/HealType.scala

diff --git a/compiler/src/dotty/tools/dotc/staging/HealType.scala b/compiler/src/dotty/tools/dotc/staging/HealType.scala
new file mode 100644
index 000000000000..ad266e257d7e
--- /dev/null
+++ b/compiler/src/dotty/tools/dotc/staging/HealType.scala
@@ -0,0 +1,98 @@
+package dotty.tools.dotc
+package staging
+
+import dotty.tools.dotc.core.Contexts._
+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.staging.StagingLevel.*
+import dotty.tools.dotc.transform.SymUtils._
+import dotty.tools.dotc.typer.Implicits.SearchFailureType
+import dotty.tools.dotc.util.SrcPos
+
+class HealType(pos: SrcPos)(using Context) extends TypeMap {
+
+  /** 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 higher level, then it is inconsistent.
+   *    It cannot be healed because the term will not exist in any future stage.
+   *
+   *  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`.
+   */
+  def apply(tp: Type): Type =
+    tp match
+      case tp: TypeRef =>
+        healTypeRef(tp)
+      case tp @ TermRef(NoPrefix, _) if !tp.symbol.isStatic && level > levelOf(tp.symbol) =>
+        levelError(tp.symbol, tp, pos)
+      case tp: AnnotatedType =>
+        derivedAnnotatedType(tp, apply(tp.parent), tp.annot)
+      case _ =>
+        mapOver(tp)
+
+  private def healTypeRef(tp: TypeRef): Type =
+    tp.prefix match
+      case prefix: TermRef if tp.symbol.isTypeSplice =>
+        checkNotWildcardSplice(tp)
+        if level == 0 then tp else getQuoteTypeTags.getTagRef(prefix)
+      case prefix: TermRef if !prefix.symbol.isStatic && level > levelOf(prefix.symbol) =>
+        dealiasAndTryHeal(prefix.symbol, tp, pos)
+      case NoPrefix if level > levelOf(tp.symbol) && !tp.typeSymbol.hasAnnotation(defn.QuotedRuntime_SplicedTypeAnnot) =>
+        dealiasAndTryHeal(tp.symbol, tp, pos)
+      case prefix: ThisType if level > levelOf(prefix.cls) && !tp.symbol.isStatic =>
+        dealiasAndTryHeal(tp.symbol, tp, pos)
+      case _ =>
+        mapOver(tp)
+
+  private def checkNotWildcardSplice(splice: TypeRef): Unit =
+    splice.prefix.termSymbol.info.argInfos match
+      case (tb: TypeBounds) :: _ => report.error(em"Cannot splice $splice because it is a wildcard type", pos)
+      case _ =>
+
+  private def dealiasAndTryHeal(sym: Symbol, tp: TypeRef, pos: SrcPos): Type =
+    val tp1 = tp.dealias
+    if tp1 != tp then apply(tp1)
+    else tryHeal(tp.symbol, tp, pos)
+
+  /** 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): TypeRef = {
+    val reqType = defn.QuotedTypeClass.typeRef.appliedTo(tp)
+    val tag = ctx.typer.inferImplicitArg(reqType, pos.span)
+    tag.tpe match
+      case tp: TermRef =>
+        ctx.typer.checkStable(tp, pos, "type witness")
+        getQuoteTypeTags.getTagRef(tp)
+      case _: SearchFailureType =>
+        report.error(
+          ctx.typer.missingArgMsg(tag, reqType, "")
+            .prepend(i"Reference to $tp within quotes requires a given $reqType 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): tp.type = {
+    report.error(
+      em"""access to $sym from wrong staging level:
+          | - the definition is at level ${levelOf(sym)},
+          | - but the access is at level $level""", pos)
+    tp
+  }
+}
diff --git a/compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala b/compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala
index 43cd44869a25..59039278ffe1 100644
--- a/compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala
+++ b/compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala
@@ -2,7 +2,7 @@ package dotty.tools.dotc
 package staging
 
 import dotty.tools.dotc.ast.{tpd, untpd}
-import dotty.tools.dotc.core.Annotations.BodyAnnotation
+import dotty.tools.dotc.core.Annotations._
 import dotty.tools.dotc.core.Contexts._
 import dotty.tools.dotc.core.Decorators._
 import dotty.tools.dotc.core.Flags._
@@ -11,15 +11,10 @@ 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.staging.StagingLevel.*
-
 import dotty.tools.dotc.util.Property
+import dotty.tools.dotc.util.Spans._
+import dotty.tools.dotc.util.SrcPos
 
 /** Checks that the Phase Consistency Principle (PCP) holds and heals types.
  *
@@ -203,42 +198,8 @@ class PCPCheckAndHeal extends TreeMapWithStages {
    *  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 =>
-          healTypeRef(tp)
-        case tp @ TermRef(NoPrefix, _) if !tp.symbol.isStatic && level > levelOf(tp.symbol) =>
-          levelError(tp.symbol, tp, pos)
-        case tp: AnnotatedType =>
-          derivedAnnotatedType(tp, apply(tp.parent), tp.annot)
-        case _ =>
-          mapOver(tp)
-
-    private def healTypeRef(tp: TypeRef): Type =
-      tp.prefix match
-        case prefix: TermRef if tp.symbol.isTypeSplice =>
-          checkNotWildcardSplice(tp)
-          if level == 0 then tp else getQuoteTypeTags.getTagRef(prefix)
-        case prefix: TermRef if !prefix.symbol.isStatic && level > levelOf(prefix.symbol) =>
-          dealiasAndTryHeal(prefix.symbol, tp, pos)
-        case NoPrefix if level > levelOf(tp.symbol) && !tp.typeSymbol.hasAnnotation(defn.QuotedRuntime_SplicedTypeAnnot) =>
-          dealiasAndTryHeal(tp.symbol, tp, pos)
-        case prefix: ThisType if level > levelOf(prefix.cls) && !tp.symbol.isStatic =>
-          dealiasAndTryHeal(tp.symbol, tp, pos)
-        case _ =>
-          mapOver(tp)
-
-    private def dealiasAndTryHeal(sym: Symbol, tp: TypeRef, pos: SrcPos)(using Context): Type =
-      val tp1 = tp.dealias
-      if tp1 != tp then apply(tp1)
-      else tryHeal(tp.symbol, tp, pos)
-
-    private def checkNotWildcardSplice(splice: TypeRef)(using Context): Unit =
-      splice.prefix.termSymbol.info.argInfos match
-        case (tb: TypeBounds) :: _ => report.error(em"Cannot splice $splice because it is a wildcard type", pos)
-        case _ =>
-  }
+  protected def healType(pos: SrcPos)(using Context) =
+    new HealType(pos)
 
   /** Check level consistency of terms references */
   private def checkLevelConsistency(tree: Ident | This)(using Context): Unit =
@@ -257,33 +218,6 @@ class PCPCheckAndHeal extends TreeMapWithStages {
              traverseChildren(tp)
     }.traverse(tree.tpe)
 
-  /** 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 =>
-        ctx.typer.checkStable(tp, pos, "type witness")
-        getQuoteTypeTags.getTagRef(tp)
-      case _: SearchFailureType =>
-        report.error(
-          ctx.typer.missingArgMsg(tag, reqType, "")
-            .prepend(i"Reference to $tp within quotes requires a given $reqType 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
@@ -301,7 +235,6 @@ class PCPCheckAndHeal extends TreeMapWithStages {
           | - but the access is at level $level.$hint""", pos)
     tp
   }
-
 }
 
 object PCPCheckAndHeal {
diff --git a/compiler/src/dotty/tools/dotc/staging/StagingLevel.scala b/compiler/src/dotty/tools/dotc/staging/StagingLevel.scala
index 4cf57d28ed8c..8067f5c9aa18 100644
--- a/compiler/src/dotty/tools/dotc/staging/StagingLevel.scala
+++ b/compiler/src/dotty/tools/dotc/staging/StagingLevel.scala
@@ -1,12 +1,14 @@
-package dotty.tools.dotc.staging
+package dotty.tools.dotc
+package staging
 
-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.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.Property
+import dotty.tools.dotc.util.SrcPos
 
 import scala.collection.mutable
 
@@ -29,4 +31,4 @@ object StagingLevel {
       val syms1 = syms//.filter(sym => !levelOfMap.contains(sym))
       val newMap = syms1.foldLeft(levelOfMap)((acc, sym) => acc.updated(sym, level))
       ctx.fresh.setProperty(LevelOfKey, newMap)
-}
\ No newline at end of file
+}
diff --git a/compiler/src/dotty/tools/dotc/transform/Staging.scala b/compiler/src/dotty/tools/dotc/transform/Staging.scala
index 37640cbb265d..f8e2c86169f2 100644
--- a/compiler/src/dotty/tools/dotc/transform/Staging.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Staging.scala
@@ -13,6 +13,7 @@ import dotty.tools.dotc.util.SrcPos
 import dotty.tools.dotc.transform.SymUtils._
 import dotty.tools.dotc.staging.StagingLevel.*
 import dotty.tools.dotc.staging.PCPCheckAndHeal
+import dotty.tools.dotc.staging.HealType
 
 /** Checks that the Phase Consistency Principle (PCP) holds and heals types.
  *
@@ -35,19 +36,21 @@ class Staging extends MacroTransform {
       tree match {
         case PackageDef(pid, _) if tree.symbol.owner == defn.RootClass =>
           val checker = new PCPCheckAndHeal {
-            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""")
+            override protected def healType(pos: SrcPos)(using Context) = new HealType(pos) {
+              override protected def tryHeal(sym: Symbol, tp: TypeRef, pos: SrcPos): 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
+                tp
+              }
             }
           }
           checker.transform(tree)

From 540277bdb16dfcc892d913af7d7b25c731ed2493 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 13 Mar 2023 21:15:50 +0100
Subject: [PATCH 268/657] Move level tracking into StagingLevel

---
 .../tools/dotc/core/StagingContext.scala      | 21 +++----------------
 .../dotty/tools/dotc/inlines/Inliner.scala    |  5 +++--
 .../dotty/tools/dotc/inlines/Inlines.scala    |  3 ++-
 .../dotc/inlines/PrepareInlineable.scala      |  7 ++++---
 .../tools/dotc/staging/StagingLevel.scala     | 15 +++++++++++++
 .../dotty/tools/dotc/transform/Inlining.scala | 13 ++++++------
 .../dotty/tools/dotc/transform/Splicing.scala |  1 +
 .../tools/dotc/typer/QuotesAndSplices.scala   |  5 +++--
 .../src/dotty/tools/dotc/typer/Typer.scala    |  3 ++-
 9 files changed, 40 insertions(+), 33 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/StagingContext.scala b/compiler/src/dotty/tools/dotc/core/StagingContext.scala
index f6d81582dc97..6fb8a190921f 100644
--- a/compiler/src/dotty/tools/dotc/core/StagingContext.scala
+++ b/compiler/src/dotty/tools/dotc/core/StagingContext.scala
@@ -5,12 +5,10 @@ import dotty.tools.dotc.core.Contexts._
 import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.util.Property
 import dotty.tools.dotc.staging.PCPCheckAndHeal
+import dotty.tools.dotc.staging.StagingLevel.*
 
 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.
    */
@@ -18,23 +16,10 @@ object StagingContext {
 
   private val TaggedTypes = new Property.Key[PCPCheckAndHeal.QuoteTypeTags]
 
-  /** All enclosing calls that are currently inlined, from innermost to outermost. */
-  def level(using Context): Int =
-    ctx.property(QuotationLevel).getOrElse(0)
-
-  /** Context with an incremented quotation level. */
-  def quoteContext(using Context): Context =
-    ctx.fresh.setProperty(QuotationLevel, level + 1)
-
   /** Context with an incremented quotation level and pushes a reference to a Quotes on the quote context stack */
   def pushQuotes(qctxRef: tpd.Tree)(using Context): Context =
     val old = ctx.property(QuotesStack).getOrElse(List.empty)
-    ctx.fresh.setProperty(QuotationLevel, level + 1)
-             .setProperty(QuotesStack, qctxRef :: old)
-
-  /** Context with a decremented quotation level. */
-  def spliceContext(using Context): Context =
-    ctx.fresh.setProperty(QuotationLevel, level - 1)
+    quoteContext.setProperty(QuotesStack, qctxRef :: old)
 
   def contextWithQuoteTypeTags(taggedTypes: PCPCheckAndHeal.QuoteTypeTags)(using Context) =
     ctx.fresh.setProperty(TaggedTypes, taggedTypes)
@@ -46,7 +31,7 @@ object StagingContext {
    *  The quotation stack could be empty if we are in a top level splice or an erroneous splice directly within a top level splice.
    */
   def popQuotes()(using Context): (Option[tpd.Tree], Context) =
-    val ctx1 = ctx.fresh.setProperty(QuotationLevel, level - 1)
+    val ctx1 = spliceContext
     val head =
       ctx.property(QuotesStack) match
         case Some(x :: xs) =>
diff --git a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
index f2a0d5f03e38..872dc7793ff4 100644
--- a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
@@ -23,6 +23,7 @@ import util.Spans.Span
 import dotty.tools.dotc.transform.Splicer
 import dotty.tools.dotc.transform.BetaReduce
 import quoted.QuoteUtils
+import staging.StagingLevel
 import scala.annotation.constructorOnly
 
 /** General support for inlining */
@@ -814,7 +815,7 @@ class Inliner(val call: tpd.Tree)(using Context):
       val locked = ctx.typerState.ownedVars
       val res = cancelQuotes(constToLiteral(BetaReduce(super.typedApply(tree, pt)))) match {
         case res: Apply if res.symbol == defn.QuotedRuntime_exprSplice
-                        && StagingContext.level == 0
+                        && StagingLevel.level == 0
                         && !hasInliningErrors =>
           val expanded = expandMacro(res.args.head, tree.srcPos)
           transform.TreeChecker.checkMacroGeneratedTree(res, expanded)
@@ -1026,7 +1027,7 @@ class Inliner(val call: tpd.Tree)(using Context):
   }
 
   private def expandMacro(body: Tree, splicePos: SrcPos)(using Context) = {
-    assert(StagingContext.level == 0)
+    assert(StagingLevel.level == 0)
     val inlinedFrom = enclosingInlineds.last
     val dependencies = macroDependencies(body)
     val suspendable = ctx.compilationUnit.isSuspendable
diff --git a/compiler/src/dotty/tools/dotc/inlines/Inlines.scala b/compiler/src/dotty/tools/dotc/inlines/Inlines.scala
index 8110fd2de195..f504a4034631 100644
--- a/compiler/src/dotty/tools/dotc/inlines/Inlines.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/Inlines.scala
@@ -14,6 +14,7 @@ import ErrorReporting.errorTree
 import dotty.tools.dotc.util.{SourceFile, SourcePosition, SrcPos}
 import parsing.Parsers.Parser
 import transform.{PostTyper, Inlining, CrossVersionChecks}
+import staging.StagingLevel
 
 import collection.mutable
 import reporting.trace
@@ -56,7 +57,7 @@ object Inlines:
     case _ =>
       isInlineable(tree.symbol)
       && !tree.tpe.widenTermRefExpr.isInstanceOf[MethodOrPoly]
-      && StagingContext.level == 0
+      && StagingLevel.level == 0
       && (
         ctx.phase == Phases.inliningPhase
         || (ctx.phase == Phases.typerPhase && needsTransparentInlining(tree))
diff --git a/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala b/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
index 619e36d942b3..eb1a97ab93c0 100644
--- a/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
@@ -22,6 +22,7 @@ import staging.PCPCheckAndHeal
 import transform.SymUtils.*
 import config.Printers.inlining
 import util.Property
+import staging.StagingLevel
 
 object PrepareInlineable {
   import tpd._
@@ -73,7 +74,7 @@ object PrepareInlineable {
         !sym.isContainedIn(inlineSym) &&
         !(sym.isStableMember && sym.info.widenTermRefExpr.isInstanceOf[ConstantType]) &&
         !sym.isInlineMethod &&
-        (Inlines.inInlineMethod || StagingContext.level > 0)
+        (Inlines.inInlineMethod || StagingLevel.level > 0)
 
       def preTransform(tree: Tree)(using Context): Tree
 
@@ -90,8 +91,8 @@ object PrepareInlineable {
         }
 
       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 tree: Apply if tree.symbol.isQuote => StagingLevel.quoteContext
+        case tree: Apply if tree.symbol.isExprSplice => StagingLevel.spliceContext
         case _ => ctx
     }
 
diff --git a/compiler/src/dotty/tools/dotc/staging/StagingLevel.scala b/compiler/src/dotty/tools/dotc/staging/StagingLevel.scala
index 8067f5c9aa18..f29019a14e47 100644
--- a/compiler/src/dotty/tools/dotc/staging/StagingLevel.scala
+++ b/compiler/src/dotty/tools/dotc/staging/StagingLevel.scala
@@ -14,9 +14,24 @@ import scala.collection.mutable
 
 object StagingLevel {
 
+  /** A key to be used in a context property that tracks the staging level */
+  private val LevelKey = new Property.Key[Int]
+
   /** A key to be used in a context property that caches the `levelOf` mapping */
   private val LevelOfKey = new Property.Key[Map[Symbol, Int]]
 
+  /** All enclosing calls that are currently inlined, from innermost to outermost. */
+  def level(using Context): Int =
+    ctx.property(LevelKey).getOrElse(0)
+
+  /** Context with an incremented staging level. */
+  def quoteContext(using Context): FreshContext =
+    ctx.fresh.setProperty(LevelKey, level + 1)
+
+  /** Context with a decremented staging level. */
+  def spliceContext(using Context): FreshContext =
+    ctx.fresh.setProperty(LevelKey, level - 1)
+
   /** The quotation level of the definition of the locally defined symbol */
   def levelOf(sym: Symbol)(using Context): Int =
     ctx.property(LevelOfKey) match
diff --git a/compiler/src/dotty/tools/dotc/transform/Inlining.scala b/compiler/src/dotty/tools/dotc/transform/Inlining.scala
index f0ed7026ee91..ed85746a78b5 100644
--- a/compiler/src/dotty/tools/dotc/transform/Inlining.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Inlining.scala
@@ -13,6 +13,7 @@ import dotty.tools.dotc.core.StagingContext._
 import dotty.tools.dotc.inlines.Inlines
 import dotty.tools.dotc.ast.TreeMapWithImplicits
 import dotty.tools.dotc.core.DenotTransformers.IdentityDenotTransformer
+import dotty.tools.dotc.staging.StagingLevel
 
 import scala.collection.mutable.ListBuffer
 
@@ -46,10 +47,10 @@ class Inlining extends MacroTransform {
           def traverse(tree: Tree)(using Context): Unit =
             tree match
               case _: GenericApply if tree.symbol.isQuote =>
-                traverseChildren(tree)(using StagingContext.quoteContext)
+                traverseChildren(tree)(using StagingLevel.quoteContext)
               case _: GenericApply if tree.symbol.isExprSplice =>
-                traverseChildren(tree)(using StagingContext.spliceContext)
-              case tree: RefTree if !Inlines.inInlineMethod && StagingContext.level == 0 =>
+                traverseChildren(tree)(using StagingLevel.spliceContext)
+              case tree: RefTree if !Inlines.inInlineMethod && StagingLevel.level == 0 =>
                 assert(!tree.symbol.isInlineMethod, tree.show)
               case _ =>
                 traverseChildren(tree)
@@ -76,7 +77,7 @@ class Inlining extends MacroTransform {
           else if tree.symbol.is(Param) then super.transform(tree)
           else if
             !tree.symbol.isPrimaryConstructor
-            && StagingContext.level == 0
+            && StagingLevel.level == 0
             && MacroAnnotations.hasMacroAnnotation(tree.symbol)
           then
             val trees = (new MacroAnnotations).expandAnnotations(tree)
@@ -98,9 +99,9 @@ class Inlining extends MacroTransform {
           if tree1.tpe.isError then tree1
           else Inlines.inlineCall(tree1)
         case _: GenericApply if tree.symbol.isQuote =>
-          super.transform(tree)(using StagingContext.quoteContext)
+          super.transform(tree)(using StagingLevel.quoteContext)
         case _: GenericApply if tree.symbol.isExprSplice =>
-          super.transform(tree)(using StagingContext.spliceContext)
+          super.transform(tree)(using StagingLevel.spliceContext)
         case _: PackageDef =>
           super.transform(tree) match
             case tree1: PackageDef  =>
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicing.scala b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
index 22c95d56c688..39cd059a78ab 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicing.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
@@ -23,6 +23,7 @@ import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.quoted._
 import dotty.tools.dotc.config.ScalaRelease.*
 import dotty.tools.dotc.staging.PCPCheckAndHeal
+import dotty.tools.dotc.staging.StagingLevel.*
 
 import scala.annotation.constructorOnly
 
diff --git a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
index 65d8abfdf6a7..75874d1d1060 100644
--- a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
+++ b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
@@ -11,11 +11,12 @@ 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.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.staging.StagingLevel.*
 import dotty.tools.dotc.transform.SymUtils._
 import dotty.tools.dotc.typer.Implicits._
 import dotty.tools.dotc.typer.Inferencing._
@@ -91,7 +92,7 @@ trait QuotesAndSplices {
         tree.withType(UnspecifiedErrorType)
       }
     else {
-      if (StagingContext.level == 0) {
+      if (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)
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 96149caf215d..8e8c8b2da1ca 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -44,6 +44,7 @@ import config.Feature
 import config.Feature.{sourceVersion, migrateTo3}
 import config.SourceVersion._
 import rewrites.Rewrites.patch
+import staging.StagingLevel
 import transform.SymUtils._
 import transform.TypeUtils._
 import reporting._
@@ -2410,7 +2411,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       else typedExpr(ddef.rhs, tpt1.tpe.widenExpr)(using rhsCtx))
 
     if sym.isInlineMethod then
-      if StagingContext.level > 0 then
+      if StagingLevel.level > 0 then
         report.error("inline def cannot be within quotes", sym.sourcePos)
       if sym.is(Given)
           && untpd.stripBlock(untpd.unsplice(ddef.rhs)).isInstanceOf[untpd.Function]

From 9cbc14c99905b7127bdff657433c5e18de8b6cf8 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 13 Mar 2023 21:20:38 +0100
Subject: [PATCH 269/657] Move StagingContext to dotty.tools.dotc.staging

---
 compiler/src/dotty/tools/dotc/quoted/Interpreter.scala          | 2 +-
 compiler/src/dotty/tools/dotc/staging/HealType.scala            | 2 +-
 compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala     | 2 +-
 .../src/dotty/tools/dotc/{core => staging}/StagingContext.scala | 2 +-
 compiler/src/dotty/tools/dotc/staging/StagingLevel.scala        | 1 -
 compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala   | 1 -
 compiler/src/dotty/tools/dotc/transform/Inlining.scala          | 2 +-
 compiler/src/dotty/tools/dotc/transform/Splicing.scala          | 2 +-
 compiler/src/dotty/tools/dotc/transform/Staging.scala           | 2 +-
 compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala      | 2 +-
 10 files changed, 8 insertions(+), 10 deletions(-)
 rename compiler/src/dotty/tools/dotc/{core => staging}/StagingContext.scala (98%)

diff --git a/compiler/src/dotty/tools/dotc/quoted/Interpreter.scala b/compiler/src/dotty/tools/dotc/quoted/Interpreter.scala
index 7153c17e30ed..0252e042441b 100644
--- a/compiler/src/dotty/tools/dotc/quoted/Interpreter.scala
+++ b/compiler/src/dotty/tools/dotc/quoted/Interpreter.scala
@@ -19,12 +19,12 @@ 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.staging.StagingContext.*
 import dotty.tools.dotc.typer.ImportInfo.withRootImports
 import dotty.tools.dotc.util.SrcPos
 import dotty.tools.dotc.reporting.Message
diff --git a/compiler/src/dotty/tools/dotc/staging/HealType.scala b/compiler/src/dotty/tools/dotc/staging/HealType.scala
index ad266e257d7e..f62f20081b3a 100644
--- a/compiler/src/dotty/tools/dotc/staging/HealType.scala
+++ b/compiler/src/dotty/tools/dotc/staging/HealType.scala
@@ -4,9 +4,9 @@ package staging
 import dotty.tools.dotc.core.Contexts._
 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.staging.StagingContext.*
 import dotty.tools.dotc.staging.StagingLevel.*
 import dotty.tools.dotc.transform.SymUtils._
 import dotty.tools.dotc.typer.Implicits.SearchFailureType
diff --git a/compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala b/compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala
index 59039278ffe1..194a5414a72c 100644
--- a/compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala
+++ b/compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala
@@ -7,10 +7,10 @@ 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.staging.StagingContext.*
 import dotty.tools.dotc.staging.StagingLevel.*
 import dotty.tools.dotc.util.Property
 import dotty.tools.dotc.util.Spans._
diff --git a/compiler/src/dotty/tools/dotc/core/StagingContext.scala b/compiler/src/dotty/tools/dotc/staging/StagingContext.scala
similarity index 98%
rename from compiler/src/dotty/tools/dotc/core/StagingContext.scala
rename to compiler/src/dotty/tools/dotc/staging/StagingContext.scala
index 6fb8a190921f..37e25862206c 100644
--- a/compiler/src/dotty/tools/dotc/core/StagingContext.scala
+++ b/compiler/src/dotty/tools/dotc/staging/StagingContext.scala
@@ -1,4 +1,4 @@
-package dotty.tools.dotc.core
+package dotty.tools.dotc.staging
 
 import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.core.Contexts._
diff --git a/compiler/src/dotty/tools/dotc/staging/StagingLevel.scala b/compiler/src/dotty/tools/dotc/staging/StagingLevel.scala
index f29019a14e47..4704501e38ff 100644
--- a/compiler/src/dotty/tools/dotc/staging/StagingLevel.scala
+++ b/compiler/src/dotty/tools/dotc/staging/StagingLevel.scala
@@ -4,7 +4,6 @@ package staging
 import dotty.tools.dotc.core.Contexts._
 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.Property
diff --git a/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala b/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
index 49c5b4c12747..adaacafa764a 100644
--- a/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
+++ b/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
@@ -5,7 +5,6 @@ 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 dotty.tools.dotc.staging.StagingLevel.*
diff --git a/compiler/src/dotty/tools/dotc/transform/Inlining.scala b/compiler/src/dotty/tools/dotc/transform/Inlining.scala
index ed85746a78b5..1967a0298504 100644
--- a/compiler/src/dotty/tools/dotc/transform/Inlining.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Inlining.scala
@@ -9,10 +9,10 @@ import SymUtils._
 import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.ast.Trees._
 import dotty.tools.dotc.quoted._
-import dotty.tools.dotc.core.StagingContext._
 import dotty.tools.dotc.inlines.Inlines
 import dotty.tools.dotc.ast.TreeMapWithImplicits
 import dotty.tools.dotc.core.DenotTransformers.IdentityDenotTransformer
+import dotty.tools.dotc.staging.StagingContext.*
 import dotty.tools.dotc.staging.StagingLevel
 
 import scala.collection.mutable.ListBuffer
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicing.scala b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
index 39cd059a78ab..0105e6c55253 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicing.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
@@ -14,7 +14,6 @@ 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._
@@ -23,6 +22,7 @@ import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.quoted._
 import dotty.tools.dotc.config.ScalaRelease.*
 import dotty.tools.dotc.staging.PCPCheckAndHeal
+import dotty.tools.dotc.staging.StagingContext.*
 import dotty.tools.dotc.staging.StagingLevel.*
 
 import scala.annotation.constructorOnly
diff --git a/compiler/src/dotty/tools/dotc/transform/Staging.scala b/compiler/src/dotty/tools/dotc/transform/Staging.scala
index f8e2c86169f2..b0c3b8086971 100644
--- a/compiler/src/dotty/tools/dotc/transform/Staging.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Staging.scala
@@ -6,11 +6,11 @@ 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.staging.StagingContext.*
 import dotty.tools.dotc.staging.StagingLevel.*
 import dotty.tools.dotc.staging.PCPCheckAndHeal
 import dotty.tools.dotc.staging.HealType
diff --git a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
index 75874d1d1060..e1f91a46f6bc 100644
--- a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
+++ b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
@@ -11,11 +11,11 @@ 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.staging.StagingContext.*
 import dotty.tools.dotc.staging.StagingLevel.*
 import dotty.tools.dotc.transform.SymUtils._
 import dotty.tools.dotc.typer.Implicits._

From 6d02874b5f6af07728fa377ae97746be4f084e18 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 13 Mar 2023 21:32:06 +0100
Subject: [PATCH 270/657] Extract QuoteTypeTags

---
 .../dotty/tools/dotc/staging/HealType.scala   |  1 +
 .../tools/dotc/staging/PCPCheckAndHeal.scala  | 35 +------------
 .../tools/dotc/staging/QuoteTypeTags.scala    | 52 +++++++++++++++++++
 .../tools/dotc/staging/StagingContext.scala   |  8 ---
 .../dotty/tools/dotc/transform/Splicing.scala |  7 +--
 5 files changed, 59 insertions(+), 44 deletions(-)
 create mode 100644 compiler/src/dotty/tools/dotc/staging/QuoteTypeTags.scala

diff --git a/compiler/src/dotty/tools/dotc/staging/HealType.scala b/compiler/src/dotty/tools/dotc/staging/HealType.scala
index f62f20081b3a..deffa98fef53 100644
--- a/compiler/src/dotty/tools/dotc/staging/HealType.scala
+++ b/compiler/src/dotty/tools/dotc/staging/HealType.scala
@@ -8,6 +8,7 @@ import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.Types._
 import dotty.tools.dotc.staging.StagingContext.*
 import dotty.tools.dotc.staging.StagingLevel.*
+import dotty.tools.dotc.staging.QuoteTypeTags.*
 import dotty.tools.dotc.transform.SymUtils._
 import dotty.tools.dotc.typer.Implicits.SearchFailureType
 import dotty.tools.dotc.util.SrcPos
diff --git a/compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala b/compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala
index 194a5414a72c..751dfcbf1b68 100644
--- a/compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala
+++ b/compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala
@@ -12,6 +12,7 @@ import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.Types._
 import dotty.tools.dotc.staging.StagingContext.*
 import dotty.tools.dotc.staging.StagingLevel.*
+import dotty.tools.dotc.staging.QuoteTypeTags.*
 import dotty.tools.dotc.util.Property
 import dotty.tools.dotc.util.Spans._
 import dotty.tools.dotc.util.SrcPos
@@ -98,7 +99,7 @@ class PCPCheckAndHeal extends TreeMapWithStages {
 
   /** Transform quoted trees while maintaining phase correctness */
   override protected def transformQuotation(body: Tree, quote: Apply)(using Context): Tree = {
-    val taggedTypes = new PCPCheckAndHeal.QuoteTypeTags(quote.span)
+    val taggedTypes = new QuoteTypeTags(quote.span)
 
     if (ctx.property(InAnnotation).isDefined)
       report.error("Cannot have a quote in an annotation", quote.srcPos)
@@ -236,35 +237,3 @@ class PCPCheckAndHeal extends TreeMapWithStages {
     tp
   }
 }
-
-object PCPCheckAndHeal {
-  import tpd._
-
-  class QuoteTypeTags(span: Span)(using Context) {
-
-    private val tags = collection.mutable.LinkedHashMap.empty[Symbol, TypeDef]
-
-    def getTagRef(spliced: TermRef): TypeRef = {
-      val typeDef = tags.getOrElseUpdate(spliced.symbol, mkTagSymbolAndAssignType(spliced))
-      typeDef.symbol.typeRef
-    }
-
-    def getTypeTags: List[TypeDef] = tags.valuesIterator.toList
-
-    private def mkTagSymbolAndAssignType(spliced: TermRef): TypeDef = {
-      val splicedTree = tpd.ref(spliced).withSpan(span)
-      val rhs = splicedTree.select(tpnme.Underlying).withSpan(span)
-      val alias = ctx.typeAssigner.assignType(untpd.TypeBoundsTree(rhs, rhs), rhs, rhs, EmptyTree)
-      val local = newSymbol(
-        owner = ctx.owner,
-        name = UniqueName.fresh((splicedTree.symbol.name.toString + "$_").toTermName).toTypeName,
-        flags = Synthetic,
-        info = TypeAlias(splicedTree.tpe.select(tpnme.Underlying)),
-        coord = span).asType
-      local.addAnnotation(Annotation(defn.QuotedRuntime_SplicedTypeAnnot, span))
-      ctx.typeAssigner.assignType(untpd.TypeDef(local.name, alias), local)
-    }
-
-  }
-
-}
diff --git a/compiler/src/dotty/tools/dotc/staging/QuoteTypeTags.scala b/compiler/src/dotty/tools/dotc/staging/QuoteTypeTags.scala
new file mode 100644
index 000000000000..c4c9c611be3a
--- /dev/null
+++ b/compiler/src/dotty/tools/dotc/staging/QuoteTypeTags.scala
@@ -0,0 +1,52 @@
+package dotty.tools.dotc.staging
+
+import dotty.tools.dotc.ast.{tpd, untpd}
+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._
+import dotty.tools.dotc.core.StdNames._
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Types._
+import dotty.tools.dotc.staging.StagingLevel.*
+import dotty.tools.dotc.util.Property
+import dotty.tools.dotc.util.Spans._
+
+object QuoteTypeTags {
+
+  private val TaggedTypes = new Property.Key[QuoteTypeTags]
+
+  def contextWithQuoteTypeTags(taggedTypes: QuoteTypeTags)(using Context) =
+    ctx.fresh.setProperty(TaggedTypes, taggedTypes)
+
+  def getQuoteTypeTags(using Context): QuoteTypeTags =
+    ctx.property(TaggedTypes).get
+}
+
+class QuoteTypeTags(span: Span)(using Context) {
+  import tpd.*
+
+  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, span))
+    ctx.typeAssigner.assignType(untpd.TypeDef(local.name, alias), local)
+  }
+}
diff --git a/compiler/src/dotty/tools/dotc/staging/StagingContext.scala b/compiler/src/dotty/tools/dotc/staging/StagingContext.scala
index 37e25862206c..839eabeaafeb 100644
--- a/compiler/src/dotty/tools/dotc/staging/StagingContext.scala
+++ b/compiler/src/dotty/tools/dotc/staging/StagingContext.scala
@@ -14,19 +14,11 @@ object StagingContext {
    */
   private val QuotesStack = new Property.Key[List[tpd.Tree]]
 
-  private val TaggedTypes = new Property.Key[PCPCheckAndHeal.QuoteTypeTags]
-
   /** 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)
     quoteContext.setProperty(QuotesStack, qctxRef :: old)
 
-  def contextWithQuoteTypeTags(taggedTypes: PCPCheckAndHeal.QuoteTypeTags)(using Context) =
-    ctx.fresh.setProperty(TaggedTypes, taggedTypes)
-
-  def getQuoteTypeTags(using Context): PCPCheckAndHeal.QuoteTypeTags =
-    ctx.property(TaggedTypes).get
-
   /** Context with a decremented quotation level and pops the Some of top of the quote context stack or None if the stack is empty.
    *  The quotation stack could be empty if we are in a top level splice or an erroneous splice directly within a top level splice.
    */
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicing.scala b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
index 0105e6c55253..3aec4ceb156c 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicing.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
@@ -24,6 +24,7 @@ import dotty.tools.dotc.config.ScalaRelease.*
 import dotty.tools.dotc.staging.PCPCheckAndHeal
 import dotty.tools.dotc.staging.StagingContext.*
 import dotty.tools.dotc.staging.StagingLevel.*
+import dotty.tools.dotc.staging.QuoteTypeTags
 
 import scala.annotation.constructorOnly
 
@@ -191,7 +192,7 @@ class Splicing extends MacroTransform:
     private var refBindingMap = mutable.Map.empty[Symbol, (Tree, Symbol)]
     /** Reference to the `Quotes` instance of the current level 1 splice */
     private var quotes: Tree | Null = null // TODO: add to the context
-    private var healedTypes: PCPCheckAndHeal.QuoteTypeTags | Null = null // TODO: add to the context
+    private var healedTypes: QuoteTypeTags | Null = null // TODO: add to the context
 
     def transformSplice(tree: tpd.Tree, tpe: Type, holeIdx: Int)(using Context): tpd.Tree =
       assert(level == 0)
@@ -261,7 +262,7 @@ class Splicing extends MacroTransform:
     private def transformLevel0QuoteContent(tree: Tree)(using Context): Tree =
       // transform and collect new healed types
       val old = healedTypes
-      healedTypes = new PCPCheckAndHeal.QuoteTypeTags(tree.span)
+      healedTypes = new QuoteTypeTags(tree.span)
       val tree1 = transform(tree)
       val newHealedTypes = healedTypes.nn.getTypeTags
       healedTypes = old
@@ -359,7 +360,7 @@ class Splicing extends MacroTransform:
 
     private def capturedPartTypes(tpt: Tree)(using Context): Tree =
       val old = healedTypes
-      healedTypes = PCPCheckAndHeal.QuoteTypeTags(tpt.span)
+      healedTypes = QuoteTypeTags(tpt.span)
       val capturePartTypes = new TypeMap {
         def apply(tp: Type) = tp match {
           case typeRef @ TypeRef(prefix, _) if isCaptured(prefix.typeSymbol) || isCaptured(prefix.termSymbol) =>

From 3cbc635f861eb2e2d9fe1aa6a3251761b2f55663 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 13 Mar 2023 21:39:37 +0100
Subject: [PATCH 271/657] Rename StagingContext to QuoteContext

---
 compiler/src/dotty/tools/dotc/quoted/Interpreter.scala      | 2 +-
 compiler/src/dotty/tools/dotc/staging/HealType.scala        | 2 +-
 compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala | 6 +++---
 .../staging/{StagingContext.scala => QuoteContext.scala}    | 6 +++---
 compiler/src/dotty/tools/dotc/transform/Inlining.scala      | 2 +-
 compiler/src/dotty/tools/dotc/transform/Splicing.scala      | 2 +-
 compiler/src/dotty/tools/dotc/transform/Staging.scala       | 2 +-
 compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala  | 2 +-
 8 files changed, 12 insertions(+), 12 deletions(-)
 rename compiler/src/dotty/tools/dotc/staging/{StagingContext.scala => QuoteContext.scala} (89%)

diff --git a/compiler/src/dotty/tools/dotc/quoted/Interpreter.scala b/compiler/src/dotty/tools/dotc/quoted/Interpreter.scala
index 0252e042441b..a98284f4078d 100644
--- a/compiler/src/dotty/tools/dotc/quoted/Interpreter.scala
+++ b/compiler/src/dotty/tools/dotc/quoted/Interpreter.scala
@@ -24,7 +24,7 @@ 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.staging.StagingContext.*
+import dotty.tools.dotc.staging.QuoteContext.*
 import dotty.tools.dotc.typer.ImportInfo.withRootImports
 import dotty.tools.dotc.util.SrcPos
 import dotty.tools.dotc.reporting.Message
diff --git a/compiler/src/dotty/tools/dotc/staging/HealType.scala b/compiler/src/dotty/tools/dotc/staging/HealType.scala
index deffa98fef53..645bde42eb29 100644
--- a/compiler/src/dotty/tools/dotc/staging/HealType.scala
+++ b/compiler/src/dotty/tools/dotc/staging/HealType.scala
@@ -6,7 +6,7 @@ import dotty.tools.dotc.core.Decorators._
 import dotty.tools.dotc.core.Flags._
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.Types._
-import dotty.tools.dotc.staging.StagingContext.*
+import dotty.tools.dotc.staging.QuoteContext.*
 import dotty.tools.dotc.staging.StagingLevel.*
 import dotty.tools.dotc.staging.QuoteTypeTags.*
 import dotty.tools.dotc.transform.SymUtils._
diff --git a/compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala b/compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala
index 751dfcbf1b68..2a1371d8eb0d 100644
--- a/compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala
+++ b/compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala
@@ -10,7 +10,7 @@ import dotty.tools.dotc.core.NameKinds._
 import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.Types._
-import dotty.tools.dotc.staging.StagingContext.*
+import dotty.tools.dotc.staging.QuoteContext.*
 import dotty.tools.dotc.staging.StagingLevel.*
 import dotty.tools.dotc.staging.QuoteTypeTags.*
 import dotty.tools.dotc.util.Property
@@ -146,11 +146,11 @@ class PCPCheckAndHeal extends TreeMapWithStages {
         // `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) =>
+      case f @ Apply(fun @ TypeApply(_, _), quotes :: 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)
+        cpy.Apply(splice)(cpy.Apply(f)(cpy.TypeApply(fun)(fun.fun, tpd.TypeTree(tp) :: Nil), quotes :: Nil), body1 :: Nil)
     }
   }
 
diff --git a/compiler/src/dotty/tools/dotc/staging/StagingContext.scala b/compiler/src/dotty/tools/dotc/staging/QuoteContext.scala
similarity index 89%
rename from compiler/src/dotty/tools/dotc/staging/StagingContext.scala
rename to compiler/src/dotty/tools/dotc/staging/QuoteContext.scala
index 839eabeaafeb..542e8ecc2b9f 100644
--- a/compiler/src/dotty/tools/dotc/staging/StagingContext.scala
+++ b/compiler/src/dotty/tools/dotc/staging/QuoteContext.scala
@@ -7,7 +7,7 @@ import dotty.tools.dotc.util.Property
 import dotty.tools.dotc.staging.PCPCheckAndHeal
 import dotty.tools.dotc.staging.StagingLevel.*
 
-object StagingContext {
+object QuoteContext {
 
   /** A key to be used in a context property that tracks the quotation stack.
    *  Stack containing the Quotes references received by the surrounding quotes.
@@ -15,9 +15,9 @@ object StagingContext {
   private val QuotesStack = new Property.Key[List[tpd.Tree]]
 
   /** 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 =
+  def pushQuotes(quotes: tpd.Tree)(using Context): Context =
     val old = ctx.property(QuotesStack).getOrElse(List.empty)
-    quoteContext.setProperty(QuotesStack, qctxRef :: old)
+    quoteContext.setProperty(QuotesStack, quotes :: old)
 
   /** 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.
diff --git a/compiler/src/dotty/tools/dotc/transform/Inlining.scala b/compiler/src/dotty/tools/dotc/transform/Inlining.scala
index 1967a0298504..d6b7f3141b96 100644
--- a/compiler/src/dotty/tools/dotc/transform/Inlining.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Inlining.scala
@@ -12,7 +12,7 @@ import dotty.tools.dotc.quoted._
 import dotty.tools.dotc.inlines.Inlines
 import dotty.tools.dotc.ast.TreeMapWithImplicits
 import dotty.tools.dotc.core.DenotTransformers.IdentityDenotTransformer
-import dotty.tools.dotc.staging.StagingContext.*
+import dotty.tools.dotc.staging.QuoteContext.*
 import dotty.tools.dotc.staging.StagingLevel
 
 import scala.collection.mutable.ListBuffer
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicing.scala b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
index 3aec4ceb156c..2b35188425fb 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicing.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
@@ -22,7 +22,7 @@ import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.quoted._
 import dotty.tools.dotc.config.ScalaRelease.*
 import dotty.tools.dotc.staging.PCPCheckAndHeal
-import dotty.tools.dotc.staging.StagingContext.*
+import dotty.tools.dotc.staging.QuoteContext.*
 import dotty.tools.dotc.staging.StagingLevel.*
 import dotty.tools.dotc.staging.QuoteTypeTags
 
diff --git a/compiler/src/dotty/tools/dotc/transform/Staging.scala b/compiler/src/dotty/tools/dotc/transform/Staging.scala
index b0c3b8086971..5ebfa25eeacd 100644
--- a/compiler/src/dotty/tools/dotc/transform/Staging.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Staging.scala
@@ -10,7 +10,7 @@ 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.staging.StagingContext.*
+import dotty.tools.dotc.staging.QuoteContext.*
 import dotty.tools.dotc.staging.StagingLevel.*
 import dotty.tools.dotc.staging.PCPCheckAndHeal
 import dotty.tools.dotc.staging.HealType
diff --git a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
index e1f91a46f6bc..5d04f27a1305 100644
--- a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
+++ b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
@@ -15,7 +15,7 @@ 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.staging.StagingContext.*
+import dotty.tools.dotc.staging.QuoteContext.*
 import dotty.tools.dotc.staging.StagingLevel.*
 import dotty.tools.dotc.transform.SymUtils._
 import dotty.tools.dotc.typer.Implicits._

From 8bb74d7e80df4c436a02741d9392a9a608552767 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Timoth=C3=A9e=20Andres?= <andres.timothee@gmail.com>
Date: Mon, 20 Feb 2023 11:00:37 +0100
Subject: [PATCH 272/657] Add InlineNumeric prototype skeleton

---
 InlineNumeric.scala | 50 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 InlineNumeric.scala

diff --git a/InlineNumeric.scala b/InlineNumeric.scala
new file mode 100644
index 000000000000..e044998e8d70
--- /dev/null
+++ b/InlineNumeric.scala
@@ -0,0 +1,50 @@
+// community-build/community-projects/stdLib213/src/library/scala/math/Numeric.scala
+// community-build/community-projects/stdLib213/src/library/scala/math/Integral.scala
+// community-build/community-projects/stdLib213/src/library/scala/math/Fractional.scala
+
+
+trait InlineNumeric[T]: // extends Numeric[T] // TODO can we do this?
+  transparent inline def plus(inline x: T, inline y: T): T
+  transparent inline def times(inline x: T, inline y: T): T
+  // TODO add missing methods
+object InlineNumeric:
+  extension [T](inline x: T)(using inline num: InlineNumeric[T])
+    transparent inline def +(inline y: T): T = num.plus(x, y)
+    transparent inline def *(inline y: T): T = num.times(x, y)
+    // TODO add missing methods
+
+trait InlineIntegral[T] extends InlineNumeric[T]:
+  transparent inline def quot(inline x: T, inline y: T): T
+  // TODO add missing methods
+object InlineIntegral:
+  // TODO: how are these imported/composed with Numeric/Integral. Should the extension methods be defined in trait InlineIntegral?
+  extension [T](inline lhs: T)(using inline int: InlineIntegral[T])
+    transparent inline def /(inline rhs: T) = int.quot(lhs, rhs)
+    // TODO add missing methods
+
+// TODO: InlineFractional
+
+given IntIsInlineIntegral: InlineIntegral[Int] with
+  transparent inline def plus(inline x: Int, inline y: Int): Int = x + y
+  transparent inline def times(inline x: Int, inline y: Int): Int = x * y
+  transparent inline def quot(inline x: Int, inline y: Int): Int = x / y
+  // TODO add missing methods
+
+given ShortIsInlineIntegral: InlineIntegral[Short] with
+  transparent inline def plus(inline x: Short, inline y: Short): Short = (x + y).toShort
+  transparent inline def times(inline x: Short, inline y: Short): Short = (x * y).toShort
+  transparent inline def quot(inline x: Short, inline y: Short): Short = (x / y).toShort
+  // TODO add missing methods
+
+// TODO add missing primitive types
+
+object tests:
+  import InlineNumeric.*
+
+  // A generic inline operation that inlines/specializes primitive operations
+  inline def foo[T: InlineNumeric](a: T, b: T) =
+    a + b * b
+
+  def test(a: Int, b: Int) =
+    foo(a, b) // should be a + b * b // can check with -Xprint:inlining
+    foo(a.toShort, b.toShort) // should be a + b * b

From a1b4cc3a1a9784cae6d736ac3e2eb0d29595a0b3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Timoth=C3=A9e=20Andres?= <andres.timothee@gmail.com>
Date: Mon, 20 Feb 2023 14:34:47 +0100
Subject: [PATCH 273/657] Implement missing methods, add examples

Add methods missing in the skeleton

Add given for all primitive types

Add test methods for division, modulo, sign and toInt
---
 InlineNumeric.scala | 203 +++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 192 insertions(+), 11 deletions(-)

diff --git a/InlineNumeric.scala b/InlineNumeric.scala
index e044998e8d70..c011923e1fa2 100644
--- a/InlineNumeric.scala
+++ b/InlineNumeric.scala
@@ -2,41 +2,200 @@
 // community-build/community-projects/stdLib213/src/library/scala/math/Integral.scala
 // community-build/community-projects/stdLib213/src/library/scala/math/Fractional.scala
 
+import scala.util.Try
 
-trait InlineNumeric[T]: // extends Numeric[T] // TODO can we do this?
+trait InlineNumeric[T] extends Ordering[T]: // extends Numeric[T] // TODO can we do this?
   transparent inline def plus(inline x: T, inline y: T): T
+  transparent inline def minus(inline x: T, inline y: T): T
   transparent inline def times(inline x: T, inline y: T): T
-  // TODO add missing methods
+  transparent inline def negate(inline x: T): T
+  transparent inline def fromInt(inline x: Int): T
+  transparent inline def parseString(inline str: String): Option[T]
+  transparent inline def toInt(inline x: T): Int
+  transparent inline def toLong(inline x: T): Long
+  transparent inline def toFloat(inline x: T): Float
+  transparent inline def toDouble(inline x: T): Double
+
+  transparent inline def zero = fromInt(0)
+  transparent inline def one = fromInt(1)
+
+  transparent inline def abs(inline x: T): T = if lt(x, zero) then negate(x) else x
+
+  transparent inline def sign(inline x: T): T =
+    if lt(x, zero) then negate(one)
+    else if gt(x, zero) then one
+    else zero
+
 object InlineNumeric:
   extension [T](inline x: T)(using inline num: InlineNumeric[T])
     transparent inline def +(inline y: T): T = num.plus(x, y)
+    transparent inline def -(inline y: T) = num.minus(x, y)
     transparent inline def *(inline y: T): T = num.times(x, y)
-    // TODO add missing methods
+    transparent inline def unary_- = num.negate(x)
+    transparent inline def toInt: Int = num.toInt(x)
+    transparent inline def toLong: Long = num.toLong(x)
+    transparent inline def toFloat: Float = num.toFloat(x)
+    transparent inline def toDouble: Double = num.toDouble(x)
+
+    transparent inline def abs: T = num.abs(x)
+
+    transparent inline def sign: T = num.sign(x)
 
 trait InlineIntegral[T] extends InlineNumeric[T]:
   transparent inline def quot(inline x: T, inline y: T): T
-  // TODO add missing methods
+  transparent inline def rem(inline x: T, inline y: T): T
+
 object InlineIntegral:
   // TODO: how are these imported/composed with Numeric/Integral. Should the extension methods be defined in trait InlineIntegral?
   extension [T](inline lhs: T)(using inline int: InlineIntegral[T])
     transparent inline def /(inline rhs: T) = int.quot(lhs, rhs)
-    // TODO add missing methods
+    transparent inline def %(inline rhs: T) = int.rem(lhs, rhs)
+    transparent inline def /%(inline rhs: T) = (int.quot(lhs, rhs), int.rem(lhs, rhs))
+
+trait InlineFractional[T] extends InlineNumeric[T]:
+  transparent inline def div(inline x: T, inline y: T): T
 
-// TODO: InlineFractional
+object InlineFractional:
+  // TODO: how are these imported/composed with Numeric/Fractional. Should the extension methods be defined in trait InlineFractional?
+  extension [T](inline lhs: T)(using inline frac: InlineFractional[T])
+    transparent inline def /(inline rhs: T) = frac.div(lhs, rhs)
 
-given IntIsInlineIntegral: InlineIntegral[Int] with
+given IntIsInlineIntegral: InlineIntegral[Int] with Ordering.IntOrdering with
   transparent inline def plus(inline x: Int, inline y: Int): Int = x + y
+  transparent inline def minus(inline x: Int, inline y: Int): Int = x - y
   transparent inline def times(inline x: Int, inline y: Int): Int = x * y
+  transparent inline def negate(inline x: Int): Int = -x
+  transparent inline def fromInt(inline x: Int): Int = x
+  transparent inline def parseString(inline str: String): Option[Int] = str.toIntOption
+  transparent inline def toInt(inline x: Int): Int = x
+  transparent inline def toLong(inline x: Int): Long = x.toLong
+  transparent inline def toFloat(inline x: Int): Float = x.toFloat
+  transparent inline def toDouble(inline x: Int): Double = x.toDouble
+
   transparent inline def quot(inline x: Int, inline y: Int): Int = x / y
-  // TODO add missing methods
+  transparent inline def rem(inline x: Int, inline y: Int): Int = x % y
+
+given BigIntIsInlineIntegral: InlineIntegral[BigInt] with Ordering.BigIntOrdering with
+  transparent inline def plus(inline x: BigInt, inline y: BigInt): BigInt = x + y
+  transparent inline def minus(inline x: BigInt, inline y: BigInt): BigInt = x - y
+  transparent inline def times(inline x: BigInt, inline y: BigInt): BigInt = x * y
+  transparent inline def negate(inline x: BigInt): BigInt = -x
+  transparent inline def fromInt(inline x: Int): BigInt = BigInt(x)
+  transparent inline def parseString(inline str: String): Option[BigInt] = Try(BigInt(str)).toOption
+  transparent inline def toInt(inline x: BigInt): Int = x.intValue
+  transparent inline def toLong(inline x: BigInt): Long = x.longValue
+  transparent inline def toFloat(inline x: BigInt): Float = x.floatValue
+  transparent inline def toDouble(inline x: BigInt): Double = x.doubleValue
 
-given ShortIsInlineIntegral: InlineIntegral[Short] with
+  transparent inline def quot(inline x: BigInt, inline y: BigInt): BigInt = x / y
+  transparent inline def rem(inline x: BigInt, inline y: BigInt): BigInt = x % y
+
+given ShortIsInlineIntegral: InlineIntegral[Short] with Ordering.ShortOrdering with
   transparent inline def plus(inline x: Short, inline y: Short): Short = (x + y).toShort
+  transparent inline def minus(inline x: Short, inline y: Short): Short = (x - y).toShort
   transparent inline def times(inline x: Short, inline y: Short): Short = (x * y).toShort
+  transparent inline def negate(inline x: Short): Short = (-x).toShort
+  transparent inline def fromInt(inline x: Int): Short = x.toShort
+  transparent inline def parseString(inline str: String): Option[Short] = str.toShortOption
+  transparent inline def toInt(inline x: Short): Int = x.toInt
+  transparent inline def toLong(inline x: Short): Long = x.toLong
+  transparent inline def toFloat(inline x: Short): Float = x.toFloat
+  transparent inline def toDouble(inline x: Short): Double = x.toDouble
+
   transparent inline def quot(inline x: Short, inline y: Short): Short = (x / y).toShort
-  // TODO add missing methods
+  transparent inline def rem(inline x: Short, inline y: Short): Short = (x % y).toShort
+
+given ByteIsInlineIntegral: InlineIntegral[Byte] with Ordering.ByteOrdering with
+  transparent inline def plus(inline x: Byte, inline y: Byte): Byte = (x + y).toByte
+  transparent inline def minus(inline x: Byte, inline y: Byte): Byte = (x - y).toByte
+  transparent inline def times(inline x: Byte, inline y: Byte): Byte = (x * y).toByte
+  transparent inline def negate(inline x: Byte): Byte = (-x).toByte
+  transparent inline def fromInt(inline x: Int): Byte = x.toByte
+  transparent inline def parseString(inline str: String): Option[Byte] = str.toByteOption
+  transparent inline def toInt(inline x: Byte): Int = x.toInt
+  transparent inline def toLong(inline x: Byte): Long = x.toLong
+  transparent inline def toFloat(inline x: Byte): Float = x.toFloat
+  transparent inline def toDouble(inline x: Byte): Double = x.toDouble
+
+  transparent inline def quot(inline x: Byte, inline y: Byte): Byte = (x / y).toByte
+  transparent inline def rem(inline x: Byte, inline y: Byte): Byte = (x % y).toByte
+
+given CharIsInlineIntegral: InlineIntegral[Char] with Ordering.CharOrdering with
+  transparent inline def plus(inline x: Char, inline y: Char): Char = (x + y).toChar
+  transparent inline def minus(inline x: Char, inline y: Char): Char = (x - y).toChar
+  transparent inline def times(inline x: Char, inline y: Char): Char = (x * y).toChar
+  transparent inline def negate(inline x: Char): Char = (-x).toChar
+  transparent inline def fromInt(inline x: Int): Char = x.toChar
+  transparent inline def parseString(inline str: String): Option[Char] = Try(str.toInt.toChar).toOption
+  transparent inline def toInt(inline x: Char): Int = x.toInt
+  transparent inline def toLong(inline x: Char): Long = x.toLong
+  transparent inline def toFloat(inline x: Char): Float = x.toFloat
+  transparent inline def toDouble(inline x: Char): Double = x.toDouble
+
+  transparent inline def quot(inline x: Char, inline y: Char): Char = (x / y).toChar
+  transparent inline def rem(inline x: Char, inline y: Char): Char = (x % y).toChar
 
-// TODO add missing primitive types
+given LongIsInlineIntegral: InlineIntegral[Long] with Ordering.LongOrdering with
+  transparent inline def plus(inline x: Long, inline y: Long): Long = x + y
+  transparent inline def minus(inline x: Long, inline y: Long): Long = x - y
+  transparent inline def times(inline x: Long, inline y: Long): Long = x * y
+  transparent inline def negate(inline x: Long): Long = -x
+  transparent inline def fromInt(inline x: Int): Long = x.toLong
+  transparent inline def parseString(inline str: String): Option[Long] = str.toLongOption
+  transparent inline def toInt(inline x: Long): Int = x.toInt
+  transparent inline def toLong(inline x: Long): Long = x
+  transparent inline def toFloat(inline x: Long): Float = x.toFloat
+  transparent inline def toDouble(inline x: Long): Double = x.toDouble
+
+  transparent inline def quot(inline x: Long, inline y: Long): Long = (x / y).toLong
+  transparent inline def rem(inline x: Long, inline y: Long): Long = (x % y).toLong
+
+given FloatIsInlineFractional: InlineFractional[Float] with Ordering.Float.IeeeOrdering with
+  transparent inline def plus(inline x: Float, inline y: Float): Float = x + y
+  transparent inline def minus(inline x: Float, inline y: Float): Float = x - y
+  transparent inline def times(inline x: Float, inline y: Float): Float = x * y
+  transparent inline def negate(inline x: Float): Float = -x
+  transparent inline def fromInt(inline x: Int): Float = x.toFloat
+  transparent inline def parseString(inline str: String): Option[Float] = str.toFloatOption
+  transparent inline def toInt(inline x: Float): Int = x.toInt
+  transparent inline def toLong(inline x: Float): Long = x.toLong
+  transparent inline def toFloat(inline x: Float): Float = x
+  transparent inline def toDouble(inline x: Float): Double = x.toDouble
+
+  transparent inline def div(inline x: Float, inline y: Float): Float = x / y
+
+given DoubleIsInlineFractional: InlineFractional[Double] with Ordering.Double.IeeeOrdering with
+  transparent inline def plus(inline x: Double, inline y: Double): Double = x + y
+  transparent inline def minus(inline x: Double, inline y: Double): Double = x - y
+  transparent inline def times(inline x: Double, inline y: Double): Double = x * y
+  transparent inline def negate(inline x: Double): Double = -x
+  transparent inline def fromInt(inline x: Int): Double = x.toDouble
+  transparent inline def parseString(inline str: String): Option[Double] = str.toDoubleOption
+  transparent inline def toInt(inline x: Double): Int = x.toInt
+  transparent inline def toLong(inline x: Double): Long = x.toLong
+  transparent inline def toFloat(inline x: Double): Float = x.toFloat
+  transparent inline def toDouble(inline x: Double): Double = x
+
+  transparent inline def div(inline x: Double, inline y: Double): Double = x / y
+
+trait BigDecimalIsConflicted extends InlineNumeric[BigDecimal] with Ordering.BigDecimalOrdering:
+  transparent inline def plus(inline x: BigDecimal, inline y: BigDecimal): BigDecimal = x + y
+  transparent inline def minus(inline x: BigDecimal, inline y: BigDecimal): BigDecimal = x - y
+  transparent inline def times(inline x: BigDecimal, inline y: BigDecimal): BigDecimal = x * y
+  transparent inline def negate(inline x: BigDecimal): BigDecimal = -x
+  transparent inline def fromInt(inline x: Int): BigDecimal = BigDecimal(x)
+  transparent inline def parseString(inline str: String): Option[BigDecimal] = Try(BigDecimal(str)).toOption
+  transparent inline def toInt(inline x: BigDecimal): Int = x.intValue
+  transparent inline def toLong(inline x: BigDecimal): Long = x.longValue
+  transparent inline def toFloat(inline x: BigDecimal): Float = x.floatValue
+  transparent inline def toDouble(inline x: BigDecimal): Double = x.doubleValue
+
+given BigDecimalIsInlineFractional: BigDecimalIsConflicted with InlineFractional[BigDecimal] with
+  transparent inline def div(inline x: BigDecimal, inline y: BigDecimal): BigDecimal = x / y
+
+given BigDecimalAsIfInlineIntegral: BigDecimalIsConflicted with InlineIntegral[BigDecimal] with
+  transparent inline def quot(inline x: BigDecimal, inline y: BigDecimal): BigDecimal = x quot y
+  transparent inline def rem(inline x: BigDecimal, inline y: BigDecimal): BigDecimal = x remainder y
 
 object tests:
   import InlineNumeric.*
@@ -45,6 +204,28 @@ object tests:
   inline def foo[T: InlineNumeric](a: T, b: T) =
     a + b * b
 
+  inline def integDiv[T: InlineIntegral](a: T, b: T) =
+    import InlineIntegral.{/, %}
+    a / b % b
+
+  inline def fracDiv[T: InlineFractional](a: T, b: T) =
+    import InlineFractional.{/}
+    a / b + a
+
+  inline def bar[T: InlineNumeric](a: T) = a.toInt
+
+  inline def sign[T: InlineNumeric](a: T) = a.sign
+
   def test(a: Int, b: Int) =
     foo(a, b) // should be a + b * b // can check with -Xprint:inlining
     foo(a.toShort, b.toShort) // should be a + b * b
+
+    integDiv(BigDecimal(a), BigDecimal(b)) // should be BigDecimal(a) quot BigDecimal(b) remainder BigDecimal(b)
+    fracDiv(BigDecimal(a), BigDecimal(b)) // should be BigDecimal(a) / BigDecimal(b) + BigDecimal(a)
+
+    bar(a.toFloat) // should be a.toFloat.toInt
+    bar(a) // should be a
+
+    sign(a)
+    sign(a.toChar)
+    sign(-7F)

From 66db95a0ab9aa04731cdb20defda6224bbc72fc7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Timoth=C3=A9e=20Andres?= <andres.timothee@gmail.com>
Date: Tue, 21 Feb 2023 11:06:36 +0100
Subject: [PATCH 274/657] Fix mishandling of abs and sign for float and double

---
 InlineNumeric.scala | 45 ++++++++++++++++++++++++++++++++-------------
 1 file changed, 32 insertions(+), 13 deletions(-)

diff --git a/InlineNumeric.scala b/InlineNumeric.scala
index c011923e1fa2..99bd447d6307 100644
--- a/InlineNumeric.scala
+++ b/InlineNumeric.scala
@@ -15,17 +15,12 @@ trait InlineNumeric[T] extends Ordering[T]: // extends Numeric[T] // TODO can we
   transparent inline def toLong(inline x: T): Long
   transparent inline def toFloat(inline x: T): Float
   transparent inline def toDouble(inline x: T): Double
+  transparent inline def abs(inline x: T): T
+  transparent inline def sign(inline x: T): T
 
   transparent inline def zero = fromInt(0)
   transparent inline def one = fromInt(1)
 
-  transparent inline def abs(inline x: T): T = if lt(x, zero) then negate(x) else x
-
-  transparent inline def sign(inline x: T): T =
-    if lt(x, zero) then negate(one)
-    else if gt(x, zero) then one
-    else zero
-
 object InlineNumeric:
   extension [T](inline x: T)(using inline num: InlineNumeric[T])
     transparent inline def +(inline y: T): T = num.plus(x, y)
@@ -36,12 +31,16 @@ object InlineNumeric:
     transparent inline def toLong: Long = num.toLong(x)
     transparent inline def toFloat: Float = num.toFloat(x)
     transparent inline def toDouble: Double = num.toDouble(x)
-
     transparent inline def abs: T = num.abs(x)
-
     transparent inline def sign: T = num.sign(x)
 
 trait InlineIntegral[T] extends InlineNumeric[T]:
+  transparent inline def abs(inline x: T): T = if lt(x, zero) then negate(x) else x
+  transparent inline def sign(inline x: T): T =
+    if lt(x, zero) then negate(one)
+    else if gt(x, zero) then one
+    else zero
+
   transparent inline def quot(inline x: T, inline y: T): T
   transparent inline def rem(inline x: T, inline y: T): T
 
@@ -53,7 +52,16 @@ object InlineIntegral:
     transparent inline def /%(inline rhs: T) = (int.quot(lhs, rhs), int.rem(lhs, rhs))
 
 trait InlineFractional[T] extends InlineNumeric[T]:
+  transparent inline def abs(inline x: T): T = if lt(x, zero) || isNegZero(x) then negate(x) else x
+  transparent inline def sign(inline x: T): T =
+    if isNaN(x) || isNegZero(x) then x
+    else if lt(x, zero) then negate(one)
+    else if gt(x, zero) then one
+    else zero
+
   transparent inline def div(inline x: T, inline y: T): T
+  protected transparent inline def isNaN(inline x: T): Boolean
+  protected transparent inline def isNegZero(inline x: T): Boolean
 
 object InlineFractional:
   // TODO: how are these imported/composed with Numeric/Fractional. Should the extension methods be defined in trait InlineFractional?
@@ -163,6 +171,8 @@ given FloatIsInlineFractional: InlineFractional[Float] with Ordering.Float.IeeeO
   transparent inline def toDouble(inline x: Float): Double = x.toDouble
 
   transparent inline def div(inline x: Float, inline y: Float): Float = x / y
+  protected transparent inline def isNaN(inline x: Float): Boolean = x.isNaN
+  protected transparent inline def isNegZero(inline x: Float): Boolean = x.equals(-0f)
 
 given DoubleIsInlineFractional: InlineFractional[Double] with Ordering.Double.IeeeOrdering with
   transparent inline def plus(inline x: Double, inline y: Double): Double = x + y
@@ -177,6 +187,8 @@ given DoubleIsInlineFractional: InlineFractional[Double] with Ordering.Double.Ie
   transparent inline def toDouble(inline x: Double): Double = x
 
   transparent inline def div(inline x: Double, inline y: Double): Double = x / y
+  protected transparent inline def isNaN(inline x: Double): Boolean = x.isNaN
+  protected transparent inline def isNegZero(inline x: Double): Boolean = x.equals(-0.0)
 
 trait BigDecimalIsConflicted extends InlineNumeric[BigDecimal] with Ordering.BigDecimalOrdering:
   transparent inline def plus(inline x: BigDecimal, inline y: BigDecimal): BigDecimal = x + y
@@ -192,6 +204,9 @@ trait BigDecimalIsConflicted extends InlineNumeric[BigDecimal] with Ordering.Big
 
 given BigDecimalIsInlineFractional: BigDecimalIsConflicted with InlineFractional[BigDecimal] with
   transparent inline def div(inline x: BigDecimal, inline y: BigDecimal): BigDecimal = x / y
+  protected transparent inline def isNaN(inline x: BigDecimal): Boolean = false
+  protected transparent inline def isNegZero(inline x: BigDecimal): Boolean = false
+
 
 given BigDecimalAsIfInlineIntegral: BigDecimalIsConflicted with InlineIntegral[BigDecimal] with
   transparent inline def quot(inline x: BigDecimal, inline y: BigDecimal): BigDecimal = x quot y
@@ -214,7 +229,8 @@ object tests:
 
   inline def bar[T: InlineNumeric](a: T) = a.toInt
 
-  inline def sign[T: InlineNumeric](a: T) = a.sign
+  inline def signInt[T: InlineIntegral](a: T) = a.sign
+  inline def signFrac[T: InlineFractional](a: T) = a.sign
 
   def test(a: Int, b: Int) =
     foo(a, b) // should be a + b * b // can check with -Xprint:inlining
@@ -226,6 +242,9 @@ object tests:
     bar(a.toFloat) // should be a.toFloat.toInt
     bar(a) // should be a
 
-    sign(a)
-    sign(a.toChar)
-    sign(-7F)
+    signInt(a)
+    signInt(a.toChar)
+    signFrac(-7F)
+
+    signInt(BigDecimal(a))
+    signFrac(BigDecimal(a)) // the condition with isNan() should be removed

From 28bf386ca3a654c0c2b9479dd0538dcc39cdad3a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Timoth=C3=A9e=20Andres?= <andres.timothee@gmail.com>
Date: Tue, 21 Feb 2023 12:06:54 +0100
Subject: [PATCH 275/657] Use explicit InlineNumeric for BigDecimal

---
 InlineNumeric.scala | 33 +++++++++++++++++----------------
 1 file changed, 17 insertions(+), 16 deletions(-)

diff --git a/InlineNumeric.scala b/InlineNumeric.scala
index 99bd447d6307..25a5185287f3 100644
--- a/InlineNumeric.scala
+++ b/InlineNumeric.scala
@@ -219,32 +219,33 @@ object tests:
   inline def foo[T: InlineNumeric](a: T, b: T) =
     a + b * b
 
-  inline def integDiv[T: InlineIntegral](a: T, b: T) =
+  inline def div[T: InlineIntegral](a: T, b: T) =
     import InlineIntegral.{/, %}
     a / b % b
 
-  inline def fracDiv[T: InlineFractional](a: T, b: T) =
+  inline def div[T: InlineFractional](a: T, b: T) =
     import InlineFractional.{/}
     a / b + a
 
-  inline def bar[T: InlineNumeric](a: T) = a.toInt
+  inline def bar[T: InlineNumeric](a: T) =
+    a.toInt
 
-  inline def signInt[T: InlineIntegral](a: T) = a.sign
-  inline def signFrac[T: InlineFractional](a: T) = a.sign
+  inline def sign[T: InlineNumeric](a: T) =
+    a.sign
 
   def test(a: Int, b: Int) =
-    foo(a, b) // should be a + b * b // can check with -Xprint:inlining
-    foo(a.toShort, b.toShort) // should be a + b * b
+    val v1 = foo(a, b) // should be a + b * b // can check with -Xprint:inlining
+    val v2 = foo(a.toShort, b.toShort) // should be a + b * b
 
-    integDiv(BigDecimal(a), BigDecimal(b)) // should be BigDecimal(a) quot BigDecimal(b) remainder BigDecimal(b)
-    fracDiv(BigDecimal(a), BigDecimal(b)) // should be BigDecimal(a) / BigDecimal(b) + BigDecimal(a)
+    val v3 = div(BigDecimal(a), BigDecimal(b))(using BigDecimalAsIfInlineIntegral) // should be BigDecimal(a) quot BigDecimal(b) remainder BigDecimal(b)
+    val v4 = div(BigDecimal(a), BigDecimal(b))(using BigDecimalIsInlineFractional) // should be BigDecimal(a) / BigDecimal(b) + BigDecimal(a)
 
-    bar(a.toFloat) // should be a.toFloat.toInt
-    bar(a) // should be a
+    val v5 = bar(a.toFloat) // should be a.toFloat.toInt
+    val v6 = bar(a) // should be a
 
-    signInt(a)
-    signInt(a.toChar)
-    signFrac(-7F)
+    val v7 = sign(a)
+    val v8 = sign(a.toChar)
+    val v9 = sign(-7F)
 
-    signInt(BigDecimal(a))
-    signFrac(BigDecimal(a)) // the condition with isNan() should be removed
+    val v10 = sign(BigDecimal(a))(using BigDecimalAsIfInlineIntegral)
+    val v11 = sign(BigDecimal(a))(using BigDecimalIsInlineFractional) // the condition with isNan() should be removed, i.e. it should be equivalent to v10
\ No newline at end of file

From c8251983a75e30b8135e22588353365fac44ed0e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Timoth=C3=A9e=20Andres?= <andres.timothee@gmail.com>
Date: Tue, 21 Feb 2023 14:20:21 +0100
Subject: [PATCH 276/657] Inline parameters to shorten generated code

---
 InlineNumeric.scala | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/InlineNumeric.scala b/InlineNumeric.scala
index 25a5185287f3..061f8b11942d 100644
--- a/InlineNumeric.scala
+++ b/InlineNumeric.scala
@@ -214,23 +214,23 @@ given BigDecimalAsIfInlineIntegral: BigDecimalIsConflicted with InlineIntegral[B
 
 object tests:
   import InlineNumeric.*
+  import InlineIntegral.{/ => quot, %}
+  import InlineFractional.{/}
 
   // A generic inline operation that inlines/specializes primitive operations
-  inline def foo[T: InlineNumeric](a: T, b: T) =
+  inline def foo[T: InlineNumeric](inline a: T, inline b: T) =
     a + b * b
 
-  inline def div[T: InlineIntegral](a: T, b: T) =
-    import InlineIntegral.{/, %}
-    a / b % b
+  inline def div[T: InlineIntegral](inline a: T, inline b: T) =
+    a quot b % b
 
-  inline def div[T: InlineFractional](a: T, b: T) =
-    import InlineFractional.{/}
+  inline def div[T: InlineFractional](inline a: T, inline b: T) =
     a / b + a
 
-  inline def bar[T: InlineNumeric](a: T) =
+  inline def bar[T: InlineNumeric](inline a: T) =
     a.toInt
 
-  inline def sign[T: InlineNumeric](a: T) =
+  inline def sign[T: InlineNumeric](inline a: T) =
     a.sign
 
   def test(a: Int, b: Int) =

From 563f2c5a755eba625abdc87852cb76191de7522a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Timoth=C3=A9e=20Andres?= <andres.timothee@gmail.com>
Date: Tue, 21 Feb 2023 14:37:19 +0100
Subject: [PATCH 277/657] Use symbol for integral division

---
 InlineNumeric.scala | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/InlineNumeric.scala b/InlineNumeric.scala
index 061f8b11942d..265343dfc793 100644
--- a/InlineNumeric.scala
+++ b/InlineNumeric.scala
@@ -214,7 +214,7 @@ given BigDecimalAsIfInlineIntegral: BigDecimalIsConflicted with InlineIntegral[B
 
 object tests:
   import InlineNumeric.*
-  import InlineIntegral.{/ => quot, %}
+  import InlineIntegral.{/ => ¦, %}
   import InlineFractional.{/}
 
   // A generic inline operation that inlines/specializes primitive operations
@@ -222,7 +222,7 @@ object tests:
     a + b * b
 
   inline def div[T: InlineIntegral](inline a: T, inline b: T) =
-    a quot b % b
+    a ¦ b % b
 
   inline def div[T: InlineFractional](inline a: T, inline b: T) =
     a / b + a

From 2113507cca507c041dea67c385423865a4833689 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Timoth=C3=A9e=20Andres?= <andres.timothee@gmail.com>
Date: Tue, 21 Feb 2023 16:54:05 +0100
Subject: [PATCH 278/657] Create two new versions of InlineNumeric

Create version of InlineNumeric that extends Numeric. This requires:
- dropping the inline keyword for parameters (cannot override non-inline
parameter with inline parameter)
- dropping abs, sign, zero and one from InlineNumeric (see code for the
errors). Instead, override them in the given instances

Create version of InlineNumeric with extension methods defined in
the traits instead of in the companion objects.
This allows the usage of said methods without having to import them.
The inconvenient is that the overriding must be done with extension
methods, but since an extension method

  object A:
    extension (x: T)
      def foo: U = ???

can be called both like x.foo and A.foo(x), this allows for both forms
when performing operations such as toInt.
---
 InlineNumeric-extendsNumeric.scala    | 242 ++++++++++++++++++++++++
 InlineNumeric-extensionsInTrait.scala | 263 ++++++++++++++++++++++++++
 2 files changed, 505 insertions(+)
 create mode 100644 InlineNumeric-extendsNumeric.scala
 create mode 100644 InlineNumeric-extensionsInTrait.scala

diff --git a/InlineNumeric-extendsNumeric.scala b/InlineNumeric-extendsNumeric.scala
new file mode 100644
index 000000000000..0c0587c8c416
--- /dev/null
+++ b/InlineNumeric-extendsNumeric.scala
@@ -0,0 +1,242 @@
+import scala.util.Try
+
+trait InlineNumeric[T] extends Numeric[T]:
+  transparent inline def plus(x: T, y: T): T
+  transparent inline def minus(x: T, y: T): T
+  transparent inline def times(x: T, y: T): T
+  transparent inline def negate(x: T): T
+  transparent inline def fromInt(x: Int): T
+  transparent inline def parseString(str: String): Option[T]
+  transparent inline def toInt(x: T): Int
+  transparent inline def toLong(x: T): Long
+  transparent inline def toFloat(x: T): Float
+  transparent inline def toDouble(x: T): Double
+
+  // error overriding method abs in trait InlineNumeric of type (x: T): T;
+  //   method abs in trait Numeric of type (x: T): T is not inline, cannot implement an inline method
+  //transparent inline def abs(x: T): T
+  //transparent inline def sign(x: T): T
+
+  // Deferred inline method fromInt in trait InlineNumeric cannot be invoked
+  //transparent inline def zero = fromInt(0)
+  //transparent inline def one = fromInt(1)
+
+object InlineNumeric:
+  extension [T](x: T)(using num: InlineNumeric[T])
+    transparent inline def +(y: T): T = num.plus(x, y)
+    transparent inline def -(y: T) = num.minus(x, y)
+    transparent inline def *(y: T): T = num.times(x, y)
+    transparent inline def unary_- = num.negate(x)
+    transparent inline def toInt: Int = num.toInt(x)
+    transparent inline def toLong: Long = num.toLong(x)
+    transparent inline def toFloat: Float = num.toFloat(x)
+    transparent inline def toDouble: Double = num.toDouble(x)
+    transparent inline def abs: T = num.abs(x)
+    transparent inline def sign: T = num.sign(x)
+
+trait InlineIntegral[T] extends InlineNumeric[T]:
+  transparent inline def quot(x: T, y: T): T
+  transparent inline def rem(x: T, y: T): T
+
+object InlineIntegral:
+  extension [T](lhs: T)(using int: InlineIntegral[T])
+    transparent inline def /(rhs: T) = int.quot(lhs, rhs)
+    transparent inline def %(rhs: T) = int.rem(lhs, rhs)
+    transparent inline def /%(rhs: T) = (int.quot(lhs, rhs), int.rem(lhs, rhs))
+
+trait InlineFractional[T] extends InlineNumeric[T]:
+  transparent inline def div(x: T, y: T): T
+
+object InlineFractional:
+  extension [T](lhs: T)(using frac: InlineFractional[T])
+    transparent inline def /(rhs: T) = frac.div(lhs, rhs)
+
+given IntIsInlineIntegral: InlineIntegral[Int] with Ordering.IntOrdering with
+  transparent inline def plus(x: Int, y: Int): Int = x + y
+  transparent inline def minus(x: Int, y: Int): Int = x - y
+  transparent inline def times(x: Int, y: Int): Int = x * y
+  transparent inline def negate(x: Int): Int = -x
+  transparent inline def fromInt(x: Int): Int = x
+  transparent inline def parseString(str: String): Option[Int] = str.toIntOption
+  transparent inline def toInt(x: Int): Int = x
+  transparent inline def toLong(x: Int): Long = x.toLong
+  transparent inline def toFloat(x: Int): Float = x.toFloat
+  transparent inline def toDouble(x: Int): Double = x.toDouble
+  transparent override inline def abs(x: Int): Int = math.abs(x)
+  transparent override inline def sign(x: Int): Int = math.signum(x)
+
+  transparent inline def quot(x: Int, y: Int): Int = x / y
+  transparent inline def rem(x: Int, y: Int): Int = x % y
+
+given BigIntIsInlineIntegral: InlineIntegral[BigInt] with Ordering.BigIntOrdering with
+  transparent inline def plus(x: BigInt, y: BigInt): BigInt = x + y
+  transparent inline def minus(x: BigInt, y: BigInt): BigInt = x - y
+  transparent inline def times(x: BigInt, y: BigInt): BigInt = x * y
+  transparent inline def negate(x: BigInt): BigInt = -x
+  transparent inline def fromInt(x: Int): BigInt = BigInt(x)
+  transparent inline def parseString(str: String): Option[BigInt] = Try(BigInt(str)).toOption
+  transparent inline def toInt(x: BigInt): Int = x.intValue
+  transparent inline def toLong(x: BigInt): Long = x.longValue
+  transparent inline def toFloat(x: BigInt): Float = x.floatValue
+  transparent inline def toDouble(x: BigInt): Double = x.doubleValue
+  transparent override inline def abs(x: BigInt): BigInt = x.abs
+  transparent override inline def sign(x: BigInt): BigInt = x.sign
+
+  transparent inline def quot(x: BigInt, y: BigInt): BigInt = x / y
+  transparent inline def rem(x: BigInt, y: BigInt): BigInt = x % y
+
+given ShortIsInlineIntegral: InlineIntegral[Short] with Ordering.ShortOrdering with
+  transparent inline def plus(x: Short, y: Short): Short = (x + y).toShort
+  transparent inline def minus(x: Short, y: Short): Short = (x - y).toShort
+  transparent inline def times(x: Short, y: Short): Short = (x * y).toShort
+  transparent inline def negate(x: Short): Short = (-x).toShort
+  transparent inline def fromInt(x: Int): Short = x.toShort
+  transparent inline def parseString(str: String): Option[Short] = str.toShortOption
+  transparent inline def toInt(x: Short): Int = x.toInt
+  transparent inline def toLong(x: Short): Long = x.toLong
+  transparent inline def toFloat(x: Short): Float = x.toFloat
+  transparent inline def toDouble(x: Short): Double = x.toDouble
+  transparent override inline def abs(x: Short): Short = math.abs(x).toShort
+  transparent override inline def sign(x: Short): Short = math.signum(x).toShort
+
+  transparent inline def quot(x: Short, y: Short): Short = (x / y).toShort
+  transparent inline def rem(x: Short, y: Short): Short = (x % y).toShort
+
+given ByteIsInlineIntegral: InlineIntegral[Byte] with Ordering.ByteOrdering with
+  transparent inline def plus(x: Byte, y: Byte): Byte = (x + y).toByte
+  transparent inline def minus(x: Byte, y: Byte): Byte = (x - y).toByte
+  transparent inline def times(x: Byte, y: Byte): Byte = (x * y).toByte
+  transparent inline def negate(x: Byte): Byte = (-x).toByte
+  transparent inline def fromInt(x: Int): Byte = x.toByte
+  transparent inline def parseString(str: String): Option[Byte] = str.toByteOption
+  transparent inline def toInt(x: Byte): Int = x.toInt
+  transparent inline def toLong(x: Byte): Long = x.toLong
+  transparent inline def toFloat(x: Byte): Float = x.toFloat
+  transparent inline def toDouble(x: Byte): Double = x.toDouble
+  transparent override inline def abs(x: Byte): Byte = math.abs(x).toByte
+  transparent override inline def sign(x: Byte): Byte = math.signum(x).toByte
+
+  transparent inline def quot(x: Byte, y: Byte): Byte = (x / y).toByte
+  transparent inline def rem(x: Byte, y: Byte): Byte = (x % y).toByte
+
+given CharIsInlineIntegral: InlineIntegral[Char] with Ordering.CharOrdering with
+  transparent inline def plus(x: Char, y: Char): Char = (x + y).toChar
+  transparent inline def minus(x: Char, y: Char): Char = (x - y).toChar
+  transparent inline def times(x: Char, y: Char): Char = (x * y).toChar
+  transparent inline def negate(x: Char): Char = (-x).toChar
+  transparent inline def fromInt(x: Int): Char = x.toChar
+  transparent inline def parseString(str: String): Option[Char] = Try(str.toInt.toChar).toOption
+  transparent inline def toInt(x: Char): Int = x.toInt
+  transparent inline def toLong(x: Char): Long = x.toLong
+  transparent inline def toFloat(x: Char): Float = x.toFloat
+  transparent inline def toDouble(x: Char): Double = x.toDouble
+  transparent override inline def abs(x: Char): Char = math.abs(x).toChar
+  transparent override inline def sign(x: Char): Char = math.signum(x).toChar
+
+  transparent inline def quot(x: Char, y: Char): Char = (x / y).toChar
+  transparent inline def rem(x: Char, y: Char): Char = (x % y).toChar
+
+given LongIsInlineIntegral: InlineIntegral[Long] with Ordering.LongOrdering with
+  transparent inline def plus(x: Long, y: Long): Long = x + y
+  transparent inline def minus(x: Long, y: Long): Long = x - y
+  transparent inline def times(x: Long, y: Long): Long = x * y
+  transparent inline def negate(x: Long): Long = -x
+  transparent inline def fromInt(x: Int): Long = x.toLong
+  transparent inline def parseString(str: String): Option[Long] = str.toLongOption
+  transparent inline def toInt(x: Long): Int = x.toInt
+  transparent inline def toLong(x: Long): Long = x
+  transparent inline def toFloat(x: Long): Float = x.toFloat
+  transparent inline def toDouble(x: Long): Double = x.toDouble
+  transparent override inline def abs(x: Long): Long = math.abs(x)
+  transparent override inline def sign(x: Long): Long = math.signum(x)
+
+  transparent inline def quot(x: Long, y: Long): Long = (x / y).toLong
+  transparent inline def rem(x: Long, y: Long): Long = (x % y).toLong
+
+given FloatIsInlineFractional: InlineFractional[Float] with Ordering.Float.IeeeOrdering with
+  transparent inline def plus(x: Float, y: Float): Float = x + y
+  transparent inline def minus(x: Float, y: Float): Float = x - y
+  transparent inline def times(x: Float, y: Float): Float = x * y
+  transparent inline def negate(x: Float): Float = -x
+  transparent inline def fromInt(x: Int): Float = x.toFloat
+  transparent inline def parseString(str: String): Option[Float] = str.toFloatOption
+  transparent inline def toInt(x: Float): Int = x.toInt
+  transparent inline def toLong(x: Float): Long = x.toLong
+  transparent inline def toFloat(x: Float): Float = x
+  transparent inline def toDouble(x: Float): Double = x.toDouble
+  transparent override inline def abs(x: Float): Float = math.abs(x)
+  transparent override inline def sign(x: Float): Float = math.signum(x)
+
+  transparent inline def div(x: Float, y: Float): Float = x / y
+
+given DoubleIsInlineFractional: InlineFractional[Double] with Ordering.Double.IeeeOrdering with
+  transparent inline def plus(x: Double, y: Double): Double = x + y
+  transparent inline def minus(x: Double, y: Double): Double = x - y
+  transparent inline def times(x: Double, y: Double): Double = x * y
+  transparent inline def negate(x: Double): Double = -x
+  transparent inline def fromInt(x: Int): Double = x.toDouble
+  transparent inline def parseString(str: String): Option[Double] = str.toDoubleOption
+  transparent inline def toInt(x: Double): Int = x.toInt
+  transparent inline def toLong(x: Double): Long = x.toLong
+  transparent inline def toFloat(x: Double): Float = x.toFloat
+  transparent inline def toDouble(x: Double): Double = x
+  transparent override inline def abs(x: Double): Double = math.abs(x)
+  transparent override inline def sign(x: Double): Double = math.signum(x)
+
+  transparent inline def div(x: Double, y: Double): Double = x / y
+
+trait BigDecimalIsConflicted extends InlineNumeric[BigDecimal] with Ordering.BigDecimalOrdering:
+  transparent inline def plus(x: BigDecimal, y: BigDecimal): BigDecimal = x + y
+  transparent inline def minus(x: BigDecimal, y: BigDecimal): BigDecimal = x - y
+  transparent inline def times(x: BigDecimal, y: BigDecimal): BigDecimal = x * y
+  transparent inline def negate(x: BigDecimal): BigDecimal = -x
+  transparent inline def fromInt(x: Int): BigDecimal = BigDecimal(x)
+  transparent inline def parseString(str: String): Option[BigDecimal] = Try(BigDecimal(str)).toOption
+  transparent inline def toInt(x: BigDecimal): Int = x.intValue
+  transparent inline def toLong(x: BigDecimal): Long = x.longValue
+  transparent inline def toFloat(x: BigDecimal): Float = x.floatValue
+  transparent inline def toDouble(x: BigDecimal): Double = x.doubleValue
+  transparent override inline def abs(x: BigDecimal): BigDecimal = x.abs
+  transparent override inline def sign(x: BigDecimal): BigDecimal = x.sign
+
+given BigDecimalIsInlineFractional: BigDecimalIsConflicted with InlineFractional[BigDecimal] with
+  transparent inline def div(x: BigDecimal, y: BigDecimal): BigDecimal = x / y
+
+given BigDecimalAsIfInlineIntegral: BigDecimalIsConflicted with InlineIntegral[BigDecimal] with
+  transparent inline def quot(x: BigDecimal, y: BigDecimal): BigDecimal = x quot y
+  transparent inline def rem(x: BigDecimal, y: BigDecimal): BigDecimal = x remainder y
+
+object tests:
+  import InlineNumeric.*
+  import InlineIntegral.{/ => ¦, %}
+  import InlineFractional./
+
+  inline def foo[T: InlineNumeric](a: T, b: T) =
+    a + b * b
+
+  inline def div[T: InlineIntegral](a: T, b: T) =
+    a ¦ b % b
+
+  inline def div[T: InlineFractional](a: T, b: T) =
+    a / b + a
+
+  inline def bar[T: InlineNumeric](a: T) = a.toInt
+
+  inline def sign[T: InlineNumeric](a: T) = a.sign
+
+  def test(a: Int, b: Int) =
+    val v1 = foo(a, b) // should be a + b * b // can check with -Xprint:inlining
+    val v2 = foo(a.toShort, b.toShort) // should be a + b * b
+
+    val v3 = div(BigDecimal(a), BigDecimal(b))(using BigDecimalAsIfInlineIntegral) // should be BigDecimal(a) quot BigDecimal(b) remainder BigDecimal(b)
+    val v4 = div(BigDecimal(a), BigDecimal(b))(using BigDecimalIsInlineFractional) // should be BigDecimal(a) / BigDecimal(b) + BigDecimal(a)
+
+    val v5 = bar(a.toFloat) // should be a.toFloat.toInt
+    val v6 = bar(a) // should be a
+
+    val v7 = sign(a)
+    val v8 = sign(a.toChar)
+    val v9 = sign(-7F)
+
+    val v10 = sign(BigDecimal(a))(using BigDecimalAsIfInlineIntegral)
+    val v11 = sign(BigDecimal(a))(using BigDecimalIsInlineFractional) // the condition with isNan() should be removed, i.e. it should be equivalent to v10
\ No newline at end of file
diff --git a/InlineNumeric-extensionsInTrait.scala b/InlineNumeric-extensionsInTrait.scala
new file mode 100644
index 000000000000..bac390783e65
--- /dev/null
+++ b/InlineNumeric-extensionsInTrait.scala
@@ -0,0 +1,263 @@
+import scala.util.Try
+
+trait InlineNumeric[T] extends Ordering[T]: // extends Numeric[T] // TODO can we do this?
+  transparent inline def plus(inline x: T, inline y: T): T
+  transparent inline def minus(inline x: T, inline y: T): T
+  transparent inline def times(inline x: T, inline y: T): T
+  transparent inline def negate(inline x: T): T
+  transparent inline def fromInt(inline x: Int): T
+  transparent inline def parseString(inline str: String): Option[T]
+
+  transparent inline def zero = fromInt(0)
+  transparent inline def one = fromInt(1)
+
+  extension (inline x: T)
+    transparent inline def +(inline y: T): T = plus(x, y)
+    transparent inline def -(inline y: T) = minus(x, y)
+    transparent inline def *(inline y: T): T = times(x, y)
+    transparent inline def unary_- = negate(x)
+    transparent inline def toInt: Int
+    transparent inline def toLong: Long
+    transparent inline def toFloat: Float
+    transparent inline def toDouble: Double
+    transparent inline def abs: T
+    transparent inline def sign: T
+
+trait InlineIntegral[T] extends InlineNumeric[T]:
+  transparent inline def quot(inline x: T, inline y: T): T
+  transparent inline def rem(inline x: T, inline y: T): T
+
+  extension (inline lhs: T)
+    transparent inline def /(inline rhs: T) = quot(lhs, rhs)
+    transparent inline def %(inline rhs: T) = rem(lhs, rhs)
+    transparent inline def /%(inline rhs: T) = (quot(lhs, rhs), rem(lhs, rhs))
+
+    transparent inline def abs: T = if lt(lhs, zero) then negate(lhs) else lhs
+    transparent inline def sign: T =
+      if lt(lhs, zero) then negate(one)
+      else if gt(lhs, zero) then one
+      else zero
+
+trait InlineFractional[T] extends InlineNumeric[T]:
+  transparent inline def div(inline x: T, inline y: T): T
+  protected transparent inline def isNaN(inline x: T): Boolean
+  protected transparent inline def isNegZero(inline x: T): Boolean
+
+  extension (inline lhs: T)
+    transparent inline def /(inline rhs: T) = div(lhs, rhs)
+    transparent inline def abs: T = if lt(lhs, zero) || isNegZero(lhs) then negate(lhs) else lhs
+    transparent inline def sign: T =
+      if isNaN(lhs) || isNegZero(lhs) then lhs
+      else if lt(lhs, zero) then negate(one)
+      else if gt(lhs, zero) then one
+      else zero
+
+given IntIsInlineIntegral: InlineIntegral[Int] with Ordering.IntOrdering with
+  transparent inline def plus(inline x: Int, inline y: Int): Int = x + y
+  transparent inline def minus(inline x: Int, inline y: Int): Int = x - y
+  transparent inline def times(inline x: Int, inline y: Int): Int = x * y
+  transparent inline def negate(inline x: Int): Int = -x
+  transparent inline def fromInt(inline x: Int): Int = x
+  transparent inline def parseString(inline str: String): Option[Int] = str.toIntOption
+
+  transparent inline def quot(inline x: Int, inline y: Int): Int = x / y
+  transparent inline def rem(inline x: Int, inline y: Int): Int = x % y
+
+  extension (inline x: Int)
+    transparent inline def toInt: Int = x
+    transparent inline def toLong: Long = x.toLong
+    transparent inline def toFloat: Float = x.toFloat
+    transparent inline def toDouble: Double = x.toDouble
+
+given BigIntIsInlineIntegral: InlineIntegral[BigInt] with Ordering.BigIntOrdering with
+  transparent inline def plus(inline x: BigInt, inline y: BigInt): BigInt = x + y
+  transparent inline def minus(inline x: BigInt, inline y: BigInt): BigInt = x - y
+  transparent inline def times(inline x: BigInt, inline y: BigInt): BigInt = x * y
+  transparent inline def negate(inline x: BigInt): BigInt = -x
+  transparent inline def fromInt(inline x: Int): BigInt = BigInt(x)
+  transparent inline def parseString(inline str: String): Option[BigInt] = Try(BigInt(str)).toOption
+
+  transparent inline def quot(inline x: BigInt, inline y: BigInt): BigInt = x / y
+  transparent inline def rem(inline x: BigInt, inline y: BigInt): BigInt = x % y
+
+  extension (inline x: BigInt)
+    transparent inline def toInt: Int = x.intValue
+    transparent inline def toLong: Long = x.longValue
+    transparent inline def toFloat: Float = x.floatValue
+    transparent inline def toDouble: Double = x.doubleValue
+
+given ShortIsInlineIntegral: InlineIntegral[Short] with Ordering.ShortOrdering with
+  transparent inline def plus(inline x: Short, inline y: Short): Short = (x + y).toShort
+  transparent inline def minus(inline x: Short, inline y: Short): Short = (x - y).toShort
+  transparent inline def times(inline x: Short, inline y: Short): Short = (x * y).toShort
+  transparent inline def negate(inline x: Short): Short = (-x).toShort
+  transparent inline def fromInt(inline x: Int): Short = x.toShort
+  transparent inline def parseString(inline str: String): Option[Short] = str.toShortOption
+
+  transparent inline def quot(inline x: Short, inline y: Short): Short = (x / y).toShort
+  transparent inline def rem(inline x: Short, inline y: Short): Short = (x % y).toShort
+
+  extension (inline x: Short)
+    transparent inline def toInt: Int = x.toInt
+    transparent inline def toLong: Long = x.toLong
+    transparent inline def toFloat: Float = x.toFloat
+    transparent inline def toDouble: Double = x.toDouble
+
+given ByteIsInlineIntegral: InlineIntegral[Byte] with Ordering.ByteOrdering with
+  transparent inline def plus(inline x: Byte, inline y: Byte): Byte = (x + y).toByte
+  transparent inline def minus(inline x: Byte, inline y: Byte): Byte = (x - y).toByte
+  transparent inline def times(inline x: Byte, inline y: Byte): Byte = (x * y).toByte
+  transparent inline def negate(inline x: Byte): Byte = (-x).toByte
+  transparent inline def fromInt(inline x: Int): Byte = x.toByte
+  transparent inline def parseString(inline str: String): Option[Byte] = str.toByteOption
+
+  transparent inline def quot(inline x: Byte, inline y: Byte): Byte = (x / y).toByte
+  transparent inline def rem(inline x: Byte, inline y: Byte): Byte = (x % y).toByte
+
+  extension (inline x: Byte)
+    transparent inline def toInt: Int = x.toInt
+    transparent inline def toLong: Long = x.toLong
+    transparent inline def toFloat: Float = x.toFloat
+    transparent inline def toDouble: Double = x.toDouble
+
+given CharIsInlineIntegral: InlineIntegral[Char] with Ordering.CharOrdering with
+  transparent inline def plus(inline x: Char, inline y: Char): Char = (x + y).toChar
+  transparent inline def minus(inline x: Char, inline y: Char): Char = (x - y).toChar
+  transparent inline def times(inline x: Char, inline y: Char): Char = (x * y).toChar
+  transparent inline def negate(inline x: Char): Char = (-x).toChar
+  transparent inline def fromInt(inline x: Int): Char = x.toChar
+  transparent inline def parseString(inline str: String): Option[Char] = Try(str.toInt.toChar).toOption
+
+  transparent inline def quot(inline x: Char, inline y: Char): Char = (x / y).toChar
+  transparent inline def rem(inline x: Char, inline y: Char): Char = (x % y).toChar
+
+  extension (inline x: Char)
+    transparent inline def toInt: Int = x.toInt
+    transparent inline def toLong: Long = x.toLong
+    transparent inline def toFloat: Float = x.toFloat
+    transparent inline def toDouble: Double = x.toDouble
+
+given LongIsInlineIntegral: InlineIntegral[Long] with Ordering.LongOrdering with
+  transparent inline def plus(inline x: Long, inline y: Long): Long = x + y
+  transparent inline def minus(inline x: Long, inline y: Long): Long = x - y
+  transparent inline def times(inline x: Long, inline y: Long): Long = x * y
+  transparent inline def negate(inline x: Long): Long = -x
+  transparent inline def fromInt(inline x: Int): Long = x.toLong
+  transparent inline def parseString(inline str: String): Option[Long] = str.toLongOption
+
+  transparent inline def quot(inline x: Long, inline y: Long): Long = (x / y).toLong
+  transparent inline def rem(inline x: Long, inline y: Long): Long = (x % y).toLong
+
+  extension (inline x: Long)
+    transparent inline def toInt: Int = x.toInt
+    transparent inline def toLong: Long = x
+    transparent inline def toFloat: Float = x.toFloat
+    transparent inline def toDouble: Double = x.toDouble
+
+given FloatIsInlineFractional: InlineFractional[Float] with Ordering.Float.IeeeOrdering with
+  transparent inline def plus(inline x: Float, inline y: Float): Float = x + y
+  transparent inline def minus(inline x: Float, inline y: Float): Float = x - y
+  transparent inline def times(inline x: Float, inline y: Float): Float = x * y
+  transparent inline def negate(inline x: Float): Float = -x
+  transparent inline def fromInt(inline x: Int): Float = x.toFloat
+  transparent inline def parseString(inline str: String): Option[Float] = str.toFloatOption
+
+  transparent inline def div(inline x: Float, inline y: Float): Float = x / y
+  protected transparent inline def isNaN(inline x: Float): Boolean = x.isNaN
+  protected transparent inline def isNegZero(inline x: Float): Boolean = x.equals(-0f)
+
+  extension (inline x: Float)
+    transparent inline def toInt: Int = x.toInt
+    transparent inline def toLong: Long = x.toLong
+    transparent inline def toFloat: Float = x
+    transparent inline def toDouble: Double = x.toDouble
+
+given DoubleIsInlineFractional: InlineFractional[Double] with Ordering.Double.IeeeOrdering with
+  transparent inline def plus(inline x: Double, inline y: Double): Double = x + y
+  transparent inline def minus(inline x: Double, inline y: Double): Double = x - y
+  transparent inline def times(inline x: Double, inline y: Double): Double = x * y
+  transparent inline def negate(inline x: Double): Double = -x
+  transparent inline def fromInt(inline x: Int): Double = x.toDouble
+  transparent inline def parseString(inline str: String): Option[Double] = str.toDoubleOption
+
+  transparent inline def div(inline x: Double, inline y: Double): Double = x / y
+  protected transparent inline def isNaN(inline x: Double): Boolean = x.isNaN
+  protected transparent inline def isNegZero(inline x: Double): Boolean = x.equals(-0.0)
+
+  extension (inline x: Double)
+    transparent inline def toInt: Int = x.toInt
+    transparent inline def toLong: Long = x.toLong
+    transparent inline def toFloat: Float = x.toFloat
+    transparent inline def toDouble: Double = x.toDouble
+
+trait BigDecimalIsConflicted extends InlineNumeric[BigDecimal] with Ordering.BigDecimalOrdering:
+  transparent inline def plus(inline x: BigDecimal, inline y: BigDecimal): BigDecimal = x + y
+  transparent inline def minus(inline x: BigDecimal, inline y: BigDecimal): BigDecimal = x - y
+  transparent inline def times(inline x: BigDecimal, inline y: BigDecimal): BigDecimal = x * y
+  transparent inline def negate(inline x: BigDecimal): BigDecimal = -x
+  transparent inline def fromInt(inline x: Int): BigDecimal = BigDecimal(x)
+  transparent inline def parseString(inline str: String): Option[BigDecimal] = Try(BigDecimal(str)).toOption
+
+  extension (inline x: BigDecimal)
+    transparent inline def toInt: Int = x.intValue
+    transparent inline def toLong: Long = x.longValue
+    transparent inline def toFloat: Float = x.floatValue
+    transparent inline def toDouble: Double = x.doubleValue
+
+given BigDecimalIsInlineFractional: BigDecimalIsConflicted with InlineFractional[BigDecimal] with
+  transparent inline def div(inline x: BigDecimal, inline y: BigDecimal): BigDecimal = x / y
+  protected transparent inline def isNaN(inline x: BigDecimal): Boolean = false
+  protected transparent inline def isNegZero(inline x: BigDecimal): Boolean = false
+
+
+given BigDecimalAsIfInlineIntegral: BigDecimalIsConflicted with InlineIntegral[BigDecimal] with
+  transparent inline def quot(inline x: BigDecimal, inline y: BigDecimal): BigDecimal = x quot y
+  transparent inline def rem(inline x: BigDecimal, inline y: BigDecimal): BigDecimal = x remainder y
+
+object tests:
+  // A generic inline operation that inlines/specializes primitive operations
+  inline def foo[T: InlineNumeric](inline a: T, inline b: T) =
+    a + b * b
+
+  inline def div[T: InlineIntegral](inline a: T, inline b: T) =
+    a / b % b
+
+  inline def div[T: InlineFractional](inline a: T, inline b: T) =
+    a / b + a
+
+  inline def toInt[T: InlineNumeric](inline a: T) =
+    a.toInt
+
+  inline def explicitToInt[T](inline a: T)(using n: InlineNumeric[T]) =
+    n.toInt(a)
+
+  inline def sign[T: InlineNumeric](inline a: T) =
+    a.sign
+
+  inline def explicitPlus[T](inline a: T, inline b: T)(using n: InlineNumeric[T]) =
+    n.plus(a, b)
+
+  def test(a: Int, b: Int) =
+    val v1 = foo(a, b) // should be a + b * b // can check with -Xprint:inlining
+    val v2 = foo(a.toShort, b.toShort) // should be a + b * b
+
+    val v3 = div(BigDecimal(a), BigDecimal(b))(using BigDecimalAsIfInlineIntegral) // should be BigDecimal(a) quot BigDecimal(b) remainder BigDecimal(b)
+    val v4 = div(BigDecimal(a), BigDecimal(b))(using BigDecimalIsInlineFractional) // should be BigDecimal(a) / BigDecimal(b) + BigDecimal(a)
+
+    val v5 = toInt(a.toFloat) // should be a.toFloat.toInt
+    val v6 = toInt(a) // should be a
+
+    val v7 = sign(a)
+    val v8 = sign(a.toChar)
+    val v9 = sign(-7F)
+
+    val v10 = sign(BigDecimal(a))(using BigDecimalAsIfInlineIntegral)
+    val v11 = sign(BigDecimal(a))(using BigDecimalIsInlineFractional) // the condition with isNan() should be removed, i.e. it should be equivalent to v10
+
+    val v12 = explicitPlus(3, 5) // should be 8
+    val v13 = explicitPlus(a, b) // should be a + b
+
+    val v14 = explicitToInt(3.2) // should be (3.2).toInt
+    val v15 = explicitToInt(3) // should be 3
+    val v16 = explicitToInt(a) // should be a
+    val v17 = explicitToInt(a.toShort) // should be a.toShort.toInt
\ No newline at end of file

From 4e27a3acf829d36f35e37249c52af0b4b60be5b2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Timoth=C3=A9e=20Andres?= <andres.timothee@gmail.com>
Date: Fri, 24 Feb 2023 10:31:38 +0100
Subject: [PATCH 279/657] Create clean test for inline Numeric

Split code into separate files for clarity

Reimplement Numeric and Ordering as inline

Place symbols in the trait
---
 InlineNumeric-extendsNumeric.scala        | 242 --------------------
 InlineNumeric-extensionsInTrait.scala     | 263 ----------------------
 InlineNumeric.scala                       | 251 ---------------------
 tests/run/inline-numeric/Fractional.scala |  62 +++++
 tests/run/inline-numeric/Integral.scala   | 132 +++++++++++
 tests/run/inline-numeric/Numeric.scala    |  43 ++++
 tests/run/inline-numeric/Ordering.scala   |  56 +++++
 tests/run/inline-numeric/test.scala       |  54 +++++
 8 files changed, 347 insertions(+), 756 deletions(-)
 delete mode 100644 InlineNumeric-extendsNumeric.scala
 delete mode 100644 InlineNumeric-extensionsInTrait.scala
 delete mode 100644 InlineNumeric.scala
 create mode 100644 tests/run/inline-numeric/Fractional.scala
 create mode 100644 tests/run/inline-numeric/Integral.scala
 create mode 100644 tests/run/inline-numeric/Numeric.scala
 create mode 100644 tests/run/inline-numeric/Ordering.scala
 create mode 100644 tests/run/inline-numeric/test.scala

diff --git a/InlineNumeric-extendsNumeric.scala b/InlineNumeric-extendsNumeric.scala
deleted file mode 100644
index 0c0587c8c416..000000000000
--- a/InlineNumeric-extendsNumeric.scala
+++ /dev/null
@@ -1,242 +0,0 @@
-import scala.util.Try
-
-trait InlineNumeric[T] extends Numeric[T]:
-  transparent inline def plus(x: T, y: T): T
-  transparent inline def minus(x: T, y: T): T
-  transparent inline def times(x: T, y: T): T
-  transparent inline def negate(x: T): T
-  transparent inline def fromInt(x: Int): T
-  transparent inline def parseString(str: String): Option[T]
-  transparent inline def toInt(x: T): Int
-  transparent inline def toLong(x: T): Long
-  transparent inline def toFloat(x: T): Float
-  transparent inline def toDouble(x: T): Double
-
-  // error overriding method abs in trait InlineNumeric of type (x: T): T;
-  //   method abs in trait Numeric of type (x: T): T is not inline, cannot implement an inline method
-  //transparent inline def abs(x: T): T
-  //transparent inline def sign(x: T): T
-
-  // Deferred inline method fromInt in trait InlineNumeric cannot be invoked
-  //transparent inline def zero = fromInt(0)
-  //transparent inline def one = fromInt(1)
-
-object InlineNumeric:
-  extension [T](x: T)(using num: InlineNumeric[T])
-    transparent inline def +(y: T): T = num.plus(x, y)
-    transparent inline def -(y: T) = num.minus(x, y)
-    transparent inline def *(y: T): T = num.times(x, y)
-    transparent inline def unary_- = num.negate(x)
-    transparent inline def toInt: Int = num.toInt(x)
-    transparent inline def toLong: Long = num.toLong(x)
-    transparent inline def toFloat: Float = num.toFloat(x)
-    transparent inline def toDouble: Double = num.toDouble(x)
-    transparent inline def abs: T = num.abs(x)
-    transparent inline def sign: T = num.sign(x)
-
-trait InlineIntegral[T] extends InlineNumeric[T]:
-  transparent inline def quot(x: T, y: T): T
-  transparent inline def rem(x: T, y: T): T
-
-object InlineIntegral:
-  extension [T](lhs: T)(using int: InlineIntegral[T])
-    transparent inline def /(rhs: T) = int.quot(lhs, rhs)
-    transparent inline def %(rhs: T) = int.rem(lhs, rhs)
-    transparent inline def /%(rhs: T) = (int.quot(lhs, rhs), int.rem(lhs, rhs))
-
-trait InlineFractional[T] extends InlineNumeric[T]:
-  transparent inline def div(x: T, y: T): T
-
-object InlineFractional:
-  extension [T](lhs: T)(using frac: InlineFractional[T])
-    transparent inline def /(rhs: T) = frac.div(lhs, rhs)
-
-given IntIsInlineIntegral: InlineIntegral[Int] with Ordering.IntOrdering with
-  transparent inline def plus(x: Int, y: Int): Int = x + y
-  transparent inline def minus(x: Int, y: Int): Int = x - y
-  transparent inline def times(x: Int, y: Int): Int = x * y
-  transparent inline def negate(x: Int): Int = -x
-  transparent inline def fromInt(x: Int): Int = x
-  transparent inline def parseString(str: String): Option[Int] = str.toIntOption
-  transparent inline def toInt(x: Int): Int = x
-  transparent inline def toLong(x: Int): Long = x.toLong
-  transparent inline def toFloat(x: Int): Float = x.toFloat
-  transparent inline def toDouble(x: Int): Double = x.toDouble
-  transparent override inline def abs(x: Int): Int = math.abs(x)
-  transparent override inline def sign(x: Int): Int = math.signum(x)
-
-  transparent inline def quot(x: Int, y: Int): Int = x / y
-  transparent inline def rem(x: Int, y: Int): Int = x % y
-
-given BigIntIsInlineIntegral: InlineIntegral[BigInt] with Ordering.BigIntOrdering with
-  transparent inline def plus(x: BigInt, y: BigInt): BigInt = x + y
-  transparent inline def minus(x: BigInt, y: BigInt): BigInt = x - y
-  transparent inline def times(x: BigInt, y: BigInt): BigInt = x * y
-  transparent inline def negate(x: BigInt): BigInt = -x
-  transparent inline def fromInt(x: Int): BigInt = BigInt(x)
-  transparent inline def parseString(str: String): Option[BigInt] = Try(BigInt(str)).toOption
-  transparent inline def toInt(x: BigInt): Int = x.intValue
-  transparent inline def toLong(x: BigInt): Long = x.longValue
-  transparent inline def toFloat(x: BigInt): Float = x.floatValue
-  transparent inline def toDouble(x: BigInt): Double = x.doubleValue
-  transparent override inline def abs(x: BigInt): BigInt = x.abs
-  transparent override inline def sign(x: BigInt): BigInt = x.sign
-
-  transparent inline def quot(x: BigInt, y: BigInt): BigInt = x / y
-  transparent inline def rem(x: BigInt, y: BigInt): BigInt = x % y
-
-given ShortIsInlineIntegral: InlineIntegral[Short] with Ordering.ShortOrdering with
-  transparent inline def plus(x: Short, y: Short): Short = (x + y).toShort
-  transparent inline def minus(x: Short, y: Short): Short = (x - y).toShort
-  transparent inline def times(x: Short, y: Short): Short = (x * y).toShort
-  transparent inline def negate(x: Short): Short = (-x).toShort
-  transparent inline def fromInt(x: Int): Short = x.toShort
-  transparent inline def parseString(str: String): Option[Short] = str.toShortOption
-  transparent inline def toInt(x: Short): Int = x.toInt
-  transparent inline def toLong(x: Short): Long = x.toLong
-  transparent inline def toFloat(x: Short): Float = x.toFloat
-  transparent inline def toDouble(x: Short): Double = x.toDouble
-  transparent override inline def abs(x: Short): Short = math.abs(x).toShort
-  transparent override inline def sign(x: Short): Short = math.signum(x).toShort
-
-  transparent inline def quot(x: Short, y: Short): Short = (x / y).toShort
-  transparent inline def rem(x: Short, y: Short): Short = (x % y).toShort
-
-given ByteIsInlineIntegral: InlineIntegral[Byte] with Ordering.ByteOrdering with
-  transparent inline def plus(x: Byte, y: Byte): Byte = (x + y).toByte
-  transparent inline def minus(x: Byte, y: Byte): Byte = (x - y).toByte
-  transparent inline def times(x: Byte, y: Byte): Byte = (x * y).toByte
-  transparent inline def negate(x: Byte): Byte = (-x).toByte
-  transparent inline def fromInt(x: Int): Byte = x.toByte
-  transparent inline def parseString(str: String): Option[Byte] = str.toByteOption
-  transparent inline def toInt(x: Byte): Int = x.toInt
-  transparent inline def toLong(x: Byte): Long = x.toLong
-  transparent inline def toFloat(x: Byte): Float = x.toFloat
-  transparent inline def toDouble(x: Byte): Double = x.toDouble
-  transparent override inline def abs(x: Byte): Byte = math.abs(x).toByte
-  transparent override inline def sign(x: Byte): Byte = math.signum(x).toByte
-
-  transparent inline def quot(x: Byte, y: Byte): Byte = (x / y).toByte
-  transparent inline def rem(x: Byte, y: Byte): Byte = (x % y).toByte
-
-given CharIsInlineIntegral: InlineIntegral[Char] with Ordering.CharOrdering with
-  transparent inline def plus(x: Char, y: Char): Char = (x + y).toChar
-  transparent inline def minus(x: Char, y: Char): Char = (x - y).toChar
-  transparent inline def times(x: Char, y: Char): Char = (x * y).toChar
-  transparent inline def negate(x: Char): Char = (-x).toChar
-  transparent inline def fromInt(x: Int): Char = x.toChar
-  transparent inline def parseString(str: String): Option[Char] = Try(str.toInt.toChar).toOption
-  transparent inline def toInt(x: Char): Int = x.toInt
-  transparent inline def toLong(x: Char): Long = x.toLong
-  transparent inline def toFloat(x: Char): Float = x.toFloat
-  transparent inline def toDouble(x: Char): Double = x.toDouble
-  transparent override inline def abs(x: Char): Char = math.abs(x).toChar
-  transparent override inline def sign(x: Char): Char = math.signum(x).toChar
-
-  transparent inline def quot(x: Char, y: Char): Char = (x / y).toChar
-  transparent inline def rem(x: Char, y: Char): Char = (x % y).toChar
-
-given LongIsInlineIntegral: InlineIntegral[Long] with Ordering.LongOrdering with
-  transparent inline def plus(x: Long, y: Long): Long = x + y
-  transparent inline def minus(x: Long, y: Long): Long = x - y
-  transparent inline def times(x: Long, y: Long): Long = x * y
-  transparent inline def negate(x: Long): Long = -x
-  transparent inline def fromInt(x: Int): Long = x.toLong
-  transparent inline def parseString(str: String): Option[Long] = str.toLongOption
-  transparent inline def toInt(x: Long): Int = x.toInt
-  transparent inline def toLong(x: Long): Long = x
-  transparent inline def toFloat(x: Long): Float = x.toFloat
-  transparent inline def toDouble(x: Long): Double = x.toDouble
-  transparent override inline def abs(x: Long): Long = math.abs(x)
-  transparent override inline def sign(x: Long): Long = math.signum(x)
-
-  transparent inline def quot(x: Long, y: Long): Long = (x / y).toLong
-  transparent inline def rem(x: Long, y: Long): Long = (x % y).toLong
-
-given FloatIsInlineFractional: InlineFractional[Float] with Ordering.Float.IeeeOrdering with
-  transparent inline def plus(x: Float, y: Float): Float = x + y
-  transparent inline def minus(x: Float, y: Float): Float = x - y
-  transparent inline def times(x: Float, y: Float): Float = x * y
-  transparent inline def negate(x: Float): Float = -x
-  transparent inline def fromInt(x: Int): Float = x.toFloat
-  transparent inline def parseString(str: String): Option[Float] = str.toFloatOption
-  transparent inline def toInt(x: Float): Int = x.toInt
-  transparent inline def toLong(x: Float): Long = x.toLong
-  transparent inline def toFloat(x: Float): Float = x
-  transparent inline def toDouble(x: Float): Double = x.toDouble
-  transparent override inline def abs(x: Float): Float = math.abs(x)
-  transparent override inline def sign(x: Float): Float = math.signum(x)
-
-  transparent inline def div(x: Float, y: Float): Float = x / y
-
-given DoubleIsInlineFractional: InlineFractional[Double] with Ordering.Double.IeeeOrdering with
-  transparent inline def plus(x: Double, y: Double): Double = x + y
-  transparent inline def minus(x: Double, y: Double): Double = x - y
-  transparent inline def times(x: Double, y: Double): Double = x * y
-  transparent inline def negate(x: Double): Double = -x
-  transparent inline def fromInt(x: Int): Double = x.toDouble
-  transparent inline def parseString(str: String): Option[Double] = str.toDoubleOption
-  transparent inline def toInt(x: Double): Int = x.toInt
-  transparent inline def toLong(x: Double): Long = x.toLong
-  transparent inline def toFloat(x: Double): Float = x.toFloat
-  transparent inline def toDouble(x: Double): Double = x
-  transparent override inline def abs(x: Double): Double = math.abs(x)
-  transparent override inline def sign(x: Double): Double = math.signum(x)
-
-  transparent inline def div(x: Double, y: Double): Double = x / y
-
-trait BigDecimalIsConflicted extends InlineNumeric[BigDecimal] with Ordering.BigDecimalOrdering:
-  transparent inline def plus(x: BigDecimal, y: BigDecimal): BigDecimal = x + y
-  transparent inline def minus(x: BigDecimal, y: BigDecimal): BigDecimal = x - y
-  transparent inline def times(x: BigDecimal, y: BigDecimal): BigDecimal = x * y
-  transparent inline def negate(x: BigDecimal): BigDecimal = -x
-  transparent inline def fromInt(x: Int): BigDecimal = BigDecimal(x)
-  transparent inline def parseString(str: String): Option[BigDecimal] = Try(BigDecimal(str)).toOption
-  transparent inline def toInt(x: BigDecimal): Int = x.intValue
-  transparent inline def toLong(x: BigDecimal): Long = x.longValue
-  transparent inline def toFloat(x: BigDecimal): Float = x.floatValue
-  transparent inline def toDouble(x: BigDecimal): Double = x.doubleValue
-  transparent override inline def abs(x: BigDecimal): BigDecimal = x.abs
-  transparent override inline def sign(x: BigDecimal): BigDecimal = x.sign
-
-given BigDecimalIsInlineFractional: BigDecimalIsConflicted with InlineFractional[BigDecimal] with
-  transparent inline def div(x: BigDecimal, y: BigDecimal): BigDecimal = x / y
-
-given BigDecimalAsIfInlineIntegral: BigDecimalIsConflicted with InlineIntegral[BigDecimal] with
-  transparent inline def quot(x: BigDecimal, y: BigDecimal): BigDecimal = x quot y
-  transparent inline def rem(x: BigDecimal, y: BigDecimal): BigDecimal = x remainder y
-
-object tests:
-  import InlineNumeric.*
-  import InlineIntegral.{/ => ¦, %}
-  import InlineFractional./
-
-  inline def foo[T: InlineNumeric](a: T, b: T) =
-    a + b * b
-
-  inline def div[T: InlineIntegral](a: T, b: T) =
-    a ¦ b % b
-
-  inline def div[T: InlineFractional](a: T, b: T) =
-    a / b + a
-
-  inline def bar[T: InlineNumeric](a: T) = a.toInt
-
-  inline def sign[T: InlineNumeric](a: T) = a.sign
-
-  def test(a: Int, b: Int) =
-    val v1 = foo(a, b) // should be a + b * b // can check with -Xprint:inlining
-    val v2 = foo(a.toShort, b.toShort) // should be a + b * b
-
-    val v3 = div(BigDecimal(a), BigDecimal(b))(using BigDecimalAsIfInlineIntegral) // should be BigDecimal(a) quot BigDecimal(b) remainder BigDecimal(b)
-    val v4 = div(BigDecimal(a), BigDecimal(b))(using BigDecimalIsInlineFractional) // should be BigDecimal(a) / BigDecimal(b) + BigDecimal(a)
-
-    val v5 = bar(a.toFloat) // should be a.toFloat.toInt
-    val v6 = bar(a) // should be a
-
-    val v7 = sign(a)
-    val v8 = sign(a.toChar)
-    val v9 = sign(-7F)
-
-    val v10 = sign(BigDecimal(a))(using BigDecimalAsIfInlineIntegral)
-    val v11 = sign(BigDecimal(a))(using BigDecimalIsInlineFractional) // the condition with isNan() should be removed, i.e. it should be equivalent to v10
\ No newline at end of file
diff --git a/InlineNumeric-extensionsInTrait.scala b/InlineNumeric-extensionsInTrait.scala
deleted file mode 100644
index bac390783e65..000000000000
--- a/InlineNumeric-extensionsInTrait.scala
+++ /dev/null
@@ -1,263 +0,0 @@
-import scala.util.Try
-
-trait InlineNumeric[T] extends Ordering[T]: // extends Numeric[T] // TODO can we do this?
-  transparent inline def plus(inline x: T, inline y: T): T
-  transparent inline def minus(inline x: T, inline y: T): T
-  transparent inline def times(inline x: T, inline y: T): T
-  transparent inline def negate(inline x: T): T
-  transparent inline def fromInt(inline x: Int): T
-  transparent inline def parseString(inline str: String): Option[T]
-
-  transparent inline def zero = fromInt(0)
-  transparent inline def one = fromInt(1)
-
-  extension (inline x: T)
-    transparent inline def +(inline y: T): T = plus(x, y)
-    transparent inline def -(inline y: T) = minus(x, y)
-    transparent inline def *(inline y: T): T = times(x, y)
-    transparent inline def unary_- = negate(x)
-    transparent inline def toInt: Int
-    transparent inline def toLong: Long
-    transparent inline def toFloat: Float
-    transparent inline def toDouble: Double
-    transparent inline def abs: T
-    transparent inline def sign: T
-
-trait InlineIntegral[T] extends InlineNumeric[T]:
-  transparent inline def quot(inline x: T, inline y: T): T
-  transparent inline def rem(inline x: T, inline y: T): T
-
-  extension (inline lhs: T)
-    transparent inline def /(inline rhs: T) = quot(lhs, rhs)
-    transparent inline def %(inline rhs: T) = rem(lhs, rhs)
-    transparent inline def /%(inline rhs: T) = (quot(lhs, rhs), rem(lhs, rhs))
-
-    transparent inline def abs: T = if lt(lhs, zero) then negate(lhs) else lhs
-    transparent inline def sign: T =
-      if lt(lhs, zero) then negate(one)
-      else if gt(lhs, zero) then one
-      else zero
-
-trait InlineFractional[T] extends InlineNumeric[T]:
-  transparent inline def div(inline x: T, inline y: T): T
-  protected transparent inline def isNaN(inline x: T): Boolean
-  protected transparent inline def isNegZero(inline x: T): Boolean
-
-  extension (inline lhs: T)
-    transparent inline def /(inline rhs: T) = div(lhs, rhs)
-    transparent inline def abs: T = if lt(lhs, zero) || isNegZero(lhs) then negate(lhs) else lhs
-    transparent inline def sign: T =
-      if isNaN(lhs) || isNegZero(lhs) then lhs
-      else if lt(lhs, zero) then negate(one)
-      else if gt(lhs, zero) then one
-      else zero
-
-given IntIsInlineIntegral: InlineIntegral[Int] with Ordering.IntOrdering with
-  transparent inline def plus(inline x: Int, inline y: Int): Int = x + y
-  transparent inline def minus(inline x: Int, inline y: Int): Int = x - y
-  transparent inline def times(inline x: Int, inline y: Int): Int = x * y
-  transparent inline def negate(inline x: Int): Int = -x
-  transparent inline def fromInt(inline x: Int): Int = x
-  transparent inline def parseString(inline str: String): Option[Int] = str.toIntOption
-
-  transparent inline def quot(inline x: Int, inline y: Int): Int = x / y
-  transparent inline def rem(inline x: Int, inline y: Int): Int = x % y
-
-  extension (inline x: Int)
-    transparent inline def toInt: Int = x
-    transparent inline def toLong: Long = x.toLong
-    transparent inline def toFloat: Float = x.toFloat
-    transparent inline def toDouble: Double = x.toDouble
-
-given BigIntIsInlineIntegral: InlineIntegral[BigInt] with Ordering.BigIntOrdering with
-  transparent inline def plus(inline x: BigInt, inline y: BigInt): BigInt = x + y
-  transparent inline def minus(inline x: BigInt, inline y: BigInt): BigInt = x - y
-  transparent inline def times(inline x: BigInt, inline y: BigInt): BigInt = x * y
-  transparent inline def negate(inline x: BigInt): BigInt = -x
-  transparent inline def fromInt(inline x: Int): BigInt = BigInt(x)
-  transparent inline def parseString(inline str: String): Option[BigInt] = Try(BigInt(str)).toOption
-
-  transparent inline def quot(inline x: BigInt, inline y: BigInt): BigInt = x / y
-  transparent inline def rem(inline x: BigInt, inline y: BigInt): BigInt = x % y
-
-  extension (inline x: BigInt)
-    transparent inline def toInt: Int = x.intValue
-    transparent inline def toLong: Long = x.longValue
-    transparent inline def toFloat: Float = x.floatValue
-    transparent inline def toDouble: Double = x.doubleValue
-
-given ShortIsInlineIntegral: InlineIntegral[Short] with Ordering.ShortOrdering with
-  transparent inline def plus(inline x: Short, inline y: Short): Short = (x + y).toShort
-  transparent inline def minus(inline x: Short, inline y: Short): Short = (x - y).toShort
-  transparent inline def times(inline x: Short, inline y: Short): Short = (x * y).toShort
-  transparent inline def negate(inline x: Short): Short = (-x).toShort
-  transparent inline def fromInt(inline x: Int): Short = x.toShort
-  transparent inline def parseString(inline str: String): Option[Short] = str.toShortOption
-
-  transparent inline def quot(inline x: Short, inline y: Short): Short = (x / y).toShort
-  transparent inline def rem(inline x: Short, inline y: Short): Short = (x % y).toShort
-
-  extension (inline x: Short)
-    transparent inline def toInt: Int = x.toInt
-    transparent inline def toLong: Long = x.toLong
-    transparent inline def toFloat: Float = x.toFloat
-    transparent inline def toDouble: Double = x.toDouble
-
-given ByteIsInlineIntegral: InlineIntegral[Byte] with Ordering.ByteOrdering with
-  transparent inline def plus(inline x: Byte, inline y: Byte): Byte = (x + y).toByte
-  transparent inline def minus(inline x: Byte, inline y: Byte): Byte = (x - y).toByte
-  transparent inline def times(inline x: Byte, inline y: Byte): Byte = (x * y).toByte
-  transparent inline def negate(inline x: Byte): Byte = (-x).toByte
-  transparent inline def fromInt(inline x: Int): Byte = x.toByte
-  transparent inline def parseString(inline str: String): Option[Byte] = str.toByteOption
-
-  transparent inline def quot(inline x: Byte, inline y: Byte): Byte = (x / y).toByte
-  transparent inline def rem(inline x: Byte, inline y: Byte): Byte = (x % y).toByte
-
-  extension (inline x: Byte)
-    transparent inline def toInt: Int = x.toInt
-    transparent inline def toLong: Long = x.toLong
-    transparent inline def toFloat: Float = x.toFloat
-    transparent inline def toDouble: Double = x.toDouble
-
-given CharIsInlineIntegral: InlineIntegral[Char] with Ordering.CharOrdering with
-  transparent inline def plus(inline x: Char, inline y: Char): Char = (x + y).toChar
-  transparent inline def minus(inline x: Char, inline y: Char): Char = (x - y).toChar
-  transparent inline def times(inline x: Char, inline y: Char): Char = (x * y).toChar
-  transparent inline def negate(inline x: Char): Char = (-x).toChar
-  transparent inline def fromInt(inline x: Int): Char = x.toChar
-  transparent inline def parseString(inline str: String): Option[Char] = Try(str.toInt.toChar).toOption
-
-  transparent inline def quot(inline x: Char, inline y: Char): Char = (x / y).toChar
-  transparent inline def rem(inline x: Char, inline y: Char): Char = (x % y).toChar
-
-  extension (inline x: Char)
-    transparent inline def toInt: Int = x.toInt
-    transparent inline def toLong: Long = x.toLong
-    transparent inline def toFloat: Float = x.toFloat
-    transparent inline def toDouble: Double = x.toDouble
-
-given LongIsInlineIntegral: InlineIntegral[Long] with Ordering.LongOrdering with
-  transparent inline def plus(inline x: Long, inline y: Long): Long = x + y
-  transparent inline def minus(inline x: Long, inline y: Long): Long = x - y
-  transparent inline def times(inline x: Long, inline y: Long): Long = x * y
-  transparent inline def negate(inline x: Long): Long = -x
-  transparent inline def fromInt(inline x: Int): Long = x.toLong
-  transparent inline def parseString(inline str: String): Option[Long] = str.toLongOption
-
-  transparent inline def quot(inline x: Long, inline y: Long): Long = (x / y).toLong
-  transparent inline def rem(inline x: Long, inline y: Long): Long = (x % y).toLong
-
-  extension (inline x: Long)
-    transparent inline def toInt: Int = x.toInt
-    transparent inline def toLong: Long = x
-    transparent inline def toFloat: Float = x.toFloat
-    transparent inline def toDouble: Double = x.toDouble
-
-given FloatIsInlineFractional: InlineFractional[Float] with Ordering.Float.IeeeOrdering with
-  transparent inline def plus(inline x: Float, inline y: Float): Float = x + y
-  transparent inline def minus(inline x: Float, inline y: Float): Float = x - y
-  transparent inline def times(inline x: Float, inline y: Float): Float = x * y
-  transparent inline def negate(inline x: Float): Float = -x
-  transparent inline def fromInt(inline x: Int): Float = x.toFloat
-  transparent inline def parseString(inline str: String): Option[Float] = str.toFloatOption
-
-  transparent inline def div(inline x: Float, inline y: Float): Float = x / y
-  protected transparent inline def isNaN(inline x: Float): Boolean = x.isNaN
-  protected transparent inline def isNegZero(inline x: Float): Boolean = x.equals(-0f)
-
-  extension (inline x: Float)
-    transparent inline def toInt: Int = x.toInt
-    transparent inline def toLong: Long = x.toLong
-    transparent inline def toFloat: Float = x
-    transparent inline def toDouble: Double = x.toDouble
-
-given DoubleIsInlineFractional: InlineFractional[Double] with Ordering.Double.IeeeOrdering with
-  transparent inline def plus(inline x: Double, inline y: Double): Double = x + y
-  transparent inline def minus(inline x: Double, inline y: Double): Double = x - y
-  transparent inline def times(inline x: Double, inline y: Double): Double = x * y
-  transparent inline def negate(inline x: Double): Double = -x
-  transparent inline def fromInt(inline x: Int): Double = x.toDouble
-  transparent inline def parseString(inline str: String): Option[Double] = str.toDoubleOption
-
-  transparent inline def div(inline x: Double, inline y: Double): Double = x / y
-  protected transparent inline def isNaN(inline x: Double): Boolean = x.isNaN
-  protected transparent inline def isNegZero(inline x: Double): Boolean = x.equals(-0.0)
-
-  extension (inline x: Double)
-    transparent inline def toInt: Int = x.toInt
-    transparent inline def toLong: Long = x.toLong
-    transparent inline def toFloat: Float = x.toFloat
-    transparent inline def toDouble: Double = x.toDouble
-
-trait BigDecimalIsConflicted extends InlineNumeric[BigDecimal] with Ordering.BigDecimalOrdering:
-  transparent inline def plus(inline x: BigDecimal, inline y: BigDecimal): BigDecimal = x + y
-  transparent inline def minus(inline x: BigDecimal, inline y: BigDecimal): BigDecimal = x - y
-  transparent inline def times(inline x: BigDecimal, inline y: BigDecimal): BigDecimal = x * y
-  transparent inline def negate(inline x: BigDecimal): BigDecimal = -x
-  transparent inline def fromInt(inline x: Int): BigDecimal = BigDecimal(x)
-  transparent inline def parseString(inline str: String): Option[BigDecimal] = Try(BigDecimal(str)).toOption
-
-  extension (inline x: BigDecimal)
-    transparent inline def toInt: Int = x.intValue
-    transparent inline def toLong: Long = x.longValue
-    transparent inline def toFloat: Float = x.floatValue
-    transparent inline def toDouble: Double = x.doubleValue
-
-given BigDecimalIsInlineFractional: BigDecimalIsConflicted with InlineFractional[BigDecimal] with
-  transparent inline def div(inline x: BigDecimal, inline y: BigDecimal): BigDecimal = x / y
-  protected transparent inline def isNaN(inline x: BigDecimal): Boolean = false
-  protected transparent inline def isNegZero(inline x: BigDecimal): Boolean = false
-
-
-given BigDecimalAsIfInlineIntegral: BigDecimalIsConflicted with InlineIntegral[BigDecimal] with
-  transparent inline def quot(inline x: BigDecimal, inline y: BigDecimal): BigDecimal = x quot y
-  transparent inline def rem(inline x: BigDecimal, inline y: BigDecimal): BigDecimal = x remainder y
-
-object tests:
-  // A generic inline operation that inlines/specializes primitive operations
-  inline def foo[T: InlineNumeric](inline a: T, inline b: T) =
-    a + b * b
-
-  inline def div[T: InlineIntegral](inline a: T, inline b: T) =
-    a / b % b
-
-  inline def div[T: InlineFractional](inline a: T, inline b: T) =
-    a / b + a
-
-  inline def toInt[T: InlineNumeric](inline a: T) =
-    a.toInt
-
-  inline def explicitToInt[T](inline a: T)(using n: InlineNumeric[T]) =
-    n.toInt(a)
-
-  inline def sign[T: InlineNumeric](inline a: T) =
-    a.sign
-
-  inline def explicitPlus[T](inline a: T, inline b: T)(using n: InlineNumeric[T]) =
-    n.plus(a, b)
-
-  def test(a: Int, b: Int) =
-    val v1 = foo(a, b) // should be a + b * b // can check with -Xprint:inlining
-    val v2 = foo(a.toShort, b.toShort) // should be a + b * b
-
-    val v3 = div(BigDecimal(a), BigDecimal(b))(using BigDecimalAsIfInlineIntegral) // should be BigDecimal(a) quot BigDecimal(b) remainder BigDecimal(b)
-    val v4 = div(BigDecimal(a), BigDecimal(b))(using BigDecimalIsInlineFractional) // should be BigDecimal(a) / BigDecimal(b) + BigDecimal(a)
-
-    val v5 = toInt(a.toFloat) // should be a.toFloat.toInt
-    val v6 = toInt(a) // should be a
-
-    val v7 = sign(a)
-    val v8 = sign(a.toChar)
-    val v9 = sign(-7F)
-
-    val v10 = sign(BigDecimal(a))(using BigDecimalAsIfInlineIntegral)
-    val v11 = sign(BigDecimal(a))(using BigDecimalIsInlineFractional) // the condition with isNan() should be removed, i.e. it should be equivalent to v10
-
-    val v12 = explicitPlus(3, 5) // should be 8
-    val v13 = explicitPlus(a, b) // should be a + b
-
-    val v14 = explicitToInt(3.2) // should be (3.2).toInt
-    val v15 = explicitToInt(3) // should be 3
-    val v16 = explicitToInt(a) // should be a
-    val v17 = explicitToInt(a.toShort) // should be a.toShort.toInt
\ No newline at end of file
diff --git a/InlineNumeric.scala b/InlineNumeric.scala
deleted file mode 100644
index 265343dfc793..000000000000
--- a/InlineNumeric.scala
+++ /dev/null
@@ -1,251 +0,0 @@
-// community-build/community-projects/stdLib213/src/library/scala/math/Numeric.scala
-// community-build/community-projects/stdLib213/src/library/scala/math/Integral.scala
-// community-build/community-projects/stdLib213/src/library/scala/math/Fractional.scala
-
-import scala.util.Try
-
-trait InlineNumeric[T] extends Ordering[T]: // extends Numeric[T] // TODO can we do this?
-  transparent inline def plus(inline x: T, inline y: T): T
-  transparent inline def minus(inline x: T, inline y: T): T
-  transparent inline def times(inline x: T, inline y: T): T
-  transparent inline def negate(inline x: T): T
-  transparent inline def fromInt(inline x: Int): T
-  transparent inline def parseString(inline str: String): Option[T]
-  transparent inline def toInt(inline x: T): Int
-  transparent inline def toLong(inline x: T): Long
-  transparent inline def toFloat(inline x: T): Float
-  transparent inline def toDouble(inline x: T): Double
-  transparent inline def abs(inline x: T): T
-  transparent inline def sign(inline x: T): T
-
-  transparent inline def zero = fromInt(0)
-  transparent inline def one = fromInt(1)
-
-object InlineNumeric:
-  extension [T](inline x: T)(using inline num: InlineNumeric[T])
-    transparent inline def +(inline y: T): T = num.plus(x, y)
-    transparent inline def -(inline y: T) = num.minus(x, y)
-    transparent inline def *(inline y: T): T = num.times(x, y)
-    transparent inline def unary_- = num.negate(x)
-    transparent inline def toInt: Int = num.toInt(x)
-    transparent inline def toLong: Long = num.toLong(x)
-    transparent inline def toFloat: Float = num.toFloat(x)
-    transparent inline def toDouble: Double = num.toDouble(x)
-    transparent inline def abs: T = num.abs(x)
-    transparent inline def sign: T = num.sign(x)
-
-trait InlineIntegral[T] extends InlineNumeric[T]:
-  transparent inline def abs(inline x: T): T = if lt(x, zero) then negate(x) else x
-  transparent inline def sign(inline x: T): T =
-    if lt(x, zero) then negate(one)
-    else if gt(x, zero) then one
-    else zero
-
-  transparent inline def quot(inline x: T, inline y: T): T
-  transparent inline def rem(inline x: T, inline y: T): T
-
-object InlineIntegral:
-  // TODO: how are these imported/composed with Numeric/Integral. Should the extension methods be defined in trait InlineIntegral?
-  extension [T](inline lhs: T)(using inline int: InlineIntegral[T])
-    transparent inline def /(inline rhs: T) = int.quot(lhs, rhs)
-    transparent inline def %(inline rhs: T) = int.rem(lhs, rhs)
-    transparent inline def /%(inline rhs: T) = (int.quot(lhs, rhs), int.rem(lhs, rhs))
-
-trait InlineFractional[T] extends InlineNumeric[T]:
-  transparent inline def abs(inline x: T): T = if lt(x, zero) || isNegZero(x) then negate(x) else x
-  transparent inline def sign(inline x: T): T =
-    if isNaN(x) || isNegZero(x) then x
-    else if lt(x, zero) then negate(one)
-    else if gt(x, zero) then one
-    else zero
-
-  transparent inline def div(inline x: T, inline y: T): T
-  protected transparent inline def isNaN(inline x: T): Boolean
-  protected transparent inline def isNegZero(inline x: T): Boolean
-
-object InlineFractional:
-  // TODO: how are these imported/composed with Numeric/Fractional. Should the extension methods be defined in trait InlineFractional?
-  extension [T](inline lhs: T)(using inline frac: InlineFractional[T])
-    transparent inline def /(inline rhs: T) = frac.div(lhs, rhs)
-
-given IntIsInlineIntegral: InlineIntegral[Int] with Ordering.IntOrdering with
-  transparent inline def plus(inline x: Int, inline y: Int): Int = x + y
-  transparent inline def minus(inline x: Int, inline y: Int): Int = x - y
-  transparent inline def times(inline x: Int, inline y: Int): Int = x * y
-  transparent inline def negate(inline x: Int): Int = -x
-  transparent inline def fromInt(inline x: Int): Int = x
-  transparent inline def parseString(inline str: String): Option[Int] = str.toIntOption
-  transparent inline def toInt(inline x: Int): Int = x
-  transparent inline def toLong(inline x: Int): Long = x.toLong
-  transparent inline def toFloat(inline x: Int): Float = x.toFloat
-  transparent inline def toDouble(inline x: Int): Double = x.toDouble
-
-  transparent inline def quot(inline x: Int, inline y: Int): Int = x / y
-  transparent inline def rem(inline x: Int, inline y: Int): Int = x % y
-
-given BigIntIsInlineIntegral: InlineIntegral[BigInt] with Ordering.BigIntOrdering with
-  transparent inline def plus(inline x: BigInt, inline y: BigInt): BigInt = x + y
-  transparent inline def minus(inline x: BigInt, inline y: BigInt): BigInt = x - y
-  transparent inline def times(inline x: BigInt, inline y: BigInt): BigInt = x * y
-  transparent inline def negate(inline x: BigInt): BigInt = -x
-  transparent inline def fromInt(inline x: Int): BigInt = BigInt(x)
-  transparent inline def parseString(inline str: String): Option[BigInt] = Try(BigInt(str)).toOption
-  transparent inline def toInt(inline x: BigInt): Int = x.intValue
-  transparent inline def toLong(inline x: BigInt): Long = x.longValue
-  transparent inline def toFloat(inline x: BigInt): Float = x.floatValue
-  transparent inline def toDouble(inline x: BigInt): Double = x.doubleValue
-
-  transparent inline def quot(inline x: BigInt, inline y: BigInt): BigInt = x / y
-  transparent inline def rem(inline x: BigInt, inline y: BigInt): BigInt = x % y
-
-given ShortIsInlineIntegral: InlineIntegral[Short] with Ordering.ShortOrdering with
-  transparent inline def plus(inline x: Short, inline y: Short): Short = (x + y).toShort
-  transparent inline def minus(inline x: Short, inline y: Short): Short = (x - y).toShort
-  transparent inline def times(inline x: Short, inline y: Short): Short = (x * y).toShort
-  transparent inline def negate(inline x: Short): Short = (-x).toShort
-  transparent inline def fromInt(inline x: Int): Short = x.toShort
-  transparent inline def parseString(inline str: String): Option[Short] = str.toShortOption
-  transparent inline def toInt(inline x: Short): Int = x.toInt
-  transparent inline def toLong(inline x: Short): Long = x.toLong
-  transparent inline def toFloat(inline x: Short): Float = x.toFloat
-  transparent inline def toDouble(inline x: Short): Double = x.toDouble
-
-  transparent inline def quot(inline x: Short, inline y: Short): Short = (x / y).toShort
-  transparent inline def rem(inline x: Short, inline y: Short): Short = (x % y).toShort
-
-given ByteIsInlineIntegral: InlineIntegral[Byte] with Ordering.ByteOrdering with
-  transparent inline def plus(inline x: Byte, inline y: Byte): Byte = (x + y).toByte
-  transparent inline def minus(inline x: Byte, inline y: Byte): Byte = (x - y).toByte
-  transparent inline def times(inline x: Byte, inline y: Byte): Byte = (x * y).toByte
-  transparent inline def negate(inline x: Byte): Byte = (-x).toByte
-  transparent inline def fromInt(inline x: Int): Byte = x.toByte
-  transparent inline def parseString(inline str: String): Option[Byte] = str.toByteOption
-  transparent inline def toInt(inline x: Byte): Int = x.toInt
-  transparent inline def toLong(inline x: Byte): Long = x.toLong
-  transparent inline def toFloat(inline x: Byte): Float = x.toFloat
-  transparent inline def toDouble(inline x: Byte): Double = x.toDouble
-
-  transparent inline def quot(inline x: Byte, inline y: Byte): Byte = (x / y).toByte
-  transparent inline def rem(inline x: Byte, inline y: Byte): Byte = (x % y).toByte
-
-given CharIsInlineIntegral: InlineIntegral[Char] with Ordering.CharOrdering with
-  transparent inline def plus(inline x: Char, inline y: Char): Char = (x + y).toChar
-  transparent inline def minus(inline x: Char, inline y: Char): Char = (x - y).toChar
-  transparent inline def times(inline x: Char, inline y: Char): Char = (x * y).toChar
-  transparent inline def negate(inline x: Char): Char = (-x).toChar
-  transparent inline def fromInt(inline x: Int): Char = x.toChar
-  transparent inline def parseString(inline str: String): Option[Char] = Try(str.toInt.toChar).toOption
-  transparent inline def toInt(inline x: Char): Int = x.toInt
-  transparent inline def toLong(inline x: Char): Long = x.toLong
-  transparent inline def toFloat(inline x: Char): Float = x.toFloat
-  transparent inline def toDouble(inline x: Char): Double = x.toDouble
-
-  transparent inline def quot(inline x: Char, inline y: Char): Char = (x / y).toChar
-  transparent inline def rem(inline x: Char, inline y: Char): Char = (x % y).toChar
-
-given LongIsInlineIntegral: InlineIntegral[Long] with Ordering.LongOrdering with
-  transparent inline def plus(inline x: Long, inline y: Long): Long = x + y
-  transparent inline def minus(inline x: Long, inline y: Long): Long = x - y
-  transparent inline def times(inline x: Long, inline y: Long): Long = x * y
-  transparent inline def negate(inline x: Long): Long = -x
-  transparent inline def fromInt(inline x: Int): Long = x.toLong
-  transparent inline def parseString(inline str: String): Option[Long] = str.toLongOption
-  transparent inline def toInt(inline x: Long): Int = x.toInt
-  transparent inline def toLong(inline x: Long): Long = x
-  transparent inline def toFloat(inline x: Long): Float = x.toFloat
-  transparent inline def toDouble(inline x: Long): Double = x.toDouble
-
-  transparent inline def quot(inline x: Long, inline y: Long): Long = (x / y).toLong
-  transparent inline def rem(inline x: Long, inline y: Long): Long = (x % y).toLong
-
-given FloatIsInlineFractional: InlineFractional[Float] with Ordering.Float.IeeeOrdering with
-  transparent inline def plus(inline x: Float, inline y: Float): Float = x + y
-  transparent inline def minus(inline x: Float, inline y: Float): Float = x - y
-  transparent inline def times(inline x: Float, inline y: Float): Float = x * y
-  transparent inline def negate(inline x: Float): Float = -x
-  transparent inline def fromInt(inline x: Int): Float = x.toFloat
-  transparent inline def parseString(inline str: String): Option[Float] = str.toFloatOption
-  transparent inline def toInt(inline x: Float): Int = x.toInt
-  transparent inline def toLong(inline x: Float): Long = x.toLong
-  transparent inline def toFloat(inline x: Float): Float = x
-  transparent inline def toDouble(inline x: Float): Double = x.toDouble
-
-  transparent inline def div(inline x: Float, inline y: Float): Float = x / y
-  protected transparent inline def isNaN(inline x: Float): Boolean = x.isNaN
-  protected transparent inline def isNegZero(inline x: Float): Boolean = x.equals(-0f)
-
-given DoubleIsInlineFractional: InlineFractional[Double] with Ordering.Double.IeeeOrdering with
-  transparent inline def plus(inline x: Double, inline y: Double): Double = x + y
-  transparent inline def minus(inline x: Double, inline y: Double): Double = x - y
-  transparent inline def times(inline x: Double, inline y: Double): Double = x * y
-  transparent inline def negate(inline x: Double): Double = -x
-  transparent inline def fromInt(inline x: Int): Double = x.toDouble
-  transparent inline def parseString(inline str: String): Option[Double] = str.toDoubleOption
-  transparent inline def toInt(inline x: Double): Int = x.toInt
-  transparent inline def toLong(inline x: Double): Long = x.toLong
-  transparent inline def toFloat(inline x: Double): Float = x.toFloat
-  transparent inline def toDouble(inline x: Double): Double = x
-
-  transparent inline def div(inline x: Double, inline y: Double): Double = x / y
-  protected transparent inline def isNaN(inline x: Double): Boolean = x.isNaN
-  protected transparent inline def isNegZero(inline x: Double): Boolean = x.equals(-0.0)
-
-trait BigDecimalIsConflicted extends InlineNumeric[BigDecimal] with Ordering.BigDecimalOrdering:
-  transparent inline def plus(inline x: BigDecimal, inline y: BigDecimal): BigDecimal = x + y
-  transparent inline def minus(inline x: BigDecimal, inline y: BigDecimal): BigDecimal = x - y
-  transparent inline def times(inline x: BigDecimal, inline y: BigDecimal): BigDecimal = x * y
-  transparent inline def negate(inline x: BigDecimal): BigDecimal = -x
-  transparent inline def fromInt(inline x: Int): BigDecimal = BigDecimal(x)
-  transparent inline def parseString(inline str: String): Option[BigDecimal] = Try(BigDecimal(str)).toOption
-  transparent inline def toInt(inline x: BigDecimal): Int = x.intValue
-  transparent inline def toLong(inline x: BigDecimal): Long = x.longValue
-  transparent inline def toFloat(inline x: BigDecimal): Float = x.floatValue
-  transparent inline def toDouble(inline x: BigDecimal): Double = x.doubleValue
-
-given BigDecimalIsInlineFractional: BigDecimalIsConflicted with InlineFractional[BigDecimal] with
-  transparent inline def div(inline x: BigDecimal, inline y: BigDecimal): BigDecimal = x / y
-  protected transparent inline def isNaN(inline x: BigDecimal): Boolean = false
-  protected transparent inline def isNegZero(inline x: BigDecimal): Boolean = false
-
-
-given BigDecimalAsIfInlineIntegral: BigDecimalIsConflicted with InlineIntegral[BigDecimal] with
-  transparent inline def quot(inline x: BigDecimal, inline y: BigDecimal): BigDecimal = x quot y
-  transparent inline def rem(inline x: BigDecimal, inline y: BigDecimal): BigDecimal = x remainder y
-
-object tests:
-  import InlineNumeric.*
-  import InlineIntegral.{/ => ¦, %}
-  import InlineFractional.{/}
-
-  // A generic inline operation that inlines/specializes primitive operations
-  inline def foo[T: InlineNumeric](inline a: T, inline b: T) =
-    a + b * b
-
-  inline def div[T: InlineIntegral](inline a: T, inline b: T) =
-    a ¦ b % b
-
-  inline def div[T: InlineFractional](inline a: T, inline b: T) =
-    a / b + a
-
-  inline def bar[T: InlineNumeric](inline a: T) =
-    a.toInt
-
-  inline def sign[T: InlineNumeric](inline a: T) =
-    a.sign
-
-  def test(a: Int, b: Int) =
-    val v1 = foo(a, b) // should be a + b * b // can check with -Xprint:inlining
-    val v2 = foo(a.toShort, b.toShort) // should be a + b * b
-
-    val v3 = div(BigDecimal(a), BigDecimal(b))(using BigDecimalAsIfInlineIntegral) // should be BigDecimal(a) quot BigDecimal(b) remainder BigDecimal(b)
-    val v4 = div(BigDecimal(a), BigDecimal(b))(using BigDecimalIsInlineFractional) // should be BigDecimal(a) / BigDecimal(b) + BigDecimal(a)
-
-    val v5 = bar(a.toFloat) // should be a.toFloat.toInt
-    val v6 = bar(a) // should be a
-
-    val v7 = sign(a)
-    val v8 = sign(a.toChar)
-    val v9 = sign(-7F)
-
-    val v10 = sign(BigDecimal(a))(using BigDecimalAsIfInlineIntegral)
-    val v11 = sign(BigDecimal(a))(using BigDecimalIsInlineFractional) // the condition with isNan() should be removed, i.e. it should be equivalent to v10
\ No newline at end of file
diff --git a/tests/run/inline-numeric/Fractional.scala b/tests/run/inline-numeric/Fractional.scala
new file mode 100644
index 000000000000..a61c60063fd9
--- /dev/null
+++ b/tests/run/inline-numeric/Fractional.scala
@@ -0,0 +1,62 @@
+package scala.math
+package inline
+
+trait Fractional[T] extends Numeric[T]:
+  transparent inline def div(inline x: T, inline y: T): T
+  protected transparent inline def isNaN(inline x: T): Boolean
+  protected transparent inline def isNegZero(inline x: T): Boolean
+
+  extension (inline x: T)
+    transparent inline def abs: T =
+      if lt(x, zero) || isNegZero(x) then negate(x) else x
+    transparent inline def sign: T =
+      if isNaN(x) || isNegZero(x) then x
+      else if lt(x, zero) then negate(one)
+      else if gt(x, zero) then one
+      else zero
+    transparent inline def /(inline y: T) = div(x, y)
+
+object Fractional:
+  given BigDecimalIsFractional: BigDecimalIsConflicted with Fractional[BigDecimal] with
+    transparent inline def div(inline x: BigDecimal, inline y: BigDecimal): BigDecimal = x / y
+
+    protected transparent inline def isNaN(inline x: BigDecimal): Boolean = false
+    protected transparent inline def isNegZero(inline x: BigDecimal): Boolean = false
+
+  given DoubleIsFractional: Fractional[Double] with Ordering.DoubleIeeeOrdering with
+    transparent inline def plus(inline x: Double, inline y: Double): Double = x + y
+    transparent inline def minus(inline x: Double, inline y: Double): Double = x - y
+    transparent inline def times(inline x: Double, inline y: Double): Double = x * y
+    transparent inline def div(inline x: Double, inline y: Double): Double = x / y
+    transparent inline def negate(inline x: Double): Double = -x
+
+    transparent inline def fromInt(x: Int): Double = x.toDouble
+    def parseString(str: String): Option[Double] = str.toDoubleOption
+
+    protected transparent inline def isNaN(inline x: Double): Boolean = x.isNaN
+    protected transparent inline def isNegZero(inline x: Double): Boolean = x.equals(-0.0)
+
+    extension (inline x: Double)
+      transparent inline def toInt: Int = x.toInt
+      transparent inline def toLong: Long = x.toLong
+      transparent inline def toFloat: Float = x.toFloat
+      transparent inline def toDouble: Double = x
+
+  given FloatIsFractional: Fractional[Float] with Ordering.FloatIeeeOrdering with
+    transparent inline def plus(inline x: Float, inline y: Float): Float = x + y
+    transparent inline def minus(inline x: Float, inline y: Float): Float = x - y
+    transparent inline def times(inline x: Float, inline y: Float): Float = x * y
+    transparent inline def div(inline x: Float, inline y: Float): Float = x / y
+    transparent inline def negate(inline x: Float): Float = -x
+
+    transparent inline def fromInt(x: Int): Float = x.toFloat
+    def parseString(str: String): Option[Float] = str.toFloatOption
+
+    protected transparent inline def isNaN(inline x: Float): Boolean = x.isNaN
+    protected transparent inline def isNegZero(inline x: Float): Boolean = x.equals(-0f)
+
+    extension (inline x: Float)
+      transparent inline def toInt: Int = x.toInt
+      transparent inline def toLong: Long = x.toLong
+      transparent inline def toFloat: Float = x
+      transparent inline def toDouble: Double = x.toDouble
\ No newline at end of file
diff --git a/tests/run/inline-numeric/Integral.scala b/tests/run/inline-numeric/Integral.scala
new file mode 100644
index 000000000000..4ef11738113c
--- /dev/null
+++ b/tests/run/inline-numeric/Integral.scala
@@ -0,0 +1,132 @@
+package scala.math
+package inline
+
+import scala.util.Try
+
+trait Integral[T] extends Numeric[T]:
+  inline def quot(inline x: T, inline y: T): T
+  inline def rem(inline x: T, inline y: T): T
+
+  extension (inline x: T)
+    transparent inline def abs: T =
+      if lt(x, zero) then negate(x) else x
+    transparent inline def sign: T =
+      if lt(x, zero) then negate(one)
+      else if gt(x, zero) then one
+      else zero
+    transparent inline def /(inline y: T) = quot(x, y)
+    transparent inline def %(inline y: T) = rem(x, y)
+    transparent inline def /%(inline y: T) = (quot(x, y), rem(x, y))
+
+object Integral:
+  given BigDecimalAsIfIntegral: Integral[BigDecimal] with BigDecimalIsConflicted with
+    transparent inline def quot(inline x: BigDecimal, inline y: BigDecimal): BigDecimal = x quot y
+    transparent inline def rem(inline x: BigDecimal, inline y: BigDecimal): BigDecimal = x remainder y
+
+  given BigIntIsIntegral: Integral[BigInt] with Ordering.BigIntOrdering with
+    transparent inline def plus(inline x: BigInt, inline y: BigInt): BigInt = x + y
+    transparent inline def minus(inline x: BigInt, inline y: BigInt): BigInt = x - y
+    transparent inline def times(inline x: BigInt, inline y: BigInt): BigInt = x * y
+    transparent inline def negate(inline x: BigInt): BigInt = -x
+
+    extension (inline x: BigInt)
+      transparent inline def toInt: Int = x.intValue
+      transparent inline def toLong: Long = x.longValue
+      transparent inline def toFloat: Float = x.floatValue
+      transparent inline def toDouble: Double = x.doubleValue
+
+    transparent inline def fromInt(x: Int): BigInt = BigInt(x)
+    def parseString(str: String): Option[BigInt] = Try(BigInt(str)).toOption
+
+    transparent inline def quot(inline x: BigInt, inline y: BigInt): BigInt = x / y
+    transparent inline def rem(inline x: BigInt, inline y: BigInt): BigInt = x % y
+
+  given ByteIsIntegral: Integral[Byte] with Ordering.ByteOrdering with
+    transparent inline def plus(inline x: Byte, inline y: Byte): Byte = (x + y).toByte
+    transparent inline def minus(inline x: Byte, inline y: Byte): Byte = (x - y).toByte
+    transparent inline def times(inline x: Byte, inline y: Byte): Byte = (x * y).toByte
+    transparent inline def negate(inline x: Byte): Byte = (-x).toByte
+
+    transparent inline def fromInt(x: Int): Byte = x.toByte
+    def parseString(str: String): Option[Byte] = str.toByteOption
+
+    transparent inline def quot(inline x: Byte, inline y: Byte): Byte = (x / y).toByte
+    transparent inline def rem(inline x: Byte, inline y: Byte): Byte = (x % y).toByte
+
+    extension (inline x: Byte)
+      transparent inline def toInt: Int = x.toInt
+      transparent inline def toLong: Long = x.toLong
+      transparent inline def toFloat: Float = x.toFloat
+      transparent inline def toDouble: Double = x.toDouble
+
+  given CharIsIntegral: Integral[Char] with Ordering.CharOrdering with
+    transparent inline def plus(inline x: Char, inline y: Char): Char = (x + y).toChar
+    transparent inline def minus(inline x: Char, inline y: Char): Char = (x - y).toChar
+    transparent inline def times(inline x: Char, inline y: Char): Char = (x * y).toChar
+    transparent inline def negate(inline x: Char): Char = (-x).toChar
+
+    transparent inline def fromInt(x: Int): Char = x.toChar
+    def parseString(str: String): Option[Char] = Try(str.toInt.toChar).toOption
+
+    transparent inline def quot(inline x: Char, inline y: Char): Char = (x / y).toChar
+    transparent inline def rem(inline x: Char, inline y: Char): Char = (x % y).toChar
+
+    extension (inline x: Char)
+      transparent inline def toInt: Int = x.toInt
+      transparent inline def toLong: Long = x.toLong
+      transparent inline def toFloat: Float = x.toFloat
+      transparent inline def toDouble: Double = x.toDouble
+
+  given IntIsIntegral: Integral[Int] with Ordering.IntOrdering with
+    transparent inline def plus(inline x: Int, inline y: Int): Int = x + y
+    transparent inline def minus(inline x: Int, inline y: Int): Int = x - y
+    transparent inline def times(inline x: Int, inline y: Int): Int = x * y
+    transparent inline def negate(inline x: Int): Int = -x
+
+    transparent inline def fromInt(x: Int): Int = x
+    def parseString(str: String): Option[Int] = str.toIntOption
+
+    transparent inline def quot(inline x: Int, inline y: Int): Int = x / y
+    transparent inline def rem(inline x: Int, inline y: Int): Int = x % y
+
+    extension (inline x: Int)
+      transparent inline def toInt: Int = x
+      transparent inline def toLong: Long = x.toLong
+      transparent inline def toFloat: Float = x.toFloat
+      transparent inline def toDouble: Double = x.toDouble
+
+  given LongIsIntegral: Integral[Long] with Ordering.LongOrdering with
+    transparent inline def plus(inline x: Long, inline y: Long): Long = x + y
+    transparent inline def minus(inline x: Long, inline y: Long): Long = x - y
+    transparent inline def times(inline x: Long, inline y: Long): Long = x * y
+    transparent inline def negate(inline x: Long): Long = -x
+
+    transparent inline def fromInt(x: Int): Long = x.toLong
+    def parseString(str: String): Option[Long] = str.toLongOption
+
+    transparent inline def quot(inline x: Long, inline y: Long): Long = (x / y).toLong
+    transparent inline def rem(inline x: Long, inline y: Long): Long = (x % y).toLong
+
+    extension (inline x: Long)
+      transparent inline def toInt: Int = x.toInt
+      transparent inline def toLong: Long = x
+      transparent inline def toFloat: Float = x.toFloat
+      transparent inline def toDouble: Double = x.toDouble
+
+  given ShortIsIntegral: Integral[Short] with Ordering.ShortOrdering with
+    transparent inline def plus(inline x: Short, inline y: Short): Short = (x + y).toShort
+    transparent inline def minus(inline x: Short, inline y: Short): Short = (x - y).toShort
+    transparent inline def times(inline x: Short, inline y: Short): Short = (x * y).toShort
+    transparent inline def negate(inline x: Short): Short = (-x).toShort
+
+    transparent inline def fromInt(x: Int): Short = x.toShort
+    def parseString(str: String): Option[Short] = str.toShortOption
+
+    transparent inline def quot(inline x: Short, inline y: Short): Short = (x / y).toShort
+    transparent inline def rem(inline x: Short, inline y: Short): Short = (x % y).toShort
+
+    extension (inline x: Short)
+      transparent inline def toInt: Int = x.toInt
+      transparent inline def toLong: Long = x.toLong
+      transparent inline def toFloat: Float = x.toFloat
+      transparent inline def toDouble: Double = x.toDouble
\ No newline at end of file
diff --git a/tests/run/inline-numeric/Numeric.scala b/tests/run/inline-numeric/Numeric.scala
new file mode 100644
index 000000000000..2ab4e5cf5db0
--- /dev/null
+++ b/tests/run/inline-numeric/Numeric.scala
@@ -0,0 +1,43 @@
+package scala.math
+package inline
+
+import scala.util.Try
+
+trait Numeric[T] extends Ordering[T]:
+  inline def plus(inline x: T, inline y: T): T
+  inline def minus(inline x: T, inline y: T): T
+  inline def times(inline x: T, inline y: T): T
+  inline def negate(inline x: T): T
+
+  def fromInt(x: Int): T
+  def parseString(str: String): Option[T]
+
+  transparent inline def zero = fromInt(0)
+  transparent inline def one = fromInt(1)
+
+  extension (inline x: T)
+    transparent inline def +(inline y: T): T = plus(x, y)
+    transparent inline def -(inline y: T) = minus(x, y)
+    transparent inline def *(inline y: T): T = times(x, y)
+    transparent inline def unary_- = negate(x)
+    inline def toInt: Int
+    inline def toLong: Long
+    inline def toFloat: Float
+    inline def toDouble: Double
+    inline def abs: T
+    inline def sign: T
+
+trait BigDecimalIsConflicted extends Numeric[BigDecimal] with Ordering.BigDecimalOrdering:
+  transparent inline def plus(inline x: BigDecimal, inline y: BigDecimal): BigDecimal = x + y
+  transparent inline def minus(inline x: BigDecimal, inline y: BigDecimal): BigDecimal = x - y
+  transparent inline def times(inline x: BigDecimal, inline y: BigDecimal): BigDecimal = x * y
+  transparent inline def negate(inline x: BigDecimal): BigDecimal = -x
+
+  transparent inline def fromInt(x: Int): BigDecimal = BigDecimal(x)
+  def parseString(str: String): Option[BigDecimal] = Try(BigDecimal(str)).toOption
+
+  extension (inline x: BigDecimal)
+    transparent inline def toInt: Int = x.intValue
+    transparent inline def toLong: Long = x.longValue
+    transparent inline def toFloat: Float = x.floatValue
+    transparent inline def toDouble: Double = x.doubleValue
\ No newline at end of file
diff --git a/tests/run/inline-numeric/Ordering.scala b/tests/run/inline-numeric/Ordering.scala
new file mode 100644
index 000000000000..9be3377b8dc4
--- /dev/null
+++ b/tests/run/inline-numeric/Ordering.scala
@@ -0,0 +1,56 @@
+package scala.math
+package inline
+
+import java.util.Comparator
+
+trait Ordering[T] extends Comparator[T] with PartialOrdering[T] with Serializable:
+  outer =>
+
+  inline def tryCompare(x: T, y: T) = Some(compare(x, y))
+
+  def compare(x: T, y: T): Int
+
+  override inline def lteq(x: T, y: T): Boolean = compare(x, y) <= 0
+  override inline def gteq(x: T, y: T): Boolean = compare(x, y) >= 0
+  override inline def lt(x: T, y: T): Boolean = compare(x, y) < 0
+  override inline def gt(x: T, y: T): Boolean = compare(x, y) > 0
+  override inline def equiv(x: T, y: T): Boolean = compare(x, y) == 0
+
+  inline def max(x: T, y: T): T = if gteq(x, y) then x else y
+  inline def min(x: T, y: T): T = if lteq(x, y) then x else y
+
+  // This is made into a separate trait, because defining the reverse ordering
+  // anonymously results in an error:
+  //   Implementation restriction: nested inline methods are not supported
+  inline def on[U](f: U => T): Ordering[U] = new ReverseOrdering(f) {}
+
+  private trait ReverseOrdering[U](f: U => T) extends Ordering[U]:
+    inline def compare(x: U, y: U) = outer.compare(f(x), f(y))
+
+object Ordering:
+  trait BigDecimalOrdering extends Ordering[BigDecimal]:
+    inline def compare(x: BigDecimal, y: BigDecimal) = x.compare(y)
+
+  trait BigIntOrdering extends Ordering[BigInt]:
+    inline def compare(x: BigInt, y: BigInt) = x.compare(y)
+
+  trait ByteOrdering extends Ordering[Byte]:
+    inline def compare(x: Byte, y: Byte) = java.lang.Byte.compare(x, y)
+
+  trait CharOrdering extends Ordering[Char]:
+    inline def compare(x: Char, y: Char) = java.lang.Character.compare(x, y)
+
+  trait IntOrdering extends Ordering[Int]:
+    inline def compare(x: Int, y: Int) = java.lang.Integer.compare(x, y)
+
+  trait LongOrdering extends Ordering[Long]:
+    inline def compare(x: Long, y: Long) = java.lang.Long.compare(x, y)
+
+  trait ShortOrdering extends Ordering[Short]:
+    inline def compare(x: Short, y: Short) = java.lang.Short.compare(x, y)
+
+  trait FloatIeeeOrdering extends Ordering[Float]:
+    inline def compare(x: Float, y: Float) = java.lang.Float.compare(x, y)
+
+  trait DoubleIeeeOrdering extends Ordering[Double]:
+    inline def compare(x: Double, y: Double) = java.lang.Double.compare(x, y)
\ No newline at end of file
diff --git a/tests/run/inline-numeric/test.scala b/tests/run/inline-numeric/test.scala
new file mode 100644
index 000000000000..deab452bcce8
--- /dev/null
+++ b/tests/run/inline-numeric/test.scala
@@ -0,0 +1,54 @@
+import scala.math.inline.*
+import scala.math.inline.Ordering.*
+import scala.math.inline.Integral.given
+import scala.math.inline.Fractional.given
+
+object tests:
+  inline def foo[T: Numeric](inline a: T, inline b: T) =
+    a + b * b
+
+  inline def div[T: Integral](inline a: T, inline b: T) =
+    a / b % b
+
+  inline def div[T: Fractional](inline a: T, inline b: T) =
+    a / b + a
+
+  inline def toInt[T: Numeric](inline a: T) =
+    a.toInt
+
+  inline def explicitToInt[T](inline a: T)(using n: Numeric[T]) =
+    n.toInt(a)
+
+  inline def sign[T: Numeric](inline a: T) =
+    a.sign
+
+  inline def explicitPlus[T](inline a: T, inline b: T)(using n: Numeric[T]) =
+    n.plus(a, b)
+
+  @main def Test =
+    def a: Int = 0
+    def b: Int = 1
+
+    val v1 = foo(a, b) // should be a + b * b // can check with -Xprint:inlining
+    val v2 = foo(a.toShort, b.toShort) // should be a + b * b
+
+    val v3 = div(BigDecimal(a), BigDecimal(b))(using BigDecimalAsIfIntegral) // should be BigDecimal(a) quot BigDecimal(b) remainder BigDecimal(b)
+    val v4 = div(BigDecimal(a), BigDecimal(b))(using BigDecimalIsFractional) // should be BigDecimal(a) / BigDecimal(b) + BigDecimal(a)
+
+    val v5 = toInt(a.toFloat) // should be a.toFloat.toInt
+    val v6 = toInt(a) // should be a
+
+    val v7 = sign(a)
+    val v8 = sign(a.toChar)
+    val v9 = sign(-7F)
+
+    val v10 = sign(BigDecimal(a))(using BigDecimalAsIfIntegral)
+    val v11 = sign(BigDecimal(a))(using BigDecimalIsFractional) // the condition with isNan() should be removed, i.e. it should be equivalent to v10
+
+    val v12 = explicitPlus(3, 5) // should be 8
+    val v13 = explicitPlus(a, b) // should be a + b
+
+    val v14 = explicitToInt(3.2) // should be (3.2).toInt
+    val v15 = explicitToInt(3) // should be 3
+    val v16 = explicitToInt(a) // should be a
+    val v17 = explicitToInt(a.toShort) // should be a.toShort.toInt
\ No newline at end of file

From 0dea6c0681d632f66689eae8ee126a1910cf7ecd Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Tue, 14 Mar 2023 11:09:49 +0000
Subject: [PATCH 280/657] Fail the Java protected member case, rather than be
 wierd

---
 .../tools/dotc/transform/ProtectedAccessors.scala  | 14 ++++++++++----
 .../tools/dotc/transform/SuperAccessors.scala      | 13 +++++++++++--
 tests/neg/i17021.ext-java/A.java                   |  6 ++++++
 tests/neg/i17021.ext-java/Test.scala               | 14 ++++++++++++++
 tests/run/i17021.ext-java/Test.scala               |  6 +++---
 5 files changed, 44 insertions(+), 9 deletions(-)
 create mode 100644 tests/neg/i17021.ext-java/A.java
 create mode 100644 tests/neg/i17021.ext-java/Test.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/ProtectedAccessors.scala b/compiler/src/dotty/tools/dotc/transform/ProtectedAccessors.scala
index 2b150d321812..6d8f7bdb32cb 100644
--- a/compiler/src/dotty/tools/dotc/transform/ProtectedAccessors.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ProtectedAccessors.scala
@@ -33,12 +33,18 @@ object ProtectedAccessors {
       ctx.owner.isContainedIn(boundary) || ctx.owner.isContainedIn(boundary.linkedClass)
     }
 
-  /** Do we need a protected accessor for accessing sym from the current context's owner? */
-  def needsAccessor(sym: Symbol)(using Context): Boolean =
+  /** 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) &&
-    (sym.is(JavaDefined) || !ctx.owner.enclosingClass.derivesFrom(sym.owner))
+    !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 {
diff --git a/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala b/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala
index 5d7210a59a96..b78c75d58340 100644
--- a/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala
+++ b/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala
@@ -175,7 +175,7 @@ class SuperAccessors(thisPhase: DenotTransformer) {
     val sym = sel.symbol
 
     def needsSuperAccessor =
-      ProtectedAccessors.needsAccessor(sym) &&
+      ProtectedAccessors.needsAccessorIfNotInSubclass(sym) &&
       AccessProxies.hostForAccessorOf(sym).is(Trait)
     qual match {
       case _: This if needsSuperAccessor =>
@@ -185,10 +185,19 @@ class SuperAccessors(thisPhase: DenotTransformer) {
          * If T extends C, then we can access it by casting
          * the qualifier of the select to C.
          *
+         * That's because the protected method is actually public,
+         * so we can call it.  For truly protected methods, like from
+         * Java, we error instead of emitting the wrong code (i17021.ext-java).
+         *
          * Otherwise, we need to go through an accessor,
          * which the implementing class will provide an implementation for.
          */
-        superAccessorCall(sel)
+        if ctx.owner.enclosingClass.derivesFrom(sym.owner) 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
+        else
+          superAccessorCall(sel)
       case Super(_, mix) =>
         transformSuperSelect(sel)
       case _ =>
diff --git a/tests/neg/i17021.ext-java/A.java b/tests/neg/i17021.ext-java/A.java
new file mode 100644
index 000000000000..536e9caa4a38
--- /dev/null
+++ b/tests/neg/i17021.ext-java/A.java
@@ -0,0 +1,6 @@
+// Derives from run/i17021.defs, but with a Java protected member
+package p1;
+
+public class A {
+  protected int foo() { return 1; }
+}
diff --git a/tests/neg/i17021.ext-java/Test.scala b/tests/neg/i17021.ext-java/Test.scala
new file mode 100644
index 000000000000..c700ed8138d7
--- /dev/null
+++ b/tests/neg/i17021.ext-java/Test.scala
@@ -0,0 +1,14 @@
+// Derives from run/i17021.defs
+// but with a Java protected member
+// which leads to a compile error
+package p2:
+  trait B extends p1.A:
+    def bar: Int = foo // error: method bar accesses protected method foo inside a concrete trait method: use super.foo instead
+
+  class C extends B:
+    override def foo: Int = 2
+
+object Test:
+  def main(args: Array[String]): Unit =
+    val n = new p2.C().bar
+    assert(n == 2, n)
diff --git a/tests/run/i17021.ext-java/Test.scala b/tests/run/i17021.ext-java/Test.scala
index 80dbca9fdd5d..3741fa2dfadb 100644
--- a/tests/run/i17021.ext-java/Test.scala
+++ b/tests/run/i17021.ext-java/Test.scala
@@ -1,9 +1,9 @@
 // Derives from run/i17021.defs
 // but with a Java protected member
-// which changes the behaviour
+// and fixed calling code, that uses super
 package p2:
   trait B extends p1.A:
-    def bar: Int = foo
+    def bar: Int = super.foo
 
   class C extends B:
     override def foo: Int = 2
@@ -11,4 +11,4 @@ package p2:
 object Test:
   def main(args: Array[String]): Unit =
     val n = new p2.C().bar
-    assert(n == 1, n) // B can only call super.foo
+    assert(n == 1, n)

From 61165cca968ca28da834c3a47138530decd02a2b Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 14 Mar 2023 12:17:13 +0100
Subject: [PATCH 281/657] Update
 compiler/src/dotty/tools/dotc/staging/HealType.scala

Co-authored-by: Natsu Kagami <natsukagami@gmail.com>
---
 compiler/src/dotty/tools/dotc/staging/HealType.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/staging/HealType.scala b/compiler/src/dotty/tools/dotc/staging/HealType.scala
index 645bde42eb29..44843dfa91ca 100644
--- a/compiler/src/dotty/tools/dotc/staging/HealType.scala
+++ b/compiler/src/dotty/tools/dotc/staging/HealType.scala
@@ -66,7 +66,7 @@ class HealType(pos: SrcPos)(using Context) extends TypeMap {
   /** 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`.
+   *  Emits an error if `T` cannot be healed and returns `T`.
    */
   protected def tryHeal(sym: Symbol, tp: TypeRef, pos: SrcPos): TypeRef = {
     val reqType = defn.QuotedTypeClass.typeRef.appliedTo(tp)

From e9d87184cdbd40516f6bb2844c484bd6d12ce1e3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Timoth=C3=A9e=20Andres?= <andres.timothee@gmail.com>
Date: Tue, 14 Mar 2023 13:45:45 +0100
Subject: [PATCH 282/657] Add newlines at end of test files

---
 tests/run/inline-numeric/Fractional.scala | 2 +-
 tests/run/inline-numeric/Integral.scala   | 2 +-
 tests/run/inline-numeric/Numeric.scala    | 2 +-
 tests/run/inline-numeric/Ordering.scala   | 2 +-
 tests/run/inline-numeric/test.scala       | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/tests/run/inline-numeric/Fractional.scala b/tests/run/inline-numeric/Fractional.scala
index a61c60063fd9..f1bc81246a43 100644
--- a/tests/run/inline-numeric/Fractional.scala
+++ b/tests/run/inline-numeric/Fractional.scala
@@ -59,4 +59,4 @@ object Fractional:
       transparent inline def toInt: Int = x.toInt
       transparent inline def toLong: Long = x.toLong
       transparent inline def toFloat: Float = x
-      transparent inline def toDouble: Double = x.toDouble
\ No newline at end of file
+      transparent inline def toDouble: Double = x.toDouble
diff --git a/tests/run/inline-numeric/Integral.scala b/tests/run/inline-numeric/Integral.scala
index 4ef11738113c..1a740a3e1d99 100644
--- a/tests/run/inline-numeric/Integral.scala
+++ b/tests/run/inline-numeric/Integral.scala
@@ -129,4 +129,4 @@ object Integral:
       transparent inline def toInt: Int = x.toInt
       transparent inline def toLong: Long = x.toLong
       transparent inline def toFloat: Float = x.toFloat
-      transparent inline def toDouble: Double = x.toDouble
\ No newline at end of file
+      transparent inline def toDouble: Double = x.toDouble
diff --git a/tests/run/inline-numeric/Numeric.scala b/tests/run/inline-numeric/Numeric.scala
index 2ab4e5cf5db0..99b46b05aa9d 100644
--- a/tests/run/inline-numeric/Numeric.scala
+++ b/tests/run/inline-numeric/Numeric.scala
@@ -40,4 +40,4 @@ trait BigDecimalIsConflicted extends Numeric[BigDecimal] with Ordering.BigDecima
     transparent inline def toInt: Int = x.intValue
     transparent inline def toLong: Long = x.longValue
     transparent inline def toFloat: Float = x.floatValue
-    transparent inline def toDouble: Double = x.doubleValue
\ No newline at end of file
+    transparent inline def toDouble: Double = x.doubleValue
diff --git a/tests/run/inline-numeric/Ordering.scala b/tests/run/inline-numeric/Ordering.scala
index 9be3377b8dc4..714fa51b1226 100644
--- a/tests/run/inline-numeric/Ordering.scala
+++ b/tests/run/inline-numeric/Ordering.scala
@@ -53,4 +53,4 @@ object Ordering:
     inline def compare(x: Float, y: Float) = java.lang.Float.compare(x, y)
 
   trait DoubleIeeeOrdering extends Ordering[Double]:
-    inline def compare(x: Double, y: Double) = java.lang.Double.compare(x, y)
\ No newline at end of file
+    inline def compare(x: Double, y: Double) = java.lang.Double.compare(x, y)
diff --git a/tests/run/inline-numeric/test.scala b/tests/run/inline-numeric/test.scala
index deab452bcce8..9ca88aee0374 100644
--- a/tests/run/inline-numeric/test.scala
+++ b/tests/run/inline-numeric/test.scala
@@ -51,4 +51,4 @@ object tests:
     val v14 = explicitToInt(3.2) // should be (3.2).toInt
     val v15 = explicitToInt(3) // should be 3
     val v16 = explicitToInt(a) // should be a
-    val v17 = explicitToInt(a.toShort) // should be a.toShort.toInt
\ No newline at end of file
+    val v17 = explicitToInt(a.toShort) // should be a.toShort.toInt

From fab5e7b53b060ef8140c6801aa62684b515aa95c Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Tue, 14 Mar 2023 15:53:10 +0100
Subject: [PATCH 283/657] Fix for formatting and traverse call of inlined tree
 in wunused

---
 .../src/dotty/tools/dotc/transform/CheckUnused.scala | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index 66b0876668be..35153dbf66e9 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -1,7 +1,7 @@
 package dotty.tools.dotc.transform
 
 import dotty.tools.dotc.ast.tpd
-import dotty.tools.dotc.ast.tpd.TreeTraverser
+import dotty.tools.dotc.ast.tpd.{Inlined, TreeTraverser}
 import dotty.tools.dotc.ast.untpd
 import dotty.tools.dotc.ast.untpd.ImportSelector
 import dotty.tools.dotc.config.ScalaSettings
@@ -59,6 +59,7 @@ class CheckUnused extends MiniPhase:
   // ========== SETUP ============
 
   override def prepareForUnit(tree: tpd.Tree)(using Context): Context =
+    println(tree)
     val data = UnusedData()
     val fresh = ctx.fresh.setProperty(_key, data)
     fresh
@@ -75,15 +76,16 @@ class CheckUnused extends MiniPhase:
     traverser.traverse(tree)
     ctx
 
+  def prepareForInlined(tree: Inlined)(using Context): Context =
+    traverser.traverse(tree.call)
+    ctx
+
   override def prepareForIdent(tree: tpd.Ident)(using Context): Context =
     if tree.symbol.exists then
       val prefixes = LazyList.iterate(tree.typeOpt.normalizedPrefix)(_.normalizedPrefix).takeWhile(_ != NoType)
         .take(10) // Failsafe for the odd case if there was an infinite cycle
-      for {
-        prefix <- prefixes
-      } {
+      for prefix <- prefixes do
         unusedDataApply(_.registerUsed(prefix.classSymbol, None))
-      }
       unusedDataApply(_.registerUsed(tree.symbol, Some(tree.name)))
     else if tree.hasType then
       unusedDataApply(_.registerUsed(tree.tpe.classSymbol, Some(tree.name)))

From 43725233dc69ceabbcda6d498065949f4cc4f75f Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 7 Mar 2023 14:23:30 +0100
Subject: [PATCH 284/657] Update cross-stage safety nomenclature

Before `3.0` we experimented with the Phase Consistency Principle (PCP)
which was described in [A practical unification of multi-stage
programming and macros](https://dl.acm.org/doi/10.1145/3278122.3278139).
This principle restricted term and types to be used at the same level.

Now, and since `3.0` we use a more general version of cross-stage safety
where types can be used at any level. Lower levels get erased and higher
levels require a given `Type[T]`. The most updated reference is in
[Scalable Metaprogramming in Scala 3](https://github.com/nicolasstucki/nicolasstucki/raw/main/Scalable%20Metaprogramming%20in%20Scala%203.pdf).

We must remove the use of the term PCP to avoid confusion in the current
implementation.
---
 .../tools/dotc/inlines/PrepareInlineable.scala   |  4 ++--
 ...CheckAndHeal.scala => CrossStageSafety.scala} | 10 +++++-----
 .../dotty/tools/dotc/staging/QuoteContext.scala  |  1 -
 .../dotty/tools/dotc/transform/Splicing.scala    |  1 -
 .../src/dotty/tools/dotc/transform/Staging.scala | 12 ++++++------
 .../dotty/tools/dotc/transform/TreeChecker.scala |  2 +-
 docs/_docs/internals/overall-structure.md        |  5 ++++-
 .../dotc/core/StagingContext.scala               |  8 ++++----
 .../dotc/inlines/PrepareInlineable.scala         |  4 ++--
 ...CheckAndHeal.scala => CrossStageSafety.scala} | 16 ++++++++--------
 .../dotc/transform/Splicing.scala                |  4 ++--
 .../dotc/transform/Staging.scala                 | 10 +++++-----
 .../dotc/transform/TreeChecker.scala             |  2 +-
 13 files changed, 40 insertions(+), 39 deletions(-)
 rename compiler/src/dotty/tools/dotc/staging/{PCPCheckAndHeal.scala => CrossStageSafety.scala} (96%)
 rename tests/pos-with-compiler-cc/dotc/transform/{PCPCheckAndHeal.scala => CrossStageSafety.scala} (95%)

diff --git a/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala b/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
index eb1a97ab93c0..7a0d3f61cb33 100644
--- a/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
@@ -18,7 +18,7 @@ import inlines.Inlines
 import NameOps._
 import Annotations._
 import transform.{AccessProxies, Splicer}
-import staging.PCPCheckAndHeal
+import staging.CrossStageSafety
 import transform.SymUtils.*
 import config.Printers.inlining
 import util.Property
@@ -294,7 +294,7 @@ object PrepareInlineable {
           if (code.symbol.flags.is(Inline))
             report.error("Macro cannot be implemented with an `inline` method", code.srcPos)
           Splicer.checkValidMacroBody(code)
-          (new PCPCheckAndHeal).transform(body) // Ignore output, only check PCP
+          (new CrossStageSafety).transform(body) // Ignore output, only check cross-stage safety
         case Block(List(stat), Literal(Constants.Constant(()))) => checkMacro(stat)
         case Block(Nil, expr) => checkMacro(expr)
         case Typed(expr, _) => checkMacro(expr)
diff --git a/compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
similarity index 96%
rename from compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala
rename to compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
index 2a1371d8eb0d..219b428ca8d4 100644
--- a/compiler/src/dotty/tools/dotc/staging/PCPCheckAndHeal.scala
+++ b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
@@ -17,14 +17,14 @@ import dotty.tools.dotc.util.Property
 import dotty.tools.dotc.util.Spans._
 import dotty.tools.dotc.util.SrcPos
 
-/** Checks that the Phase Consistency Principle (PCP) holds and heals types.
+/** Checks that staging level consistency holds and heals staged types .
  *
- *  Local term references are phase consistent if and only if they are used at the same level as their definition.
+ *  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 phase inconsistent type `T` into `summon[Type[T]].Underlying`.
+ *  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.
@@ -43,7 +43,7 @@ import dotty.tools.dotc.util.SrcPos
  *     }
  *
  */
-class PCPCheckAndHeal extends TreeMapWithStages {
+class CrossStageSafety extends TreeMapWithStages {
   import tpd._
 
   private val InAnnotation = Property.Key[Unit]()
@@ -97,7 +97,7 @@ class PCPCheckAndHeal extends TreeMapWithStages {
         super.transform(tree)
     }
 
-  /** Transform quoted trees while maintaining phase correctness */
+  /** Transform quoted trees while maintaining level correctness */
   override protected def transformQuotation(body: Tree, quote: Apply)(using Context): Tree = {
     val taggedTypes = new QuoteTypeTags(quote.span)
 
diff --git a/compiler/src/dotty/tools/dotc/staging/QuoteContext.scala b/compiler/src/dotty/tools/dotc/staging/QuoteContext.scala
index 542e8ecc2b9f..8e25bba7110c 100644
--- a/compiler/src/dotty/tools/dotc/staging/QuoteContext.scala
+++ b/compiler/src/dotty/tools/dotc/staging/QuoteContext.scala
@@ -4,7 +4,6 @@ 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.staging.PCPCheckAndHeal
 import dotty.tools.dotc.staging.StagingLevel.*
 
 object QuoteContext {
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicing.scala b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
index 7ecde9400445..6067a0b4ff96 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicing.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
@@ -21,7 +21,6 @@ import dotty.tools.dotc.core.Names._
 import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.quoted._
 import dotty.tools.dotc.config.ScalaRelease.*
-import dotty.tools.dotc.staging.PCPCheckAndHeal
 import dotty.tools.dotc.staging.QuoteContext.*
 import dotty.tools.dotc.staging.StagingLevel.*
 import dotty.tools.dotc.staging.QuoteTypeTags
diff --git a/compiler/src/dotty/tools/dotc/transform/Staging.scala b/compiler/src/dotty/tools/dotc/transform/Staging.scala
index 5ebfa25eeacd..83b2bcdbcaa6 100644
--- a/compiler/src/dotty/tools/dotc/transform/Staging.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Staging.scala
@@ -12,12 +12,12 @@ import dotty.tools.dotc.util.SrcPos
 import dotty.tools.dotc.transform.SymUtils._
 import dotty.tools.dotc.staging.QuoteContext.*
 import dotty.tools.dotc.staging.StagingLevel.*
-import dotty.tools.dotc.staging.PCPCheckAndHeal
+import dotty.tools.dotc.staging.CrossStageSafety
 import dotty.tools.dotc.staging.HealType
 
-/** Checks that the Phase Consistency Principle (PCP) holds and heals types.
+/** Checks that staging level consistency holds and heals types used in higher levels.
  *
- *  Type healing consists in transforming a phase inconsistent type `T` into `${ implicitly[Type[T]] }`.
+ *  See `CrossStageSafety`
  */
 class Staging extends MacroTransform {
   import tpd._
@@ -32,10 +32,10 @@ class Staging extends MacroTransform {
 
   override def checkPostCondition(tree: Tree)(using Context): Unit =
     if (ctx.phase <= splicingPhase) {
-      // Recheck that PCP holds but do not heal any inconsistent types as they should already have been heald
+      // Recheck that staging level consistency holds but do not heal any inconsistent types as they should already have been heald
       tree match {
         case PackageDef(pid, _) if tree.symbol.owner == defn.RootClass =>
-          val checker = new PCPCheckAndHeal {
+          val checker = new CrossStageSafety {
             override protected def healType(pos: SrcPos)(using Context) = new HealType(pos) {
               override protected def tryHeal(sym: Symbol, tp: TypeRef, pos: SrcPos): TypeRef = {
                 def symStr =
@@ -72,7 +72,7 @@ class Staging extends MacroTransform {
 
   protected def newTransformer(using Context): Transformer = new Transformer {
     override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
-      (new PCPCheckAndHeal).transform(tree)
+      (new CrossStageSafety).transform(tree)
   }
 }
 
diff --git a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
index 05d3ce5679a3..6d904d1f3cc6 100644
--- a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
@@ -513,7 +513,7 @@ object TreeChecker {
             val inliningPhase = ctx.base.inliningPhase
             inliningPhase.exists && ctx.phase.id > inliningPhase.id
           if isAfterInlining then
-            // The staging phase destroys in PCPCheckAndHeal the property that
+            // 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
diff --git a/docs/_docs/internals/overall-structure.md b/docs/_docs/internals/overall-structure.md
index f50ab6bf03a7..5bb43eb946a8 100644
--- a/docs/_docs/internals/overall-structure.md
+++ b/docs/_docs/internals/overall-structure.md
@@ -104,7 +104,6 @@ phases. The current list of phases is specified in class [Compiler] as follows:
     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 Staging) ::            // Check PCP, heal quoted types and expand macros
     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
@@ -112,6 +111,10 @@ phases. The current list of phases is specified in class [Compiler] as follows:
   /** 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
 
diff --git a/tests/pos-with-compiler-cc/dotc/core/StagingContext.scala b/tests/pos-with-compiler-cc/dotc/core/StagingContext.scala
index 9e0bb95394a3..4ca53e02a831 100644
--- a/tests/pos-with-compiler-cc/dotc/core/StagingContext.scala
+++ b/tests/pos-with-compiler-cc/dotc/core/StagingContext.scala
@@ -4,7 +4,7 @@ import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.core.Contexts._
 import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.util.Property
-import dotty.tools.dotc.transform.PCPCheckAndHeal
+import dotty.tools.dotc.transform.CrossStageSafety
 
 object StagingContext {
 
@@ -16,7 +16,7 @@ object StagingContext {
    */
   private val QuotesStack = new Property.Key[List[tpd.Tree]]
 
-  private val TaggedTypes = new Property.Key[PCPCheckAndHeal.QuoteTypeTags]
+  private val TaggedTypes = new Property.Key[CrossStageSafety.QuoteTypeTags]
 
   /** All enclosing calls that are currently inlined, from innermost to outermost. */
   def level(using Context): Int =
@@ -36,10 +36,10 @@ object StagingContext {
   def spliceContext(using Context): Context =
     ctx.fresh.setProperty(QuotationLevel, level - 1)
 
-  def contextWithQuoteTypeTags(taggedTypes: PCPCheckAndHeal.QuoteTypeTags)(using Context) =
+  def contextWithQuoteTypeTags(taggedTypes: CrossStageSafety.QuoteTypeTags)(using Context) =
     ctx.fresh.setProperty(TaggedTypes, taggedTypes)
 
-  def getQuoteTypeTags(using Context): PCPCheckAndHeal.QuoteTypeTags =
+  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.
diff --git a/tests/pos-with-compiler-cc/dotc/inlines/PrepareInlineable.scala b/tests/pos-with-compiler-cc/dotc/inlines/PrepareInlineable.scala
index ecf24ff8264e..9bb0bacd7a78 100644
--- a/tests/pos-with-compiler-cc/dotc/inlines/PrepareInlineable.scala
+++ b/tests/pos-with-compiler-cc/dotc/inlines/PrepareInlineable.scala
@@ -17,7 +17,7 @@ import NameKinds.{InlineAccessorName, UniqueInlineName}
 import inlines.Inlines
 import NameOps._
 import Annotations._
-import transform.{AccessProxies, PCPCheckAndHeal, Splicer}
+import transform.{AccessProxies, CrossStageSafety, Splicer}
 import transform.SymUtils.*
 import config.Printers.inlining
 import util.Property
@@ -294,7 +294,7 @@ object PrepareInlineable {
           if (code.symbol.flags.is(Inline))
             report.error("Macro cannot be implemented with an `inline` method", code.srcPos)
           Splicer.checkValidMacroBody(code)
-          new PCPCheckAndHeal(freshStagingContext).transform(body) // Ignore output, only check PCP
+          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)
diff --git a/tests/pos-with-compiler-cc/dotc/transform/PCPCheckAndHeal.scala b/tests/pos-with-compiler-cc/dotc/transform/CrossStageSafety.scala
similarity index 95%
rename from tests/pos-with-compiler-cc/dotc/transform/PCPCheckAndHeal.scala
rename to tests/pos-with-compiler-cc/dotc/transform/CrossStageSafety.scala
index 90128500374e..ca00c87161ef 100644
--- a/tests/pos-with-compiler-cc/dotc/transform/PCPCheckAndHeal.scala
+++ b/tests/pos-with-compiler-cc/dotc/transform/CrossStageSafety.scala
@@ -22,14 +22,14 @@ import dotty.tools.dotc.util.Property
 
 import scala.annotation.constructorOnly
 
-/** Checks that the Phase Consistency Principle (PCP) holds and heals types.
+/** Checks that staging level consistency holds and heals staged types .
  *
- *  Local term references are phase consistent if and only if they are used at the same level as their definition.
+ *  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 phase inconsistent type `T` into `summon[Type[T]].Underlying`.
+ *  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.
@@ -48,7 +48,7 @@ import scala.annotation.constructorOnly
  *     }
  *
  */
-class PCPCheckAndHeal(@constructorOnly ictx: DetachedContext) extends TreeMapWithStages(ictx), Checking, caps.Pure {
+class CrossStageSafety(@constructorOnly ictx: DetachedContext) extends TreeMapWithStages(ictx), Checking, caps.Pure {
   import tpd._
 
   private val InAnnotation = Property.Key[Unit]()
@@ -96,9 +96,9 @@ class PCPCheckAndHeal(@constructorOnly ictx: DetachedContext) extends TreeMapWit
         super.transform(tree)
     }
 
-  /** Transform quoted trees while maintaining phase correctness */
+  /** Transform quoted trees while maintaining level correctness */
   override protected def transformQuotation(body: Tree, quote: Apply)(using Context): Tree = {
-    val taggedTypes = new PCPCheckAndHeal.QuoteTypeTags(quote.span)
+    val taggedTypes = new CrossStageSafety.QuoteTypeTags(quote.span)
 
     if (ctx.property(InAnnotation).isDefined)
       report.error("Cannot have a quote in an annotation", quote.srcPos)
@@ -215,7 +215,7 @@ class PCPCheckAndHeal(@constructorOnly ictx: DetachedContext) extends TreeMapWit
           mapOver(tp)
   }
 
-  /** Check phase consistency of terms and heal inconsistent type references. */
+  /** 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
@@ -275,7 +275,7 @@ class PCPCheckAndHeal(@constructorOnly ictx: DetachedContext) extends TreeMapWit
 
 }
 
-object PCPCheckAndHeal {
+object CrossStageSafety {
   import tpd._
 
   class QuoteTypeTags(span: Span)(using DetachedContext) extends caps.Pure {
diff --git a/tests/pos-with-compiler-cc/dotc/transform/Splicing.scala b/tests/pos-with-compiler-cc/dotc/transform/Splicing.scala
index df6128d249d2..3a3aa7e89445 100644
--- a/tests/pos-with-compiler-cc/dotc/transform/Splicing.scala
+++ b/tests/pos-with-compiler-cc/dotc/transform/Splicing.scala
@@ -191,7 +191,7 @@ class Splicing extends MacroTransform:
     private var refBindingMap = mutable.Map.empty[Symbol, (Tree, Symbol)]
     /** Reference to the `Quotes` instance of the current level 1 splice */
     private var quotes: Tree | Null = null // TODO: add to the context
-    private var healedTypes: PCPCheckAndHeal.QuoteTypeTags | Null = null // TODO: add to the context
+    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)
@@ -254,7 +254,7 @@ class Splicing extends MacroTransform:
     private def transformLevel0QuoteContent(tree: Tree)(using Context): Tree =
       // transform and collect new healed types
       val old = healedTypes
-      healedTypes = new PCPCheckAndHeal.QuoteTypeTags(tree.span)
+      healedTypes = new CrossStageSafety.QuoteTypeTags(tree.span)
       val tree1 = transform(tree)
       val newHealedTypes = healedTypes.nn.getTypeTags
       healedTypes = old
diff --git a/tests/pos-with-compiler-cc/dotc/transform/Staging.scala b/tests/pos-with-compiler-cc/dotc/transform/Staging.scala
index 12c5c8215cad..c2c6f76cd0fc 100644
--- a/tests/pos-with-compiler-cc/dotc/transform/Staging.scala
+++ b/tests/pos-with-compiler-cc/dotc/transform/Staging.scala
@@ -15,7 +15,7 @@ import dotty.tools.dotc.transform.TreeMapWithStages._
 
 
 
-/** Checks that the Phase Consistency Principle (PCP) holds and heals types.
+/** Checks that staging level consistency holds and heals staged types.
  *
  *  Type healing consists in transforming a phase inconsistent type `T` into `${ implicitly[Type[T]] }`.
  */
@@ -32,12 +32,12 @@ class Staging extends MacroTransform {
 
   override def checkPostCondition(tree: Tree)(using Context): Unit =
     if (ctx.phase <= splicingPhase) {
-      // Recheck that PCP holds but do not heal any inconsistent types as they should already have been heald
+      // 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 PCPCheckAndHeal(stagingCtx) {
-            // !cc! type error is checker is defined as val checker = new PCPCheckAndHeal { ... }
+          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
@@ -72,7 +72,7 @@ class Staging extends MacroTransform {
 
   protected def newTransformer(using Context): Transformer = new Transformer {
     override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
-      new PCPCheckAndHeal(ctx.detach).transform(tree)
+      new CrossStageSafety(ctx.detach).transform(tree)
   }
 }
 
diff --git a/tests/pos-with-compiler-cc/dotc/transform/TreeChecker.scala b/tests/pos-with-compiler-cc/dotc/transform/TreeChecker.scala
index e7607d8e59c6..b0d7fb89985f 100644
--- a/tests/pos-with-compiler-cc/dotc/transform/TreeChecker.scala
+++ b/tests/pos-with-compiler-cc/dotc/transform/TreeChecker.scala
@@ -458,7 +458,7 @@ class TreeChecker extends Phase with SymTransformer {
             val inliningPhase = ctx.base.inliningPhase
             inliningPhase.exists && ctx.phase.id > inliningPhase.id
           if isAfterInlining then
-            // The staging phase destroys in PCPCheckAndHeal the property that
+            // 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

From d8c9714fd81de526d425054fb71fcff7b36c8740 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Wed, 8 Mar 2023 11:07:28 +0100
Subject: [PATCH 285/657] Update macros.md and macro-spec.md

Copy pasted and adapted a bit the contents of chapter 3 of _Scalable Metaprogramming in Scala 3_.

The previous version was based on _A practical unification of multi-stage programming and macros_.
This version was extremely out of date.
---
 .../reference/metaprogramming/macros-spec.md  |  848 ++++++++++---
 .../_docs/reference/metaprogramming/macros.md | 1054 +++++++----------
 .../reference/metaprogramming/staging.md      |    4 +-
 .../metaprogramming/macros-spec.md            |  842 ++++++++++---
 .../TODOreference/metaprogramming/macros.md   | 1028 +++++++---------
 .../TODOreference/metaprogramming/staging.md  |    2 +-
 6 files changed, 2135 insertions(+), 1643 deletions(-)

diff --git a/docs/_docs/reference/metaprogramming/macros-spec.md b/docs/_docs/reference/metaprogramming/macros-spec.md
index d4221365454d..6045354fdbbc 100644
--- a/docs/_docs/reference/metaprogramming/macros-spec.md
+++ b/docs/_docs/reference/metaprogramming/macros-spec.md
@@ -4,251 +4,711 @@ title: "Macros Spec"
 nightlyOf: https://docs.scala-lang.org/scala3/reference/metaprogramming/macros-spec.html
 ---
 
+## Formalization
+
+* Multi-stage programming with generative and analytical macros[^2]
+* Multi-Stage Macro Calculus, Chapter 4 of Scalable Metaprogramming in Scala 3[^1].
+  Contains and extends the calculus of _Multi-stage programming with generative and analytical macros_ with type polymorphism.
+
+## Syntax
+
+The quotation syntax using `'` and `$` was chosen to mimic the string interpolation syntax of Scala.
+Like a string double-quotation, a single-quote block can contain splices.
+However, unlike strings, splices can contain quotes using the same rules.
+
+```scala
+s" Hello $name"           s" Hello ${name}"
+'{ hello($name) }         '{ hello(${name}) }
+${ hello('name) }         ${ hello('{name}) }
+```
+
+### Quotes
+Quotes come in four flavors: quoted identifiers, quoted blocks, quoted block patterns and quoted type patterns.
+Scala 2 used quoted identifiers to represent `Symbol` literals. They were deprecated in Scala 3, allowing to use them for quotation.
+```scala
+SimpleExpr ::= ...
+             |  `'` alphaid                           // quoted identifier
+             |  `'` `{` Block `}`                     // quoted block
+Pattern    ::= ...
+             |  `'` `{` Block `}`                     // quoted block pattern
+             |  `'` `[` Type `]`                      // quoted type pattern
+```
+
+Quoted blocks and quoted block patterns contain an expression equivalent to a normal block of code.
+When entering either of those we track the fact that we are in a quoted block (`inQuoteBlock`) which is used for spliced identifiers.
+When entering a quoted block pattern we additionally track the fact that we are in a quoted pattern (`inQuotePattern`) which is used to distinguish spliced blocks and splice patterns.
+Lastly, the quoted type pattern simply contains a type.
+
+### Splices
+Splices come in three flavors: spliced identifiers, spliced blocks and splice patterns.
+Scala specifies identifiers containing `$` as valid identifiers but reserves them for compiler and standard library use only.
+Unfortunately, many libraries have used such identifiers in Scala~2. Therefore to mitigate the cost of migration, we still support them.
+We work around this by only allowing spliced identifiers[^3] within quoted blocks or quoted block patterns (`inQuoteBlock`).
+Splice blocks and splice patterns can contain an arbitrary block or pattern respectively.
+They are distinguished based on their surrounding quote (`inQuotePattern`), a quote block will contain spliced blocks, and a quote block pattern will contain splice patterns.
+
+```scala
+SimpleExpr ::= ...
+             |  `$` alphaid         if  inQuoteBlock    // spliced identifier
+             |  `$` `{` Block `}`   if !inQuotePattern  // spliced block
+             |  `$` `{` Pattern `}` if  inQuotePattern  // splice pattern
+```
+
+### Quoted Pattern Type Variables
+Quoted pattern type variables in quoted patterns and quoted type patterns do not require additional syntax.
+Any type definition or reference with a name composed of lower cases is assumed to be a pattern type variable definition while typing.
+A backticked type name with lower cases is interpreted as a reference to the type with that name.
+
+
 ## Implementation
 
-### Syntax
-
-Compared to the [Scala 3 reference grammar](../syntax.md)
-there are the following syntax changes:
-```
-SimpleExpr      ::=  ...
-                  |  ‘'’ ‘{’ Block ‘}’
-                  |  ‘'’ ‘[’ Type ‘]’
-                  |  ‘$’ ‘{’ Block ‘}’
-SimpleType      ::=  ...
-                  |  ‘$’ ‘{’ Block ‘}’
-```
-In addition, an identifier `$x` starting with a `$` that appears inside
-a quoted expression or type is treated as a splice `${x}` and a quoted identifier
-`'x` that appears inside a splice is treated as a quote `'{x}`
-
-### Implementation in `scalac`
-
-Quotes and splices are primitive forms in the generated abstract syntax trees.
-Top-level splices are eliminated during macro expansion while typing. On the
-other hand, top-level quotes are eliminated in an expansion phase `PickleQuotes`
-phase (after typing and pickling). PCP checking occurs while preparing the RHS
-of an inline method for top-level splices and in the `Staging` phase (after
-typing and before pickling).
-
-Macro-expansion works outside-in. If the outermost scope is a splice,
-the spliced AST will be evaluated in an interpreter. A call to a
-previously compiled method can be implemented as a reflective call to
-that method. With the restrictions on splices that are currently in
-place that’s all that’s needed. We might allow more interpretation in
-splices in the future, which would allow us to loosen the
-restriction.  Quotes in spliced, interpreted code are kept as they
-are, after splices nested in the quotes are expanded.
-
-If the outermost scope is a quote, we need to generate code that
-constructs the quoted tree at run-time. We implement this by
-serializing the tree as a TASTy structure, which is stored
-in a string literal. At runtime, an unpickler method is called to
-deserialize the string into a tree.
-
-Splices inside quoted code insert the spliced tree as is, after
-expanding any quotes in the spliced code recursively.
+### Run-Time Representation
 
-## Formalization
+The standard library defines the `Quotes` interface which contains all the logic and the abstract classes `Expr` and `Type`.
+The compiler implements the `Quotes` interface and provides the implementation of `Expr` and `Type`.
+
+##### `class Expr`
+Expressions of type `Expr[T]` are represented by the following abstract class:
+```scala
+abstract class Expr[+T] private[scala]
+```
+The only implementation of `Expr` is in the compiler along with the implementation of `Quotes`.
+It is a class that wraps a typed AST and a `Scope` object with no methods of its own.
+The `Scope` object is used to track the current splice scope and detect scope extrusions.
+
+##### `object Expr`
+The companion object of `Expr` contains a few useful static methods;
+the `apply`/`unapply` methods to use `ToExpr`/`FromExpr` with ease;
+the `betaReduce` and `summon` methods.
+It also contains methods to create expressions out of lists or sequences of expressions: `block`, `ofSeq`, `ofList`, `ofTupleFromSeq` and `ofTuple`.
+
+```scala
+object Expr:
+  def apply[T](x: T)(using ToExpr[T])(using Quotes): Expr[T] = ...
+  def unapply[T](x: Expr[T])(using FromExpr[T])(using Quotes): Option[T] = ...
+  def betaReduce[T](e: Expr[T])(using Quotes): Expr[T] = ...
+  def summon[T: Type](using Quotes): Option[Expr[T]] = ...
+  def block[T](stats: List[Expr[Any]], e: Expr[T])(using Quotes): Expr[T] = ...
+  def ofSeq[T: Type](xs: Seq[Expr[T]])(using Quotes): Expr[Seq[T]] = ...
+  def ofList[T: Type](xs: Seq[Expr[T]])(using Quotes): Expr[List[T]] = ...
+  def ofTupleFromSeq(xs: Seq[Expr[Any]])(using Quotes): Expr[Tuple] = ...
+  def ofTuple[T <: Tuple: Tuple.IsMappedBy[Expr]: Type](tup: T)(using Quotes):
+      Expr[Tuple.InverseMap[T, Expr]] = ...
+```
+
+##### `class Type`
+Types of type `Type[T]` are represented by the following abstract class:
+```scala
+abstract class Type[T <: AnyKind] private[scala]:
+  type Underlying = T
+```
+
+The only implementation of `Type` is in the compiler along with the implementation of `Quotes`.
+It is a class that wraps the AST of a type and a `Scope` object with no methods of its own.
+The upper bound of `T` is `AnyKind` which implies that `T` may be a higher-kinded type.
+The `Underlying` alias is used to select the type from an instance of `Type`.
+Users never need to use this alias as they can always use `T` directly.
+`Underlying` is used for internal encoding while compiling the code (see _Type Healing_).
+
+##### `object Type`
+The companion object of `Type` contains a few useful static methods.
+The first and most important one is the `Type.of` given definition.
+This instance of `Type[T]` is summoned by default when no other instance is available.
+The `of` operation is an intrinsic operation that the compiler will transform into code that will generate the `Type[T]` at run-time.
+Secondly, the `Type.show[T]` operation will show a string representation of the type, which is often useful when debugging.
+Finally, the object defines `valueOfConstant` (and `valueOfTuple`) which can transform singleton types (or tuples of singleton types) into their value.
+
+
+```scala
+object Type:
+  given of[T <: AnyKind](using Quotes): Type[T] = ...
+  def show[T <: AnyKind](using Type[T])(using Quotes): String = ...
+  def valueOfConstant[T](using Type[T])(using Quotes): Option[T] = ...
+  def valueOfTuple[T <: Tuple](using Type[T])(using Quotes): Option[T] = ...
+```
+
+##### `Quotes`
+The `Quotes` interface is where most of the primitive operations of the quotation system are defined.
+
+Quotes define all the `Expr[T]` methods as extension methods.
+`Type[T]` does not have methods and therefore does not appear here.
+These methods are available as long as `Quotes` is implicitly given in the current scope.
+
+The `Quotes` instance is also the entry point to the [reflection API](./refelction.md) through the `reflect` object.
+
+Finally, `Quotes` provides the internal logic used in quote un-pickling (`QuoteUnpickler`) in quote pattern matching (`QuoteMatching`).
+These interfaces are added to the self-type of the trait to make sure they are implemented on this object but not visible to users of `Quotes`.
+
+Internally, the implementation of `Quotes` will also track its current splicing scope `Scope`.
+This scope will be attached to any expression that is created using this `Quotes` instance.
+
+```scala
+trait Quotes:
+  this: runtime.QuoteUnpickler & runtime.QuoteMatching =>
+
+  extension [T](self: Expr[T])
+    def show: String
+    def matches(that: Expr[Any]): Boolean
+    def value(using FromExpr[T]): Option[T]
+    def valueOrAbort(using FromExpr[T]): T
+  end extension
+
+  extension (self: Expr[Any])
+    def isExprOf[X](using Type[X]): Boolean
+    def asExprOf[X](using Type[X]): Expr[X]
+  end extension
+
+  // abstract object reflect ...
+```
+
+
+##### `Scope`
+The splice context is represented as a stack (immutable list) of `Scope` objects.
+Each `Scope` contains the position of the splice (used for error reporting) and a reference to the enclosing splice scope `Scope`.
+A scope is a sub-scope of another if the other is contained in its parents.
+This check is performed when an expression is spliced into another using the `Scope` provided in the current scope in `Quotes` and the one in the `Expr` or `Type`.
+
+### Entry Points
+The two entry points for multi-stage programming are macros and the `run` operation.
+
+#### Macros
+Inline macro definitions will inline a top-level splice (a splice not nested in a quote).
+This splice needs to be evaluated at compile-time.
+In _Avoiding a complete interpreter_[^1], we stated the following restrictions:
+
+ * The top-level splice must contain a single call to a compiled static method.
+ * Arguments to the function are either literal constants, quoted expressions (parameters), `Type.of` for type parameters and a reference to `Quotes`.
+
+These restrictions make the implementation of the interpreter quite simple.
+Java Reflection is used to call the single function call in the top-level splice.
+The execution of that function is entirely done on compiled bytecode.
+These are Scala static methods and may not always become Java static methods, they might be inside module objects.
+As modules are encoded as class instances, we need to interpret the prefix of the method to instantiate it before we can invoke the method.
+
+The code of the arguments has not been compiled and therefore needs to be interpreted by the compiler.
+Interpreting literal constants is as simple as extracting the constant from the AST that represents literals.
+When interpreting a quoted expression, the contents of the quote is kept as an AST which is wrapped inside the implementation of `Expr`.
+Calls to `Type.of[T]` also wrap the AST of the type inside the implementation of `Type`.
+Finally, the reference to `Quotes` is supposed to be the reference to the quotes provided by the splice.
+This reference is interpreted as a new instance of `Quotes` that contains a fresh initial `Scope` with no parents.
+
+The result of calling the method via Java Reflection will return an `Expr` containing a new AST that was generated by the implementation of that macro.
+The scope of this `Expr` is checked to make sure it did not extrude from some splice or `run` operation.
+Then the AST is extracted from the `Expr` and it is inserted as replacement for the AST that contained the top-level splice.
+
+
+#### Run-time Multi-Stage Programming
+
+To be able to compile the code, the `scala.quoted.staging` library defines the `Compiler` trait.
+An instance of `staging.Compiler` is a wrapper over the normal Scala~3 compiler.
+To be instantiated it requires an instance of the JVM _classloader_ of the application.
+
+```scala
+import scala.quoted.staging.*
+given Compiler = Compiler.make(getClass.getClassLoader)
+```
+
+The classloader is needed for the compiler to know which dependencies have been loaded and to load the generated code using the same classloader.
+
+```scala
+def mkPower2()(using Quotes): Expr[Double => Double] = ...
+
+run(mkPower2())
+```
+To run the previous example, the compiler will create code equivalent to the following class and compile it using a new `Scope` without parents.
+
+```scala
+class RunInstance:
+  def exec(): Double => Double = ${ mkPower2() }
+```
+Finally, `run` will interpret `(new RunInstance).exec()` to evaluate the contents of the quote.
+To do this, the resulting `RunInstance` class is loaded in the JVM using Java Reflection, instantiated and then the `exec` method is invoked.
+
+
+### Compilation
+
+Quotes and splices are primitive forms in the generated typed abstract syntax trees.
+These need to be type-checked with some extra rules, e.g., staging levels need to be checked and the references to generic types need to be adapted.
+Finally, quoted expressions that will be generated at run-time need to be encoded (serialized) and decoded (deserialized).
+
+#### Typing Quoted Expressions
+
+The typing process for quoted expressions and splices with `Expr` is relatively straightforward.
+At its core, quotes are desugared into calls to `quote`, splices are desugared into calls to `splice`.
+We track the quotation level when desugaring into these methods.
+
+
+```scala
+def quote[T](x: T): Quotes ?=> Expr[T]
+
+def splice[T](x: Quotes ?=> Expr[T]): T
+```
+
+It would be impossible to track the quotation levels if users wrote calls to these methods directly.
+To know if it is a call to one of those methods we would need to type it first, but to type it we would need to know if it is one of these methods to update the quotation level.
+Therefore these methods can only be used by the compiler.
+
+At run-time, the splice needs to have a reference to the `Quotes` that created its surrounding quote.
+To simplify this for later phases, we track the current `Quotes` and encode a reference directly in the splice using `nestedSplice` instead of `splice`.
+
+```scala
+def nestedSplice[T](q: Quotes)(x: q.Nested ?=> Expr[T]): T
+```
+With this addition, the original `splice` is only used for top-level splices.
+
+The levels are mostly used to identify top-level splices that need to be evaluated while typing.
+We do not use the quotation level to influence the typing process.
+Level checking is performed at a later phase.
+This ensures that a source expression in a quote will have the same elaboration as a source expression outside the quote.
+
+
+
+#### Quote Pattern Matching
+
+Pattern matching is defined in the trait `QuoteMatching`, which is part of the self type of `Quotes`.
+It is implemented by `Quotes` but not available to users of `Quotes`.
+To access it, the compiler generates a cast from `Quotes` to `QuoteMatching` and then selects one of its two members: `ExprMatch` or `TypeMatch`.
+`ExprMatch` defines an `unapply` extractor method that is used to encode quote patterns and `TypeMatch` defines an `unapply` method for quoted type patterns.
+
+```scala
+trait Quotes:
+  self: runtime.QuoteMatching & ...  =>
+  ...
+
+trait QuoteMatching:
+  object ExprMatch:
+    def unapply[TypeBindings <: Tuple, Tup <: Tuple]
+               (scrutinee: Expr[Any])
+               (using pattern: Expr[Any]): Option[Tup] = ...
+  object TypeMatch:
+    ...
+```
+
+These extractor methods are only meant to be used in code generated by the compiler.
+The call to the extractor that is generated has an already elaborated form that cannot be written in source, namely explicit type parameters and explicit contextual parameters.
+
+This extractor returns a tuple type `Tup` which cannot be inferred from the types in the method signature.
+This type will be computed when typing the quote pattern and will be explicitly added to the extractor call.
+To refer to type variables in arbitrary places of `Tup`, we need to define them all before their use, hence we have `TypeBindings`, which will contain all pattern type variable definitions.
+The extractor also receives a given parameter of type `Expr[Any]` that will contain an expression that represents the pattern.
+The compiler will explicitly add this pattern expression.
+We use a given parameter because these are the only parameters we are allowed to add to the extractor call in a pattern position.
+
+This extractor is a bit convoluted, but it encodes away all the quotation-specific features.
+It compiles the pattern down into a representation that the pattern matcher compiler phase understands.
+
+The quote patterns are encoded into two parts: a tuple pattern that is tasked with extracting the result of the match and a quoted expression representing the pattern.
+For example, if the pattern has no `$` we will have an `EmptyTuple` as the pattern and `'{1}` to represent the pattern.
+
+```scala
+  case '{ 1 } =>
+// is elaborated to
+  case ExprMatch(EmptyTuple)(using '{1}) =>
+//               ^^^^^^^^^^  ^^^^^^^^^^
+//                pattern    expression
+```
+When extracting expressions, each pattern that is contained in a splice `${..}` will be placed in order in the tuple pattern.
+In the following case, the `f` and `x` are placed in a tuple pattern `(f, x)`.
+The type of the tuple is encoded in the `Tup` and not only in the tuple itself.
+Otherwise, the extractor would return a tuple `Tuple` for which the types need to be tested which is in turn not possible due to type erasure.
+
+```scala
+  case '{ ((y: Int) => $f(y)).apply($x) } =>
+// is elaborated to
+  case ExprMatch[.., (Expr[Int => Int], Expr[Int])]((f, x))(using pattern) =>
+// pattern = '{ ((y: Int) => pat[Int](y)).apply(pat[Int]()) }
+```
+The contents of the quote are transformed into a valid quote expression by replacing the splice with a marker expression `pat[T](..)`.
+The type `T` is taken from the type of the splice and the arguments are the HOAS arguments.
+This implies that a `pat[T]()` is a closed pattern and `pat[T](y)` is an HOAS pattern that can refer to `y`.
+
+
+Type variables in quoted patterns are first normalized to have all definitions at the start of the pattern.
+For each definition of a type variable `t` in the pattern we will add a type variable definition in `TypeBindings`.
+Each one will have a corresponding `Type[t]` that will get extracted if the pattern matches.
+These `Type[t]` are also listed in the `Tup` and added in the tuple pattern.
+It is additionally marked as `using` in the pattern to make it implicitly available in this case branch.
+
+
+```scala
+  case '{ type t; ($xs: List[t]).map[t](identity[t]) } =>
+// is elaborated to
+  case ExprMatch[(t), (Type[t], Expr[List[t]])]((using t, xs))(using p) =>
+//               ^^^  ^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^  ^^^^^^^
+//     type bindings        result type            pattern     expression
+// p = '{ @patternType type u; pat[List[u]]().map[u](identity[u]) }
+```
+
+The contents of the quote are transformed into a valid quote expression by replacing type variables with fresh ones that do not escape the quote scope.
+These are also annotated to be easily identifiable as pattern variables.
+
+#### Level Consistency Checking
+Level consistency checking is performed after typing the program as a static check.
+To check level consistency we traverse the tree top-down remembering the context staging level.
+Each local definition in scope is recorded with its level and each term reference to a definition is checked against the current staging level.
+```scala
+// level 0
+'{ // level 1
+  val x = ... // level 1 with (x -> 1)
+  ${ // level 0 (x -> 1)
+    val y = ... // level 0 with (x -> 1, y -> 0)
+    x // error: defined at level 1 but used in level 0
+  }
+  // level 1 (x -> 1)
+  x // x is ok
+}
+```
+
+#### Type Healing
+
+When using a generic type `T` in a future stage, it is necessary to have a given `Type[T]` in scope.
+The compiler needs to identify those references and link them with the instance of `Type[T]`.
+For instance consider the following example:
+
+```scala
+def emptyList[T](using t: Type[T])(using Quotes): Expr[List[T]] =
+  '{ List.empty[T] }
+```
+
+For each reference to a generic type `T` that is defined at level 0 and used at level 1 or greater, the compiler will summon a `Type[T]`.
+This is usually the given type that is provided as parameter, `t` in this case.
+We can use the type `t.Underlying` to replace `T` as it is an alias of that type.
+But `t.Underlying` contains the extra information that it is `t` that will be used in the evaluation of the quote.
+In a sense, `Underlying` acts like a splice for types.
+
+```scala
+def emptyList[T](using t: Type[T])(using Quotes): Expr[List[T]] =
+  '{ List.empty[t.Underlying] }
+```
+
+Due to some technical limitations, it is not always possible to replace the type reference with the AST containing `t.Underlying`.
+To overcome this limitation, we can simply define a list of type aliases at the start of the quote and insert the `t.Underlying` there.
+This has the added advantage that we do not have to repeatedly insert the `t.Underlying` in the quote.
+
+```scala
+def emptyList[T](using t: Type[T])(using Quotes): Expr[List[T]] =
+  '{ type U = t.Underlying; List.empty[U] }
+```
+These aliases can be used at any level within the quote and this transformation is only performed on quotes that are at level 0.
+
+```scala
+  '{ List.empty[T] ... '{ List.empty[T] } ... }
+// becomes
+  '{ type U = t.Underlying; List.empty[U] ... '{ List.empty[U] } ... }
+```
+If we define a generic type at level 1 or greater, it will not be subject to this transformation.
+In some future compilation stage, when the definition of the generic type is at level 0, it will be subject to this transformation.
+This simplifies the transformation logic and avoids leaking the encoding into code that a macro could inspect.
+
+```scala
+'{
+  def emptyList[T: Type](using Quotes): Expr[List[T]] = '{ List.empty[T] }
+  ...
+}
+```
+A similar transformation is performed on `Type.of[T]`.
+Any generic type in `T` needs to have an implicitly given `Type[T]` in scope, which will also be used as a path.
+The example:
+
+```scala
+def empty[T](using t: Type[T])(using Quotes): Expr[T] =
+  Type.of[T] match ...
+// becomes
+def empty[T](using t: Type[T])(using Quotes): Expr[T] =
+  Type.of[t.Underlying] match ...
+// then becomes
+def empty[T](using t: Type[T])(using Quotes): Expr[T] =
+  t match ...
+```
+
+The operation `Type.of[t.Underlying]` can be optimized to just `t`.
+But this is not always the case.
+If the generic reference is nested in the type, we will need to keep the `Type.of`.
 
-The phase consistency principle can be formalized in a calculus that
-extends simply-typed lambda calculus with quotes and splices.
+```scala
+def matchOnList[T](using t: Type[T])(using Quotes): Expr[List[T]] =
+  Type.of[List[T]] match ...
+// becomes
+def matchOnList[T](using t: Type[T])(using Quotes): Expr[List[T]] =
+  Type.of[List[t.Underlying]] match ...
+```
 
-### Syntax
+By doing this transformation, we ensure that each abstract type `U` used in `Type.of` has an implicit `Type[U]` in scope.
+This representation makes it simpler to identify parts of the type that are statically known from those that are known dynamically.
+Type aliases are also added within the type of the `Type.of` though these are not valid source code.
+These would look like `Type.of[{type U = t.Underlying; Map[U, U]}]` if written in source code.
 
-The syntax of terms, values, and types is given as follows:
-```ebnf
-Terms         t  ::=  x                 variable
-                      (x: T) => t       lambda
-                      t t               application
-                      't                quote
-                      $t                splice
 
-Values        v  ::=  (x: T) => t       lambda
-                      'u                quote
+#### Splice Normalization
 
-Simple terms  u  ::=  x  |  (x: T) => u  |  u u  |  't
+The contents of a splice may refer to variables defined in the enclosing quote.
+This complicates the process of serialization of the contents of the quotes.
+To make serialization simple, we first transform the contents of each level 1 splice.
+Consider the following example:
 
-Types         T  ::=  A                 base type
-                      T -> T            function type
-                      expr T            quoted
+```scala
+def power5to(n: Expr[Int]): Expr[Double] = '{
+  val x: Int = 5
+  ${ powerCode('{x}, n) }
+}
 ```
-Typing rules are formulated using a stack of environments
-`Es`. Individual environments `E` consist as usual of variable
-bindings `x: T`. Environments can be combined using the two
-combinators `'` and `$`.
-```ebnf
-Environment   E  ::=  ()                empty
-                      E, x: T
 
-Env. stack    Es ::=  ()                empty
-                      E                 simple
-                      Es * Es           combined
+The variable `x` is defined in the quote and used in the splice.
+The normal form will extract all references to `x` and replace them with a staged version of `x`.
+We will replace the reference to `x` of type `T` with a `$y` where `y` is of type `Expr[T]`.
+Then we wrap the new contents of the splice in a lambda that defines `y` and apply it to the quoted version of `x`.
+After this transformation we have 2 parts, a lambda without references to the quote, which knows how to compute the contents of the splice, and a sequence of quoted arguments that refer to variables defined in the lambda.
 
-Separator     *  ::=  '
-                      $
+```scala
+def power5to(n: Expr[Int]): Expr[Double] = '{
+  val x: Int = 5
+  ${ ((y: Expr[Int]) => powerCode('{$y}, n)).apply('x) }
+}
 ```
-The two environment combinators are both associative with left and
-right identity `()`.
 
-### Operational semantics
+In general, the splice normal form has the shape `${ <lambda>.apply(<args>*) }` and the following constraints:
+ * `<lambda>` a lambda expression that does not refer to variables defined in the outer quote
+ * `<args>` sequence of quoted expressions or `Type.of` containing references to variables defined in the enclosing quote and no references to local variables defined outside the enclosing quote
 
-We define a small step reduction relation `-->` with the following rules:
+
+##### Function references normalization
+A reference to a function `f` that receives parameters is not a valid value in Scala.
+Such a function reference `f` can be eta-expaned as `x => f(x)` to be used as a lambda value.
+Therefore function references cannot be transformed by the normalization as directly as other expressions as we cannot represent `'{f}` with a method reference type.
+We can use the eta-expanded form of `f` in the normalized form.
+For example, consider the reference to `f` below.
+
+```scala
+'{
+  def f(a: Int)(b: Int, c: Int): Int = 2 + a + b + c
+  ${ '{ f(3)(4, 5) } }
+}
 ```
-          ((x: T) => t) v  -->  [x := v]t
 
-                    ${'u}  -->  u
+To normalize this code, we can eta-expand the reference to `f` and place it in a quote containing a proper expression.
+Therefore the normalized form of the argument `'{f}` becomes the quoted lambda `'{ (a: Int) => (b: Int, c: Int) => f(a)(b, c) }` and is an expression of type `Expr[Int => (Int, Int) => Int]`.
+The eta-expansion produces one curried lambda per parameter list.
+The application `f(3)(4, 5)` does not become `$g(3)(4, 5)` but `$g.apply(3).apply(4, 5)`.
+We add the `apply` because `g` is not a quoted reference to a function but a curried lambda.
 
-                       t1  -->  t2
-                    -----------------
-                    e[t1]  -->  e[t2]
+```scala
+'{
+  def f(a: Int)(b: Int, c: Int): Int = 2 + a + b + c
+  ${
+    (
+      (g: Expr[Int => (Int, Int) => Int]) => '{$g.apply(3).apply(4, 5)}
+    ).apply('{ (a: Int) => (b: Int, c: Int) => f(a)(b, c) })
+  }
+}
 ```
-The first rule is standard call-by-value beta-reduction. The second
-rule says that splice and quotes cancel each other out. The third rule
-is a context rule; it says that reduction is allowed in the hole `[ ]`
-position of an evaluation context.  Evaluation contexts `e` and
-splice evaluation context `e_s` are defined syntactically as follows:
-```ebnf
-Eval context    e    ::=  [ ]  |  e t  |  v e  |  'e_s[${e}]
-Splice context  e_s  ::=  [ ]  |  (x: T) => e_s  |  e_s t  |  u e_s
+
+Then we can apply it and beta-reduce the application when generating the code.
+
+```scala
+      (g: Expr[Int => Int => Int]) => betaReduce('{$g.apply(3).apply(4)})
 ```
 
-### Typing rules
 
-Typing judgments are of the form `Es |- t: T`. There are two
-substructural rules which express the fact that quotes and splices
-cancel each other out:
+##### Variable assignment normalization
+A reference to a mutable variable in the left-hand side of an assignment cannot be transformed directly as it is not in an expression position.
+```scala
+'{
+  var x: Int = 5
+  ${ g('{x = 2}) }
+}
 ```
-                    Es1 * Es2 |- t: T
-               ---------------------------
-               Es1 $ E1 ' E2 * Es2 |- t: T
 
+We can use the same strategy used for function references by eta-expanding the assignment operation `x = _` into `y => x = y`.
 
-                    Es1 * Es2 |- t: T
-               ---------------------------
-               Es1 ' E1 $ E2 * Es2 |- t: T
+```scala
+'{
+  var x: Int = 5
+  ${
+    g(
+      (
+        (f: Expr[Int => Unit]) => betaReduce('{$f(2)})
+      ).apply('{ (y: Int) => x = $y })
+    )
+  }
+}
 ```
-The lambda calculus fragment of the rules is standard, except that we
-use a stack of environments. The rules only interact with the topmost
-environment of the stack.
+
+
+##### Type normalization
+Types defined in the quote are subject to a similar transformation.
+In this example, `T` is defined within the quote at level 1 and used in the splice again at level 1.
+
+```scala
+'{ def f[T] = ${ '{g[T]} } }
 ```
-                          x: T in E
-                        --------------
-                        Es * E |- x: T
 
+The normalization will add a `Type[T]` to the lambda, and we will insert this reference.
+The difference is that it will add an alias similar to the one used in type healing.
+In this example, we create a `type U` that aliases the staged type.
+
+```scala
+'{
+  def f[T] = ${
+    (
+      (t: Type[T]) => '{type U = t.Underling; g[U]}
+    ).apply(Type.of[T])
+  }
+}
+```
 
-                    Es * E, x: T1 |- t: T2
-                -------------------------------
-                Es * E |- (x: T1) => t: T -> T2
+#### Serialization
 
+Quoted code needs to be pickled to make it available at run-time in the next compilation phase.
+We implement this by pickling the AST as a TASTy binary.
 
-               Es |- t1: T2 -> T    Es |- t2: T2
-               ---------------------------------
-                      Es |- t1 t2: T
+##### TASTy
+The TASTy format is the typed abstract syntax tree serialization format of Scala 3.
+It usually pickles the fully elaborated code after type-checking and is kept along the generated Java classfiles.
+
+
+##### Pickling
+We use TASTy as a serialization format for the contents of the quotes.
+To show how serialization is performed, we will use the following example.
+```scala
+'{
+  val (x, n): (Double, Int) = (5, 2)
+  ${ powerCode('{x}, '{n}) } * ${ powerCode('{2}, '{n}) }
+}
 ```
-The rules for quotes and splices map between `expr T` and `T` by trading `'` and `$` between
-environments and terms.
+
+This quote is transformed into the following code when normalizing the splices.
+
+```scala
+'{
+  val (x, n): (Double, Int) = (5, 2)
+  ${
+    ((y: Expr[Double], m: Expr[Int]) => powerCode(y, m)).apply('x, 'n)
+  } * ${
+    ((m: Expr[Int]) => powerCode('{2}, m)).apply('n)
+  }
+}
 ```
-                     Es $ () |- t: expr T
-                     --------------------
-                         Es |- $t: T
 
+Splice normalization is a key part of the serialization process as it only allows references to variables defined in the quote in the arguments of the lambda in the splice.
+This makes it possible to create a closed representation of the quote without much effort.
+The first step is to remove all the splices and replace them with holes.
+A hole is like a splice but it lacks the knowledge of how to compute the contents of the splice.
+Instead, it knows the index of the hole and the contents of the arguments of the splice.
+We can see this transformation in the following example where a hole is represented by `<< idx; holeType; args* >>`.
 
-                       Es ' () |- t: T
-                       ----------------
-                       Es |- 't: expr T
+```scala
+  ${ ((y: Expr[Double], m: Expr[Int]) => powerCode(y, m)).apply('x, 'n) }
+// becomes
+  << 0; Double; x, n >>
 ```
-The meta theory of a slightly simplified 2-stage variant of this calculus
-is studied [separately](./simple-smp.md).
 
-## Going Further
+As this was the first hole it has index 0.
+The hole type is `Double`, which needs to be remembered now that we cannot infer it from the contents of the splice.
+The arguments of the splice are `x` and `n`; note that they do not require quoting because they were moved out of the splice.
 
-The metaprogramming framework as presented and currently implemented is quite restrictive
-in that it does not allow for the inspection of quoted expressions and
-types. It’s possible to work around this by providing all necessary
-information as normal, unquoted inline parameters. But we would gain
-more flexibility by allowing for the inspection of quoted code with
-pattern matching. This opens new possibilities.
+References to healed types are handled in a similar way.
+Consider the `emptyList` example, which shows the type aliases that are inserted into the quote.
+```scala
+'{ List.empty[T] }
+// type healed to
+'{ type U = t.Underlying; List.empty[U] }
+```
+Instead of replacing a splice, we replace the `t.Underlying` type with a type hole.
+The type hole is represented by `<< idx; bounds >>`.
+```scala
+'{ type U = << 0; Nothing..Any >>; List.empty[U] }
+```
+Here, the bounds of `Nothing..Any` are the bounds of the original `T` type.
+The types of a `Type.of` are transformed in the same way.
+
+
+With these transformations, the contents of the quote or `Type.of` are guaranteed to be closed and therefore can be pickled.
+The AST is pickled into TASTy, which is a sequence of bytes.
+This sequence of bytes needs to be instantiated in the bytecode, but unfortunately it cannot be dumped into the classfile as bytes.
+To reify it we encode the bytes into a Java `String`.
+In the following examples we display this encoding in human readable form with the fictitious |tasty"..."| string literal.
 
-For instance, here is a version of `power` that generates the multiplications
-directly if the exponent is statically known and falls back to the dynamic
-implementation of `power` otherwise.
 ```scala
-import scala.quoted.*
+// pickled AST bytes encoded in a base64 string
+tasty"""
+  val (x, n): (Double, Int) = (5, 2)
+  << 0; Double; x, n >> * << 1; Double; n >>
+"""
+// or
+tasty"""
+  type U = << 0; Nothing..Any; >>
+  List.empty[U]
+"""
+```
+The contents of a quote or `Type.of` are not always pickled.
+In some cases it is better to generate equivalent (smaller and/or faster) code that will compute the expression.
+Literal values are compiled into a call to `Expr(<literal>)` using the implementation of `ToExpr` to create the quoted expression.
+This is currently performed only on literal values, but can be extended to any value for which we have a `ToExpr` defined in the standard library.
+Similarly, for non-generic types we can use their respective `java.lang.Class` and convert them into a `Type` using a primitive operation `typeConstructorOf` defined in the reflection API.
 
-inline def power(x: Double, n: Int): Double =
-  ${ powerExpr('x, 'n) }
+##### Unpickling
 
-private def powerExpr(x: Expr[Double], n: Expr[Int])
-                     (using Quotes): Expr[Double] =
-  n.value match
-    case Some(m) => powerExpr(x, m)
-    case _ => '{ dynamicPower($x, $n) }
+Now that we have seen how a quote is pickled, we can look at how to unpickle it.
+We will continue with the previous example.
 
-private def powerExpr(x: Expr[Double], n: Int)
-                     (using Quotes): Expr[Double] =
-  if n == 0 then '{ 1.0 }
-  else if n == 1 then x
-  else if n % 2 == 0 then '{ val y = $x * $x; ${ powerExpr('y, n / 2) } }
-  else '{ $x * ${ powerExpr(x, n - 1) } }
+Holes were used to replace the splices in the quote.
+When we perform this transformation we also need to remember the lambdas from the splices and their hole index.
+When unpickling a hole, the corresponding splice lambda will be used to compute the contents of the hole.
+The lambda will receive as parameters quoted versions of the arguments of the hole.
+For example to compute the contents of `<< 0; Double; x, n >>` we will evaluate the following code
 
-private def dynamicPower(x: Double, n: Int): Double =
-  if n == 0 then 1.0
-  else if n % 2 == 0 then dynamicPower(x * x, n / 2)
-  else x * dynamicPower(x, n - 1)
+```scala
+  ((y: Expr[Double], m: Expr[Int]) => powerCode(y, m)).apply('x, 'n)
 ```
 
-In the above, the method `.value` maps a constant expression of the type
-`Expr[T]` to its value of the type `T`.
+The evaluation is not as trivial as it looks, because the lambda comes from compiled code and the rest is code that must be interpreted.
+We put the AST of `x` and `n` into `Expr` objects to simulate the quotes and then we use Java Reflection to call the `apply` method.
+
+We may have many holes in a quote and therefore as many lambdas.
+To avoid the instantiation of many lambdas, we can join them together into a single lambda.
+Apart from the list of arguments, this lambda will also take the index of the hole that is being evaluated.
+It will perform a switch match on the index and call the corresponding lambda in each branch.
+Each branch will also extract the arguments depending on the definition of the lambda.
+The application of the original lambdas are beta-reduced to avoid extra overhead.
 
-With the right extractors, the "AsFunction" conversion
-that maps expressions over functions to functions over expressions can
-be implemented in user code:
 ```scala
-given AsFunction1[T, U]: Conversion[Expr[T => U], Expr[T] => Expr[U]] with
-  def apply(f: Expr[T => U]): Expr[T] => Expr[U] =
-    (x: Expr[T]) => f match
-      case Lambda(g) => g(x)
-      case _ => '{ ($f)($x) }
+(idx: Int, args: Seq[Any]) =>
+  idx match
+    case 0 => // for << 0; Double; x, n >>
+      val x = args(0).asInstanceOf[Expr[Double]]
+      val n = args(1).asInstanceOf[Expr[Int]]
+      powerCode(x, n)
+    case 1 => // for << 1; Double; n >>
+      val n = args(0).asInstanceOf[Expr[Int]]
+      powerCode('{2}, n)
 ```
-This assumes an extractor
+
+This is similar to what we do for splices when we replace the type aliased with holes we keep track of the index of the hole.
+Instead of lambdas, we will have a list of references to instances of `Type`.
+From the following example we would extract `t`, `u`, ... .
+
 ```scala
-object Lambda:
-  def unapply[T, U](x: Expr[T => U]): Option[Expr[T] => Expr[U]]
+  '{ type T1 = t1.Underlying; type Tn = tn.Underlying; ... }
+// with holes
+  '{ type T1 = << 0; ... >>; type Tn = << n-1; ... >>; ... }
 ```
-Once we allow inspection of code via extractors, it’s tempting to also
-add constructors that create typed trees directly without going
-through quotes. Most likely, those constructors would work over `Expr`
-types which lack a known type argument. For instance, an `Apply`
-constructor could be typed as follows:
+
+As the type holes are at the start of the quote, they will have the first `N` indices.
+This implies that we can place the references in a sequence `Seq(t, u, ...)` where the index in the sequence is the same as the hole index.
+
+Lastly, the quote itself is replaced by a call to `QuoteUnpickler.unpickleExpr` which will unpickle the AST, evaluate the holes, i.e., splices, and wrap the resulting AST in an `Expr[Int]`.
+This method takes takes the pickled |tasty"..."|, the types and the hole lambda.
+Similarly, `Type.of` is replaced with a call to `QuoteUnpickler.unpickleType` but only receives the pickled |tasty"..."| and the types.
+Because `QuoteUnpickler` is part of the self-type of the `Quotes` class, we have to cast the instance but know that this cast will always succeed.
+
 ```scala
-def Apply(fn: Expr[Any], args: List[Expr[Any]]): Expr[Any]
+quotes.asInstanceOf[runtime.QuoteUnpickler].unpickleExpr[T](
+  pickled = tasty"...",
+  types = Seq(...),
+  holes = (idx: Int, args: Seq[Any]) => idx match ...
+)
 ```
-This would allow constructing applications from lists of arguments
-without having to match the arguments one-by-one with the
-corresponding formal parameter types of the function. We then need "at
-the end" a method to convert an `Expr[Any]` to an `Expr[T]` where `T` is
-given from the outside. For instance, if `code` yields a `Expr[Any]`, then
-`code.atType[T]` yields an `Expr[T]`. The `atType` method has to be
-implemented as a primitive; it would check that the computed type
-structure of `Expr` is a subtype of the type structure representing
-`T`.
 
-Before going down that route, we should evaluate in detail the tradeoffs it
-presents. Constructing trees that are only verified _a posteriori_
-to be type correct loses a lot of guidance for constructing the right
-trees.  So we should wait with this addition until we have more
-use-cases that help us decide whether the loss in type-safety is worth
-the gain in flexibility. In this context, it seems that deconstructing types is
-less error-prone than deconstructing terms, so one might also
-envisage a solution that allows the former but not the latter.
-
-## Conclusion
-
-Metaprogramming has a reputation of being difficult and confusing.
-But with explicit `Expr/Type` types and quotes and splices it can become
-downright pleasant. A simple strategy first defines the underlying quoted or unquoted
-values using `Expr` and `Type` and then inserts quotes and splices to make the types
-line up. Phase consistency is at the same time a great guideline
-where to insert a splice or a quote and a vital sanity check that
-the result makes sense.
+[^1]: [Scalable Metaprogramming in Scala 3](https://infoscience.epfl.ch/record/299370)
+[^2]: [Multi-stage programming with generative and analytical macros](https://dl.acm.org/doi/10.1145/3486609.3487203).
+[^3]: In quotes, identifiers starting with `$` must be surrounded by backticks (`` `$` ``). For example `$conforms` from `scala.Predef`.
diff --git a/docs/_docs/reference/metaprogramming/macros.md b/docs/_docs/reference/metaprogramming/macros.md
index 0be48ef2baf8..1233d0007bc5 100644
--- a/docs/_docs/reference/metaprogramming/macros.md
+++ b/docs/_docs/reference/metaprogramming/macros.md
@@ -6,843 +6,617 @@ nightlyOf: https://docs.scala-lang.org/scala3/reference/metaprogramming/macros.h
 
 > When developing macros enable `-Xcheck-macros` scalac option flag to have extra runtime checks.
 
-## Macros: Quotes and Splices
+## Multi-Staging
 
-Macros are built on two well-known fundamental operations: quotation and splicing.
-Quotation is expressed as `'{...}` for expressions and splicing is expressed as `${ ... }`.
-Additionally, within a quote or a splice we can quote or splice identifiers directly (i.e. `'e` and `$e`).
-Readers may notice the resemblance of the two aforementioned syntactic
-schemes with the familiar string interpolation syntax.
+#### Quoted expressions
+Multi-stage programming in Scala 3 uses quotes `'{..}` to delay, i.e., stage, execution of code and splices `${..}` to evaluate and insert code into quotes.
+Quoted expressions are typed as `Expr[T]` with a covariant type parameter `T`.
+It is easy to write statically safe code generators with these two concepts.
+The following example shows a naive implementation of the $x^n$ mathematical operation.
 
 ```scala
-println(s"Hello, $name, here is the result of 1 + 1 = ${1 + 1}")
+import scala.quoted.*
+def unrolledPowerCode(x: Expr[Double], n: Int)(using Quotes): Expr[Double] =
+  if n == 0 then '{ 1.0 }
+  else if n == 1 then x
+  else '{ $x * ${ unrolledPowerCode(x, n-1) } }
 ```
 
-In string interpolation we _quoted_ a string and then we _spliced_ into it, two others. The first, `name`, is a reference to a value of type [`String`](https://scala-lang.org/api/3.x/scala/Predef$.html#String-0), and the second is an arithmetic expression that will be _evaluated_ followed by the splicing of its string representation.
-
-Quotes and splices in this section allow us to treat code in a similar way,
-effectively supporting macros. The entry point for macros is an inline method
-with a top-level splice. We call it a top-level because it is the only occasion
-where we encounter a splice outside a quote (consider as a quote the
-compilation-unit at the call-site). For example, the code below presents an
-`inline` method `assert` which calls at compile-time a method `assertImpl` with
-a boolean expression tree as argument. `assertImpl` evaluates the expression and
-prints it again in an error message if it evaluates to `false`.
-
 ```scala
-import scala.quoted.*
-
-inline def assert(inline expr: Boolean): Unit =
-  ${ assertImpl('expr) }
-
-def assertImpl(expr: Expr[Boolean])(using Quotes) = '{
-  if !$expr then
-    throw AssertionError(s"failed assertion: ${${ showExpr(expr) }}")
+'{
+  val x = ...
+  ${ unrolledPowerCode('{x}, 3) } // evaluates to: x * x * x
 }
-
-def showExpr(expr: Expr[Boolean])(using Quotes): Expr[String] =
-  '{ [actual implementation later in this document] }
 ```
 
-If `e` is an expression, then `'{e}` represents the typed
-abstract syntax tree representing `e`. If `T` is a type, then `Type.of[T]`
-represents the type structure representing `T`.  The precise
-definitions of "typed abstract syntax tree" or "type-structure" do not
-matter for now, the terms are used only to give some
-intuition. Conversely, `${e}` evaluates the expression `e`, which must
-yield a typed abstract syntax tree or type structure, and embeds the
-result as an expression (respectively, type) in the enclosing program.
+Quotes and splices are duals of each other.
+For an arbitrary expression `x` of type `T` we have `${'{x}} = x` and for an arbitrary expression `e` of type `Expr[T]` we have `'{${e}} = e`.
 
-Quotations can have spliced parts in them; in this case the embedded
-splices are evaluated and embedded as part of the formation of the
-quotation.
+#### Abstract types
+Quotes can handle generic and abstract types using the type class `Type[T]`.
+A quote that refers to a generic or abstract type `T` requires a given `Type[T]` to be provided in the implicit scope.
+The following examples show how `T` is annotated with a context bound (`: Type`) to provide an implicit `Type[T]`, or the equivalent `using Type[T]` parameter.
 
-Quotes and splices can also be applied directly to identifiers. An identifier
-`$x` starting with a `$` that appears inside a quoted expression or type is treated as a
-splice `${x}`. Analogously, an quoted identifier `'x` that appears inside a splice
-is treated as a quote `'{x}`. See the Syntax section below for details.
+```scala
+import scala.quoted.*
+def singletonListExpr[T: Type](x: Expr[T])(using Quotes): Expr[List[T]] =
+  '{ List[T]($x) } // generic T used within a quote
 
-Quotes and splices are duals of each other.
-For arbitrary expressions `e` we have:
+def emptyListExpr[T](using Type[T], Quotes): Expr[List[T]] =
+  '{ List.empty[T] } // generic T used within a quote
+```
 
+If no other instance is found, the default `Type.of[T]` is used.
+The following example implicitly uses `Type.of[String]` and `Type.of[Option[U]]`.
 ```scala
-${'{e}} = e
-'{${e}} = e
+val list1: Expr[List[String]] =
+  singletonListExpr('{"hello"}) // requires a given `Type[Sting]`
+val list0: Expr[List[Option[T]]] =
+  emptyListExpr[Option[U]] // requires a given `Type[Option[U]]`
 ```
 
-## Types for Quotations
-
-The type signatures of quotes and splices can be described using
-two fundamental types:
 
-- `Expr[T]`: abstract syntax trees representing expressions of type `T`
-- `Type[T]`: non erased representation of type `T`.
-
-Quoting takes expressions of type `T` to expressions of type `Expr[T]`
-and it takes types `T` to expressions of type `Type[T]`. Splicing
-takes expressions of type `Expr[T]` to expressions of type `T` and it
-takes expressions of type `Type[T]` to types `T`.
-
-The two types can be defined in package [`scala.quoted`](https://scala-lang.org/api/3.x/scala/quoted.html) as follows:
+The `Type.of[T]` method is a primitive operation that the compiler will handle specially.
+It will provide the implicit if the type `T` is statically known, or if `T` contains some other types `Ui` for which we have an implicit `Type[Ui]`.
+In the example, `Type.of[String]` has a statically known type and `Type.of[Option[U]]` requires an implicit `Type[U]` in scope.
 
+#### Quote context
+We also track the current quotation context using a given `Quotes` instance.
+To create a quote `'{..}` we require a given `Quotes` context, which should be passed as a contextual parameter `(using Quotes)` to the function.
+Each splice will provide a new `Quotes` context within the scope of the splice.
+Therefore quotes and splices can be seen as methods with the following signatures, but with special semantics.
 ```scala
-package scala.quoted
+def '[T](x: T): Quotes ?=> Expr[T] // def '[T](x: T)(using Quotes): Expr[T]
 
-sealed trait Expr[+T]
-sealed trait Type[T]
+def $[T](x: Quotes ?=> Expr[T]): T
 ```
 
-Both `Expr` and `Type` are abstract and sealed, so all constructors for
-these types are provided by the system. One way to construct values of
-these types is by quoting, the other is by type-specific lifting
-operations that will be discussed later on.
-
-## The Phase Consistency Principle
-
-A fundamental *phase consistency principle* (PCP) regulates accesses
-to free variables in quoted and spliced code:
-
-- _For any free variable reference `x`, the number of quoted scopes and the number of spliced scopes between the reference to `x` and the definition of `x` must be equal_.
-
-Here, `this`-references count as free variables. On the other
-hand, we assume that all imports are fully expanded and that `_root_` is
-not a free variable. So references to global definitions are
-allowed everywhere.
-
-The phase consistency principle can be motivated as follows: First,
-suppose the result of a program `P` is some quoted text `'{ ... x
-... }` that refers to a free variable `x` in `P`. This can be
-represented only by referring to the original variable `x`. Hence, the
-result of the program will need to persist the program state itself as
-one of its parts. We don’t want to do this, hence this situation
-should be made illegal. Dually, suppose a top-level part of a program
-is a spliced text `${ ... x ... }` that refers to a free variable `x`
-in `P`.  This would mean that we refer during _construction_ of `P` to
-a value that is available only during _execution_ of `P`. This is of
-course impossible and therefore needs to be ruled out.  Now, the
-small-step evaluation of a program will reduce quotes and splices in
-equal measure using the cancellation rules above. But it will neither
-create nor remove quotes or splices individually. So the PCP ensures
-that program elaboration will lead to neither of the two unwanted
-situations described above.
-
-In what concerns the range of features it covers, this form of macros introduces
-a principled metaprogramming framework that is quite close to the MetaML family of
-languages. One difference is that MetaML does not have an equivalent of the PCP -
-quoted code in MetaML _can_ access variables in its immediately enclosing
-environment, with some restrictions and caveats since such accesses involve
-serialization. However, this does not constitute a fundamental gain in
-expressiveness.
+The lambda with a question mark `?=>` is a contextual function; it is a lambda that takes its argument implicitly and provides it implicitly in the implementation the lambda.
+`Quotes` are used for a variety of purposes that will be mentioned when covering those topics.
 
-## From `Expr`s to Functions and Back
+## Quoted Values
 
-It is possible to convert any `Expr[T => R]` into `Expr[T] => Expr[R]` and back.
-These conversions can be implemented as follows:
+#### Lifting
+While it is not possible to use cross-stage persistence of local variables, it is possible to lift them to the next stage.
+To this end, we provide the `Expr.apply` method, which can take a value and lift it into a quoted representation of the value.
 
 ```scala
-def to[T: Type, R: Type](f: Expr[T] => Expr[R])(using Quotes): Expr[T => R] =
-  '{ (x: T) => ${ f('x) } }
+val expr1plus1: Expr[Int] = '{ 1 + 1 }
 
-def from[T: Type, R: Type](f: Expr[T => R])(using Quotes): Expr[T] => Expr[R] =
-  (x: Expr[T]) => '{ $f($x) }
+val expr2: Expr[Int] = Expr(1 + 1) // lift 2 into '{ 2 }
 ```
 
-Note how the fundamental phase consistency principle works in two
-different directions here for `f` and `x`.  In the method `to`,  the reference to `f` is
-legal because it is quoted, then spliced, whereas the reference to `x`
-is legal because it is spliced, then quoted.
-
-They can be used as follows:
+While it looks type wise similar to `'{ 1 + 1 }`, the semantics of `Expr(1 + 1)` are quite different.
+`Expr(1 + 1)` will not stage or delay any computation; the argument is evaluated to a value and then lifted into a quote.
+The quote will contain code that will create a copy of this value in the next stage.
+`Expr` is polymorphic and user-extensible via the `ToExpr` type class.
 
 ```scala
-val f1: Expr[Int => String] =
-  to((x: Expr[Int]) => '{ $x.toString }) // '{ (x: Int) => x.toString }
-
-val f2: Expr[Int] => Expr[String] =
-  from('{ (x: Int) => x.toString }) // (x: Expr[Int]) => '{ ((x: Int) => x.toString)($x) }
-f2('{2}) // '{ ((x: Int) => x.toString)(2) }
+trait ToExpr[T]:
+  def apply(x: T)(using Quotes): Expr[T]
 ```
 
-One limitation of `from` is that it does not β-reduce when a lambda is called immediately, as evidenced in the code `{ ((x: Int) => x.toString)(2) }`.
-In some cases we want to remove the lambda from the code, for this we provide the method `Expr.betaReduce` that turns a tree
-describing a function into a function mapping trees to trees.
+We can implement a `ToExpr` using a `given` definition that will add the definition to the implicits in scope.
+In the following example we show how to implement a `ToExpr[Option[T]]` for any liftable type `T.
 
 ```scala
-object Expr:
-  ...
-  def betaReduce[T](expr: Expr[T])(using Quotes): Expr[T]
+given OptionToExpr[T: Type: ToExpr]: ToExpr[Option[T]] with
+  def apply(opt: Option[T])(using Quotes): Expr[Option[T]] =
+    opt match
+      case Some(x) => '{ Some[T]( ${Expr(x)} ) }
+      case None => '{ None }
 ```
 
-`Expr.betaReduce` returns an expression that is functionally equivalent to e, however if e is of the form `((y1, ..., yn) => e2)(e1, ..., en)` then it optimizes the top most call by returning the result of beta-reducing the application. Otherwise returns expr.
+The `ToExpr` for primitive types must be implemented as primitive operations in the system.
+In our case, we use the reflection API to implement them.
 
-## Lifting Types
-
-Types are not directly affected by the phase consistency principle.
-It is possible to use types defined at any level in any other level.
-But, if a type is used in a subsequent stage it will need to be lifted to a `Type`.
-Indeed, the definition of `to` above uses `T` in the next stage, there is a
-quote but no splice between the parameter binding of `T` and its
-usage. But the code can be rewritten by adding an explicit binding of a `Type[T]`:
+#### Extracting values from quotes
+To be able to generate optimized code using the method `unrolledPowerCode`, the macro implementation `powerCode` needs to first
+determine whether the argument passed as parameter `n` is a known constant value.
+This can be achieved via _unlifting_ using the `Expr.unapply` extractor from our library implementation, which will only match if `n` is a quoted constant and extracts its value.
 
 ```scala
-def to[T, R](f: Expr[T] => Expr[R])(using t: Type[T], r: Type[R])(using Quotes): Expr[T => R] =
-  '{ (x: t.Underlying) => ${ f('x) } }
+def powerCode(x: Expr[Double], n: Expr[Int])(using Quotes): Expr[Double] =
+  n match
+    case Expr(m) => // it is a constant: unlift code n='{m} into number m
+      unrolledPowerCode(x, m)
+    case _ => // not known: call power at run-time
+      '{ power($x, $n) }
 ```
 
-In this version of `to`, the type of `x` is now the result of
-inserting the type `Type[T]` and selecting its `Underlying`.
-
-To avoid clutter, the compiler converts any type reference to
-a type `T` in subsequent phases to `summon[Type[T]].Underlying`.
-
-And to avoid duplication it does it once per type, and creates
-an alias for that type at the start of the quote.
-
-For instance, the user-level definition of `to`:
-
+Alternatively, the `n.value` method can be used to get an `Option[Int]` with the value or `n.valueOrAbort` to get the value directly.
 ```scala
-def to[T, R](f: Expr[T] => Expr[R])(using t: Type[T], r: Type[R])(using Quotes): Expr[T => R] =
-  '{ (x: T) => ${ f('x) } }
+def powerCode(x: Expr[Double], n: Expr[Int])(using Quotes): Expr[Double] =
+  // emits an error message if `n` is not a constant
+  unrolledPowerCode(x, n.valueOrAbort)
 ```
 
-would be rewritten to
+`Expr.unapply` and all variants of `value` are polymorphic and user-extensible via a given `FromExpr` type class.
 
 ```scala
-def to[T, R](f: Expr[T] => Expr[R])(using t: Type[T], r: Type[R])(using Quotes): Expr[T => R] =
-  '{
-    type T = summon[Type[T]].Underlying
-    (x: T) => ${ f('x) }
-  }
+trait FromExpr[T]:
+  def unapply(x: Expr[T])(using Quotes): Option[T]
 ```
 
-The `summon` query succeeds because there is a using parameter of
-type `Type[T]`, and the reference to that value is
-phase-correct. If that was not the case, the phase inconsistency for
-`T` would be reported as an error.
-
-## Lifting Expressions
+We can use `given` definitions to implement the `FromExpr` as we did for `ToExpr`.
+The `FromExpr` for primitive types must be implemented as primitive operations in the system.
+In our case, we use the reflection API to implement them.
+To implement `FromExpr` for non-primitive types we use quote pattern matching (for example `OptionFromExpr`).
 
-Consider the following implementation of a staged interpreter that implements
-a compiler through staging.
 
-```scala
-import scala.quoted.*
+## Macros and Multi-Stage Programming
 
-enum Exp:
-  case Num(n: Int)
-  case Plus(e1: Exp, e2: Exp)
-  case Var(x: String)
-  case Let(x: String, e: Exp, in: Exp)
+The system supports multi-stage macros and run-time multi-stage programming using the same quotation abstractions.
 
-import Exp.*
-```
+### Multi-Stage Macros
 
-The interpreted language consists of numbers `Num`, addition `Plus`, and variables
-`Var` which are bound by `Let`. Here are two sample expressions in the language:
+#### Macros
+We can generalize the splicing abstraction to express macros.
+A macro consists of a top-level splice that is not nested in any quote.
+Conceptually, the contents of the splice are evaluated one stage earlier than the program.
+In other words, the contents are evaluated while compiling the program. The generated code resulting from the macro replaces the splice in the program.
 
 ```scala
-val exp = Plus(Plus(Num(2), Var("x")), Num(4))
-val letExp = Let("x", Num(3), exp)
+def power2(x: Double): Double =
+  ${ unrolledPowerCode('x, 2) } // x * x
 ```
 
-Here’s a compiler that maps an expression given in the interpreted
-language to quoted Scala code of type `Expr[Int]`.
-The compiler takes an environment that maps variable names to Scala `Expr`s.
+#### Inline macros
+Since using the splices in the middle of a program is not as ergonomic as calling a function; we hide the staging mechanism from end-users of macros. We have a uniform way of calling macros and normal functions.
+For this, _we restrict the use of top-level splices to only appear in inline methods_[^1][^2].
 
 ```scala
-import scala.quoted.*
+// inline macro definition
+inline def powerMacro(x: Double, inline n: Int): Double =
+  ${ powerCode('x, 'n) }
 
-def compile(e: Exp, env: Map[String, Expr[Int]])(using Quotes): Expr[Int] =
-  e match
-    case Num(n) =>
-      Expr(n)
-    case Plus(e1, e2) =>
-      '{ ${ compile(e1, env) } + ${ compile(e2, env) } }
-    case Var(x) =>
-      env(x)
-    case Let(x, e, body) =>
-      '{ val y = ${ compile(e, env) }; ${ compile(body, env + (x -> 'y)) } }
+// user code
+def power2(x: Double): Double =
+  powerMacro(x, 2) // x * x
 ```
 
-Running `compile(letExp, Map())` would yield the following Scala code:
-
-```scala
-'{ val y = 3; (2 + y) + 4 }
-```
-
-The body of the first clause, `case Num(n) => Expr(n)`, looks suspicious. `n`
-is declared as an `Int`, yet it is converted to an `Expr[Int]` with `Expr()`.
-Shouldn’t `n` be quoted? In fact this would not
-work since replacing `n` by `'n` in the clause would not be phase
-correct.
-
-The `Expr.apply` method is defined in package `quoted`:
-
-```scala
-package quoted
-
-object Expr:
-  ...
-  def apply[T: ToExpr](x: T)(using Quotes): Expr[T] =
-    summon[ToExpr[T]].toExpr(x)
-```
+The evaluation of the macro will only happen when the code is inlined into `power2`.
+When inlined, the code is equivalent to the previous definition of `power2`.
+A consequence of using inline methods is that none of the arguments nor the return type of the macro will have to mention the `Expr` types; this hides all aspects of metaprogramming from the end-users.
 
-This method says that values of types implementing the `ToExpr` type class can be
-converted to `Expr` values using `Expr.apply`.
+#### Avoiding a complete interpreter
+When evaluating a top-level splice, the compiler needs to interpret the code that is within the splice.
+Providing an interpreter for the entire language is quite tricky, and it is even more challenging to make that interpreter run efficiently.
+To avoid needing a complete interpreter, we can impose the following restrictions on splices to simplify the evaluation of the code in top-level splices.
+ * The top-level splice must contain a single call to a compiled static method.
+ * Arguments to the function are literal constants, quoted expressions (parameters), calls to `Type.of` for type parameters and a reference to `Quotes`.
 
-Scala 3 comes with given instances of `ToExpr` for
-several types including `Boolean`, `String`, and all primitive number
-types. For example, `Int` values can be converted to `Expr[Int]`
-values by wrapping the value in a `Literal` tree node. This makes use
-of the underlying tree representation in the compiler for
-efficiency. But the `ToExpr` instances are nevertheless not _magic_
-in the sense that they could all be defined in a user program without
-knowing anything about the representation of `Expr` trees. For
-instance, here is a possible instance of `ToExpr[Boolean]`:
+In particular, these restrictions disallow the use of splices in top-level splices.
+Such a splice would require several stages of interpretation which would be unnecessarily inefficient.
 
+#### Compilation stages
+The macro implementation (i.e., the method called in the top-level splice) can come from any pre-compiled library.
+This provides a clear difference between the stages of the compilation process.
+Consider the following 3 source files defined in distinct libraries.
 ```scala
-given ToExpr[Boolean] with
-  def toExpr(b: Boolean) =
-    if b then '{ true } else '{ false }
+// Macro.scala
+def powerCode(x: Expr[Double], n: Expr[Int])(using Quotes): Expr[Double] = ...
+inline def powerMacro(x: Double, inline n: Int): Double =
+  ${ powerCode('x, 'n) }
 ```
 
-Once we can lift bits, we can work our way up. For instance, here is a
-possible implementation of `ToExpr[Int]` that does not use the underlying
-tree machinery:
-
 ```scala
-given ToExpr[Int] with
-  def toExpr(n: Int) = n match
-    case Int.MinValue    => '{ Int.MinValue }
-    case _ if n < 0      => '{ - ${ toExpr(-n) } }
-    case 0               => '{ 0 }
-    case _ if n % 2 == 0 => '{ ${ toExpr(n / 2) } * 2 }
-    case _               => '{ ${ toExpr(n / 2) } * 2 + 1 }
+// Lib.scala (depends on Macro.scala)
+def power2(x: Double) =
+  ${ powerCode('x, '{2}) } // inlined from a call to: powerMacro(x, 2)
 ```
 
-Since `ToExpr` is a type class, its instances can be conditional. For example,
-a `List` is liftable if its element type is:
-
 ```scala
-given [T: ToExpr : Type]: ToExpr[List[T]] with
-  def toExpr(xs: List[T]) = xs match
-    case head :: tail => '{ ${ Expr(head) } :: ${ toExpr(tail) } }
-    case Nil          => '{ Nil: List[T] }
+// App.scala  (depends on Lib.scala)
+@main def app() = power2(3.14)
 ```
-
-In the end, `ToExpr` resembles very much a serialization
-framework. Like the latter it can be derived systematically for all
-collections, case classes and enums. Note also that the synthesis
-of _type-tag_ values of type `Type[T]` is essentially the type-level
-analogue of lifting.
-
-Using lifting, we can now give the missing definition of `showExpr` in the introductory example:
+One way to syntactically visualize this is to put the application in a quote that delays the compilation of the application.
+Then the application dependencies can be placed in an outer quote that contains the quoted application, and we repeat this recursively for dependencies of dependencies.
 
 ```scala
-def showExpr[T](expr: Expr[T])(using Quotes): Expr[String] =
-  val code: String = expr.show
-  Expr(code)
+'{ // macro library (compilation stage 1)
+  def powerCode(x: Expr[Double], n: Expr[Int])(using Quotes): Expr[Double] =
+    ...
+  inline def powerMacro(x: Double, inline n: Int): Double =
+    ${ powerCode('x, 'n) }
+  '{ // library using macros (compilation stage 2)
+    def power2(x: Double) =
+      ${ powerCode('x, '{2}) } // inlined from a call to: powerMacro(x, 2)
+    '{ power2(3.14) /* app (compilation stage 3) */ }
+  }
+}
 ```
 
-That is, the `showExpr` method converts its `Expr` argument to a string (`code`), and lifts
-the result back to an `Expr[String]` using `Expr.apply`.
-
-## Lifting Types
+To make the system more versatile, we allow calling macros in the project where it is defined, with some restrictions.
+For example, to compile `Macro.scala` and `Lib.scala` together in the same library.
+To this end, we do not follow the simpler syntactic model and rely on semantic information from the source files.
+When compiling a source, if we detect a call to a macro that is not compiled yet, we delay the compilation of this source to the following compilation stage.
+In the example, we would delay the compilation of `Lib.scala` because it contains a compile-time call to `powerCode`.
+Compilation stages are repeated until all sources are compiled, or no progress can be made.
+If no progress is made, there was a cyclic dependency between the definition and the use of the macro.
+We also need to detect if at runtime the macro depends on sources that have not been compiled yet.
+These are detected by executing the macro and checking for JVM linking errors to classes that have not been compiled yet.
 
-The previous section has shown that the metaprogramming framework has
-to be able to take a type `T` and convert it to a type tree of type
-`Type[T]` that can be reified. This means that all free variables of
-the type tree refer to types and values defined in the current stage.
+### Run-Time Multi-Stage Programming
 
-For a reference to a global class, this is easy: Just issue the fully
-qualified name of the class. Members of reifiable types are handled by
-just reifying the containing type together with the member name. But
-what to do for references to type parameters or local type definitions
-that are not defined in the current stage? Here, we cannot construct
-the `Type[T]` tree directly, so we need to get it from a recursive
-implicit search. For instance, to implement
+See [Run-Time Multi-Stage Programming](./staging.md)
 
-```scala
-summon[Type[List[T]]]
-```
-
-where `T` is not defined in the current stage, we construct the type constructor
-of `List` applied to the splice of the result of searching for a given instance for `Type[T]`:
-
-```scala
-Type.of[ List[ summon[Type[T]].Underlying ] ]
-```
+## Safety
 
-This is exactly the algorithm that Scala 2 uses to search for type tags.
-In fact Scala 2's type tag feature can be understood as a more ad-hoc version of
-`quoted.Type`. As was the case for type tags, the implicit search for a `quoted.Type`
-is handled by the compiler, using the algorithm sketched above.
+Multi-stage programming is by design statically safe and cross-stage safe.
 
-## Relationship with `inline`
+### Static Safety
 
-Seen by itself, principled metaprogramming looks more like a framework for
-runtime metaprogramming than one for compile-time metaprogramming with macros.
-But combined with Scala 3’s `inline` feature it can be turned into a compile-time
-system. The idea is that macro elaboration can be understood as a combination of
-a macro library and a quoted program. For instance, here’s the `assert` macro
-again together with a program that calls `assert`.
-
-```scala
-object Macros:
+#### Hygiene
+All identifier names are interpreted as symbolic references to the corresponding variable in the context of the quote.
+Therefore, while evaluating the quote, it is not possible to accidentally rebind a reference to a new variable with the same textual name.
 
-  inline def assert(inline expr: Boolean): Unit =
-    ${ assertImpl('expr) }
+#### Well-typed
+If a quote is well typed, then the generated code is well typed.
+This is a simple consequence of tracking the type of each expression.
+An `Expr[T]` can only be created from a quote that contains an expression of type `T.
+Conversely, an `Expr[T]` can only be spliced in a location that expects a type `T.
+As mentioned before, `Expr` is covariant in its type parameter.
+This means that an `Expr[T]` can contain an expression of a subtype of `T.
+When spliced in a location that expects a type `T, these expressions also have a valid type.
 
-  def assertImpl(expr: Expr[Boolean])(using Quotes) =
-    val failMsg: Expr[String] = Expr("failed assertion: " + expr.show)
-    '{ if !($expr) then throw new AssertionError($failMsg) }
+### Cross-Stage Safety
 
-@main def program =
-  val x = 1
-  Macros.assert(x != 0)
-```
+#### Level consistency
+We define the _staging level_ of some code as the number of quotes minus the number of splices surrounding said code.
+Local variables must be defined and used in the same staging level.
 
-Inlining the `assert` function would give the following program:
+It is never possible to access a local variable from a lower staging level as it does not yet exist.
 
 ```scala
-@main def program =
-  val x = 1
-  ${ Macros.assertImpl('{ x != 0}) }
+def badPower(x: Double, n: Int): Double =
+  ${ unrolledPowerCode('x, n) } // error: value of `n` not known yet
 ```
 
-The example is only phase correct because `Macros` is a global value and
-as such not subject to phase consistency checking. Conceptually that’s
-a bit unsatisfactory. If the PCP is so fundamental, it should be
-applicable without the global value exception. But in the example as
-given this does not hold since both `assert` and `program` call
-`assertImpl` with a splice but no quote.
 
-However, one could argue that the example is really missing
-an important aspect: The macro library has to be compiled in a phase
-prior to the program using it, but in the code above, macro
-and program are defined together. A more accurate view of
-macros would be to have the user program be in a phase after the macro
-definitions, reflecting the fact that macros have to be defined and
-compiled before they are used. Hence, conceptually the program part
-should be treated by the compiler as if it was quoted:
+In the context of macros and _cross-platform portability_, that is,
+macros compiled on one machine but potentially executed on another,
+we cannot support cross-stage persistence of local variables.
+Therefore, local variables can only be accessed at precisely the same staging level in our system.
 
 ```scala
-@main def program = '{
-  val x = 1
-  ${ Macros.assertImpl('{ x != 0 }) }
-}
+def badPowerCode(x: Expr[Double], n: Int)(using Quotes): Expr[Double] =
+  // error: `n` potentially not available in the next execution environment
+  '{ power($x, n) }
 ```
 
-If `program` is treated as a quoted expression, the call to
-`Macro.assertImpl` becomes phase correct even if macro library and
-program are conceptualized as local definitions.
-
-But what about the call from `assert` to `assertImpl`? Here, we need a
-tweak of the typing rules. An inline function such as `assert` that
-contains a splice operation outside an enclosing quote is called a
-_macro_. Macros are supposed to be expanded in a subsequent phase,
-i.e. in a quoted context. Therefore, they are also type checked as if
-they were in a quoted context. For instance, the definition of
-`assert` is typechecked as if it appeared inside quotes.  This makes
-the call from `assert` to `assertImpl` phase-correct, even if we
-assume that both definitions are local.
-
-The `inline` modifier is used to declare a `val` that is
-either a constant or is a parameter that will be a constant when instantiated. This
-aspect is also important for macro expansion.
 
-To get values out of expressions containing constants `Expr` provides the method
-`value` (or `valueOrError`). This will convert the `Expr[T]` into a `Some[T]` (or `T`) when the
-expression contains value. Otherwise it will return `None` (or emit an error).
-To avoid having incidental val bindings generated by the inlining of the `def`
-it is recommended to use an inline parameter. To illustrate this, consider an
-implementation of the `power` function that makes use of a statically known exponent:
+The rules are slightly different for global definitions, such as `unrolledPowerCode`.
+It is possible to generate code that contains a reference to a _global_ definition such as in `'{ power(2, 4) }`.
+This is a limited form of cross-stage persistence that does not impede cross-platform portability, where we refer to the already compiled code for `power`.
+Each compilation step will lower the staging level by one while keeping global definitions.
+In consequence, we can refer to compiled definitions in macros such as `unrolledPowerCode` in `${ unrolledPowerCode('x, 2) }`.
 
-```scala
-inline def power(x: Double, inline n: Int) = ${ powerCode('x, 'n) }
-
-private def powerCode(x: Expr[Double], n: Expr[Int])(using Quotes): Expr[Double] =
-  n.value match
-    case Some(m) => powerCode(x, m)
-    case None => '{ Math.pow($x, $n.toDouble) }
-
-private def powerCode(x: Expr[Double], n: Int)(using Quotes): Expr[Double] =
-  if n == 0 then '{ 1.0 }
-  else if n == 1 then x
-  else if n % 2 == 0 then '{ val y = $x * $x; ${ powerCode('y, n / 2) } }
-  else '{ $x * ${ powerCode(x, n - 1) } }
-```
+We can sumarize level consistency in two rules:
+ * Local variables can be used only at the same staging level as their definition
+ * Global variables can be used at any staging level
 
-## Scope Extrusion
 
-Quotes and splices are duals as far as the PCP is concerned. But there is an
-additional restriction that needs to be imposed on splices to guarantee
-soundness: code in splices must be free of side effects. The restriction
-prevents code like this:
+#### Type consistency
+As Scala uses type erasure, generic types will be erased at run-time and hence in any following stage.
+To ensure any quoted expression that refers to a generic type `T` does not lose the information it needs, we require a given `Type[T]` in scope.
+The `Type[T]` will carry over the non-erased representation of the type into the next phase.
+Therefore any generic type used at a higher staging level than its definition will require its `Type`.
 
+#### Scope extrusion
+Within the contents of a splice, it is possible to have a quote that refers to a local variable defined in the outer quote.
+If this quote is used within the splice, the variable will be in scope.
+However, if the quote is somehow _extruded_ outside the splice, then variables might not be in scope anymore.
+Quoted expressions can be extruded using side effects such as mutable state and exceptions.
+The following example shows how a quote can be extruded using mutable state.
 ```scala
-var x: Expr[T] = ...
+var x: Expr[T] = null
 '{ (y: T) => ${ x = 'y; 1 } }
+x // has value '{y} but y is not in scope
 ```
 
-This code, if it was accepted, would _extrude_ a reference to a quoted variable
-`y` from its scope. This would subsequently allow access to a variable outside the
-scope where it is defined, which is likely problematic. The code is clearly
-phase consistent, so we cannot use PCP to rule it out. Instead, we postulate a
-future effect system that can guarantee that splices are pure. In the absence of
-such a system we simply demand that spliced expressions are pure by convention,
-and allow for undefined compiler behavior if they are not. This is analogous to
-the status of pattern guards in Scala, which are also required, but not
-verified, to be pure.
-
-[Multi-Stage Programming](./staging.md) introduces one additional method where
-you can expand code at runtime with a method `run`. There is also a problem with
-that invocation of `run` in splices. Consider the following expression:
+A second way a variable can be extruded is through the `run` method.
+If `run` consumes a quoted variable reference, it will not be in scope anymore.
+The result will reference a variable that is defined in the next stage.
 
 ```scala
-'{ (x: Int) => ${ run('x); 1 } }
+'{ (x: Int) => ${ run('x); ... } }
+// evaluates to: '{ (x: Int) => ${ x; ... } 1
 ```
 
-This is again phase correct, but will lead us into trouble. Indeed, evaluating
-the splice will reduce the expression `run('x)` to `x`. But then the result
+To catch both scope extrusion scenarios, our system restricts the use of quotes by only allowing a quote to be spliced if it was not extruded from a splice scope.
+Unlike level consistency, this is checked at run-time[^4] rather than compile-time to avoid making the static type system too complicated.
 
-```scala
-'{ (x: Int) => ${ x; 1 } }
-```
+Each `Quotes` instance contains a unique scope identifier and refers to its parent scope, forming a stack of identifiers.
+The parent of the scope of a `Quotes` is the scope of the `Quotes` used to create the enclosing quote.
+Top-level splices and `run` create new scope stacks.
+Every `Expr` knows in which scope it was created.
+When it is spliced, we check that the quote scope is either the same as the splice scope, or a parent scope thereof.
 
-is no longer phase correct. To prevent this soundness hole it seems easiest to
-classify `run` as a side-effecting operation. It would thus be prevented from
-appearing in splices. In a base language with side effects we would have to do this
-anyway: Since `run` runs arbitrary code it can always produce a side effect if
-the code it runs produces one.
 
-## Example Expansion
+## Staged Lambdas
 
-Assume we have two methods, `foreach` that takes an `Expr[Array[T]]` and a
-consumer `f`, and `sum` that performs a sum by delegating to `foreach`.
+When staging programs in a functional language there are two fundamental abstractions: a staged lambda `Expr[T => U]` and a staging lambda `Expr[T] => Expr[U]`.
+The first is a function that will exist in the next stage, whereas the second is a function that exists in the current stage.
+It is often convenient to have a mechanism to go from `Expr[T => U]` to `Expr[T] => Expr[U]` and vice versa.
 
 ```scala
-object Macros:
-
-  def foreach[T](arr: Expr[Array[T]], f: Expr[T] => Expr[Unit])
-            (using Type[T], Quotes): Expr[Unit] = '{
-    var i: Int = 0
-    while i < ($arr).length do
-      val element: T = ($arr)(i)
-      ${f('element)}
-      i += 1
-  }
-
-  def sum(arr: Expr[Array[Int]])(using Quotes): Expr[Int] = '{
-    var sum = 0
-    ${ foreach(arr, x => '{sum += $x}) }
-    sum
-  }
-
-  inline def sum_m(arr: Array[Int]): Int = ${sum('arr)}
+def later[T: Type, U: Type](f: Expr[T] => Expr[U]): Expr[T => U] =
+  '{ (x: T) => ${ f('x) } }
 
-end Macros
+def now[T: Type, U: Type](f: Expr[T => U]): Expr[T] => Expr[U] =
+  (x: Expr[T]) => '{ $f($x) }
 ```
 
-A call to `sum_m(Array(1, 2, 3))` will first inline `sum_m`:
+Both conversions can be performed out of the box with quotes and splices.
+But if `f` is a known lambda function, `'{ $f($x) }` will not beta-reduce the lambda in place.
+This optimization is performed in a later phase of the compiler.
+Not reducing the application immediately can simplify analysis of generated code.
+Nevertheless, it is possible to beta-reduce the lambda in place using the `Expr.betaReduce` method.
 
 ```scala
-val arr: Array[Int] = Array.apply(1, 2, 3)
-${ _root_.Macros.sum('arr) }
+def now[T: Type, U: Type](f: Expr[T => U]): Expr[T] => Expr[U] =
+  (x: Expr[T]) => Expr.betaReduce('{ $f($x) })
 ```
 
-then it will call `sum`:
+The `betaReduce` method will beta-reduce the outermost application of the expression if possible (regardless of arity).
+If it is not possible to beta-reduce the expression, then it will return the original expression.
 
+## Staged Constructors
+To create new class instances in a later stage, we can create them using factory methods (usually `apply` methods of an `object`), or we can instantiate them with a `new`.
+For example, we can write `Some(1)` or `new Some(1)`, creating the same value.
+In Scala 3, using the factory method call notation will fall back to a `new` if no `apply` method is found.
+We follow the usual staging rules when calling a factory method.
+Similarly, when we use a `new C`, the constructor of `C` is implicitly called, which also follows the usual staging rules.
+Therefore for an arbitrary known class `C`, we can use both `'{ C(...) }` or `'{ new C(...) }` as constructors.
+
+## Staged Classes
+Quoted code can contain any valid expression including local class definitions.
+This allows the creation of new classes with specialized implementations.
+For example, we can implement a new version of `Runnable` that will perform some optimized operation.
 ```scala
-val arr: Array[Int] = Array.apply(1, 2, 3)
-${ '{
-  var sum = 0
-  ${ foreach('arr, x => '{sum += $x}) }
-  sum
-} }
+def mkRunnable(x: Int)(using Quotes): Expr[Runnable] = '{
+  class MyRunnable extends Runnable:
+    def run(): Unit = ... // generate some custom code that uses `x`
+  new MyRunnable
+}
 ```
 
-and cancel the `${'{...}}`:
-
-```scala
-val arr: Array[Int] = Array.apply(1, 2, 3)
+The quoted class is a local class and its type cannot escape the enclosing quote.
+The class must be used inside the quote or an instance of it can be returned using a known interface (`Runnable` in this case).
 
-var sum = 0
-${ foreach('arr, x => '{sum += $x}) }
-sum
-```
+## Quote Pattern Matching
 
-then it will extract `x => '{sum += $x}` into `f`, to have a value:
+It is sometimes necessary to analyze the structure of the code or decompose the code into its sub-expressions.
+A classic example is an embedded DSL, where a macro knows a set of definitions that it can reinterpret while compiling the code (for instance, to perform optimizations).
+In the following example, we extend our previous implementation of `powCode` to look into `x` to perform further optimizations.
 
 ```scala
-val arr: Array[Int] = Array.apply(1, 2, 3)
-
-var sum = 0
-val f = x => '{sum += $x}
-${ _root_.Macros.foreach('arr, 'f)(Type.of[Int]) }
-sum
+def fusedPowCode(x: Expr[Double], n: Expr[Int])(using Quotes): Expr[Double] =
+  x match
+    case '{ power($y, $m) } => // we have (y^m)^n
+      fusedPowCode(y, '{ $n * $m }) // generate code for y^(n*m)
+    case _ =>
+      '{ power($x, $n) }
 ```
 
-and then call `foreach`:
-
-```scala
-val arr: Array[Int] = Array.apply(1, 2, 3)
 
-var sum = 0
-val f = x => '{sum += $x}
-${ '{
-  var i: Int = 0
-  while i < arr.length do
-    val element: Int = (arr)(i)
-    sum += element
-    i += 1
-  sum
-} }
-```
+#### Sub-patterns
 
-and cancel the `${'{...}}` again:
+In quoted patterns, the `$` binds the sub-expression to an expression `Expr` that can be used in that `case` branch.
+The contents of `${..}` in a quote pattern are regular Scala patterns.
+For example, we can use the `Expr(_)` pattern within the `${..}` to only match if it is a known value and extract it.
 
 ```scala
-val arr: Array[Int] = Array.apply(1, 2, 3)
-
-var sum = 0
-val f = x => '{sum += $x}
-var i: Int = 0
-while i < arr.length do
-  val element: Int = (arr)(i)
-  sum += element
-  i += 1
-sum
+def fusedUnrolledPowCode(x: Expr[Double], n: Int)(using Quotes): Expr[Double] =
+  x match
+    case '{ power($y, ${Expr(m)}) } => // we have (y^m)^n
+      fusedUnrolledPowCode(y, n * m) // generate code for y * ... * y
+    case _ =>                        //                  ( n*m times )
+      unrolledPowerCode(x, n)
 ```
 
-Finally cleanups and dead code elimination:
+These value extraction sub-patterns can be polymorphic using an instance of `FromExpr`.
+In the following example, we show the implementation of `OptionFromExpr` which internally uses the `FromExpr[T]` to extract the value using the `Expr(x)` pattern.
 
 ```scala
-val arr: Array[Int] = Array.apply(1, 2, 3)
-var sum = 0
-var i: Int = 0
-while i < arr.length do
-  val element: Int = arr(i)
-  sum += element
-  i += 1
-sum
+given OptionFromExpr[T](using Type[T], FromExpr[T]): FromExpr[Option[T]] with
+  def unapply(x: Expr[Option[T]])(using Quotes): Option[Option[T]] =
+    x match
+      case '{ Some( ${Expr(x)} ) } => Some(Some(x))
+      case '{ None } => Some(None)
+      case _ => None
 ```
 
-## Find implicits within a macro
 
-Similarly to the `summonFrom` construct, it is possible to make implicit search available
-in a quote context. For this we simply provide `scala.quoted.Expr.summon`:
 
-```scala
-import scala.collection.immutable.{ TreeSet, HashSet }
-inline def setFor[T]: Set[T] = ${ setForExpr[T] }
+#### Closed patterns
+Patterns may contain two kinds of references: global references such as the call to the `power` method in `'{ power(...) }`, or references to bindings defined in the pattern such as `x` in `case '{ (x: Int) => x }`.
+When extracting an expression from a quote, we need to ensure that we do not extrude any variable from the scope where it is defined.
 
-def setForExpr[T: Type](using Quotes): Expr[Set[T]] =
-  Expr.summon[Ordering[T]] match
-    case Some(ord) => '{ new TreeSet[T]()($ord) }
-    case _ => '{ new HashSet[T] }
+```scala
+'{ (x: Int) => x + 1 } match
+  case '{ (y: Int) => $z } =>
+    // should not match, otherwise: z = '{ x + 1 }
 ```
 
-## Relationship with Transparent Inline
+In this example, we see that the pattern should not match.
+Otherwise, any use of the expression `z` would contain an unbound reference to `x`.
+To avoid any such extrusion, we only match on a `${..}` if its expression is closed under the definitions within the pattern.
+Therefore, the pattern will not match if the expression is not closed.
 
-[Inline](./inline.md) documents inlining. The code below introduces a transparent
-inline method that can calculate either a value of type `Int` or a value of type
-`String`.
+#### HOAS patterns
+To allow extracting expressions that may contain extruded references we offer a _higher-order abstract syntax_ (HOAS) pattern `$f(y)` (or `$f(y1,...,yn)`).
+This pattern will eta-expand the sub-expression with respect to `y` and bind it to `f`.
+The lambda arguments will replace the variables that might have been extruded.
 
 ```scala
-transparent inline def defaultOf(inline str: String) =
-  ${ defaultOfImpl('str) }
-
-def defaultOfImpl(strExpr: Expr[String])(using Quotes): Expr[Any] =
-  strExpr.valueOrError match
-    case "int" => '{1}
-    case "string" => '{"a"}
-
-// in a separate file
-val a: Int = defaultOf("int")
-val b: String = defaultOf("string")
-
+'{ ((x: Int) => x + 1).apply(2) } match
+  case '{ ((y: Int) => $f(y)).apply($z: Int) } =>
+    // f may contain references to `x` (replaced by `$y`)
+    // f = (y: Expr[Int]) => '{ $y + 1 }
+    f(z) // generates '{ 2 + 1 }
 ```
 
-## Defining a macro and using it in a single project
-
-It is possible to define macros and use them in the same project as long as the implementation
-of the macros does not have run-time dependencies on code in the file where it is used.
-It might still have compile-time dependencies on types and quoted code that refers to the use-site file.
-
-To provide this functionality Scala 3 provides a transparent compilation mode where files that
-try to expand a macro but fail because the macro has not been compiled yet are suspended.
-If there are any suspended files when the compilation ends, the compiler will automatically restart
-compilation of the suspended files using the output of the previous (partial) compilation as macro classpath.
-In case all files are suspended due to cyclic dependencies the compilation will fail with an error.
-
-## Pattern matching on quoted expressions
 
-It is possible to deconstruct or extract values out of `Expr` using pattern matching.
+A HOAS pattern `$x(y1,...,yn)` will only match the expression if it does not contain references to variables defined in the pattern that are not in the set `y1,...,yn`.
+In other words, the pattern will match if the expression only contains references to variables defined in the pattern that are in `y1,...,yn`.
+Note that the HOAS patterns `$x()` are semantically equivalent to closed patterns `$x`.
 
-`scala.quoted` contains objects that can help extracting values from `Expr`.
 
-- `scala.quoted.Expr`/`scala.quoted.Exprs`: matches an expression of a value (resp. list of values) and returns the value (resp. list of values).
-- `scala.quoted.Const`/`scala.quoted.Consts`: Same as `Expr`/`Exprs` but only works on primitive values.
-- `scala.quoted.Varargs`: matches an explicit sequence of expressions and returns them. These sequences are useful to get individual `Expr[T]` out of a varargs expression of type `Expr[Seq[T]]`.
+#### Type variables
 
-These could be used in the following way to optimize any call to `sum` that has statically known values.
+Expressions may contain types that are not statically known.
+For example, an `Expr[List[Int]]` may contain `list.map(_.toInt)` where `list` is a `List` of some type.
+To cover all the possible cases we would need to explicitly match `list` on all possible types (`List[Int]`, `List[Int => Int]`, ...).
+This is an infinite set of types and therefore pattern cases.
+Even if we would know all possible types that a specific program could use, we may still end up with an unmanageable number of cases.
+To overcome this, we introduce type variables in quoted patterns, which will match any type.
 
+In the following example, we show how type variables `t` and `u` match all possible pairs of consecutive calls to `map` on lists.
+In the quoted patterns, types named with lower cases are identified as type variables.
+This follows the same notation as type variables used in normal patterns.
 ```scala
-inline def sum(inline args: Int*): Int = ${ sumExpr('args) }
-private def sumExpr(argsExpr: Expr[Seq[Int]])(using Quotes): Expr[Int] =
-  argsExpr match
-    case Varargs(args @ Exprs(argValues)) =>
-      // args is of type Seq[Expr[Int]]
-      // argValues is of type Seq[Int]
-      Expr(argValues.sum) // precompute result of sum
-    case Varargs(argExprs) => // argExprs is of type Seq[Expr[Int]]
-      val staticSum: Int = argExprs.map(_.value.getOrElse(0)).sum
-      val dynamicSum: Seq[Expr[Int]] = argExprs.filter(_.value.isEmpty)
-      dynamicSum.foldLeft(Expr(staticSum))((acc, arg) => '{ $acc + $arg })
-    case _ =>
-      '{ $argsExpr.sum }
-
-sum(1, 2, 3) // gets matched by Varargs
+def fuseMapCode(x: Expr[List[Int]]): Expr[List[Int]] =
+  x match
+    case '{ ($ls: List[t]).map[u]($f).map[Int]($g) } =>
+      '{ $ls.map($g.compose($f)) }
+    ...
 
-val xs = List(1, 2, 3)
-sum(xs*) // doesn't get matched by Varargs
+fuseMapCode('{ List(1.2).map(f).map(g) }) // '{ List(1.2).map(g.compose(f)) }
+fuseMapCode('{ List('a').map(h).map(i) }) // '{ List('a').map(i.compose(h))  }
 ```
+Variables `f` and `g` are inferred to be of type `Expr[t => u]` and `Expr[u => Int]` respectively.
+Subsequently, we can infer `$g.compose($f)` to be of type `Expr[t => Int]` which is the type of the argument of `$ls.map(..)`.
 
-### Quoted patterns
+Type variables are abstract types that will be erased; this implies that to reference them in the second quote we need a given `Type[t]` and `Type[u]`.
+The quoted pattern will implicitly provide those given types.
+At run-time, when the pattern matches, the type of `t` and `u` will be known, and the `Type[t]` and `Type[u]` will contain the precise types in the expression.
 
-Quoted pattens allow deconstructing complex code that contains a precise structure, types or methods.
-Patterns `'{ ... }` can be placed in any location where Scala expects a pattern.
+As `Expr` is covariant, the statically known type of the expression might not be the actual type.
+Type variables can also be used to recover the precise type of the expression.
+``scala
+def let(x: Expr[Any])(using Quotes): Expr[Any] =
+  x match
+    case '{ $x: t } =>
+      '{ val y: t = $x; y }
 
-For example
+let('{1}) // will return a `Expr[Any]` that contains an `Expr[Int]]`
+```
 
+While we can define the type variable in the middle of the pattern, their normal form is to define them as a `type` with a lower case name at the start of the pattern.
+We use the Scala backquote `` `t` `` naming convention which interprets the string within the backquote as a literal name identifier.
+This is typically used when we have names that contain special characters that are not allowed for normal Scala identifiers.
+But we use it to explicitly state that this is a reference to that name and not the introduction of a new variable.
 ```scala
-optimize {
-   sum(sum(1, a, 2), 3, b)
-} // should be optimized to 6 + a + b
+  case '{ type t; $x: `t` } =>
 ```
+This is a bit more verbose but has some expressivity advantages such as allowing to define bounds on the variables and be able to refer to them several times in any scope of the pattern.
 
 ```scala
-def sum(args: Int*): Int = args.sum
-inline def optimize(inline arg: Int): Int = ${ optimizeExpr('arg) }
-private def optimizeExpr(body: Expr[Int])(using Quotes): Expr[Int] =
-  body match
-    // Match a call to sum without any arguments
-    case '{ sum() } => Expr(0)
-    // Match a call to sum with an argument $n of type Int.
-    // n will be the Expr[Int] representing the argument.
-    case '{ sum($n) } => n
-    // Match a call to sum and extracts all its args in an `Expr[Seq[Int]]`
-    case '{ sum(${Varargs(args)}: _*) } => sumExpr(args)
-    case body => body
-
-private def sumExpr(args1: Seq[Expr[Int]])(using Quotes): Expr[Int] =
-  def flatSumArgs(arg: Expr[Int]): Seq[Expr[Int]] = arg match
-    case '{ sum(${Varargs(subArgs)}: _*) } => subArgs.flatMap(flatSumArgs)
-    case arg => Seq(arg)
-  val args2 = args1.flatMap(flatSumArgs)
-  val staticSum: Int = args2.map(_.value.getOrElse(0)).sum
-  val dynamicSum: Seq[Expr[Int]] = args2.filter(_.value.isEmpty)
-  dynamicSum.foldLeft(Expr(staticSum))((acc, arg) => '{ $acc + $arg })
+  case '{ type t >: List[Int] <: Seq[Int]; $x: `t` } =>
+  case '{ type t; $x: (`t`, `t`) } =>
 ```
 
-### Recovering precise types using patterns
 
-Sometimes it is necessary to get a more precise type for an expression. This can be achieved using the following pattern match.
+#### Type patterns
+It is possible to only have a type and no expression of that type.
+To be able to inspect a type, we introduce quoted type pattern `case '[..] =>`.
+It works the same way as a quoted pattern but is restricted to contain a type.
+Type variables can be used in quoted type patterns to extract a type.
 
 ```scala
-def f(expr: Expr[Any])(using Quotes) = expr match
-  case '{ $x: t } =>
-    // If the pattern match succeeds, then there is
-    // some type `t` such that
-    // - `x` is bound to a variable of type `Expr[t]`
-    // - `t` is bound to a new type `t` and a given
-    //   instance `Type[t]` is provided for it
-    // That is, we have `x: Expr[t]` and `given Type[t]`,
-    // for some (unknown) type `t`.
+def empty[T: Type]: Expr[T] =
+  Type.of[T] match
+    case '[String] => '{ "" }
+    case '[List[t]] => '{ List.empty[t] }
+    ...
 ```
 
-This might be used to then perform an implicit search as in:
-
-```scala
-extension (inline sc: StringContext)
-  inline def showMe(inline args: Any*): String = ${ showMeExpr('sc, 'args) }
-
-private def showMeExpr(sc: Expr[StringContext], argsExpr: Expr[Seq[Any]])(using Quotes): Expr[String] =
-  import quotes.reflect.report
-  argsExpr match
-    case Varargs(argExprs) =>
-      val argShowedExprs = argExprs.map {
-        case '{ $arg: tp } =>
-          Expr.summon[Show[tp]] match
-            case Some(showExpr) =>
-              '{ $showExpr.show($arg) }
-            case None =>
-              report.error(s"could not find implicit for ${Type.show[Show[tp]]}", arg); '{???}
-      }
-      val newArgsExpr = Varargs(argShowedExprs)
-      '{ $sc.s($newArgsExpr: _*) }
-    case _ =>
-      // `new StringContext(...).showMeExpr(args: _*)` not an explicit `showMeExpr"..."`
-      report.error(s"Args must be explicit", argsExpr)
-      '{???}
+`Type.of[T]` is used to summon the given instance of `Type[T]` in scope, it is equivalent to `summon[Type[T]]`.
 
-trait Show[-T]:
-  def show(x: T): String
+#### Type testing and casting
+It is important to note that instance checks and casts on `Expr`, such as `isInstanceOf[Expr[T]]` and `asInstanceOf[Expr[T]]`, will only check if the instance is of the class `Expr` but will not be able to check the `T` argument.
+These cases will issue a warning at compile-time, but if they are ignored, they can result in unexpected behavior.
 
-// in a different file
-given Show[Boolean] with
-  def show(b: Boolean) = "boolean!"
+These operations can be supported correctly in the system.
+For a simple type test it is possible to use the `isExprOf[T]` method of `Expr` to check if it is an instance of that type.
+Similarly, it is possible to use `asExprOf[T]` to cast an expression to a given type.
+These operations use a given `Type[T]` to work around type erasure.
 
-println(showMe"${true}")
-```
 
-### Open code patterns
+## Sub-Expression Transformation
 
-Quoted pattern matching also provides higher-order patterns to match open terms. If a quoted term contains a definition,
-then the rest of the quote can refer to this definition.
+The system provides a mechanism to transform all sub-expressions of an expression.
+This is useful when the sub-expressions we want to transform are deep in the expression.
+It is also necessary if the expression contains sub-expressions that cannot be matched using quoted patterns (such as local class definitions).
 
 ```scala
-'{
-  val x: Int = 4
-  x * x
-}
+trait ExprMap:
+  def transform[T](e: Expr[T])(using Type[T])(using Quotes): Expr[T]
+  def transformChildren[T](e: Expr[T])(using Type[T])(using Quotes): Expr[T] =
+    ...
 ```
 
-To match such a term we need to match the definition and the rest of the code, but we need to explicitly state that the rest of the code may refer to this definition.
+Users can extend the `ExprMap` trait and implement the `transform` method.
+This interface is flexible and can implement top-down, bottom-up, or other transformations.
 
 ```scala
-case '{ val y: Int = $x; $body(y): Int } =>
+object OptimizeIdentity extends ExprMap:
+  def transform[T](e: Expr[T])(using Type[T])(using Quotes): Expr[T] =
+    transformChildren(e) match // bottom-up transformation
+      case '{ identity($x) } => x
+      case _ => e
 ```
 
-Here `$x` will match any closed expression while `$body(y)` will match an expression that is closed under `y`. Then
-the subexpression of type `Expr[Int]` is bound to `body` as an `Expr[Int => Int]`. The extra argument represents the references to `y`. Usually this expression is used in combination with `Expr.betaReduce` to replace the extra argument.
+The `transformChildren` method is implemented as a primitive that knows how to reach all the direct sub-expressions and calls `transform` on each one.
+The type passed to `transform` is the expected type of this sub-expression in its expression.
+For example while transforming `Some(1)` in `'{ val x: Option[Int] = Some(1); ...}` the type will be `Option[Int]` and not `Some[Int]`.
+This implies that we can safely transform `Some(1)` into `None`.
+
+## Staged Implicit Summoning
+When summoning implicit arguments using `summon`, we will find the given instances in the current scope.
+It is possible to use `summon` to get staged implicit arguments by explicitly staging them first.
+In the following example, we can pass an implicit `Ordering[T]` in a macro as an `Expr[Ordering[T]]` to its implementation.
+Then we can splice it and give it implicitly in the next stage.
 
 ```scala
-inline def eval(inline e: Int): Int = ${ evalExpr('e) }
+inline def treeSetFor[T](using ord: Ordering[T]): Set[T] =
+  ${ setExpr[T](using 'ord) }
 
-private def evalExpr(e: Expr[Int])(using Quotes): Expr[Int] = e match
-  case '{ val y: Int = $x; $body(y): Int } =>
-    // body: Expr[Int => Int] where the argument represents
-    // references to y
-    evalExpr(Expr.betaReduce('{$body(${evalExpr(x)})}))
-  case '{ ($x: Int) * ($y: Int) } =>
-    (x.value, y.value) match
-      case (Some(a), Some(b)) => Expr(a * b)
-      case _ => e
-  case _ => e
+def setExpr[T:Type](using ord: Expr[Ordering[T]])(using Quotes): Expr[Set[T]] =
+  '{ given Ordering[T] = $ord; new TreeSet[T]() }
 ```
 
+We pass it as an implicit `Expr[Ordering[T]]` because there might be intermediate methods that can pass it along implicitly.
+
+An alternative is to summon implicit values in the scope where the macro is invoked.
+Using the `Expr.summon` method we get an optional expression containing the implicit instance.
+This provides the ability to search for implicit instances conditionally.
+
 ```scala
-eval { // expands to the code: (16: Int)
-  val x: Int = 4
-  x * x
-}
+def summon[T: Type](using Quotes): Option[Expr[T]]
 ```
 
-We can also close over several bindings using `$b(a1, a2, ..., an)`.
-To match an actual application we can use braces on the function part `${b}(a1, a2, ..., an)`.
+```scala
+inline def setFor[T]: Set[T] =
+  ${ setForExpr[T] }
+
+def setForExpr[T: Type]()(using Quotes): Expr[Set[T]] =
+  Expr.summon[Ordering[T]] match
+    case Some(ord) =>
+      '{ new TreeSet[T]()($ord) }
+    case _ =>
+      '{ new HashSet[T] }
+```
 
 ## More details
 
-[More details](./macros-spec.md)
+* [Specification](./macros-spec.md)
+* Scalable Metaprogramming in Scala 3[^1]
+
+
+[^1]: [Scalable Metaprogramming in Scala 3](https://infoscience.epfl.ch/record/299370)
+[^2]: [Semantics-preserving inlining for metaprogramming](https://dl.acm.org/doi/10.1145/3426426.3428486)
+[^3]: Implemented in the Scala 3 Dotty project https://github.com/lampepfl/dotty. sbt library dependency `"org.scala-lang" %% "scala3-staging" % scalaVersion.value`
+[^4]: Using the `-Xcheck-macros` compiler flag
diff --git a/docs/_docs/reference/metaprogramming/staging.md b/docs/_docs/reference/metaprogramming/staging.md
index e74d491402b5..1c154e09f50e 100644
--- a/docs/_docs/reference/metaprogramming/staging.md
+++ b/docs/_docs/reference/metaprogramming/staging.md
@@ -1,6 +1,6 @@
 ---
 layout: doc-page
-title: "Runtime Multi-Stage Programming"
+title: "Run-Time Multi-Stage Programming"
 nightlyOf: https://docs.scala-lang.org/scala3/reference/metaprogramming/staging.html
 ---
 
@@ -60,7 +60,7 @@ impose the following restrictions on the use of splices.
 The framework as discussed so far allows code to be staged, i.e. be prepared
 to be executed at a later stage. To run that code, there is another method
 in class `Expr` called `run`. Note that `$` and `run` both map from `Expr[T]`
-to `T` but only `$` is subject to the [PCP](./macros.md#the-phase-consistency-principle), whereas `run` is just a normal method.
+to `T` but only `$` is subject to [Cross-Stage Safety](./macros.md#cross-stage-safety), whereas `run` is just a normal method.
 `scala.quoted.staging.run` provides a `Quotes` that can be used to show the expression in its scope.
 On the other hand `scala.quoted.staging.withQuotes` provides a `Quotes` without evaluating the expression.
 
diff --git a/docs/_spec/TODOreference/metaprogramming/macros-spec.md b/docs/_spec/TODOreference/metaprogramming/macros-spec.md
index aa8f94a9a1f7..6045354fdbbc 100644
--- a/docs/_spec/TODOreference/metaprogramming/macros-spec.md
+++ b/docs/_spec/TODOreference/metaprogramming/macros-spec.md
@@ -4,251 +4,711 @@ title: "Macros Spec"
 nightlyOf: https://docs.scala-lang.org/scala3/reference/metaprogramming/macros-spec.html
 ---
 
+## Formalization
+
+* Multi-stage programming with generative and analytical macros[^2]
+* Multi-Stage Macro Calculus, Chapter 4 of Scalable Metaprogramming in Scala 3[^1].
+  Contains and extends the calculus of _Multi-stage programming with generative and analytical macros_ with type polymorphism.
+
+## Syntax
+
+The quotation syntax using `'` and `$` was chosen to mimic the string interpolation syntax of Scala.
+Like a string double-quotation, a single-quote block can contain splices.
+However, unlike strings, splices can contain quotes using the same rules.
+
+```scala
+s" Hello $name"           s" Hello ${name}"
+'{ hello($name) }         '{ hello(${name}) }
+${ hello('name) }         ${ hello('{name}) }
+```
+
+### Quotes
+Quotes come in four flavors: quoted identifiers, quoted blocks, quoted block patterns and quoted type patterns.
+Scala 2 used quoted identifiers to represent `Symbol` literals. They were deprecated in Scala 3, allowing to use them for quotation.
+```scala
+SimpleExpr ::= ...
+             |  `'` alphaid                           // quoted identifier
+             |  `'` `{` Block `}`                     // quoted block
+Pattern    ::= ...
+             |  `'` `{` Block `}`                     // quoted block pattern
+             |  `'` `[` Type `]`                      // quoted type pattern
+```
+
+Quoted blocks and quoted block patterns contain an expression equivalent to a normal block of code.
+When entering either of those we track the fact that we are in a quoted block (`inQuoteBlock`) which is used for spliced identifiers.
+When entering a quoted block pattern we additionally track the fact that we are in a quoted pattern (`inQuotePattern`) which is used to distinguish spliced blocks and splice patterns.
+Lastly, the quoted type pattern simply contains a type.
+
+### Splices
+Splices come in three flavors: spliced identifiers, spliced blocks and splice patterns.
+Scala specifies identifiers containing `$` as valid identifiers but reserves them for compiler and standard library use only.
+Unfortunately, many libraries have used such identifiers in Scala~2. Therefore to mitigate the cost of migration, we still support them.
+We work around this by only allowing spliced identifiers[^3] within quoted blocks or quoted block patterns (`inQuoteBlock`).
+Splice blocks and splice patterns can contain an arbitrary block or pattern respectively.
+They are distinguished based on their surrounding quote (`inQuotePattern`), a quote block will contain spliced blocks, and a quote block pattern will contain splice patterns.
+
+```scala
+SimpleExpr ::= ...
+             |  `$` alphaid         if  inQuoteBlock    // spliced identifier
+             |  `$` `{` Block `}`   if !inQuotePattern  // spliced block
+             |  `$` `{` Pattern `}` if  inQuotePattern  // splice pattern
+```
+
+### Quoted Pattern Type Variables
+Quoted pattern type variables in quoted patterns and quoted type patterns do not require additional syntax.
+Any type definition or reference with a name composed of lower cases is assumed to be a pattern type variable definition while typing.
+A backticked type name with lower cases is interpreted as a reference to the type with that name.
+
+
 ## Implementation
 
-### Syntax
-
-Compared to the [Scala 3 reference grammar](../syntax.md)
-there are the following syntax changes:
-```
-SimpleExpr      ::=  ...
-                  |  ‘'’ ‘{’ Block ‘}’
-                  |  ‘'’ ‘[’ Type ‘]’
-                  |  ‘$’ ‘{’ Block ‘}’
-SimpleType      ::=  ...
-                  |  ‘$’ ‘{’ Block ‘}’
-```
-In addition, an identifier `$x` starting with a `$` that appears inside
-a quoted expression or type is treated as a splice `${x}` and a quoted identifier
-`'x` that appears inside a splice is treated as a quote `'{x}`
-
-### Implementation in `scalac`
-
-Quotes and splices are primitive forms in the generated abstract syntax trees.
-Top-level splices are eliminated during macro expansion while typing. On the
-other hand, top-level quotes are eliminated in an expansion phase `PickleQuotes`
-phase (after typing and pickling). PCP checking occurs while preparing the RHS
-of an inline method for top-level splices and in the `Staging` phase (after
-typing and before pickling).
-
-Macro-expansion works outside-in. If the outermost scope is a splice,
-the spliced AST will be evaluated in an interpreter. A call to a
-previously compiled method can be implemented as a reflective call to
-that method. With the restrictions on splices that are currently in
-place that’s all that’s needed. We might allow more interpretation in
-splices in the future, which would allow us to loosen the
-restriction.  Quotes in spliced, interpreted code are kept as they
-are, after splices nested in the quotes are expanded.
-
-If the outermost scope is a quote, we need to generate code that
-constructs the quoted tree at run-time. We implement this by
-serializing the tree as a TASTy structure, which is stored
-in a string literal. At runtime, an unpickler method is called to
-deserialize the string into a tree.
-
-Splices inside quoted code insert the spliced tree as is, after
-expanding any quotes in the spliced code recursively.
+### Run-Time Representation
 
-## Formalization
+The standard library defines the `Quotes` interface which contains all the logic and the abstract classes `Expr` and `Type`.
+The compiler implements the `Quotes` interface and provides the implementation of `Expr` and `Type`.
 
-The phase consistency principle can be formalized in a calculus that
-extends simply-typed lambda calculus with quotes and splices.
+##### `class Expr`
+Expressions of type `Expr[T]` are represented by the following abstract class:
+```scala
+abstract class Expr[+T] private[scala]
+```
+The only implementation of `Expr` is in the compiler along with the implementation of `Quotes`.
+It is a class that wraps a typed AST and a `Scope` object with no methods of its own.
+The `Scope` object is used to track the current splice scope and detect scope extrusions.
 
-### Syntax
+##### `object Expr`
+The companion object of `Expr` contains a few useful static methods;
+the `apply`/`unapply` methods to use `ToExpr`/`FromExpr` with ease;
+the `betaReduce` and `summon` methods.
+It also contains methods to create expressions out of lists or sequences of expressions: `block`, `ofSeq`, `ofList`, `ofTupleFromSeq` and `ofTuple`.
 
-The syntax of terms, values, and types is given as follows:
+```scala
+object Expr:
+  def apply[T](x: T)(using ToExpr[T])(using Quotes): Expr[T] = ...
+  def unapply[T](x: Expr[T])(using FromExpr[T])(using Quotes): Option[T] = ...
+  def betaReduce[T](e: Expr[T])(using Quotes): Expr[T] = ...
+  def summon[T: Type](using Quotes): Option[Expr[T]] = ...
+  def block[T](stats: List[Expr[Any]], e: Expr[T])(using Quotes): Expr[T] = ...
+  def ofSeq[T: Type](xs: Seq[Expr[T]])(using Quotes): Expr[Seq[T]] = ...
+  def ofList[T: Type](xs: Seq[Expr[T]])(using Quotes): Expr[List[T]] = ...
+  def ofTupleFromSeq(xs: Seq[Expr[Any]])(using Quotes): Expr[Tuple] = ...
+  def ofTuple[T <: Tuple: Tuple.IsMappedBy[Expr]: Type](tup: T)(using Quotes):
+      Expr[Tuple.InverseMap[T, Expr]] = ...
 ```
-Terms         t  ::=  x                 variable
-                      (x: T) => t       lambda
-                      t t               application
-                      't                quote
-                      $t                splice
 
-Values        v  ::=  (x: T) => t       lambda
-                      'u                quote
+##### `class Type`
+Types of type `Type[T]` are represented by the following abstract class:
+```scala
+abstract class Type[T <: AnyKind] private[scala]:
+  type Underlying = T
+```
+
+The only implementation of `Type` is in the compiler along with the implementation of `Quotes`.
+It is a class that wraps the AST of a type and a `Scope` object with no methods of its own.
+The upper bound of `T` is `AnyKind` which implies that `T` may be a higher-kinded type.
+The `Underlying` alias is used to select the type from an instance of `Type`.
+Users never need to use this alias as they can always use `T` directly.
+`Underlying` is used for internal encoding while compiling the code (see _Type Healing_).
 
-Simple terms  u  ::=  x  |  (x: T) => u  |  u u  |  't
+##### `object Type`
+The companion object of `Type` contains a few useful static methods.
+The first and most important one is the `Type.of` given definition.
+This instance of `Type[T]` is summoned by default when no other instance is available.
+The `of` operation is an intrinsic operation that the compiler will transform into code that will generate the `Type[T]` at run-time.
+Secondly, the `Type.show[T]` operation will show a string representation of the type, which is often useful when debugging.
+Finally, the object defines `valueOfConstant` (and `valueOfTuple`) which can transform singleton types (or tuples of singleton types) into their value.
 
-Types         T  ::=  A                 base type
-                      T -> T            function type
-                      expr T            quoted
+
+```scala
+object Type:
+  given of[T <: AnyKind](using Quotes): Type[T] = ...
+  def show[T <: AnyKind](using Type[T])(using Quotes): String = ...
+  def valueOfConstant[T](using Type[T])(using Quotes): Option[T] = ...
+  def valueOfTuple[T <: Tuple](using Type[T])(using Quotes): Option[T] = ...
 ```
-Typing rules are formulated using a stack of environments
-`Es`. Individual environments `E` consist as usual of variable
-bindings `x: T`. Environments can be combined using the two
-combinators `'` and `$`.
+
+##### `Quotes`
+The `Quotes` interface is where most of the primitive operations of the quotation system are defined.
+
+Quotes define all the `Expr[T]` methods as extension methods.
+`Type[T]` does not have methods and therefore does not appear here.
+These methods are available as long as `Quotes` is implicitly given in the current scope.
+
+The `Quotes` instance is also the entry point to the [reflection API](./refelction.md) through the `reflect` object.
+
+Finally, `Quotes` provides the internal logic used in quote un-pickling (`QuoteUnpickler`) in quote pattern matching (`QuoteMatching`).
+These interfaces are added to the self-type of the trait to make sure they are implemented on this object but not visible to users of `Quotes`.
+
+Internally, the implementation of `Quotes` will also track its current splicing scope `Scope`.
+This scope will be attached to any expression that is created using this `Quotes` instance.
+
+```scala
+trait Quotes:
+  this: runtime.QuoteUnpickler & runtime.QuoteMatching =>
+
+  extension [T](self: Expr[T])
+    def show: String
+    def matches(that: Expr[Any]): Boolean
+    def value(using FromExpr[T]): Option[T]
+    def valueOrAbort(using FromExpr[T]): T
+  end extension
+
+  extension (self: Expr[Any])
+    def isExprOf[X](using Type[X]): Boolean
+    def asExprOf[X](using Type[X]): Expr[X]
+  end extension
+
+  // abstract object reflect ...
 ```
-Environment   E  ::=  ()                empty
-                      E, x: T
 
-Env. stack    Es ::=  ()                empty
-                      E                 simple
-                      Es * Es           combined
 
-Separator     *  ::=  '
-                      $
+##### `Scope`
+The splice context is represented as a stack (immutable list) of `Scope` objects.
+Each `Scope` contains the position of the splice (used for error reporting) and a reference to the enclosing splice scope `Scope`.
+A scope is a sub-scope of another if the other is contained in its parents.
+This check is performed when an expression is spliced into another using the `Scope` provided in the current scope in `Quotes` and the one in the `Expr` or `Type`.
+
+### Entry Points
+The two entry points for multi-stage programming are macros and the `run` operation.
+
+#### Macros
+Inline macro definitions will inline a top-level splice (a splice not nested in a quote).
+This splice needs to be evaluated at compile-time.
+In _Avoiding a complete interpreter_[^1], we stated the following restrictions:
+
+ * The top-level splice must contain a single call to a compiled static method.
+ * Arguments to the function are either literal constants, quoted expressions (parameters), `Type.of` for type parameters and a reference to `Quotes`.
+
+These restrictions make the implementation of the interpreter quite simple.
+Java Reflection is used to call the single function call in the top-level splice.
+The execution of that function is entirely done on compiled bytecode.
+These are Scala static methods and may not always become Java static methods, they might be inside module objects.
+As modules are encoded as class instances, we need to interpret the prefix of the method to instantiate it before we can invoke the method.
+
+The code of the arguments has not been compiled and therefore needs to be interpreted by the compiler.
+Interpreting literal constants is as simple as extracting the constant from the AST that represents literals.
+When interpreting a quoted expression, the contents of the quote is kept as an AST which is wrapped inside the implementation of `Expr`.
+Calls to `Type.of[T]` also wrap the AST of the type inside the implementation of `Type`.
+Finally, the reference to `Quotes` is supposed to be the reference to the quotes provided by the splice.
+This reference is interpreted as a new instance of `Quotes` that contains a fresh initial `Scope` with no parents.
+
+The result of calling the method via Java Reflection will return an `Expr` containing a new AST that was generated by the implementation of that macro.
+The scope of this `Expr` is checked to make sure it did not extrude from some splice or `run` operation.
+Then the AST is extracted from the `Expr` and it is inserted as replacement for the AST that contained the top-level splice.
+
+
+#### Run-time Multi-Stage Programming
+
+To be able to compile the code, the `scala.quoted.staging` library defines the `Compiler` trait.
+An instance of `staging.Compiler` is a wrapper over the normal Scala~3 compiler.
+To be instantiated it requires an instance of the JVM _classloader_ of the application.
+
+```scala
+import scala.quoted.staging.*
+given Compiler = Compiler.make(getClass.getClassLoader)
 ```
-The two environment combinators are both associative with left and
-right identity `()`.
 
-### Operational semantics
+The classloader is needed for the compiler to know which dependencies have been loaded and to load the generated code using the same classloader.
+
+```scala
+def mkPower2()(using Quotes): Expr[Double => Double] = ...
 
-We define a small step reduction relation `-->` with the following rules:
+run(mkPower2())
 ```
-          ((x: T) => t) v  -->  [x := v]t
+To run the previous example, the compiler will create code equivalent to the following class and compile it using a new `Scope` without parents.
+
+```scala
+class RunInstance:
+  def exec(): Double => Double = ${ mkPower2() }
+```
+Finally, `run` will interpret `(new RunInstance).exec()` to evaluate the contents of the quote.
+To do this, the resulting `RunInstance` class is loaded in the JVM using Java Reflection, instantiated and then the `exec` method is invoked.
+
+
+### Compilation
+
+Quotes and splices are primitive forms in the generated typed abstract syntax trees.
+These need to be type-checked with some extra rules, e.g., staging levels need to be checked and the references to generic types need to be adapted.
+Finally, quoted expressions that will be generated at run-time need to be encoded (serialized) and decoded (deserialized).
+
+#### Typing Quoted Expressions
 
-                    ${'u}  -->  u
+The typing process for quoted expressions and splices with `Expr` is relatively straightforward.
+At its core, quotes are desugared into calls to `quote`, splices are desugared into calls to `splice`.
+We track the quotation level when desugaring into these methods.
 
-                       t1  -->  t2
-                    -----------------
-                    e[t1]  -->  e[t2]
+
+```scala
+def quote[T](x: T): Quotes ?=> Expr[T]
+
+def splice[T](x: Quotes ?=> Expr[T]): T
 ```
-The first rule is standard call-by-value beta-reduction. The second
-rule says that splice and quotes cancel each other out. The third rule
-is a context rule; it says that reduction is allowed in the hole `[ ]`
-position of an evaluation context.  Evaluation contexts `e` and
-splice evaluation context `e_s` are defined syntactically as follows:
+
+It would be impossible to track the quotation levels if users wrote calls to these methods directly.
+To know if it is a call to one of those methods we would need to type it first, but to type it we would need to know if it is one of these methods to update the quotation level.
+Therefore these methods can only be used by the compiler.
+
+At run-time, the splice needs to have a reference to the `Quotes` that created its surrounding quote.
+To simplify this for later phases, we track the current `Quotes` and encode a reference directly in the splice using `nestedSplice` instead of `splice`.
+
+```scala
+def nestedSplice[T](q: Quotes)(x: q.Nested ?=> Expr[T]): T
 ```
-Eval context    e    ::=  [ ]  |  e t  |  v e  |  'e_s[${e}]
-Splice context  e_s  ::=  [ ]  |  (x: T) => e_s  |  e_s t  |  u e_s
+With this addition, the original `splice` is only used for top-level splices.
+
+The levels are mostly used to identify top-level splices that need to be evaluated while typing.
+We do not use the quotation level to influence the typing process.
+Level checking is performed at a later phase.
+This ensures that a source expression in a quote will have the same elaboration as a source expression outside the quote.
+
+
+
+#### Quote Pattern Matching
+
+Pattern matching is defined in the trait `QuoteMatching`, which is part of the self type of `Quotes`.
+It is implemented by `Quotes` but not available to users of `Quotes`.
+To access it, the compiler generates a cast from `Quotes` to `QuoteMatching` and then selects one of its two members: `ExprMatch` or `TypeMatch`.
+`ExprMatch` defines an `unapply` extractor method that is used to encode quote patterns and `TypeMatch` defines an `unapply` method for quoted type patterns.
+
+```scala
+trait Quotes:
+  self: runtime.QuoteMatching & ...  =>
+  ...
+
+trait QuoteMatching:
+  object ExprMatch:
+    def unapply[TypeBindings <: Tuple, Tup <: Tuple]
+               (scrutinee: Expr[Any])
+               (using pattern: Expr[Any]): Option[Tup] = ...
+  object TypeMatch:
+    ...
 ```
 
-### Typing rules
+These extractor methods are only meant to be used in code generated by the compiler.
+The call to the extractor that is generated has an already elaborated form that cannot be written in source, namely explicit type parameters and explicit contextual parameters.
+
+This extractor returns a tuple type `Tup` which cannot be inferred from the types in the method signature.
+This type will be computed when typing the quote pattern and will be explicitly added to the extractor call.
+To refer to type variables in arbitrary places of `Tup`, we need to define them all before their use, hence we have `TypeBindings`, which will contain all pattern type variable definitions.
+The extractor also receives a given parameter of type `Expr[Any]` that will contain an expression that represents the pattern.
+The compiler will explicitly add this pattern expression.
+We use a given parameter because these are the only parameters we are allowed to add to the extractor call in a pattern position.
+
+This extractor is a bit convoluted, but it encodes away all the quotation-specific features.
+It compiles the pattern down into a representation that the pattern matcher compiler phase understands.
 
-Typing judgments are of the form `Es |- t: T`. There are two
-substructural rules which express the fact that quotes and splices
-cancel each other out:
+The quote patterns are encoded into two parts: a tuple pattern that is tasked with extracting the result of the match and a quoted expression representing the pattern.
+For example, if the pattern has no `$` we will have an `EmptyTuple` as the pattern and `'{1}` to represent the pattern.
+
+```scala
+  case '{ 1 } =>
+// is elaborated to
+  case ExprMatch(EmptyTuple)(using '{1}) =>
+//               ^^^^^^^^^^  ^^^^^^^^^^
+//                pattern    expression
+```
+When extracting expressions, each pattern that is contained in a splice `${..}` will be placed in order in the tuple pattern.
+In the following case, the `f` and `x` are placed in a tuple pattern `(f, x)`.
+The type of the tuple is encoded in the `Tup` and not only in the tuple itself.
+Otherwise, the extractor would return a tuple `Tuple` for which the types need to be tested which is in turn not possible due to type erasure.
+
+```scala
+  case '{ ((y: Int) => $f(y)).apply($x) } =>
+// is elaborated to
+  case ExprMatch[.., (Expr[Int => Int], Expr[Int])]((f, x))(using pattern) =>
+// pattern = '{ ((y: Int) => pat[Int](y)).apply(pat[Int]()) }
 ```
-                    Es1 * Es2 |- t: T
-               ---------------------------
-               Es1 $ E1 ' E2 * Es2 |- t: T
+The contents of the quote are transformed into a valid quote expression by replacing the splice with a marker expression `pat[T](..)`.
+The type `T` is taken from the type of the splice and the arguments are the HOAS arguments.
+This implies that a `pat[T]()` is a closed pattern and `pat[T](y)` is an HOAS pattern that can refer to `y`.
 
 
-                    Es1 * Es2 |- t: T
-               ---------------------------
-               Es1 ' E1 $ E2 * Es2 |- t: T
+Type variables in quoted patterns are first normalized to have all definitions at the start of the pattern.
+For each definition of a type variable `t` in the pattern we will add a type variable definition in `TypeBindings`.
+Each one will have a corresponding `Type[t]` that will get extracted if the pattern matches.
+These `Type[t]` are also listed in the `Tup` and added in the tuple pattern.
+It is additionally marked as `using` in the pattern to make it implicitly available in this case branch.
+
+
+```scala
+  case '{ type t; ($xs: List[t]).map[t](identity[t]) } =>
+// is elaborated to
+  case ExprMatch[(t), (Type[t], Expr[List[t]])]((using t, xs))(using p) =>
+//               ^^^  ^^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^  ^^^^^^^
+//     type bindings        result type            pattern     expression
+// p = '{ @patternType type u; pat[List[u]]().map[u](identity[u]) }
 ```
-The lambda calculus fragment of the rules is standard, except that we
-use a stack of environments. The rules only interact with the topmost
-environment of the stack.
+
+The contents of the quote are transformed into a valid quote expression by replacing type variables with fresh ones that do not escape the quote scope.
+These are also annotated to be easily identifiable as pattern variables.
+
+#### Level Consistency Checking
+Level consistency checking is performed after typing the program as a static check.
+To check level consistency we traverse the tree top-down remembering the context staging level.
+Each local definition in scope is recorded with its level and each term reference to a definition is checked against the current staging level.
+```scala
+// level 0
+'{ // level 1
+  val x = ... // level 1 with (x -> 1)
+  ${ // level 0 (x -> 1)
+    val y = ... // level 0 with (x -> 1, y -> 0)
+    x // error: defined at level 1 but used in level 0
+  }
+  // level 1 (x -> 1)
+  x // x is ok
+}
 ```
-                          x: T in E
-                        --------------
-                        Es * E |- x: T
 
+#### Type Healing
 
-                    Es * E, x: T1 |- t: T2
-                -------------------------------
-                Es * E |- (x: T1) => t: T -> T2
+When using a generic type `T` in a future stage, it is necessary to have a given `Type[T]` in scope.
+The compiler needs to identify those references and link them with the instance of `Type[T]`.
+For instance consider the following example:
 
+```scala
+def emptyList[T](using t: Type[T])(using Quotes): Expr[List[T]] =
+  '{ List.empty[T] }
+```
 
-               Es |- t1: T2 -> T    Es |- t2: T2
-               ---------------------------------
-                      Es |- t1 t2: T
+For each reference to a generic type `T` that is defined at level 0 and used at level 1 or greater, the compiler will summon a `Type[T]`.
+This is usually the given type that is provided as parameter, `t` in this case.
+We can use the type `t.Underlying` to replace `T` as it is an alias of that type.
+But `t.Underlying` contains the extra information that it is `t` that will be used in the evaluation of the quote.
+In a sense, `Underlying` acts like a splice for types.
+
+```scala
+def emptyList[T](using t: Type[T])(using Quotes): Expr[List[T]] =
+  '{ List.empty[t.Underlying] }
 ```
-The rules for quotes and splices map between `expr T` and `T` by trading `'` and `$` between
-environments and terms.
+
+Due to some technical limitations, it is not always possible to replace the type reference with the AST containing `t.Underlying`.
+To overcome this limitation, we can simply define a list of type aliases at the start of the quote and insert the `t.Underlying` there.
+This has the added advantage that we do not have to repeatedly insert the `t.Underlying` in the quote.
+
+```scala
+def emptyList[T](using t: Type[T])(using Quotes): Expr[List[T]] =
+  '{ type U = t.Underlying; List.empty[U] }
+```
+These aliases can be used at any level within the quote and this transformation is only performed on quotes that are at level 0.
+
+```scala
+  '{ List.empty[T] ... '{ List.empty[T] } ... }
+// becomes
+  '{ type U = t.Underlying; List.empty[U] ... '{ List.empty[U] } ... }
+```
+If we define a generic type at level 1 or greater, it will not be subject to this transformation.
+In some future compilation stage, when the definition of the generic type is at level 0, it will be subject to this transformation.
+This simplifies the transformation logic and avoids leaking the encoding into code that a macro could inspect.
+
+```scala
+'{
+  def emptyList[T: Type](using Quotes): Expr[List[T]] = '{ List.empty[T] }
+  ...
+}
+```
+A similar transformation is performed on `Type.of[T]`.
+Any generic type in `T` needs to have an implicitly given `Type[T]` in scope, which will also be used as a path.
+The example:
+
+```scala
+def empty[T](using t: Type[T])(using Quotes): Expr[T] =
+  Type.of[T] match ...
+// becomes
+def empty[T](using t: Type[T])(using Quotes): Expr[T] =
+  Type.of[t.Underlying] match ...
+// then becomes
+def empty[T](using t: Type[T])(using Quotes): Expr[T] =
+  t match ...
+```
+
+The operation `Type.of[t.Underlying]` can be optimized to just `t`.
+But this is not always the case.
+If the generic reference is nested in the type, we will need to keep the `Type.of`.
+
+```scala
+def matchOnList[T](using t: Type[T])(using Quotes): Expr[List[T]] =
+  Type.of[List[T]] match ...
+// becomes
+def matchOnList[T](using t: Type[T])(using Quotes): Expr[List[T]] =
+  Type.of[List[t.Underlying]] match ...
+```
+
+By doing this transformation, we ensure that each abstract type `U` used in `Type.of` has an implicit `Type[U]` in scope.
+This representation makes it simpler to identify parts of the type that are statically known from those that are known dynamically.
+Type aliases are also added within the type of the `Type.of` though these are not valid source code.
+These would look like `Type.of[{type U = t.Underlying; Map[U, U]}]` if written in source code.
+
+
+#### Splice Normalization
+
+The contents of a splice may refer to variables defined in the enclosing quote.
+This complicates the process of serialization of the contents of the quotes.
+To make serialization simple, we first transform the contents of each level 1 splice.
+Consider the following example:
+
+```scala
+def power5to(n: Expr[Int]): Expr[Double] = '{
+  val x: Int = 5
+  ${ powerCode('{x}, n) }
+}
+```
+
+The variable `x` is defined in the quote and used in the splice.
+The normal form will extract all references to `x` and replace them with a staged version of `x`.
+We will replace the reference to `x` of type `T` with a `$y` where `y` is of type `Expr[T]`.
+Then we wrap the new contents of the splice in a lambda that defines `y` and apply it to the quoted version of `x`.
+After this transformation we have 2 parts, a lambda without references to the quote, which knows how to compute the contents of the splice, and a sequence of quoted arguments that refer to variables defined in the lambda.
+
+```scala
+def power5to(n: Expr[Int]): Expr[Double] = '{
+  val x: Int = 5
+  ${ ((y: Expr[Int]) => powerCode('{$y}, n)).apply('x) }
+}
+```
+
+In general, the splice normal form has the shape `${ <lambda>.apply(<args>*) }` and the following constraints:
+ * `<lambda>` a lambda expression that does not refer to variables defined in the outer quote
+ * `<args>` sequence of quoted expressions or `Type.of` containing references to variables defined in the enclosing quote and no references to local variables defined outside the enclosing quote
+
+
+##### Function references normalization
+A reference to a function `f` that receives parameters is not a valid value in Scala.
+Such a function reference `f` can be eta-expaned as `x => f(x)` to be used as a lambda value.
+Therefore function references cannot be transformed by the normalization as directly as other expressions as we cannot represent `'{f}` with a method reference type.
+We can use the eta-expanded form of `f` in the normalized form.
+For example, consider the reference to `f` below.
+
+```scala
+'{
+  def f(a: Int)(b: Int, c: Int): Int = 2 + a + b + c
+  ${ '{ f(3)(4, 5) } }
+}
+```
+
+To normalize this code, we can eta-expand the reference to `f` and place it in a quote containing a proper expression.
+Therefore the normalized form of the argument `'{f}` becomes the quoted lambda `'{ (a: Int) => (b: Int, c: Int) => f(a)(b, c) }` and is an expression of type `Expr[Int => (Int, Int) => Int]`.
+The eta-expansion produces one curried lambda per parameter list.
+The application `f(3)(4, 5)` does not become `$g(3)(4, 5)` but `$g.apply(3).apply(4, 5)`.
+We add the `apply` because `g` is not a quoted reference to a function but a curried lambda.
+
+```scala
+'{
+  def f(a: Int)(b: Int, c: Int): Int = 2 + a + b + c
+  ${
+    (
+      (g: Expr[Int => (Int, Int) => Int]) => '{$g.apply(3).apply(4, 5)}
+    ).apply('{ (a: Int) => (b: Int, c: Int) => f(a)(b, c) })
+  }
+}
+```
+
+Then we can apply it and beta-reduce the application when generating the code.
+
+```scala
+      (g: Expr[Int => Int => Int]) => betaReduce('{$g.apply(3).apply(4)})
+```
+
+
+##### Variable assignment normalization
+A reference to a mutable variable in the left-hand side of an assignment cannot be transformed directly as it is not in an expression position.
+```scala
+'{
+  var x: Int = 5
+  ${ g('{x = 2}) }
+}
+```
+
+We can use the same strategy used for function references by eta-expanding the assignment operation `x = _` into `y => x = y`.
+
+```scala
+'{
+  var x: Int = 5
+  ${
+    g(
+      (
+        (f: Expr[Int => Unit]) => betaReduce('{$f(2)})
+      ).apply('{ (y: Int) => x = $y })
+    )
+  }
+}
+```
+
+
+##### Type normalization
+Types defined in the quote are subject to a similar transformation.
+In this example, `T` is defined within the quote at level 1 and used in the splice again at level 1.
+
+```scala
+'{ def f[T] = ${ '{g[T]} } }
+```
+
+The normalization will add a `Type[T]` to the lambda, and we will insert this reference.
+The difference is that it will add an alias similar to the one used in type healing.
+In this example, we create a `type U` that aliases the staged type.
+
+```scala
+'{
+  def f[T] = ${
+    (
+      (t: Type[T]) => '{type U = t.Underling; g[U]}
+    ).apply(Type.of[T])
+  }
+}
+```
+
+#### Serialization
+
+Quoted code needs to be pickled to make it available at run-time in the next compilation phase.
+We implement this by pickling the AST as a TASTy binary.
+
+##### TASTy
+The TASTy format is the typed abstract syntax tree serialization format of Scala 3.
+It usually pickles the fully elaborated code after type-checking and is kept along the generated Java classfiles.
+
+
+##### Pickling
+We use TASTy as a serialization format for the contents of the quotes.
+To show how serialization is performed, we will use the following example.
+```scala
+'{
+  val (x, n): (Double, Int) = (5, 2)
+  ${ powerCode('{x}, '{n}) } * ${ powerCode('{2}, '{n}) }
+}
 ```
-                     Es $ () |- t: expr T
-                     --------------------
-                         Es |- $t: T
 
+This quote is transformed into the following code when normalizing the splices.
 
-                       Es ' () |- t: T
-                       ----------------
-                       Es |- 't: expr T
+```scala
+'{
+  val (x, n): (Double, Int) = (5, 2)
+  ${
+    ((y: Expr[Double], m: Expr[Int]) => powerCode(y, m)).apply('x, 'n)
+  } * ${
+    ((m: Expr[Int]) => powerCode('{2}, m)).apply('n)
+  }
+}
 ```
-The meta theory of a slightly simplified 2-stage variant of this calculus
-is studied [separately](./simple-smp.md).
 
-## Going Further
+Splice normalization is a key part of the serialization process as it only allows references to variables defined in the quote in the arguments of the lambda in the splice.
+This makes it possible to create a closed representation of the quote without much effort.
+The first step is to remove all the splices and replace them with holes.
+A hole is like a splice but it lacks the knowledge of how to compute the contents of the splice.
+Instead, it knows the index of the hole and the contents of the arguments of the splice.
+We can see this transformation in the following example where a hole is represented by `<< idx; holeType; args* >>`.
+
+```scala
+  ${ ((y: Expr[Double], m: Expr[Int]) => powerCode(y, m)).apply('x, 'n) }
+// becomes
+  << 0; Double; x, n >>
+```
 
-The metaprogramming framework as presented and currently implemented is quite restrictive
-in that it does not allow for the inspection of quoted expressions and
-types. It’s possible to work around this by providing all necessary
-information as normal, unquoted inline parameters. But we would gain
-more flexibility by allowing for the inspection of quoted code with
-pattern matching. This opens new possibilities.
+As this was the first hole it has index 0.
+The hole type is `Double`, which needs to be remembered now that we cannot infer it from the contents of the splice.
+The arguments of the splice are `x` and `n`; note that they do not require quoting because they were moved out of the splice.
 
-For instance, here is a version of `power` that generates the multiplications
-directly if the exponent is statically known and falls back to the dynamic
-implementation of `power` otherwise.
+References to healed types are handled in a similar way.
+Consider the `emptyList` example, which shows the type aliases that are inserted into the quote.
 ```scala
-import scala.quoted.*
+'{ List.empty[T] }
+// type healed to
+'{ type U = t.Underlying; List.empty[U] }
+```
+Instead of replacing a splice, we replace the `t.Underlying` type with a type hole.
+The type hole is represented by `<< idx; bounds >>`.
+```scala
+'{ type U = << 0; Nothing..Any >>; List.empty[U] }
+```
+Here, the bounds of `Nothing..Any` are the bounds of the original `T` type.
+The types of a `Type.of` are transformed in the same way.
 
-inline def power(x: Double, n: Int): Double =
-  ${ powerExpr('x, 'n) }
 
-private def powerExpr(x: Expr[Double], n: Expr[Int])
-                     (using Quotes): Expr[Double] =
-  n.value match
-    case Some(m) => powerExpr(x, m)
-    case _ => '{ dynamicPower($x, $n) }
+With these transformations, the contents of the quote or `Type.of` are guaranteed to be closed and therefore can be pickled.
+The AST is pickled into TASTy, which is a sequence of bytes.
+This sequence of bytes needs to be instantiated in the bytecode, but unfortunately it cannot be dumped into the classfile as bytes.
+To reify it we encode the bytes into a Java `String`.
+In the following examples we display this encoding in human readable form with the fictitious |tasty"..."| string literal.
 
-private def powerExpr(x: Expr[Double], n: Int)
-                     (using Quotes): Expr[Double] =
-  if n == 0 then '{ 1.0 }
-  else if n == 1 then x
-  else if n % 2 == 0 then '{ val y = $x * $x; ${ powerExpr('y, n / 2) } }
-  else '{ $x * ${ powerExpr(x, n - 1) } }
+```scala
+// pickled AST bytes encoded in a base64 string
+tasty"""
+  val (x, n): (Double, Int) = (5, 2)
+  << 0; Double; x, n >> * << 1; Double; n >>
+"""
+// or
+tasty"""
+  type U = << 0; Nothing..Any; >>
+  List.empty[U]
+"""
+```
+The contents of a quote or `Type.of` are not always pickled.
+In some cases it is better to generate equivalent (smaller and/or faster) code that will compute the expression.
+Literal values are compiled into a call to `Expr(<literal>)` using the implementation of `ToExpr` to create the quoted expression.
+This is currently performed only on literal values, but can be extended to any value for which we have a `ToExpr` defined in the standard library.
+Similarly, for non-generic types we can use their respective `java.lang.Class` and convert them into a `Type` using a primitive operation `typeConstructorOf` defined in the reflection API.
 
-private def dynamicPower(x: Double, n: Int): Double =
-  if n == 0 then 1.0
-  else if n % 2 == 0 then dynamicPower(x * x, n / 2)
-  else x * dynamicPower(x, n - 1)
+##### Unpickling
+
+Now that we have seen how a quote is pickled, we can look at how to unpickle it.
+We will continue with the previous example.
+
+Holes were used to replace the splices in the quote.
+When we perform this transformation we also need to remember the lambdas from the splices and their hole index.
+When unpickling a hole, the corresponding splice lambda will be used to compute the contents of the hole.
+The lambda will receive as parameters quoted versions of the arguments of the hole.
+For example to compute the contents of `<< 0; Double; x, n >>` we will evaluate the following code
+
+```scala
+  ((y: Expr[Double], m: Expr[Int]) => powerCode(y, m)).apply('x, 'n)
 ```
 
-In the above, the method `.value` maps a constant expression of the type
-`Expr[T]` to its value of the type `T`.
+The evaluation is not as trivial as it looks, because the lambda comes from compiled code and the rest is code that must be interpreted.
+We put the AST of `x` and `n` into `Expr` objects to simulate the quotes and then we use Java Reflection to call the `apply` method.
+
+We may have many holes in a quote and therefore as many lambdas.
+To avoid the instantiation of many lambdas, we can join them together into a single lambda.
+Apart from the list of arguments, this lambda will also take the index of the hole that is being evaluated.
+It will perform a switch match on the index and call the corresponding lambda in each branch.
+Each branch will also extract the arguments depending on the definition of the lambda.
+The application of the original lambdas are beta-reduced to avoid extra overhead.
 
-With the right extractors, the "AsFunction" conversion
-that maps expressions over functions to functions over expressions can
-be implemented in user code:
 ```scala
-given AsFunction1[T, U]: Conversion[Expr[T => U], Expr[T] => Expr[U]] with
-  def apply(f: Expr[T => U]): Expr[T] => Expr[U] =
-    (x: Expr[T]) => f match
-      case Lambda(g) => g(x)
-      case _ => '{ ($f)($x) }
+(idx: Int, args: Seq[Any]) =>
+  idx match
+    case 0 => // for << 0; Double; x, n >>
+      val x = args(0).asInstanceOf[Expr[Double]]
+      val n = args(1).asInstanceOf[Expr[Int]]
+      powerCode(x, n)
+    case 1 => // for << 1; Double; n >>
+      val n = args(0).asInstanceOf[Expr[Int]]
+      powerCode('{2}, n)
 ```
-This assumes an extractor
+
+This is similar to what we do for splices when we replace the type aliased with holes we keep track of the index of the hole.
+Instead of lambdas, we will have a list of references to instances of `Type`.
+From the following example we would extract `t`, `u`, ... .
+
 ```scala
-object Lambda:
-  def unapply[T, U](x: Expr[T => U]): Option[Expr[T] => Expr[U]]
+  '{ type T1 = t1.Underlying; type Tn = tn.Underlying; ... }
+// with holes
+  '{ type T1 = << 0; ... >>; type Tn = << n-1; ... >>; ... }
 ```
-Once we allow inspection of code via extractors, it’s tempting to also
-add constructors that create typed trees directly without going
-through quotes. Most likely, those constructors would work over `Expr`
-types which lack a known type argument. For instance, an `Apply`
-constructor could be typed as follows:
+
+As the type holes are at the start of the quote, they will have the first `N` indices.
+This implies that we can place the references in a sequence `Seq(t, u, ...)` where the index in the sequence is the same as the hole index.
+
+Lastly, the quote itself is replaced by a call to `QuoteUnpickler.unpickleExpr` which will unpickle the AST, evaluate the holes, i.e., splices, and wrap the resulting AST in an `Expr[Int]`.
+This method takes takes the pickled |tasty"..."|, the types and the hole lambda.
+Similarly, `Type.of` is replaced with a call to `QuoteUnpickler.unpickleType` but only receives the pickled |tasty"..."| and the types.
+Because `QuoteUnpickler` is part of the self-type of the `Quotes` class, we have to cast the instance but know that this cast will always succeed.
+
 ```scala
-def Apply(fn: Expr[Any], args: List[Expr[Any]]): Expr[Any]
+quotes.asInstanceOf[runtime.QuoteUnpickler].unpickleExpr[T](
+  pickled = tasty"...",
+  types = Seq(...),
+  holes = (idx: Int, args: Seq[Any]) => idx match ...
+)
 ```
-This would allow constructing applications from lists of arguments
-without having to match the arguments one-by-one with the
-corresponding formal parameter types of the function. We then need "at
-the end" a method to convert an `Expr[Any]` to an `Expr[T]` where `T` is
-given from the outside. For instance, if `code` yields a `Expr[Any]`, then
-`code.atType[T]` yields an `Expr[T]`. The `atType` method has to be
-implemented as a primitive; it would check that the computed type
-structure of `Expr` is a subtype of the type structure representing
-`T`.
 
-Before going down that route, we should evaluate in detail the tradeoffs it
-presents. Constructing trees that are only verified _a posteriori_
-to be type correct loses a lot of guidance for constructing the right
-trees.  So we should wait with this addition until we have more
-use-cases that help us decide whether the loss in type-safety is worth
-the gain in flexibility. In this context, it seems that deconstructing types is
-less error-prone than deconstructing terms, so one might also
-envisage a solution that allows the former but not the latter.
-
-## Conclusion
-
-Metaprogramming has a reputation of being difficult and confusing.
-But with explicit `Expr/Type` types and quotes and splices it can become
-downright pleasant. A simple strategy first defines the underlying quoted or unquoted
-values using `Expr` and `Type` and then inserts quotes and splices to make the types
-line up. Phase consistency is at the same time a great guideline
-where to insert a splice or a quote and a vital sanity check that
-the result makes sense.
+[^1]: [Scalable Metaprogramming in Scala 3](https://infoscience.epfl.ch/record/299370)
+[^2]: [Multi-stage programming with generative and analytical macros](https://dl.acm.org/doi/10.1145/3486609.3487203).
+[^3]: In quotes, identifiers starting with `$` must be surrounded by backticks (`` `$` ``). For example `$conforms` from `scala.Predef`.
diff --git a/docs/_spec/TODOreference/metaprogramming/macros.md b/docs/_spec/TODOreference/metaprogramming/macros.md
index 8045794d1143..e39f6f1022b8 100644
--- a/docs/_spec/TODOreference/metaprogramming/macros.md
+++ b/docs/_spec/TODOreference/metaprogramming/macros.md
@@ -6,818 +6,616 @@ nightlyOf: https://docs.scala-lang.org/scala3/reference/metaprogramming/macros.h
 
 > When developing macros enable `-Xcheck-macros` scalac option flag to have extra runtime checks.
 
-## Macros: Quotes and Splices
+## Multi-Staging
 
-Macros are built on two well-known fundamental operations: quotation and splicing.
-Quotation is expressed as `'{...}` for expressions and splicing is expressed as `${ ... }`.
-Additionally, within a quote or a splice we can quote or splice identifiers directly (i.e. `'e` and `$e`).
-Readers may notice the resemblance of the two aforementioned syntactic
-schemes with the familiar string interpolation syntax.
+#### Quoted expressions
+Multi-stage programming in Scala 3 uses quotes `'{..}` to delay, i.e., stage, execution of code and splices `${..}` to evaluate and insert code into quotes.
+Quoted expressions are typed as `Expr[T]` with a covariant type parameter `T`.
+It is easy to write statically safe code generators with these two concepts.
+The following example shows a naive implementation of the $x^n$ mathematical operation.
 
 ```scala
-println(s"Hello, $name, here is the result of 1 + 1 = ${1 + 1}")
+import scala.quoted.*
+def unrolledPowerCode(x: Expr[Double], n: Int)(using Quotes): Expr[Double] =
+  if n == 0 then '{ 1.0 }
+  else if n == 1 then x
+  else '{ $x * ${ unrolledPowerCode(x, n-1) } }
 ```
 
-In string interpolation we _quoted_ a string and then we _spliced_ into it, two others. The first, `name`, is a reference to a value of type [`String`](https://scala-lang.org/api/3.x/scala/Predef$.html#String-0), and the second is an arithmetic expression that will be _evaluated_ followed by the splicing of its string representation.
-
-Quotes and splices in this section allow us to treat code in a similar way,
-effectively supporting macros. The entry point for macros is an inline method
-with a top-level splice. We call it a top-level because it is the only occasion
-where we encounter a splice outside a quote (consider as a quote the
-compilation-unit at the call-site). For example, the code below presents an
-`inline` method `assert` which calls at compile-time a method `assertImpl` with
-a boolean expression tree as argument. `assertImpl` evaluates the expression and
-prints it again in an error message if it evaluates to `false`.
-
 ```scala
-import scala.quoted.*
-
-inline def assert(inline expr: Boolean): Unit =
-  ${ assertImpl('expr) }
-
-def assertImpl(expr: Expr[Boolean])(using Quotes) = '{
-  if !$expr then
-    throw AssertionError(s"failed assertion: ${${ showExpr(expr) }}")
+'{
+  val x = ...
+  ${ unrolledPowerCode('{x}, 3) } // evaluates to: x * x * x
 }
-
-def showExpr(expr: Expr[Boolean])(using Quotes): Expr[String] =
-  '{ [actual implementation later in this document] }
 ```
 
-If `e` is an expression, then `'{e}` represents the typed
-abstract syntax tree representing `e`. If `T` is a type, then `Type.of[T]`
-represents the type structure representing `T`.  The precise
-definitions of "typed abstract syntax tree" or "type-structure" do not
-matter for now, the terms are used only to give some
-intuition. Conversely, `${e}` evaluates the expression `e`, which must
-yield a typed abstract syntax tree or type structure, and embeds the
-result as an expression (respectively, type) in the enclosing program.
+Quotes and splices are duals of each other.
+For an arbitrary expression `x` of type `T` we have `${'{x}} = x` and for an arbitrary expression `e` of type `Expr[T]` we have `'{${e}} = e`.
 
-Quotations can have spliced parts in them; in this case the embedded
-splices are evaluated and embedded as part of the formation of the
-quotation.
+#### Abstract types
+Quotes can handle generic and abstract types using the type class `Type[T]`.
+A quote that refers to a generic or abstract type `T` requires a given `Type[T]` to be provided in the implicit scope.
+The following examples show how `T` is annotated with a context bound (`: Type`) to provide an implicit `Type[T]`, or the equivalent `using Type[T]` parameter.
 
-Quotes and splices can also be applied directly to identifiers. An identifier
-`$x` starting with a `$` that appears inside a quoted expression or type is treated as a
-splice `${x}`. Analogously, an quoted identifier `'x` that appears inside a splice
-is treated as a quote `'{x}`. See the Syntax section below for details.
+```scala
+import scala.quoted.*
+def singletonListExpr[T: Type](x: Expr[T])(using Quotes): Expr[List[T]] =
+  '{ List[T]($x) } // generic T used within a quote
 
-Quotes and splices are duals of each other.
-For arbitrary expressions `e` we have:
+def emptyListExpr[T](using Type[T], Quotes): Expr[List[T]] =
+  '{ List.empty[T] } // generic T used within a quote
+```
 
+If no other instance is found, the default `Type.of[T]` is used.
+The following example implicitly uses `Type.of[String]` and `Type.of[Option[U]]`.
 ```scala
-${'{e}} = e
-'{${e}} = e
+val list1: Expr[List[String]] =
+  singletonListExpr('{"hello"}) // requires a given `Type[Sting]`
+val list0: Expr[List[Option[T]]] =
+  emptyListExpr[Option[U]] // requires a given `Type[Option[U]]`
 ```
 
-## Types for Quotations
-
-The type signatures of quotes and splices can be described using
-two fundamental types:
 
-- `Expr[T]`: abstract syntax trees representing expressions of type `T`
-- `Type[T]`: non erased representation of type `T`.
-
-Quoting takes expressions of type `T` to expressions of type `Expr[T]`
-and it takes types `T` to expressions of type `Type[T]`. Splicing
-takes expressions of type `Expr[T]` to expressions of type `T` and it
-takes expressions of type `Type[T]` to types `T`.
-
-The two types can be defined in package [`scala.quoted`](https://scala-lang.org/api/3.x/scala/quoted.html) as follows:
+The `Type.of[T]` method is a primitive operation that the compiler will handle specially.
+It will provide the implicit if the type `T` is statically known, or if `T` contains some other types `Ui` for which we have an implicit `Type[Ui]`.
+In the example, `Type.of[String]` has a statically known type and `Type.of[Option[U]]` requires an implicit `Type[U]` in scope.
 
+#### Quote context
+We also track the current quotation context using a given `Quotes` instance.
+To create a quote `'{..}` we require a given `Quotes` context, which should be passed as a contextual parameter `(using Quotes)` to the function.
+Each splice will provide a new `Quotes` context within the scope of the splice.
+Therefore quotes and splices can be seen as methods with the following signatures, but with special semantics.
 ```scala
-package scala.quoted
+def '[T](x: T): Quotes ?=> Expr[T] // def '[T](x: T)(using Quotes): Expr[T]
 
-sealed trait Expr[+T]
-sealed trait Type[T]
+def $[T](x: Quotes ?=> Expr[T]): T
 ```
 
-Both `Expr` and `Type` are abstract and sealed, so all constructors for
-these types are provided by the system. One way to construct values of
-these types is by quoting, the other is by type-specific lifting
-operations that will be discussed later on.
+The lambda with a question mark `?=>` is a contextual function; it is a lambda that takes its argument implicitly and provides it implicitly in the implementation the lambda.
+`Quotes` are used for a variety of purposes that will be mentioned when covering those topics.
 
-## The Phase Consistency Principle
+## Quoted Values
 
-A fundamental *phase consistency principle* (PCP) regulates accesses
-to free variables in quoted and spliced code:
+#### Lifting
+While it is not possible to use cross-stage persistence of local variables, it is possible to lift them to the next stage.
+To this end, we provide the `Expr.apply` method, which can take a value and lift it into a quoted representation of the value.
 
-- _For any free variable reference `x`, the number of quoted scopes and the number of spliced scopes between the reference to `x` and the definition of `x` must be equal_.
-
-Here, `this`-references count as free variables. On the other
-hand, we assume that all imports are fully expanded and that `_root_` is
-not a free variable. So references to global definitions are
-allowed everywhere.
+```scala
+val expr1plus1: Expr[Int] = '{ 1 + 1 }
 
-The phase consistency principle can be motivated as follows: First,
-suppose the result of a program `P` is some quoted text `'{ ... x
-... }` that refers to a free variable `x` in `P`. This can be
-represented only by referring to the original variable `x`. Hence, the
-result of the program will need to persist the program state itself as
-one of its parts. We don’t want to do this, hence this situation
-should be made illegal. Dually, suppose a top-level part of a program
-is a spliced text `${ ... x ... }` that refers to a free variable `x`
-in `P`.  This would mean that we refer during _construction_ of `P` to
-a value that is available only during _execution_ of `P`. This is of
-course impossible and therefore needs to be ruled out.  Now, the
-small-step evaluation of a program will reduce quotes and splices in
-equal measure using the cancellation rules above. But it will neither
-create nor remove quotes or splices individually. So the PCP ensures
-that program elaboration will lead to neither of the two unwanted
-situations described above.
+val expr2: Expr[Int] = Expr(1 + 1) // lift 2 into '{ 2 }
+```
 
-In what concerns the range of features it covers, this form of macros introduces
-a principled metaprogramming framework that is quite close to the MetaML family of
-languages. One difference is that MetaML does not have an equivalent of the PCP -
-quoted code in MetaML _can_ access variables in its immediately enclosing
-environment, with some restrictions and caveats since such accesses involve
-serialization. However, this does not constitute a fundamental gain in
-expressiveness.
+While it looks type wise similar to `'{ 1 + 1 }`, the semantics of `Expr(1 + 1)` are quite different.
+`Expr(1 + 1)` will not stage or delay any computation; the argument is evaluated to a value and then lifted into a quote.
+The quote will contain code that will create a copy of this value in the next stage.
+`Expr` is polymorphic and user-extensible via the `ToExpr` type class.
 
-## From `Expr`s to Functions and Back
+```scala
+trait ToExpr[T]:
+  def apply(x: T)(using Quotes): Expr[T]
+```
 
-It is possible to convert any `Expr[T => R]` into `Expr[T] => Expr[R]` and back.
-These conversions can be implemented as follows:
+We can implement a `ToExpr` using a `given` definition that will add the definition to the implicits in scope.
+In the following example we show how to implement a `ToExpr[Option[T]]` for any liftable type `T.
 
 ```scala
-def to[T: Type, R: Type](f: Expr[T] => Expr[R])(using Quotes): Expr[T => R] =
-  '{ (x: T) => ${ f('x) } }
-
-def from[T: Type, R: Type](f: Expr[T => R])(using Quotes): Expr[T] => Expr[R] =
-  (x: Expr[T]) => '{ $f($x) }
+given OptionToExpr[T: Type: ToExpr]: ToExpr[Option[T]] with
+  def apply(opt: Option[T])(using Quotes): Expr[Option[T]] =
+    opt match
+      case Some(x) => '{ Some[T]( ${Expr(x)} ) }
+      case None => '{ None }
 ```
 
-Note how the fundamental phase consistency principle works in two
-different directions here for `f` and `x`.  In the method `to`,  the reference to `f` is
-legal because it is quoted, then spliced, whereas the reference to `x`
-is legal because it is spliced, then quoted.
+The `ToExpr` for primitive types must be implemented as primitive operations in the system.
+In our case, we use the reflection API to implement them.
 
-They can be used as follows:
+#### Extracting values from quotes
+To be able to generate optimized code using the method `unrolledPowerCode`, the macro implementation `powerCode` needs to first
+determine whether the argument passed as parameter `n` is a known constant value.
+This can be achieved via _unlifting_ using the `Expr.unapply` extractor from our library implementation, which will only match if `n` is a quoted constant and extracts its value.
 
 ```scala
-val f1: Expr[Int => String] =
-  to((x: Expr[Int]) => '{ $x.toString }) // '{ (x: Int) => x.toString }
-
-val f2: Expr[Int] => Expr[String] =
-  from('{ (x: Int) => x.toString }) // (x: Expr[Int]) => '{ ((x: Int) => x.toString)($x) }
-f2('{2}) // '{ ((x: Int) => x.toString)(2) }
+def powerCode(x: Expr[Double], n: Expr[Int])(using Quotes): Expr[Double] =
+  n match
+    case Expr(m) => // it is a constant: unlift code n='{m} into number m
+      unrolledPowerCode(x, m)
+    case _ => // not known: call power at run-time
+      '{ power($x, $n) }
 ```
 
-One limitation of `from` is that it does not β-reduce when a lambda is called immediately, as evidenced in the code `{ ((x: Int) => x.toString)(2) }`.
-In some cases we want to remove the lambda from the code, for this we provide the method `Expr.betaReduce` that turns a tree
-describing a function into a function mapping trees to trees.
-
+Alternatively, the `n.value` method can be used to get an `Option[Int]` with the value or `n.valueOrAbort` to get the value directly.
 ```scala
-object Expr:
-  ...
-  def betaReduce[...](...)(...): ... = ...
+def powerCode(x: Expr[Double], n: Expr[Int])(using Quotes): Expr[Double] =
+  // emits an error message if `n` is not a constant
+  unrolledPowerCode(x, n.valueOrAbort)
 ```
 
-The definition of `Expr.betaReduce(f)(x)` is assumed to be functionally the same as
-`'{($f)($x)}`, however it should optimize this call by returning the
-result of beta-reducing `f(x)` if `f` is a known lambda expression.
-`Expr.betaReduce` distributes applications of `Expr` over function arrows:
+`Expr.unapply` and all variants of `value` are polymorphic and user-extensible via a given `FromExpr` type class.
 
 ```scala
-Expr.betaReduce(_): Expr[(T1, ..., Tn) => R] => ((Expr[T1], ..., Expr[Tn]) => Expr[R])
+trait FromExpr[T]:
+  def unapply(x: Expr[T])(using Quotes): Option[T]
 ```
 
-## Lifting Types
+We can use `given` definitions to implement the `FromExpr` as we did for `ToExpr`.
+The `FromExpr` for primitive types must be implemented as primitive operations in the system.
+In our case, we use the reflection API to implement them.
+To implement `FromExpr` for non-primitive types we use quote pattern matching (for example `OptionFromExpr`).
 
-Types are not directly affected by the phase consistency principle.
-It is possible to use types defined at any level in any other level.
-But, if a type is used in a subsequent stage it will need to be lifted to a `Type`.
-Indeed, the definition of `to` above uses `T` in the next stage, there is a
-quote but no splice between the parameter binding of `T` and its
-usage. But the code can be rewritten by adding an explicit binding of a `Type[T]`:
-
-```scala
-def to[T, R](f: Expr[T] => Expr[R])(using t: Type[T])(using Type[R], Quotes): Expr[T => R] =
-  '{ (x: t.Underlying) => ${ f('x) } }
-```
 
-In this version of `to`, the type of `x` is now the result of
-inserting the type `Type[T]` and selecting its `Underlying`.
+## Macros and Multi-Stage Programming
 
-To avoid clutter, the compiler converts any type reference to
-a type `T` in subsequent phases to `summon[Type[T]].Underlying`.
+The system supports multi-stage macros and run-time multi-stage programming using the same quotation abstractions.
 
-And to avoid duplication it does it once per type, and creates
-an alias for that type at the start of the quote.
+### Multi-Stage Macros
 
-For instance, the user-level definition of `to`:
+#### Macros
+We can generalize the splicing abstraction to express macros.
+A macro consists of a top-level splice that is not nested in any quote.
+Conceptually, the contents of the splice are evaluated one stage earlier than the program.
+In other words, the contents are evaluated while compiling the program. The generated code resulting from the macro replaces the splice in the program.
 
 ```scala
-def to[T, R](f: Expr[T] => Expr[R])(using t: Type[T], r: Type[R])(using Quotes): Expr[T => R] =
-  '{ (x: T) => ${ f('x) } }
+def power2(x: Double): Double =
+  ${ unrolledPowerCode('x, 2) } // x * x
 ```
 
-would be rewritten to
+#### Inline macros
+Since using the splices in the middle of a program is not as ergonomic as calling a function; we hide the staging mechanism from end-users of macros. We have a uniform way of calling macros and normal functions.
+For this, _we restrict the use of top-level splices to only appear in inline methods_[^1][^2].
 
 ```scala
-def to[T, R](f: Expr[T] => Expr[R])(using t: Type[T], r: Type[R])(using Quotes): Expr[T => R] =
-  '{
-    type T = t.Underlying
-    (x: T) => ${ f('x) }
-  }
+// inline macro definition
+inline def powerMacro(x: Double, inline n: Int): Double =
+  ${ powerCode('x, 'n) }
+
+// user code
+def power2(x: Double): Double =
+  powerMacro(x, 2) // x * x
 ```
 
-The `summon` query succeeds because there is a given instance of
-type `Type[T]` available (namely the given parameter corresponding
-to the context bound `: Type`), and the reference to that value is
-phase-correct. If that was not the case, the phase inconsistency for
-`T` would be reported as an error.
+The evaluation of the macro will only happen when the code is inlined into `power2`.
+When inlined, the code is equivalent to the previous definition of `power2`.
+A consequence of using inline methods is that none of the arguments nor the return type of the macro will have to mention the `Expr` types; this hides all aspects of metaprogramming from the end-users.
 
-## Lifting Expressions
+#### Avoiding a complete interpreter
+When evaluating a top-level splice, the compiler needs to interpret the code that is within the splice.
+Providing an interpreter for the entire language is quite tricky, and it is even more challenging to make that interpreter run efficiently.
+To avoid needing a complete interpreter, we can impose the following restrictions on splices to simplify the evaluation of the code in top-level splices.
+ * The top-level splice must contain a single call to a compiled static method.
+ * Arguments to the function are literal constants, quoted expressions (parameters), calls to `Type.of` for type parameters and a reference to `Quotes`.
 
-Consider the following implementation of a staged interpreter that implements
-a compiler through staging.
+In particular, these restrictions disallow the use of splices in top-level splices.
+Such a splice would require several stages of interpretation which would be unnecessarily inefficient.
 
+#### Compilation stages
+The macro implementation (i.e., the method called in the top-level splice) can come from any pre-compiled library.
+This provides a clear difference between the stages of the compilation process.
+Consider the following 3 source files defined in distinct libraries.
 ```scala
-import scala.quoted.*
-
-enum Exp:
-  case Num(n: Int)
-  case Plus(e1: Exp, e2: Exp)
-  case Var(x: String)
-  case Let(x: String, e: Exp, in: Exp)
-
-import Exp.*
+// Macro.scala
+def powerCode(x: Expr[Double], n: Expr[Int])(using Quotes): Expr[Double] = ...
+inline def powerMacro(x: Double, inline n: Int): Double =
+  ${ powerCode('x, 'n) }
 ```
 
-The interpreted language consists of numbers `Num`, addition `Plus`, and variables
-`Var` which are bound by `Let`. Here are two sample expressions in the language:
-
 ```scala
-val exp = Plus(Plus(Num(2), Var("x")), Num(4))
-val letExp = Let("x", Num(3), exp)
+// Lib.scala (depends on Macro.scala)
+def power2(x: Double) =
+  ${ powerCode('x, '{2}) } // inlined from a call to: powerMacro(x, 2)
 ```
 
-Here’s a compiler that maps an expression given in the interpreted
-language to quoted Scala code of type `Expr[Int]`.
-The compiler takes an environment that maps variable names to Scala `Expr`s.
-
 ```scala
-import scala.quoted.*
-
-def compile(e: Exp, env: Map[String, Expr[Int]])(using Quotes): Expr[Int] =
-  e match
-    case Num(n) =>
-      Expr(n)
-    case Plus(e1, e2) =>
-      '{ ${ compile(e1, env) } + ${ compile(e2, env) } }
-    case Var(x) =>
-      env(x)
-    case Let(x, e, body) =>
-      '{ val y = ${ compile(e, env) }; ${ compile(body, env + (x -> 'y)) } }
+// App.scala  (depends on Lib.scala)
+@main def app() = power2(3.14)
 ```
-
-Running `compile(letExp, Map())` would yield the following Scala code:
+One way to syntactically visualize this is to put the application in a quote that delays the compilation of the application.
+Then the application dependencies can be placed in an outer quote that contains the quoted application, and we repeat this recursively for dependencies of dependencies.
 
 ```scala
-'{ val y = 3; (2 + y) + 4 }
+'{ // macro library (compilation stage 1)
+  def powerCode(x: Expr[Double], n: Expr[Int])(using Quotes): Expr[Double] =
+    ...
+  inline def powerMacro(x: Double, inline n: Int): Double =
+    ${ powerCode('x, 'n) }
+  '{ // library using macros (compilation stage 2)
+    def power2(x: Double) =
+      ${ powerCode('x, '{2}) } // inlined from a call to: powerMacro(x, 2)
+    '{ power2(3.14) /* app (compilation stage 3) */ }
+  }
+}
 ```
 
-The body of the first clause, `case Num(n) => Expr(n)`, looks suspicious. `n`
-is declared as an `Int`, yet it is converted to an `Expr[Int]` with `Expr()`.
-Shouldn’t `n` be quoted? In fact this would not
-work since replacing `n` by `'n` in the clause would not be phase
-correct.
+To make the system more versatile, we allow calling macros in the project where it is defined, with some restrictions.
+For example, to compile `Macro.scala` and `Lib.scala` together in the same library.
+To this end, we do not follow the simpler syntactic model and rely on semantic information from the source files.
+When compiling a source, if we detect a call to a macro that is not compiled yet, we delay the compilation of this source to the following compilation stage.
+In the example, we would delay the compilation of `Lib.scala` because it contains a compile-time call to `powerCode`.
+Compilation stages are repeated until all sources are compiled, or no progress can be made.
+If no progress is made, there was a cyclic dependency between the definition and the use of the macro.
+We also need to detect if at runtime the macro depends on sources that have not been compiled yet.
+These are detected by executing the macro and checking for JVM linking errors to classes that have not been compiled yet.
 
-The `Expr.apply` method is defined in package `quoted`:
+### Run-Time Multi-Stage Programming
 
-```scala
-package quoted
+See [Run-Time Multi-Stage Programming](./staging.md)
 
-object Expr:
-  ...
-  def apply[T: ToExpr](x: T)(using Quotes): Expr[T] =
-    summon[ToExpr[T]].toExpr(x)
-```
+## Safety
 
-This method says that values of types implementing the `ToExpr` type class can be
-converted to `Expr` values using `Expr.apply`.
+Multi-stage programming is by design statically safe and cross-stage safe.
 
-Scala 3 comes with given instances of `ToExpr` for
-several types including `Boolean`, `String`, and all primitive number
-types. For example, `Int` values can be converted to `Expr[Int]`
-values by wrapping the value in a `Literal` tree node. This makes use
-of the underlying tree representation in the compiler for
-efficiency. But the `ToExpr` instances are nevertheless not _magic_
-in the sense that they could all be defined in a user program without
-knowing anything about the representation of `Expr` trees. For
-instance, here is a possible instance of `ToExpr[Boolean]`:
+### Static Safety
 
-```scala
-given ToExpr[Boolean] with
-  def toExpr(b: Boolean) =
-    if b then '{ true } else '{ false }
-```
+#### Hygiene
+All identifier names are interpreted as symbolic references to the corresponding variable in the context of the quote.
+Therefore, while evaluating the quote, it is not possible to accidentally rebind a reference to a new variable with the same textual name.
 
-Once we can lift bits, we can work our way up. For instance, here is a
-possible implementation of `ToExpr[Int]` that does not use the underlying
-tree machinery:
+#### Well-typed
+If a quote is well typed, then the generated code is well typed.
+This is a simple consequence of tracking the type of each expression.
+An `Expr[T]` can only be created from a quote that contains an expression of type `T.
+Conversely, an `Expr[T]` can only be spliced in a location that expects a type `T.
+As mentioned before, `Expr` is covariant in its type parameter.
+This means that an `Expr[T]` can contain an expression of a subtype of `T.
+When spliced in a location that expects a type `T, these expressions also have a valid type.
 
-```scala
-given ToExpr[Int] with
-  def toExpr(n: Int) = n match
-    case Int.MinValue    => '{ Int.MinValue }
-    case _ if n < 0      => '{ - ${ toExpr(-n) } }
-    case 0               => '{ 0 }
-    case _ if n % 2 == 0 => '{ ${ toExpr(n / 2) } * 2 }
-    case _               => '{ ${ toExpr(n / 2) } * 2 + 1 }
-```
+### Cross-Stage Safety
 
-Since `ToExpr` is a type class, its instances can be conditional. For example,
-a `List` is liftable if its element type is:
+#### Level consistency
+We define the _staging level_ of some code as the number of quotes minus the number of splices surrounding said code.
+Local variables must be defined and used in the same staging level.
+
+It is never possible to access a local variable from a lower staging level as it does not yet exist.
 
 ```scala
-given [T: ToExpr : Type]: ToExpr[List[T]] with
-  def toExpr(xs: List[T]) = xs match
-    case head :: tail => '{ ${ Expr(head) } :: ${ toExpr(tail) } }
-    case Nil          => '{ Nil: List[T] }
+def badPower(x: Double, n: Int): Double =
+  ${ unrolledPowerCode('x, n) } // error: value of `n` not known yet
 ```
 
-In the end, `ToExpr` resembles very much a serialization
-framework. Like the latter it can be derived systematically for all
-collections, case classes and enums. Note also that the synthesis
-of _type-tag_ values of type `Type[T]` is essentially the type-level
-analogue of lifting.
 
-Using lifting, we can now give the missing definition of `showExpr` in the introductory example:
+In the context of macros and _cross-platform portability_, that is,
+macros compiled on one machine but potentially executed on another,
+we cannot support cross-stage persistence of local variables.
+Therefore, local variables can only be accessed at precisely the same staging level in our system.
 
 ```scala
-def showExpr[T](expr: Expr[T])(using Quotes): Expr[String] =
-  val code: String = expr.show
-  Expr(code)
+def badPowerCode(x: Expr[Double], n: Int)(using Quotes): Expr[Double] =
+  // error: `n` potentially not available in the next execution environment
+  '{ power($x, n) }
 ```
 
-That is, the `showExpr` method converts its `Expr` argument to a string (`code`), and lifts
-the result back to an `Expr[String]` using `Expr.apply`.
 
-## Lifting Types
+The rules are slightly different for global definitions, such as `unrolledPowerCode`.
+It is possible to generate code that contains a reference to a _global_ definition such as in `'{ power(2, 4) }`.
+This is a limited form of cross-stage persistence that does not impede cross-platform portability, where we refer to the already compiled code for `power`.
+Each compilation step will lower the staging level by one while keeping global definitions.
+In consequence, we can refer to compiled definitions in macros such as `unrolledPowerCode` in `${ unrolledPowerCode('x, 2) }`.
+
+We can sumarize level consistency in two rules:
+ * Local variables can be used only at the same staging level as their definition
+ * Global variables can be used at any staging level
 
-The previous section has shown that the metaprogramming framework has
-to be able to take a type `T` and convert it to a type tree of type
-`Type[T]` that can be reified. This means that all free variables of
-the type tree refer to types and values defined in the current stage.
 
-For a reference to a global class, this is easy: Just issue the fully
-qualified name of the class. Members of reifiable types are handled by
-just reifying the containing type together with the member name. But
-what to do for references to type parameters or local type definitions
-that are not defined in the current stage? Here, we cannot construct
-the `Type[T]` tree directly, so we need to get it from a recursive
-implicit search. For instance, to implement
+#### Type consistency
+As Scala uses type erasure, generic types will be erased at run-time and hence in any following stage.
+To ensure any quoted expression that refers to a generic type `T` does not lose the information it needs, we require a given `Type[T]` in scope.
+The `Type[T]` will carry over the non-erased representation of the type into the next phase.
+Therefore any generic type used at a higher staging level than its definition will require its `Type`.
 
+#### Scope extrusion
+Within the contents of a splice, it is possible to have a quote that refers to a local variable defined in the outer quote.
+If this quote is used within the splice, the variable will be in scope.
+However, if the quote is somehow _extruded_ outside the splice, then variables might not be in scope anymore.
+Quoted expressions can be extruded using side effects such as mutable state and exceptions.
+The following example shows how a quote can be extruded using mutable state.
 ```scala
-summon[Type[List[T]]]
+var x: Expr[T] = null
+'{ (y: T) => ${ x = 'y; 1 } }
+x // has value '{y} but y is not in scope
 ```
 
-where `T` is not defined in the current stage, we construct the type constructor
-of `List` applied to the splice of the result of searching for a given instance for `Type[T]`:
+A second way a variable can be extruded is through the `run` method.
+If `run` consumes a quoted variable reference, it will not be in scope anymore.
+The result will reference a variable that is defined in the next stage.
 
 ```scala
-Type.of[ List[ summon[Type[T]].Underlying ] ]
+'{ (x: Int) => ${ run('x); ... } }
+// evaluates to: '{ (x: Int) => ${ x; ... } 1
 ```
 
-This is exactly the algorithm that Scala 2 uses to search for type tags.
-In fact Scala 2's type tag feature can be understood as a more ad-hoc version of
-`quoted.Type`. As was the case for type tags, the implicit search for a `quoted.Type`
-is handled by the compiler, using the algorithm sketched above.
+To catch both scope extrusion scenarios, our system restricts the use of quotes by only allowing a quote to be spliced if it was not extruded from a splice scope.
+Unlike level consistency, this is checked at run-time[^4] rather than compile-time to avoid making the static type system too complicated.
 
-## Relationship with `inline`
+Each `Quotes` instance contains a unique scope identifier and refers to its parent scope, forming a stack of identifiers.
+The parent of the scope of a `Quotes` is the scope of the `Quotes` used to create the enclosing quote.
+Top-level splices and `run` create new scope stacks.
+Every `Expr` knows in which scope it was created.
+When it is spliced, we check that the quote scope is either the same as the splice scope, or a parent scope thereof.
 
-Seen by itself, principled metaprogramming looks more like a framework for
-runtime metaprogramming than one for compile-time metaprogramming with macros.
-But combined with Scala 3’s `inline` feature it can be turned into a compile-time
-system. The idea is that macro elaboration can be understood as a combination of
-a macro library and a quoted program. For instance, here’s the `assert` macro
-again together with a program that calls `assert`.
 
-```scala
-object Macros:
+## Staged Lambdas
 
-  inline def assert(inline expr: Boolean): Unit =
-    ${ assertImpl('expr) }
+When staging programs in a functional language there are two fundamental abstractions: a staged lambda `Expr[T => U]` and a staging lambda `Expr[T] => Expr[U]`.
+The first is a function that will exist in the next stage, whereas the second is a function that exists in the current stage.
+It is often convenient to have a mechanism to go from `Expr[T => U]` to `Expr[T] => Expr[U]` and vice versa.
 
-  def assertImpl(expr: Expr[Boolean])(using Quotes) =
-    val failMsg: Expr[String] = Expr("failed assertion: " + expr.show)
-    '{ if !($expr) then throw new AssertionError($failMsg) }
+```scala
+def later[T: Type, U: Type](f: Expr[T] => Expr[U]): Expr[T => U] =
+  '{ (x: T) => ${ f('x) } }
 
-@main def program =
-  val x = 1
-  Macros.assert(x != 0)
+def now[T: Type, U: Type](f: Expr[T => U]): Expr[T] => Expr[U] =
+  (x: Expr[T]) => '{ $f($x) }
 ```
 
-Inlining the `assert` function would give the following program:
+Both conversions can be performed out of the box with quotes and splices.
+But if `f` is a known lambda function, `'{ $f($x) }` will not beta-reduce the lambda in place.
+This optimization is performed in a later phase of the compiler.
+Not reducing the application immediately can simplify analysis of generated code.
+Nevertheless, it is possible to beta-reduce the lambda in place using the `Expr.betaReduce` method.
 
 ```scala
-@main def program =
-  val x = 1
-  ${ Macros.assertImpl('{ x != 0}) }
+def now[T: Type, U: Type](f: Expr[T => U]): Expr[T] => Expr[U] =
+  (x: Expr[T]) => Expr.betaReduce('{ $f($x) })
 ```
 
-The example is only phase correct because `Macros` is a global value and
-as such not subject to phase consistency checking. Conceptually that’s
-a bit unsatisfactory. If the PCP is so fundamental, it should be
-applicable without the global value exception. But in the example as
-given this does not hold since both `assert` and `program` call
-`assertImpl` with a splice but no quote.
+The `betaReduce` method will beta-reduce the outermost application of the expression if possible (regardless of arity).
+If it is not possible to beta-reduce the expression, then it will return the original expression.
 
-However, one could argue that the example is really missing
-an important aspect: The macro library has to be compiled in a phase
-prior to the program using it, but in the code above, macro
-and program are defined together. A more accurate view of
-macros would be to have the user program be in a phase after the macro
-definitions, reflecting the fact that macros have to be defined and
-compiled before they are used. Hence, conceptually the program part
-should be treated by the compiler as if it was quoted:
+## Staged Constructors
+To create new class instances in a later stage, we can create them using factory methods (usually `apply` methods of an `object`), or we can instantiate them with a `new`.
+For example, we can write `Some(1)` or `new Some(1)`, creating the same value.
+In Scala 3, using the factory method call notation will fall back to a `new` if no `apply` method is found.
+We follow the usual staging rules when calling a factory method.
+Similarly, when we use a `new C`, the constructor of `C` is implicitly called, which also follows the usual staging rules.
+Therefore for an arbitrary known class `C`, we can use both `'{ C(...) }` or `'{ new C(...) }` as constructors.
 
+## Staged Classes
+Quoted code can contain any valid expression including local class definitions.
+This allows the creation of new classes with specialized implementations.
+For example, we can implement a new version of `Runnable` that will perform some optimized operation.
 ```scala
-@main def program = '{
-  val x = 1
-  ${ Macros.assertImpl('{ x != 0 }) }
+def mkRunnable(x: Int)(using Quotes): Expr[Runnable] = '{
+  class MyRunnable extends Runnable:
+    def run(): Unit = ... // generate some custom code that uses `x`
+  new MyRunnable
 }
 ```
 
-If `program` is treated as a quoted expression, the call to
-`Macro.assertImpl` becomes phase correct even if macro library and
-program are conceptualized as local definitions.
-
-But what about the call from `assert` to `assertImpl`? Here, we need a
-tweak of the typing rules. An inline function such as `assert` that
-contains a splice operation outside an enclosing quote is called a
-_macro_. Macros are supposed to be expanded in a subsequent phase,
-i.e. in a quoted context. Therefore, they are also type checked as if
-they were in a quoted context. For instance, the definition of
-`assert` is typechecked as if it appeared inside quotes.  This makes
-the call from `assert` to `assertImpl` phase-correct, even if we
-assume that both definitions are local.
+The quoted class is a local class and its type cannot escape the enclosing quote.
+The class must be used inside the quote or an instance of it can be returned using a known interface (`Runnable` in this case).
 
-The `inline` modifier is used to declare a `val` that is
-either a constant or is a parameter that will be a constant when instantiated. This
-aspect is also important for macro expansion.
+## Quote Pattern Matching
 
-To get values out of expressions containing constants `Expr` provides the method
-`value` (or `valueOrError`). This will convert the `Expr[T]` into a `Some[T]` (or `T`) when the
-expression contains value. Otherwise it will return `None` (or emit an error).
-To avoid having incidental val bindings generated by the inlining of the `def`
-it is recommended to use an inline parameter. To illustrate this, consider an
-implementation of the `power` function that makes use of a statically known exponent:
+It is sometimes necessary to analyze the structure of the code or decompose the code into its sub-expressions.
+A classic example is an embedded DSL, where a macro knows a set of definitions that it can reinterpret while compiling the code (for instance, to perform optimizations).
+In the following example, we extend our previous implementation of `powCode` to look into `x` to perform further optimizations.
 
 ```scala
-inline def power(x: Double, inline n: Int) = ${ powerCode('x, 'n) }
-
-private def powerCode(x: Expr[Double], n: Expr[Int])(using Quotes): Expr[Double] =
-  n.value match
-    case Some(m) => powerCode(x, m)
-    case None => '{ Math.pow($x, $n.toDouble) }
-
-private def powerCode(x: Expr[Double], n: Int)(using Quotes): Expr[Double] =
-  if n == 0 then '{ 1.0 }
-  else if n == 1 then x
-  else if n % 2 == 0 then '{ val y = $x * $x; ${ powerCode('y, n / 2) } }
-  else '{ $x * ${ powerCode(x, n - 1) } }
+def fusedPowCode(x: Expr[Double], n: Expr[Int])(using Quotes): Expr[Double] =
+  x match
+    case '{ power($y, $m) } => // we have (y^m)^n
+      fusedPowCode(y, '{ $n * $m }) // generate code for y^(n*m)
+    case _ =>
+      '{ power($x, $n) }
 ```
 
-## Scope Extrusion
-
-Quotes and splices are duals as far as the PCP is concerned. But there is an
-additional restriction that needs to be imposed on splices to guarantee
-soundness: code in splices must be free of side effects. The restriction
-prevents code like this:
-
-```scala
-var x: Expr[T] = ...
-'{ (y: T) => ${ x = 'y; 1 } }
-```
 
-This code, if it was accepted, would _extrude_ a reference to a quoted variable
-`y` from its scope. This would subsequently allow access to a variable outside the
-scope where it is defined, which is likely problematic. The code is clearly
-phase consistent, so we cannot use PCP to rule it out. Instead, we postulate a
-future effect system that can guarantee that splices are pure. In the absence of
-such a system we simply demand that spliced expressions are pure by convention,
-and allow for undefined compiler behavior if they are not. This is analogous to
-the status of pattern guards in Scala, which are also required, but not
-verified, to be pure.
+#### Sub-patterns
 
-[Multi-Stage Programming](./staging.md) introduces one additional method where
-you can expand code at runtime with a method `run`. There is also a problem with
-that invocation of `run` in splices. Consider the following expression:
+In quoted patterns, the `$` binds the sub-expression to an expression `Expr` that can be used in that `case` branch.
+The contents of `${..}` in a quote pattern are regular Scala patterns.
+For example, we can use the `Expr(_)` pattern within the `${..}` to only match if it is a known value and extract it.
 
 ```scala
-'{ (x: Int) => ${ run('x); 1 } }
+def fusedUnrolledPowCode(x: Expr[Double], n: Int)(using Quotes): Expr[Double] =
+  x match
+    case '{ power($y, ${Expr(m)}) } => // we have (y^m)^n
+      fusedUnrolledPowCode(y, n * m) // generate code for y * ... * y
+    case _ =>                        //                  ( n*m times )
+      unrolledPowerCode(x, n)
 ```
 
-This is again phase correct, but will lead us into trouble. Indeed, evaluating
-the splice will reduce the expression `run('x)` to `x`. But then the result
+These value extraction sub-patterns can be polymorphic using an instance of `FromExpr`.
+In the following example, we show the implementation of `OptionFromExpr` which internally uses the `FromExpr[T]` to extract the value using the `Expr(x)` pattern.
 
 ```scala
-'{ (x: Int) => ${ x; 1 } }
+given OptionFromExpr[T](using Type[T], FromExpr[T]): FromExpr[Option[T]] with
+  def unapply(x: Expr[Option[T]])(using Quotes): Option[Option[T]] =
+    x match
+      case '{ Some( ${Expr(x)} ) } => Some(Some(x))
+      case '{ None } => Some(None)
+      case _ => None
 ```
 
-is no longer phase correct. To prevent this soundness hole it seems easiest to
-classify `run` as a side-effecting operation. It would thus be prevented from
-appearing in splices. In a base language with side effects we would have to do this
-anyway: Since `run` runs arbitrary code it can always produce a side effect if
-the code it runs produces one.
 
-## Example Expansion
 
-Assume we have two methods, one `map` that takes an `Expr[Array[T]]` and a
-function `f` and one `sum` that performs a sum by delegating to `map`.
+#### Closed patterns
+Patterns may contain two kinds of references: global references such as the call to the `power` method in `'{ power(...) }`, or references to bindings defined in the pattern such as `x` in `case '{ (x: Int) => x }`.
+When extracting an expression from a quote, we need to ensure that we do not extrude any variable from the scope where it is defined.
 
 ```scala
-object Macros:
-
-  def map[T](arr: Expr[Array[T]], f: Expr[T] => Expr[Unit])
-            (using Type[T], Quotes): Expr[Unit] = '{
-    var i: Int = 0
-    while i < ($arr).length do
-      val element: T = ($arr)(i)
-      ${f('element)}
-      i += 1
-  }
-
-  def sum(arr: Expr[Array[Int]])(using Quotes): Expr[Int] = '{
-    var sum = 0
-    ${ map(arr, x => '{sum += $x}) }
-    sum
-  }
-
-  inline def sum_m(arr: Array[Int]): Int = ${sum('arr)}
-
-end Macros
+'{ (x: Int) => x + 1 } match
+  case '{ (y: Int) => $z } =>
+    // should not match, otherwise: z = '{ x + 1 }
 ```
 
-A call to `sum_m(Array(1,2,3))` will first inline `sum_m`:
+In this example, we see that the pattern should not match.
+Otherwise, any use of the expression `z` would contain an unbound reference to `x`.
+To avoid any such extrusion, we only match on a `${..}` if its expression is closed under the definitions within the pattern.
+Therefore, the pattern will not match if the expression is not closed.
+
+#### HOAS patterns
+To allow extracting expressions that may contain extruded references we offer a _higher-order abstract syntax_ (HOAS) pattern `$f(y)` (or `$f(y1,...,yn)`).
+This pattern will eta-expand the sub-expression with respect to `y` and bind it to `f`.
+The lambda arguments will replace the variables that might have been extruded.
 
 ```scala
-val arr: Array[Int] = Array.apply(1, [2,3 : Int]:Int*)
-${_root_.Macros.sum('arr)}
+'{ ((x: Int) => x + 1).apply(2) } match
+  case '{ ((y: Int) => $f(y)).apply($z: Int) } =>
+    // f may contain references to `x` (replaced by `$y`)
+    // f = (y: Expr[Int]) => '{ $y + 1 }
+    f(z) // generates '{ 2 + 1 }
 ```
 
-then it will splice `sum`:
 
-```scala
-val arr: Array[Int] = Array.apply(1, [2,3 : Int]:Int*)
+A HOAS pattern `$x(y1,...,yn)` will only match the expression if it does not contain references to variables defined in the pattern that are not in the set `y1,...,yn`.
+In other words, the pattern will match if the expression only contains references to variables defined in the pattern that are in `y1,...,yn`.
+Note that the HOAS patterns `$x()` are semantically equivalent to closed patterns `$x`.
 
-var sum = 0
-${ map('arr, x => '{sum += $x}) }
-sum
-```
 
-then it will inline `map`:
+#### Type variables
 
+Expressions may contain types that are not statically known.
+For example, an `Expr[List[Int]]` may contain `list.map(_.toInt)` where `list` is a `List` of some type.
+To cover all the possible cases we would need to explicitly match `list` on all possible types (`List[Int]`, `List[Int => Int]`, ...).
+This is an infinite set of types and therefore pattern cases.
+Even if we would know all possible types that a specific program could use, we may still end up with an unmanageable number of cases.
+To overcome this, we introduce type variables in quoted patterns, which will match any type.
+
+In the following example, we show how type variables `t` and `u` match all possible pairs of consecutive calls to `map` on lists.
+In the quoted patterns, types named with lower cases are identified as type variables.
+This follows the same notation as type variables used in normal patterns.
 ```scala
-val arr: Array[Int] = Array.apply(1, [2,3 : Int]:Int*)
+def fuseMapCode(x: Expr[List[Int]]): Expr[List[Int]] =
+  x match
+    case '{ ($ls: List[t]).map[u]($f).map[Int]($g) } =>
+      '{ $ls.map($g.compose($f)) }
+    ...
 
-var sum = 0
-val f = x => '{sum += $x}
-${ _root_.Macros.map('arr, 'f)(Type.of[Int])}
-sum
+fuseMapCode('{ List(1.2).map(f).map(g) }) // '{ List(1.2).map(g.compose(f)) }
+fuseMapCode('{ List('a').map(h).map(i) }) // '{ List('a').map(i.compose(h))  }
 ```
+Variables `f` and `g` are inferred to be of type `Expr[t => u]` and `Expr[u => Int]` respectively.
+Subsequently, we can infer `$g.compose($f)` to be of type `Expr[t => Int]` which is the type of the argument of `$ls.map(..)`.
 
-then it will expand and splice inside quotes `map`:
+Type variables are abstract types that will be erased; this implies that to reference them in the second quote we need a given `Type[t]` and `Type[u]`.
+The quoted pattern will implicitly provide those given types.
+At run-time, when the pattern matches, the type of `t` and `u` will be known, and the `Type[t]` and `Type[u]` will contain the precise types in the expression.
 
-```scala
-val arr: Array[Int] = Array.apply(1, [2,3 : Int]:Int*)
+As `Expr` is covariant, the statically known type of the expression might not be the actual type.
+Type variables can also be used to recover the precise type of the expression.
+``scala
+def let(x: Expr[Any])(using Quotes): Expr[Any] =
+  x match
+    case '{ $x: t } =>
+      '{ val y: t = $x; y }
 
-var sum = 0
-val f = x => '{sum += $x}
-var i: Int = 0
-while i < arr.length do
-  val element: Int = (arr)(i)
-  sum += element
-  i += 1
-sum
+let('{1}) // will return a `Expr[Any]` that contains an `Expr[Int]]`
 ```
 
-Finally cleanups and dead code elimination:
-
+While we can define the type variable in the middle of the pattern, their normal form is to define them as a `type` with a lower case name at the start of the pattern.
+We use the Scala backquote `` `t` `` naming convention which interprets the string within the backquote as a literal name identifier.
+This is typically used when we have names that contain special characters that are not allowed for normal Scala identifiers.
+But we use it to explicitly state that this is a reference to that name and not the introduction of a new variable.
 ```scala
-val arr: Array[Int] = Array.apply(1, [2,3 : Int]:Int*)
-var sum = 0
-var i: Int = 0
-while i < arr.length do
-  val element: Int = arr(i)
-  sum += element
-  i += 1
-sum
+  case '{ type t; $x: `t` } =>
 ```
-
-## Find implicits within a macro
-
-Similarly to the `summonFrom` construct, it is possible to make implicit search available
-in a quote context. For this we simply provide `scala.quoted.Expr.summon`:
+This is a bit more verbose but has some expressivity advantages such as allowing to define bounds on the variables and be able to refer to them several times in any scope of the pattern.
 
 ```scala
-import scala.collection.immutable.{ TreeSet, HashSet }
-inline def setFor[T]: Set[T] = ${ setForExpr[T] }
-
-def setForExpr[T: Type](using Quotes): Expr[Set[T]] =
-  Expr.summon[Ordering[T]] match
-    case Some(ord) => '{ new TreeSet[T]()($ord) }
-    case _ => '{ new HashSet[T] }
+  case '{ type t >: List[Int] <: Seq[Int]; $x: `t` } =>
+  case '{ type t; $x: (`t`, `t`) } =>
 ```
 
-## Relationship with Transparent Inline
 
-[Inline](./inline.md) documents inlining. The code below introduces a transparent
-inline method that can calculate either a value of type `Int` or a value of type
-`String`.
+#### Type patterns
+It is possible to only have a type and no expression of that type.
+To be able to inspect a type, we introduce quoted type pattern `case '[..] =>`.
+It works the same way as a quoted pattern but is restricted to contain a type.
+Type variables can be used in quoted type patterns to extract a type.
 
 ```scala
-transparent inline def defaultOf(inline str: String) =
-  ${ defaultOfImpl('str) }
-
-def defaultOfImpl(strExpr: Expr[String])(using Quotes): Expr[Any] =
-  strExpr.valueOrError match
-    case "int" => '{1}
-    case "string" => '{"a"}
-
-// in a separate file
-val a: Int = defaultOf("int")
-val b: String = defaultOf("string")
-
+def empty[T: Type]: Expr[T] =
+  Type.of[T] match
+    case '[String] => '{ "" }
+    case '[List[t]] => '{ List.empty[t] }
+    ...
 ```
 
-## Defining a macro and using it in a single project
-
-It is possible to define macros and use them in the same project as long as the implementation
-of the macros does not have run-time dependencies on code in the file where it is used.
-It might still have compile-time dependencies on types and quoted code that refers to the use-site file.
-
-To provide this functionality Scala 3 provides a transparent compilation mode where files that
-try to expand a macro but fail because the macro has not been compiled yet are suspended.
-If there are any suspended files when the compilation ends, the compiler will automatically restart
-compilation of the suspended files using the output of the previous (partial) compilation as macro classpath.
-In case all files are suspended due to cyclic dependencies the compilation will fail with an error.
+`Type.of[T]` is used to summon the given instance of `Type[T]` in scope, it is equivalent to `summon[Type[T]]`.
 
-## Pattern matching on quoted expressions
+#### Type testing and casting
+It is important to note that instance checks and casts on `Expr`, such as `isInstanceOf[Expr[T]]` and `asInstanceOf[Expr[T]]`, will only check if the instance is of the class `Expr` but will not be able to check the `T` argument.
+These cases will issue a warning at compile-time, but if they are ignored, they can result in unexpected behavior.
 
-It is possible to deconstruct or extract values out of `Expr` using pattern matching.
+These operations can be supported correctly in the system.
+For a simple type test it is possible to use the `isExprOf[T]` method of `Expr` to check if it is an instance of that type.
+Similarly, it is possible to use `asExprOf[T]` to cast an expression to a given type.
+These operations use a given `Type[T]` to work around type erasure.
 
-`scala.quoted` contains objects that can help extracting values from `Expr`.
 
-- `scala.quoted.Expr`/`scala.quoted.Exprs`: matches an expression of a value (or list of values) and returns the value (or list of values).
-- `scala.quoted.Const`/`scala.quoted.Consts`: Same as `Expr`/`Exprs` but only works on primitive values.
-- `scala.quoted.Varargs`: matches an explicit sequence of expressions and returns them. These sequences are useful to get individual `Expr[T]` out of a varargs expression of type `Expr[Seq[T]]`.
+## Sub-Expression Transformation
 
-These could be used in the following way to optimize any call to `sum` that has statically known values.
+The system provides a mechanism to transform all sub-expressions of an expression.
+This is useful when the sub-expressions we want to transform are deep in the expression.
+It is also necessary if the expression contains sub-expressions that cannot be matched using quoted patterns (such as local class definitions).
 
 ```scala
-inline def sum(inline args: Int*): Int = ${ sumExpr('args) }
-private def sumExpr(argsExpr: Expr[Seq[Int]])(using Quotes): Expr[Int] =
-  argsExpr match
-    case Varargs(args @ Exprs(argValues)) =>
-      // args is of type Seq[Expr[Int]]
-      // argValues is of type Seq[Int]
-      Expr(argValues.sum) // precompute result of sum
-    case Varargs(argExprs) => // argExprs is of type Seq[Expr[Int]]
-      val staticSum: Int = argExprs.map(_.value.getOrElse(0)).sum
-      val dynamicSum: Seq[Expr[Int]] = argExprs.filter(_.value.isEmpty)
-      dynamicSum.foldLeft(Expr(staticSum))((acc, arg) => '{ $acc + $arg })
-    case _ =>
-      '{ $argsExpr.sum }
+trait ExprMap:
+  def transform[T](e: Expr[T])(using Type[T])(using Quotes): Expr[T]
+  def transformChildren[T](e: Expr[T])(using Type[T])(using Quotes): Expr[T] =
+    ...
 ```
 
-### Quoted patterns
-
-Quoted pattens allow deconstructing complex code that contains a precise structure, types or methods.
-Patterns `'{ ... }` can be placed in any location where Scala expects a pattern.
-
-For example
+Users can extend the `ExprMap` trait and implement the `transform` method.
+This interface is flexible and can implement top-down, bottom-up, or other transformations.
 
 ```scala
-optimize {
-   sum(sum(1, a, 2), 3, b)
-} // should be optimized to 6 + a + b
-```
-
-```scala
-def sum(args: Int*): Int = args.sum
-inline def optimize(inline arg: Int): Int = ${ optimizeExpr('arg) }
-private def optimizeExpr(body: Expr[Int])(using Quotes): Expr[Int] =
-  body match
-    // Match a call to sum without any arguments
-    case '{ sum() } => Expr(0)
-    // Match a call to sum with an argument $n of type Int.
-    // n will be the Expr[Int] representing the argument.
-    case '{ sum($n) } => n
-    // Match a call to sum and extracts all its args in an `Expr[Seq[Int]]`
-    case '{ sum(${Varargs(args)}: _*) } => sumExpr(args)
-    case body => body
-
-private def sumExpr(args1: Seq[Expr[Int]])(using Quotes): Expr[Int] =
-  def flatSumArgs(arg: Expr[Int]): Seq[Expr[Int]] = arg match
-    case '{ sum(${Varargs(subArgs)}: _*) } => subArgs.flatMap(flatSumArgs)
-    case arg => Seq(arg)
-  val args2 = args1.flatMap(flatSumArgs)
-  val staticSum: Int = args2.map(_.value.getOrElse(0)).sum
-  val dynamicSum: Seq[Expr[Int]] = args2.filter(_.value.isEmpty)
-  dynamicSum.foldLeft(Expr(staticSum))((acc, arg) => '{ $acc + $arg })
+object OptimizeIdentity extends ExprMap:
+  def transform[T](e: Expr[T])(using Type[T])(using Quotes): Expr[T] =
+    transformChildren(e) match // bottom-up transformation
+      case '{ identity($x) } => x
+      case _ => e
 ```
 
-### Recovering precise types using patterns
+The `transformChildren` method is implemented as a primitive that knows how to reach all the direct sub-expressions and calls `transform` on each one.
+The type passed to `transform` is the expected type of this sub-expression in its expression.
+For example while transforming `Some(1)` in `'{ val x: Option[Int] = Some(1); ...}` the type will be `Option[Int]` and not `Some[Int]`.
+This implies that we can safely transform `Some(1)` into `None`.
 
-Sometimes it is necessary to get a more precise type for an expression. This can be achieved using the following pattern match.
+## Staged Implicit Summoning
+When summoning implicit arguments using `summon`, we will find the given instances in the current scope.
+It is possible to use `summon` to get staged implicit arguments by explicitly staging them first.
+In the following example, we can pass an implicit `Ordering[T]` in a macro as an `Expr[Ordering[T]]` to its implementation.
+Then we can splice it and give it implicitly in the next stage.
 
 ```scala
-def f(expr: Expr[Any])(using Quotes) = expr match
-  case '{ $x: t } =>
-    // If the pattern match succeeds, then there is
-    // some type `t` such that
-    // - `x` is bound to a variable of type `Expr[t]`
-    // - `t` is bound to a new type `t` and a given
-    //   instance `Type[t]` is provided for it
-    // That is, we have `x: Expr[t]` and `given Type[t]`,
-    // for some (unknown) type `t`.
-```
+inline def treeSetFor[T](using ord: Ordering[T]): Set[T] =
+  ${ setExpr[T](using 'ord) }
 
-This might be used to then perform an implicit search as in:
-
-```scala
-extension (inline sc: StringContext)
-  inline def showMe(inline args: Any*): String = ${ showMeExpr('sc, 'args) }
-
-private def showMeExpr(sc: Expr[StringContext], argsExpr: Expr[Seq[Any]])(using Quotes): Expr[String] =
-  import quotes.reflect.report
-  argsExpr match
-    case Varargs(argExprs) =>
-      val argShowedExprs = argExprs.map {
-        case '{ $arg: tp } =>
-          Expr.summon[Show[tp]] match
-            case Some(showExpr) =>
-              '{ $showExpr.show($arg) }
-            case None =>
-              report.error(s"could not find implicit for ${Type.show[Show[tp]]}", arg); '{???}
-      }
-      val newArgsExpr = Varargs(argShowedExprs)
-      '{ $sc.s($newArgsExpr: _*) }
-    case _ =>
-      // `new StringContext(...).showMeExpr(args: _*)` not an explicit `showMeExpr"..."`
-      report.error(s"Args must be explicit", argsExpr)
-      '{???}
-
-trait Show[-T]:
-  def show(x: T): String
-
-// in a different file
-given Show[Boolean] with
-  def show(b: Boolean) = "boolean!"
-
-println(showMe"${true}")
+def setExpr[T:Type](using ord: Expr[Ordering[T]])(using Quotes): Expr[Set[T]] =
+  '{ given Ordering[T] = $ord; new TreeSet[T]() }
 ```
 
-### Open code patterns
-
-Quoted pattern matching also provides higher-order patterns to match open terms. If a quoted term contains a definition,
-then the rest of the quote can refer to this definition.
-
-```scala
-'{
-  val x: Int = 4
-  x * x
-}
-```
+We pass it as an implicit `Expr[Ordering[T]]` because there might be intermediate methods that can pass it along implicitly.
 
-To match such a term we need to match the definition and the rest of the code, but we need to explicitly state that the rest of the code may refer to this definition.
+An alternative is to summon implicit values in the scope where the macro is invoked.
+Using the `Expr.summon` method we get an optional expression containing the implicit instance.
+This provides the ability to search for implicit instances conditionally.
 
 ```scala
-case '{ val y: Int = $x; $body(y): Int } =>
+def summon[T: Type](using Quotes): Option[Expr[T]]
 ```
 
-Here `$x` will match any closed expression while `$body(y)` will match an expression that is closed under `y`. Then
-the subexpression of type `Expr[Int]` is bound to `body` as an `Expr[Int => Int]`. The extra argument represents the references to `y`. Usually this expression is used in combination with `Expr.betaReduce` to replace the extra argument.
-
 ```scala
-inline def eval(inline e: Int): Int = ${ evalExpr('e) }
-
-private def evalExpr(e: Expr[Int])(using Quotes): Expr[Int] = e match
-  case '{ val y: Int = $x; $body(y): Int } =>
-    // body: Expr[Int => Int] where the argument represents
-    // references to y
-    evalExpr(Expr.betaReduce('{$body(${evalExpr(x)})}))
-  case '{ ($x: Int) * ($y: Int) } =>
-    (x.value, y.value) match
-      case (Some(a), Some(b)) => Expr(a * b)
-      case _ => e
-  case _ => e
-```
+inline def setFor[T]: Set[T] =
+  ${ setForExpr[T] }
 
-```scala
-eval { // expands to the code: (16: Int)
-  val x: Int = 4
-  x * x
-}
+def setForExpr[T: Type]()(using Quotes): Expr[Set[T]] =
+  Expr.summon[Ordering[T]] match
+    case Some(ord) =>
+      '{ new TreeSet[T]()($ord) }
+    case _ =>
+      '{ new HashSet[T] }
 ```
 
-We can also close over several bindings using `$b(a1, a2, ..., an)`.
-To match an actual application we can use braces on the function part `${b}(a1, a2, ..., an)`.
-
 ## More details
 
 [More details](./macros-spec.md)
+
+
+[^1]: [Scalable Metaprogramming in Scala 3](https://infoscience.epfl.ch/record/299370)
+[^2]: [Semantics-preserving inlining for metaprogramming](https://dl.acm.org/doi/10.1145/3426426.3428486)
+[^3]: Implemented in the Scala 3 Dotty project https://github.com/lampepfl/dotty. sbt library dependency `"org.scala-lang" %% "scala3-staging" % scalaVersion.value`
+[^4]: Using the `-Xcheck-macros` compiler flag
diff --git a/docs/_spec/TODOreference/metaprogramming/staging.md b/docs/_spec/TODOreference/metaprogramming/staging.md
index e74d491402b5..6d9166e8249e 100644
--- a/docs/_spec/TODOreference/metaprogramming/staging.md
+++ b/docs/_spec/TODOreference/metaprogramming/staging.md
@@ -60,7 +60,7 @@ impose the following restrictions on the use of splices.
 The framework as discussed so far allows code to be staged, i.e. be prepared
 to be executed at a later stage. To run that code, there is another method
 in class `Expr` called `run`. Note that `$` and `run` both map from `Expr[T]`
-to `T` but only `$` is subject to the [PCP](./macros.md#the-phase-consistency-principle), whereas `run` is just a normal method.
+to `T` but only `$` is subject to the [Cross-Stage Safety](./macros.md#cross-stage-safety), whereas `run` is just a normal method.
 `scala.quoted.staging.run` provides a `Quotes` that can be used to show the expression in its scope.
 On the other hand `scala.quoted.staging.withQuotes` provides a `Quotes` without evaluating the expression.
 

From 06b5684b47f4d49ae3d67cc11ee54905a81c35b5 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 6 Mar 2023 11:42:27 +0100
Subject: [PATCH 286/657] Avoid creation of `@SplicedType` quote local
 refrences

The type declarations annotated with `@SplicedType` are only meant for
types that come from outside the quote. If the reference to the `Type[T]`
is to a definition within the quote (i.e. its level is grater than 0) we
can use it directly. The `@SplicedType` for that type will be generated
in a future compilation phase when the `Type[T]` definition reaches
level 0.

Fixes #17026
---
 compiler/src/dotty/tools/dotc/staging/HealType.scala | 6 ++++--
 tests/pos-macros/i17026.scala                        | 3 +++
 tests/pos-macros/i17026b.scala                       | 7 +++++++
 3 files changed, 14 insertions(+), 2 deletions(-)
 create mode 100644 tests/pos-macros/i17026.scala
 create mode 100644 tests/pos-macros/i17026b.scala

diff --git a/compiler/src/dotty/tools/dotc/staging/HealType.scala b/compiler/src/dotty/tools/dotc/staging/HealType.scala
index 44843dfa91ca..22008f381c32 100644
--- a/compiler/src/dotty/tools/dotc/staging/HealType.scala
+++ b/compiler/src/dotty/tools/dotc/staging/HealType.scala
@@ -4,6 +4,7 @@ package staging
 import dotty.tools.dotc.core.Contexts._
 import dotty.tools.dotc.core.Decorators._
 import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.Types._
 import dotty.tools.dotc.staging.QuoteContext.*
@@ -68,13 +69,14 @@ class HealType(pos: SrcPos)(using Context) extends TypeMap {
    *  reference to a type alias containing the equivalent of `${summon[quoted.Type[T]]}`.
    *  Emits an error if `T` cannot be healed and returns `T`.
    */
-  protected def tryHeal(sym: Symbol, tp: TypeRef, pos: SrcPos): TypeRef = {
+  protected def tryHeal(sym: Symbol, tp: TypeRef, pos: SrcPos): Type = {
     val reqType = defn.QuotedTypeClass.typeRef.appliedTo(tp)
     val tag = ctx.typer.inferImplicitArg(reqType, pos.span)
     tag.tpe match
       case tp: TermRef =>
         ctx.typer.checkStable(tp, pos, "type witness")
-        getQuoteTypeTags.getTagRef(tp)
+        if levelOf(tp.symbol) > 0 then tp.select(tpnme.Underlying)
+        else getQuoteTypeTags.getTagRef(tp)
       case _: SearchFailureType =>
         report.error(
           ctx.typer.missingArgMsg(tag, reqType, "")
diff --git a/tests/pos-macros/i17026.scala b/tests/pos-macros/i17026.scala
new file mode 100644
index 000000000000..d8845ef1d086
--- /dev/null
+++ b/tests/pos-macros/i17026.scala
@@ -0,0 +1,3 @@
+import scala.quoted.*
+def macroImpl(using Quotes) =
+  '{ def weird[A: Type](using Quotes) = Type.of[A] }
diff --git a/tests/pos-macros/i17026b.scala b/tests/pos-macros/i17026b.scala
new file mode 100644
index 000000000000..98a29066462e
--- /dev/null
+++ b/tests/pos-macros/i17026b.scala
@@ -0,0 +1,7 @@
+import scala.quoted.*
+
+def macroImpl(using Quotes) =
+  '{
+    def weird[A: ToExpr: Type](a: A)(using quotes: Quotes) =
+      '{ Some(${ Expr(a) }) }
+  }

From 7fed80e4c3827bd3a7f8199bf702ab508790e660 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Tue, 14 Mar 2023 16:11:07 +0100
Subject: [PATCH 287/657] Add test for wunused Inlined call

---
 .../tools/dotc/transform/CheckUnused.scala    |  3 +--
 .../fatal-warnings/i15503i.scala              | 22 ++++++++++++++++++-
 2 files changed, 22 insertions(+), 3 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index 35153dbf66e9..5e4ed6f6e0df 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -59,7 +59,6 @@ class CheckUnused extends MiniPhase:
   // ========== SETUP ============
 
   override def prepareForUnit(tree: tpd.Tree)(using Context): Context =
-    println(tree)
     val data = UnusedData()
     val fresh = ctx.fresh.setProperty(_key, data)
     fresh
@@ -76,7 +75,7 @@ class CheckUnused extends MiniPhase:
     traverser.traverse(tree)
     ctx
 
-  def prepareForInlined(tree: Inlined)(using Context): Context =
+  override def prepareForInlined(tree: tpd.Inlined)(using Context): Context =
     traverser.traverse(tree.call)
     ctx
 
diff --git a/tests/neg-custom-args/fatal-warnings/i15503i.scala b/tests/neg-custom-args/fatal-warnings/i15503i.scala
index 9f8416146af4..3dd4d1fc61e7 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503i.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503i.scala
@@ -209,7 +209,7 @@ package foo.test.i16925:
       _ = println(i) // OK
     } yield ()
 
-package foo.test.i16679:
+package foo.test.i16679a:
   object myPackage:
     trait CaseClassName[A]:
       def name: String
@@ -225,3 +225,23 @@ package foo.test.i16679:
     import myPackage.CaseClassName // OK
     case class CoolClass(i: Int) derives CaseClassName.CaseClassByStringName
     println(summon[CaseClassName[CoolClass]].name)
+
+package foo.test.i16679b:
+  object myPackage:
+    trait CaseClassName[A]:
+      def name: String
+
+    object CaseClassName:
+      import scala.deriving.Mirror
+      inline final def derived[A](using inline A: Mirror.Of[A]): CaseClassName[A] =
+        new CaseClassName[A]:
+          def name: String = A.toString
+
+  object Foo:
+    given x: myPackage.CaseClassName[secondPackage.CoolClass] = null
+
+  object secondPackage:
+    import myPackage.CaseClassName // OK
+    import Foo.x
+    case class CoolClass(i: Int)
+    println(summon[myPackage.CaseClassName[CoolClass]])

From 421591fc792480033e28714bb2ecc60c32923d9b Mon Sep 17 00:00:00 2001
From: Flavio Brasil <fwbrasil@gmail.com>
Date: Sat, 11 Mar 2023 14:08:13 -0800
Subject: [PATCH 288/657] optimization: avoid NotGiven allocations

---
 library/src/scala/util/NotGiven.scala | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/library/src/scala/util/NotGiven.scala b/library/src/scala/util/NotGiven.scala
index 99cc903d4426..973e709042cb 100644
--- a/library/src/scala/util/NotGiven.scala
+++ b/library/src/scala/util/NotGiven.scala
@@ -31,11 +31,13 @@ trait LowPriorityNotGiven {
 }
 object NotGiven extends LowPriorityNotGiven {
 
+  private val cachedValue = new NotGiven[Nothing]()
+
   /** A value of type `NotGiven` to signal a successful search for `NotGiven[C]` (i.e. a failing
    *  search for `C`). A reference to this value will be explicitly constructed by Dotty's
    *  implicit search algorithm
    */
-  def value: NotGiven[Nothing] = new NotGiven[Nothing]()
+  def value: NotGiven[Nothing] = cachedValue
 
   /** One of two ambiguous methods used to emulate negation in Scala 2 */
   given amb1[T](using ev: T): NotGiven[T] = ???

From 64709f8710b7c4b9c5155a0b325297f50f134294 Mon Sep 17 00:00:00 2001
From: Decel <8268812+Decel@users.noreply.github.com>
Date: Wed, 15 Mar 2023 03:22:30 +0100
Subject: [PATCH 289/657] Add a regression test

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

diff --git a/tests/pos/i10369.scala b/tests/pos/i10369.scala
new file mode 100644
index 000000000000..8689c2833664
--- /dev/null
+++ b/tests/pos/i10369.scala
@@ -0,0 +1,15 @@
+type Upgrade[T] = T match
+  case Int => Double
+  case Char => String
+  case Boolean => Boolean
+
+val upgrade: [t] => t => Upgrade[t] = new PolyFunction:
+  def apply[T](x: T): Upgrade[T] = x match
+    case x: Int => x.toDouble
+    case x: Char => x.toString
+    case x: Boolean => !x
+
+val upgrade2: [t] => t => Upgrade[t] = [t] => (x: t) => x match
+  case x: Int => x.toDouble
+  case x: Char => x.toString
+  case x: Boolean => !x

From 2d1ef6386a18f26735e0057a1216c67e7858962c Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Wed, 15 Mar 2023 13:51:35 +0100
Subject: [PATCH 290/657] Fix references to class members defined in quotes

If an inner quote selects a symbol that is defined in an outer quote we
need to transform it or reject it. The issue is that the inner quote
cannot contain a reference to the type of the class defined in the outer
quote. Any such reference is erased the parents of that class that are
statically know outside those quotes. If the selected symbol is
overriding a symbol in one of those statically known classes, we can use
that overridden symbol instead. If not we have to reject the code.

Fixes #17103
---
 .../dotty/tools/dotc/transform/Splicing.scala |  8 +++++++
 tests/neg-macros/i17103.scala                 | 16 ++++++++++++++
 tests/pos-macros/i17103a.scala                | 21 +++++++++++++++++++
 tests/pos-macros/i17103b.scala                | 21 +++++++++++++++++++
 tests/pos-macros/i7405b.scala                 |  6 +++++-
 5 files changed, 71 insertions(+), 1 deletion(-)
 create mode 100644 tests/neg-macros/i17103.scala
 create mode 100644 tests/pos-macros/i17103a.scala
 create mode 100644 tests/pos-macros/i17103b.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/Splicing.scala b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
index 7ecde9400445..47b65ba767bb 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicing.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
@@ -208,6 +208,14 @@ class Splicing extends MacroTransform:
 
     override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
       tree match
+        case tree: Select if tree.isTerm && isCaptured(tree.symbol) =>
+          tree.symbol.allOverriddenSymbols.find(sym => !isCaptured(sym.owner)) match
+            case Some(sym) =>
+              // virtualize call on overridden symbol that is not defined in a non static class
+              transform(tree.qualifier.select(sym))
+            case _ =>
+              report.error(em"Can not use reference to staged local ${tree.symbol} defined in an outer quote.\n\nThis can work if ${tree.symbol.owner} would extend a top level interface that defines ${tree.symbol}.", tree)
+              tree
         case tree: RefTree =>
           if tree.isTerm then
             if isCaptured(tree.symbol) then
diff --git a/tests/neg-macros/i17103.scala b/tests/neg-macros/i17103.scala
new file mode 100644
index 000000000000..bd4b41d8b559
--- /dev/null
+++ b/tests/neg-macros/i17103.scala
@@ -0,0 +1,16 @@
+import scala.quoted.*
+
+def test(using Quotes): Expr[Unit] =
+  '{
+    trait C:
+      def d: Int
+    val c: C = ???
+    ${
+      val expr = '{
+        val cRef: c.type = ???
+        cRef.d // error
+        ()
+      }
+      expr
+    }
+  }
\ No newline at end of file
diff --git a/tests/pos-macros/i17103a.scala b/tests/pos-macros/i17103a.scala
new file mode 100644
index 000000000000..ffd0c15f28b2
--- /dev/null
+++ b/tests/pos-macros/i17103a.scala
@@ -0,0 +1,21 @@
+import scala.quoted.*
+
+trait C0:
+  def d: Int
+
+def test(using Quotes): Expr[Unit] =
+  '{
+    trait C1 extends C0:
+      def d: Int
+    trait C extends C1:
+      def d: Int
+    val c: C = ???
+    ${
+      val expr = '{
+        val cRef: C = ???
+        cRef.d // calls C0.d
+        ()
+      }
+      expr
+    }
+  }
diff --git a/tests/pos-macros/i17103b.scala b/tests/pos-macros/i17103b.scala
new file mode 100644
index 000000000000..0fbe86f0cf73
--- /dev/null
+++ b/tests/pos-macros/i17103b.scala
@@ -0,0 +1,21 @@
+import scala.quoted.*
+
+trait C0:
+  def d: Int
+
+def test(using Quotes): Expr[Unit] =
+  '{
+    trait C1 extends C0:
+      def d: Int
+    trait C extends C1:
+      def d: Int
+    val c: C = ???
+    ${
+      val expr = '{
+        val cRef: c.type = ???
+        cRef.d // calls C0.d
+        ()
+      }
+      expr
+    }
+  }
diff --git a/tests/pos-macros/i7405b.scala b/tests/pos-macros/i7405b.scala
index df7218608e88..6c73c275e15f 100644
--- a/tests/pos-macros/i7405b.scala
+++ b/tests/pos-macros/i7405b.scala
@@ -3,7 +3,7 @@ import scala.quoted.*
 class Foo {
   def f(using Quotes): Expr[Any] = {
     '{
-      trait X {
+      trait X extends A {
         type Y
         def y: Y = ???
       }
@@ -17,3 +17,7 @@ class Foo {
     }
   }
 }
+
+trait A:
+  type Y
+  def y: Y = ???

From 60b6ff04d0d25415840a9f1de88ea8518f0973a3 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Wed, 15 Mar 2023 11:35:57 +0100
Subject: [PATCH 291/657] Allow selectDynamic and applyDynamic to be an
 extension methods

Allow selectDynamic and applyDynamic to be an extension methods when dispatching structurally.

Fixes #17100
---
 compiler/src/dotty/tools/dotc/typer/Dynamic.scala |  8 ++++----
 tests/pos/i17100.scala                            | 10 ++++++++++
 2 files changed, 14 insertions(+), 4 deletions(-)
 create mode 100644 tests/pos/i17100.scala

diff --git a/compiler/src/dotty/tools/dotc/typer/Dynamic.scala b/compiler/src/dotty/tools/dotc/typer/Dynamic.scala
index 8ec4e9416151..1513872cf47a 100644
--- a/compiler/src/dotty/tools/dotc/typer/Dynamic.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Dynamic.scala
@@ -186,7 +186,7 @@ trait Dynamic {
       // ($qual: Selectable).$selectorName("$name")
       val base =
         untpd.Apply(
-          untpd.TypedSplice(selectable.select(selectorName)).withSpan(fun.span),
+          untpd.Select(untpd.TypedSplice(selectable), selectorName).withSpan(fun.span),
           (Literal(Constant(name.encode.toString)) :: Nil).map(untpd.TypedSplice(_)))
 
       val scall =
@@ -219,19 +219,19 @@ trait Dynamic {
     extension (tree: Tree)
       /** The implementations of `selectDynamic` and `applyDynamic` in `scala.reflect.SelectDynamic` have no information about the expected return type of a value/method which was declared in the refinement,
        *  only the JVM type after erasure can be obtained through reflection, e.g.
-       *  
+       *
        *  class Foo(val i: Int) extends AnyVal
        *  class Reflective extends reflect.Selectable
        *  val reflective = new Reflective {
        *    def foo = Foo(1) // Foo at compile time, java.lang.Integer in reflection
        *  }
-       * 
+       *
        *  Because of that reflective access cannot be implemented properly in `scala.reflect.SelectDynamic` itself
        *  because it's not known there if the value should be wrapped in a value class constructor call or not.
        *  Hence the logic of wrapping is performed here, relying on the fact that the implementations of `selectDynamic` and `applyDynamic` in `scala.reflect.SelectDynamic` are final.
        */
       def maybeBoxingCast(tpe: Type) =
-        val maybeBoxed = 
+        val maybeBoxed =
           if ValueClasses.isDerivedValueClass(tpe.classSymbol) && qual.tpe <:< defn.ReflectSelectableTypeRef then
             val genericUnderlying = ValueClasses.valueClassUnbox(tpe.classSymbol.asClass)
             val underlying = tpe.select(genericUnderlying).widen.resultType
diff --git a/tests/pos/i17100.scala b/tests/pos/i17100.scala
new file mode 100644
index 000000000000..2fd01bcbe5ff
--- /dev/null
+++ b/tests/pos/i17100.scala
@@ -0,0 +1,10 @@
+trait Sel extends Selectable
+
+extension (s: Sel)
+  def selectDynamic(name: String) = ???
+  def applyDynamic(name: String)(x: Int) = ???
+
+val sel = (new Sel {}).asInstanceOf[Sel{ def foo: String; def bar(x: Int): Int }]
+val foo = sel.selectDynamic("foo")
+val foo2 = sel.foo
+val foo3 = sel.bar(2)

From a3242e82b20d9df8b8d48ba9e50b96f93009e5cb Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Wed, 15 Mar 2023 13:04:55 +0100
Subject: [PATCH 292/657] Update semanticDB expect files

---
 tests/pos/i17100.scala                        | 6 +++++-
 tests/semanticdb/expect/Advanced.expect.scala | 8 ++++----
 tests/semanticdb/metac.expect                 | 6 +++++-
 3 files changed, 14 insertions(+), 6 deletions(-)

diff --git a/tests/pos/i17100.scala b/tests/pos/i17100.scala
index 2fd01bcbe5ff..1858e0383f8d 100644
--- a/tests/pos/i17100.scala
+++ b/tests/pos/i17100.scala
@@ -3,8 +3,12 @@ trait Sel extends Selectable
 extension (s: Sel)
   def selectDynamic(name: String) = ???
   def applyDynamic(name: String)(x: Int) = ???
+  def applyDynamic(name: String)() = ???
 
-val sel = (new Sel {}).asInstanceOf[Sel{ def foo: String; def bar(x: Int): Int }]
+val sel = (new Sel {}).asInstanceOf[Sel{ def foo: String; def bar(x: Int): Int; def baz(): Int }]
 val foo = sel.selectDynamic("foo")
 val foo2 = sel.foo
 val foo3 = sel.bar(2)
+val foo4 = sel.baz()
+
+
diff --git a/tests/semanticdb/expect/Advanced.expect.scala b/tests/semanticdb/expect/Advanced.expect.scala
index c701821a09b8..d36fcd611eef 100644
--- a/tests/semanticdb/expect/Advanced.expect.scala
+++ b/tests/semanticdb/expect/Advanced.expect.scala
@@ -25,11 +25,11 @@ class Wildcards/*<-advanced::Wildcards#*/ {
 object Test/*<-advanced::Test.*/ {
   val s/*<-advanced::Test.s.*/ = new Structural/*->advanced::Structural#*/
   val s1/*<-advanced::Test.s1.*/ = s/*->advanced::Test.s.*/.s1/*->advanced::Structural#s1().*/
-  val s1x/*<-advanced::Test.s1x.*/ = s/*->advanced::Test.s.*/.s1/*->advanced::Structural#s1().*/.x
+  val s1x/*<-advanced::Test.s1x.*/ = s/*->advanced::Test.s.*/.s1/*->advanced::Structural#s1().*/.x/*->scala::reflect::Selectable#selectDynamic().*/
   val s2/*<-advanced::Test.s2.*/ = s/*->advanced::Test.s.*/.s2/*->advanced::Structural#s2().*/
-  val s2x/*<-advanced::Test.s2x.*/ = s/*->advanced::Test.s.*/.s2/*->advanced::Structural#s2().*/.x
+  val s2x/*<-advanced::Test.s2x.*/ = s/*->advanced::Test.s.*/.s2/*->advanced::Structural#s2().*/.x/*->scala::reflect::Selectable#selectDynamic().*/
   val s3/*<-advanced::Test.s3.*/ = s/*->advanced::Test.s.*/.s3/*->advanced::Structural#s3().*/
-  val s3x/*<-advanced::Test.s3x.*/ = s/*->advanced::Test.s.*/.s3/*->advanced::Structural#s3().*/.m(???/*->scala::Predef.`???`().*/)
+  val s3x/*<-advanced::Test.s3x.*/ = s/*->advanced::Test.s.*/.s3/*->advanced::Structural#s3().*/.m/*->scala::reflect::Selectable#applyDynamic().*/(???/*->scala::Predef.`???`().*/)
 
   val e/*<-advanced::Test.e.*/ = new Wildcards/*->advanced::Wildcards#*/
   val e1/*<-advanced::Test.e1.*/ = e/*->advanced::Test.e.*/.e1/*->advanced::Wildcards#e1().*/
@@ -45,7 +45,7 @@ object Test/*<-advanced::Test.*/ {
 
   // see: https://github.com/lampepfl/dotty/pull/14608#discussion_r835642563
   lazy val foo/*<-advanced::Test.foo.*/: (reflect.Selectable/*->scala::reflect::Selectable#*/ { type A/*<-local16*/ = Int/*->scala::Int#*/ }) &/*->scala::`&`#*/ (reflect.Selectable/*->scala::reflect::Selectable#*/ { type A/*<-local17*/ = Int/*->scala::Int#*/; val a/*<-local18*/: A/*->local17*/ }) = ???/*->scala::Predef.`???`().*/
-  def bar/*<-advanced::Test.bar().*/: foo/*->advanced::Test.foo.*/.A/*->local17*/ = foo/*->advanced::Test.foo.*/.a
+  def bar/*<-advanced::Test.bar().*/: foo/*->advanced::Test.foo.*/.A/*->local17*/ = foo/*->advanced::Test.foo.*/.a/*->scala::reflect::Selectable#selectDynamic().*/
 }
 
 
diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect
index c78d30e00863..f5556e28bd1b 100644
--- a/tests/semanticdb/metac.expect
+++ b/tests/semanticdb/metac.expect
@@ -49,7 +49,7 @@ Uri => Advanced.scala
 Text => empty
 Language => Scala
 Symbols => 60 entries
-Occurrences => 134 entries
+Occurrences => 138 entries
 Synthetics => 3 entries
 
 Symbols:
@@ -187,18 +187,21 @@ Occurrences:
 [27:6..27:9): s1x <- advanced/Test.s1x.
 [27:12..27:13): s -> advanced/Test.s.
 [27:14..27:16): s1 -> advanced/Structural#s1().
+[27:16..27:18): .x -> scala/reflect/Selectable#selectDynamic().
 [28:6..28:8): s2 <- advanced/Test.s2.
 [28:11..28:12): s -> advanced/Test.s.
 [28:13..28:15): s2 -> advanced/Structural#s2().
 [29:6..29:9): s2x <- advanced/Test.s2x.
 [29:12..29:13): s -> advanced/Test.s.
 [29:14..29:16): s2 -> advanced/Structural#s2().
+[29:16..29:18): .x -> scala/reflect/Selectable#selectDynamic().
 [30:6..30:8): s3 <- advanced/Test.s3.
 [30:11..30:12): s -> advanced/Test.s.
 [30:13..30:15): s3 -> advanced/Structural#s3().
 [31:6..31:9): s3x <- advanced/Test.s3x.
 [31:12..31:13): s -> advanced/Test.s.
 [31:14..31:16): s3 -> advanced/Structural#s3().
+[31:16..31:18): .m -> scala/reflect/Selectable#applyDynamic().
 [31:19..31:22): ??? -> scala/Predef.`???`().
 [33:6..33:7): e <- advanced/Test.e.
 [33:14..33:23): Wildcards -> advanced/Wildcards#
@@ -233,6 +236,7 @@ Occurrences:
 [47:11..47:14): foo -> advanced/Test.foo.
 [47:15..47:16): A -> local17
 [47:19..47:22): foo -> advanced/Test.foo.
+[47:22..47:24): .a -> scala/reflect/Selectable#selectDynamic().
 [52:6..52:13): HKClass <- advanced/HKClass#
 [52:14..52:15): F <- advanced/HKClass#[F]
 [52:20..52:21): T <- advanced/HKClass#`<init>`().[F][T]

From fa29ba5c03da550123299611aa7f4c32028472ce Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Wed, 15 Mar 2023 13:41:31 +0100
Subject: [PATCH 293/657] Also allow structural dispatch on Dynamic

Given
```scala
trait Sel extends Dynamic

extension (s: Sel)
  def selectDynamic(name: String) = ???
```
the following worked:
```scala
val sel = new Sel {}
val foo = sel.foo
```
but the following didn't:
```scala
val sel2 = (new Sel {}).asInstanceOf[Sel{ def foo: String }]
val foo2 = sel2.foo
```
The problem was that we recognized a structural dispatch and then required
the qualifier to be an instance of `Selectable`. But in fact, `Dynamic`
works just as well, and the mechanism is the same. It's just that
`Dynamic` is less type safe then `Selectable`.
---
 compiler/src/dotty/tools/dotc/typer/Dynamic.scala |  2 +-
 tests/pos/i17100a.scala                           | 12 ++++++++++++
 2 files changed, 13 insertions(+), 1 deletion(-)
 create mode 100644 tests/pos/i17100a.scala

diff --git a/compiler/src/dotty/tools/dotc/typer/Dynamic.scala b/compiler/src/dotty/tools/dotc/typer/Dynamic.scala
index 1513872cf47a..717966923708 100644
--- a/compiler/src/dotty/tools/dotc/typer/Dynamic.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Dynamic.scala
@@ -181,7 +181,7 @@ trait Dynamic {
     val vargss = termArgss(tree)
 
     def structuralCall(selectorName: TermName, classOfs: => List[Tree]) = {
-      val selectable = adapt(qual, defn.SelectableClass.typeRef)
+      val selectable = adapt(qual, defn.SelectableClass.typeRef | defn.DynamicClass.typeRef)
 
       // ($qual: Selectable).$selectorName("$name")
       val base =
diff --git a/tests/pos/i17100a.scala b/tests/pos/i17100a.scala
new file mode 100644
index 000000000000..abf74c80a4f5
--- /dev/null
+++ b/tests/pos/i17100a.scala
@@ -0,0 +1,12 @@
+
+import scala.language.dynamics
+trait Sel extends Dynamic
+
+extension (s: Sel)
+  def selectDynamic(name: String) = ???
+
+val sel = new Sel {}
+val foo = sel.foo
+val sel2 = (new Sel {}).asInstanceOf[Sel{ def foo: String }]
+val foo2 = sel2.foo
+

From 5fb69be4eaac058d1d19fb72eb79e04bb8fe7d93 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Doeraene?= <sjrdoeraene@gmail.com>
Date: Wed, 15 Mar 2023 16:38:00 +0100
Subject: [PATCH 294/657] Fix #17042: Preserve the shape of secondary ctors in
 instrumentCoverage.

---
 .../dotc/transform/InstrumentCoverage.scala   |  30 +++-
 tests/coverage/pos/Constructor.scala          |  10 ++
 .../coverage/pos/Constructor.scoverage.check  | 145 ++++++++++++++----
 3 files changed, 154 insertions(+), 31 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/InstrumentCoverage.scala b/compiler/src/dotty/tools/dotc/transform/InstrumentCoverage.scala
index c69b342b9a01..29572a4ae30d 100644
--- a/compiler/src/dotty/tools/dotc/transform/InstrumentCoverage.scala
+++ b/compiler/src/dotty/tools/dotc/transform/InstrumentCoverage.scala
@@ -11,6 +11,7 @@ import core.DenotTransformers.IdentityDenotTransformer
 import core.Symbols.{defn, Symbol}
 import core.Constants.Constant
 import core.NameOps.isContextFunction
+import core.StdNames.nme
 import core.Types.*
 import coverage.*
 import typer.LiftCoverage
@@ -325,7 +326,11 @@ class InstrumentCoverage extends MacroTransform with IdentityDenotTransformer:
         // 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 tree.rhs.isEmpty then
+            tree.rhs
+          else if sym.isClassConstructor then
+            instrumentSecondaryCtor(tree)
+          else if !sym.isOneOf(Accessor | Artifact | Synthetic) 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`),
@@ -410,6 +415,24 @@ class InstrumentCoverage extends MacroTransform with IdentityDenotTransformer:
           val coverageCall = createInvokeCall(parent, pos)
           InstrumentedParts.singleExprTree(coverageCall, body)
 
+    /** Instruments the body of a secondary constructor DefDef.
+     *
+     *  We must preserve the delegate constructor call as the first statement of
+     *  the rhs Block, otherwise `HoistSuperArgs` will not be happy (see #17042).
+     */
+    private def instrumentSecondaryCtor(ctorDef: DefDef)(using Context): Tree =
+      // compute position like in instrumentBody
+      val namePos = ctorDef.namePos
+      val pos = namePos.withSpan(namePos.span.withStart(ctorDef.span.start))
+      val coverageCall = createInvokeCall(ctorDef, pos)
+
+      ctorDef.rhs match
+        case b @ Block(delegateCtorCall :: stats, expr: Literal) =>
+          cpy.Block(b)(transform(delegateCtorCall) :: coverageCall :: stats.mapConserve(transform), expr)
+        case rhs =>
+          cpy.Block(rhs)(transform(rhs) :: coverageCall :: Nil, unitLiteral)
+    end instrumentSecondaryCtor
+
     /**
      * Checks if the apply needs a lift in the coverage phase.
      * In case of a nested application, we have to lift all arguments
@@ -447,9 +470,14 @@ class InstrumentCoverage extends MacroTransform with IdentityDenotTransformer:
 
     /** Check if an Apply can be instrumented. Prevents this phase from generating incorrect code. */
     private def canInstrumentApply(tree: Apply)(using Context): Boolean =
+      def isSecondaryCtorDelegateCall: Boolean = tree.fun match
+        case Select(This(_), nme.CONSTRUCTOR) => true
+        case _                                => false
+
       val sym = tree.symbol
       !sym.isOneOf(ExcludeMethodFlags)
       && !isCompilerIntrinsicMethod(sym)
+      && !(sym.isClassConstructor && isSecondaryCtorDelegateCall)
       && (tree.typeOpt match
         case AppliedType(tycon: NamedType, _) =>
           /* If the last expression in a block is a context function, we'll try to
diff --git a/tests/coverage/pos/Constructor.scala b/tests/coverage/pos/Constructor.scala
index 251370ec8e6e..536bfa26f386 100644
--- a/tests/coverage/pos/Constructor.scala
+++ b/tests/coverage/pos/Constructor.scala
@@ -1,10 +1,20 @@
 package covtest
 
 class C:
+  def this(arg: String) = {
+    this()
+    g()
+  }
+
+  def this(x: Int) =
+    this(x.toString() + "foo")
+
   def f(x: Int) = x
   def x = 1
   f(x)
 
+  def g(): Int = 2
+
 object O:
   def g(y: Int) = y
   def y = 1
diff --git a/tests/coverage/pos/Constructor.scoverage.check b/tests/coverage/pos/Constructor.scoverage.check
index 678da472fd4c..6a6742c9118d 100644
--- a/tests/coverage/pos/Constructor.scoverage.check
+++ b/tests/coverage/pos/Constructor.scoverage.check
@@ -24,10 +24,78 @@ covtest
 C
 Class
 covtest.C
-f
+<init>
 28
-33
+36
 3
+<init>
+DefDef
+false
+0
+false
+def this
+
+1
+Constructor.scala
+covtest
+C
+Class
+covtest.C
+<init>
+69
+72
+5
+g
+Apply
+false
+0
+false
+g()
+
+2
+Constructor.scala
+covtest
+C
+Class
+covtest.C
+<init>
+80
+88
+8
+<init>
+DefDef
+false
+0
+false
+def this
+
+3
+Constructor.scala
+covtest
+C
+Class
+covtest.C
+<init>
+108
+128
+9
++
+Apply
+false
+0
+false
+x.toString() + "foo"
+
+4
+Constructor.scala
+covtest
+C
+Class
+covtest.C
+f
+133
+138
+11
 f
 DefDef
 false
@@ -35,16 +103,16 @@ false
 false
 def f
 
-1
+5
 Constructor.scala
 covtest
 C
 Class
 covtest.C
 x
-48
-53
-4
+153
+158
+12
 x
 DefDef
 false
@@ -52,16 +120,16 @@ false
 false
 def x
 
-2
+6
 Constructor.scala
 covtest
 C
 Class
 covtest.C
 <init>
-60
-64
-5
+165
+169
+13
 f
 Apply
 false
@@ -69,16 +137,16 @@ false
 false
 f(x)
 
-3
+7
 Constructor.scala
 covtest
 C
 Class
 covtest.C
 <init>
-62
-63
-5
+167
+168
+13
 x
 Select
 false
@@ -86,16 +154,33 @@ false
 false
 x
 
-4
+8
+Constructor.scala
+covtest
+C
+Class
+covtest.C
+g
+173
+178
+15
+g
+DefDef
+false
+0
+false
+def g
+
+9
 Constructor.scala
 covtest
 O$
 Object
 covtest.O$
 g
-78
-83
-8
+203
+208
+18
 g
 DefDef
 false
@@ -103,16 +188,16 @@ false
 false
 def g
 
-5
+10
 Constructor.scala
 covtest
 O$
 Object
 covtest.O$
 y
-98
-103
-9
+223
+228
+19
 y
 DefDef
 false
@@ -120,16 +205,16 @@ false
 false
 def y
 
-6
+11
 Constructor.scala
 covtest
 O$
 Object
 covtest.O$
 <init>
-110
-114
-10
+235
+239
+20
 g
 Apply
 false
@@ -137,16 +222,16 @@ false
 false
 g(y)
 
-7
+12
 Constructor.scala
 covtest
 O$
 Object
 covtest.O$
 <init>
-112
-113
-10
+237
+238
+20
 y
 Ident
 false

From 9afa629bc844340527361473e0326a64d9e6a5da Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Wed, 8 Mar 2023 18:40:14 +0000
Subject: [PATCH 295/657] AppliedTypes returned by baseType shouldn't have type
 lambdas as constructors

In tests/pos/argDenot-alpakka.min.scala, we want

    `(([O] =>> Foo[O, S]) @uV)[Int]`.baseType(`Foo`)

to return `Foo[Int]` rather than an applied type lambda, so that we can rely on
the invariant that the type arguments of the type returned by baseType(cls)
correspond to the type parameter of cls which `NamedType#argDenot` is implicitly
relying on.

This could be achieved by removing the initial if branch from the AppliedType
case in baseTypeOf, since the recursive fallback will always work, but it makes
sense to keep a special case for performance, so we just explicitly add as a
condition to the fast-path that the type constructor of the AppliedType can't be
a lambda.
---
 .../tools/dotc/core/SymDenotations.scala      |  5 ++---
 tests/pos/argDenot-alpakka.min.scala          |  9 ++++++++
 tests/pos/argDenot-alpakka.scala              | 21 +++++++++++++++++++
 3 files changed, 32 insertions(+), 3 deletions(-)
 create mode 100644 tests/pos/argDenot-alpakka.min.scala
 create mode 100644 tests/pos/argDenot-alpakka.scala

diff --git a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
index 0f94d52f5be9..beeaa2ee922e 100644
--- a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -2226,13 +2226,12 @@ object SymDenotations {
             def computeApplied = {
               btrCache(tp) = NoPrefix
               val baseTp =
-                if (tycon.typeSymbol eq symbol) tp
-                else (tycon.typeParams: @unchecked) match {
+                if (tycon.typeSymbol eq symbol) && !tycon.isLambdaSub then 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
             }
diff --git a/tests/pos/argDenot-alpakka.min.scala b/tests/pos/argDenot-alpakka.min.scala
new file mode 100644
index 000000000000..0e509be59cfd
--- /dev/null
+++ b/tests/pos/argDenot-alpakka.min.scala
@@ -0,0 +1,9 @@
+import scala.annotation.unchecked.uncheckedVariance as uV
+
+trait Test:
+  def test[S] =
+    val a: (([O] =>> Foo[O, S]) @uV)[Int] = ???
+    a.m()
+
+class Foo[X, Y]:
+  def m(): Y = ???
diff --git a/tests/pos/argDenot-alpakka.scala b/tests/pos/argDenot-alpakka.scala
new file mode 100644
index 000000000000..41d6ad52ac97
--- /dev/null
+++ b/tests/pos/argDenot-alpakka.scala
@@ -0,0 +1,21 @@
+import scala.annotation.unchecked.uncheckedVariance as uV
+
+trait Test:
+  def split[I, M](in: Flow[I, Byte, M]): SubFlow[Byte, M, in.Repr]
+  def test =
+    split(new Flow[Int, Byte, Unit])
+      .via[Char]
+      .merge
+      .filter()
+
+trait FlowOps[+Out, +Mat]:
+  type Repr[+O] <: FlowOps[O, Mat] { type Repr[+O] = FlowOps.this.Repr[O] }
+  def via[O]:   Repr[O]   = ???
+  def filter(): Repr[Out] = ???
+
+class Flow[-In, +Out, +Mat] extends FlowOps[Out, Mat]:
+  type Repr[+O] = Flow[In @uV, O, Mat @uV]
+
+class SubFlow[+Out, +Mat, +F[+_]] extends FlowOps[Out, Mat]:
+  type Repr[+O] = SubFlow[O, Mat @uV, F @uV]
+  def merge: F[Out] = ???

From 22b4a549e086723f86d52649b893f9613cb2f50e Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Fri, 17 Mar 2023 13:35:45 +0100
Subject: [PATCH 296/657] Fix documentation of HOLE in TastyFormat

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

diff --git a/tasty/src/dotty/tools/tasty/TastyFormat.scala b/tasty/src/dotty/tools/tasty/TastyFormat.scala
index 23b74ed1d7c7..226fc14acb39 100644
--- a/tasty/src/dotty/tools/tasty/TastyFormat.scala
+++ b/tasty/src/dotty/tools/tasty/TastyFormat.scala
@@ -122,7 +122,8 @@ Standard-Section: "ASTs" TopLevelStat*
                   MATCHtpt       Length bound_Term? sel_Term CaseDef*              -- sel match { CaseDef } where `bound` is optional upper bound of all rhs
                   BYNAMEtpt             underlying_Term                            -- => underlying
                   SHAREDterm            term_ASTRef                                -- Link to previously serialized term
-                  HOLE           Length idx_Nat arg_Tree*                          -- Hole where a splice goes with sequence number idx, splice is applied to arguments `arg`s
+                  HOLE           Length idx_Nat tpe_Type arg_Tree*                 -- Splice hole with index `idx`, the type of the hole `tpe`, type and term arguments of the hole `arg`s
+
 
   CaseDef       = CASEDEF        Length pat_Term rhs_Tree guard_Tree?              -- case pat if guard => rhs
   ImplicitArg   = IMPLICITARG           arg_Term                                   -- implicit unapply argument

From b223c20e358dacf47bbf63857aafac935c26d275 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Fri, 17 Mar 2023 13:50:39 +0100
Subject: [PATCH 297/657] Improve implicit parameter error message with aliases

Fixes #17122
---
 compiler/src/dotty/tools/dotc/typer/Implicits.scala | 2 +-
 tests/neg/i17122.check                              | 5 +++++
 tests/neg/i17122.scala                              | 7 +++++++
 3 files changed, 13 insertions(+), 1 deletion(-)
 create mode 100644 tests/neg/i17122.check
 create mode 100644 tests/neg/i17122.scala

diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
index c37da9fcf701..a9631ad45e28 100644
--- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -969,7 +969,7 @@ trait Implicits:
       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")
+        def addendum = if (qt1 eq qt) "" else (i"\nWhere $qt is an alias of: $qt1")
         i"parameter of ${qual.tpe.widen}$addendum"
       case _ =>
         i"${ if paramName.is(EvidenceParamName) then "an implicit parameter"
diff --git a/tests/neg/i17122.check b/tests/neg/i17122.check
new file mode 100644
index 000000000000..683908c5af0f
--- /dev/null
+++ b/tests/neg/i17122.check
@@ -0,0 +1,5 @@
+-- [E172] Type Error: tests/neg/i17122.scala:7:14 ----------------------------------------------------------------------
+7 |def test = m() // error
+  |              ^
+  |              No given instance of type A was found for parameter of C
+  |              Where C is an alias of: (A) ?=> B
diff --git a/tests/neg/i17122.scala b/tests/neg/i17122.scala
new file mode 100644
index 000000000000..fcf9af106488
--- /dev/null
+++ b/tests/neg/i17122.scala
@@ -0,0 +1,7 @@
+case class A()
+case class B()
+
+type C = A ?=> B
+def m(): C = ???
+
+def test = m() // error

From 44fa111a3a7067d63674c0c0a80e83473dceee9c Mon Sep 17 00:00:00 2001
From: Anatolii Kmetiuk <anatoliykmetyuk@gmail.com>
Date: Fri, 17 Mar 2023 14:59:39 +0100
Subject: [PATCH 298/657] Check the status of coursier download in
 CoursierScalaTests.scala

This should provide more insight on why #17119 happens.
---
 .../tools/coursier/CoursierScalaTests.scala    | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/compiler/test-coursier/dotty/tools/coursier/CoursierScalaTests.scala b/compiler/test-coursier/dotty/tools/coursier/CoursierScalaTests.scala
index 979fea0684b2..944bf1957d43 100644
--- a/compiler/test-coursier/dotty/tools/coursier/CoursierScalaTests.scala
+++ b/compiler/test-coursier/dotty/tools/coursier/CoursierScalaTests.scala
@@ -148,11 +148,11 @@ class CoursierScalaTests:
 
 object CoursierScalaTests:
 
-  def execCmd(command: String, options: String*): List[String] =
+  def execCmd(command: String, options: String*): (Int, List[String]) =
     val cmd = (command :: options.toList).toSeq.mkString(" ")
     val out = new ListBuffer[String]
-    cmd.!(ProcessLogger(out += _, out += _))
-    out.toList
+    val code = cmd.!(ProcessLogger(out += _, out += _))
+    (code, out.toList)
 
   def csScalaCmd(options: String*): List[String] =
     csCmd("dotty.tools.MainGenericRunner", options*)
@@ -166,10 +166,16 @@ object CoursierScalaTests:
       case Nil => args
       case _ => "--" +: args
     val newJOpts = jOpts.map(s => s"--java-opt ${s.stripPrefix("-J")}").mkString(" ")
-    execCmd("./cs", (s"""launch "org.scala-lang:scala3-compiler_3:${sys.env("DOTTY_BOOTSTRAPPED_VERSION")}" $newJOpts --main-class "$entry" --property "scala.usejavacp=true"""" +: newOptions)*)
+    execCmd("./cs", (s"""launch "org.scala-lang:scala3-compiler_3:${sys.env("DOTTY_BOOTSTRAPPED_VERSION")}" $newJOpts --main-class "$entry" --property "scala.usejavacp=true"""" +: newOptions)*)._2
 
   /** Get coursier script */
   @BeforeClass def setup(): Unit =
-    val ver = execCmd("uname").head.replace('L', 'l').replace('D', 'd')
-    execCmd("curl", s"-fLo cs https://git.io/coursier-cli-$ver") #&& execCmd("chmod", "+x cs")
+    val ver = execCmd("uname")._2.head.replace('L', 'l').replace('D', 'd')
 
+    def runAndCheckCmd(cmd: String, options: String*): Unit =
+      val (code, out) = execCmd(cmd, options*)
+      if code != 0 then
+        fail(s"Failed to run $cmd ${options.mkString(" ")}, exit code: $code, output: ${out.mkString("\n")}")
+
+    runAndCheckCmd("curl", s"-fLo cs https://git.io/coursier-cli-$ver")
+    runAndCheckCmd("chmod", "+x cs")

From 00790452c5217b36aaa42b2885abd9652befbea0 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Fri, 17 Mar 2023 15:07:27 +0100
Subject: [PATCH 299/657] =?UTF-8?q?Avoid=20timeouts=20in=20community?=
 =?UTF-8?q?=E2=80=93build-C?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Increased timeout due to timeouts when running on dotty community build
---
 community-build/community-projects/requests-scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/community-build/community-projects/requests-scala b/community-build/community-projects/requests-scala
index 6d4a223bc33d..2d7316a8f444 160000
--- a/community-build/community-projects/requests-scala
+++ b/community-build/community-projects/requests-scala
@@ -1 +1 @@
-Subproject commit 6d4a223bc33def14ae9a4def24a3f5c258451e8e
+Subproject commit 2d7316a8f444c2f38795e5905f90837e651c79c3

From 1dc02d154cc9169d2743889e994f0fb075b37ac8 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Fri, 17 Mar 2023 15:22:06 +0100
Subject: [PATCH 300/657] Apply suggestions from code review

Co-authored-by: anna herlihy <herlihyap@gmail.com>
---
 .../reference/metaprogramming/macros-spec.md     | 16 ++++++++--------
 docs/_docs/reference/metaprogramming/macros.md   |  6 +++---
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/docs/_docs/reference/metaprogramming/macros-spec.md b/docs/_docs/reference/metaprogramming/macros-spec.md
index 6045354fdbbc..35a1b4b3d43a 100644
--- a/docs/_docs/reference/metaprogramming/macros-spec.md
+++ b/docs/_docs/reference/metaprogramming/macros-spec.md
@@ -24,7 +24,7 @@ ${ hello('name) }         ${ hello('{name}) }
 
 ### Quotes
 Quotes come in four flavors: quoted identifiers, quoted blocks, quoted block patterns and quoted type patterns.
-Scala 2 used quoted identifiers to represent `Symbol` literals. They were deprecated in Scala 3, allowing to use them for quotation.
+Scala 2 used quoted identifiers to represent `Symbol` literals. They were deprecated in Scala 3, allowing the syntax to be used for quotation.
 ```scala
 SimpleExpr ::= ...
              |  `'` alphaid                           // quoted identifier
@@ -42,7 +42,7 @@ Lastly, the quoted type pattern simply contains a type.
 ### Splices
 Splices come in three flavors: spliced identifiers, spliced blocks and splice patterns.
 Scala specifies identifiers containing `$` as valid identifiers but reserves them for compiler and standard library use only.
-Unfortunately, many libraries have used such identifiers in Scala~2. Therefore to mitigate the cost of migration, we still support them.
+Unfortunately, many libraries have used such identifiers in Scala 2. Therefore to mitigate the cost of migration, we still support them.
 We work around this by only allowing spliced identifiers[^3] within quoted blocks or quoted block patterns (`inQuoteBlock`).
 Splice blocks and splice patterns can contain an arbitrary block or pattern respectively.
 They are distinguished based on their surrounding quote (`inQuotePattern`), a quote block will contain spliced blocks, and a quote block pattern will contain splice patterns.
@@ -208,7 +208,7 @@ import scala.quoted.staging.*
 given Compiler = Compiler.make(getClass.getClassLoader)
 ```
 
-The classloader is needed for the compiler to know which dependencies have been loaded and to load the generated code using the same classloader.
+The classloader is needed for the compiler to know which dependencies have been loaded and to load the generated code using the same classloader. Below is an example method `mkPower2` that is passed to `staging.run`:
 
 ```scala
 def mkPower2()(using Quotes): Expr[Double => Double] = ...
@@ -229,7 +229,7 @@ To do this, the resulting `RunInstance` class is loaded in the JVM using Java Re
 
 Quotes and splices are primitive forms in the generated typed abstract syntax trees.
 These need to be type-checked with some extra rules, e.g., staging levels need to be checked and the references to generic types need to be adapted.
-Finally, quoted expressions that will be generated at run-time need to be encoded (serialized) and decoded (deserialized).
+Finally, quoted expressions that will be generated at run-time need to be encoded (serialized/pickled) and decoded (deserialized/unpickled).
 
 #### Typing Quoted Expressions
 
@@ -473,7 +473,7 @@ In general, the splice normal form has the shape `${ <lambda>.apply(<args>*) }`
 
 ##### Function references normalization
 A reference to a function `f` that receives parameters is not a valid value in Scala.
-Such a function reference `f` can be eta-expaned as `x => f(x)` to be used as a lambda value.
+Such a function reference `f` can be eta-expanded as `x => f(x)` to be used as a lambda value.
 Therefore function references cannot be transformed by the normalization as directly as other expressions as we cannot represent `'{f}` with a method reference type.
 We can use the eta-expanded form of `f` in the normalized form.
 For example, consider the reference to `f` below.
@@ -626,7 +626,7 @@ With these transformations, the contents of the quote or `Type.of` are guarantee
 The AST is pickled into TASTy, which is a sequence of bytes.
 This sequence of bytes needs to be instantiated in the bytecode, but unfortunately it cannot be dumped into the classfile as bytes.
 To reify it we encode the bytes into a Java `String`.
-In the following examples we display this encoding in human readable form with the fictitious |tasty"..."| string literal.
+In the following examples we display this encoding in human readable form with the fictitious `|tasty"..."|` string literal.
 
 ```scala
 // pickled AST bytes encoded in a base64 string
@@ -697,8 +697,8 @@ As the type holes are at the start of the quote, they will have the first `N` in
 This implies that we can place the references in a sequence `Seq(t, u, ...)` where the index in the sequence is the same as the hole index.
 
 Lastly, the quote itself is replaced by a call to `QuoteUnpickler.unpickleExpr` which will unpickle the AST, evaluate the holes, i.e., splices, and wrap the resulting AST in an `Expr[Int]`.
-This method takes takes the pickled |tasty"..."|, the types and the hole lambda.
-Similarly, `Type.of` is replaced with a call to `QuoteUnpickler.unpickleType` but only receives the pickled |tasty"..."| and the types.
+This method takes takes the pickled `|tasty"..."|`, the types and the hole lambda.
+Similarly, `Type.of` is replaced with a call to `QuoteUnpickler.unpickleType` but only receives the pickled `|tasty"..."|` and the types.
 Because `QuoteUnpickler` is part of the self-type of the `Quotes` class, we have to cast the instance but know that this cast will always succeed.
 
 ```scala
diff --git a/docs/_docs/reference/metaprogramming/macros.md b/docs/_docs/reference/metaprogramming/macros.md
index 1233d0007bc5..a91e69d985f0 100644
--- a/docs/_docs/reference/metaprogramming/macros.md
+++ b/docs/_docs/reference/metaprogramming/macros.md
@@ -254,10 +254,10 @@ Therefore, while evaluating the quote, it is not possible to accidentally rebind
 #### Well-typed
 If a quote is well typed, then the generated code is well typed.
 This is a simple consequence of tracking the type of each expression.
-An `Expr[T]` can only be created from a quote that contains an expression of type `T.
+An `Expr[T]` can only be created from a quote that contains an expression of type `T`.
 Conversely, an `Expr[T]` can only be spliced in a location that expects a type `T.
 As mentioned before, `Expr` is covariant in its type parameter.
-This means that an `Expr[T]` can contain an expression of a subtype of `T.
+This means that an `Expr[T]` can contain an expression of a subtype of `T`.
 When spliced in a location that expects a type `T, these expressions also have a valid type.
 
 ### Cross-Stage Safety
@@ -495,7 +495,7 @@ At run-time, when the pattern matches, the type of `t` and `u` will be known, an
 
 As `Expr` is covariant, the statically known type of the expression might not be the actual type.
 Type variables can also be used to recover the precise type of the expression.
-``scala
+```scala
 def let(x: Expr[Any])(using Quotes): Expr[Any] =
   x match
     case '{ $x: t } =>

From a8e150fad8d93f8703dd00ff8157735e7844b43d Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Fri, 17 Mar 2023 16:24:21 +0100
Subject: [PATCH 301/657] Scaladoc: fix inkuire generation for PolyTypes

---
 .../src/dotty/tools/scaladoc/tasty/InkuireSupport.scala   | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/InkuireSupport.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/InkuireSupport.scala
index 0cdb3535c3ff..8a703cfb5d24 100644
--- a/scaladoc/src/dotty/tools/scaladoc/tasty/InkuireSupport.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/tasty/InkuireSupport.scala
@@ -317,6 +317,8 @@ trait InkuireSupport(using DocContext) extends Resources:
         inner(tpe, vars)
       case tl @ TypeLambda(paramNames, _, resType) =>
         Inkuire.TypeLambda(paramNames.map(Inkuire.TypeLambda.argument), inner(resType, vars)) //TODO [Inkuire] Type bounds
+      case pt @ PolyType(paramNames, _, resType) =>
+        Inkuire.TypeLambda(paramNames.map(Inkuire.TypeLambda.argument), inner(resType, vars)) //TODO [Inkuire] Type bounds
       case r: Refinement =>
         inner(r.info, vars) //TODO [Inkuire] Refinements
       case t @ AppliedType(tpe, typeList) =>
@@ -357,10 +359,8 @@ trait InkuireSupport(using DocContext) extends Resources:
         Inkuire.Type.unresolved //TODO [Inkuire] <- should be handled by Singleton case, but didn't work
       case MatchType(bond, sc, cases) =>
         inner(sc, vars)
-      case ParamRef(TypeLambda(names, _, _), i) =>
-        Inkuire.TypeLambda.argument(names(i))
-      case ParamRef(m: MethodType, i) =>
-        inner(m.paramTypes(i), vars)
+      case ParamRef(binder: LambdaType, i) =>
+        Inkuire.TypeLambda.argument(binder.paramNames(i))
       case RecursiveType(tp) =>
         inner(tp, vars)
       case m@MethodType(_, typeList, resType) =>

From c8efe69ac26d2767e638641bd633533200a1eb87 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sat, 18 Mar 2023 16:28:08 +0100
Subject: [PATCH 302/657] Align tests in TypeComparer and AsSeenFrom

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

diff --git a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
index 07a573e9169d..45ccf80198e2 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
@@ -284,13 +284,13 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
           given Context = ctx // optimization for performance
           val info2 = tp2.info
 
-          /** Does `tp2` have a singleton type or NoPrefix as a prefix?
+          /** Does `tp2` have a stable prefix or NoPrefix as a prefix?
            *  If that's not the case, following an alias via asSeenFrom could be lossy
            *  so we should not conclude `false` if comparing aliases fails.
            *  See pos/i17064.scala for a test case
            */
           def hasPrecisePrefix(tp: NamedType) =
-            tp.prefix.isSingleton || tp.prefix == NoPrefix
+            tp.prefix.isStable || tp.prefix == NoPrefix
 
           info2 match
             case info2: TypeAlias =>

From 10538994e3990c68e90c8bf3ec5270a304a3e0be Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 7 Mar 2023 13:23:26 +0100
Subject: [PATCH 303/657] Dealias quoted types when staging

This change improves the code generation of the contents of splices. In
the splicing phase, we have to find all types that are defined in the
quote but used in the splice. When there are type aliases, we can end up
with several `Type[T]` for the different aliases of `T`. By dealiasing
during the staging phase (just before splicing phase) we make sure that
the splicer phase will only generate one `Type[T]`.

By dealiasing we also optimize some situations where a type from outside
a quote is inserted in the quoted code and then used in one of its
splice through an alias. In this situation we can use the outer
`Type[T]` directly.
---
 .../tools/dotc/staging/CrossStageSafety.scala | 27 +++++++++++---
 .../dotty/tools/dotc/staging/HealType.scala   | 18 ++++-----
 tests/pos-macros/i8100b.scala                 | 37 +++++++++++++++++++
 tests/run-macros/i12392.check                 |  2 +-
 tests/run-staging/quote-nested-3.check        |  4 +-
 tests/run-staging/quote-nested-4.check        |  4 +-
 tests/run-staging/quote-nested-6.check        |  4 +-
 tests/run-staging/quote-owners-2.check        |  2 +-
 .../run-staging/quote-unrolled-foreach.check  |  8 ++--
 tests/run-staging/shonan-hmm-simple.check     |  6 +--
 tests/run-staging/shonan-hmm.check            | 24 ++++++------
 11 files changed, 95 insertions(+), 41 deletions(-)
 create mode 100644 tests/pos-macros/i8100b.scala

diff --git a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
index 219b428ca8d4..16df5708993e 100644
--- a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
+++ b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
@@ -122,12 +122,29 @@ class CrossStageSafety extends TreeMapWithStages {
       val targs2 = targs.map(targ => TypeTree(healType(quote.fun.srcPos)(stripAnnotsDeep(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)
+      object DirectTypeOfRef:
+        def unapply(body: Tree): Option[Tree] =
+          body.tpe match
+            case tp @ TypeRef(x: TermRef, _) if tp.symbol == defn.QuotedType_splice =>
+              // Optimization: `quoted.Type.of[x.Underlying](quotes)`  -->  `x`
+              Some(ref(x).withSpan(quote.span))
+            case _ =>
+              body2 match
+                case Block(List(tdef: TypeDef), tpt: TypeTree) =>
+                  tpt.tpe match
+                    case tpe: TypeRef if tpe.typeSymbol == tdef.symbol =>
+                      tdef.rhs.tpe.hiBound match
+                        case tp @ TypeRef(x: TermRef, _) if tp.symbol == defn.QuotedType_splice =>
+                          // Optimization: `quoted.Type.of[@SplicedType type T = x.Underlying; T](quotes)`  -->  `x`
+                          Some(ref(x).withSpan(quote.span))
+                        case _ => None
+                    case _ => None
+                case _ => None
+
+      body match
+        case DirectTypeOfRef(ref) => ref
         case _ =>
+          val quotes = quote.args.mapConserve(transform)
           // `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)
diff --git a/compiler/src/dotty/tools/dotc/staging/HealType.scala b/compiler/src/dotty/tools/dotc/staging/HealType.scala
index 22008f381c32..7907c2e47542 100644
--- a/compiler/src/dotty/tools/dotc/staging/HealType.scala
+++ b/compiler/src/dotty/tools/dotc/staging/HealType.scala
@@ -32,7 +32,12 @@ class HealType(pos: SrcPos)(using Context) extends TypeMap {
   def apply(tp: Type): Type =
     tp match
       case tp: TypeRef =>
-        healTypeRef(tp)
+        tp.underlying match
+          case TypeAlias(alias)
+          if !tp.symbol.isTypeSplice && !tp.typeSymbol.hasAnnotation(defn.QuotedRuntime_SplicedTypeAnnot) =>
+            this.apply(alias)
+          case _ =>
+            healTypeRef(tp)
       case tp @ TermRef(NoPrefix, _) if !tp.symbol.isStatic && level > levelOf(tp.symbol) =>
         levelError(tp.symbol, tp, pos)
       case tp: AnnotatedType =>
@@ -46,11 +51,11 @@ class HealType(pos: SrcPos)(using Context) extends TypeMap {
         checkNotWildcardSplice(tp)
         if level == 0 then tp else getQuoteTypeTags.getTagRef(prefix)
       case prefix: TermRef if !prefix.symbol.isStatic && level > levelOf(prefix.symbol) =>
-        dealiasAndTryHeal(prefix.symbol, tp, pos)
+        tryHeal(prefix.symbol, tp, pos)
       case NoPrefix if level > levelOf(tp.symbol) && !tp.typeSymbol.hasAnnotation(defn.QuotedRuntime_SplicedTypeAnnot) =>
-        dealiasAndTryHeal(tp.symbol, tp, pos)
+        tryHeal(tp.symbol, tp, pos)
       case prefix: ThisType if level > levelOf(prefix.cls) && !tp.symbol.isStatic =>
-        dealiasAndTryHeal(tp.symbol, tp, pos)
+        tryHeal(tp.symbol, tp, pos)
       case _ =>
         mapOver(tp)
 
@@ -59,11 +64,6 @@ class HealType(pos: SrcPos)(using Context) extends TypeMap {
       case (tb: TypeBounds) :: _ => report.error(em"Cannot splice $splice because it is a wildcard type", pos)
       case _ =>
 
-  private def dealiasAndTryHeal(sym: Symbol, tp: TypeRef, pos: SrcPos): Type =
-    val tp1 = tp.dealias
-    if tp1 != tp then apply(tp1)
-    else tryHeal(tp.symbol, tp, pos)
-
   /** 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]]}`.
diff --git a/tests/pos-macros/i8100b.scala b/tests/pos-macros/i8100b.scala
new file mode 100644
index 000000000000..ecba10e439d2
--- /dev/null
+++ b/tests/pos-macros/i8100b.scala
@@ -0,0 +1,37 @@
+import scala.quoted.*
+
+def f[T](using t: Type[T])(using Quotes) =
+  '{
+    // @SplicedType type t$1 = t.Underlying
+    type T2 = T // type T2 = t$1
+    ${
+
+      val t0: T = ???
+      val t1: T2 = ??? //  val t1: T = ???
+      val tp1 = Type.of[T] // val tp1 = t
+      val tp2 = Type.of[T2] //  val tp2 = t
+      '{
+        // @SplicedType type t$2 = t.Underlying
+        val t3: T = ??? // val t3: t$2 = ???
+        val t4: T2 = ???  // val t4: t$2 = ???
+      }
+    }
+  }
+
+def g(using Quotes) =
+  '{
+    type U
+    type U2 = U
+    ${
+
+      val u1: U = ???
+      val u2: U2 = ??? //  val u2: U = ???
+
+      val tp1 = Type.of[U] // val tp1 = Type.of[U]
+      val tp2 = Type.of[U2]  // val tp2 = Type.of[U]
+      '{
+        val u3: U = ???
+        val u4: U2 = ??? // val u4: U = ???
+      }
+    }
+  }
diff --git a/tests/run-macros/i12392.check b/tests/run-macros/i12392.check
index 54c7f5d06c3f..92bbfa65fb49 100644
--- a/tests/run-macros/i12392.check
+++ b/tests/run-macros/i12392.check
@@ -1 +1 @@
-scala.Option[scala.Predef.String] to scala.Option[scala.Int]
+scala.Option[java.lang.String] to scala.Option[scala.Int]
diff --git a/tests/run-staging/quote-nested-3.check b/tests/run-staging/quote-nested-3.check
index 63bdda5c6c4c..c3dfba2d8abe 100644
--- a/tests/run-staging/quote-nested-3.check
+++ b/tests/run-staging/quote-nested-3.check
@@ -1,7 +1,7 @@
 {
-  type T = scala.Predef.String
+  type T = java.lang.String
   val x: java.lang.String = "foo"
-  val z: T = x
+  val z: java.lang.String = x
 
   (x: java.lang.String)
 }
diff --git a/tests/run-staging/quote-nested-4.check b/tests/run-staging/quote-nested-4.check
index 895bd0ddc914..d31b6394dccd 100644
--- a/tests/run-staging/quote-nested-4.check
+++ b/tests/run-staging/quote-nested-4.check
@@ -1,5 +1,5 @@
 ((q: scala.quoted.Quotes) ?=> {
-  val t: scala.quoted.Type[scala.Predef.String] = scala.quoted.Type.of[scala.Predef.String](q)
+  val t: scala.quoted.Type[java.lang.String] = scala.quoted.Type.of[java.lang.String](q)
 
-  (t: scala.quoted.Type[scala.Predef.String])
+  (t: scala.quoted.Type[java.lang.String])
 })
diff --git a/tests/run-staging/quote-nested-6.check b/tests/run-staging/quote-nested-6.check
index 05c2bd4eb00c..2ae8b0d26e47 100644
--- a/tests/run-staging/quote-nested-6.check
+++ b/tests/run-staging/quote-nested-6.check
@@ -1,7 +1,7 @@
 {
-  type T[X] = scala.List[X]
+  type T[X] = [A >: scala.Nothing <: scala.Any] => scala.collection.immutable.List[A][X]
   val x: java.lang.String = "foo"
-  val z: T[scala.Predef.String] = scala.List.apply[java.lang.String](x)
+  val z: [X >: scala.Nothing <: scala.Any] => scala.collection.immutable.List[X][java.lang.String] = scala.List.apply[java.lang.String](x)
 
   (x: java.lang.String)
 }
diff --git a/tests/run-staging/quote-owners-2.check b/tests/run-staging/quote-owners-2.check
index 323ce64b7bc7..49c09271779c 100644
--- a/tests/run-staging/quote-owners-2.check
+++ b/tests/run-staging/quote-owners-2.check
@@ -2,7 +2,7 @@
   def ff: scala.Int = {
     val a: scala.collection.immutable.List[scala.Int] = {
       type T = scala.collection.immutable.List[scala.Int]
-      val b: T = scala.Nil.::[scala.Int](3)
+      val b: scala.collection.immutable.List[scala.Int] = scala.Nil.::[scala.Int](3)
 
       (b: scala.collection.immutable.List[scala.Int])
     }
diff --git a/tests/run-staging/quote-unrolled-foreach.check b/tests/run-staging/quote-unrolled-foreach.check
index 8e58ab8eed51..3a72cd1b1311 100644
--- a/tests/run-staging/quote-unrolled-foreach.check
+++ b/tests/run-staging/quote-unrolled-foreach.check
@@ -8,7 +8,7 @@
   }
 })
 
-((arr: scala.Array[scala.Predef.String], f: scala.Function1[scala.Predef.String, scala.Unit]) => {
+((arr: scala.Array[java.lang.String], f: scala.Function1[java.lang.String, scala.Unit]) => {
   val size: scala.Int = arr.length
   var i: scala.Int = 0
   while (i.<(size)) {
@@ -18,7 +18,7 @@
   }
 })
 
-((arr: scala.Array[scala.Predef.String], f: scala.Function1[scala.Predef.String, scala.Unit]) => {
+((arr: scala.Array[java.lang.String], f: scala.Function1[java.lang.String, scala.Unit]) => {
   val size: scala.Int = arr.length
   var i: scala.Int = 0
   while (i.<(size)) {
@@ -41,7 +41,7 @@
 ((arr: scala.Array[scala.Int], f: scala.Function1[scala.Int, scala.Unit]) => {
   val size: scala.Int = arr.length
   var i: scala.Int = 0
-  if (size.%(3).!=(0)) throw new scala.Exception("...") else ()
+  if (size.%(3).!=(0)) throw new java.lang.Exception("...") else ()
   while (i.<(size)) {
     f.apply(arr.apply(i))
     f.apply(arr.apply(i.+(1)))
@@ -53,7 +53,7 @@
 ((arr: scala.Array[scala.Int], f: scala.Function1[scala.Int, scala.Unit]) => {
   val size: scala.Int = arr.length
   var i: scala.Int = 0
-  if (size.%(4).!=(0)) throw new scala.Exception("...") else ()
+  if (size.%(4).!=(0)) throw new java.lang.Exception("...") else ()
   while (i.<(size)) {
     f.apply(arr.apply(i.+(0)))
     f.apply(arr.apply(i.+(1)))
diff --git a/tests/run-staging/shonan-hmm-simple.check b/tests/run-staging/shonan-hmm-simple.check
index da437646482d..cbef88812dcd 100644
--- a/tests/run-staging/shonan-hmm-simple.check
+++ b/tests/run-staging/shonan-hmm-simple.check
@@ -6,7 +6,7 @@ Complex(4,3)
 10
 
 ((arr1: scala.Array[scala.Int], arr2: scala.Array[scala.Int]) => {
-  if (arr1.length.!=(arr2.length)) throw new scala.Exception("...") else ()
+  if (arr1.length.!=(arr2.length)) throw new java.lang.Exception("...") else ()
   var sum: scala.Int = 0
   var i: scala.Int = 0
   while (i.<(scala.Predef.intArrayOps(arr1).size)) {
@@ -22,13 +22,13 @@ Complex(4,3)
 10
 
 ((arr: scala.Array[scala.Int]) => {
-  if (arr.length.!=(5)) throw new scala.Exception("...") else ()
+  if (arr.length.!=(5)) throw new java.lang.Exception("...") else ()
   arr.apply(0).+(arr.apply(2)).+(arr.apply(4))
 })
 10
 
 ((arr: scala.Array[Complex[scala.Int]]) => {
-  if (arr.length.!=(4)) throw new scala.Exception("...") else ()
+  if (arr.length.!=(4)) throw new java.lang.Exception("...") else ()
   Complex.apply[scala.Int](0.-(arr.apply(0).im).+(0.-(arr.apply(2).im)).+(arr.apply(3).re.*(2)), arr.apply(0).re.+(arr.apply(2).re).+(arr.apply(3).im.*(2)))
 })
 Complex(4,3)
diff --git a/tests/run-staging/shonan-hmm.check b/tests/run-staging/shonan-hmm.check
index fa5206904962..9cb77f850155 100644
--- a/tests/run-staging/shonan-hmm.check
+++ b/tests/run-staging/shonan-hmm.check
@@ -35,8 +35,8 @@ List(25, 30, 20, 43, 44)
 
 
 ((vout: scala.Array[scala.Int], a: scala.Array[scala.Array[scala.Int]], v: scala.Array[scala.Int]) => {
-  if (3.!=(vout.length)) throw new scala.IndexOutOfBoundsException("3") else ()
-  if (2.!=(v.length)) throw new scala.IndexOutOfBoundsException("2") else ()
+  if (3.!=(vout.length)) throw new java.lang.IndexOutOfBoundsException("3") else ()
+  if (2.!=(v.length)) throw new java.lang.IndexOutOfBoundsException("2") else ()
   vout.update(0, 0.+(v.apply(0).*(a.apply(0).apply(0))).+(v.apply(1).*(a.apply(0).apply(1))))
   vout.update(1, 0.+(v.apply(0).*(a.apply(1).apply(0))).+(v.apply(1).*(a.apply(1).apply(1))))
   vout.update(2, 0.+(v.apply(0).*(a.apply(2).apply(0))).+(v.apply(1).*(a.apply(2).apply(1))))
@@ -95,8 +95,8 @@ List(25, 30, 20, 43, 44)
     array
   }
   ((vout: scala.Array[scala.Int], v: scala.Array[scala.Int]) => {
-    if (5.!=(vout.length)) throw new scala.IndexOutOfBoundsException("5") else ()
-    if (5.!=(v.length)) throw new scala.IndexOutOfBoundsException("5") else ()
+    if (5.!=(vout.length)) throw new java.lang.IndexOutOfBoundsException("5") else ()
+    if (5.!=(v.length)) throw new java.lang.IndexOutOfBoundsException("5") else ()
     vout.update(0, 0.+(v.apply(0).*(5)).+(v.apply(1).*(0)).+(v.apply(2).*(0)).+(v.apply(3).*(5)).+(v.apply(4).*(0)))
     vout.update(1, 0.+(v.apply(0).*(0)).+(v.apply(1).*(0)).+(v.apply(2).*(10)).+(v.apply(3).*(0)).+(v.apply(4).*(0)))
     vout.update(2, 0.+(v.apply(0).*(0)).+(v.apply(1).*(10)).+(v.apply(2).*(0)).+(v.apply(3).*(0)).+(v.apply(4).*(0)))
@@ -158,8 +158,8 @@ List(25, 30, 20, 43, 44)
     array
   }
   ((vout: scala.Array[scala.Int], v: scala.Array[scala.Int]) => {
-    if (5.!=(vout.length)) throw new scala.IndexOutOfBoundsException("5") else ()
-    if (5.!=(v.length)) throw new scala.IndexOutOfBoundsException("5") else ()
+    if (5.!=(vout.length)) throw new java.lang.IndexOutOfBoundsException("5") else ()
+    if (5.!=(v.length)) throw new java.lang.IndexOutOfBoundsException("5") else ()
     vout.update(0, v.apply(0).*(5).+(v.apply(3).*(5)))
     vout.update(1, v.apply(2).*(10))
     vout.update(2, v.apply(1).*(10))
@@ -221,8 +221,8 @@ List(25, 30, 20, 43, 44)
     array
   }
   ((vout: scala.Array[scala.Int], v: scala.Array[scala.Int]) => {
-    if (5.!=(vout.length)) throw new scala.IndexOutOfBoundsException("5") else ()
-    if (5.!=(v.length)) throw new scala.IndexOutOfBoundsException("5") else ()
+    if (5.!=(vout.length)) throw new java.lang.IndexOutOfBoundsException("5") else ()
+    if (5.!=(v.length)) throw new java.lang.IndexOutOfBoundsException("5") else ()
     vout.update(0, v.apply(0).*(5).+(v.apply(3).*(5)))
     vout.update(1, v.apply(2).*(10))
     vout.update(2, v.apply(1).*(10))
@@ -243,8 +243,8 @@ List(25, 30, 20, 43, 44)
 
 
 ((vout: scala.Array[scala.Int], v: scala.Array[scala.Int]) => {
-  if (5.!=(vout.length)) throw new scala.IndexOutOfBoundsException("5") else ()
-  if (5.!=(v.length)) throw new scala.IndexOutOfBoundsException("5") else ()
+  if (5.!=(vout.length)) throw new java.lang.IndexOutOfBoundsException("5") else ()
+  if (5.!=(v.length)) throw new java.lang.IndexOutOfBoundsException("5") else ()
   vout.update(0, v.apply(0).*(5).+(v.apply(3).*(5)))
   vout.update(1, v.apply(2).*(10))
   vout.update(2, v.apply(1).*(10))
@@ -282,8 +282,8 @@ List(25, 30, 20, 43, 44)
     array
   }
   ((vout: scala.Array[scala.Int], v: scala.Array[scala.Int]) => {
-    if (5.!=(vout.length)) throw new scala.IndexOutOfBoundsException("5") else ()
-    if (5.!=(v.length)) throw new scala.IndexOutOfBoundsException("5") else ()
+    if (5.!=(vout.length)) throw new java.lang.IndexOutOfBoundsException("5") else ()
+    if (5.!=(v.length)) throw new java.lang.IndexOutOfBoundsException("5") else ()
     vout.update(0, v.apply(0).*(5).+(v.apply(3).*(5)))
     vout.update(1, v.apply(2).*(10))
     vout.update(2, v.apply(1).*(10))

From d479de60052056744b42d16266fffd12261ad9bb Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 7 Mar 2023 17:00:37 +0100
Subject: [PATCH 304/657] Avoid transforming the body in optimization case

---
 .../tools/dotc/staging/CrossStageSafety.scala | 56 ++++++++-----------
 .../tools/dotc/staging/DirectTypeOf.scala     | 25 +++++++++
 2 files changed, 48 insertions(+), 33 deletions(-)
 create mode 100644 compiler/src/dotty/tools/dotc/staging/DirectTypeOf.scala

diff --git a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
index 16df5708993e..98e060488f43 100644
--- a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
+++ b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
@@ -107,47 +107,37 @@ class CrossStageSafety extends TreeMapWithStages {
     val stripAnnotsDeep: TypeMap = new TypeMap:
       def apply(tp: Type): Type = mapOver(tp.stripAnnots)
 
-    val contextWithQuote =
-      if level == 0 then contextWithQuoteTypeTags(taggedTypes)(using quoteContext)
-      else quoteContext
-    val body1 = transform(body)(using contextWithQuote)
-    val body2 =
+    def transformBody() =
+      val contextWithQuote =
+        if level == 0 then contextWithQuoteTypeTags(taggedTypes)(using quoteContext)
+        else quoteContext
+      val transformedBody = transform(body)(using contextWithQuote)
       taggedTypes.getTypeTags match
-        case Nil  => body1
-        case tags => tpd.Block(tags, body1).withSpan(body.span)
+        case Nil  => transformedBody
+        case tags => tpd.Block(tags, transformedBody).withSpan(body.span)
 
     if body.isTerm then
+      val transformedBody = transformBody()
       // `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(healType(quote.fun.srcPos)(stripAnnotsDeep(targ.tpe))))
-      cpy.Apply(quote)(cpy.TypeApply(quote.fun)(fun, targs2), body2 :: Nil)
+      cpy.Apply(quote)(cpy.TypeApply(quote.fun)(fun, targs2), transformedBody :: Nil)
     else
-      object DirectTypeOfRef:
-        def unapply(body: Tree): Option[Tree] =
-          body.tpe match
-            case tp @ TypeRef(x: TermRef, _) if tp.symbol == defn.QuotedType_splice =>
-              // Optimization: `quoted.Type.of[x.Underlying](quotes)`  -->  `x`
-              Some(ref(x).withSpan(quote.span))
-            case _ =>
-              body2 match
-                case Block(List(tdef: TypeDef), tpt: TypeTree) =>
-                  tpt.tpe match
-                    case tpe: TypeRef if tpe.typeSymbol == tdef.symbol =>
-                      tdef.rhs.tpe.hiBound match
-                        case tp @ TypeRef(x: TermRef, _) if tp.symbol == defn.QuotedType_splice =>
-                          // Optimization: `quoted.Type.of[@SplicedType type T = x.Underlying; T](quotes)`  -->  `x`
-                          Some(ref(x).withSpan(quote.span))
-                        case _ => None
-                    case _ => None
-                case _ => None
-
-      body match
-        case DirectTypeOfRef(ref) => ref
+      body.tpe match
+        case DirectTypeOf(termRef) =>
+          // Optimization: `quoted.Type.of[x.Underlying](quotes)`  -->  `x`
+          ref(termRef).withSpan(quote.span)
         case _ =>
-          val quotes = quote.args.mapConserve(transform)
-          // `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)
+          transformBody() match
+            case DirectTypeOf.Healed(termRef) =>
+              // Optimization: `quoted.Type.of[@SplicedType type T = x.Underlying; T](quotes)`  -->  `x`
+              ref(termRef).withSpan(quote.span)
+            case transformedBody =>
+              val quotes = quote.args.mapConserve(transform)
+              // `quoted.Type.of[<body>](quotes)`  --> `quoted.Type.of[<body2>](quotes)`
+              val TypeApply(fun, _) = quote.fun: @unchecked
+              cpy.Apply(quote)(cpy.TypeApply(quote.fun)(fun, transformedBody :: Nil), quotes)
+
   }
 
   /** Transform splice
diff --git a/compiler/src/dotty/tools/dotc/staging/DirectTypeOf.scala b/compiler/src/dotty/tools/dotc/staging/DirectTypeOf.scala
new file mode 100644
index 000000000000..488d8ff2a88e
--- /dev/null
+++ b/compiler/src/dotty/tools/dotc/staging/DirectTypeOf.scala
@@ -0,0 +1,25 @@
+package dotty.tools.dotc.staging
+
+import dotty.tools.dotc.ast.{tpd, untpd}
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Types._
+
+object DirectTypeOf:
+  import tpd.*
+
+  /** Matches `x.Underlying` and extracts the TermRef to `x` */
+  def unapply(tpe: Type)(using Context): Option[TermRef] = tpe match
+    case tp @ TypeRef(x: TermRef, _) if tp.symbol == defn.QuotedType_splice => Some(x)
+    case _ => None
+
+  object Healed:
+    /** Matches `{ @SplicedType type T = x.Underlying; T }` and extracts the TermRef to `x` */
+    def unapply(body: Tree)(using Context): Option[TermRef] =
+      body match
+        case Block(List(tdef: TypeDef), tpt: TypeTree) =>
+          tpt.tpe match
+            case tpe: TypeRef if tpe.typeSymbol == tdef.symbol =>
+              DirectTypeOf.unapply(tdef.rhs.tpe.hiBound)
+            case _ => None
+        case _ => None

From f8fb548300850aebaece5c15a13632289a563c67 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Thu, 23 Mar 2023 10:55:28 +0100
Subject: [PATCH 305/657] Skip Java using run test when scalajs

---
 compiler/test/dotty/tools/vulpix/ParallelTesting.scala | 7 +++++--
 tests/run/i17021.ext-java/Test.scala                   | 1 +
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/compiler/test/dotty/tools/vulpix/ParallelTesting.scala b/compiler/test/dotty/tools/vulpix/ParallelTesting.scala
index 62b1b88984bc..3799a2335a78 100644
--- a/compiler/test/dotty/tools/vulpix/ParallelTesting.scala
+++ b/compiler/test/dotty/tools/vulpix/ParallelTesting.scala
@@ -751,8 +751,11 @@ trait ParallelTesting extends RunnerOrchestration { self =>
           case _ =>
         }
         case Failure(output) =>
-          echo(s"Test '${testSource.title}' failed with output:")
-          echo(output)
+          if output == "" then
+            echo(s"Test '${testSource.title}' failed with no output")
+          else
+            echo(s"Test '${testSource.title}' failed with output:")
+            echo(output)
           failTestSource(testSource)
         case Timeout =>
           echo("failed because test " + testSource.title + " timed out")
diff --git a/tests/run/i17021.ext-java/Test.scala b/tests/run/i17021.ext-java/Test.scala
index 3741fa2dfadb..2cca286c3801 100644
--- a/tests/run/i17021.ext-java/Test.scala
+++ b/tests/run/i17021.ext-java/Test.scala
@@ -1,3 +1,4 @@
+// scalajs: --skip
 // Derives from run/i17021.defs
 // but with a Java protected member
 // and fixed calling code, that uses super

From e96b422b06577b5838f961adc26b51e0a913512a Mon Sep 17 00:00:00 2001
From: Anatolii Kmetiuk <anatoliykmetyuk@gmail.com>
Date: Thu, 23 Mar 2023 11:31:28 +0100
Subject: [PATCH 306/657] Fix #17119: Download Coursier from GitHub directly

git.io is a URL shortener which, it seems, is unreliable.
---
 .../dotty/tools/coursier/CoursierScalaTests.scala         | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/compiler/test-coursier/dotty/tools/coursier/CoursierScalaTests.scala b/compiler/test-coursier/dotty/tools/coursier/CoursierScalaTests.scala
index 944bf1957d43..8f9a9bd69a50 100644
--- a/compiler/test-coursier/dotty/tools/coursier/CoursierScalaTests.scala
+++ b/compiler/test-coursier/dotty/tools/coursier/CoursierScalaTests.scala
@@ -170,12 +170,16 @@ object CoursierScalaTests:
 
   /** Get coursier script */
   @BeforeClass def setup(): Unit =
-    val ver = execCmd("uname")._2.head.replace('L', 'l').replace('D', 'd')
+    val launcherLocation = "https://github.com/coursier/launchers/raw/master"
+    val launcherName = execCmd("uname")._2.head.toLowerCase match
+      case "linux" => "cs-x86_64-pc-linux"
+      case "darwin" => "cs-x86_64-apple-darwin"
+      case other => fail(s"Unsupported OS for coursier launcher: $other")
 
     def runAndCheckCmd(cmd: String, options: String*): Unit =
       val (code, out) = execCmd(cmd, options*)
       if code != 0 then
         fail(s"Failed to run $cmd ${options.mkString(" ")}, exit code: $code, output: ${out.mkString("\n")}")
 
-    runAndCheckCmd("curl", s"-fLo cs https://git.io/coursier-cli-$ver")
+    runAndCheckCmd("curl", s"-fLo cs $launcherLocation/$launcherName")
     runAndCheckCmd("chmod", "+x cs")

From 36da313ddfc62d1356d2d1b8d37acf33cfad0794 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Thu, 23 Mar 2023 14:05:31 +0100
Subject: [PATCH 307/657] Add regression test for #15709

Closes #15709
---
 tests/pos-macros/i15709.scala | 4 ++++
 1 file changed, 4 insertions(+)
 create mode 100644 tests/pos-macros/i15709.scala

diff --git a/tests/pos-macros/i15709.scala b/tests/pos-macros/i15709.scala
new file mode 100644
index 000000000000..845ed35d1a55
--- /dev/null
+++ b/tests/pos-macros/i15709.scala
@@ -0,0 +1,4 @@
+import quoted.*
+
+inline def foo(s: Singleton): Unit = ${ fooImpl('s) }
+def fooImpl(s: Expr[Singleton])(using Quotes) = '{}

From 03a8f644c2b99073c2cca79e4d2c01539fa3391a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Pa=C5=82ka?= <prolativus@gmail.com>
Date: Wed, 22 Mar 2023 13:09:33 +0100
Subject: [PATCH 308/657] Improve subtyping check for not yet eta-expanded
 higher kinded types

---
 .../src/dotty/tools/dotc/core/TypeComparer.scala   |  2 +-
 tests/pos/i16183/Lib_1.scala                       | 14 ++++++++++++++
 tests/pos/i16183/Test_2.scala                      |  6 ++++++
 3 files changed, 21 insertions(+), 1 deletion(-)
 create mode 100644 tests/pos/i16183/Lib_1.scala
 create mode 100644 tests/pos/i16183/Test_2.scala

diff --git a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
index 9dda18c72f26..ac6a6b9481d8 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
@@ -580,7 +580,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
             val base = nonExprBaseType(tp1, cls2)
             if (base.typeSymbol == cls2) return true
           }
-          else if tp1.isLambdaSub && !tp1.isAnyKind then
+          else if tp1.typeParams.nonEmpty && !tp1.isAnyKind then
             return recur(tp1, EtaExpansion(tp2))
         fourthTry
     }
diff --git a/tests/pos/i16183/Lib_1.scala b/tests/pos/i16183/Lib_1.scala
new file mode 100644
index 000000000000..824af18e1d40
--- /dev/null
+++ b/tests/pos/i16183/Lib_1.scala
@@ -0,0 +1,14 @@
+package pkg
+
+trait Foo1[A]
+trait Foo2[A] extends Foo1[A]
+
+trait Bar[F[_]]
+object Bar {
+  implicit val bar: Bar[pkg.Foo2] = ???
+}
+
+trait Qux
+object Qux {
+  implicit def qux[F[_]](implicit bar: Bar[F]): F[Qux] = ???
+}
\ No newline at end of file
diff --git a/tests/pos/i16183/Test_2.scala b/tests/pos/i16183/Test_2.scala
new file mode 100644
index 000000000000..c8c5cbed838c
--- /dev/null
+++ b/tests/pos/i16183/Test_2.scala
@@ -0,0 +1,6 @@
+import pkg._
+
+object Test {
+  implicitly[Foo2[Qux]]
+  implicitly[Foo1[Qux]]
+}
\ No newline at end of file

From 1828c8a8a7d5b8827886bf63b3a791ff574c339a Mon Sep 17 00:00:00 2001
From: Lucas <leblanc.lucas29@gmail.com>
Date: Mon, 20 Mar 2023 15:31:07 +0100
Subject: [PATCH 309/657] Add tests for extensions's signatures

---
 project/Build.scala                           |  2 +-
 .../src/tests/extensionParams.scala           | 32 +++++++++++++------
 .../scaladoc/signatures/SignatureTest.scala   | 20 +++++++++---
 .../TranslatableSignaturesTestCases.scala     |  2 +-
 4 files changed, 41 insertions(+), 15 deletions(-)

diff --git a/project/Build.scala b/project/Build.scala
index 82b7fee64879..1ec68edbdc1b 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -361,7 +361,7 @@ 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
-    bspEnabled := false,
+    // bspEnabled := false,
     (Compile / unmanagedSourceDirectories) += baseDirectory.value / "src-bootstrapped",
 
     version := dottyVersion,
diff --git a/scaladoc-testcases/src/tests/extensionParams.scala b/scaladoc-testcases/src/tests/extensionParams.scala
index 9276bf41f067..950dc57dbe93 100644
--- a/scaladoc-testcases/src/tests/extensionParams.scala
+++ b/scaladoc-testcases/src/tests/extensionParams.scala
@@ -10,11 +10,11 @@ extension [A](a: A)(using Int)
   def f1[B](b: B): (A, B)
   = ???
 
-extension [A](a: A)(using Int)
+extension [A](a: A)(using String)
   def f2(b: A): (A, A)
   = ???
 
-extension [A](a: A)(using Int)
+extension [A](a: A)(using Number)
   def f3(using String)(b: A): (A, A)
   = ???
 
@@ -22,7 +22,7 @@ extension (a: Char)(using Int)
   def f4(using String)(b: Int): Unit
   = ???
 
-extension (a: Char)(using Int)
+extension (a: String)(using Int)
   def f5[B](using String)(b: B): Unit
   = ???
 
@@ -34,15 +34,15 @@ extension [A <: List[Char]](using String)(using Unit)(a: A)(using Int)(using Num
   def f7[B, C](b: B)(c: C): (A, B)
   = ???
 
-extension [A <: List[Char]](using String)(using Unit)(a: A)(using Int)(using Number)
+extension [A <: List[Char]](using String)(using Number)(a: A)(using Int)(using Unit)
   def f8(b: Any)(c: Any): Any
   = ???
 
-extension [A <: List[Char]](using String)(using Unit)(a: A)(using Int)(using Number)
+extension [A <: List[Char]](using Unit)(using String)(a: A)(using Int)(using Number)
   def f9[B, C](using Int)(b: B)(c: C): (A, B)
   = ???
 
-extension [A <: List[Char]](using String)(using Unit)(a: A)(using Int)(using Number)
+extension [A <: List[Char]](using Number)(using Unit)(a: A)(using Int)(using String)
   def f10(using Int)(b: Any)(c: Any): Any
    = ???
 
@@ -53,11 +53,25 @@ extension (using String)(using Unit)(a: Animal)(using Int)(using Number)
   def f11(b: Any)(c: Any): Any
   = ???
 
+extension (a: Int)
+  def f13(): Any
+  = ???
+
+extension (using Unit)(a: Int)
+  def f14(): Any
+  = ???
+
+extension (a: Int)(using Unit)
+  def f15(): Any
+  = ???
+
 import scala.language.experimental.clauseInterleaving
 
-extension (using String)(using Unit)(a: Animal)(using Int)(using Number)
-  def f13(b: Any)[T](c: T): T
+extension (using String)(using Int)(a: Animal)(using Unit)(using Number)
+  def f16(b: Any)[T](c: T): T
   = ???
-  def f14[D](b: D)[T](c: T): T
+  def f17[D](b: D)[T](c: T): T
   = ???
 
+
+
diff --git a/scaladoc/test/dotty/tools/scaladoc/signatures/SignatureTest.scala b/scaladoc/test/dotty/tools/scaladoc/signatures/SignatureTest.scala
index 4d8a9f46f21e..9c831d6a7349 100644
--- a/scaladoc/test/dotty/tools/scaladoc/signatures/SignatureTest.scala
+++ b/scaladoc/test/dotty/tools/scaladoc/signatures/SignatureTest.scala
@@ -82,11 +82,18 @@ abstract class SignatureTest(
     private def startWithAnyOfThese(c: String*) = c.exists(s.startsWith)
     private def compactWhitespaces = whitespaceRegex.replaceAllIn(s, " ")
 
+  private var counter = 0
   private def findName(signature: String, kinds: Seq[String]): Option[String] =
     for
-      kindMatch <- kinds.flatMap(k => s"\\b$k\\b".r.findFirstMatchIn(signature)).headOption
+      kindMatch <- kinds.flatMap(k =>s"\\b$k\\b".r.findFirstMatchIn(signature)).headOption
       afterKind <- Option(kindMatch.after(0)) // to filter out nulls
-      nameMatch <- identifierRegex.findFirstMatchIn(afterKind)
+      nameMatch <- identifierRegex.findFirstMatchIn(
+        if kindMatch.group(0).contains("extension")
+        then
+          signature
+        else
+          afterKind
+        )
     yield nameMatch.group(1)
 
   private def signaturesFromSources(source: Source, kinds: Seq[String]): Seq[SignatureRes] =
@@ -110,6 +117,11 @@ abstract class SignatureTest(
 
     def processFile(path: Path): Unit = if filterFunc(path) then
       val document = Jsoup.parse(IO.read(path))
+      val documentable = document.select(".groupHeader").forEach { element =>
+        val signature = element.select(".groupHeader").eachText.asScala.mkString("")
+        val all = s"$signature"
+        signatures += all
+      }
       val content = document.select(".documentableElement").forEach { elem =>
         val annotations = elem.select(".annotations").eachText.asScala.mkString("")
         val other = elem.select(".header .other-modifiers").eachText.asScala.mkString("")
@@ -122,13 +134,13 @@ abstract class SignatureTest(
         val all = s"$annotations$other $sigPrefix$signature".trim()
         signatures += all
       }
-
+    counter = 0
 
     IO.foreachFileIn(output, processFile)
     signatures.result
 
 object SignatureTest {
   val classlikeKinds = Seq("class",  "object", "trait", "enum") // TODO add docs for packages
-  val members = Seq("type", "def", "val", "var", "given")
+  val members = Seq("type", "def", "val", "var", "given", "extension")
   val all = classlikeKinds ++ members
 }
diff --git a/scaladoc/test/dotty/tools/scaladoc/signatures/TranslatableSignaturesTestCases.scala b/scaladoc/test/dotty/tools/scaladoc/signatures/TranslatableSignaturesTestCases.scala
index 49316b08dbc0..302ee39d6351 100644
--- a/scaladoc/test/dotty/tools/scaladoc/signatures/TranslatableSignaturesTestCases.scala
+++ b/scaladoc/test/dotty/tools/scaladoc/signatures/TranslatableSignaturesTestCases.scala
@@ -39,7 +39,7 @@ class PackageObjectSymbolSignatures extends SignatureTest("packageObjectSymbolSi
 class MergedPackageSignatures extends SignatureTest("mergedPackage", SignatureTest.all.filterNot(_ == "object"),
   sourceFiles = List("mergedPackage1", "mergedPackage2", "mergedPackage3"))
 
-class ExtensionMethodSignature extends SignatureTest("extensionMethodSignatures", SignatureTest.all)
+class ExtensionMethodSignature extends SignatureTest("extensionMethodSignatures", SignatureTest.all.filterNot(_ == "extension"))
 
 class ExtensionMethodParamsSignature extends SignatureTest("extensionParams", SignatureTest.all)
 

From 6a05f66064ee3cc426c6142abb4dd4658a6518b1 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Wed, 8 Mar 2023 13:54:34 +0100
Subject: [PATCH 310/657] Implement getScaladoc2Type without using tree show

Showing the tree or type does not return a reliable representation. The
only way to create this correctly is be creating a custom printer that
prints in the required format.
---
 .../tasty/Scaladoc2AnchorCreator.scala        | 70 +++++++++++++++++--
 .../dotty/tools/scaladoc/tasty/SymOps.scala   |  2 +-
 2 files changed, 64 insertions(+), 8 deletions(-)

diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/Scaladoc2AnchorCreator.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/Scaladoc2AnchorCreator.scala
index ba59f77495b1..3c34a1c9bba9 100644
--- a/scaladoc/src/dotty/tools/scaladoc/tasty/Scaladoc2AnchorCreator.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/tasty/Scaladoc2AnchorCreator.scala
@@ -7,10 +7,66 @@ import scala.util.matching.Regex
 
 object Scaladoc2AnchorCreator:
 
-  def getScaladoc2Type(using Quotes)(t: reflect.Tree) =
-    import reflect.*
-    val regex = t match
-      case d: DefDef =>  "def"
-      case t: TypeDef => "type"
-      case v: ValDef =>  "val|var"
-    t.show(using Printer.TreeShortCode).split(regex, 2)(1).replace(" ","")
+  def getScaladoc2Type(using Quotes)(sym: quotes.reflect.Symbol) = signatureAnchor(sym)
+
+  /** Creates the signature anchor
+   *
+   *  - `X` for a `type X ...`
+   *  - `x:X` for a `val x: X`
+   *  - `f[U1,...](x1:T1,...)(impliciti1:U1,impliciti2:U2,...)...:R` for a `def f[U1, ...](x1: T1, ...)(implicit i1: U1, i2: U2...)...: R`
+   *
+   *  Types are printed without their paths. No spaces are printed in the output.
+   */
+  private def signatureAnchor(using Quotes)(sym: quotes.reflect.Symbol): String =
+    import quotes.reflect.*
+    def signatureType(tp: quotes.reflect.TypeRepr): String =
+      tp match
+        case mt @ MethodType(paramNames, paramTypes, res) =>
+          val implicitPrefix = if mt.isImplicit then "implicit" else ""
+          val closeClause = res match
+            case _: MethodOrPoly => ")"
+            case _ => "):"
+          paramNames.zip(paramTypes.map(signatureType))
+            .map((name, tpe) => s"$implicitPrefix$name:$tpe")
+            .mkString("(", ",", closeClause) + signatureType(res)
+        case PolyType(paramNames, paramBounds, res) =>
+          val closeClause = res match
+            case _: MethodOrPoly => "]"
+            case _ => "]:"
+          paramNames.zip(paramBounds.map(signatureType))
+            .map((name, tpe) => s"$name$tpe")
+            .mkString("[", ",", closeClause) + signatureType(res)
+        case TypeLambda(paramNames, paramBounds, res) =>
+          paramNames.zip(paramBounds.map(signatureType))
+            .map((name, tpe) => s"$name$tpe")
+            .mkString("[", ",", "]") + "=>" + signatureType(res)
+        case ByNameType(tp) =>
+          ":" + signatureType(tp)
+        case TypeBounds(low, hi) =>
+          val lowBound = if low =:= defn.NothingClass.typeRef then "" else ">:" + signatureType(low)
+          val hiBound = if low =:= defn.AnyClass.typeRef then "" else "<:" + signatureType(hi)
+          lowBound + hiBound
+        case tp: ParamRef =>
+          tp.binder match
+            case binder: MethodType => binder.paramNames(tp.paramNum) + ".type"
+            case binder: PolyType => binder.paramNames(tp.paramNum)
+            case binder: LambdaType => binder.paramNames(tp.paramNum)
+        case AppliedType(tycon, args) =>
+          args.map {
+            case tp: TypeBounds => "_" + signatureType(tp)
+            case tp => signatureType(tp)
+          }.mkString(signatureType(tycon) + "[", ",", "]")
+        case tp: AnnotatedType =>
+          signatureType(tp.underlying) + "@" + tp.annotation.symbol.owner.name
+        case tp: ThisType =>
+          signatureType(tp.tref) + ".this"
+        case tp: TypeRef =>
+          tp.name
+        case tp =>
+          // TODO handle other cases without using show (show does not have a stable representation)
+          tp.show(using Printer.TypeReprShortCode).replace(" ","")
+
+    sym match
+      case sym if sym.isType => sym.name
+      case sym if sym.flags.is(Flags.Method) => sym.name + signatureType(sym.info)
+      case sym => sym.name + ":" + signatureType(sym.info)
diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/SymOps.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/SymOps.scala
index 584ef1f54267..5bc1b98a7fff 100644
--- a/scaladoc/src/dotty/tools/scaladoc/tasty/SymOps.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/tasty/SymOps.scala
@@ -235,7 +235,7 @@ class SymOpsWithLinkCache:
       def constructPathForScaladoc2: String =
         val l = escapeUrl(location.mkString("/"))
         val scaladoc2Anchor = if anchor.isDefined then {
-          "#" + getScaladoc2Type(sym.tree)
+          "#" + getScaladoc2Type(sym)
         } else ""
         docURL + l + extension + scaladoc2Anchor
 

From 1c2ceae379b62f298935cf280430ac7b01b50a78 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 6 Mar 2023 17:26:15 +0100
Subject: [PATCH 311/657] Fix type aliases in beta-reduction of polyfunctions

Fixes #17052
---
 .../tools/dotc/transform/BetaReduce.scala     |  2 +-
 .../tools/dotc/transform/TreeChecker.scala    |  5 ++++
 .../runtime/impl/printers/SourceCode.scala    | 28 +++++++++++--------
 tests/pos/i17052.scala                        |  2 ++
 4 files changed, 24 insertions(+), 13 deletions(-)
 create mode 100644 tests/pos/i17052.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala b/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala
index c586bb06cc29..b8cbb4367db4 100644
--- a/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala
+++ b/compiler/src/dotty/tools/dotc/transform/BetaReduce.scala
@@ -117,7 +117,7 @@ object BetaReduce:
           case ref @ TypeRef(NoPrefix, _) =>
             ref.symbol
           case _ =>
-            val binding = TypeDef(newSymbol(ctx.owner, tparam.name, EmptyFlags, targ.tpe, coord = targ.span)).withSpan(targ.span)
+            val binding = TypeDef(newSymbol(ctx.owner, tparam.name, EmptyFlags, TypeAlias(targ.tpe), coord = targ.span)).withSpan(targ.span)
             bindings += binding
             binding.symbol
 
diff --git a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
index 52942ea719f9..96d6da39a913 100644
--- a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
@@ -533,6 +533,11 @@ object TreeChecker {
         i"owner chain = ${tree.symbol.ownersIterator.toList}%, %, ctxOwners = ${ctx.outersIterator.map(_.owner).toList}%, %")
     }
 
+    override def typedTypeDef(tdef: untpd.TypeDef, sym: Symbol)(using Context): Tree = {
+      assert(sym.info.isInstanceOf[ClassInfo | TypeBounds], i"wrong type, expect a template or type bounds for ${sym.fullName}, but found: ${sym.info}")
+      super.typedTypeDef(tdef, sym)
+    }
+
     override def typedClassDef(cdef: untpd.TypeDef, cls: ClassSymbol)(using Context): Tree = {
       val TypeDef(_, impl @ Template(constr, _, _, _)) = cdef: @unchecked
       assert(cdef.symbol == cls)
diff --git a/compiler/src/scala/quoted/runtime/impl/printers/SourceCode.scala b/compiler/src/scala/quoted/runtime/impl/printers/SourceCode.scala
index e934c1930163..a6a773adc9ba 100644
--- a/compiler/src/scala/quoted/runtime/impl/printers/SourceCode.scala
+++ b/compiler/src/scala/quoted/runtime/impl/printers/SourceCode.scala
@@ -1345,18 +1345,22 @@ object SourceCode {
     }
 
     private def printBoundsTree(bounds: TypeBoundsTree)(using elideThis: Option[Symbol]): this.type = {
-      bounds.low match {
-        case Inferred() =>
-        case low =>
-          this += " >: "
-          printTypeTree(low)
-      }
-      bounds.hi match {
-        case Inferred() => this
-        case hi =>
-          this += " <: "
-          printTypeTree(hi)
-      }
+      if bounds.low.tpe == bounds.hi.tpe then
+        this += " = "
+        printTypeTree(bounds.low)
+      else
+        bounds.low match {
+          case Inferred() =>
+          case low =>
+            this += " >: "
+            printTypeTree(low)
+        }
+        bounds.hi match {
+          case Inferred() => this
+          case hi =>
+            this += " <: "
+            printTypeTree(hi)
+        }
     }
 
     private def printBounds(bounds: TypeBounds)(using elideThis: Option[Symbol]): this.type = {
diff --git a/tests/pos/i17052.scala b/tests/pos/i17052.scala
new file mode 100644
index 000000000000..4bb8cf493d0b
--- /dev/null
+++ b/tests/pos/i17052.scala
@@ -0,0 +1,2 @@
+def test[F[_]](fAny: F[Any]) =
+  { [X] => (fx: F[X]) => { val fx2: F[X] = fx; () } }.apply[Any](fAny)

From d17da7a733e9eda1e2618792609da07aa84dd50b Mon Sep 17 00:00:00 2001
From: Guillaume Martres <smarter@ubuntu.com>
Date: Sat, 25 Mar 2023 14:57:05 +0100
Subject: [PATCH 312/657] Simplify hasPrecisePrefix check

`NoPrefix.isStable` already returns true.
---
 compiler/src/dotty/tools/dotc/core/TypeComparer.scala | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
index 45ccf80198e2..465978d329e6 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
@@ -284,18 +284,18 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
           given Context = ctx // optimization for performance
           val info2 = tp2.info
 
-          /** Does `tp2` have a stable prefix or NoPrefix as a prefix?
+          /** Does `tp2` have a stable prefix?
            *  If that's not the case, following an alias via asSeenFrom could be lossy
            *  so we should not conclude `false` if comparing aliases fails.
            *  See pos/i17064.scala for a test case
            */
-          def hasPrecisePrefix(tp: NamedType) =
-            tp.prefix.isStable || tp.prefix == NoPrefix
+          def hasStablePrefix(tp: NamedType) =
+            tp.prefix.isStable
 
           info2 match
             case info2: TypeAlias =>
               if recur(tp1, info2.alias) then return true
-              if tp2.asInstanceOf[TypeRef].canDropAlias && hasPrecisePrefix(tp2) then
+              if tp2.asInstanceOf[TypeRef].canDropAlias && hasStablePrefix(tp2) then
                 return false
             case _ =>
           tp1 match
@@ -303,7 +303,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
               tp1.info match {
                 case info1: TypeAlias =>
                   if recur(info1.alias, tp2) then return true
-                  if tp1.asInstanceOf[TypeRef].canDropAlias && hasPrecisePrefix(tp2) then
+                  if tp1.asInstanceOf[TypeRef].canDropAlias && hasStablePrefix(tp2) then
                     return false
                 case _ =>
               }

From e3aeed198717e6764f2a27b70a22a03b03a87a0b Mon Sep 17 00:00:00 2001
From: David Hua <d5hua@uwaterloo.ca>
Date: Sun, 26 Mar 2023 01:23:43 -0400
Subject: [PATCH 313/657] Add test for cacheResult flag

---
 tests/init/pos/recursive.scala | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 tests/init/pos/recursive.scala

diff --git a/tests/init/pos/recursive.scala b/tests/init/pos/recursive.scala
new file mode 100644
index 000000000000..74b658330e03
--- /dev/null
+++ b/tests/init/pos/recursive.scala
@@ -0,0 +1,9 @@
+class A {
+  def p(cb: Int => Int): Int = cb(0)
+
+  val q: List[Int] = {
+    def f(x: Int): Int => Int = y => p(f(y))
+    List(1, 2).map(f(3))
+  }
+  val n: Int = 4
+}
\ No newline at end of file

From 8af1b29a88ac71e3eea910b206c2b8c165bc35a8 Mon Sep 17 00:00:00 2001
From: David Hua <d5hua@uwaterloo.ca>
Date: Sun, 26 Mar 2023 01:33:40 -0400
Subject: [PATCH 314/657] Reformat the output when printing a function to
 console in init checker

---
 compiler/src/dotty/tools/dotc/transform/init/Semantic.scala | 2 +-
 tests/init/neg/closureLeak.check                            | 2 +-
 tests/init/neg/t3273.check                                  | 4 ++--
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
index b8d867e96a7e..9412cef6efc8 100644
--- a/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
+++ b/compiler/src/dotty/tools/dotc/transform/init/Semantic.scala
@@ -69,7 +69,7 @@ object Semantic:
         val argsText = if args.nonEmpty then ", args = " + args.map(_.show).mkString("(", ", ", ")") else ""
         "a non-transitively initialized (Warm) object of type (" + klass.show + ") { outer = " + outer.show + argsText + " }"
       case Fun(expr, thisV, klass) =>
-        "a function where \"this\" is (" + thisV.show + ") and the function owner is an object of type (" + klass.show + ")"
+        "a function where \"this\" is (" + thisV.show + ")"
       case RefSet(values) =>
         values.map(_.show).mkString("Set { ", ", ", " }")
       case Hot =>
diff --git a/tests/init/neg/closureLeak.check b/tests/init/neg/closureLeak.check
index 2437509faa73..a90acaa8ed00 100644
--- a/tests/init/neg/closureLeak.check
+++ b/tests/init/neg/closureLeak.check
@@ -1,7 +1,7 @@
 -- Error: tests/init/neg/closureLeak.scala:11:14 -----------------------------------------------------------------------
 11 |    l.foreach(a => a.addX(this)) // error
    |              ^^^^^^^^^^^^^^^^^
-   |Could not verify that the method argument is transitively initialized (Hot). It was found to be a function where "this" is (the original object of type (class Outer) where initialization checking started) and the function owner is an object of type (class Outer). Only transitively initialized arguments may be passed to methods (except constructors). Calling trace:
+   |Could not verify that the method argument is transitively initialized (Hot). It was found to be a function where "this" is (the original object of type (class Outer) where initialization checking started). Only transitively initialized arguments may be passed to methods (except constructors). Calling trace:
    |-> class Outer {	[ closureLeak.scala:1 ]
    |   ^
    |-> l.foreach(a => a.addX(this)) // error	[ closureLeak.scala:11 ]
diff --git a/tests/init/neg/t3273.check b/tests/init/neg/t3273.check
index 2e4d8db50ebb..0fe7ea78871c 100644
--- a/tests/init/neg/t3273.check
+++ b/tests/init/neg/t3273.check
@@ -1,7 +1,7 @@
 -- Error: tests/init/neg/t3273.scala:4:42 ------------------------------------------------------------------------------
 4 |  val num1: LazyList[Int] = 1 #:: num1.map(_ + 1)                        // error
   |                                  ^^^^^^^^^^^^^^^
-  |Could not verify that the method argument is transitively initialized (Hot). It was found to be a function where "this" is (the original object of type (object Test) where initialization checking started) and the function owner is an object of type (object Test). Only transitively initialized arguments may be passed to methods (except constructors). Calling trace:
+  |Could not verify that the method argument is transitively initialized (Hot). It was found to be a function where "this" is (the original object of type (object Test) where initialization checking started). Only transitively initialized arguments may be passed to methods (except constructors). Calling trace:
   |-> object Test {	[ t3273.scala:3 ]
   |   ^
   |-> val num1: LazyList[Int] = 1 #:: num1.map(_ + 1)                        // error	[ t3273.scala:4 ]
@@ -14,7 +14,7 @@
 -- Error: tests/init/neg/t3273.scala:5:61 ------------------------------------------------------------------------------
 5 |  val num2: LazyList[Int] = 1 #:: num2.iterator.map(_ + 1).to(LazyList)  // error
   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  |Could not verify that the method argument is transitively initialized (Hot). It was found to be a function where "this" is (the original object of type (object Test) where initialization checking started) and the function owner is an object of type (object Test). Only transitively initialized arguments may be passed to methods (except constructors). Calling trace:
+  |Could not verify that the method argument is transitively initialized (Hot). It was found to be a function where "this" is (the original object of type (object Test) where initialization checking started). Only transitively initialized arguments may be passed to methods (except constructors). Calling trace:
   |-> object Test {	[ t3273.scala:3 ]
   |   ^
   |-> val num2: LazyList[Int] = 1 #:: num2.iterator.map(_ + 1).to(LazyList)  // error	[ t3273.scala:5 ]

From 0625d1c62e0fb4ce05a3ce6fa6b6a1640ea15d75 Mon Sep 17 00:00:00 2001
From: Lucas Leblanc <44496264+Dedelweiss@users.noreply.github.com>
Date: Mon, 27 Mar 2023 07:56:18 +0200
Subject: [PATCH 315/657] Fix: Add Doctype to be in standard mode (#17087)

In this PR, I added the `<!DOCTYPE html>` in the HtmlRenderer file.
I combined in the def page content the tag html with all the content of
the page (head, body,...) and the Doctype.

## Result :
<img width="400" alt="Screenshot 2023-03-13 at 16 03 43"
src="https://user-images.githubusercontent.com/44496264/224742326-280b1f86-e578-4f25-8d13-9ca39f6c0aec.png">

(On chrome)
<img width="400" alt="Screenshot 2023-03-13 at 16 04 36"
src="https://user-images.githubusercontent.com/44496264/224742405-c5dbc809-c085-4cde-aa4d-4faffc088682.png">

Fixes #16803
---
 .../src/dotty/tools/scaladoc/renderers/HtmlRenderer.scala   | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/scaladoc/src/dotty/tools/scaladoc/renderers/HtmlRenderer.scala b/scaladoc/src/dotty/tools/scaladoc/renderers/HtmlRenderer.scala
index 719033959b47..dbb3b6bc6014 100644
--- a/scaladoc/src/dotty/tools/scaladoc/renderers/HtmlRenderer.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/renderers/HtmlRenderer.scala
@@ -41,7 +41,7 @@ class HtmlRenderer(rootPackage: Member, members: Map[DRI, Member])(using ctx: Do
       case _ => Nil)
       :+ (Attr("data-pathToRoot") := pathToRoot(page.link.dri))
 
-    html(attrs: _*)(
+    val htmlTag = html(attrs: _*)(
       head((mkHead(page) :+ docHead):_*),
       body(
         if !page.hasFrame then docBody
@@ -49,6 +49,10 @@ class HtmlRenderer(rootPackage: Member, members: Map[DRI, Member])(using ctx: Do
       )
     )
 
+    val doctypeTag = s"<!DOCTYPE html>"
+    val finalTag = raw(doctypeTag + htmlTag.toString)
+    finalTag
+
   override def render(): Unit =
     val renderedResources = renderResources()
     super.render()

From 36db085c7821a4daf1cef8567dc06aca2fc1175b Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Mon, 27 Mar 2023 12:56:56 +0200
Subject: [PATCH 316/657] Improve "constructor proxy shadows outer" handling

 - Avoid an error if outer reference cannot be applied
 - Switch to outer reference if reference is not to a function in an application
 - Improve error message with hints how to fix it
---
 .../tools/dotc/reporting/ErrorMessageID.scala |  1 +
 .../dotty/tools/dotc/reporting/messages.scala | 31 ++++++++
 .../src/dotty/tools/dotc/typer/Typer.scala    | 44 +++++++----
 .../explain/constructor-proxy-shadowing.check | 75 +++++++++++++++++++
 .../explain/constructor-proxy-shadowing.scala | 16 ++++
 tests/neg/constructor-proxy-shadowing.scala   | 10 ---
 tests/pos/constr-proxy-shadowing.scala        |  7 ++
 7 files changed, 161 insertions(+), 23 deletions(-)
 create mode 100644 tests/neg-custom-args/explain/constructor-proxy-shadowing.check
 create mode 100644 tests/neg-custom-args/explain/constructor-proxy-shadowing.scala
 delete mode 100644 tests/neg/constructor-proxy-shadowing.scala
 create mode 100644 tests/pos/constr-proxy-shadowing.scala

diff --git a/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala b/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
index b72ec2a19d76..65ebeb02c667 100644
--- a/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
@@ -190,6 +190,7 @@ enum ErrorMessageID(val isActive: Boolean = true) extends java.lang.Enum[ErrorMe
   case InlineGivenShouldNotBeFunctionID // errorNumber 174
   case ValueDiscardingID // errorNumber 175
   case UnusedNonUnitValueID // errorNumber 176
+  case ConstrProxyShadowsID // errorNumber 177
 
   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 4d5e77ef2c49..9875c508c9fd 100644
--- a/compiler/src/dotty/tools/dotc/reporting/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/messages.scala
@@ -1305,6 +1305,37 @@ extends SyntaxMsg(VarArgsParamMustComeLastID) {
 
 import typer.Typer.BindingPrec
 
+class ConstrProxyShadows(proxy: TermRef, shadowed: Type, shadowedIsApply: Boolean)(using Context)
+  extends ReferenceMsg(ConstrProxyShadowsID), NoDisambiguation:
+
+  def clsString(using Context) = proxy.symbol.companionClass.showLocated
+  def shadowedString(using Context) = shadowed.termSymbol.showLocated
+  def appClause = if shadowedIsApply then " the apply method of" else ""
+  def appSuffix = if shadowedIsApply then ".apply" else ""
+
+  def msg(using Context) =
+    i"""Reference to constructor proxy for $clsString
+       |shadows outer reference to $shadowedString
+       |
+       |The instance needs to be created with an explicit `new`."""
+
+  def explain(using Context) =
+    i"""There is an ambiguity in the meaning of the call
+       |
+       |   ${proxy.symbol.name}(...)
+       |
+       |It could mean creating an instance of $clsString with
+       |
+       |   new ${proxy.symbol.companionClass.name}(...)
+       |
+       |Or it could mean calling$appClause $shadowedString as in
+       |
+       |   ${shadowed.termSymbol.name}$appSuffix(...)
+       |
+       |To disambiguate, use an explicit `new` if you mean the former,
+       |or use a full prefix for ${shadowed.termSymbol.name} if you mean the latter."""
+end ConstrProxyShadows
+
 class AmbiguousReference(name: Name, newPrec: BindingPrec, prevPrec: BindingPrec, prevCtx: Context)(using Context)
   extends ReferenceMsg(AmbiguousReferenceID), NoDisambiguation {
 
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 8e8c8b2da1ca..45e8d2da00ca 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -544,22 +544,40 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       	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 _ =>
+    /** Normally, returns `ownType` except if `ownType` is a constructor proxy,
+     *  and there is another shadowed type accessible with the same name that is not:
+     *    - if the prototype is an application:
+     *      - if the shadowed type has a method alternative or an apply method,
+     *        issue an ambiguity error
+     *      - otherwise again return `ownType`
+     *    - if the prototype is not an application, return the shadowed type
+     */
+    def checkNotShadowed(ownType: Type): Type =
+      ownType match
+        case ownType: TermRef if ownType.symbol.is(ConstructorProxy) =>
+          findRef(name, pt, EmptyFlags, ConstructorProxy, tree.srcPos) match
+            case shadowed: TermRef =>
+              pt match
+                case pt: FunOrPolyProto =>
+                  def err(shadowedIsApply: Boolean) =
+                    report.error(ConstrProxyShadows(ownType, shadowed, shadowedIsApply), tree.srcPos)
+                  if shadowed.denot.hasAltWith(sd => sd.symbol.is(Method, butNot = Accessor)) then
+                    err(shadowedIsApply = false)
+                  else if shadowed.member(nme.apply).hasAltWith(_.symbol.is(Method, butNot = Accessor)) then
+                    err(shadowedIsApply = true)
+                case _ =>
+                  return shadowed
+            case shadowed =>
+        case _ =>
+      ownType
 
     def setType(ownType: Type): Tree =
-      checkNotShadowed(ownType)
-      val tree1 = ownType match
-        case ownType: NamedType if !prefixIsElidable(ownType) =>
-          ref(ownType).withSpan(tree.span)
+      val checkedType = checkNotShadowed(ownType)
+      val tree1 = checkedType match
+        case checkedType: NamedType if !prefixIsElidable(checkedType) =>
+          ref(checkedType).withSpan(tree.span)
         case _ =>
-          tree.withType(ownType)
+          tree.withType(checkedType)
       val tree2 = toNotNullTermRef(tree1, pt)
       checkLegalValue(tree2, pt)
       tree2
diff --git a/tests/neg-custom-args/explain/constructor-proxy-shadowing.check b/tests/neg-custom-args/explain/constructor-proxy-shadowing.check
new file mode 100644
index 000000000000..db223ba33640
--- /dev/null
+++ b/tests/neg-custom-args/explain/constructor-proxy-shadowing.check
@@ -0,0 +1,75 @@
+-- [E177] Reference Error: tests/neg-custom-args/explain/constructor-proxy-shadowing.scala:10:12 -----------------------
+10 |    val x = A22("") // error: shadowing
+   |            ^^^
+   |            Reference to constructor proxy for class A22 in class A
+   |            shadows outer reference to method A22 in object Test
+   |
+   |            The instance needs to be created with an explicit `new`.
+   |--------------------------------------------------------------------------------------------------------------------
+   | Explanation (enabled by `-explain`)
+   |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   | There is an ambiguity in the meaning of the call
+   |
+   |    A22(...)
+   |
+   | It could mean creating an instance of class A22 in class A with
+   |
+   |    new A22(...)
+   |
+   | Or it could mean calling method A22 in object Test as in
+   |
+   |    A22(...)
+   |
+   | To disambiguate, use an explicit `new` if you mean the former,
+   | or use a full prefix for A22 if you mean the latter.
+    --------------------------------------------------------------------------------------------------------------------
+-- [E177] Reference Error: tests/neg-custom-args/explain/constructor-proxy-shadowing.scala:11:12 -----------------------
+11 |    val y = A33("") // error: shadowing
+   |            ^^^
+   |            Reference to constructor proxy for class A33 in class A
+   |            shadows outer reference to object A33 in object Test
+   |
+   |            The instance needs to be created with an explicit `new`.
+   |--------------------------------------------------------------------------------------------------------------------
+   | Explanation (enabled by `-explain`)
+   |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   | There is an ambiguity in the meaning of the call
+   |
+   |    A33(...)
+   |
+   | It could mean creating an instance of class A33 in class A with
+   |
+   |    new A33(...)
+   |
+   | Or it could mean calling the apply method of object A33 in object Test as in
+   |
+   |    A33.apply(...)
+   |
+   | To disambiguate, use an explicit `new` if you mean the former,
+   | or use a full prefix for A33 if you mean the latter.
+    --------------------------------------------------------------------------------------------------------------------
+-- [E177] Reference Error: tests/neg-custom-args/explain/constructor-proxy-shadowing.scala:16:8 ------------------------
+16 |val x = Seq(3) // error: shadowing
+   |        ^^^
+   |        Reference to constructor proxy for class Seq
+   |        shadows outer reference to getter Seq in package scala
+   |
+   |        The instance needs to be created with an explicit `new`.
+   |--------------------------------------------------------------------------------------------------------------------
+   | Explanation (enabled by `-explain`)
+   |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   | There is an ambiguity in the meaning of the call
+   |
+   |    Seq(...)
+   |
+   | It could mean creating an instance of class Seq with
+   |
+   |    new Seq(...)
+   |
+   | Or it could mean calling the apply method of getter Seq in package scala as in
+   |
+   |    Seq.apply(...)
+   |
+   | To disambiguate, use an explicit `new` if you mean the former,
+   | or use a full prefix for Seq if you mean the latter.
+    --------------------------------------------------------------------------------------------------------------------
diff --git a/tests/neg-custom-args/explain/constructor-proxy-shadowing.scala b/tests/neg-custom-args/explain/constructor-proxy-shadowing.scala
new file mode 100644
index 000000000000..c47fc2f4859b
--- /dev/null
+++ b/tests/neg-custom-args/explain/constructor-proxy-shadowing.scala
@@ -0,0 +1,16 @@
+
+object Test extends App {
+  def A22(s: String): String = s
+  class A33(s: String)
+  object A33:
+    def apply(s: String) = ???
+  class A {
+    class A22(s: String)
+    class A33(s: String)
+    val x = A22("") // error: shadowing
+    val y = A33("") // error: shadowing
+  }
+}
+
+class Seq(n: Int)
+val x = Seq(3) // error: shadowing
diff --git a/tests/neg/constructor-proxy-shadowing.scala b/tests/neg/constructor-proxy-shadowing.scala
deleted file mode 100644
index 857ef986cb79..000000000000
--- a/tests/neg/constructor-proxy-shadowing.scala
+++ /dev/null
@@ -1,10 +0,0 @@
-
-object Test extends App {
-  def A22(s: String): String = s
-  class A {
-    class A22(s: String) {
-      def run = s
-    }
-    val x = A22("") // error: shadowing
-  }
-}
\ No newline at end of file
diff --git a/tests/pos/constr-proxy-shadowing.scala b/tests/pos/constr-proxy-shadowing.scala
new file mode 100644
index 000000000000..3a3b7cdfec2a
--- /dev/null
+++ b/tests/pos/constr-proxy-shadowing.scala
@@ -0,0 +1,7 @@
+class Number(n: Int)
+val x = Number(3)
+
+class Seq(n: Int)
+val y = Seq
+
+

From 80b165c568699da0265f2bd0b105906d9491c8c3 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Mon, 27 Mar 2023 15:38:47 +0200
Subject: [PATCH 317/657] Change the rules for constructor proxy shadowing in
 reference docs

---
 .../reference/other-new-features/creator-applications.md  | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/docs/_docs/reference/other-new-features/creator-applications.md b/docs/_docs/reference/other-new-features/creator-applications.md
index 81f09d897955..8b1de02b2f25 100644
--- a/docs/_docs/reference/other-new-features/creator-applications.md
+++ b/docs/_docs/reference/other-new-features/creator-applications.md
@@ -47,8 +47,12 @@ be selected with `apply` (or be applied to arguments, in which case the `apply`
 inserted).
 
 Constructor proxies are also not allowed to shadow normal definitions. That is,
-if an identifier resolves to a constructor proxy, and the same identifier is also
-defined or imported in some other scope, an ambiguity is reported.
+an ambiguity is reported, if
+
+ - an identifier resolves to a constructor proxy,
+ - the same identifier is also defined or imported in some other scope,
+ - the other reference can be applied to a (possibly empty) parameter list. That
+   is, it refers either to a method or to a value containing an apply method as member.
 
 ## Motivation
 

From fa9648259d29a3c8bfcf8f1123bfa19b31931a84 Mon Sep 17 00:00:00 2001
From: Wojciech Mazur <wojciech.mazur95@gmail.com>
Date: Mon, 27 Jun 2022 16:22:15 +0200
Subject: [PATCH 318/657] Port GenBCode refactor Scala#6012

---
 .../tools/backend/jvm/BCodeBodyBuilder.scala  |   2 +-
 .../tools/backend/jvm/BCodeHelpers.scala      |  95 +--
 .../tools/backend/jvm/BCodeIdiomatic.scala    |  41 +-
 .../tools/backend/jvm/BCodeSkelBuilder.scala  |   2 +-
 .../src/dotty/tools/backend/jvm/BTypes.scala  |  18 +-
 .../tools/backend/jvm/BTypesFromSymbols.scala |  43 +-
 .../tools/backend/jvm/BackendUtils.scala      | 181 +++++
 .../tools/backend/jvm/BytecodeWriters.scala   | 147 ----
 .../tools/backend/jvm/ClassfileWriter.scala   | 142 ++++
 .../src/dotty/tools/backend/jvm/CodeGen.scala | 181 +++++
 .../dotty/tools/backend/jvm/CoreBTypes.scala  | 256 +++----
 .../backend/jvm/DottyBackendInterface.scala   |   2 +-
 .../dotty/tools/backend/jvm/GenBCode.scala    | 702 ++----------------
 .../backend/jvm/GenericSignatureVisitor.scala |   6 +-
 .../tools/backend/jvm/PostProcessor.scala     | 117 +++
 .../jvm/PostProcessorFrontendAccess.scala     |  79 ++
 .../tools/dotc/config/ScalaSettings.scala     |   2 +-
 docs/_docs/internals/backend.md               |  56 +-
 18 files changed, 937 insertions(+), 1135 deletions(-)
 create mode 100644 compiler/src/dotty/tools/backend/jvm/BackendUtils.scala
 delete mode 100644 compiler/src/dotty/tools/backend/jvm/BytecodeWriters.scala
 create mode 100644 compiler/src/dotty/tools/backend/jvm/ClassfileWriter.scala
 create mode 100644 compiler/src/dotty/tools/backend/jvm/CodeGen.scala
 create mode 100644 compiler/src/dotty/tools/backend/jvm/PostProcessor.scala
 create mode 100644 compiler/src/dotty/tools/backend/jvm/PostProcessorFrontendAccess.scala

diff --git a/compiler/src/dotty/tools/backend/jvm/BCodeBodyBuilder.scala b/compiler/src/dotty/tools/backend/jvm/BCodeBodyBuilder.scala
index 1d559c9950f1..e7b5a0dad1bf 100644
--- a/compiler/src/dotty/tools/backend/jvm/BCodeBodyBuilder.scala
+++ b/compiler/src/dotty/tools/backend/jvm/BCodeBodyBuilder.scala
@@ -1297,7 +1297,7 @@ trait BCodeBodyBuilder extends BCodeSkelBuilder {
             .toList
 
           // `StringConcatFactory` only got added in JDK 9, so use `StringBuilder` for lower
-          if (classfileVersion < asm.Opcodes.V9) {
+          if (backendUtils.classfileVersion < asm.Opcodes.V9) {
 
             // Estimate capacity needed for the string builder
             val approxBuilderSize = concatArguments.view.map {
diff --git a/compiler/src/dotty/tools/backend/jvm/BCodeHelpers.scala b/compiler/src/dotty/tools/backend/jvm/BCodeHelpers.scala
index 3cf7d88b9282..c36c8c546635 100644
--- a/compiler/src/dotty/tools/backend/jvm/BCodeHelpers.scala
+++ b/compiler/src/dotty/tools/backend/jvm/BCodeHelpers.scala
@@ -42,18 +42,19 @@ import dotty.tools.backend.jvm.DottyBackendInterface.symExtensions
  *  @version 1.0
  *
  */
-trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
+trait BCodeHelpers extends BCodeIdiomatic {
   // 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._
 
+  // We need to access GenBCode phase to get access to post-processor components.
+  // At this point it should always be initialized already.
+  protected lazy val backendUtils = genBCodePhase.asInstanceOf[GenBCode].postProcessor.backendUtils
+
   def ScalaATTRName: String = "Scala"
   def ScalaSignatureATTRName: String = "ScalaSig"
 
@@ -64,96 +65,12 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
 
   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
@@ -680,7 +597,7 @@ trait BCodeHelpers extends BCodeIdiomatic with BytecodeWriters {
 
       val mirrorClass = new asm.tree.ClassNode
       mirrorClass.visit(
-        classfileVersion,
+        backendUtils.classfileVersion,
         bType.info.flags,
         mirrorName,
         null /* no java-generic-signature */,
diff --git a/compiler/src/dotty/tools/backend/jvm/BCodeIdiomatic.scala b/compiler/src/dotty/tools/backend/jvm/BCodeIdiomatic.scala
index b86efb7cacb1..42f8ef7f4ef6 100644
--- a/compiler/src/dotty/tools/backend/jvm/BCodeIdiomatic.scala
+++ b/compiler/src/dotty/tools/backend/jvm/BCodeIdiomatic.scala
@@ -19,52 +19,13 @@ import dotty.tools.dotc.report
  */
 trait BCodeIdiomatic {
   val int: DottyBackendInterface
-  final lazy val bTypes = new BTypesFromSymbols[int.type](int)
+  val bTypes: BTypesFromSymbols[int.type]
 
   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
-  }
-
-  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>"
diff --git a/compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala b/compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala
index f7afaae22f76..0a11fb898b48 100644
--- a/compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala
+++ b/compiler/src/dotty/tools/backend/jvm/BCodeSkelBuilder.scala
@@ -271,7 +271,7 @@ trait BCodeSkelBuilder extends BCodeHelpers {
       val flags = javaFlags(claszSymbol)
 
       val thisSignature = getGenericSignature(claszSymbol, claszSymbol.owner)
-      cnode.visit(classfileVersion, flags,
+      cnode.visit(backendUtils.classfileVersion, flags,
                   thisName, thisSignature,
                   superClass, interfaceNames.toArray)
 
diff --git a/compiler/src/dotty/tools/backend/jvm/BTypes.scala b/compiler/src/dotty/tools/backend/jvm/BTypes.scala
index 57bd343b6658..5539bf44aa17 100644
--- a/compiler/src/dotty/tools/backend/jvm/BTypes.scala
+++ b/compiler/src/dotty/tools/backend/jvm/BTypes.scala
@@ -14,7 +14,9 @@ import scala.tools.asm
  * This representation is immutable and independent of the compiler data structures, hence it can
  * be queried by concurrent threads.
  */
-abstract class BTypes {
+abstract class BTypes { self =>
+  val frontendAccess: PostProcessorFrontendAccess
+  import frontendAccess.{frontendSynch}
 
   val int: DottyBackendInterface
   import int.given
@@ -37,10 +39,7 @@ abstract class BTypes {
    */
   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]
+  val coreBTypes: CoreBTypes { val bTypes: self.type}
   import coreBTypes._
 
   /**
@@ -862,3 +861,12 @@ abstract class BTypes {
    */
   /*final*/ case class MethodNameAndType(name: String, methodType: MethodBType)
 }
+
+object BTypes {
+  /**
+   * A marker for strings that represent class internal names.
+   * Ideally the type would be incompatible with String, for example by making it a value class.
+   * But that would create overhead in a Collection[InternalName].
+   */
+  type InternalName = String
+}
diff --git a/compiler/src/dotty/tools/backend/jvm/BTypesFromSymbols.scala b/compiler/src/dotty/tools/backend/jvm/BTypesFromSymbols.scala
index 54dafe6f0032..884dd19ee64f 100644
--- a/compiler/src/dotty/tools/backend/jvm/BTypesFromSymbols.scala
+++ b/compiler/src/dotty/tools/backend/jvm/BTypesFromSymbols.scala
@@ -14,20 +14,14 @@ 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
+import dotty.tools.dotc.core.Phases
 
 /**
  * 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 {
+class BTypesFromSymbols[I <: DottyBackendInterface](val int: I, val frontendAccess: PostProcessorFrontendAccess) extends BTypes {
   import int.{_, given}
   import DottyBackendInterface.{symExtensions, _}
 
@@ -37,39 +31,18 @@ class BTypesFromSymbols[I <: DottyBackendInterface](val int: I) extends BTypes {
   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]
+  val coreBTypes = new CoreBTypesFromSymbols[I]{
+    val bTypes: BTypesFromSymbols.this.type = BTypesFromSymbols.this
   }
+  import coreBTypes._
 
-  @threadUnsafe protected lazy val classBTypeFromInternalNameMap = {
-    perRunCaches.recordCache(collection.concurrent.TrieMap.empty[String, ClassBType])
-  }
+  @threadUnsafe protected lazy val classBTypeFromInternalNameMap =
+    collection.concurrent.TrieMap.empty[String, ClassBType]
 
   /**
    * Cache for the method classBTypeFromSymbol.
    */
-  @threadUnsafe private lazy val convertedClasses = perRunCaches.newMap[Symbol, ClassBType]()
+  @threadUnsafe private lazy val convertedClasses = collection.mutable.HashMap.empty[Symbol, ClassBType]
 
   /**
    * The ClassBType for a class symbol `sym`.
diff --git a/compiler/src/dotty/tools/backend/jvm/BackendUtils.scala b/compiler/src/dotty/tools/backend/jvm/BackendUtils.scala
new file mode 100644
index 000000000000..d54364b1675f
--- /dev/null
+++ b/compiler/src/dotty/tools/backend/jvm/BackendUtils.scala
@@ -0,0 +1,181 @@
+package dotty.tools.backend.jvm
+
+import scala.tools.asm
+import scala.tools.asm.Handle
+import scala.tools.asm.tree.InvokeDynamicInsnNode
+import asm.tree.ClassNode
+import scala.collection.mutable
+import scala.jdk.CollectionConverters._
+import dotty.tools.dotc.report
+
+import scala.language.unsafeNulls
+
+/**
+ * This component hosts tools and utilities used in the backend that require access to a `BTypes`
+ * instance.
+ */
+class BackendUtils(val postProcessor: PostProcessor) {
+  import postProcessor.{bTypes, frontendAccess}
+  import frontendAccess.{compilerSettings}
+  import bTypes.*
+  import coreBTypes.jliLambdaMetaFactoryAltMetafactoryHandle
+
+  // Keep synchronized with `minTargetVersion` and `maxTargetVersion` in ScalaSettings
+  lazy val classfileVersion: Int = compilerSettings.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
+  }
+
+  lazy val extraProc: Int = {
+    import GenBCodeOps.addFlagIf
+    val majorVersion: Int = (classfileVersion & 0xFF)
+    val emitStackMapFrame = (majorVersion >= 50)
+    asm.ClassWriter.COMPUTE_MAXS
+      .addFlagIf(emitStackMapFrame, asm.ClassWriter.COMPUTE_FRAMES)
+  }
+
+  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.
+  */
+  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)
+  }
+
+  /**
+   * Visit the class node and collect all referenced nested classes.
+   */
+  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)
+  }
+
+  /*
+   * 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)
+    }
+  }
+}
diff --git a/compiler/src/dotty/tools/backend/jvm/BytecodeWriters.scala b/compiler/src/dotty/tools/backend/jvm/BytecodeWriters.scala
deleted file mode 100644
index 551d4f8d809e..000000000000
--- a/compiler/src/dotty/tools/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/compiler/src/dotty/tools/backend/jvm/ClassfileWriter.scala b/compiler/src/dotty/tools/backend/jvm/ClassfileWriter.scala
new file mode 100644
index 000000000000..08e84de92dca
--- /dev/null
+++ b/compiler/src/dotty/tools/backend/jvm/ClassfileWriter.scala
@@ -0,0 +1,142 @@
+package dotty.tools.backend.jvm
+
+import java.io.{DataOutputStream, IOException, PrintWriter, StringWriter}
+import java.nio.file.Files
+import java.util.jar.Attributes.Name
+
+import scala.tools.asm.ClassReader
+import scala.tools.asm.tree.ClassNode
+import dotty.tools.io.*
+import dotty.tools.dotc.core.Decorators.*
+import dotty.tools.dotc.util.NoSourcePosition
+import java.nio.charset.StandardCharsets
+import java.nio.channels.ClosedByInterruptException
+import BTypes.InternalName
+import scala.language.unsafeNulls
+
+class ClassfileWriter(frontendAccess: PostProcessorFrontendAccess) {
+  import frontendAccess.{backendReporting, compilerSettings}
+
+  // if non-null, classfiles are additionally written to this directory
+  private val dumpOutputDir: AbstractFile = getDirectoryOrNull(compilerSettings.dumpClassesDirectory)
+
+  // if non-null, classfiles are written to a jar instead of the output directory
+  private val jarWriter: JarWriter | Null = compilerSettings.outputDirectory match {
+    case jar: JarArchive =>
+      val mainClass = compilerSettings.mainClass.orElse {
+        // If no main class was specified, see if there's only one
+        // entry point among the classes going into the jar.
+        frontendAccess.getEntryPoints match {
+          case name :: Nil =>
+            backendReporting.log(i"Unique entry point: setting Main-Class to $name")
+            Some(name)
+          case names =>
+            if names.isEmpty then backendReporting.warning(em"No Main-Class designated or discovered.")
+            else backendReporting.warning(em"No Main-Class due to multiple entry points:\n  ${names.mkString("\n  ")}")
+            None
+        }
+      }
+      jar.underlyingSource.map{ source =>
+        if jar.isEmpty then
+          val jarMainAttrs = mainClass.map(Name.MAIN_CLASS -> _).toList
+          new Jar(source.file).jarWriter(jarMainAttrs: _*)
+        else
+          // Writing to non-empty JAR might be an undefined behaviour, e.g. in case if other files where
+          // created using `AbstractFile.bufferedOutputStream`instead of JarWritter
+          backendReporting.warning(em"Tried to write to non-empty JAR: $source")
+          null
+      }.orNull
+
+    case _ => null
+  }
+
+  private def getDirectoryOrNull(dir: Option[String]): AbstractFile =
+    dir.map(d => new PlainDirectory(Directory(d))).orNull
+
+  private def getFile(base: AbstractFile, clsName: String, suffix: String): AbstractFile = {
+    if (base.file != null) {
+      fastGetFile(base, clsName, suffix)
+    } else {
+      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
+    }
+  }
+
+  private def fastGetFile(base: AbstractFile, clsName: String, suffix: String) = {
+    val index = clsName.lastIndexOf('/')
+    val (packageName, simpleName) = if (index > 0) {
+      (clsName.substring(0, index), clsName.substring(index + 1))
+    } else ("", clsName)
+    val directory = base.file.toPath.resolve(packageName)
+    new PlainFile(Path(directory.resolve(simpleName + suffix)))
+  }
+
+  private def writeBytes(outFile: AbstractFile, bytes: Array[Byte]): Unit = {
+    if (outFile.file != null) {
+      val outPath = outFile.file.toPath
+      try Files.write(outPath, bytes)
+      catch {
+        case _: java.nio.file.NoSuchFileException =>
+          Files.createDirectories(outPath.getParent)
+          Files.write(outPath, bytes)
+      }
+    } else {
+      val out = new DataOutputStream(outFile.bufferedOutput)
+      try out.write(bytes, 0, bytes.length)
+      finally out.close()
+    }
+  }
+
+  def writeClass(className: InternalName, bytes: Array[Byte], sourceFile: AbstractFile): AbstractFile | Null = try {
+    // val writeStart = Statistics.startTimer(BackendStats.bcodeWriteTimer)
+    val outFile = writeToJarOrFile(className, bytes, ".class")
+    // Statistics.stopTimer(BackendStats.bcodeWriteTimer, writeStart)
+
+    if (dumpOutputDir != null) {
+      val dumpFile = getFile(dumpOutputDir, className, ".class")
+      writeBytes(dumpFile, bytes)
+    }
+    outFile
+  } catch {
+    case e: FileConflictException =>
+      backendReporting.error(em"error writing $className: ${e.getMessage}")
+      null
+    case e: java.nio.file.FileSystemException =>
+      if compilerSettings.debug then e.printStackTrace()
+      backendReporting.error(em"error writing $className: ${e.getClass.getName} ${e.getMessage}")
+      null
+  }
+
+  def writeTasty(className: InternalName, bytes: Array[Byte]): Unit =
+    writeToJarOrFile(className, bytes, ".tasty")
+
+  private def writeToJarOrFile(className: InternalName, bytes: Array[Byte], suffix: String): AbstractFile | Null = {
+    if jarWriter == null then
+      val outFolder = compilerSettings.outputDirectory
+      val outFile = getFile(outFolder, className, suffix)
+      try writeBytes(outFile, bytes)
+      catch case ex: ClosedByInterruptException =>
+        try outFile.delete() // don't leave an empty or half-written files around after an interrupt
+        catch case _: Throwable => ()
+        finally throw ex
+      outFile
+    else
+      val path = className + suffix
+      val out = jarWriter.newOutputStream(path)
+      try out.write(bytes, 0, bytes.length)
+      finally out.flush()
+      null
+  }
+
+  def close(): Unit = {
+    if (jarWriter != null) jarWriter.close()
+  }
+}
+
+/** Can't output a file due to the state of the file system. */
+class FileConflictException(msg: String, val file: AbstractFile) extends IOException(msg)
diff --git a/compiler/src/dotty/tools/backend/jvm/CodeGen.scala b/compiler/src/dotty/tools/backend/jvm/CodeGen.scala
new file mode 100644
index 000000000000..c9f9e4e23d90
--- /dev/null
+++ b/compiler/src/dotty/tools/backend/jvm/CodeGen.scala
@@ -0,0 +1,181 @@
+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 java.util.Optional
+import dotty.tools.dotc.sbt.ExtractDependencies
+import dotty.tools.dotc.core._
+import Contexts._
+import Phases._
+import Symbols._
+import StdNames.nme
+
+import java.io.DataOutputStream
+import java.nio.channels.ClosedByInterruptException
+
+import dotty.tools.tasty.{ TastyBuffer, TastyHeaderUnpickler }
+
+import scala.tools.asm
+import scala.tools.asm.tree._
+import tpd._
+import dotty.tools.io.AbstractFile
+import dotty.tools.dotc.util.NoSourcePosition
+
+
+class CodeGen(val int: DottyBackendInterface, val primitives: DottyPrimitives)( val bTypes: BTypesFromSymbols[int.type]) { self =>
+  import DottyBackendInterface.symExtensions
+  import bTypes._
+  import int.given
+
+  private lazy val mirrorCodeGen = Impl.JMirrorBuilder()
+
+  def genUnit(unit: CompilationUnit): GeneratedDefs = {
+    val generatedClasses = mutable.ListBuffer.empty[GeneratedClass]
+    val generatedTasty = mutable.ListBuffer.empty[GeneratedTasty]
+
+    def genClassDef(cd: TypeDef): Unit =
+      try
+        val sym = cd.symbol
+        val sourceFile = unit.source.file
+
+        def registerGeneratedClass(classNode: ClassNode, isArtifact: Boolean): Unit =
+          generatedClasses += GeneratedClass(classNode, sourceFile, isArtifact, onFileCreated(classNode, sym, unit.source))
+
+        val plainC = genClass(cd, unit)
+        registerGeneratedClass(plainC, isArtifact = false)
+
+        val attrNode =
+          if !sym.isTopLevelModuleClass then plainC
+          else if sym.companionClass == NoSymbol then
+            val mirrorC = genMirrorClass(sym, unit)
+            registerGeneratedClass(mirrorC, isArtifact = true)
+            mirrorC
+          else
+            report.log(s"No mirror class for module with linked class: ${sym.fullName}", NoSourcePosition)
+            plainC
+
+        if sym.isClass then
+          genTastyAndSetAttributes(sym, attrNode)
+      catch
+        case ex: Throwable =>
+          ex.printStackTrace()
+          report.error(s"Error while emitting ${unit.source}\n${ex.getMessage}", NoSourcePosition)
+
+
+    def genTastyAndSetAttributes(claszSymbol: Symbol, store: ClassNode): Unit =
+      import Impl.createJAttribute
+      for (binary <- unit.pickled.get(claszSymbol.asClass)) {
+        generatedTasty += GeneratedTasty(store, binary)
+        val tasty =
+          val uuid = new TastyHeaderUnpickler(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)
+      }
+
+    def genClassDefs(tree: Tree): Unit =
+      tree match {
+        case EmptyTree => ()
+        case PackageDef(_, stats) => stats foreach genClassDefs
+        case ValDef(_, _, _) => () // module val not emitted
+        case td: TypeDef =>  genClassDef(td)
+      }
+
+    genClassDefs(unit.tpdTree)
+    GeneratedDefs(generatedClasses.toList, generatedTasty.toList)
+  }
+
+  // Creates a callback that will be evaluated in PostProcessor after creating a file
+  private def onFileCreated(cls: ClassNode, claszSymbol: Symbol, sourceFile: interfaces.SourceFile): AbstractFile => Unit = clsFile => {
+    val (fullClassName, isLocal) = atPhase(sbtExtractDependenciesPhase) {
+      (ExtractDependencies.classNameAsString(claszSymbol), claszSymbol.isLocal)
+    }
+
+    val className = cls.name.replace('/', '.')
+    if (ctx.compilerCallback != null)
+      ctx.compilerCallback.onClassGenerated(sourceFile, convertAbstractFile(clsFile), className)
+
+    if (ctx.sbtCallback != null) {
+      val jSourceFile = sourceFile.jfile.orElse(null)
+      val cb = ctx.sbtCallback
+      if (isLocal) cb.generatedLocalClass(jSourceFile, clsFile.file)
+      else cb.generatedNonLocalClass(jSourceFile, clsFile.file, className, fullClassName)
+    }
+  }
+
+  /** 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)
+    }
+
+  private def genClass(cd: TypeDef, unit: CompilationUnit): ClassNode = {
+    val b = new Impl.PlainClassBuilder(unit)
+    b.genPlainClass(cd)
+    val cls = b.cnode
+    checkForCaseConflict(cls.name, cd.symbol)
+    cls
+  }
+
+  private def genMirrorClass(classSym: Symbol, unit: CompilationUnit): ClassNode = {
+    val cls = mirrorCodeGen.genMirrorClass(classSym, unit)
+    checkForCaseConflict(cls.name, classSym)
+    cls
+  }
+
+  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 then
+             // FIXME: This should really be an error, but then FromTasty tests fail
+            report.warning(s"${cl1.show} and ${cl2.showLocated} produce classes that overwrite one another", cl1.sourcePos)
+          else
+            report.warning(s"${cl1.show} differs only in case from ${cl2.showLocated}. " +
+              "Such classes will overwrite one another on case-insensitive filesystems.", cl1.sourcePos)
+        }
+    }
+  }
+
+  sealed transparent trait ImplEarlyInit{
+    val int: self.int.type = self.int
+    val bTypes: self.bTypes.type = self.bTypes
+    protected val primitives: DottyPrimitives = self.primitives
+  }
+  object Impl extends ImplEarlyInit with BCodeSyncAndTry {
+    class PlainClassBuilder(unit: CompilationUnit) extends SyncAndTryBuilder(unit)
+  }
+}
diff --git a/compiler/src/dotty/tools/backend/jvm/CoreBTypes.scala b/compiler/src/dotty/tools/backend/jvm/CoreBTypes.scala
index d5fce3f53627..30ad6b29b9f0 100644
--- a/compiler/src/dotty/tools/backend/jvm/CoreBTypes.scala
+++ b/compiler/src/dotty/tools/backend/jvm/CoreBTypes.scala
@@ -7,38 +7,58 @@ import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.transform.Erasure
 import scala.tools.asm.{Handle, Opcodes}
 import dotty.tools.dotc.core.StdNames
+import BTypes.InternalName
+
+abstract class CoreBTypes {
+  val bTypes: BTypes
+  import bTypes._
+
+   def primitiveTypeMap: Map[Symbol, PrimitiveBType]
+
+   def boxedClasses: Set[ClassBType]
+
+   def boxedClassOfPrimitive: Map[PrimitiveBType, ClassBType]
+
+   def boxResultType: Map[Symbol, ClassBType]
+
+   def unboxResultType: Map[Symbol, PrimitiveBType]
+
+   def srNothingRef : ClassBType
+   def srNullRef    : ClassBType
+
+   def ObjectRef                   : ClassBType
+   def StringRef                   : ClassBType
+   def jlStringBuilderRef          : ClassBType
+   def jlStringBufferRef           : ClassBType
+   def jlCharSequenceRef           : ClassBType
+   def jlClassRef                  : ClassBType
+   def jlThrowableRef              : ClassBType
+   def jlCloneableRef              : ClassBType
+   def jiSerializableRef           : ClassBType
+   def jlClassCastExceptionRef     : ClassBType
+   def jlIllegalArgExceptionRef    : ClassBType
+   def jliSerializedLambdaRef      : ClassBType
+
+   def srBoxesRuntimeRef: ClassBType
+
+   def jliLambdaMetaFactoryMetafactoryHandle    : Handle
+   def jliLambdaMetaFactoryAltMetafactoryHandle : Handle
+   def jliLambdaDeserializeBootstrapHandle      : Handle
+   def jliStringConcatFactoryMakeConcatWithConstantsHandle: Handle
+
+   def asmBoxTo  : Map[BType, MethodNameAndType]
+   def asmUnboxTo: Map[BType, MethodNameAndType]
+
+   def typeOfArrayOp: Map[Int, BType]
+}
+
+abstract class CoreBTypesFromSymbols[I <: DottyBackendInterface] extends CoreBTypes {
+  val bTypes: BTypesFromSymbols[I]
 
-/**
- * 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._
+  import dotty.tools.dotc.core.Contexts.Context
 
   /**
    * Maps primitive types to their corresponding PrimitiveBType. The map is defined lexically above
@@ -56,31 +76,21 @@ class CoreBTypes[BTFS <: BTypesFromSymbols[_ <: DottyBackendInterface]](val bTyp
     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
-  )
+      UNIT   -> classBTypeFromSymbol(requiredClass[java.lang.Void]),
+      BOOL   -> classBTypeFromSymbol(requiredClass[java.lang.Boolean]),
+      BYTE   -> classBTypeFromSymbol(requiredClass[java.lang.Byte]),
+      SHORT  -> classBTypeFromSymbol(requiredClass[java.lang.Short]),
+      CHAR   -> classBTypeFromSymbol(requiredClass[java.lang.Character]),
+      INT    -> classBTypeFromSymbol(requiredClass[java.lang.Integer]),
+      LONG   -> classBTypeFromSymbol(requiredClass[java.lang.Long]),
+      FLOAT  -> classBTypeFromSymbol(requiredClass[java.lang.Float]),
+      DOUBLE -> classBTypeFromSymbol(requiredClass[java.lang.Double])
+    )
 
   lazy val boxedClasses: Set[ClassBType] = boxedClassOfPrimitive.values.toSet
 
@@ -114,33 +124,35 @@ class CoreBTypes[BTFS <: BTypesFromSymbols[_ <: DottyBackendInterface]](val bTyp
    * 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(
+  lazy val srNothingRef : ClassBType = classBTypeFromSymbol(requiredClass("scala.runtime.Nothing$"))
+  lazy val srNullRef    : ClassBType = classBTypeFromSymbol(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)
+  lazy val jiSerializableRef        : ClassBType = classBTypeFromSymbol(requiredClass[java.io.Serializable])
+  lazy val jlClassCastExceptionRef  : ClassBType = classBTypeFromSymbol(requiredClass[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
+
+  lazy val srLambdaDeserialize               : ClassBType = classBTypeFromSymbol(requiredClass[scala.runtime.LambdaDeserialize])
+
+  lazy val jliLambdaMetaFactoryMetafactoryHandle = new Handle(
     Opcodes.H_INVOKESTATIC,
     jliLambdaMetafactoryRef.internalName,
     "metafactory",
@@ -150,7 +162,7 @@ class CoreBTypes[BTFS <: BTypesFromSymbols[_ <: DottyBackendInterface]](val bTyp
     ).descriptor,
     /* itf = */ false)
 
-  lazy val jliLambdaMetaFactoryAltMetafactoryHandle: Handle = new Handle(
+  lazy val jliLambdaMetaFactoryAltMetafactoryHandle = new Handle(
     Opcodes.H_INVOKESTATIC,
     jliLambdaMetafactoryRef.internalName,
     "altMetafactory",
@@ -159,7 +171,7 @@ class CoreBTypes[BTFS <: BTypesFromSymbols[_ <: DottyBackendInterface]](val bTyp
       jliCallSiteRef
     ).descriptor,
     /* itf = */ false)
-    
+
   lazy val jliLambdaDeserializeBootstrapHandle: Handle = new Handle(
     Opcodes.H_INVOKESTATIC,
     srLambdaDeserialize.internalName,
@@ -179,19 +191,19 @@ class CoreBTypes[BTFS <: BTypesFromSymbols[_ <: DottyBackendInterface]](val bTyp
       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))
+    BOOL   -> MethodNameAndType("boxToBoolean",   MethodBType(List(BOOL),   boxedClassOfPrimitive(BOOL))),
+    BYTE   -> MethodNameAndType("boxToByte",      MethodBType(List(BYTE),   boxedClassOfPrimitive(BYTE))),
+    CHAR   -> MethodNameAndType("boxToCharacter", MethodBType(List(CHAR),   boxedClassOfPrimitive(CHAR))),
+    SHORT  -> MethodNameAndType("boxToShort",     MethodBType(List(SHORT),  boxedClassOfPrimitive(SHORT))),
+    INT    -> MethodNameAndType("boxToInteger",   MethodBType(List(INT),    boxedClassOfPrimitive(INT))),
+    LONG   -> MethodNameAndType("boxToLong",      MethodBType(List(LONG),   boxedClassOfPrimitive(LONG))),
+    FLOAT  -> MethodNameAndType("boxToFloat",     MethodBType(List(FLOAT),  boxedClassOfPrimitive(FLOAT))),
+    DOUBLE -> MethodNameAndType("boxToDouble",    MethodBType(List(DOUBLE), boxedClassOfPrimitive(DOUBLE)))
   )
 
   lazy val asmUnboxTo: Map[BType, MethodNameAndType] = Map(
@@ -220,75 +232,3 @@ class CoreBTypes[BTFS <: BTypesFromSymbols[_ <: DottyBackendInterface]](val bTyp
     )
   }
 }
-
-/**
- * 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/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala b/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
index f8f683a429f6..b2278c3f0ce8 100644
--- a/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
+++ b/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
@@ -25,7 +25,7 @@ import StdNames.nme
 import NameKinds.{LazyBitMapName, LazyLocalName}
 import Names.Name
 
-class DottyBackendInterface(val outputDirectory: AbstractFile, val superCallsMap: ReadOnlyMap[Symbol, Set[ClassSymbol]])(using val ctx: Context) {
+class DottyBackendInterface(val superCallsMap: ReadOnlyMap[Symbol, Set[ClassSymbol]])(using val ctx: Context) {
 
   private val desugared = new java.util.IdentityHashMap[Type, tpd.Select]
 
diff --git a/compiler/src/dotty/tools/backend/jvm/GenBCode.scala b/compiler/src/dotty/tools/backend/jvm/GenBCode.scala
index e788c2b2a4ec..469a6ea57679 100644
--- a/compiler/src/dotty/tools/backend/jvm/GenBCode.scala
+++ b/compiler/src/dotty/tools/backend/jvm/GenBCode.scala
@@ -1,43 +1,16 @@
 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 dotty.tools.dotc.interfaces.CompilerCallback
 import Contexts._
-import Phases._
 import Symbols._
-import Decorators.em
-
-import java.io.DataOutputStream
-import java.nio.channels.ClosedByInterruptException
-
-import dotty.tools.tasty.{ TastyBuffer, TastyHeaderUnpickler }
-
-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
+import scala.collection.mutable
 
-class GenBCode extends Phase {
+class GenBCode extends Phase { self =>
 
   override def phaseName: String = GenBCode.name
 
@@ -52,618 +25,85 @@ class GenBCode extends Phase {
   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 _backendInterface: DottyBackendInterface = _
+  def backendInterface(using ctx: Context): DottyBackendInterface = {
+    if _backendInterface eq null then
+      // Enforce usage of FreshContext so we would be able to modify compilation unit between runs
+      val backendCtx = ctx match
+        case fc: FreshContext => fc
+        case ctx => ctx.fresh
+      _backendInterface = DottyBackendInterface(superCallsMap)(using backendCtx)
+    _backendInterface
   }
 
-  private var myPrimitives: DottyPrimitives = null
-
-  override def run(using Context): Unit =
-    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 var _codeGen: CodeGen = _
+  def codeGen(using Context): CodeGen = {
+    if _codeGen eq null then
+      val int = backendInterface
+      val dottyPrimitives = new DottyPrimitives(ctx)
+      _codeGen = new CodeGen(int, dottyPrimitives)(bTypes.asInstanceOf[BTypesFromSymbols[int.type]])
+    _codeGen
   }
 
-  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 Context) 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 var _bTypes: BTypesFromSymbols[DottyBackendInterface] = _
+  def bTypes(using Context): BTypesFromSymbols[DottyBackendInterface] = {
+    if _bTypes eq null then
+      _bTypes = BTypesFromSymbols(backendInterface, frontendAccess)
+    _bTypes
   }
-  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 var _frontendAccess: PostProcessorFrontendAccess | Null = _
+  def frontendAccess(using Context): PostProcessorFrontendAccess = {
+    if _frontendAccess eq null then
+      _frontendAccess = PostProcessorFrontendAccess.Impl(backendInterface, entryPoints)
+    _frontendAccess.nn
   }
 
-  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 var _postProcessor: PostProcessor | Null = _
+  def postProcessor(using Context): PostProcessor = {
+    if _postProcessor eq null then
+      _postProcessor = new PostProcessor(frontendAccess, bTypes)
+    _postProcessor.nn
   }
-  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.warning( // FIXME: This should really be an error, but then FromTasty tests fail
-                s"${cl1.show} and ${cl2.showLocated} produce classes that overwrite one another", cl1.sourcePos)
-            else
-              report.warning(s"${cl1.show} differs only in case from ${cl2.showLocated}. " +
-                "Such 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(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
-          }
+  override def run(using ctx: Context): Unit =
+    // CompilationUnit is the only component that will differ between each run invocation
+    // We need to update it to have correct source positions.
+    // FreshContext is always enforced when creating backend interface
+    backendInterface.ctx
+      .asInstanceOf[FreshContext]
+      .setCompilationUnit(ctx.compilationUnit)
+    val generated = codeGen.genUnit(ctx.compilationUnit)
+    // In Scala 2, the backend might use global optimizations which might delay post-processing to build the call graph.
+    // In Scala 3, we don't perform backend optimizations and always perform post-processing immediately.
+    // https://github.com/scala/scala/pull/6057
+    postProcessor.postProcessAndSendToDisk(generated)
+    (ctx.compilerCallback: CompilerCallback | Null) match {
+      case cb: CompilerCallback => cb.onSourceCompiled(ctx.source)
+      case null => ()
+    }
+
+  override def runOn(units: List[CompilationUnit])(using ctx:Context): List[CompilationUnit] = {
+    try super.runOn(units)
+    finally
+      // frontendAccess and postProcessor are created lazilly, clean them up only if they were initialized
+      if _frontendAccess ne null then
+        frontendAccess.compilerSettings.outputDirectory 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 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()`
-      *
-      */
+      if _postProcessor ne null then
+        postProcessor.classfileWriter.close()
   }
+}
 
-  /*
-    *  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
+object GenBCode {
+  val name: String = "genBCode"
+  val description: String = "generate JVM bytecode"
 }
diff --git a/compiler/src/dotty/tools/backend/jvm/GenericSignatureVisitor.scala b/compiler/src/dotty/tools/backend/jvm/GenericSignatureVisitor.scala
index e9e532933290..c16bc70fc3b0 100644
--- a/compiler/src/dotty/tools/backend/jvm/GenericSignatureVisitor.scala
+++ b/compiler/src/dotty/tools/backend/jvm/GenericSignatureVisitor.scala
@@ -185,13 +185,13 @@ abstract class GenericSignatureVisitor(nestedOnly: Boolean) {
 }
 
 // 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 
+// 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 
+  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]
 
diff --git a/compiler/src/dotty/tools/backend/jvm/PostProcessor.scala b/compiler/src/dotty/tools/backend/jvm/PostProcessor.scala
new file mode 100644
index 000000000000..606b5645aa24
--- /dev/null
+++ b/compiler/src/dotty/tools/backend/jvm/PostProcessor.scala
@@ -0,0 +1,117 @@
+package dotty.tools.backend.jvm
+
+import scala.collection.mutable.ListBuffer
+import dotty.tools.dotc.util.{SourcePosition, NoSourcePosition}
+import dotty.tools.io.AbstractFile
+import dotty.tools.dotc.core.Contexts.*
+import dotty.tools.dotc.core.Decorators.em
+import scala.tools.asm.ClassWriter
+import scala.tools.asm.tree.ClassNode
+
+/**
+ * Implements late stages of the backend that don't depend on a Global instance, i.e.,
+ * optimizations, post-processing and classfile serialization and writing.
+ */
+class PostProcessor(val frontendAccess: PostProcessorFrontendAccess, val bTypes: BTypes) {
+  self =>
+  import bTypes.*
+  import frontendAccess.{backendReporting, compilerSettings}
+  import int.given
+
+  val backendUtils = new BackendUtils(this)
+  val classfileWriter  = ClassfileWriter(frontendAccess)
+
+  def postProcessAndSendToDisk(generatedDefs: GeneratedDefs): Unit = {
+    val GeneratedDefs(classes, tasty) = generatedDefs
+    for (GeneratedClass(classNode, sourceFile, isArtifact, onFileCreated) <- classes) {
+      val bytes =
+        try
+          if !isArtifact then setSerializableLambdas(classNode)
+          setInnerClasses(classNode)
+          serializeClass(classNode)
+        catch
+          case e: java.lang.RuntimeException if e.getMessage != null && e.getMessage.nn.contains("too large!") =>
+            backendReporting.error(em"Could not write class ${classNode.name} because it exceeds JVM code size limits. ${e.getMessage}")
+            null
+          case ex: Throwable =>
+            ex.printStackTrace()
+            backendReporting.error(em"Error while emitting ${classNode.name}\n${ex.getMessage}")
+            null
+
+      if (bytes != null) {
+        if (AsmUtils.traceSerializedClassEnabled && classNode.name.nn.contains(AsmUtils.traceSerializedClassPattern))
+          AsmUtils.traceClass(bytes)
+
+        val clsFile = classfileWriter.writeClass(classNode.name.nn, bytes, sourceFile)
+        if clsFile != null then onFileCreated(clsFile)
+      }
+    }
+
+    for (GeneratedTasty(classNode, binaryGen) <- tasty){
+      classfileWriter.writeTasty(classNode.name.nn, binaryGen())
+    }
+  }
+
+  private def setSerializableLambdas(classNode: ClassNode): Unit = {
+    import backendUtils.{collectSerializableLambdas, addLambdaDeserialize}
+    val serializableLambdas = collectSerializableLambdas(classNode)
+    if serializableLambdas.nonEmpty then
+      addLambdaDeserialize(classNode, serializableLambdas)
+  }
+
+  private def setInnerClasses(classNode: ClassNode): Unit = {
+    import backendUtils.{collectNestedClasses, addInnerClasses}
+    classNode.innerClasses.nn.clear()
+    val (declared, referred) = collectNestedClasses(classNode)
+    addInnerClasses(classNode, declared, referred)
+  }
+
+  def serializeClass(classNode: ClassNode): Array[Byte] = {
+    val cw = new ClassWriterWithBTypeLub(backendUtils.extraProc)
+    classNode.accept(cw)
+    cw.toByteArray.nn
+  }
+
+  // -----------------------------------------------------------------------------------------
+  // 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://github.com/scala/bug/issues/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 ClassWriterWithBTypeLub(flags: Int) extends ClassWriter(flags) {
+
+    /**
+     * This method is used by asm when computing stack map frames. It 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 = {
+      // All types that appear in a class node need to have their ClassBType cached, see [[cachedClassBType]].
+      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.
+    }
+  }
+}
+
+/**
+ * The result of code generation. [[isArtifact]] is `true` for mirror.
+ */
+case class GeneratedClass(classNode: ClassNode, sourceFile: AbstractFile, isArtifact: Boolean, onFileCreated: AbstractFile => Unit)
+case class GeneratedTasty(classNode: ClassNode, tastyGen: () => Array[Byte])
+case class GeneratedDefs(classes: List[GeneratedClass], tasty: List[GeneratedTasty])
+
+// Temporary class, will be refactored in a future commit
+trait ClassWriterForPostProcessor {
+  type InternalName = String
+  def write(bytes: Array[Byte], className: InternalName, sourceFile: AbstractFile): Unit
+}
diff --git a/compiler/src/dotty/tools/backend/jvm/PostProcessorFrontendAccess.scala b/compiler/src/dotty/tools/backend/jvm/PostProcessorFrontendAccess.scala
new file mode 100644
index 000000000000..80ee68bc94c3
--- /dev/null
+++ b/compiler/src/dotty/tools/backend/jvm/PostProcessorFrontendAccess.scala
@@ -0,0 +1,79 @@
+package dotty.tools.backend.jvm
+
+import scala.collection.mutable.{Clearable, HashSet}
+import dotty.tools.dotc.util.*
+import dotty.tools.dotc.reporting.Message
+import dotty.tools.io.AbstractFile
+import java.util.{Collection => JCollection, Map => JMap}
+import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.report
+import dotty.tools.dotc.core.Phases
+
+/**
+ * Functionality needed in the post-processor whose implementation depends on the compiler
+ * frontend. All methods are synchronized.
+ */
+sealed abstract class PostProcessorFrontendAccess {
+  import PostProcessorFrontendAccess._
+
+  def compilerSettings: CompilerSettings
+  def backendReporting: BackendReporting
+  def getEntryPoints: List[String]
+
+  private val frontendLock: AnyRef = new Object()
+  inline final def frontendSynch[T](inline x: => T): T = frontendLock.synchronized(x)
+}
+
+object PostProcessorFrontendAccess {
+  sealed trait CompilerSettings {
+    def debug: Boolean
+    def target: String // javaOutputVersion
+
+    def dumpClassesDirectory: Option[String]
+    def outputDirectory: AbstractFile
+
+    def mainClass: Option[String]
+  }
+
+  sealed trait BackendReporting {
+    def error(message: Context ?=> Message): Unit
+    def warning(message: Context ?=> Message): Unit
+    def log(message: Context ?=> String): Unit
+  }
+
+  class Impl[I <: DottyBackendInterface](val int: I, entryPoints: HashSet[String]) extends PostProcessorFrontendAccess {
+    import int.given
+    lazy val compilerSettings: CompilerSettings = buildCompilerSettings()
+
+    private def buildCompilerSettings(): CompilerSettings = new CompilerSettings {
+      extension [T](s: dotty.tools.dotc.config.Settings.Setting[T])
+         def valueSetByUser: Option[T] =
+           Option(s.value).filter(_ != s.default)
+      def s = ctx.settings
+
+      lazy val target =
+        val releaseValue = Option(s.javaOutputVersion.value).filter(_.nonEmpty)
+        val targetValue = Option(s.XuncheckedJavaOutputVersion.value).filter(_.nonEmpty)
+        (releaseValue, targetValue) match
+          case (Some(release), None) => release
+          case (None, Some(target)) => target
+          case (Some(release), Some(_)) =>
+            report.warning(s"The value of ${s.XuncheckedJavaOutputVersion.name} was overridden by ${ctx.settings.javaOutputVersion.name}")
+            release
+          case (None, None) => "8" // least supported version by default
+
+      lazy val debug: Boolean = ctx.debug
+      lazy val dumpClassesDirectory: Option[String] = s.Ydumpclasses.valueSetByUser
+      lazy val outputDirectory: AbstractFile = s.outputDir.value
+      lazy val mainClass: Option[String] = s.XmainClass.valueSetByUser
+     }
+
+    object backendReporting extends BackendReporting {
+      def error(message: Context ?=> Message): Unit = frontendSynch(report.error(message))
+      def warning(message: Context ?=> Message): Unit = frontendSynch(report.warning(message))
+      def log(message: Context ?=> String): Unit = frontendSynch(report.log(message))
+    }
+
+    def getEntryPoints: List[String] = frontendSynch(entryPoints.toList)
+  }
+}
\ No newline at end of file
diff --git a/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala b/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala
index 8606d72546ef..32cb030a3296 100644
--- a/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala
+++ b/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala
@@ -15,7 +15,7 @@ import scala.util.chaining._
 class ScalaSettings extends SettingGroup with AllScalaSettings
 
 object ScalaSettings:
-  // Keep synchronized with `classfileVersion` in `BCodeIdiomatic`
+  // Keep synchronized with `classfileVersion` in `BackendUtils`
   private val minTargetVersion = 8
   private val maxTargetVersion = 20
 
diff --git a/docs/_docs/internals/backend.md b/docs/_docs/internals/backend.md
index e3215c3993ae..660f6e1f41e5 100644
--- a/docs/_docs/internals/backend.md
+++ b/docs/_docs/internals/backend.md
@@ -6,8 +6,13 @@ title: "Backend Internals"
 The code for the JVM backend is split up by functionality and assembled in
 `GenBCode.scala`. This file defines class `GenBCode`, the compiler phase.
 
+The workflow is split into `CodeGen.scala` Scala compilation context aware responsible for emitting bytecode,
+and `PostProcessor.scala` which can be used for parallelized, context agnostic processing. In Scala 2 `PostProcessor`,
+was responsible for performing bytecode optimization, e.g. inlining method calls. In Scala 3 it is only used for writing
+Class files and Tasty to disk.
+
 ```
-class GenBCodePipeline -[defines]-->        PlainClassBuilder
+class CodeGen.Impl -[defines]-->        PlainClassBuilder
      |                                              |
  [extends]                                      [extends]
      |                                              |
@@ -18,14 +23,14 @@ BCodeBodyBuilder   ---------------->        PlainBodyBuilder
 BCodeSkelBuilder   ---------------->        PlainSkelBuilder
      |                                       /      |       \
  BCodeHelpers      ---------------->  BCClassGen BCAnnotGen ...  (more components)
-     |    |         \
-     |    |          \------------->  helper methods
-     |    |           \------------>  JMirrorBuilder, JBeanInfoBuilder (uses some components, e.g. BCInnerClassGen)
-     |    |
-     |   BytecodeWriters  --------->        methods and classes to write byte code files
+     |              \
+     |               \------------->  helper methods
+     |                \------------>  JMirrorBuilder, JAndroidBuilder (uses some components, e.g. BCInnerClassGen)
+     |                 \----------->  `backendUtils`: utility for bytecode related ops, contains mapping for supported classfile version
      |
 BCodeIdiomatic     ---------------->        utilities for code generation, e.g. genPrimitiveArithmetic
                     \-------------->        `bTypes`: maps and fields for common BTypes
+                     \------------->        `int`: synchronized interface between PostProcessor and compiltion ctx
 ```
 
 The `BTypes.scala` class contains the `BType` class and predefined BTypes
@@ -34,28 +39,33 @@ The `BTypes.scala` class contains the `BType` class and predefined BTypes
 Compiler creates a `GenBCode` `Phase`, calls `runOn(compilationUnits)`,
 which calls `run(context)`. This:
 
-* initializes `myPrimitives` defined in `DottyPrimitives` (maps primitive
-  members, like `int.+`, to bytecode instructions)
-* creates a `GenBCodePipeline` and calls `run(tree)`
-
-`GenBCodePipeline` now:
-
-* initializes the `bTypes` field of `GenBCodePipeline` defined in `BCodeIdiomatic`
-  (BType maps, common BTypes like `StringRef`)
-* creates `BytecodeWriter` and `JMirrorBuilder` instances (on each compiler run)
-* `buildAndSendToDisk(units)`: uses work queues, see below.
-  - `GenBCodePipeline.feedPipeline1` adds ClassDefs to `q1`
-  - `Worker1.run` creates ASM `ClassNodes`, adds to `q2`. It creates one
-    `PlainClassBuilder` for each compilation unit.
-  - `Worker2.run` adds byte arrays (one for each class) to `q3`
-  - `GenBCodePipeline.drainQ3` writes byte arrays to disk
+* initializes lazily components reused by all `compilationUnits` using same instance of Context:
+  - `bTypes`, used by `CodeGen` and `PostProcessro`, defined in `BCodeIdiomatic`  (BType maps, common BTypes like `StringRef`)
+  - `backendInterface:` - proxy to Context specific operations
+  - `codeGen: CodeGen` - uses `backendInterface`, `bTypes`, initializes instance of `DottyPrimitives` and defines `JMirrorBuilder` instance and implements bytecode generation flow (maps primitive members, like `int.+`, to bytecode instructions)
+  - `fontendAccess` - synchronized `PostProcessor` interface to compiler settings, reporting and GenBCode context (e.g. list of entrypoints)
+  - `postProcessor` - compilation context agnostic module dedicated to parallel processing of produced bytecode. Currently used only for writing Tasty and Class files. Defines `backendUtils` and `classfileWriter`
+* sets context of current compilation unit to the shared context instance
+* calls `codeGen.genUnit(ctx.compilation)` which returns structure with generated definitions (both Class files and Tasty)
+* calls postProcessing of generated definition in `postProcessor`
+* calls registered callbacks if needed for every generated class
+
+Upon calling `codeGen.genUnit` it:
+* creates `PlainClassBuilder` instance for each generated `TypeDef` and creates ASM `ClassNode`
+* creates optional mirror class if needed
+* generates Tasty file content and store its attributes in either mirror or plain class node
+
+`PostProcessor` is later:
+* enriching `ClassNode` with collected serializable lambdas
+* sets its inner classes
+* serializes class and writes it to file, optionally it can execute register callbacks for each generated file
+* writes generated Tasty to file
 
 
 ## Architecture ##
 The architecture of `GenBCode` is the same as in Scalac. It can be partitioned
 into weakly coupled components (called "subsystems" below):
 
-
 ### (a) The queue subsystem ###
 Queues mediate between processors, queues don't know what each processor does.
 
@@ -126,4 +136,4 @@ emitting:
 
 
 ### (f) Building an ASM ClassNode given an AST TypeDef ###
-It's done by `PlainClassBuilder`(see `GenBCode.scala`).
+It's done by `PlainClassBuilder`(see `CodeGen.scala`).

From d1255f33c0aea7a5dd9ed4303606de653c347ab3 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Tue, 28 Mar 2023 12:12:02 +0200
Subject: [PATCH 319/657] Fix needsOuterIfReferenced

#17135 shows that traits also need an outer accessor if they are in a toplevel
method (or lazy val).

Fixes #17135
---
 .../tools/dotc/transform/ExplicitOuter.scala  | 10 ++--
 tests/pos/i17135.scala                        | 53 +++++++++++++++++++
 2 files changed, 59 insertions(+), 4 deletions(-)
 create mode 100644 tests/pos/i17135.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala b/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala
index cddfe51275c8..636dcc2772d0 100644
--- a/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala
@@ -199,9 +199,9 @@ object ExplicitOuter {
 
   /** 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)
+    !(cls.isStatic
+      || cls.effectiveOwner.isStaticOwner
+      || cls.is(PureInterface)
      )
 
   /** Class unconditionally needs an outer pointer. This is the case if
@@ -226,7 +226,9 @@ object ExplicitOuter {
 
   /** The outer parameter accessor of cass `cls` */
   private def outerParamAccessor(cls: ClassSymbol)(using Context): TermSymbol =
-    cls.info.decl(nme.OUTER).symbol.asTerm
+    val outer = cls.info.decl(nme.OUTER).symbol
+    assert(outer.isTerm, i"missing outer accessor in $cls")
+    outer.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,
diff --git a/tests/pos/i17135.scala b/tests/pos/i17135.scala
new file mode 100644
index 000000000000..7e3f91cf5e83
--- /dev/null
+++ b/tests/pos/i17135.scala
@@ -0,0 +1,53 @@
+package doobie
+
+// original example
+def someFunction(param: Int): Int = {
+  sealed trait Foo {
+    def asString: String = this match {
+      case Foo.CaseC => "C"
+    }
+  }
+  object Foo {
+    // Having an object here crashes the compiler.
+    object CaseC extends Foo
+  }
+
+  ???
+}
+
+// minimization
+def foo =
+  class Bar {
+    // Having an object here crashes the compiler.
+    lazy val CaseC =
+      class Baz extends Foo
+      new Baz()
+  }
+  val Bar: Bar = new Bar()
+  trait Foo {
+    def asString = Bar.CaseC
+  }
+
+// variant: outer is lazy val
+lazy val lazyfoo =
+  class Bar {
+    // Having an object here crashes the compiler.
+    lazy val CaseC =
+      class Baz extends Foo
+      new Baz()
+  }
+  val Bar: Bar = new Bar()
+  trait Foo {
+    def asString = Bar.CaseC
+  }
+
+// other example
+def bar =
+  sealed trait GADT2[A] extends Product with Serializable
+
+  object GADT2 {
+    case class IsDir(path: String) extends GADT2[_root_.scala.Boolean]
+    case class Exists(path: String) extends GADT2[_root_.scala.Boolean]
+    case class ReadBytes(path: String) extends GADT2[_root_.scala.Array[_root_.scala.Byte]]
+    case class CopyOver(src: Seq[_root_.scala.Byte], path: String) extends GADT2[Int]
+  }
\ No newline at end of file

From 7296e72779b34d5cd17eb91f132339c391bb169f Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Tue, 28 Mar 2023 13:31:00 +0200
Subject: [PATCH 320/657] Skip superArg methods when determining whether an
 outer accessor is needed

---
 .../src/dotty/tools/dotc/transform/ExplicitOuter.scala   | 9 ++++++++-
 tests/pos/t0049.scala                                    | 3 +++
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala b/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala
index 636dcc2772d0..deb1f665c022 100644
--- a/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala
@@ -13,6 +13,7 @@ import core.Decorators._
 import core.StdNames.nme
 import core.Names._
 import core.NameOps._
+import core.NameKinds.SuperArgName
 import SymUtils._
 import dotty.tools.dotc.ast.tpd
 
@@ -197,10 +198,16 @@ object ExplicitOuter {
   private def outerAccName(cls: ClassSymbol)(using Context): TermName =
     nme.OUTER.expandedName(cls)
 
+  private def outerOwner(sym: Symbol)(using Context): Symbol =
+    val owner = sym.effectiveOwner
+    if owner.name.is(SuperArgName) || owner.isLocalDummy
+    then owner.enclosingClass
+    else owner
+
   /** 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.effectiveOwner.isStaticOwner
+      || outerOwner(cls).isStaticOwner
       || cls.is(PureInterface)
      )
 
diff --git a/tests/pos/t0049.scala b/tests/pos/t0049.scala
index dd866422637f..a453cec9568e 100644
--- a/tests/pos/t0049.scala
+++ b/tests/pos/t0049.scala
@@ -1,3 +1,6 @@
 class C1(x: AnyRef) {};
 
 class C2 extends C1({ class A extends AnyRef {}; (new A) : AnyRef }) {};
+
+class Outer:
+  class C2 extends C1({ class A extends AnyRef {}; (new A) : AnyRef }) {};

From 1d497f586a313aeb92039bd14d90db132c72d91e Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Tue, 28 Mar 2023 14:24:34 +0200
Subject: [PATCH 321/657] Recognize named arguments in
 isFunctionWithUnknownParamType

---
 compiler/src/dotty/tools/dotc/ast/TreeInfo.scala       | 2 ++
 compiler/src/dotty/tools/dotc/typer/Applications.scala | 2 +-
 tests/pos/i17155.scala                                 | 7 +++++++
 3 files changed, 10 insertions(+), 1 deletion(-)
 create mode 100644 tests/pos/i17155.scala

diff --git a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
index 73f45bd7369b..c2147b6af2d3 100644
--- a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
+++ b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
@@ -399,6 +399,8 @@ trait UntypedTreeInfo extends TreeInfo[Untyped] { self: Trees.Instance[Untyped]
       Some(tree)
     case Block(Nil, expr) =>
       functionWithUnknownParamType(expr)
+    case NamedArg(_, expr) =>
+      functionWithUnknownParamType(expr)
     case _ =>
       None
   }
diff --git a/compiler/src/dotty/tools/dotc/typer/Applications.scala b/compiler/src/dotty/tools/dotc/typer/Applications.scala
index 345a8693063b..79d6501ccb2d 100644
--- a/compiler/src/dotty/tools/dotc/typer/Applications.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Applications.scala
@@ -448,7 +448,7 @@ trait Applications extends Compatibility {
       def rec(t: Type): Type = {
         t.widen match{
           case funType: MethodType => funType
-          case funType: PolyType => 
+          case funType: PolyType =>
             rec(instantiateWithTypeVars(funType))
           case tp => tp
         }
diff --git a/tests/pos/i17155.scala b/tests/pos/i17155.scala
new file mode 100644
index 000000000000..7b58dbe4a13a
--- /dev/null
+++ b/tests/pos/i17155.scala
@@ -0,0 +1,7 @@
+def foo[A, B](arr: Array[A], pf: PartialFunction[A, B]): Seq[B] = arr.toSeq.collect(pf)
+def foo[A, B](list: List[A], pf: PartialFunction[A, B]): Seq[B] = list.collect(pf) // no errors if this is commented out
+
+val arr = Array(1, 2, 3)
+val resOkay = foo(arr = arr, { case n if n % 2 != 0 => n.toString }) // compiles
+val resNope = foo(arr = arr, pf = { case n if n % 2 != 0 => n.toString }) // Error 1
+val resNope2 = foo[Int, String](arr = arr, pf = { case n if n % 2 != 0 => n.toString }) // Error 2
\ No newline at end of file

From 2417f194b23ad4dacf27e6e38d83eb5faf09349c Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Tue, 28 Mar 2023 18:06:27 +0200
Subject: [PATCH 322/657] Add suspend strawman

Add a test that combines various experiments using our hypothetical
Suspension abstractions.
---
 tests/pos/suspend-strawman/choices.scala      | 28 ++++++++
 tests/pos/suspend-strawman/generators.scala   | 67 +++++++++++++++++++
 .../suspend-strawman/monadic-reflect.scala    | 56 ++++++++++++++++
 tests/pos/suspend-strawman/runtime.scala      | 11 +++
 .../pos/suspend-strawman/simple-futures.scala | 53 +++++++++++++++
 5 files changed, 215 insertions(+)
 create mode 100644 tests/pos/suspend-strawman/choices.scala
 create mode 100644 tests/pos/suspend-strawman/generators.scala
 create mode 100644 tests/pos/suspend-strawman/monadic-reflect.scala
 create mode 100644 tests/pos/suspend-strawman/runtime.scala
 create mode 100644 tests/pos/suspend-strawman/simple-futures.scala

diff --git a/tests/pos/suspend-strawman/choices.scala b/tests/pos/suspend-strawman/choices.scala
new file mode 100644
index 000000000000..968c223d9c0b
--- /dev/null
+++ b/tests/pos/suspend-strawman/choices.scala
@@ -0,0 +1,28 @@
+import scala.util.boundary, boundary.Label
+import runtime.suspend
+
+trait Choice:
+  def choose[A](choices: A*): A
+
+// the handler
+def choices[T](body: Choice ?=> T): Seq[T] =
+  boundary[Seq[T]]:
+    given Choice with
+      def choose[A](choices: A*): A =
+        suspend[A, Seq[T]](s => choices.flatMap(s.resume))
+    Seq(body)
+
+def choose[A](choices: A*)(using c: Choice): A = c.choose(choices*)
+
+def TestChoices: Seq[Int] =
+  choices:
+    def x = choose(1, -2, -3)
+    def y = choose("ab", "cde")
+    val xx = x;
+    xx + (
+      if xx > 0 then
+        val z = choose(xx / 2, xx * 2)
+        y.length * z
+      else y.length
+    )
+
diff --git a/tests/pos/suspend-strawman/generators.scala b/tests/pos/suspend-strawman/generators.scala
new file mode 100644
index 000000000000..a890196e6215
--- /dev/null
+++ b/tests/pos/suspend-strawman/generators.scala
@@ -0,0 +1,67 @@
+import scala.util.boundary
+import scala.compiletime.uninitialized
+import runtime.suspend
+
+trait CanProduce[-T]:
+  def produce(x: T): Unit
+
+object generate:
+
+  def produce[T](x: T)(using cp: CanProduce[T]): Unit = cp.produce(x)
+
+  def apply[T](body: CanProduce[T] ?=> Unit): Iterator[T] = new:
+    var nextKnown: Boolean = false
+    var nextElem: Option[T] = uninitialized
+
+    var step: () => Unit = () =>
+      boundary[Unit]:
+        given CanProduce[T] with
+          def produce(x: T): Unit =
+            nextElem = Some(x)
+            suspend[Unit, Unit]: k =>
+              step = () => k.resume(())
+        body
+      nextElem = None
+
+    def hasNext: Boolean =
+      if !nextKnown then { step(); nextKnown = true }
+      nextElem.isDefined
+
+    def next: T =
+      require(hasNext)
+      nextKnown = false
+      nextElem.get
+end generate
+
+enum Tree[T]:
+  case Leaf(x: T)
+  case Inner(xs: List[Tree[T]])
+
+def leafs[T](t: Tree[T]): Iterator[T] =
+  generate:
+    def recur(t: Tree[T]): Unit = t match
+      case Tree.Leaf(x) => generate.produce(x)
+      case Tree.Inner(xs) => xs.foreach(recur)
+    recur(t)
+
+object Variant2:
+  trait Generator[T]:
+    def nextOption: Option[T]
+
+  def generate[T](body: CanProduce[T] ?=> Unit): Generator[T] = new:
+
+    def nextOption: Option[T] =
+      step()
+
+    var step: () => Option[T] = () =>
+      boundary:
+        given CanProduce[T] with
+          def produce(x: T): Unit =
+            suspend[Unit, Option[T]]: k =>
+              step = () => k.resume(())
+              Some(x)
+        body
+        None
+  end generate
+
+
diff --git a/tests/pos/suspend-strawman/monadic-reflect.scala b/tests/pos/suspend-strawman/monadic-reflect.scala
new file mode 100644
index 000000000000..84c5255c2a96
--- /dev/null
+++ b/tests/pos/suspend-strawman/monadic-reflect.scala
@@ -0,0 +1,56 @@
+import scala.util.boundary
+import runtime.suspend
+
+trait Monad[F[_]]:
+
+  /** The unit value for a monad */
+  def pure[A](x: A): F[A]
+
+  extension [A](x: F[A])
+    /** The fundamental composition operation */
+    def flatMap[B](f: A => F[B]): F[B]
+
+    /** The `map` operation can now be defined in terms of `flatMap` */
+    def map[B](f: A => B) = x.flatMap(f.andThen(pure))
+
+end Monad
+
+trait CanReflect[M[_]]:
+  def reflect[R](mr: M[R]): R
+
+trait Monadic[M[_]: Monad]:
+
+  /**
+   * Embedding of pure values into the monad M
+   */
+  def pure[A](a: A): M[A]
+
+  /**
+   * Sequencing of monadic values
+   *
+   * Implementations are required to implement sequencing in a stack-safe
+   * way, that is they either need to implement trampolining on their own
+   * or implement `sequence` as a tail recursive function.
+   *
+   * Actually the type X can be different for every call to f...
+   * It is a type aligned sequence, but for simplicity we do not enforce this
+   * here.
+   */
+  def sequence[X, R](init: M[X])(f: X => Either[M[X], M[R]]): M[R]
+
+  /**
+   * Helper to summon and use an instance of CanReflect[M]
+   */
+  def reflect[R](mr: M[R])(using r: CanReflect[M]): R = r.reflect(mr)
+
+  /**
+   * Reify a computation into a monadic value
+   */
+  def reify[R](prog: CanReflect[M] ?=> R): M[R] =
+    boundary [M[R]]:
+      given CanReflect[M] with
+        def reflect[R2](mr: M[R2]): R2 =
+          suspend [R2, M[R]] (k => mr.flatMap(k.resume))
+      pure(prog)
+
+end Monadic
\ No newline at end of file
diff --git a/tests/pos/suspend-strawman/runtime.scala b/tests/pos/suspend-strawman/runtime.scala
new file mode 100644
index 000000000000..406da4f7dd5e
--- /dev/null
+++ b/tests/pos/suspend-strawman/runtime.scala
@@ -0,0 +1,11 @@
+package runtime
+import scala.util.boundary, boundary.Label
+
+/** A hypothetical API for suspensions. Not yet implemented.
+ *  Suspension contain a delimited contination, which can be
+ *  invoked with `resume`
+ */
+class Suspension[-T, +R]:
+  def resume(arg: T): R = ???
+
+def suspend[T, R](body: Suspension[T, R] => R)(using Label[R]): T = ???
diff --git a/tests/pos/suspend-strawman/simple-futures.scala b/tests/pos/suspend-strawman/simple-futures.scala
new file mode 100644
index 000000000000..0a80a74d49dc
--- /dev/null
+++ b/tests/pos/suspend-strawman/simple-futures.scala
@@ -0,0 +1,53 @@
+package simpleFutures
+
+import scala.collection.mutable.ListBuffer
+import scala.util.boundary, boundary.Label
+import runtime.suspend
+
+object Scheduler:
+  def schedule(task: Runnable): Unit = ???
+
+trait Async:
+  def await[T](f: Future[T]): T
+
+class Future[+T](body: Async ?=> T):
+  private var result: Option[T] = None
+  private var waiting: ListBuffer[T => Unit] = ListBuffer()
+  private def addWaiting(k: T => Unit): Unit = waiting += k
+
+  def await(using a: Async): T = a.await(this)
+
+  private def complete(): Unit =
+    Future.async:
+      val value = body
+      val result = Some(value)
+      for k <- waiting do
+        Scheduler.schedule(() => k(value))
+      waiting.clear()
+
+  Scheduler.schedule(() => complete())
+
+object Future:
+
+  // a handler for Async
+  def async(body: Async ?=> Unit): Unit =
+    boundary [Unit]:
+      given Async with
+        def await[T](f: Future[T]): T = f.result match
+          case Some(x) => x
+          case None => suspend[T, Unit](s => f.addWaiting(s.resume))
+      body
+
+end Future
+
+def Test(x: Future[Int], xs: List[Future[Int]]) =
+  Future:
+    x.await + xs.map(_.await).sum
+
+
+
+
+
+
+
+

From 4219db2e0306b739fc9671bca9c1fac82f4c2013 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Tue, 7 Mar 2023 15:18:52 +0100
Subject: [PATCH 323/657] WUnused: Fix for symbols with synthetic names and
 unused transparent inlines

---
 .../tools/dotc/transform/CheckUnused.scala    | 27 +++++++++++++++++-
 .../fatal-warnings/i15503i.scala              | 28 +++++++++++++++++++
 2 files changed, 54 insertions(+), 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index 5e4ed6f6e0df..cc51d9bfbe64 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -10,7 +10,7 @@ import dotty.tools.dotc.core.Decorators.{em, i}
 import dotty.tools.dotc.core.Flags.*
 import dotty.tools.dotc.core.Phases.Phase
 import dotty.tools.dotc.core.StdNames
-import dotty.tools.dotc.report
+import dotty.tools.dotc.{ast, report}
 import dotty.tools.dotc.reporting.Message
 import dotty.tools.dotc.typer.ImportInfo
 import dotty.tools.dotc.util.{Property, SrcPos}
@@ -432,6 +432,20 @@ object CheckUnused:
         else
           exists
       }
+
+      // not report unused transparent inline imports
+      for {
+        imp <- imports
+        sel <- imp.selectors
+      } {
+        if unusedImport.contains(sel) then
+          val tpd.Import(qual, _) = imp
+          val importedMembers = qual.tpe.member(sel.name).alternatives.map(_.symbol)
+          val isTransparentAndInline = importedMembers.exists(s => s.is(Transparent) && s.is(Inline))
+          if isTransparentAndInline then
+            unusedImport -= sel
+      }
+
       // if there's an outer scope
       if usedInScope.nonEmpty then
         // we keep the symbols not referencing an import in this scope
@@ -450,6 +464,7 @@ object CheckUnused:
      */
     def getUnused(using Context): UnusedResult =
       popScope()
+
       val sortedImp =
         if ctx.settings.WunusedHas.imports || ctx.settings.WunusedHas.strictNoImplicitWarn then
           unusedImport.map(d => d.srcPos -> WarnTypes.Imports).toList
@@ -460,6 +475,7 @@ object CheckUnused:
           localDefInScope
             .filterNot(d => d.symbol.usedDefContains)
             .filterNot(d => usedInPosition.exists { case (pos, name) => d.span.contains(pos.span) && name == d.symbol.name})
+            .filterNot(d => containsSyntheticSuffix(d.symbol))
             .map(d => d.namePos -> WarnTypes.LocalDefs).toList
         else
           Nil
@@ -467,6 +483,7 @@ object CheckUnused:
         if ctx.settings.WunusedHas.explicits then
           explicitParamInScope
             .filterNot(d => d.symbol.usedDefContains)
+            .filterNot(d => containsSyntheticSuffix(d.symbol))
             .map(d => d.namePos -> WarnTypes.ExplicitParams).toList
         else
           Nil
@@ -474,6 +491,7 @@ object CheckUnused:
         if ctx.settings.WunusedHas.implicits then
           implicitParamInScope
             .filterNot(d => d.symbol.usedDefContains)
+            .filterNot(d => containsSyntheticSuffix(d.symbol))
             .map(d => d.namePos -> WarnTypes.ImplicitParams).toList
         else
           Nil
@@ -481,6 +499,7 @@ object CheckUnused:
         if ctx.settings.WunusedHas.privates then
           privateDefInScope
             .filterNot(d => d.symbol.usedDefContains)
+            .filterNot(d => containsSyntheticSuffix(d.symbol))
             .map(d => d.namePos -> WarnTypes.PrivateMembers).toList
         else
           Nil
@@ -488,6 +507,7 @@ object CheckUnused:
         if ctx.settings.WunusedHas.patvars then
           patVarsInScope
             .filterNot(d => d.symbol.usedDefContains)
+            .filterNot(d => containsSyntheticSuffix(d.symbol))
             .filterNot(d => usedInPosition.exists { case (pos, name) => d.span.contains(pos.span) && name == d.symbol.name})
             .map(d => d.namePos -> WarnTypes.PatVars).toList
         else
@@ -500,6 +520,11 @@ object CheckUnused:
     end getUnused
     //============================ HELPERS ====================================
 
+    /**
+     * Heuristic to detect synthetic suffixes in names of symbols
+     */
+    private def containsSyntheticSuffix(symbol: Symbol)(using Context): Boolean =
+      symbol.name.mangledString.contains("$")
     /**
      * Is the the constructor of synthetic package object
      * Should be ignored as it is always imported/used in package
diff --git a/tests/neg-custom-args/fatal-warnings/i15503i.scala b/tests/neg-custom-args/fatal-warnings/i15503i.scala
index 3dd4d1fc61e7..9ac2ec5ef622 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503i.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503i.scala
@@ -209,6 +209,34 @@ package foo.test.i16925:
       _ = println(i) // OK
     } yield ()
 
+package foo.test.i16863a:
+  import scala.quoted.*
+  def fn(using Quotes) =
+    val x = Expr(1)
+    '{ $x + 2 } // OK
+
+package foo.test.i16863b:
+  import scala.quoted.*
+  def fn[A](using Quotes, Type[A]) = // OK
+    val numeric = Expr.summon[Numeric[A]].getOrElse(???)
+    '{ $numeric.fromInt(3) } // OK
+
+package foo.test.i16863c:
+  import scala.quoted.*
+  def fn[A](expr: Expr[Any])(using Quotes) =
+    val imp = expr match
+      case '{ ${ _ }: a } => Expr.summon[Numeric[a]] // OK
+    println(imp)
+
+package foo.test.i16863d:
+  import scala.quoted.*
+  import scala.compiletime.asMatchable // OK
+  def fn[A](using Quotes, Type[A]) =
+    import quotes.reflect.*
+    val imp = TypeRepr.of[A].widen.asMatchable match
+      case Refinement(_,_,_) => ()
+    println(imp)
+
 package foo.test.i16679a:
   object myPackage:
     trait CaseClassName[A]:

From c36965ce94ff81e18e88294d932a3d9014668f70 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Wed, 8 Mar 2023 13:24:54 +0100
Subject: [PATCH 324/657] Adjust assertions in test

---
 .../fatal-warnings/i15503-scala2/scala2-t11681.scala          | 4 ++--
 tests/neg-custom-args/fatal-warnings/i15503b.scala            | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/neg-custom-args/fatal-warnings/i15503-scala2/scala2-t11681.scala b/tests/neg-custom-args/fatal-warnings/i15503-scala2/scala2-t11681.scala
index f04129a19e48..18aa6879eeba 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503-scala2/scala2-t11681.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503-scala2/scala2-t11681.scala
@@ -100,9 +100,9 @@ trait Anonymous {
 trait Context[A]
 trait Implicits {
   def f[A](implicit ctx: Context[A]) = answer // error
-  def g[A: Context] = answer // error
+  def g[A: Context] = answer // OK
 }
-class Bound[A: Context] // error
+class Bound[A: Context] // OK
 object Answers {
   def answer: Int = 42
 }
diff --git a/tests/neg-custom-args/fatal-warnings/i15503b.scala b/tests/neg-custom-args/fatal-warnings/i15503b.scala
index 19bcd01a8dde..8a4a055150f9 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503b.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503b.scala
@@ -75,7 +75,7 @@ package foo.scala2.tests:
 
   object Types {
     def l1() = {
-      object HiObject { def f = this } // error
+      object HiObject { def f = this } // OK
       class Hi { // error
         def f1: Hi = new Hi
         def f2(x: Hi) = x

From 8ff475452f74111be884cea7f18b1b818e6c4c0a Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Fri, 10 Mar 2023 17:36:15 +0100
Subject: [PATCH 325/657] Check if import contains transparent inline in
 registerImport

---
 .../tools/dotc/transform/CheckUnused.scala    | 29 +++++++++----------
 .../fatal-warnings/i15503f.scala              |  2 +-
 .../fatal-warnings/i15503g.scala              |  4 +--
 3 files changed, 17 insertions(+), 18 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index cc51d9bfbe64..9b2fd122f68a 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -10,7 +10,7 @@ import dotty.tools.dotc.core.Decorators.{em, i}
 import dotty.tools.dotc.core.Flags.*
 import dotty.tools.dotc.core.Phases.Phase
 import dotty.tools.dotc.core.StdNames
-import dotty.tools.dotc.{ast, report}
+import dotty.tools.dotc.report
 import dotty.tools.dotc.reporting.Message
 import dotty.tools.dotc.typer.ImportInfo
 import dotty.tools.dotc.util.{Property, SrcPos}
@@ -368,7 +368,7 @@ object CheckUnused:
 
     /** Register an import */
     def registerImport(imp: tpd.Import)(using Context): Unit =
-      if !tpd.languageImport(imp.expr).nonEmpty && !imp.isGeneratedByEnum then
+      if !tpd.languageImport(imp.expr).nonEmpty && !imp.isGeneratedByEnum && !isTransparentAndInline(imp) then
         impInScope.top += imp
         unusedImport ++= imp.selectors.filter { s =>
           !shouldSelectorBeReported(imp, s) && !isImportExclusion(s)
@@ -433,19 +433,6 @@ object CheckUnused:
           exists
       }
 
-      // not report unused transparent inline imports
-      for {
-        imp <- imports
-        sel <- imp.selectors
-      } {
-        if unusedImport.contains(sel) then
-          val tpd.Import(qual, _) = imp
-          val importedMembers = qual.tpe.member(sel.name).alternatives.map(_.symbol)
-          val isTransparentAndInline = importedMembers.exists(s => s.is(Transparent) && s.is(Inline))
-          if isTransparentAndInline then
-            unusedImport -= sel
-      }
-
       // if there's an outer scope
       if usedInScope.nonEmpty then
         // we keep the symbols not referencing an import in this scope
@@ -520,6 +507,18 @@ object CheckUnused:
     end getUnused
     //============================ HELPERS ====================================
 
+
+    /**
+     * Checks if import selects a def that is transparent and inline
+     */
+    private def isTransparentAndInline(imp: tpd.Import)(using Context): Boolean =
+      (for {
+        sel <- imp.selectors
+      } yield {
+        val qual = imp.expr
+        val importedMembers = qual.tpe.member(sel.name).alternatives.map(_.symbol)
+        importedMembers.exists(s => s.is(Transparent) && s.is(Inline))
+      }).exists(identity)
     /**
      * Heuristic to detect synthetic suffixes in names of symbols
      */
diff --git a/tests/neg-custom-args/fatal-warnings/i15503f.scala b/tests/neg-custom-args/fatal-warnings/i15503f.scala
index db695da3490b..d36cd01be74e 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503f.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503f.scala
@@ -5,7 +5,7 @@ val default_int = 1
 
 def f1(a: Int) = a // OK
 def f2(a: Int) = 1 // OK
-def f3(a: Int)(using Int) = a // error
+def f3(a: Int)(using Int) = a // OK
 def f4(a: Int)(using Int) = default_int // error
 def f6(a: Int)(using Int) = summon[Int] // OK
 def f7(a: Int)(using Int) = summon[Int] + a // OK
diff --git a/tests/neg-custom-args/fatal-warnings/i15503g.scala b/tests/neg-custom-args/fatal-warnings/i15503g.scala
index d4daea944184..a0822e7e1611 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503g.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503g.scala
@@ -5,8 +5,8 @@ val default_int = 1
 
 def f1(a: Int) = a // OK
 def f2(a: Int) = default_int // error
-def f3(a: Int)(using Int) = a // error
-def f4(a: Int)(using Int) = default_int // error // error
+def f3(a: Int)(using Int) = a // OK
+def f4(a: Int)(using Int) = default_int // error
 def f6(a: Int)(using Int) = summon[Int] // error
 def f7(a: Int)(using Int) = summon[Int] + a // OK
 

From 56b484dcb62e0d98c6bd0178b4469ed405e212ef Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Tue, 28 Mar 2023 17:32:00 +0200
Subject: [PATCH 326/657] Warn for synthetic using/givens with wunused

---
 compiler/src/dotty/tools/dotc/transform/CheckUnused.scala | 2 +-
 tests/neg-custom-args/fatal-warnings/i15503f.scala        | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index 9b2fd122f68a..bf1ec37ebab4 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -478,7 +478,7 @@ object CheckUnused:
         if ctx.settings.WunusedHas.implicits then
           implicitParamInScope
             .filterNot(d => d.symbol.usedDefContains)
-            .filterNot(d => containsSyntheticSuffix(d.symbol))
+            .filterNot(d => containsSyntheticSuffix(d.symbol) && !d.rawMods.is(Given))
             .map(d => d.namePos -> WarnTypes.ImplicitParams).toList
         else
           Nil
diff --git a/tests/neg-custom-args/fatal-warnings/i15503f.scala b/tests/neg-custom-args/fatal-warnings/i15503f.scala
index d36cd01be74e..db695da3490b 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503f.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503f.scala
@@ -5,7 +5,7 @@ val default_int = 1
 
 def f1(a: Int) = a // OK
 def f2(a: Int) = 1 // OK
-def f3(a: Int)(using Int) = a // OK
+def f3(a: Int)(using Int) = a // error
 def f4(a: Int)(using Int) = default_int // error
 def f6(a: Int)(using Int) = summon[Int] // OK
 def f7(a: Int)(using Int) = summon[Int] + a // OK

From 00b3d251a97817b253b4bef0c45efee4c03d9867 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Tue, 28 Mar 2023 19:29:09 +0200
Subject: [PATCH 327/657] Wunused: only filter out non-zero span-length givens

---
 .../src/dotty/tools/dotc/transform/CheckUnused.scala     | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index bf1ec37ebab4..665c0b4284ca 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -478,7 +478,7 @@ object CheckUnused:
         if ctx.settings.WunusedHas.implicits then
           implicitParamInScope
             .filterNot(d => d.symbol.usedDefContains)
-            .filterNot(d => containsSyntheticSuffix(d.symbol) && !d.rawMods.is(Given))
+            .filterNot(d => containsSyntheticSuffix(d.symbol) && (!d.rawMods.is(Given) || hasZeroLengthSpan(d.symbol)))
             .map(d => d.namePos -> WarnTypes.ImplicitParams).toList
         else
           Nil
@@ -519,11 +519,18 @@ object CheckUnused:
         val importedMembers = qual.tpe.member(sel.name).alternatives.map(_.symbol)
         importedMembers.exists(s => s.is(Transparent) && s.is(Inline))
       }).exists(identity)
+
     /**
      * Heuristic to detect synthetic suffixes in names of symbols
      */
     private def containsSyntheticSuffix(symbol: Symbol)(using Context): Boolean =
       symbol.name.mangledString.contains("$")
+
+    /**
+     * Heuristic to detect generated symbols by checking if symbol has zero length span in source
+     */
+    private def hasZeroLengthSpan(symbol: Symbol)(using Context): Boolean =
+      symbol.span.end - symbol.span.start == 0
     /**
      * Is the the constructor of synthetic package object
      * Should be ignored as it is always imported/used in package

From 8f044bf014b7ab180e3ecffd4f3fab6fe95d981b Mon Sep 17 00:00:00 2001
From: Matt Bovel <matthieu@bovel.net>
Date: Tue, 28 Mar 2023 22:50:57 +0200
Subject: [PATCH 328/657] Detail UnapplyInvalidReturnType error message

---
 .../dotty/tools/dotc/reporting/messages.scala |  6 +++++-
 tests/neg/17077.scala                         | 14 +++++++++++++
 tests/pos/17077.scala                         | 20 +++++++++++++++++++
 3 files changed, 39 insertions(+), 1 deletion(-)
 create mode 100644 tests/neg/17077.scala
 create mode 100644 tests/pos/17077.scala

diff --git a/compiler/src/dotty/tools/dotc/reporting/messages.scala b/compiler/src/dotty/tools/dotc/reporting/messages.scala
index 9875c508c9fd..a9cbf9037995 100644
--- a/compiler/src/dotty/tools/dotc/reporting/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/messages.scala
@@ -1962,7 +1962,11 @@ class UnapplyInvalidReturnType(unapplyResult: Type, unapplyName: Name)(using Con
         |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]")})
+        | - is a ${Green("Product")} (like a ${Magenta("Tuple2[T1, T2]")}) of arity i with i >= 1, and has members _1 to _i
+        |
+        |See: https://docs.scala-lang.org/scala3/reference/changed-features/pattern-matching.html#fixed-arity-extractors
+        |
+        |Examples:
         |
         |class A(val i: Int)
         |
diff --git a/tests/neg/17077.scala b/tests/neg/17077.scala
new file mode 100644
index 000000000000..26a052a7bf97
--- /dev/null
+++ b/tests/neg/17077.scala
@@ -0,0 +1,14 @@
+case class IsIntResult()
+
+object IsInt:
+    def unapply(x: Int): IsIntResult = IsIntResult()
+
+@main def test =
+  val v: String | Int = "Blop"
+  val res =
+    v match
+      case IsInt() => 43 // error: cannot use a product of arity zero as a return type for unapply
+                         // see UnapplyInvalidReturnType in messages.scala
+                         // and https://docs.scala-lang.org/scala3/reference/changed-features/pattern-matching.html#fixed-arity-extractors
+      case _ => 42
+  println(res)
diff --git a/tests/pos/17077.scala b/tests/pos/17077.scala
new file mode 100644
index 000000000000..434bba9b4e8a
--- /dev/null
+++ b/tests/pos/17077.scala
@@ -0,0 +1,20 @@
+class MyProduct extends Product:
+    def foo = ???
+    override def productArity: Int = 1
+    override def productElement(n: Int): Any = 42
+    override def canEqual(that: Any): Boolean = that.isInstanceOf[MyProduct]
+    def _1 = 42
+
+object MyProductUnapply:
+    def unapply(x: Int): MyProduct = MyProduct()
+
+@main def test =
+  val v: String | Int = "Blop"
+  val res =
+    v match
+      case MyProductUnapply(y) => y // works: a product of arity 1 is accepted as the return type of unapply
+                                    // see UnapplyInvalidReturnType in messages.scala
+                                    // and https://docs.scala-lang.org/scala3/reference/changed-features/pattern-matching.html#fixed-arity-extractors
+      case _ => 42
+  println(res)
+

From e9077a9ff4385aa79b0d34aab58b87b55749ca96 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Wed, 29 Mar 2023 14:52:46 +0200
Subject: [PATCH 329/657] Skip all symbols with $ in name in Wunused

---
 compiler/src/dotty/tools/dotc/transform/CheckUnused.scala | 7 +------
 1 file changed, 1 insertion(+), 6 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index 665c0b4284ca..f960f7b9e60c 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -478,7 +478,7 @@ object CheckUnused:
         if ctx.settings.WunusedHas.implicits then
           implicitParamInScope
             .filterNot(d => d.symbol.usedDefContains)
-            .filterNot(d => containsSyntheticSuffix(d.symbol) && (!d.rawMods.is(Given) || hasZeroLengthSpan(d.symbol)))
+            .filterNot(d => containsSyntheticSuffix(d.symbol))
             .map(d => d.namePos -> WarnTypes.ImplicitParams).toList
         else
           Nil
@@ -526,11 +526,6 @@ object CheckUnused:
     private def containsSyntheticSuffix(symbol: Symbol)(using Context): Boolean =
       symbol.name.mangledString.contains("$")
 
-    /**
-     * Heuristic to detect generated symbols by checking if symbol has zero length span in source
-     */
-    private def hasZeroLengthSpan(symbol: Symbol)(using Context): Boolean =
-      symbol.span.end - symbol.span.start == 0
     /**
      * Is the the constructor of synthetic package object
      * Should be ignored as it is always imported/used in package

From a83d0c954a619076aec91e1ed6d141a600960913 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Wed, 29 Mar 2023 15:51:50 +0200
Subject: [PATCH 330/657] Add a failing case with named using to test
 Wunused:implicits

---
 tests/neg-custom-args/fatal-warnings/i15503f.scala | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/tests/neg-custom-args/fatal-warnings/i15503f.scala b/tests/neg-custom-args/fatal-warnings/i15503f.scala
index db695da3490b..67c595d74f40 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503f.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503f.scala
@@ -5,8 +5,9 @@ val default_int = 1
 
 def f1(a: Int) = a // OK
 def f2(a: Int) = 1 // OK
-def f3(a: Int)(using Int) = a // error
-def f4(a: Int)(using Int) = default_int // error
+def f3(a: Int)(using Int) = a // OK
+def f4(a: Int)(using Int) = default_int // OK
 def f6(a: Int)(using Int) = summon[Int] // OK
 def f7(a: Int)(using Int) = summon[Int] + a // OK
+def f8(a: Int)(using foo: Int) = a // error
 

From 1f9e8693d5b782d11774b1d239fc6c82aa734ebe Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Wed, 29 Mar 2023 16:10:21 +0200
Subject: [PATCH 331/657] Replace for with exists in isTransparentInline in
 WUNused

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

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index f960f7b9e60c..d7c88a1fca40 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -512,13 +512,11 @@ object CheckUnused:
      * Checks if import selects a def that is transparent and inline
      */
     private def isTransparentAndInline(imp: tpd.Import)(using Context): Boolean =
-      (for {
-        sel <- imp.selectors
-      } yield {
+      imp.selectors.exists { sel =>
         val qual = imp.expr
         val importedMembers = qual.tpe.member(sel.name).alternatives.map(_.symbol)
         importedMembers.exists(s => s.is(Transparent) && s.is(Inline))
-      }).exists(identity)
+      }
 
     /**
      * Heuristic to detect synthetic suffixes in names of symbols

From 599fc9df8c3cc46ce3e28abb5f6832944127d3ec Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Wed, 29 Mar 2023 19:19:13 +0200
Subject: [PATCH 332/657] Skip extension method params in WUnused

---
 .../src/dotty/tools/dotc/transform/CheckUnused.scala     | 2 +-
 tests/neg-custom-args/fatal-warnings/i15503g.scala       | 9 ++++++++-
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index 5e4ed6f6e0df..b9a726455bb7 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -627,7 +627,7 @@ object CheckUnused:
 
     extension (memDef: tpd.MemberDef)
       private def isValidMemberDef(using Context): Boolean =
-        !memDef.symbol.isUnusedAnnot && !memDef.symbol.isAllOf(Flags.AccessorCreationFlags) && !memDef.name.isWildcard
+        !memDef.symbol.isUnusedAnnot && !memDef.symbol.isAllOf(Flags.AccessorCreationFlags) && !memDef.name.isWildcard && !memDef.symbol.owner.is(Extension)
 
       private def isValidParam(using Context): Boolean =
         val sym = memDef.symbol
diff --git a/tests/neg-custom-args/fatal-warnings/i15503g.scala b/tests/neg-custom-args/fatal-warnings/i15503g.scala
index d4daea944184..ee8f6075d4f6 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503g.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503g.scala
@@ -12,4 +12,11 @@ def f7(a: Int)(using Int) = summon[Int] + a // OK
 
 /* --- Trivial method check --- */
 def g1(x: Int) = 1 // OK
-def g2(x: Int) = ??? // OK
\ No newline at end of file
+def g2(x: Int) = ??? // OK
+
+package foo.test.i17101:
+  type Test[A] = A
+  extension[A] (x: Test[A]) { // OK
+    def value: A = x
+    def causesIssue: Unit = println("oh no")
+  }

From 1d6ccf84d0df260a874b2f55e7276aedd6919922 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Mon, 27 Mar 2023 16:49:09 +0200
Subject: [PATCH 333/657] Fix wunused false positive when deriving alias type

---
 .../src/dotty/tools/dotc/transform/CheckUnused.scala | 12 ++++++++++--
 libste                                               |  0
 2 files changed, 10 insertions(+), 2 deletions(-)
 create mode 100644 libste

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index d7c88a1fca40..6fc11d3ab007 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -589,14 +589,22 @@ object CheckUnused:
       /** Given an import and accessibility, return an option of selector that match import<->symbol */
       private def isInImport(imp: tpd.Import, isAccessible: Boolean, symName: Option[Name])(using Context): Option[ImportSelector] =
         val tpd.Import(qual, sels) = imp
-        val qualHasSymbol = qual.tpe.member(sym.name).alternatives.map(_.symbol).contains(sym)
+        val dealiasedSym = dealias(sym)
+        val qualHasSymbol = qual.tpe.member(sym.name).alternatives.map(_.symbol).map(dealias).contains(dealiasedSym)
         def selector = sels.find(sel => (sel.name.toTermName == sym.name || sel.name.toTypeName == sym.name) && symName.map(n => n.toTermName == sel.rename).getOrElse(true))
+        def dealiasedSelector = sels.flatMap(sel => qual.tpe.member(sym.name).alternatives.map(m => (sel, m.symbol))).collect {
+          case (sel, sym) if dealias(sym) == dealiasedSym => sel
+        }.headOption
         def wildcard = sels.find(sel => sel.isWildcard && ((sym.is(Given) == sel.isGiven) || sym.is(Implicit)))
         if qualHasSymbol && !isAccessible && sym.exists then
-          selector.orElse(wildcard) // selector with name or wildcard (or given)
+          selector.orElse(dealiasedSelector).orElse(wildcard) // selector with name or wildcard (or given)
         else
           None
 
+      private def dealias(symbol: Symbol)(using Context): Symbol =
+        if(symbol.isType && symbol.asType.denot.isAliasType) then
+          symbol.asType.typeRef.dealias.typeSymbol
+        else symbol
       /** Annotated with @unused */
       private def isUnusedAnnot(using Context): Boolean =
         sym.annotations.exists(a => a.symbol == ctx.definitions.UnusedAnnot)
diff --git a/libste b/libste
new file mode 100644
index 000000000000..e69de29bb2d1

From 2e3021109941163b9161c5085eefc4ef5e31495a Mon Sep 17 00:00:00 2001
From: Arman Bilge <armanbilge@gmail.com>
Date: Thu, 30 Mar 2023 06:42:40 -0700
Subject: [PATCH 334/657] Strip `index.html` from external API url (#17112)

Ports this fix from Scaladoc 2.


https://github.com/scala/scala/blob/15538c7365bbb03f37d06b59f050241683972c71/src/scaladoc/scala/tools/nsc/doc/Settings.scala#L281-L287

Without it, links to external docs are broken for several libraries.
---
 scaladoc/src/dotty/tools/scaladoc/ExternalDocLink.scala | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/scaladoc/src/dotty/tools/scaladoc/ExternalDocLink.scala b/scaladoc/src/dotty/tools/scaladoc/ExternalDocLink.scala
index 97e0d309d6b8..fd4963bcce4a 100644
--- a/scaladoc/src/dotty/tools/scaladoc/ExternalDocLink.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/ExternalDocLink.scala
@@ -25,10 +25,12 @@ object ExternalDocLink:
     case Failure(e) => fail(mapping, s"Unable to parse $descr. Exception $e occured")
   }
 
+  private def stripIndex(url: String): String = url.stripSuffix("index.html").stripSuffix("/") + "/"
+
   def parseLegacy(mapping: String): Either[String, ExternalDocLink] =
     mapping.split("#").toList match
       case path :: apiUrl :: Nil => for {
-        url <- tryParse(mapping, "url")(URL(apiUrl))
+        url <- tryParse(mapping, "url")(URL(stripIndex(apiUrl)))
       } yield ExternalDocLink(
         List(s"${Regex.quote(path)}.*".r),
         url,
@@ -55,7 +57,7 @@ object ExternalDocLink:
       case regexStr :: docToolStr :: urlStr :: rest =>
         for {
           regex <- tryParse(mapping, "regex")(regexStr.r)
-          url <- tryParse(mapping, "url")(URL(urlStr))
+          url <- tryParse(mapping, "url")(URL(stripIndex(urlStr)))
           doctool <- doctoolByName(docToolStr)
           packageList <- parsePackageList(rest)
         } yield ExternalDocLink(

From cabfa68927445f5a1bf09167b2daeafb4e0bc701 Mon Sep 17 00:00:00 2001
From: Lucas Leblanc <44496264+Dedelweiss@users.noreply.github.com>
Date: Thu, 30 Mar 2023 16:03:16 +0200
Subject: [PATCH 335/657] Fix: Remove the duplicate logo (#17170)

- I added an orElse to the snippet so that the dark logo works and there
is no duplicate logo.
### Before
<img width="569" alt="Screenshot 2023-03-29 at 14 51 09"
src="https://user-images.githubusercontent.com/44496264/228541357-77ca6c2a-4413-45fd-a283-40f304d88c4a.png">
### After
<img width="569" alt="Screenshot 2023-03-29 at 14 48 22"
src="https://user-images.githubusercontent.com/44496264/228541334-c9a3eccc-1d4a-475b-b03b-3698bde162fb.png">

Fixes: #16693
---
 .../src/dotty/tools/scaladoc/renderers/HtmlRenderer.scala     | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/scaladoc/src/dotty/tools/scaladoc/renderers/HtmlRenderer.scala b/scaladoc/src/dotty/tools/scaladoc/renderers/HtmlRenderer.scala
index dbb3b6bc6014..cc0a0e197d26 100644
--- a/scaladoc/src/dotty/tools/scaladoc/renderers/HtmlRenderer.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/renderers/HtmlRenderer.scala
@@ -207,11 +207,11 @@ class HtmlRenderer(rootPackage: Member, members: Map[DRI, Member])(using ctx: Do
       }
 
     val darkProjectLogoElem =
-      darkProjectLogo.flatMap {
+      darkProjectLogo.orElse(projectLogo).flatMap {
         case Resource.File(path, _) =>
           Some(span(id := "dark-project-logo", cls := "project-logo")(img(src := resolveRoot(link.dri, path))))
         case _ => None
-      }.orElse(projectLogoElem)
+      }
 
     val parentsHtml =
       val innerTags = parents.flatMap[TagArg](b => Seq(

From e940421e7cb2062c0cda5b79b347379f5005a313 Mon Sep 17 00:00:00 2001
From: Lucas <leblanc.lucas29@gmail.com>
Date: Mon, 20 Mar 2023 16:03:34 +0100
Subject: [PATCH 336/657] Added some corrections

- Correct typo in SignatureTest file
- Correct from the feedback
---
 project/Build.scala                           |  2 +-
 .../src/tests/extensionParams.scala           |  4 ----
 .../scaladoc/signatures/SignatureTest.scala   | 22 ++++++-------------
 3 files changed, 8 insertions(+), 20 deletions(-)

diff --git a/project/Build.scala b/project/Build.scala
index 1ec68edbdc1b..82b7fee64879 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -361,7 +361,7 @@ 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
-    // bspEnabled := false,
+    bspEnabled := false,
     (Compile / unmanagedSourceDirectories) += baseDirectory.value / "src-bootstrapped",
 
     version := dottyVersion,
diff --git a/scaladoc-testcases/src/tests/extensionParams.scala b/scaladoc-testcases/src/tests/extensionParams.scala
index 950dc57dbe93..0e2225d8aa3c 100644
--- a/scaladoc-testcases/src/tests/extensionParams.scala
+++ b/scaladoc-testcases/src/tests/extensionParams.scala
@@ -61,10 +61,6 @@ extension (using Unit)(a: Int)
   def f14(): Any
   = ???
 
-extension (a: Int)(using Unit)
-  def f15(): Any
-  = ???
-
 import scala.language.experimental.clauseInterleaving
 
 extension (using String)(using Int)(a: Animal)(using Unit)(using Number)
diff --git a/scaladoc/test/dotty/tools/scaladoc/signatures/SignatureTest.scala b/scaladoc/test/dotty/tools/scaladoc/signatures/SignatureTest.scala
index 9c831d6a7349..d5b7a0b9b6f8 100644
--- a/scaladoc/test/dotty/tools/scaladoc/signatures/SignatureTest.scala
+++ b/scaladoc/test/dotty/tools/scaladoc/signatures/SignatureTest.scala
@@ -43,7 +43,7 @@ abstract class SignatureTest(
 
     val unexpected = unexpectedFromSources.flatMap(actualSignatures.get).flatten
     val expectedButNotFound = expectedFromSources.flatMap {
-      case (k, v) => findMissingSingatures(v, actualSignatures.getOrElse(k, Nil))
+      case (k, v) => findMissingSignatures(v, actualSignatures.getOrElse(k, Nil))
     }
 
     val missingReport = Option.when(!ignoreMissingSignatures && !expectedButNotFound.isEmpty)
@@ -75,26 +75,21 @@ abstract class SignatureTest(
   private val unexpectedRegex = raw"(.+)//unexpected".r
   private val identifierRegex = raw"^\s*(`.*`|(?:\w+)(?:_[^\[\(\s]+)|\w+|[^\[\(\s]+)".r
 
-  private def findMissingSingatures(expected: Seq[String], actual: Seq[String]): Set[String] =
+  private def findMissingSignatures(expected: Seq[String], actual: Seq[String]): Set[String] =
     expected.toSet &~ actual.toSet
 
   extension (s: String)
     private def startWithAnyOfThese(c: String*) = c.exists(s.startsWith)
     private def compactWhitespaces = whitespaceRegex.replaceAllIn(s, " ")
 
-  private var counter = 0
   private def findName(signature: String, kinds: Seq[String]): Option[String] =
     for
       kindMatch <- kinds.flatMap(k =>s"\\b$k\\b".r.findFirstMatchIn(signature)).headOption
+      kind <- Option(kindMatch.group(0)) // to filter out nulls
       afterKind <- Option(kindMatch.after(0)) // to filter out nulls
-      nameMatch <- identifierRegex.findFirstMatchIn(
-        if kindMatch.group(0).contains("extension")
-        then
-          signature
-        else
-          afterKind
-        )
-    yield nameMatch.group(1)
+      name <- if kind.contains("extension") then Some(signature) // The name of an extension will always be the signature itself
+                    else identifierRegex.findFirstMatchIn(afterKind).map(_.group(1))
+    yield name
 
   private def signaturesFromSources(source: Source, kinds: Seq[String]): Seq[SignatureRes] =
     source.getLines.map(_.trim)
@@ -118,9 +113,7 @@ abstract class SignatureTest(
     def processFile(path: Path): Unit = if filterFunc(path) then
       val document = Jsoup.parse(IO.read(path))
       val documentable = document.select(".groupHeader").forEach { element =>
-        val signature = element.select(".groupHeader").eachText.asScala.mkString("")
-        val all = s"$signature"
-        signatures += all
+        signatures += element.text
       }
       val content = document.select(".documentableElement").forEach { elem =>
         val annotations = elem.select(".annotations").eachText.asScala.mkString("")
@@ -134,7 +127,6 @@ abstract class SignatureTest(
         val all = s"$annotations$other $sigPrefix$signature".trim()
         signatures += all
       }
-    counter = 0
 
     IO.foreachFileIn(output, processFile)
     signatures.result

From f035f102069bbbb6b438b0d18f871a68cfa29987 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Fri, 10 Mar 2023 15:39:04 +0100
Subject: [PATCH 337/657] Fix quotes with references to path dependent types

---
 .../dotty/tools/dotc/staging/HealType.scala   | 43 ++++++++----
 .../tools/dotc/transform/PickleQuotes.scala   |  7 +-
 .../tools/dotc/transform/TreeChecker.scala    |  4 +-
 .../path-dependent-type-capture/Macro_1.scala | 70 +++++++++++++++++++
 .../path-dependent-type-capture/Test_2.scala  |  1 +
 5 files changed, 107 insertions(+), 18 deletions(-)
 create mode 100644 tests/pos-macros/path-dependent-type-capture/Macro_1.scala
 create mode 100644 tests/pos-macros/path-dependent-type-capture/Test_2.scala

diff --git a/compiler/src/dotty/tools/dotc/staging/HealType.scala b/compiler/src/dotty/tools/dotc/staging/HealType.scala
index 7907c2e47542..4f59e92241fb 100644
--- a/compiler/src/dotty/tools/dotc/staging/HealType.scala
+++ b/compiler/src/dotty/tools/dotc/staging/HealType.scala
@@ -31,15 +31,12 @@ class HealType(pos: SrcPos)(using Context) extends TypeMap {
    */
   def apply(tp: Type): Type =
     tp match
-      case tp: TypeRef =>
-        tp.underlying match
-          case TypeAlias(alias)
-          if !tp.symbol.isTypeSplice && !tp.typeSymbol.hasAnnotation(defn.QuotedRuntime_SplicedTypeAnnot) =>
-            this.apply(alias)
-          case _ =>
-            healTypeRef(tp)
-      case tp @ TermRef(NoPrefix, _) if !tp.symbol.isStatic && level > levelOf(tp.symbol) =>
-        levelError(tp.symbol, tp, pos)
+      case NonSpliceAlias(aliased) => this.apply(aliased)
+      case tp: TypeRef => healTypeRef(tp)
+      case tp: TermRef =>
+        val inconsistentRoot = levelInconsistentRootOfPath(tp)
+        if inconsistentRoot.exists then levelError(inconsistentRoot, tp, pos)
+        else tp
       case tp: AnnotatedType =>
         derivedAnnotatedType(tp, apply(tp.parent), tp.annot)
       case _ =>
@@ -47,23 +44,39 @@ class HealType(pos: SrcPos)(using Context) extends TypeMap {
 
   private def healTypeRef(tp: TypeRef): Type =
     tp.prefix match
+      case NoPrefix if tp.typeSymbol.hasAnnotation(defn.QuotedRuntime_SplicedTypeAnnot) =>
+        tp
       case prefix: TermRef if tp.symbol.isTypeSplice =>
         checkNotWildcardSplice(tp)
         if level == 0 then tp else getQuoteTypeTags.getTagRef(prefix)
-      case prefix: TermRef if !prefix.symbol.isStatic && level > levelOf(prefix.symbol) =>
-        tryHeal(prefix.symbol, tp, pos)
-      case NoPrefix if level > levelOf(tp.symbol) && !tp.typeSymbol.hasAnnotation(defn.QuotedRuntime_SplicedTypeAnnot) =>
-        tryHeal(tp.symbol, tp, pos)
-      case prefix: ThisType if level > levelOf(prefix.cls) && !tp.symbol.isStatic =>
-        tryHeal(tp.symbol, tp, pos)
+      case _: NamedType | _: ThisType | NoPrefix =>
+        if levelInconsistentRootOfPath(tp).exists then
+          tryHeal(tp.symbol, tp, pos)
+        else
+          tp
       case _ =>
         mapOver(tp)
 
+  private object NonSpliceAlias:
+    def unapply(tp: TypeRef)(using Context): Option[Type] = tp.underlying match
+      case TypeAlias(alias) if !tp.symbol.isTypeSplice && !tp.typeSymbol.hasAnnotation(defn.QuotedRuntime_SplicedTypeAnnot) => Some(alias)
+      case _ => None
+
   private def checkNotWildcardSplice(splice: TypeRef): Unit =
     splice.prefix.termSymbol.info.argInfos match
       case (tb: TypeBounds) :: _ => report.error(em"Cannot splice $splice because it is a wildcard type", pos)
       case _ =>
 
+  /** Return the root of this path if it is a variable defined in a previous level.
+   *  If the path is consistent, return NoSymbol.
+   */
+  private def levelInconsistentRootOfPath(tp: Type)(using Context): Symbol =
+    tp match
+      case tp @ NamedType(NoPrefix, _) if level > levelOf(tp.symbol) => tp.symbol
+      case tp: NamedType if !tp.symbol.isStatic => levelInconsistentRootOfPath(tp.prefix)
+      case tp: ThisType if level > levelOf(tp.cls) => tp.cls
+      case _ => NoSymbol
+
   /** 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]]}`.
diff --git a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
index 728ee9552c81..62174c806f09 100644
--- a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
@@ -157,13 +157,18 @@ class PickleQuotes extends MacroTransform {
         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 =>
+          case tp @ TypeRef(pre, _) if isLocalPath(pre) =>
             val hiBound = tp.typeSymbol.info match
               case info: ClassInfo => info.parents.reduce(_ & _)
               case info => info.hiBound
             apply(hiBound)
           case tp =>
             mapOver(tp)
+
+        private def isLocalPath(tp: Type): Boolean = tp match
+          case NoPrefix => true
+          case tp: TermRef if !tp.symbol.is(Package) => isLocalPath(tp.prefix)
+          case tp => false
       }
 
       /** Remove references to local types that will not be defined in this quote */
diff --git a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
index f9966eac7fad..f9240d6091c4 100644
--- a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
@@ -679,7 +679,7 @@ object TreeChecker {
               defn.AnyType
             case tpe => tpe
           defn.QuotedExprClass.typeRef.appliedTo(tpe)
-        else defn.QuotedTypeClass.typeRef.appliedTo(arg.typeOpt)
+        else defn.QuotedTypeClass.typeRef.appliedTo(arg.typeOpt.widenTermRefExpr)
       }
       val expectedResultType =
         if isTermHole then defn.QuotedExprClass.typeRef.appliedTo(tpt.typeOpt)
@@ -688,7 +688,7 @@ object TreeChecker {
         defn.FunctionOf(List(defn.QuotesClass.typeRef), expectedResultType, isContextual = true)
       val expectedContentType =
         defn.FunctionOf(argQuotedTypes, contextualResult)
-      assert(content.typeOpt =:= expectedContentType, i"expected content of the hole to be ${expectedContentType} but got ${content.typeOpt}")
+      assert(content.typeOpt =:= expectedContentType, i"unexpected content of hole\nexpected: ${expectedContentType}\nwas: ${content.typeOpt}")
 
       tree1
     }
diff --git a/tests/pos-macros/path-dependent-type-capture/Macro_1.scala b/tests/pos-macros/path-dependent-type-capture/Macro_1.scala
new file mode 100644
index 000000000000..588e50846eff
--- /dev/null
+++ b/tests/pos-macros/path-dependent-type-capture/Macro_1.scala
@@ -0,0 +1,70 @@
+import scala.quoted.*
+
+trait A:
+  type T
+  val b: B
+
+trait B:
+  type T
+  def f: Unit
+
+trait C0:
+  type U
+  val d: D0
+trait D0:
+  type U
+  def h: Unit
+object Macro:
+  inline def generateCode: Unit = ${ generateCodeExpr }
+
+  def generateCodeExpr(using Quotes): Expr[Unit] =
+    '{
+      $testLocalPathsGlobalClasses
+      $testLocalPathsLocalClasses
+    }
+
+  def testLocalPathsGlobalClasses(using Quotes): Expr[Unit] =
+    '{
+      type T
+      val a: A = ???
+      ${
+        val expr = '{
+          val t: T = ???
+          val aT: a.T = ???
+          val abT: a.b.T = ???
+          val aRef: a.type = ???
+          aRef.b
+          aRef.b.f
+          val abRef: a.b.type = ???
+          abRef.f
+          ()
+        }
+        expr
+      }
+    }
+
+  def testLocalPathsLocalClasses(using Quotes): Expr[Unit] =
+    '{
+      type U
+      trait C extends C0:
+        type U
+        val d: D
+      trait D extends D0:
+        type U
+        def h: Unit
+      val c: C = ???
+      ${
+        val expr = '{
+          val u: U = ???
+          val cU: c.U = ???
+          val cdU: c.d.U = ???
+          val cRef: c.type = ???
+          cRef.d
+          cRef.d.h
+          val cdRef: c.d.type = ???
+          cdRef.h
+          ()
+        }
+        expr
+      }
+    }
diff --git a/tests/pos-macros/path-dependent-type-capture/Test_2.scala b/tests/pos-macros/path-dependent-type-capture/Test_2.scala
new file mode 100644
index 000000000000..c12cd8d2436a
--- /dev/null
+++ b/tests/pos-macros/path-dependent-type-capture/Test_2.scala
@@ -0,0 +1 @@
+@main def test = Macro.generateCode

From 1297e13a7e6a5b4f83fb2d6b47f3e0921826c2dd Mon Sep 17 00:00:00 2001
From: Matt Bovel <matthieu@bovel.net>
Date: Mon, 3 Apr 2023 10:55:26 +0200
Subject: [PATCH 338/657] Drop network tests in requests community-build

---
 community-build/community-projects/requests-scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/community-build/community-projects/requests-scala b/community-build/community-projects/requests-scala
index 2d7316a8f444..8e4a40588491 160000
--- a/community-build/community-projects/requests-scala
+++ b/community-build/community-projects/requests-scala
@@ -1 +1 @@
-Subproject commit 2d7316a8f444c2f38795e5905f90837e651c79c3
+Subproject commit 8e4a40588491608aa40099f79c881d54a5094e75

From ca3f7c6ea9b9c7f37cb2d07158652868dc3d084e Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Fri, 17 Mar 2023 14:33:53 +0100
Subject: [PATCH 339/657] Improve missing argument list error

Fixes #17123
---
 .../tools/dotc/reporting/ErrorMessageID.scala |  1 +
 .../dotty/tools/dotc/reporting/messages.scala | 10 +++
 .../tools/dotc/typer/ErrorReporting.scala     | 22 +++--
 tests/neg/i16820.check                        | 24 ++++--
 tests/neg/i17123.check                        | 86 +++++++++++++++++++
 tests/neg/i17123.scala                        | 22 +++++
 tests/neg/i7816.scala                         |  2 +-
 tests/neg/indent-colons.check                 | 28 ++++--
 8 files changed, 177 insertions(+), 18 deletions(-)
 create mode 100644 tests/neg/i17123.check
 create mode 100644 tests/neg/i17123.scala

diff --git a/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala b/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
index 65ebeb02c667..1fe38ce5e801 100644
--- a/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
@@ -191,6 +191,7 @@ enum ErrorMessageID(val isActive: Boolean = true) extends java.lang.Enum[ErrorMe
   case ValueDiscardingID // errorNumber 175
   case UnusedNonUnitValueID // errorNumber 176
   case ConstrProxyShadowsID // errorNumber 177
+  case MissingArgumentListID // errorNumber: 178
 
   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 9875c508c9fd..fe2df5ca6016 100644
--- a/compiler/src/dotty/tools/dotc/reporting/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/messages.scala
@@ -1501,6 +1501,16 @@ class MissingArgument(pname: Name, methString: String)(using Context)
     else s"missing argument for parameter $pname of $methString"
   def explain(using Context) = ""
 
+class MissingArgumentList(method: String, sym: Symbol)(using Context)
+  extends TypeMsg(MissingArgumentListID) {
+  def msg(using Context) =
+    val symDcl = if sym.exists then "\n\n  " + sym.showDcl else ""
+    i"missing argument list for $method$symDcl"
+  def explain(using Context) = {
+    i"""Unapplied methods are only converted to functions when a function type is expected."""
+  }
+}
+
 class DoesNotConformToBound(tpe: Type, which: String, bound: Type)(using Context)
   extends TypeMismatchMsg(
     if which == "lower" then bound else tpe,
diff --git a/compiler/src/dotty/tools/dotc/typer/ErrorReporting.scala b/compiler/src/dotty/tools/dotc/typer/ErrorReporting.scala
index 32b5fde689ec..126d109889e1 100644
--- a/compiler/src/dotty/tools/dotc/typer/ErrorReporting.scala
+++ b/compiler/src/dotty/tools/dotc/typer/ErrorReporting.scala
@@ -41,12 +41,24 @@ object ErrorReporting {
     errorType(WrongNumberOfTypeArgs(fntpe, expectedArgs, actual), pos)
 
   def missingArgs(tree: Tree, mt: Type)(using Context): Unit =
+    def isCallableWithoutArgumentsLists(mt: Type): Boolean = mt match
+        case pt: PolyType => isCallableWithoutArgumentsLists(pt.resType)
+        case mt: MethodType if mt.isImplicitMethod => isCallableWithoutArgumentsLists(mt.resType)
+        case mt: MethodType => false
+        case _ => true
+    def isCallableWithSingleEmptyArgumentList(mt: Type): Boolean =
+      mt match
+        case mt: MethodType if mt.paramNames.isEmpty => isCallableWithoutArgumentsLists(mt.resType)
+        case mt: MethodType if mt.isImplicitMethod => isCallableWithSingleEmptyArgumentList(mt.resType)
+        case pt: PolyType => isCallableWithSingleEmptyArgumentList(pt.resType)
+        case _ => false
     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)
+    val info = if tree.symbol.exists then tree.symbol.info else mt
+    if isCallableWithSingleEmptyArgumentList(info) then
+      report.error(MissingEmptyArgumentList(meth), tree.srcPos)
+    else
+      report.error(MissingArgumentList(meth, tree.symbol), tree.srcPos)
+
 
   def matchReductionAddendum(tps: Type*)(using Context): String =
     val collectMatchTrace = new TypeAccumulator[String]:
diff --git a/tests/neg/i16820.check b/tests/neg/i16820.check
index f51bfafef899..48824d683244 100644
--- a/tests/neg/i16820.check
+++ b/tests/neg/i16820.check
@@ -1,18 +1,30 @@
--- Error: tests/neg/i16820.scala:5:11 ----------------------------------------------------------------------------------
+-- [E178] Type Error: tests/neg/i16820.scala:5:11 ----------------------------------------------------------------------
 5 |  val x1 = f  // error
   |           ^
-  |           missing arguments for method f in object Test
+  |           missing argument list for method f in object Test
+  |
+  |             def f(xs: Int*): Int
+  |
+  | longer explanation available when compiling with `-explain`
 -- [E100] Syntax Error: tests/neg/i16820.scala:6:11 --------------------------------------------------------------------
 6 |  val x2 = g  // error
   |           ^
   |           method g in object Test must be called with () argument
   |
   | longer explanation available when compiling with `-explain`
--- Error: tests/neg/i16820.scala:7:40 ----------------------------------------------------------------------------------
+-- [E178] Type Error: tests/neg/i16820.scala:7:40 ----------------------------------------------------------------------
 7 |  val x3 = java.nio.file.Paths.get(".").toRealPath // error
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  |           missing arguments for method toRealPath in trait Path
--- Error: tests/neg/i16820.scala:11:14 ---------------------------------------------------------------------------------
+  |           missing argument list for method toRealPath in trait Path
+  |
+  |             def toRealPath(x$0: java.nio.file.LinkOption*): java.nio.file.Path
+  |
+  | longer explanation available when compiling with `-explain`
+-- [E178] Type Error: tests/neg/i16820.scala:11:14 ---------------------------------------------------------------------
 11 |def test = Foo(3)  // error
    |           ^^^^^^
-   |           missing arguments for method apply in object Foo
+   |           missing argument list for method apply in object Foo
+   |
+   |             def apply(x: Int)(xs: String*): Foo
+   |
+   | longer explanation available when compiling with `-explain`
diff --git a/tests/neg/i17123.check b/tests/neg/i17123.check
new file mode 100644
index 000000000000..e858de67b73a
--- /dev/null
+++ b/tests/neg/i17123.check
@@ -0,0 +1,86 @@
+-- [E100] Syntax Error: tests/neg/i17123.scala:7:2 ---------------------------------------------------------------------
+7 |  m1 // error
+  |  ^^
+  |  method m1 in object ConfusingErrorMessage must be called with () argument
+  |
+  | longer explanation available when compiling with `-explain`
+-- [E178] Type Error: tests/neg/i17123.scala:9:2 -----------------------------------------------------------------------
+9 |  m2 // error
+  |  ^^
+  |  missing argument list for method m2 in object ConfusingErrorMessage
+  |
+  |    def m2()(): Unit
+  |
+  | longer explanation available when compiling with `-explain`
+-- [E178] Type Error: tests/neg/i17123.scala:10:4 ----------------------------------------------------------------------
+10 |  m2() // error
+   |  ^^^^
+   |  missing argument list for method m2 in object ConfusingErrorMessage
+   |
+   |    def m2()(): Unit
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E178] Type Error: tests/neg/i17123.scala:11:2 ----------------------------------------------------------------------
+11 |  m3 // error
+   |  ^^
+   |  missing argument list for method m3 in object ConfusingErrorMessage
+   |
+   |    def m3()()(): Unit
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E178] Type Error: tests/neg/i17123.scala:12:4 ----------------------------------------------------------------------
+12 |  m3() // error
+   |  ^^^^
+   |  missing argument list for method m3 in object ConfusingErrorMessage
+   |
+   |    def m3()()(): Unit
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E178] Type Error: tests/neg/i17123.scala:13:6 ----------------------------------------------------------------------
+13 |  m3()() // error
+   |  ^^^^^^
+   |  missing argument list for method m3 in object ConfusingErrorMessage
+   |
+   |    def m3()()(): Unit
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E178] Type Error: tests/neg/i17123.scala:15:2 ----------------------------------------------------------------------
+15 |  f3 // error
+   |  ^^
+   |  missing argument list for method f3 in object ConfusingErrorMessage
+   |
+   |    def f3()(i: Int)(): Unit
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E178] Type Error: tests/neg/i17123.scala:16:2 ----------------------------------------------------------------------
+16 |  f3() // error
+   |  ^^^^
+   |  missing argument list for method f3 in object ConfusingErrorMessage
+   |
+   |    def f3()(i: Int)(): Unit
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E178] Type Error: tests/neg/i17123.scala:17:6 ----------------------------------------------------------------------
+17 |  f3()(2) // error
+   |  ^^^^^^^
+   |  missing argument list for method f3 in object ConfusingErrorMessage
+   |
+   |    def f3()(i: Int)(): Unit
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E178] Type Error: tests/neg/i17123.scala:19:2 ----------------------------------------------------------------------
+19 |  i3 // error
+   |  ^^
+   |  missing argument list for method i3 in object ConfusingErrorMessage
+   |
+   |    def i3()(using d: DummyImplicit)(): Unit
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E178] Type Error: tests/neg/i17123.scala:20:2 ----------------------------------------------------------------------
+20 |  i3() // error
+   |  ^^^^
+   |  missing argument list for method i3 in object ConfusingErrorMessage
+   |
+   |    def i3()(using d: DummyImplicit)(): Unit
+   |
+   | longer explanation available when compiling with `-explain`
diff --git a/tests/neg/i17123.scala b/tests/neg/i17123.scala
new file mode 100644
index 000000000000..6547a375fec3
--- /dev/null
+++ b/tests/neg/i17123.scala
@@ -0,0 +1,22 @@
+object ConfusingErrorMessage {
+  def m1() = ()
+  def m2()() = ()
+  def m3()()() = ()
+  def f3()(i: Int)() = ()
+  def i3()(using d: DummyImplicit)() = ()
+  m1 // error
+  m1()
+  m2 // error
+  m2() // error
+  m3 // error
+  m3() // error
+  m3()() // error
+  m3()()()
+  f3 // error
+  f3() // error
+  f3()(2) // error
+  f3()(2)()
+  i3 // error
+  i3() // error
+  i3()()
+}
diff --git a/tests/neg/i7816.scala b/tests/neg/i7816.scala
index f1eed694a085..41dd6c2ea98e 100644
--- a/tests/neg/i7816.scala
+++ b/tests/neg/i7816.scala
@@ -1,4 +1,4 @@
 object A {
     def f()(>) = ???     // error
-    import f.NonExistent // error
+    import f.NonExistent
 }
\ No newline at end of file
diff --git a/tests/neg/indent-colons.check b/tests/neg/indent-colons.check
index 102d41592014..f77d491f8b8f 100644
--- a/tests/neg/indent-colons.check
+++ b/tests/neg/indent-colons.check
@@ -47,15 +47,31 @@
    |             Not found: file
    |
    | longer explanation available when compiling with `-explain`
--- Error: tests/neg/indent-colons.scala:5:2 ----------------------------------------------------------------------------
+-- [E178] Type Error: tests/neg/indent-colons.scala:5:2 ----------------------------------------------------------------
 5 |  tryEither:  // error
   |  ^^^^^^^^^
-  |  missing arguments for method tryEither
--- Error: tests/neg/indent-colons.scala:11:2 ---------------------------------------------------------------------------
+  |  missing argument list for method tryEither
+  |
+  |    def tryEither[T](x: T)(y: Int => T): T
+  |
+  |  where:    T is a type variable
+  |
+  | longer explanation available when compiling with `-explain`
+-- [E178] Type Error: tests/neg/indent-colons.scala:11:2 ---------------------------------------------------------------
 11 |  tryEither:  // error
    |  ^^^^^^^^^
-   |  missing arguments for method tryEither
--- Error: tests/neg/indent-colons.scala:18:2 ---------------------------------------------------------------------------
+   |  missing argument list for method tryEither
+   |
+   |    def tryEither[T](x: T)(y: Int => T): T
+   |
+   |  where:    T is a type variable
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E178] Type Error: tests/neg/indent-colons.scala:18:2 ---------------------------------------------------------------
 18 |  Some(3).fold:  // error
    |  ^^^^^^^^^^^^
-   |  missing arguments for method fold in class Option
+   |  missing argument list for method fold in class Option
+   |
+   |    final def fold[B](ifEmpty: => B)(f: A => B): B
+   |
+   | longer explanation available when compiling with `-explain`

From 3420f1b400af1b1ba8f3e51bc384c718156f041d Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Fri, 17 Mar 2023 16:53:20 +0100
Subject: [PATCH 340/657] Improve highlight of decl

---
 compiler/src/dotty/tools/dotc/core/Contexts.scala           | 6 ++++++
 compiler/src/dotty/tools/dotc/inlines/Inlines.scala         | 3 +--
 compiler/src/dotty/tools/dotc/reporting/messages.scala      | 2 +-
 compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala     | 2 +-
 .../dotty/tools/dotc/printing/SyntaxHighlightingTests.scala | 3 +--
 .../test/dotty/tools/dotc/reporting/ErrorMessagesTest.scala | 2 +-
 6 files changed, 11 insertions(+), 7 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/Contexts.scala b/compiler/src/dotty/tools/dotc/core/Contexts.scala
index 2f28975dd066..e0e43169820a 100644
--- a/compiler/src/dotty/tools/dotc/core/Contexts.scala
+++ b/compiler/src/dotty/tools/dotc/core/Contexts.scala
@@ -444,6 +444,12 @@ object Contexts {
     def useColors: Boolean =
       base.settings.color.value == "always"
 
+    def withColors: FreshContext =
+      fresh.setSetting(ctx.settings.color, "always")
+
+    def withoutColors: FreshContext =
+      fresh.setSetting(ctx.settings.color, "never")
+
     /** Is the explicit nulls option set? */
     def explicitNulls: Boolean = base.settings.YexplicitNulls.value
 
diff --git a/compiler/src/dotty/tools/dotc/inlines/Inlines.scala b/compiler/src/dotty/tools/dotc/inlines/Inlines.scala
index f504a4034631..36dc8a642afc 100644
--- a/compiler/src/dotty/tools/dotc/inlines/Inlines.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/Inlines.scala
@@ -381,8 +381,7 @@ object Inlines:
 
     /** 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)
+      Literal(Constant(arg.show(using ctx.withoutColors))).withSpan(pos.span)
   end Intrinsics
 
   /** Produces an inlined version of `call` via its `inlined` method.
diff --git a/compiler/src/dotty/tools/dotc/reporting/messages.scala b/compiler/src/dotty/tools/dotc/reporting/messages.scala
index fe2df5ca6016..fba08fd84d0c 100644
--- a/compiler/src/dotty/tools/dotc/reporting/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/messages.scala
@@ -1504,7 +1504,7 @@ class MissingArgument(pname: Name, methString: String)(using Context)
 class MissingArgumentList(method: String, sym: Symbol)(using Context)
   extends TypeMsg(MissingArgumentListID) {
   def msg(using Context) =
-    val symDcl = if sym.exists then "\n\n  " + sym.showDcl else ""
+    val symDcl = if sym.exists then "\n\n  " + hl(sym.showDcl(using ctx.withoutColors)) else ""
     i"missing argument list for $method$symDcl"
   def explain(using Context) = {
     i"""Unapplied methods are only converted to functions when a function type is expected."""
diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
index a575238f7cd4..1949304ca287 100644
--- a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
+++ b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
@@ -3080,7 +3080,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
       lazy val ConstantCode: Printer[Constant] = new Printer[Constant]:
         def show(const: Constant): String =
-          const.show(using ctx.fresh.setSetting(ctx.settings.color, "never"))
+          const.show(using ctx.withoutColors)
 
       lazy val ConstantStructure: Printer[Constant] = new Printer[Constant]:
         def show(const: Constant): String =
diff --git a/compiler/test/dotty/tools/dotc/printing/SyntaxHighlightingTests.scala b/compiler/test/dotty/tools/dotc/printing/SyntaxHighlightingTests.scala
index 2f35ccb35434..2e4b7bf1bb3f 100644
--- a/compiler/test/dotty/tools/dotc/printing/SyntaxHighlightingTests.scala
+++ b/compiler/test/dotty/tools/dotc/printing/SyntaxHighlightingTests.scala
@@ -12,8 +12,7 @@ class SyntaxHighlightingTests extends DottyTest {
   import SyntaxHighlighting._
 
   private def test(source: String, expected: String): Unit = {
-    val testCtx = ctx.fresh.setSetting(ctx.settings.color, "always")
-    val highlighted = SyntaxHighlighting.highlight(source)(using testCtx)
+    val highlighted = SyntaxHighlighting.highlight(source)(using ctx.withColors)
       .replace(NoColor,         ">")
       .replace(CommentColor,    "<C|")
       .replace(KeywordColor,    "<K|")
diff --git a/compiler/test/dotty/tools/dotc/reporting/ErrorMessagesTest.scala b/compiler/test/dotty/tools/dotc/reporting/ErrorMessagesTest.scala
index 5d3a7994cc47..33c740d3edf8 100644
--- a/compiler/test/dotty/tools/dotc/reporting/ErrorMessagesTest.scala
+++ b/compiler/test/dotty/tools/dotc/reporting/ErrorMessagesTest.scala
@@ -12,7 +12,7 @@ trait ErrorMessagesTest extends DottyTest {
   protected def newContext = {
     val rep = new StoreReporter(null)
               with UniqueMessagePositions with HideNonSensicalMessages
-    initialCtx.setReporter(rep).setSetting(ctx.settings.color, "never")
+    initialCtx.setReporter(rep).withoutColors
   }
 
   class Report(messages: List[Message], ictx: Context) {

From 83eabc32dd3cfe5edf3ac00eeecf455a12c37c71 Mon Sep 17 00:00:00 2001
From: Lucas <leblanc.lucas29@gmail.com>
Date: Mon, 3 Apr 2023 15:34:59 +0200
Subject: [PATCH 341/657] Add scrollbar to the content and sidebar

---
 .../resources/dotty_res/styles/theme/layout/container.css   | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/scaladoc/resources/dotty_res/styles/theme/layout/container.css b/scaladoc/resources/dotty_res/styles/theme/layout/container.css
index d71c75e8bda0..a5210210c420 100644
--- a/scaladoc/resources/dotty_res/styles/theme/layout/container.css
+++ b/scaladoc/resources/dotty_res/styles/theme/layout/container.css
@@ -20,6 +20,10 @@ p {
 }
 
 ::-webkit-scrollbar {
-  width: 0;
+  width: 5;
   background: transparent;
 }
+
+::-webkit-scrollbar-thumb {
+  background: black;
+}

From 67e70fe3a9ae7d3525cef78e69dd66e7b9802a5b Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Mon, 3 Apr 2023 15:53:05 +0200
Subject: [PATCH 342/657] Fix wunused for deriving alias type that has a
 different name

---
 .../src/dotty/tools/dotc/transform/CheckUnused.scala  |  7 +++++--
 libste                                                |  0
 tests/neg-custom-args/fatal-warnings/i15503i.scala    | 11 +++++++++++
 3 files changed, 16 insertions(+), 2 deletions(-)
 delete mode 100644 libste

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index 6fc11d3ab007..6943fb1b12e6 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -590,9 +590,12 @@ object CheckUnused:
       private def isInImport(imp: tpd.Import, isAccessible: Boolean, symName: Option[Name])(using Context): Option[ImportSelector] =
         val tpd.Import(qual, sels) = imp
         val dealiasedSym = dealias(sym)
-        val qualHasSymbol = qual.tpe.member(sym.name).alternatives.map(_.symbol).map(dealias).contains(dealiasedSym)
+        val typeSelections = sels.flatMap(n => qual.tpe.member(n.name.toTypeName).alternatives)
+        val termSelections = sels.flatMap(n => qual.tpe.member(n.name.toTermName).alternatives)
+        val allSelections = typeSelections ::: termSelections :::qual.tpe.member(sym.name).alternatives
+        val qualHasSymbol = allSelections.map(_.symbol).map(dealias).contains(dealiasedSym)
         def selector = sels.find(sel => (sel.name.toTermName == sym.name || sel.name.toTypeName == sym.name) && symName.map(n => n.toTermName == sel.rename).getOrElse(true))
-        def dealiasedSelector = sels.flatMap(sel => qual.tpe.member(sym.name).alternatives.map(m => (sel, m.symbol))).collect {
+        def dealiasedSelector = sels.flatMap(sel => allSelections.map(m => (sel, m.symbol))).collect {
           case (sel, sym) if dealias(sym) == dealiasedSym => sel
         }.headOption
         def wildcard = sels.find(sel => sel.isWildcard && ((sym.is(Given) == sel.isGiven) || sym.is(Implicit)))
diff --git a/libste b/libste
deleted file mode 100644
index e69de29bb2d1..000000000000
diff --git a/tests/neg-custom-args/fatal-warnings/i15503i.scala b/tests/neg-custom-args/fatal-warnings/i15503i.scala
index 9ac2ec5ef622..a76f96b3c89b 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503i.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503i.scala
@@ -273,3 +273,14 @@ package foo.test.i16679b:
     import Foo.x
     case class CoolClass(i: Int)
     println(summon[myPackage.CaseClassName[CoolClass]])
+
+package foo.test.i17156:
+  package a:
+    trait Foo[A]
+
+  package b:
+    type Xd = Foo
+
+  package c:
+    import b.Xd
+    trait Z derives Xd

From c7a5d0b0e6d7f541ac1133a7866116a381507ccf Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Mon, 3 Apr 2023 19:45:58 +0200
Subject: [PATCH 343/657] Fix test for wunused alias deriving

---
 tests/neg-custom-args/fatal-warnings/i15503i.scala | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/tests/neg-custom-args/fatal-warnings/i15503i.scala b/tests/neg-custom-args/fatal-warnings/i15503i.scala
index a76f96b3c89b..737e5f0739ca 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503i.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503i.scala
@@ -277,9 +277,12 @@ package foo.test.i16679b:
 package foo.test.i17156:
   package a:
     trait Foo[A]
+    object Foo:
+      inline def derived[T]: Foo[T] = new Foo{}
 
   package b:
-    type Xd = Foo
+    import a.Foo
+    type Xd[A] = Foo[A]
 
   package c:
     import b.Xd

From e1ab97e66711f847890c6b662be212dad9dd21ba Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 4 Apr 2023 09:37:52 +0200
Subject: [PATCH 344/657] Remove trailing whitespace

---
 .github/PULL_REQUEST_TEMPLATE/fix-issue.md       |  6 +++---
 .github/PULL_REQUEST_TEMPLATE/other-pr.md        |  6 +++---
 .github/workflows/releases.yml                   |  4 ++--
 .github/workflows/scripts/publish-sdkman.sh      |  4 ++--
 .../benchmarks/lazyvals/InitializedAccess.scala  |  2 +-
 .../lazyvals/InitializedAccessAny.scala          |  2 +-
 .../lazyvals/InitializedAccessGeneric.scala      |  2 +-
 .../lazyvals/InitializedAccessString.scala       |  2 +-
 .../tools/benchmarks/lazyvals/LazyVals.scala     |  2 +-
 compiler/src/dotty/tools/dotc/Compiler.scala     |  2 +-
 compiler/src/dotty/tools/dotc/cc/Setup.scala     |  2 +-
 .../src/dotty/tools/dotc/core/Annotations.scala  |  4 ++--
 .../src/dotty/tools/dotc/parsing/Parsers.scala   | 16 ++++++++--------
 .../dotty/tools/dotc/transform/LazyVals.scala    |  4 ++--
 compiler/src/dotty/tools/dotc/util/lrutest.sc    |  6 +++---
 compiler/src/dotty/tools/io/JDK9Reflectors.java  |  2 +-
 .../dotty/tools/runner/ScalaClassLoader.scala    |  2 +-
 compiler/test/worksheets/baseTypetest.sc         |  2 +-
 compiler/test/worksheets/denotTest.sc            |  4 ++--
 compiler/test/worksheets/nesting.sc              |  8 ++++----
 compiler/test/worksheets/periodtest.sc           |  4 ++--
 compiler/test/worksheets/positiontest.sc         |  2 +-
 compiler/test/worksheets/testnames.sc            |  8 ++++----
 library/src/scala/runtime/LazyVals.scala         |  2 +-
 .../sbt-dotty/tasty-inspector-jars/build.sbt     |  2 +-
 .../implicit-search/changes/A1.scala             |  2 +-
 sbt-test/source-dependencies/java-static/test    |  2 +-
 .../restore-classes/changes/A2.scala             |  2 +-
 .../src/example/typeAndObjects/binaryops.scala   |  2 +-
 scaladoc-testcases/src/tests/contextBounds.scala |  6 +++---
 .../src/tests/snippetComments.scala              |  4 ++--
 31 files changed, 59 insertions(+), 59 deletions(-)

diff --git a/.github/PULL_REQUEST_TEMPLATE/fix-issue.md b/.github/PULL_REQUEST_TEMPLATE/fix-issue.md
index 506996510c7e..f7cf22eb59c7 100644
--- a/.github/PULL_REQUEST_TEMPLATE/fix-issue.md
+++ b/.github/PULL_REQUEST_TEMPLATE/fix-issue.md
@@ -6,14 +6,14 @@ assignees: ''
 
 ---
 
-<!-- 
-  TODO first sign the CLA 
+<!--
+  TODO first sign the CLA
   https://www.lightbend.com/contribute/cla/scala
 -->
 
 ## Fix #XYZ
 
-<!-- TODO description of the change --> 
+<!-- TODO description of the change -->
 
 
 <!-- Ideally should have a called "Fix #XYZ: A SHORT FIX DESCRIPTION" -->
diff --git a/.github/PULL_REQUEST_TEMPLATE/other-pr.md b/.github/PULL_REQUEST_TEMPLATE/other-pr.md
index 4b69a80460af..fad49836df92 100644
--- a/.github/PULL_REQUEST_TEMPLATE/other-pr.md
+++ b/.github/PULL_REQUEST_TEMPLATE/other-pr.md
@@ -6,14 +6,14 @@ assignees: ''
 
 ---
 
-<!-- 
-  TODO first sign the CLA 
+<!--
+  TODO first sign the CLA
   https://www.lightbend.com/contribute/cla/scala
 -->
 
 ## Description
 
-<!-- TODO description of the change --> 
+<!-- TODO description of the change -->
 
 
 <!-- Ideally should have a single commit -->
diff --git a/.github/workflows/releases.yml b/.github/workflows/releases.yml
index 7415759078ac..ba4bae0456d0 100644
--- a/.github/workflows/releases.yml
+++ b/.github/workflows/releases.yml
@@ -13,9 +13,9 @@ jobs:
       options: --cpu-shares 4096
 
     env:
-      SDKMAN_KEY: ${{ secrets.SDKMAN_KEY }} 
+      SDKMAN_KEY: ${{ secrets.SDKMAN_KEY }}
       SDKMAN_TOKEN: ${{ secrets.SDKMAN_TOKEN }}
-      
+
     steps:
       - name: Reset existing repo
         run: git -c "http.https://github.com/.extraheader=" fetch --recurse-submodules=no "https://github.com/lampepfl/dotty" && git reset --hard FETCH_HEAD || true
diff --git a/.github/workflows/scripts/publish-sdkman.sh b/.github/workflows/scripts/publish-sdkman.sh
index 07d35a72a65e..70987bff175b 100755
--- a/.github/workflows/scripts/publish-sdkman.sh
+++ b/.github/workflows/scripts/publish-sdkman.sh
@@ -9,11 +9,11 @@
 
 set -u
 
-# latest stable dotty version 
+# latest stable dotty version
 DOTTY_VERSION=$(curl -s https://api.github.com/repos/lampepfl/dotty/releases/latest  | grep '"tag_name":' | sed -E 's/.*"([^"]+)".*/\1/')
 DOTTY_URL="https://github.com/lampepfl/dotty/releases/download/$DOTTY_VERSION/scala3-$DOTTY_VERSION.zip"
 
-# checking if dotty version is available 
+# checking if dotty version is available
 if ! curl --output /dev/null --silent --head --fail "$DOTTY_URL"; then
   echo "URL doesn't exist: $DOTTY_URL"
   exit 1
diff --git a/bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/InitializedAccess.scala b/bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/InitializedAccess.scala
index a2aaf3e88570..d413458d0049 100644
--- a/bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/InitializedAccess.scala
+++ b/bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/InitializedAccess.scala
@@ -18,7 +18,7 @@ class InitializedAccess {
 
   @Setup
   def prepare: Unit = {
-    holder = new LazyHolder 
+    holder = new LazyHolder
     holder.value
   }
 
diff --git a/bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/InitializedAccessAny.scala b/bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/InitializedAccessAny.scala
index 5a6b4ae1686d..8c75f6bb11a2 100644
--- a/bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/InitializedAccessAny.scala
+++ b/bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/InitializedAccessAny.scala
@@ -18,7 +18,7 @@ class InitializedAccessAny {
 
   @Setup
   def prepare: Unit = {
-    holder = new LazyAnyHolder 
+    holder = new LazyAnyHolder
     holder.value
   }
 
diff --git a/bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/InitializedAccessGeneric.scala b/bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/InitializedAccessGeneric.scala
index a95cb1de2980..a9fecae6281e 100644
--- a/bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/InitializedAccessGeneric.scala
+++ b/bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/InitializedAccessGeneric.scala
@@ -18,7 +18,7 @@ class InitializedAccessGeneric {
 
   @Setup
   def prepare: Unit = {
-    holder = new LazyGenericHolder[String]("foo") 
+    holder = new LazyGenericHolder[String]("foo")
     holder.value
   }
 
diff --git a/bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/InitializedAccessString.scala b/bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/InitializedAccessString.scala
index 25cc0f9b288d..e6c6cd5eb2e3 100644
--- a/bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/InitializedAccessString.scala
+++ b/bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/InitializedAccessString.scala
@@ -18,7 +18,7 @@ class InitializedAccessString {
 
   @Setup
   def prepare: Unit = {
-    holder = new LazyStringHolder 
+    holder = new LazyStringHolder
     holder.value
   }
 
diff --git a/bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/LazyVals.scala b/bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/LazyVals.scala
index 68379f9e142c..26ebb7b9d356 100644
--- a/bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/LazyVals.scala
+++ b/bench-micro/src/main/scala/dotty/tools/benchmarks/lazyvals/LazyVals.scala
@@ -21,7 +21,7 @@ object LazyVals {
             }
         }
     }
-    
+
     class LazyHolder {
 
         lazy val value: List[Int] = {
diff --git a/compiler/src/dotty/tools/dotc/Compiler.scala b/compiler/src/dotty/tools/dotc/Compiler.scala
index b03953afb37c..db3d42d32190 100644
--- a/compiler/src/dotty/tools/dotc/Compiler.scala
+++ b/compiler/src/dotty/tools/dotc/Compiler.scala
@@ -89,7 +89,7 @@ class Compiler {
          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
-         new DropBreaks) ::          // Optimize local Break throws by rewriting them 
+         new DropBreaks) ::          // Optimize local Break throws by rewriting them
     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
diff --git a/compiler/src/dotty/tools/dotc/cc/Setup.scala b/compiler/src/dotty/tools/dotc/cc/Setup.scala
index 5642ea99de1a..fc16422e1373 100644
--- a/compiler/src/dotty/tools/dotc/cc/Setup.scala
+++ b/compiler/src/dotty/tools/dotc/cc/Setup.scala
@@ -262,7 +262,7 @@ extends tpd.TreeTraverser:
       // hard-coded expansion since $throws aliases in stdlib are defined with `?=>` rather than `?->`
       defn.FunctionOf(
         AnnotatedType(
-          defn.CanThrowClass.typeRef.appliedTo(exc), 
+          defn.CanThrowClass.typeRef.appliedTo(exc),
           Annotation(defn.ErasedParamAnnot, defn.CanThrowClass.span)) :: Nil,
         res,
         isContextual = true
diff --git a/compiler/src/dotty/tools/dotc/core/Annotations.scala b/compiler/src/dotty/tools/dotc/core/Annotations.scala
index 3b00f2915f1c..202f3eb26e41 100644
--- a/compiler/src/dotty/tools/dotc/core/Annotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/Annotations.scala
@@ -194,7 +194,7 @@ object Annotations {
   object Annotation {
 
     def apply(tree: Tree): ConcreteAnnotation = ConcreteAnnotation(tree)
-    
+
     def apply(cls: ClassSymbol, span: Span)(using Context): Annotation =
       apply(cls, Nil, span)
 
@@ -206,7 +206,7 @@ object Annotations {
 
     def apply(atp: Type, arg: Tree, span: Span)(using Context): Annotation =
       apply(atp, arg :: Nil, span)
-    
+
     def apply(atp: Type, args: List[Tree], span: Span)(using Context): Annotation =
       apply(New(atp, args).withSpan(span))
 
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index d1b0c6cba097..15a639743c15 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -3129,8 +3129,8 @@ object Parsers {
  /* -------- PARAMETERS ------------------------------------------- */
 
     /** DefParamClauses       ::= DefParamClause { DefParamClause }  -- and two DefTypeParamClause cannot be adjacent
-     *  DefParamClause        ::= DefTypeParamClause 
-     *                          | DefTermParamClause 
+     *  DefParamClause        ::= DefTypeParamClause
+     *                          | DefTermParamClause
      *                          | UsingParamClause
      */
     def typeOrTermParamClauses(
@@ -3228,7 +3228,7 @@ object Parsers {
      *  UsingClsTermParamClause::= ‘(’ ‘using’ [‘erased’] (ClsParams | ContextTypes) ‘)’
      *  ClsParams         ::=  ClsParam {‘,’ ClsParam}
      *  ClsParam          ::=  {Annotation}
-     * 
+     *
      *  TypelessClause    ::= DefTermParamClause
      *                      | UsingParamClause
      *
@@ -3616,13 +3616,13 @@ object Parsers {
       }
     }
 
-    
+
 
     /** DefDef  ::=  DefSig [‘:’ Type] ‘=’ Expr
      *            |  this TypelessClauses [DefImplicitClause] `=' ConstrExpr
      *  DefDcl  ::=  DefSig `:' Type
      *  DefSig  ::=  id [DefTypeParamClause] DefTermParamClauses
-     * 
+     *
      * if clauseInterleaving is enabled:
      *  DefSig  ::=  id [DefParamClauses] [DefImplicitClause]
      */
@@ -3661,8 +3661,8 @@ object Parsers {
         val mods1 = addFlag(mods, Method)
         val ident = termIdent()
         var name = ident.name.asTermName
-        val paramss = 
-          if in.featureEnabled(Feature.clauseInterleaving) then 
+        val paramss =
+          if in.featureEnabled(Feature.clauseInterleaving) then
             // If you are making interleaving stable manually, please refer to the PR introducing it instead, section "How to make non-experimental"
             typeOrTermParamClauses(ParamOwner.Def, numLeadParams = numLeadParams)
           else
@@ -3672,7 +3672,7 @@ object Parsers {
             joinParams(tparams, vparamss)
 
         var tpt = fromWithinReturnType { typedOpt() }
-        
+
         if (migrateTo3) newLineOptWhenFollowedBy(LBRACE)
         val rhs =
           if in.token == EQUALS then
diff --git a/compiler/src/dotty/tools/dotc/transform/LazyVals.scala b/compiler/src/dotty/tools/dotc/transform/LazyVals.scala
index e4cb21a279d6..b433e37e39c0 100644
--- a/compiler/src/dotty/tools/dotc/transform/LazyVals.scala
+++ b/compiler/src/dotty/tools/dotc/transform/LazyVals.scala
@@ -283,7 +283,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
    *
    * ```
    * private @volatile var _x: AnyRef = null
-   * 
+   *
    * def x: A =
    *   val result = _x
    *   if result.isInstanceOf[A] then
@@ -292,7 +292,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
    *     null // possible unboxing applied here
    *   else
    *     x_compute() // possible unboxing applied here
-   * 
+   *
    * private def x_compute(): AnyRef =
    *   while <EmptyTree> do
    *     val current: AnyRef = _x
diff --git a/compiler/src/dotty/tools/dotc/util/lrutest.sc b/compiler/src/dotty/tools/dotc/util/lrutest.sc
index 6e6328b248e3..9c811a65a70a 100644
--- a/compiler/src/dotty/tools/dotc/util/lrutest.sc
+++ b/compiler/src/dotty/tools/dotc/util/lrutest.sc
@@ -15,12 +15,12 @@ object lrutest {
 	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)
@@ -35,6 +35,6 @@ object lrutest {
                                                   //| > 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 
+  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/compiler/src/dotty/tools/io/JDK9Reflectors.java b/compiler/src/dotty/tools/io/JDK9Reflectors.java
index 1b0ce5deabab..9816cc03f92a 100644
--- a/compiler/src/dotty/tools/io/JDK9Reflectors.java
+++ b/compiler/src/dotty/tools/io/JDK9Reflectors.java
@@ -32,7 +32,7 @@ public final class JDK9Reflectors {
     }
 
     // Classes from java.lang.Runtime are not available in JDK 8 so using them explicitly would prevent this file from compiling with JDK 8
-    // but these methods are not called in runtime when using this version of JDK 
+    // but these methods are not called in runtime when using this version of JDK
 
     public static /*java.lang.Runtime.Version*/ Object runtimeVersionParse(String string) {
         try {
diff --git a/compiler/src/dotty/tools/runner/ScalaClassLoader.scala b/compiler/src/dotty/tools/runner/ScalaClassLoader.scala
index 3c8c51d8d6b2..9ec0199abcbb 100644
--- a/compiler/src/dotty/tools/runner/ScalaClassLoader.scala
+++ b/compiler/src/dotty/tools/runner/ScalaClassLoader.scala
@@ -67,7 +67,7 @@ object ScalaClassLoader {
   @sharable private[this] val bootClassLoader: ClassLoader =
     if scala.util.Properties.isJavaAtLeast("9") then
       try
-        ClassLoader.getSystemClassLoader.getParent 
+        ClassLoader.getSystemClassLoader.getParent
       catch case _: Throwable => null
     else null
 
diff --git a/compiler/test/worksheets/baseTypetest.sc b/compiler/test/worksheets/baseTypetest.sc
index 001f1e3b3eaa..4dbd68a6fdc7 100644
--- a/compiler/test/worksheets/baseTypetest.sc
+++ b/compiler/test/worksheets/baseTypetest.sc
@@ -22,5 +22,5 @@ object baseTypetest extends DottyTest {
   defn.StringClass isSubClass defn.NullClass      //> res4: Boolean = false
   defn.StringClass.typeRef.baseType(defn.NullClass)
                                                   //> res5: dotty.tools.dotc.core.Types.Type = NoType
-                                                  
+
 }
\ No newline at end of file
diff --git a/compiler/test/worksheets/denotTest.sc b/compiler/test/worksheets/denotTest.sc
index 222a347b6947..aa3fb383bd6f 100644
--- a/compiler/test/worksheets/denotTest.sc
+++ b/compiler/test/worksheets/denotTest.sc
@@ -7,7 +7,7 @@ import Types._, Symbols._
 
 object denotTest extends DottyTest {
   println("Welcome to the Scala worksheet")       //> Welcome to the Scala worksheet
-  
+
   val str = defn.StringClass.typeRef              //> str  : dotty.tools.dotc.core.Types.TypeRef = TypeRef(ThisType(module class l
                                                   //| ang#57),String)
   val d= str.member("getBytes".toTermName)        //> d  : dotty.tools.dotc.core.Denotations.Denotation = val getBytes <and> val g
@@ -47,7 +47,7 @@ object denotTest extends DottyTest {
                                                   //| a#35),Array), scala$Array$$T, TypeAlias(TypeRef(ThisType(module class scala#
                                                   //| 35),Char))), TypeRef(ThisType(module class scala#35),Int), TypeRef(ThisType(
                                                   //| module class scala#35),Int)), TypeRef(ThisType(module class lang#57),String)
-                                                  //| ), JavaMethodType(List(x$0), List(RefinedType(TypeRef(ThisType(module class 
+                                                  //| ), JavaMethodType(List(x$0), List(RefinedType(TypeRef(ThisType(module class
                                                   //| scala#35),Array), scala$Array$$T, TypeAlias(TypeRef(ThisType(module class sc
                                                   //| ala#35),Char)))), TypeRef(ThisType(module class lang#57),String)), JavaMetho
                                                   //| dType(List(x$0), List(TypeRef(ThisType(module class scala#35),Any)), TypeRef
diff --git a/compiler/test/worksheets/nesting.sc b/compiler/test/worksheets/nesting.sc
index a6fc924320a0..bb3e9a71146e 100644
--- a/compiler/test/worksheets/nesting.sc
+++ b/compiler/test/worksheets/nesting.sc
@@ -2,7 +2,7 @@ package dotty.tools.dotc.core
 
 object nesting {
   class C {
-  
+
     class D {
     	private def x = "D"
     	def show = x
@@ -10,7 +10,7 @@ object nesting {
     		println(x)
     	}
     }
-    
+
     val foo: D = {
     	class D extends C.this.D {
     		private def x = "foo.D"
@@ -21,11 +21,11 @@ object nesting {
       new D
     }
   }
-  
+
   val c = new C                                   //> c  : dotty.tools.dotc.core.nesting.C = dotty.tools.dotc.core.nesting$C@1a84d
                                                   //| a23
   val d = c.foo                                   //> d  : dotty.tools.dotc.core.nesting.c.D = dotty.tools.dotc.core.nesting$C$D$1
                                                   //| @2705d88a
   d.show                                          //> res0: String = foo.D
-  
+
 }
\ No newline at end of file
diff --git a/compiler/test/worksheets/periodtest.sc b/compiler/test/worksheets/periodtest.sc
index 09c02da19a10..68a7cc43b20e 100644
--- a/compiler/test/worksheets/periodtest.sc
+++ b/compiler/test/worksheets/periodtest.sc
@@ -2,9 +2,9 @@ package dotty.tools.dotc.core
 
 object periodtest {
   println("Welcome to the Scala worksheet")       //> Welcome to the Scala worksheet
-  
+
   import Periods._
-  
+
   val p1 = Period(1, 2, 7)                        //> p1  : dotty.tools.dotc.core.Periods.Period = Period(2..7, run = 1)
   val p2 = Period(1, 3, 7)                        //> p2  : dotty.tools.dotc.core.Periods.Period = Period(3..7, run = 1)
   p1 contains p2                                  //> res0: Boolean = true
diff --git a/compiler/test/worksheets/positiontest.sc b/compiler/test/worksheets/positiontest.sc
index 11cc54dbeab9..b152368145f1 100644
--- a/compiler/test/worksheets/positiontest.sc
+++ b/compiler/test/worksheets/positiontest.sc
@@ -5,7 +5,7 @@ import Positions._
 
 object positiontest {
   println("Welcome to the Scala worksheet")       //> Welcome to the Scala worksheet
-  
+
   val p = Position(0, 1, 0)                       //> p  : dotty.tools.dotc.util.Positions.Position = [0..1]
   val p2 = Position(0, 2)                         //> p2  : dotty.tools.dotc.util.Positions.Position = [0..2]
   val p3 = Position(1, 0)                         //> p3  : dotty.tools.dotc.util.Positions.Position = [no position]
diff --git a/compiler/test/worksheets/testnames.sc b/compiler/test/worksheets/testnames.sc
index 282b07d4edb7..8f042b7036fd 100644
--- a/compiler/test/worksheets/testnames.sc
+++ b/compiler/test/worksheets/testnames.sc
@@ -2,7 +2,7 @@ package dotty.tools.dotc.core
 
 object testnames {
   println("Welcome to the Scala worksheet")       //> Welcome to the Scala worksheet
-  
+
   import Names._
   val n = termName("hello")                       //> n  : dotty.tools.dotc.core.Names.TermName = hello
   val tn = n.toTypeName                           //> tn  : dotty.tools.dotc.core.Names.TypeName = hello
@@ -10,7 +10,7 @@ object testnames {
   assert(tn.toTermName eq n)
   assert(tn.toLocalName eq ln)
   assert(n.toLocalName eq ln)
-  
+
   n == tn                                         //> res0: Boolean = false
   n == ln                                         //> res1: Boolean = false
   n eq tn                                         //> res2: Boolean = false
@@ -19,7 +19,7 @@ object testnames {
   val foo = encodedTermName("++")                 //> foo  : dotty.tools.dotc.core.Names.TermName = $plus$plus
   foo.hashCode                                    //> res5: Int = 5
   foo.toTypeName.hashCode                         //> res6: Int = -5
-  
+
   val nfoo = n ++ foo                             //> nfoo  : dotty.tools.dotc.core.testnames.n.ThisName = hello$plus$plus
   nfoo contains '$'                               //> res7: Boolean = true
   nfoo.replace('$', '.')                          //> res8: dotty.tools.dotc.core.testnames.nfoo.ThisName = hello.plus.plus
@@ -36,7 +36,7 @@ object testnames {
   termName("abc")                                 //> res18: dotty.tools.dotc.core.Names.TermName = abc
   nfoo.filter(_ >= 'l')                           //> res19: dotty.tools.dotc.core.Names.Name = lloplusplus
   nfoo map (_.toUpper)                            //> res20: dotty.tools.dotc.core.Names.Name = HELLO$PLUS$PLUS
-  
+
   import Decorators._
 
   val local = "local".toTermName.toLocalName      //> local  : dotty.tools.dotc.core.Names.LocalName = local
diff --git a/library/src/scala/runtime/LazyVals.scala b/library/src/scala/runtime/LazyVals.scala
index d8c89c7abf28..0edbe0e748f4 100644
--- a/library/src/scala/runtime/LazyVals.scala
+++ b/library/src/scala/runtime/LazyVals.scala
@@ -10,7 +10,7 @@ import scala.annotation.*
 object LazyVals {
   @nowarn
   private[this] val unsafe: sun.misc.Unsafe = {
-    def throwInitializationException() = 
+    def throwInitializationException() =
       throw new ExceptionInInitializerError(
         new IllegalStateException("Can't find instance of sun.misc.Unsafe")
       )
diff --git a/sbt-test/sbt-dotty/tasty-inspector-jars/build.sbt b/sbt-test/sbt-dotty/tasty-inspector-jars/build.sbt
index 59dd85290bf0..3bece1b43fa7 100644
--- a/sbt-test/sbt-dotty/tasty-inspector-jars/build.sbt
+++ b/sbt-test/sbt-dotty/tasty-inspector-jars/build.sbt
@@ -15,7 +15,7 @@ lazy val inspector = project
   .settings(
     scalaVersion := dottyVersion,
     libraryDependencies += "org.scala-lang" %% "scala3-tasty-inspector" % scalaVersion.value,
-    runTest := 
+    runTest :=
       Def.sequential(
         Def.task(IO.copyFile((lib/Compile/packageBin).value, jarDest)),
         (Compile/run).toTask(" " + jarDest.getAbsolutePath)
diff --git a/sbt-test/source-dependencies/implicit-search/changes/A1.scala b/sbt-test/source-dependencies/implicit-search/changes/A1.scala
index 7aa91d096277..69c493db2131 100644
--- a/sbt-test/source-dependencies/implicit-search/changes/A1.scala
+++ b/sbt-test/source-dependencies/implicit-search/changes/A1.scala
@@ -1 +1 @@
-object A 
+object A
diff --git a/sbt-test/source-dependencies/java-static/test b/sbt-test/source-dependencies/java-static/test
index 42890ca74f4d..0bb6f50169e4 100644
--- a/sbt-test/source-dependencies/java-static/test
+++ b/sbt-test/source-dependencies/java-static/test
@@ -2,7 +2,7 @@
 #    the statics as an object without a file and so the Analyzer must know to look for the
 #    object's linked class.
 # This test verifies this happens.
-# The test compiles a Java class with a static field. 
+# The test compiles a Java class with a static field.
 # It then adds a Scala object that references the static field.  Because the object only depends on a
 #   static member and because the Java source is not included in the compilation (since it didn't change),
 #   this triggers the special case above.
diff --git a/sbt-test/source-dependencies/restore-classes/changes/A2.scala b/sbt-test/source-dependencies/restore-classes/changes/A2.scala
index 10d738255cca..778f16ab95cc 100644
--- a/sbt-test/source-dependencies/restore-classes/changes/A2.scala
+++ b/sbt-test/source-dependencies/restore-classes/changes/A2.scala
@@ -2,4 +2,4 @@ object A {
   val x = "a"
 }
 
-class C 
+class C
diff --git a/scaladoc-testcases/src/example/typeAndObjects/binaryops.scala b/scaladoc-testcases/src/example/typeAndObjects/binaryops.scala
index 890d39732ca8..6474d04f91ef 100644
--- a/scaladoc-testcases/src/example/typeAndObjects/binaryops.scala
+++ b/scaladoc-testcases/src/example/typeAndObjects/binaryops.scala
@@ -5,7 +5,7 @@ sealed trait Expr
 
 object Expr{
   case class BinaryOp(offset: Int, lhs: Expr, op: BinaryOp.Op, rhs: Expr) extends Expr
-  
+
   object BinaryOp{
     sealed trait Op
     case object `<<` extends Op
diff --git a/scaladoc-testcases/src/tests/contextBounds.scala b/scaladoc-testcases/src/tests/contextBounds.scala
index 1925f7f40994..794af0b8b8f8 100644
--- a/scaladoc-testcases/src/tests/contextBounds.scala
+++ b/scaladoc-testcases/src/tests/contextBounds.scala
@@ -25,15 +25,15 @@ class A:
   def a[T <: String | Int : ([T] =>> T match { case String => A case Int => B })](t: T): T
     = t
 
-  def falsePositive[T](evidence$1: ClassTag[T]): Int 
+  def falsePositive[T](evidence$1: ClassTag[T]): Int
     = 1
 
   // Scala spec stats that behaviour of names with `$` is undefined.
   // Scaladoc documents definition below as `def falsePositive2[T: ClassTag]: Int`
   // that is equivalent of methods below
-  // def falsePositive2[T](implicit evidence$3: ClassTag[T]): Int 
+  // def falsePositive2[T](implicit evidence$3: ClassTag[T]): Int
   //   = 1
 
   class Outer[A]:
-    def falsePositiveInner[T](implicit evidence$3: ClassTag[A]): Int 
+    def falsePositiveInner[T](implicit evidence$3: ClassTag[A]): Int
       = 1
\ No newline at end of file
diff --git a/scaladoc-testcases/src/tests/snippetComments.scala b/scaladoc-testcases/src/tests/snippetComments.scala
index 39b15648103e..9f54b8a465f1 100644
--- a/scaladoc-testcases/src/tests/snippetComments.scala
+++ b/scaladoc-testcases/src/tests/snippetComments.scala
@@ -3,7 +3,7 @@ package tests.snippetComments
 
 /**
  * This is my codeblock
- * 
+ *
  * ```
  * //{{
  * import xd
@@ -20,7 +20,7 @@ package tests.snippetComments
  * val y = 2 // comment in the same line
  * // comment in new line
  * val z = 3
- * 
+ *
  * //{{
  * val hideMe = 7
  * //}}

From 93cc31d54efc988d41321430d973d1c7191a3f12 Mon Sep 17 00:00:00 2001
From: Lucas <leblanc.lucas29@gmail.com>
Date: Tue, 4 Apr 2023 10:32:37 +0200
Subject: [PATCH 345/657] Add scrollbar in the sidebar

---
 .../dotty_res/styles/theme/layout/container.css     | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/scaladoc/resources/dotty_res/styles/theme/layout/container.css b/scaladoc/resources/dotty_res/styles/theme/layout/container.css
index a5210210c420..849235e2fa82 100644
--- a/scaladoc/resources/dotty_res/styles/theme/layout/container.css
+++ b/scaladoc/resources/dotty_res/styles/theme/layout/container.css
@@ -19,11 +19,18 @@ p {
   --header-height: calc(8 * var(--base-spacing));
 }
 
+/* Scrollbar */
+
 ::-webkit-scrollbar {
-  width: 5;
+  width: 0;
   background: transparent;
 }
 
-::-webkit-scrollbar-thumb {
-  background: black;
+#leftColumn ::-webkit-scrollbar{
+  width: 5px;
 }
+
+#leftColumn ::-webkit-scrollbar-thumb {
+  background: var(--code-syntax-highlighting-scrollbar);
+  border-radius: 2px;
+}
\ No newline at end of file

From e7f310bf3d2b909fcb180641f8cd50bac971fb88 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Tue, 4 Apr 2023 14:43:12 +0200
Subject: [PATCH 346/657] Fix selecting unaliased selector in wunused

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

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index 6943fb1b12e6..0ebf1c090ee3 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -590,12 +590,13 @@ object CheckUnused:
       private def isInImport(imp: tpd.Import, isAccessible: Boolean, symName: Option[Name])(using Context): Option[ImportSelector] =
         val tpd.Import(qual, sels) = imp
         val dealiasedSym = dealias(sym)
+        val simpleSelections = qual.tpe.member(sym.name).alternatives
         val typeSelections = sels.flatMap(n => qual.tpe.member(n.name.toTypeName).alternatives)
         val termSelections = sels.flatMap(n => qual.tpe.member(n.name.toTermName).alternatives)
-        val allSelections = typeSelections ::: termSelections :::qual.tpe.member(sym.name).alternatives
-        val qualHasSymbol = allSelections.map(_.symbol).map(dealias).contains(dealiasedSym)
+        val selectionsToDealias = typeSelections ::: termSelections
+        val qualHasSymbol = simpleSelections.map(_.symbol).contains(sym) || (simpleSelections ::: selectionsToDealias).map(_.symbol).map(dealias).contains(dealiasedSym)
         def selector = sels.find(sel => (sel.name.toTermName == sym.name || sel.name.toTypeName == sym.name) && symName.map(n => n.toTermName == sel.rename).getOrElse(true))
-        def dealiasedSelector = sels.flatMap(sel => allSelections.map(m => (sel, m.symbol))).collect {
+        def dealiasedSelector = sels.flatMap(sel => selectionsToDealias.map(m => (sel, m.symbol))).collect {
           case (sel, sym) if dealias(sym) == dealiasedSym => sel
         }.headOption
         def wildcard = sels.find(sel => sel.isWildcard && ((sym.is(Given) == sel.isGiven) || sym.is(Implicit)))
@@ -604,6 +605,7 @@ object CheckUnused:
         else
           None
 
+
       private def dealias(symbol: Symbol)(using Context): Symbol =
         if(symbol.isType && symbol.asType.denot.isAliasType) then
           symbol.asType.typeRef.dealias.typeSymbol

From cbbae64eace76b8910170fd3022d1231a7de7ea5 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 4 Apr 2023 15:36:03 +0200
Subject: [PATCH 347/657] Use TermRef to distinguish distinct Type[T] instances

We used the symbol before, but this ignored the specific path to the
instance of Type[T].

Fixes #16959
---
 .../tools/dotc/staging/QuoteTypeTags.scala      |  6 +++---
 .../dotty/tools/dotc/transform/Splicing.scala   |  8 ++++----
 tests/pos-macros/i16959/Macro_1.scala           | 17 +++++++++++++++++
 tests/pos-macros/i16959/Test_2.scala            |  1 +
 4 files changed, 25 insertions(+), 7 deletions(-)
 create mode 100644 tests/pos-macros/i16959/Macro_1.scala
 create mode 100644 tests/pos-macros/i16959/Test_2.scala

diff --git a/compiler/src/dotty/tools/dotc/staging/QuoteTypeTags.scala b/compiler/src/dotty/tools/dotc/staging/QuoteTypeTags.scala
index c4c9c611be3a..d6f0a6576085 100644
--- a/compiler/src/dotty/tools/dotc/staging/QuoteTypeTags.scala
+++ b/compiler/src/dotty/tools/dotc/staging/QuoteTypeTags.scala
@@ -27,10 +27,10 @@ object QuoteTypeTags {
 class QuoteTypeTags(span: Span)(using Context) {
   import tpd.*
 
-  private val tags = collection.mutable.LinkedHashMap.empty[Symbol, TypeDef]
+  private val tags = collection.mutable.LinkedHashMap.empty[TermRef, TypeDef]
 
   def getTagRef(spliced: TermRef): TypeRef = {
-    val typeDef = tags.getOrElseUpdate(spliced.symbol, mkTagSymbolAndAssignType(spliced))
+    val typeDef = tags.getOrElseUpdate(spliced, mkTagSymbolAndAssignType(spliced))
     typeDef.symbol.typeRef
   }
 
@@ -42,7 +42,7 @@ class QuoteTypeTags(span: Span)(using Context) {
     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,
+      name = UniqueName.fresh(rhs.tpe.dealias.typeSymbol.name.toTypeName),
       flags = Synthetic,
       info = TypeAlias(splicedTree.tpe.select(tpnme.Underlying)),
       coord = span).asType
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicing.scala b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
index bb82fba32a7c..e959f5d1451d 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicing.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
@@ -108,8 +108,8 @@ class Splicing extends MacroTransform:
     /** 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]
+    /** Mapping from the term of a `Type[T]` to it's hole. Used to deduplicate type holes. */
+    private val typeHoles = mutable.Map.empty[TermRef, Hole]
 
     override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
       tree match
@@ -127,13 +127,13 @@ class Splicing extends MacroTransform:
         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
+          val hole = typeHoles.get(qual) 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)
+              typeHoles.put(qual, hole)
               hole
           cpy.TypeDef(tree)(rhs = hole)
         case Apply(Select(Apply(TypeApply(fn,_), List(code)),nme.apply),List(quotes))
diff --git a/tests/pos-macros/i16959/Macro_1.scala b/tests/pos-macros/i16959/Macro_1.scala
new file mode 100644
index 000000000000..61483bff7ff1
--- /dev/null
+++ b/tests/pos-macros/i16959/Macro_1.scala
@@ -0,0 +1,17 @@
+import scala.quoted.*
+
+inline def test = ${ testImpl }
+
+def testImpl(using Quotes) =
+  import quotes.reflect.*
+
+  val int = PackedType[Int]
+  val string = PackedType[String]
+
+  assert(Type.show[(int.U, string.U, string.U)] == "scala.Tuple3[scala.Int, java.lang.String, java.lang.String]")
+
+  '{ () }
+
+final class PackedType[T](using t: Type[T]):
+  opaque type U = T
+  given tpe: Type[U] = t
diff --git a/tests/pos-macros/i16959/Test_2.scala b/tests/pos-macros/i16959/Test_2.scala
new file mode 100644
index 000000000000..e9772d026451
--- /dev/null
+++ b/tests/pos-macros/i16959/Test_2.scala
@@ -0,0 +1 @@
+def app = test

From 57a6867935840447a25c63b33b7612ab7422542d Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 4 Apr 2023 15:39:21 +0200
Subject: [PATCH 348/657] Simplify tryHeal signature

---
 .../src/dotty/tools/dotc/staging/CrossStageSafety.scala    | 4 ++--
 compiler/src/dotty/tools/dotc/staging/HealType.scala       | 4 ++--
 compiler/src/dotty/tools/dotc/transform/Staging.scala      | 7 ++++---
 3 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
index 98e060488f43..ce0f323fe31a 100644
--- a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
+++ b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
@@ -206,8 +206,8 @@ class CrossStageSafety extends TreeMapWithStages {
    *  The tag is generated by an instance of `QuoteTypeTags` directly if the splice is explicit
    *  or indirectly by `tryHeal`.
    */
-  protected def healType(pos: SrcPos)(using Context) =
-    new HealType(pos)
+  protected def healType(pos: SrcPos)(tpe: Type)(using Context) =
+    new HealType(pos).apply(tpe)
 
   /** Check level consistency of terms references */
   private def checkLevelConsistency(tree: Ident | This)(using Context): Unit =
diff --git a/compiler/src/dotty/tools/dotc/staging/HealType.scala b/compiler/src/dotty/tools/dotc/staging/HealType.scala
index 4f59e92241fb..50c2584b2fd0 100644
--- a/compiler/src/dotty/tools/dotc/staging/HealType.scala
+++ b/compiler/src/dotty/tools/dotc/staging/HealType.scala
@@ -51,7 +51,7 @@ class HealType(pos: SrcPos)(using Context) extends TypeMap {
         if level == 0 then tp else getQuoteTypeTags.getTagRef(prefix)
       case _: NamedType | _: ThisType | NoPrefix =>
         if levelInconsistentRootOfPath(tp).exists then
-          tryHeal(tp.symbol, tp, pos)
+          tryHeal(tp)
         else
           tp
       case _ =>
@@ -82,7 +82,7 @@ class HealType(pos: SrcPos)(using Context) extends TypeMap {
    *  reference to a type alias containing the equivalent of `${summon[quoted.Type[T]]}`.
    *  Emits an error if `T` cannot be healed and returns `T`.
    */
-  protected def tryHeal(sym: Symbol, tp: TypeRef, pos: SrcPos): Type = {
+  protected def tryHeal(tp: TypeRef): Type = {
     val reqType = defn.QuotedTypeClass.typeRef.appliedTo(tp)
     val tag = ctx.typer.inferImplicitArg(reqType, pos.span)
     tag.tpe match
diff --git a/compiler/src/dotty/tools/dotc/transform/Staging.scala b/compiler/src/dotty/tools/dotc/transform/Staging.scala
index 83b2bcdbcaa6..4fb5f5910440 100644
--- a/compiler/src/dotty/tools/dotc/transform/Staging.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Staging.scala
@@ -36,8 +36,9 @@ class Staging extends MacroTransform {
       tree match {
         case PackageDef(pid, _) if tree.symbol.owner == defn.RootClass =>
           val checker = new CrossStageSafety {
-            override protected def healType(pos: SrcPos)(using Context) = new HealType(pos) {
-              override protected def tryHeal(sym: Symbol, tp: TypeRef, pos: SrcPos): TypeRef = {
+            override protected def healType(pos: SrcPos)(tpe: Type)(using Context) = new HealType(pos) {
+              override protected def tryHeal(tp: TypeRef): TypeRef = {
+                val sym = tp.symbol
                 def symStr =
                   if (sym.is(ModuleClass)) sym.sourceModule.show
                   else i"${sym.name}.this"
@@ -51,7 +52,7 @@ class Staging extends MacroTransform {
 
                 tp
               }
-            }
+            }.apply(tpe)
           }
           checker.transform(tree)
         case _ =>

From b08729b43722ca6aa64b0ffb38489fcc09b451f2 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Wed, 5 Apr 2023 09:56:46 +0200
Subject: [PATCH 349/657] Check level consistency of SingletonTypeTree as a
 type

Fixes #8887
---
 compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala | 2 +-
 tests/neg-macros/i8887.scala                                 | 5 +++++
 tests/neg-macros/quote-this-a.scala                          | 4 +---
 tests/pos-macros/i8887.scala                                 | 3 +++
 4 files changed, 10 insertions(+), 4 deletions(-)
 create mode 100644 tests/neg-macros/i8887.scala
 create mode 100644 tests/pos-macros/i8887.scala

diff --git a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
index 98e060488f43..e3928538a183 100644
--- a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
+++ b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
@@ -60,7 +60,7 @@ class CrossStageSafety extends TreeMapWithStages {
         val healedType = healType(tree.srcPos)(tp1)
         if healedType == tree.tpe then tree
         else TypeTree(healedType).withSpan(tree.span)
-      case _: RefTree if tree.isType =>
+      case _: RefTree | _: SingletonTypeTree if tree.isType =>
         val healedType = healType(tree.srcPos)(tree.tpe)
         if healedType == tree.tpe then tree
         else TypeTree(healedType).withSpan(tree.span)
diff --git a/tests/neg-macros/i8887.scala b/tests/neg-macros/i8887.scala
new file mode 100644
index 000000000000..944544ba33dc
--- /dev/null
+++ b/tests/neg-macros/i8887.scala
@@ -0,0 +1,5 @@
+import scala.quoted._
+
+def expr[X](x: Any)(using Quotes): Expr[Any] =
+  '{ foo[x.type] } // error
+def foo[X]: Any = ???
diff --git a/tests/neg-macros/quote-this-a.scala b/tests/neg-macros/quote-this-a.scala
index 11621176526b..9f71aca0a7fb 100644
--- a/tests/neg-macros/quote-this-a.scala
+++ b/tests/neg-macros/quote-this-a.scala
@@ -4,9 +4,7 @@ class Foo {
 
   def f(using Quotes): Unit = '{
     def bar[T](x: T): T = x
-    bar[
-      this.type  // error
-      ] {
+    bar[this.type] {
       this  // error
     }
   }
diff --git a/tests/pos-macros/i8887.scala b/tests/pos-macros/i8887.scala
new file mode 100644
index 000000000000..5bfd5501063b
--- /dev/null
+++ b/tests/pos-macros/i8887.scala
@@ -0,0 +1,3 @@
+import scala.quoted._
+inline def foo(x: Any): Any = ${ expr[x.type] }
+def expr[X](using Quotes): Expr[Any] = ???

From f2fc7444ba61fb23849771f66d8ddaacf16b78c1 Mon Sep 17 00:00:00 2001
From: Decel <8268812+Decel@users.noreply.github.com>
Date: Thu, 6 Apr 2023 16:53:46 +0200
Subject: [PATCH 350/657] add regression test

---
 tests/pos/i14351.scala | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 tests/pos/i14351.scala

diff --git a/tests/pos/i14351.scala b/tests/pos/i14351.scala
new file mode 100644
index 000000000000..556e6b1ed64e
--- /dev/null
+++ b/tests/pos/i14351.scala
@@ -0,0 +1 @@
+val p: (Option[Int], Option[String]) = (1,"foo").map([T] => (x: T) => Option.apply[T](x))

From 4c9bdf00aedd7aac948aadf0cf7d5bd6734e97d6 Mon Sep 17 00:00:00 2001
From: brandonspark <wu.brandonj@gmail.com>
Date: Fri, 7 Apr 2023 15:15:59 -0700
Subject: [PATCH 351/657] documentation: fix tokens that can start indentation
 region

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

diff --git a/compiler/src/dotty/tools/dotc/parsing/Scanners.scala b/compiler/src/dotty/tools/dotc/parsing/Scanners.scala
index b3d824a2efd2..933661b7c5c9 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Scanners.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Scanners.scala
@@ -523,7 +523,8 @@ object Scanners {
      *
      *      The following tokens can start an indentation region:
      *
-     *         :  =  =>  <-  if  then  else  while  do  try  catch  finally  for  yield  match
+     *         :  =  =>  <-  if  then  else  while  do  try  catch  
+     *         finally  for  yield  match  throw  return  with
      *
      *      Inserting an INDENT starts a new indentation region with the indentation of the current
      *      token as indentation width.

From cd5affc7dfa5f5a3bdd8b4e5aef7d346c84e5b81 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Mon, 10 Apr 2023 19:41:15 +0200
Subject: [PATCH 352/657] Dealias only conditionally when symbol is derived val
 type in wunused

---
 .../tools/dotc/transform/CheckUnused.scala    | 27 ++++++++++---------
 1 file changed, 15 insertions(+), 12 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index 0ebf1c090ee3..ff1b54ec2d76 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -24,7 +24,7 @@ import dotty.tools.dotc.core.Annotations
 import dotty.tools.dotc.core.Definitions
 import dotty.tools.dotc.core.NameKinds.WildcardParamName
 import dotty.tools.dotc.core.Symbols.Symbol
-
+import dotty.tools.dotc.core.StdNames.nme
 
 
 /**
@@ -109,6 +109,9 @@ class CheckUnused extends MiniPhase:
       traverseAnnotations(tree.symbol)
       if !tree.symbol.is(Module) then
         ud.registerDef(tree)
+      if tree.name.mangledString.startsWith(nme.derived.mangledString + "$")
+          && tree.typeOpt != NoType then
+        ud.registerUsed(tree.typeOpt.typeSymbol, None, true)
       ud.addIgnoredUsage(tree.symbol)
     }
 
@@ -304,7 +307,7 @@ object CheckUnused:
      *
      * See the `isAccessibleAsIdent` extension method below in the file
      */
-    private val usedInScope = MutStack(MutSet[(Symbol,Boolean, Option[Name])]())
+    private val usedInScope = MutStack(MutSet[(Symbol,Boolean, Option[Name], Boolean)]())
     private val usedInPosition = MutSet[(SrcPos, Name)]()
     /* unused import collected during traversal */
     private val unusedImport = MutSet[ImportSelector]()
@@ -347,14 +350,14 @@ object CheckUnused:
      * The optional name will be used to target the right import
      * as the same element can be imported with different renaming
      */
-    def registerUsed(sym: Symbol, name: Option[Name])(using Context): Unit =
+    def registerUsed(sym: Symbol, name: Option[Name], isDerived: Boolean = false)(using Context): Unit =
       if !isConstructorOfSynth(sym) && !doNotRegister(sym) then
         if sym.isConstructor && sym.exists then
           registerUsed(sym.owner, None) // constructor are "implicitly" imported with the class
         else
-          usedInScope.top += ((sym, sym.isAccessibleAsIdent, name))
-          usedInScope.top += ((sym.companionModule, sym.isAccessibleAsIdent, name))
-          usedInScope.top += ((sym.companionClass, sym.isAccessibleAsIdent, name))
+          usedInScope.top += ((sym, sym.isAccessibleAsIdent, name, isDerived))
+          usedInScope.top += ((sym.companionModule, sym.isAccessibleAsIdent, name, isDerived))
+          usedInScope.top += ((sym.companionClass, sym.isAccessibleAsIdent, name, isDerived))
           name.map(n => usedInPosition += ((sym.sourcePos, n)))
 
     /** Register a symbol that should be ignored */
@@ -408,15 +411,15 @@ object CheckUnused:
       // used symbol in this scope
       val used = usedInScope.pop().toSet
       // used imports in this scope
-      val imports = impInScope.pop().toSet
+      val imports = impInScope.pop()
       val kept = used.filterNot { t =>
-        val (sym, isAccessible, optName) = t
+        val (sym, isAccessible, optName, isDerived) = t
         // keep the symbol for outer scope, if it matches **no** import
         // This is the first matching wildcard selector
         var selWildCard: Option[ImportSelector] = None
 
         val exists = imports.exists { imp =>
-          sym.isInImport(imp, isAccessible, optName) match
+          sym.isInImport(imp, isAccessible, optName, isDerived) match
             case None => false
             case optSel@Some(sel) if sel.isWildcard =>
               if selWildCard.isEmpty then selWildCard = optSel
@@ -587,7 +590,7 @@ object CheckUnused:
           }
 
       /** Given an import and accessibility, return an option of selector that match import<->symbol */
-      private def isInImport(imp: tpd.Import, isAccessible: Boolean, symName: Option[Name])(using Context): Option[ImportSelector] =
+      private def isInImport(imp: tpd.Import, isAccessible: Boolean, symName: Option[Name], isDerived: Boolean)(using Context): Option[ImportSelector] =
         val tpd.Import(qual, sels) = imp
         val dealiasedSym = dealias(sym)
         val simpleSelections = qual.tpe.member(sym.name).alternatives
@@ -596,9 +599,9 @@ object CheckUnused:
         val selectionsToDealias = typeSelections ::: termSelections
         val qualHasSymbol = simpleSelections.map(_.symbol).contains(sym) || (simpleSelections ::: selectionsToDealias).map(_.symbol).map(dealias).contains(dealiasedSym)
         def selector = sels.find(sel => (sel.name.toTermName == sym.name || sel.name.toTypeName == sym.name) && symName.map(n => n.toTermName == sel.rename).getOrElse(true))
-        def dealiasedSelector = sels.flatMap(sel => selectionsToDealias.map(m => (sel, m.symbol))).collect {
+        def dealiasedSelector = if(isDerived) sels.flatMap(sel => selectionsToDealias.map(m => (sel, m.symbol))).collect {
           case (sel, sym) if dealias(sym) == dealiasedSym => sel
-        }.headOption
+        }.headOption else None
         def wildcard = sels.find(sel => sel.isWildcard && ((sym.is(Given) == sel.isGiven) || sym.is(Implicit)))
         if qualHasSymbol && !isAccessible && sym.exists then
           selector.orElse(dealiasedSelector).orElse(wildcard) // selector with name or wildcard (or given)

From 6195663f444cd715eea49e8012a59cfaf9d49152 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Mon, 10 Apr 2023 20:19:48 +0200
Subject: [PATCH 353/657] WIP: Disable WUnused for params of non-private defs

---
 .../src/dotty/tools/dotc/transform/CheckUnused.scala | 12 +++++++++++-
 .../fatal-warnings/i15503-scala2/scala2-t11681.scala |  2 +-
 2 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index d7c88a1fca40..d49e69c46206 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -114,6 +114,10 @@ class CheckUnused extends MiniPhase:
 
   override def prepareForDefDef(tree: tpd.DefDef)(using Context): Context =
     unusedDataApply{ ud =>
+      if !tree.rawMods.is(Private) then
+        tree.termParamss.flatten.foreach { p =>
+          ud.addIgnoredParam(p.symbol)
+        }
       import ud.registerTrivial
       tree.registerTrivial
       traverseAnnotations(tree.symbol)
@@ -331,6 +335,8 @@ object CheckUnused:
     /** Trivial definitions, avoid registering params */
     private val trivialDefs = MutSet[Symbol]()
 
+    private val paramsToSkip = MutSet[Symbol]()
+
     /**
      * Push a new Scope of the given type, executes the given Unit and
      * pop it back to the original type.
@@ -365,6 +371,10 @@ object CheckUnused:
     def removeIgnoredUsage(sym: Symbol)(using Context): Unit =
       doNotRegister --= sym.everySymbol
 
+    def addIgnoredParam(sym: Symbol)(using Context): Unit =
+      paramsToSkip += sym
+
+
 
     /** Register an import */
     def registerImport(imp: tpd.Import)(using Context): Unit =
@@ -380,7 +390,7 @@ object CheckUnused:
         if memDef.isValidParam then
           if memDef.symbol.isOneOf(GivenOrImplicit) then
             implicitParamInScope += memDef
-          else
+          else if !paramsToSkip.contains(memDef.symbol) then
             explicitParamInScope += memDef
         else if currScopeType.top == ScopeType.Local then
           localDefInScope += memDef
diff --git a/tests/neg-custom-args/fatal-warnings/i15503-scala2/scala2-t11681.scala b/tests/neg-custom-args/fatal-warnings/i15503-scala2/scala2-t11681.scala
index 18aa6879eeba..162bf9128a98 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503-scala2/scala2-t11681.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503-scala2/scala2-t11681.scala
@@ -9,7 +9,7 @@ trait InterFace {
 }
 
 trait BadAPI extends InterFace {
-  def f(a: Int,
+  private def f(a: Int,
         b: String,               // error
         c: Double): Int = {
     println(c)

From 498abec4fe07279231f816c6747c914aadd38ef0 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Wed, 29 Mar 2023 19:09:47 +0200
Subject: [PATCH 354/657] Fix WUnused for accessible symbols that are renamed

---
 .../dotty/tools/dotc/transform/CheckUnused.scala   |  2 +-
 tests/neg-custom-args/fatal-warnings/i15503i.scala | 14 ++++++++++++++
 2 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index 5a178ff2ec1f..fcbb61ab90e2 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -603,7 +603,7 @@ object CheckUnused:
           case (sel, sym) if dealias(sym) == dealiasedSym => sel
         }.headOption else None
         def wildcard = sels.find(sel => sel.isWildcard && ((sym.is(Given) == sel.isGiven) || sym.is(Implicit)))
-        if qualHasSymbol && !isAccessible && sym.exists then
+        if qualHasSymbol && (!isAccessible || symName.exists(_ != sym.name)) && sym.exists then
           selector.orElse(dealiasedSelector).orElse(wildcard) // selector with name or wildcard (or given)
         else
           None
diff --git a/tests/neg-custom-args/fatal-warnings/i15503i.scala b/tests/neg-custom-args/fatal-warnings/i15503i.scala
index 737e5f0739ca..fbdf47dae17a 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503i.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503i.scala
@@ -287,3 +287,17 @@ package foo.test.i17156:
   package c:
     import b.Xd
     trait Z derives Xd
+
+package foo.test.i17117:
+  package example {
+    object test1 {
+      val test = "test"
+    }
+
+    object test2 {
+
+      import example.test1 as t1
+
+      val test = t1.test
+    }
+  }
\ No newline at end of file

From 25d1b63c3c9c7b0970113f6b17cfe5ff039077d7 Mon Sep 17 00:00:00 2001
From: Lucas <leblanc.lucas29@gmail.com>
Date: Wed, 29 Mar 2023 15:04:33 +0200
Subject: [PATCH 355/657] Change the CSS the logo for the generated
 documentation is adaptive - Add a fixed width of the span - Add a 100% for
 the img in the span

---
 .../resources/dotty_res/styles/theme/layout/header.css    | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/scaladoc/resources/dotty_res/styles/theme/layout/header.css b/scaladoc/resources/dotty_res/styles/theme/layout/header.css
index cf3b91db2698..85e6b0240899 100644
--- a/scaladoc/resources/dotty_res/styles/theme/layout/header.css
+++ b/scaladoc/resources/dotty_res/styles/theme/layout/header.css
@@ -63,6 +63,14 @@
   align-items: center;
 }
 
+.logo-container .project-logo {
+  max-width: 40px;
+}
+
+.logo-container .project-logo img {
+  max-width: 100%;
+}
+
 #mobile-menu-toggle {
   display: none;
 }

From 781a398347963b1ac55bdf92f7f9fe916766fa73 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 11 Apr 2023 12:58:19 +0200
Subject: [PATCH 356/657] Remove NamedArg from inlined arguments

Fixes #17227
---
 .../dotty/tools/dotc/inlines/Inliner.scala    | 17 +++++++++-----
 tests/pos-macros/i17227/Macro_1.scala         | 22 +++++++++++++++++++
 tests/pos-macros/i17227/Test_2.scala          |  6 +++++
 tests/pos/i17227.scala                        | 10 +++++++++
 4 files changed, 50 insertions(+), 5 deletions(-)
 create mode 100644 tests/pos-macros/i17227/Macro_1.scala
 create mode 100644 tests/pos-macros/i17227/Test_2.scala
 create mode 100644 tests/pos/i17227.scala

diff --git a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
index 872dc7793ff4..8b775a25fe0c 100644
--- a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
@@ -207,11 +207,18 @@ class Inliner(val call: tpd.Tree)(using Context):
   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 arg =
+      def dropNameArg(arg: Tree): Tree = arg match
+        case NamedArg(_, arg1) => arg1
+        case SeqLiteral(elems, tpt) =>
+          cpy.SeqLiteral(arg)(elems.mapConserve(dropNameArg), tpt)
+        case _ => arg
+      arg0 match
+        case Typed(seq, tpt) if tpt.tpe.isRepeatedParam =>
+          if seq.tpe.derivesFrom(defn.ArrayClass) then wrapArray(dropNameArg(seq), arg0.tpe.elemType)
+          else cpy.Typed(arg0)(dropNameArg(seq), tpt)
+        case arg0 =>
+          dropNameArg(arg0)
     val argtpe = arg.tpe.dealiasKeepAnnots.translateFromRepeated(toArray = false)
     val argIsBottom = argtpe.isBottomTypeAfterErasure
     val bindingType =
diff --git a/tests/pos-macros/i17227/Macro_1.scala b/tests/pos-macros/i17227/Macro_1.scala
new file mode 100644
index 000000000000..b483336119cb
--- /dev/null
+++ b/tests/pos-macros/i17227/Macro_1.scala
@@ -0,0 +1,22 @@
+import scala.quoted.*
+
+inline def foo(f: Int => Int): Int => Int = ${impl('f)}
+inline def bar(inline f: Int => Int): Int => Int = ${impl('f)}
+inline def baz(inline f: (Int => Int)*): Int => Int = ${impl2('f)}
+
+def impl(f: Expr[Int => Int])(using Quotes): Expr[Int => Int] =
+  assertNoNamedArgs(f)
+  '{identity}
+
+def impl2(f: Expr[Seq[Int => Int]])(using Quotes): Expr[Int => Int] =
+  assertNoNamedArgs(f)
+  '{identity}
+
+def assertNoNamedArgs(expr: Expr[Any])(using Quotes): Unit =
+  import quotes.reflect.*
+  new TreeTraverser {
+    override def traverseTree(tree: Tree)(owner: Symbol): Unit = tree match
+      case _: NamedArg =>
+        report.throwError(s"Unexpected NamedArg after inlining: ${tree}", tree.pos)
+      case _ => traverseTreeChildren(tree)(owner)
+  }.traverseTree(expr.asTerm)(Symbol.spliceOwner)
diff --git a/tests/pos-macros/i17227/Test_2.scala b/tests/pos-macros/i17227/Test_2.scala
new file mode 100644
index 000000000000..4106113d94c0
--- /dev/null
+++ b/tests/pos-macros/i17227/Test_2.scala
@@ -0,0 +1,6 @@
+def g(i: Int): Int = i
+
+def test =
+  foo(f = g)
+  bar(f = g)
+  baz(f = g)
diff --git a/tests/pos/i17227.scala b/tests/pos/i17227.scala
new file mode 100644
index 000000000000..d537f99f6515
--- /dev/null
+++ b/tests/pos/i17227.scala
@@ -0,0 +1,10 @@
+inline def foo(f: Int => Int): Int => Int = f
+inline def bar(inline f: Int => Int): Int => Int = f
+inline def baz(f: (Int => Int)*): Int => Int = f.head
+
+def g(i: Int): Int = i
+
+def test =
+  foo(f = g)
+  bar(f = g)
+  baz(f = g)

From a8fab276a337bc0dfe65f15b6a9602a89c3a25ad Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Wed, 12 Apr 2023 14:35:53 +0200
Subject: [PATCH 357/657] Compare simple name and handle NO_NAME case in
 WUnused

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

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index fcbb61ab90e2..5c5f382de1b2 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -603,7 +603,7 @@ object CheckUnused:
           case (sel, sym) if dealias(sym) == dealiasedSym => sel
         }.headOption else None
         def wildcard = sels.find(sel => sel.isWildcard && ((sym.is(Given) == sel.isGiven) || sym.is(Implicit)))
-        if qualHasSymbol && (!isAccessible || symName.exists(_ != sym.name)) && sym.exists then
+        if qualHasSymbol && (!isAccessible || (sym.name != nme.NO_NAME && symName.exists(_.toSimpleName != sym.name.toSimpleName))) && sym.exists then
           selector.orElse(dealiasedSelector).orElse(wildcard) // selector with name or wildcard (or given)
         else
           None

From e5d4be3fcd349896a491c9685a45f903d43ed19a Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Wed, 29 Mar 2023 18:08:33 +0200
Subject: [PATCH 358/657] Fix WUnused false positive in for

---
 .../src/dotty/tools/dotc/transform/CheckUnused.scala   |  1 +
 tests/neg-custom-args/fatal-warnings/i15503i.scala     | 10 ++++++++++
 2 files changed, 11 insertions(+)

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index 5a178ff2ec1f..6c6bfea476d8 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -473,6 +473,7 @@ object CheckUnused:
         if ctx.settings.WunusedHas.explicits then
           explicitParamInScope
             .filterNot(d => d.symbol.usedDefContains)
+            .filterNot(d => usedInPosition.exists { case (pos, name) => d.span.contains(pos.span) && name == d.symbol.name})
             .filterNot(d => containsSyntheticSuffix(d.symbol))
             .map(d => d.namePos -> WarnTypes.ExplicitParams).toList
         else
diff --git a/tests/neg-custom-args/fatal-warnings/i15503i.scala b/tests/neg-custom-args/fatal-warnings/i15503i.scala
index 737e5f0739ca..76a982df3d67 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503i.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503i.scala
@@ -287,3 +287,13 @@ package foo.test.i17156:
   package c:
     import b.Xd
     trait Z derives Xd
+
+package foo.test.i17175:
+  val continue = true
+  def foo =
+    for {
+      i <- 1.until(10) // OK
+      if continue
+    } {
+      println(i)
+    }
\ No newline at end of file

From c63840221dc1f9606361c1449cdcbf961dd33ace Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Wed, 12 Apr 2023 17:00:18 +0200
Subject: [PATCH 359/657] Extracted isRenamedSymbol def

---
 compiler/src/dotty/tools/dotc/transform/CheckUnused.scala | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index 5c5f382de1b2..cd1a21ece440 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -603,11 +603,13 @@ object CheckUnused:
           case (sel, sym) if dealias(sym) == dealiasedSym => sel
         }.headOption else None
         def wildcard = sels.find(sel => sel.isWildcard && ((sym.is(Given) == sel.isGiven) || sym.is(Implicit)))
-        if qualHasSymbol && (!isAccessible || (sym.name != nme.NO_NAME && symName.exists(_.toSimpleName != sym.name.toSimpleName))) && sym.exists then
+        if qualHasSymbol && (!isAccessible || isRenamedSymbol(sym, symName)) && sym.exists then
           selector.orElse(dealiasedSelector).orElse(wildcard) // selector with name or wildcard (or given)
         else
           None
 
+      private def isRenamedSymbol(sym: Symbol, symNameInScope: Option[Name]) =
+        sym.name != nme.NO_NAME && symName.exists(_.toSimpleName != sym.name.toSimpleName)
 
       private def dealias(symbol: Symbol)(using Context): Symbol =
         if(symbol.isType && symbol.asType.denot.isAliasType) then

From e72c020873d05a53722000a07a8f1bd0a3338243 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Wed, 12 Apr 2023 17:16:39 +0200
Subject: [PATCH 360/657] Fix isRenamedSymbol method in WUnused

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

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index cd1a21ece440..04f993e4c805 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -603,13 +603,13 @@ object CheckUnused:
           case (sel, sym) if dealias(sym) == dealiasedSym => sel
         }.headOption else None
         def wildcard = sels.find(sel => sel.isWildcard && ((sym.is(Given) == sel.isGiven) || sym.is(Implicit)))
-        if qualHasSymbol && (!isAccessible || isRenamedSymbol(sym, symName)) && sym.exists then
+        if qualHasSymbol && (!isAccessible || sym.isRenamedSymbol(symName)) && sym.exists then
           selector.orElse(dealiasedSelector).orElse(wildcard) // selector with name or wildcard (or given)
         else
           None
 
-      private def isRenamedSymbol(sym: Symbol, symNameInScope: Option[Name]) =
-        sym.name != nme.NO_NAME && symName.exists(_.toSimpleName != sym.name.toSimpleName)
+      private def isRenamedSymbol(symNameInScope: Option[Name])(using Context) =
+        sym.name != nme.NO_NAME && symNameInScope.exists(_.toSimpleName != sym.name.toSimpleName)
 
       private def dealias(symbol: Symbol)(using Context): Symbol =
         if(symbol.isType && symbol.asType.denot.isAliasType) then

From fb0efe5a85529a42d38eff2c003cca09e3dd8a54 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Thu, 13 Apr 2023 13:32:30 +0200
Subject: [PATCH 361/657] Do not register used symbol when position doesnt
 exist in wunused

---
 compiler/src/dotty/tools/dotc/transform/CheckUnused.scala     | 3 ++-
 .../fatal-warnings/i15503-scala2/scala2-t11681.scala          | 2 +-
 tests/neg-custom-args/fatal-warnings/i15503i.scala            | 4 ++--
 3 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index 6c6bfea476d8..b4db279a522c 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -358,7 +358,8 @@ object CheckUnused:
           usedInScope.top += ((sym, sym.isAccessibleAsIdent, name, isDerived))
           usedInScope.top += ((sym.companionModule, sym.isAccessibleAsIdent, name, isDerived))
           usedInScope.top += ((sym.companionClass, sym.isAccessibleAsIdent, name, isDerived))
-          name.map(n => usedInPosition += ((sym.sourcePos, n)))
+          if sym.sourcePos.exists then
+            name.map(n => usedInPosition += ((sym.sourcePos, n)))
 
     /** Register a symbol that should be ignored */
     def addIgnoredUsage(sym: Symbol)(using Context): Unit =
diff --git a/tests/neg-custom-args/fatal-warnings/i15503-scala2/scala2-t11681.scala b/tests/neg-custom-args/fatal-warnings/i15503-scala2/scala2-t11681.scala
index 18aa6879eeba..912dbb456f3b 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503-scala2/scala2-t11681.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503-scala2/scala2-t11681.scala
@@ -60,7 +60,7 @@ class Revaluing(u: Int) { def f = u } // OK
 
 case class CaseyKasem(k: Int)        // OK
 
-case class CaseyAtTheBat(k: Int)(s: String)        // error
+case class CaseyAtTheBat(k: Int)(s: String)        // ok
 
 trait Ignorance {
   def f(readResolve: Int) = answer           // error
diff --git a/tests/neg-custom-args/fatal-warnings/i15503i.scala b/tests/neg-custom-args/fatal-warnings/i15503i.scala
index 76a982df3d67..f67e273ca6f5 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503i.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503i.scala
@@ -90,7 +90,7 @@ package foo.test.possibleclasses:
     k: Int, // OK
     private val y: Int // OK /* Kept as it can be taken from pattern */
   )(
-    s: Int, // error /* But not these */
+    s: Int,
     val t: Int, // OK
     private val z: Int // error
   )
@@ -131,7 +131,7 @@ package foo.test.possibleclasses.withvar:
     k: Int, // OK
     private var y: Int // OK /* Kept as it can be taken from pattern */
   )(
-    s: Int, // error /* But not these */
+    s: Int,
     var t: Int, // OK
     private var z: Int // error
   )

From f6040ad31d55c2cc93f9dc2eacfc3e1766c0bdc9 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Tue, 4 Apr 2023 17:20:02 +0200
Subject: [PATCH 362/657] Make CheckUnused run both after Typer and Inlining

---
 compiler/src/dotty/tools/dotc/Compiler.scala  |  3 +-
 .../tools/dotc/transform/CheckUnused.scala    | 92 ++++++++++++-------
 2 files changed, 63 insertions(+), 32 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/Compiler.scala b/compiler/src/dotty/tools/dotc/Compiler.scala
index db3d42d32190..5148e2b17c71 100644
--- a/compiler/src/dotty/tools/dotc/Compiler.scala
+++ b/compiler/src/dotty/tools/dotc/Compiler.scala
@@ -35,7 +35,7 @@ class Compiler {
   protected def frontendPhases: List[List[Phase]] =
     List(new Parser) ::             // Compiler frontend: scanner, parser
     List(new TyperPhase) ::         // Compiler frontend: namer, typer
-    List(new CheckUnused) ::        // Check for unused elements
+    List(CheckUnused.PostTyper) ::  // Check for unused elements
     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
@@ -50,6 +50,7 @@ class Compiler {
     List(new Pickler) ::            // Generate TASTY info
     List(new Inlining) ::           // Inline and execute macros
     List(new PostInlining) ::       // Add mirror support for inlined code
+    List(CheckUnused.PostInlining) ::  // Check for unused elements
     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
diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index 5a178ff2ec1f..ac28c2e36b98 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -33,22 +33,15 @@ import dotty.tools.dotc.core.StdNames.nme
  * Basically, it gathers definition/imports and their usage. If a
  * definition/imports does not have any usage, then it is reported.
  */
-class CheckUnused extends MiniPhase:
-  import CheckUnused.UnusedData
-
-  /**
-   * The key used to retrieve the "unused entity" analysis metadata,
-   * from the compilation `Context`
-   */
-  private val _key = Property.Key[UnusedData]
+class CheckUnused private (phaseMode: CheckUnused.PhaseMode, suffix: String, _key: Property.Key[CheckUnused.UnusedData]) extends MiniPhase:
+  import CheckUnused.*
+  import UnusedData.*
 
   private def unusedDataApply[U](f: UnusedData => U)(using Context): Context =
     ctx.property(_key).foreach(f)
     ctx
-  private def getUnusedData(using Context): Option[UnusedData] =
-    ctx.property(_key)
 
-  override def phaseName: String = CheckUnused.phaseName
+  override def phaseName: String = CheckUnused.phaseNamePrefix + suffix
 
   override def description: String = CheckUnused.description
 
@@ -60,13 +53,21 @@ class CheckUnused extends MiniPhase:
 
   override def prepareForUnit(tree: tpd.Tree)(using Context): Context =
     val data = UnusedData()
+    tree.getAttachment(_key).foreach(oldData =>
+      data.unusedAggregate = oldData.unusedAggregate
+    )
     val fresh = ctx.fresh.setProperty(_key, data)
+    tree.putAttachment(_key, data)
     fresh
 
   // ========== END + REPORTING ==========
 
   override def transformUnit(tree: tpd.Tree)(using Context): tpd.Tree =
-    unusedDataApply(ud => reportUnused(ud.getUnused))
+    unusedDataApply { ud =>
+      aggregateUnused(ud, ud.getUnused)
+      if(phaseMode == PhaseMode.Report) then
+        ud.unusedAggregate.foreach(reportUnused)
+    }
     tree
 
   // ========== MiniPhase Prepare ==========
@@ -252,31 +253,45 @@ class CheckUnused extends MiniPhase:
   private def traverseAnnotations(sym: Symbol)(using Context): Unit =
     sym.denot.annotations.foreach(annot => traverser.traverse(annot.tree))
 
+  private def aggregateUnused(data: UnusedData, res: UnusedData.UnusedResult)(using Context): Unit =
+    data.unusedAggregate match {
+      case None =>
+        data.unusedAggregate = Some(res)
+      case Some(prevUnused) =>
+        val intersection = res.warnings.filter(sym => prevUnused.warnings.contains(sym))
+        data.unusedAggregate = Some(UnusedResult(intersection))
+    }
+
+
+
   /** Do the actual reporting given the result of the anaylsis */
   private def reportUnused(res: UnusedData.UnusedResult)(using Context): Unit =
-    import CheckUnused.WarnTypes
     res.warnings.foreach { s =>
       s match
-        case (t, WarnTypes.Imports) =>
+        case UnusedSymbol(t, _, WarnTypes.Imports) =>
           report.warning(s"unused import", t)
-        case (t, WarnTypes.LocalDefs) =>
+        case UnusedSymbol(t, _, WarnTypes.LocalDefs) =>
           report.warning(s"unused local definition", t)
-        case (t, WarnTypes.ExplicitParams) =>
+        case UnusedSymbol(t, _, WarnTypes.ExplicitParams) =>
           report.warning(s"unused explicit parameter", t)
-        case (t, WarnTypes.ImplicitParams) =>
+        case UnusedSymbol(t, _, WarnTypes.ImplicitParams) =>
           report.warning(s"unused implicit parameter", t)
-        case (t, WarnTypes.PrivateMembers) =>
+        case UnusedSymbol(t, _, WarnTypes.PrivateMembers) =>
           report.warning(s"unused private member", t)
-        case (t, WarnTypes.PatVars) =>
+        case UnusedSymbol(t, _, WarnTypes.PatVars) =>
           report.warning(s"unused pattern variable", t)
     }
 
 end CheckUnused
 
 object CheckUnused:
-  val phaseName: String = "checkUnused"
+  val phaseNamePrefix: String = "checkUnused"
   val description: String = "check for unused elements"
 
+  enum PhaseMode:
+    case Aggregate
+    case Report
+
   private enum WarnTypes:
     case Imports
     case LocalDefs
@@ -285,6 +300,15 @@ object CheckUnused:
     case PrivateMembers
     case PatVars
 
+  /**
+   * The key used to retrieve the "unused entity" analysis metadata,
+   * from the compilation `Context`
+   */
+  private val _key = Property.StickyKey[UnusedData]
+
+  val PostTyper =    new CheckUnused(PhaseMode.Aggregate, "PostTyper", _key)
+  val PostInlining = new CheckUnused(PhaseMode.Report, "PostInlining", _key)
+
   /**
    * A stateful class gathering the infos on :
    * - imports
@@ -292,13 +316,14 @@ object CheckUnused:
    * - usage
    */
   private class UnusedData:
-    import dotty.tools.dotc.transform.CheckUnused.UnusedData.UnusedResult
     import collection.mutable.{Set => MutSet, Map => MutMap, Stack => MutStack}
-    import UnusedData.ScopeType
+    import UnusedData.*
 
     /** The current scope during the tree traversal */
     var currScopeType: MutStack[ScopeType] = MutStack(ScopeType.Other)
 
+    var unusedAggregate: Option[UnusedResult] = None
+
     /* IMPORTS */
     private val impInScope = MutStack(MutSet[tpd.Import]())
     /**
@@ -452,12 +477,13 @@ object CheckUnused:
      *
      * The given `List` is sorted by line and then column of the position
      */
+
     def getUnused(using Context): UnusedResult =
       popScope()
 
       val sortedImp =
         if ctx.settings.WunusedHas.imports || ctx.settings.WunusedHas.strictNoImplicitWarn then
-          unusedImport.map(d => d.srcPos -> WarnTypes.Imports).toList
+          unusedImport.map(d => UnusedSymbol(d.srcPos, d.name, WarnTypes.Imports)).toList
         else
           Nil
       val sortedLocalDefs =
@@ -466,7 +492,7 @@ object CheckUnused:
             .filterNot(d => d.symbol.usedDefContains)
             .filterNot(d => usedInPosition.exists { case (pos, name) => d.span.contains(pos.span) && name == d.symbol.name})
             .filterNot(d => containsSyntheticSuffix(d.symbol))
-            .map(d => d.namePos -> WarnTypes.LocalDefs).toList
+            .map(d => UnusedSymbol(d.namePos, d.name, WarnTypes.LocalDefs)).toList
         else
           Nil
       val sortedExplicitParams =
@@ -474,7 +500,7 @@ object CheckUnused:
           explicitParamInScope
             .filterNot(d => d.symbol.usedDefContains)
             .filterNot(d => containsSyntheticSuffix(d.symbol))
-            .map(d => d.namePos -> WarnTypes.ExplicitParams).toList
+            .map(d => UnusedSymbol(d.namePos, d.name, WarnTypes.ExplicitParams)).toList
         else
           Nil
       val sortedImplicitParams =
@@ -482,7 +508,7 @@ object CheckUnused:
           implicitParamInScope
             .filterNot(d => d.symbol.usedDefContains)
             .filterNot(d => containsSyntheticSuffix(d.symbol))
-            .map(d => d.namePos -> WarnTypes.ImplicitParams).toList
+            .map(d => UnusedSymbol(d.namePos, d.name, WarnTypes.ImplicitParams)).toList
         else
           Nil
       val sortedPrivateDefs =
@@ -490,7 +516,7 @@ object CheckUnused:
           privateDefInScope
             .filterNot(d => d.symbol.usedDefContains)
             .filterNot(d => containsSyntheticSuffix(d.symbol))
-            .map(d => d.namePos -> WarnTypes.PrivateMembers).toList
+            .map(d => UnusedSymbol(d.namePos, d.name, WarnTypes.PrivateMembers)).toList
         else
           Nil
       val sortedPatVars =
@@ -499,14 +525,14 @@ object CheckUnused:
             .filterNot(d => d.symbol.usedDefContains)
             .filterNot(d => containsSyntheticSuffix(d.symbol))
             .filterNot(d => usedInPosition.exists { case (pos, name) => d.span.contains(pos.span) && name == d.symbol.name})
-            .map(d => d.namePos -> WarnTypes.PatVars).toList
+            .map(d => UnusedSymbol(d.namePos, d.name, WarnTypes.PatVars)).toList
         else
           Nil
       val warnings = List(sortedImp, sortedLocalDefs, sortedExplicitParams, sortedImplicitParams, sortedPrivateDefs, sortedPatVars).flatten.sortBy { s =>
-        val pos = s._1.sourcePos
+        val pos = s.pos.sourcePos
         (pos.line, pos.column)
       }
-      UnusedResult(warnings, Nil)
+      UnusedResult(warnings)
     end getUnused
     //============================ HELPERS ====================================
 
@@ -703,7 +729,11 @@ object CheckUnused:
           case _:tpd.Block => Local
           case _ => Other
 
+      case class UnusedSymbol(pos: SrcPos, name: Name, warnType: WarnTypes)
       /** A container for the results of the used elements analysis */
-      case class UnusedResult(warnings: List[(dotty.tools.dotc.util.SrcPos, WarnTypes)], usedImports: List[(tpd.Import, untpd.ImportSelector)])
+      case class UnusedResult(warnings: List[UnusedSymbol])
+      object UnusedResult:
+        val Empty = UnusedResult(Nil)
+
 end CheckUnused
 

From 6997686525c6a01e7fd78b2b19744a245be988da Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Thu, 13 Apr 2023 14:18:44 +0200
Subject: [PATCH 363/657] Fix instantation of CheckUnused phase

---
 compiler/src/dotty/tools/dotc/Compiler.scala              | 4 ++--
 compiler/src/dotty/tools/dotc/transform/CheckUnused.scala | 6 ++++--
 tests/neg-custom-args/fatal-warnings/i15503a.scala        | 4 ++--
 3 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/Compiler.scala b/compiler/src/dotty/tools/dotc/Compiler.scala
index 5148e2b17c71..b0f7b0a533d7 100644
--- a/compiler/src/dotty/tools/dotc/Compiler.scala
+++ b/compiler/src/dotty/tools/dotc/Compiler.scala
@@ -35,7 +35,7 @@ class Compiler {
   protected def frontendPhases: List[List[Phase]] =
     List(new Parser) ::             // Compiler frontend: scanner, parser
     List(new TyperPhase) ::         // Compiler frontend: namer, typer
-    List(CheckUnused.PostTyper) ::  // Check for unused elements
+    List(new CheckUnused.PostTyper) ::  // Check for unused elements
     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
@@ -50,7 +50,7 @@ class Compiler {
     List(new Pickler) ::            // Generate TASTY info
     List(new Inlining) ::           // Inline and execute macros
     List(new PostInlining) ::       // Add mirror support for inlined code
-    List(CheckUnused.PostInlining) ::  // Check for unused elements
+    List(new CheckUnused.PostInlining) ::  // Check for unused elements
     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
diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index ac28c2e36b98..2619136d26ab 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -52,6 +52,7 @@ class CheckUnused private (phaseMode: CheckUnused.PhaseMode, suffix: String, _ke
   // ========== SETUP ============
 
   override def prepareForUnit(tree: tpd.Tree)(using Context): Context =
+    println(this)
     val data = UnusedData()
     tree.getAttachment(_key).foreach(oldData =>
       data.unusedAggregate = oldData.unusedAggregate
@@ -306,8 +307,9 @@ object CheckUnused:
    */
   private val _key = Property.StickyKey[UnusedData]
 
-  val PostTyper =    new CheckUnused(PhaseMode.Aggregate, "PostTyper", _key)
-  val PostInlining = new CheckUnused(PhaseMode.Report, "PostInlining", _key)
+  class PostTyper extends CheckUnused(PhaseMode.Aggregate, "PostTyper", _key)
+
+  class PostInlining extends CheckUnused(PhaseMode.Report, "PostInlining", _key)
 
   /**
    * A stateful class gathering the infos on :
diff --git a/tests/neg-custom-args/fatal-warnings/i15503a.scala b/tests/neg-custom-args/fatal-warnings/i15503a.scala
index 868c488ddb84..cd7282490fc9 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503a.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503a.scala
@@ -63,12 +63,12 @@ object FooTypeName:
 
 object InlineChecks:
   object InlineFoo:
-    import collection.mutable.Set // OK
+    import collection.mutable.Set // ok
     import collection.mutable.Map // error
     inline def getSet = Set(1)
 
   object InlinedBar:
-    import collection.mutable.Set // error
+    import collection.mutable.Set // ok
     import collection.mutable.Map // error
     val a = InlineFoo.getSet
 

From 3b5491e318552cdef9acd8ed0dcc2a35cd1ba211 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Thu, 13 Apr 2023 14:37:21 +0200
Subject: [PATCH 364/657] Remove unnecessary logging in CheckUnused phase

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

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index 2619136d26ab..44d130f16e16 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -52,7 +52,6 @@ class CheckUnused private (phaseMode: CheckUnused.PhaseMode, suffix: String, _ke
   // ========== SETUP ============
 
   override def prepareForUnit(tree: tpd.Tree)(using Context): Context =
-    println(this)
     val data = UnusedData()
     tree.getAttachment(_key).foreach(oldData =>
       data.unusedAggregate = oldData.unusedAggregate

From fa07b41507aa369488983099ba68f80fc5ac496c Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Thu, 13 Apr 2023 14:48:20 +0200
Subject: [PATCH 365/657] Add test cases for macro wunused

---
 .../fatal-warnings/i16876/Macro.scala         | 23 +++++++++++++++++++
 .../fatal-warnings/i16876/Test.scala          | 11 +++++++++
 2 files changed, 34 insertions(+)
 create mode 100644 tests/neg-custom-args/fatal-warnings/i16876/Macro.scala
 create mode 100644 tests/neg-custom-args/fatal-warnings/i16876/Test.scala

diff --git a/tests/neg-custom-args/fatal-warnings/i16876/Macro.scala b/tests/neg-custom-args/fatal-warnings/i16876/Macro.scala
new file mode 100644
index 000000000000..2823de1f72c5
--- /dev/null
+++ b/tests/neg-custom-args/fatal-warnings/i16876/Macro.scala
@@ -0,0 +1,23 @@
+import scala.quoted.*
+
+def findMethodSymbol(using q: Quotes)(s: quotes.reflect.Symbol): quotes.reflect.Symbol =
+  if s.isDefDef then
+    s
+  else
+    findMethodSymbol(using q)(s.owner)
+end findMethodSymbol
+
+
+inline def adder: Int = ${
+  adderImpl
+}
+
+def adderImpl(using q: Quotes): Expr[Int] =
+  import quotes.reflect.*
+
+  val inputs = findMethodSymbol(using q)(q.reflect.Symbol.spliceOwner).tree match
+    case DefDef(_, params, _, _) =>
+      params.last match
+        case TermParamClause(valDefs) =>
+          valDefs.map(vd => Ref(vd.symbol).asExprOf[Int])
+  inputs.reduce((exp1, exp2) => '{ $exp1 + $exp2 })
\ No newline at end of file
diff --git a/tests/neg-custom-args/fatal-warnings/i16876/Test.scala b/tests/neg-custom-args/fatal-warnings/i16876/Test.scala
new file mode 100644
index 000000000000..d9229d31cd6d
--- /dev/null
+++ b/tests/neg-custom-args/fatal-warnings/i16876/Test.scala
@@ -0,0 +1,11 @@
+// scalac: -Wunused:all
+
+object Foo {
+  private def myMethod(a: Int, b: Int, c: Int) = adder // ok
+  myMethod(1, 2, 3)
+
+  private def myMethodFailing(a: Int, b: Int, c: Int) = a + 0 // error // error
+  myMethodFailing(1, 2, 3)
+}
+
+

From 14dd04b1f11ec4c0aa5ed57fd4b744f134caf09b Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Thu, 13 Apr 2023 15:32:56 +0200
Subject: [PATCH 366/657] Handle implicit params and adjust tests in WUnused

---
 .../tools/dotc/transform/CheckUnused.scala    |  5 ++--
 .../i15503-scala2/scala2-t11681.scala         | 22 +++++++++---------
 .../fatal-warnings/i15503e.scala              | 18 ++++++++-------
 .../fatal-warnings/i15503f.scala              | 17 +++++++-------
 .../fatal-warnings/i15503g.scala              | 23 ++++++++++---------
 .../fatal-warnings/i15503h.scala              |  2 +-
 .../fatal-warnings/i15503i.scala              | 10 +++++---
 7 files changed, 52 insertions(+), 45 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index d49e69c46206..f083690db11f 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -374,8 +374,6 @@ object CheckUnused:
     def addIgnoredParam(sym: Symbol)(using Context): Unit =
       paramsToSkip += sym
 
-
-
     /** Register an import */
     def registerImport(imp: tpd.Import)(using Context): Unit =
       if !tpd.languageImport(imp.expr).nonEmpty && !imp.isGeneratedByEnum && !isTransparentAndInline(imp) then
@@ -389,7 +387,8 @@ object CheckUnused:
       if memDef.isValidMemberDef then
         if memDef.isValidParam then
           if memDef.symbol.isOneOf(GivenOrImplicit) then
-            implicitParamInScope += memDef
+            if !paramsToSkip.contains(memDef.symbol) then
+              implicitParamInScope += memDef
           else if !paramsToSkip.contains(memDef.symbol) then
             explicitParamInScope += memDef
         else if currScopeType.top == ScopeType.Local then
diff --git a/tests/neg-custom-args/fatal-warnings/i15503-scala2/scala2-t11681.scala b/tests/neg-custom-args/fatal-warnings/i15503-scala2/scala2-t11681.scala
index 162bf9128a98..c26ac6c57770 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503-scala2/scala2-t11681.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503-scala2/scala2-t11681.scala
@@ -33,7 +33,7 @@ trait BadAPI extends InterFace {
 
   override def equals(other: Any): Boolean = true  // OK
 
-  def i(implicit s: String) = answer           // error
+  def i(implicit s: String) = answer           // ok
 
   /*
   def future(x: Int): Int = {
@@ -63,7 +63,7 @@ case class CaseyKasem(k: Int)        // OK
 case class CaseyAtTheBat(k: Int)(s: String)        // error
 
 trait Ignorance {
-  def f(readResolve: Int) = answer           // error
+  def f(readResolve: Int) = answer           // ok
 }
 
 class Reusing(u: Int) extends Unusing(u)   // OK
@@ -78,28 +78,28 @@ trait Unimplementation {
 }
 
 trait DumbStuff {
-  def f(implicit dummy: DummyImplicit) = answer // todo // error
-  def g(dummy: DummyImplicit) = answer // error
+  def f(implicit dummy: DummyImplicit) = answer // ok
+  def g(dummy: DummyImplicit) = answer // ok
 }
 trait Proofs {
-  def f[A, B](implicit ev: A =:= B) = answer // todo // error
-  def g[A, B](implicit ev: A <:< B) = answer // todo // error
-  def f2[A, B](ev: A =:= B) = answer // error
-  def g2[A, B](ev: A <:< B) = answer // error
+  def f[A, B](implicit ev: A =:= B) = answer // ok
+  def g[A, B](implicit ev: A <:< B) = answer // ok
+  def f2[A, B](ev: A =:= B) = answer // ok
+  def g2[A, B](ev: A <:< B) = answer // ok
 }
 
 trait Anonymous {
-  def f = (i: Int) => answer      // error
+  def f = (i: Int) => answer      // ok
 
   def f1 = (_: Int) => answer     // OK
 
   def f2: Int => Int = _ + 1  // OK
 
-  def g = for (i <- List(1)) yield answer    // error
+  def g = for (i <- List(1)) yield answer    // ok
 }
 trait Context[A]
 trait Implicits {
-  def f[A](implicit ctx: Context[A]) = answer // error
+  def f[A](implicit ctx: Context[A]) = answer // ok
   def g[A: Context] = answer // OK
 }
 class Bound[A: Context] // OK
diff --git a/tests/neg-custom-args/fatal-warnings/i15503e.scala b/tests/neg-custom-args/fatal-warnings/i15503e.scala
index 56aec702a39e..6d166aff7347 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503e.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503e.scala
@@ -1,14 +1,16 @@
 // scalac: -Wunused:explicits
 
-/* This goes around the "trivial method" detection */
-val default_val = 1
+object Foo {
+  /* This goes around the "trivial method" detection */
+  val default_val = 1
 
-def f1(a: Int) = a // OK
-def f2(a: Int) = default_val // error
-def f3(a: Int)(using Int) = a // OK
-def f4(a: Int)(using Int) = default_val // error
-def f6(a: Int)(using Int) = summon[Int] // error
-def f7(a: Int)(using Int) = summon[Int] + a // OK
+  private def f1(a: Int) = a // OK
+  private def f2(a: Int) = default_val // error
+  private def f3(a: Int)(using Int) = a // OK
+  private def f4(a: Int)(using Int) = default_val // error
+  private def f6(a: Int)(using Int) = summon[Int] // error
+  private def f7(a: Int)(using Int) = summon[Int] + a // OK
+}
 
 package scala2main.unused.args:
   object happyBirthday {
diff --git a/tests/neg-custom-args/fatal-warnings/i15503f.scala b/tests/neg-custom-args/fatal-warnings/i15503f.scala
index 67c595d74f40..f909272af732 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503f.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503f.scala
@@ -3,11 +3,12 @@
 /* This goes around the "trivial method" detection */
 val default_int = 1
 
-def f1(a: Int) = a // OK
-def f2(a: Int) = 1 // OK
-def f3(a: Int)(using Int) = a // OK
-def f4(a: Int)(using Int) = default_int // OK
-def f6(a: Int)(using Int) = summon[Int] // OK
-def f7(a: Int)(using Int) = summon[Int] + a // OK
-def f8(a: Int)(using foo: Int) = a // error
-
+object Xd {
+  private def f1(a: Int) = a // OK
+  private def f2(a: Int) = 1 // OK
+  private def f3(a: Int)(using Int) = a // OK
+  private def f4(a: Int)(using Int) = default_int // OK
+  private def f6(a: Int)(using Int) = summon[Int] // OK
+  private def f7(a: Int)(using Int) = summon[Int] + a // OK
+  private def f8(a: Int)(using foo: Int) = a // error
+}
diff --git a/tests/neg-custom-args/fatal-warnings/i15503g.scala b/tests/neg-custom-args/fatal-warnings/i15503g.scala
index a0822e7e1611..0d71d516adad 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503g.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503g.scala
@@ -1,15 +1,16 @@
 // scalac: -Wunused:params
 
 /* This goes around the "trivial method" detection */
-val default_int = 1
+object Foo {
+  val default_int = 1
 
-def f1(a: Int) = a // OK
-def f2(a: Int) = default_int // error
-def f3(a: Int)(using Int) = a // OK
-def f4(a: Int)(using Int) = default_int // error
-def f6(a: Int)(using Int) = summon[Int] // error
-def f7(a: Int)(using Int) = summon[Int] + a // OK
-
-/* --- Trivial method check --- */
-def g1(x: Int) = 1 // OK
-def g2(x: Int) = ??? // OK
\ No newline at end of file
+  private def f1(a: Int) = a // OK
+  private def f2(a: Int) = default_int // error
+  private def f3(a: Int)(using Int) = a // OK
+  private def f4(a: Int)(using Int) = default_int // error
+  private def f6(a: Int)(using Int) = summon[Int] // error
+  private def f7(a: Int)(using Int) = summon[Int] + a // OK
+  /* --- Trivial method check --- */
+  private def g1(x: Int) = 1 // OK
+  private def g2(x: Int) = ??? // OK
+}
\ No newline at end of file
diff --git a/tests/neg-custom-args/fatal-warnings/i15503h.scala b/tests/neg-custom-args/fatal-warnings/i15503h.scala
index f8d1d6f2202f..3bab6cdbd098 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503h.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503h.scala
@@ -7,7 +7,7 @@ class A {
   val b = 2 // OK
 
   private def c = 2 // error
-  def d(using x:Int): Int = b // error
+  def d(using x:Int): Int = b // ok
   def e(x: Int) = 1 // OK
   def f =
     val x = 1 // error
diff --git a/tests/neg-custom-args/fatal-warnings/i15503i.scala b/tests/neg-custom-args/fatal-warnings/i15503i.scala
index 9ac2ec5ef622..2b86e444c44f 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503i.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503i.scala
@@ -17,10 +17,10 @@ class A {
   private def c2 = 2 // OK
   def c3 = c2
 
-  def d1(using x:Int): Int = default_int // error
+  def d1(using x:Int): Int = default_int // ok
   def d2(using x:Int): Int = x // OK
 
-  def e1(x: Int) = default_int // error
+  def e1(x: Int) = default_int // ok
   def e2(x: Int) = x // OK
   def f =
     val x = 1 // error
@@ -44,7 +44,11 @@ package foo.test.scala.annotation:
   val default_int = 12
 
   def a1(a: Int) = a // OK
-  def a2(a: Int) = default_int // error
+  def a2(a: Int) = default_int // ok
+
+  private def a2_p(a: Int) = default_int // error
+  def a2_p_used = a2_p(3)
+
   def a3(@unused a: Int) = default_int //OK
 
   def b1 =

From 38c35bd2b0e0881f46eda471f99a9cb28f9e973e Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Thu, 13 Apr 2023 15:47:59 +0200
Subject: [PATCH 367/657] Apply review suggestions to WUnused PR

---
 .../tools/dotc/transform/CheckUnused.scala      | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index 44d130f16e16..4f9ec3eaa9e3 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -25,7 +25,7 @@ import dotty.tools.dotc.core.Definitions
 import dotty.tools.dotc.core.NameKinds.WildcardParamName
 import dotty.tools.dotc.core.Symbols.Symbol
 import dotty.tools.dotc.core.StdNames.nme
-
+import scala.math.Ordering
 
 /**
  * A compiler phase that checks for unused imports or definitions
@@ -64,7 +64,7 @@ class CheckUnused private (phaseMode: CheckUnused.PhaseMode, suffix: String, _ke
 
   override def transformUnit(tree: tpd.Tree)(using Context): tpd.Tree =
     unusedDataApply { ud =>
-      aggregateUnused(ud, ud.getUnused)
+      finishAggregation(ud)
       if(phaseMode == PhaseMode.Report) then
         ud.unusedAggregate.foreach(reportUnused)
     }
@@ -253,12 +253,13 @@ class CheckUnused private (phaseMode: CheckUnused.PhaseMode, suffix: String, _ke
   private def traverseAnnotations(sym: Symbol)(using Context): Unit =
     sym.denot.annotations.foreach(annot => traverser.traverse(annot.tree))
 
-  private def aggregateUnused(data: UnusedData, res: UnusedData.UnusedResult)(using Context): Unit =
+  private def finishAggregation(data: UnusedData)(using Context): Unit =
+    val unusedInThisStage = data.getUnused
     data.unusedAggregate match {
       case None =>
-        data.unusedAggregate = Some(res)
+        data.unusedAggregate = Some(unusedInThisStage)
       case Some(prevUnused) =>
-        val intersection = res.warnings.filter(sym => prevUnused.warnings.contains(sym))
+        val intersection = unusedInThisStage.warnings.intersect(prevUnused.warnings)
         data.unusedAggregate = Some(UnusedResult(intersection))
     }
 
@@ -266,7 +267,7 @@ class CheckUnused private (phaseMode: CheckUnused.PhaseMode, suffix: String, _ke
 
   /** Do the actual reporting given the result of the anaylsis */
   private def reportUnused(res: UnusedData.UnusedResult)(using Context): Unit =
-    res.warnings.foreach { s =>
+    res.warnings.toList.sortBy(_.pos.line)(using Ordering[Int]).foreach { s =>
       s match
         case UnusedSymbol(t, _, WarnTypes.Imports) =>
           report.warning(s"unused import", t)
@@ -321,7 +322,7 @@ object CheckUnused:
     import UnusedData.*
 
     /** The current scope during the tree traversal */
-    var currScopeType: MutStack[ScopeType] = MutStack(ScopeType.Other)
+    val currScopeType: MutStack[ScopeType] = MutStack(ScopeType.Other)
 
     var unusedAggregate: Option[UnusedResult] = None
 
@@ -732,7 +733,7 @@ object CheckUnused:
 
       case class UnusedSymbol(pos: SrcPos, name: Name, warnType: WarnTypes)
       /** A container for the results of the used elements analysis */
-      case class UnusedResult(warnings: List[UnusedSymbol])
+      case class UnusedResult(warnings: Set[UnusedSymbol])
       object UnusedResult:
         val Empty = UnusedResult(Nil)
 

From 3f67e270baab1ccb8fed33a2c814aefdeb691c2c Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Thu, 13 Apr 2023 15:55:29 +0200
Subject: [PATCH 368/657] Move finishAggregation to UnusedData class in
 CheckUnused

---
 .../tools/dotc/transform/CheckUnused.scala    | 28 +++++++++----------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index 4f9ec3eaa9e3..c1705f97d494 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -64,7 +64,7 @@ class CheckUnused private (phaseMode: CheckUnused.PhaseMode, suffix: String, _ke
 
   override def transformUnit(tree: tpd.Tree)(using Context): tpd.Tree =
     unusedDataApply { ud =>
-      finishAggregation(ud)
+      ud.finishAggregation()
       if(phaseMode == PhaseMode.Report) then
         ud.unusedAggregate.foreach(reportUnused)
     }
@@ -253,17 +253,6 @@ class CheckUnused private (phaseMode: CheckUnused.PhaseMode, suffix: String, _ke
   private def traverseAnnotations(sym: Symbol)(using Context): Unit =
     sym.denot.annotations.foreach(annot => traverser.traverse(annot.tree))
 
-  private def finishAggregation(data: UnusedData)(using Context): Unit =
-    val unusedInThisStage = data.getUnused
-    data.unusedAggregate match {
-      case None =>
-        data.unusedAggregate = Some(unusedInThisStage)
-      case Some(prevUnused) =>
-        val intersection = unusedInThisStage.warnings.intersect(prevUnused.warnings)
-        data.unusedAggregate = Some(UnusedResult(intersection))
-    }
-
-
 
   /** Do the actual reporting given the result of the anaylsis */
   private def reportUnused(res: UnusedData.UnusedResult)(using Context): Unit =
@@ -371,6 +360,17 @@ object CheckUnused:
       execInNewScope
       popScope()
 
+    def finishAggregation(using Context)(): Unit =
+      val unusedInThisStage = this.getUnused
+      this.unusedAggregate match {
+        case None =>
+          this.unusedAggregate = Some(unusedInThisStage)
+        case Some(prevUnused) =>
+          val intersection = unusedInThisStage.warnings.intersect(prevUnused.warnings)
+          this.unusedAggregate = Some(UnusedResult(intersection))
+      }
+
+
     /**
      * Register a found (used) symbol along with its name
      *
@@ -534,7 +534,7 @@ object CheckUnused:
         val pos = s.pos.sourcePos
         (pos.line, pos.column)
       }
-      UnusedResult(warnings)
+      UnusedResult(warnings.toSet)
     end getUnused
     //============================ HELPERS ====================================
 
@@ -735,7 +735,7 @@ object CheckUnused:
       /** A container for the results of the used elements analysis */
       case class UnusedResult(warnings: Set[UnusedSymbol])
       object UnusedResult:
-        val Empty = UnusedResult(Nil)
+        val Empty = UnusedResult(Set.empty)
 
 end CheckUnused
 

From 013a2842092a31461b2a1eb4a7d81aa3cd762d70 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Thu, 13 Apr 2023 17:28:33 +0200
Subject: [PATCH 369/657] Fix tests for WUnused/disable for public defs

---
 .../fatal-warnings/i15503e.scala              | 30 +++++++++----------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/tests/neg-custom-args/fatal-warnings/i15503e.scala b/tests/neg-custom-args/fatal-warnings/i15503e.scala
index 6d166aff7347..57664cd08dcd 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503e.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503e.scala
@@ -14,7 +14,7 @@ object Foo {
 
 package scala2main.unused.args:
   object happyBirthday {
-    def main(args: Array[String]): Unit = println("Hello World") // error
+    def main(args: Array[String]): Unit = println("Hello World") // ok
   }
 
 package scala2main:
@@ -31,7 +31,7 @@ package scala3main:
 package foo.test.lambda.param:
   val default_val = 1
   val a = (i: Int) => i // OK
-  val b = (i: Int) => default_val // error
+  val b = (i: Int) => default_val // OK
   val c = (_: Int) => default_val // OK
 
 package foo.test.trivial:
@@ -39,19 +39,19 @@ package foo.test.trivial:
   class C {
     def answer: 42 = 42
     object X
-    def g0(x: Int) = ??? // OK
-    def f0(x: Int) = () // OK
-    def f1(x: Int) = throw new RuntimeException // OK
-    def f2(x: Int) = 42 // OK
-    def f3(x: Int): Option[Int] = None // OK
-    def f4(x: Int) = classOf[Int] // OK
-    def f5(x: Int) = answer + 27 // OK
-    def f6(x: Int) = X // OK
-    def f7(x: Int) = Y // OK
-    def f8(x: Int): List[C] = Nil // OK
-    def f9(x: Int): List[Int] = List(1,2,3,4) // error
-    def foo:Int = 32  // OK
-    def f77(x: Int) = foo // error
+    private def g0(x: Int) = ??? // OK
+    private def f0(x: Int) = () // OK
+    private def f1(x: Int) = throw new RuntimeException // OK
+    private def f2(x: Int) = 42 // OK
+    private def f3(x: Int): Option[Int] = None // OK
+    private def f4(x: Int) = classOf[Int] // OK
+    private def f5(x: Int) = answer + 27 // OK
+    private def f6(x: Int) = X // OK
+    private def f7(x: Int) = Y // OK
+    private def f8(x: Int): List[C] = Nil // OK
+    private def f9(x: Int): List[Int] = List(1,2,3,4) // error
+    private def foo:Int = 32  // OK
+    private def f77(x: Int) = foo // error
   }
   object Y
 

From 49d9901bcccee72515a196832bcb471c289b8229 Mon Sep 17 00:00:00 2001
From: Jamie Thompson <bishbashboshjt@gmail.com>
Date: Fri, 14 Apr 2023 11:56:54 +0200
Subject: [PATCH 370/657] correctly type Expr.ofTupleFromSeq for arity > 22

---
 library/src/scala/quoted/Expr.scala | 15 +++++++++++-
 tests/run-macros/i17257/a.scala     | 38 +++++++++++++++++++++++++++++
 tests/run-macros/i17257/b.scala     | 21 ++++++++++++++++
 3 files changed, 73 insertions(+), 1 deletion(-)
 create mode 100644 tests/run-macros/i17257/a.scala
 create mode 100644 tests/run-macros/i17257/b.scala

diff --git a/library/src/scala/quoted/Expr.scala b/library/src/scala/quoted/Expr.scala
index 996fe3ff8da2..72ceaa8ffadd 100644
--- a/library/src/scala/quoted/Expr.scala
+++ b/library/src/scala/quoted/Expr.scala
@@ -103,7 +103,7 @@ object Expr {
       case 20 => ofTupleFromSeq20(seq)
       case 21 => ofTupleFromSeq21(seq)
       case 22 => ofTupleFromSeq22(seq)
-      case _ => '{ Tuple.fromIArray(IArray(${Varargs(seq)}: _*)) }
+      case _ => ofTupleFromSeqXXL(seq)
     }
   }
 
@@ -214,6 +214,19 @@ object Expr {
       case Seq('{ $x1: t1 }, '{ $x2: t2 }, '{ $x3: t3 }, '{ $x4: t4 }, '{ $x5: t5 }, '{ $x6: t6 }, '{ $x7: t7 }, '{ $x8: t8 }, '{ $x9: t9 }, '{ $x10: t10 }, '{ $x11: t11 }, '{ $x12: t12 }, '{ $x13: t13 }, '{ $x14: t14 }, '{ $x15: t15 }, '{ $x16: t16 }, '{ $x17: t17 }, '{ $x18: t18 }, '{ $x19: t19 }, '{ $x20: t20 }, '{ $x21: t21 }, '{ $x22: t22 }) =>
         '{ Tuple22($x1, $x2, $x3, $x4, $x5, $x6, $x7, $x8, $x9, $x10, $x11, $x12, $x13, $x14, $x15, $x16, $x17, $x18, $x19, $x20, $x21, $x22) }
 
+  private def ofTupleFromSeqXXL(seq: Seq[Expr[Any]])(using Quotes): Expr[Tuple] =
+    val tupleTpe = tupleTypeFromSeq(seq)
+    tupleTpe.asType match
+      case '[tpe] =>
+        '{ Tuple.fromIArray(IArray(${Varargs(seq)}: _*)).asInstanceOf[tpe & Tuple] }
+
+  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) =>
+      expr match
+        case '{ $e: t } => AppliedType(consRef, TypeRepr.of[t] :: ts :: Nil)
+    }
 
   /** Given a tuple of the form `(Expr[A1], ..., Expr[An])`, outputs a tuple `Expr[(A1, ..., An)]`. */
   def ofTuple[T <: Tuple: Tuple.IsMappedBy[Expr]: Type](tup: T)(using Quotes): Expr[Tuple.InverseMap[T, Expr]] = {
diff --git a/tests/run-macros/i17257/a.scala b/tests/run-macros/i17257/a.scala
new file mode 100644
index 000000000000..873e8a6e84a2
--- /dev/null
+++ b/tests/run-macros/i17257/a.scala
@@ -0,0 +1,38 @@
+package derivation
+import scala.quoted.*
+
+import scala.annotation.tailrec
+
+object Helpers:
+
+  // file a.scala
+  inline def summonAllOptimized[T <: Tuple]: T =
+    ${ summonAllOptimizedImpl[T] }
+
+  private def summonAllOptimizedImpl[T <: Tuple: Type](using q: Quotes): Expr[T] = {
+    import q.reflect.*
+
+    Expr
+      .ofTupleFromSeq(typesOfTuple(TypeRepr.of[T], Nil).map { tpe =>
+        tpe.asType match {
+          case '[t] =>
+            Expr.summon[t].getOrElse(report.errorAndAbort(s"Unable to to find implicit instance for ${tpe.show}"))
+        }
+      })
+      .asExprOf[T]
+  }
+
+  @tailrec
+  private[derivation] def typesOfTuple(
+      using q: Quotes
+  )(tpe: q.reflect.TypeRepr, acc: List[q.reflect.TypeRepr]): List[q.reflect.TypeRepr] =
+    import q.reflect.*
+    val cons = Symbol.classSymbol("scala.*:")
+    tpe.widenTermRefByName.dealias match
+      case AppliedType(fn, tpes) if defn.isTupleClass(fn.typeSymbol) =>
+        tpes.reverse_:::(acc)
+      case AppliedType(tp, List(headType, tailType)) if tp.derivesFrom(cons) =>
+        typesOfTuple(tailType, headType :: acc)
+      case tpe =>
+        if tpe.derivesFrom(Symbol.classSymbol("scala.EmptyTuple")) then acc.reverse
+        else report.errorAndAbort(s"Unknown type encountered in tuple ${tpe.show}")
diff --git a/tests/run-macros/i17257/b.scala b/tests/run-macros/i17257/b.scala
new file mode 100644
index 000000000000..b9159973fbc4
--- /dev/null
+++ b/tests/run-macros/i17257/b.scala
@@ -0,0 +1,21 @@
+package derivation {
+  //file b.scala
+  val test = Helpers.summonAllOptimized[(
+      ValueOf["a"], ValueOf["a"], ValueOf["a"], ValueOf["a"], ValueOf["a"],
+      ValueOf["a"], ValueOf["a"], ValueOf["a"], ValueOf["a"], ValueOf["a"],
+      ValueOf["a"], ValueOf["a"], ValueOf["a"], ValueOf["a"], ValueOf["a"],
+      ValueOf["a"], ValueOf["a"], ValueOf["a"], ValueOf["a"], ValueOf["a"],
+      ValueOf["a"], ValueOf["a"], ValueOf["a"] //Commenting out the last one here fixes the compile error
+    )]
+}
+@main def Test =
+  def assertions(list: List[ValueOf["a"]]): Unit =
+    assert(list.size == 23)
+    assert(list.map(_.value) == List(
+      "a", "a", "a", "a", "a",
+      "a", "a", "a", "a", "a",
+      "a", "a", "a", "a", "a",
+      "a", "a", "a", "a", "a",
+      "a", "a", "a"
+    ))
+  assertions(derivation.test.toList)

From 799f22592a88546780691207d16c07c243b6a6c9 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Fri, 14 Apr 2023 12:58:37 +0200
Subject: [PATCH 371/657] Fix failing main due to wunused

---
 tests/neg-custom-args/fatal-warnings/i15503e.scala | 4 ++--
 tests/neg-custom-args/fatal-warnings/i15503g.scala | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/neg-custom-args/fatal-warnings/i15503e.scala b/tests/neg-custom-args/fatal-warnings/i15503e.scala
index 57664cd08dcd..b1b2e73d51a8 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503e.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503e.scala
@@ -8,7 +8,7 @@ object Foo {
   private def f2(a: Int) = default_val // error
   private def f3(a: Int)(using Int) = a // OK
   private def f4(a: Int)(using Int) = default_val // error
-  private def f6(a: Int)(using Int) = summon[Int] // error
+  private def f6(a: Int)(using Int) = summon[Int] // ok
   private def f7(a: Int)(using Int) = summon[Int] + a // OK
 }
 
@@ -49,7 +49,7 @@ package foo.test.trivial:
     private def f6(x: Int) = X // OK
     private def f7(x: Int) = Y // OK
     private def f8(x: Int): List[C] = Nil // OK
-    private def f9(x: Int): List[Int] = List(1,2,3,4) // error
+    private def f9(x: Int): List[Int] = List(1,2,3,4) // ok
     private def foo:Int = 32  // OK
     private def f77(x: Int) = foo // error
   }
diff --git a/tests/neg-custom-args/fatal-warnings/i15503g.scala b/tests/neg-custom-args/fatal-warnings/i15503g.scala
index 2185bfed711d..da2921351519 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503g.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503g.scala
@@ -8,7 +8,7 @@ object Foo {
   private def f2(a: Int) = default_int // error
   private def f3(a: Int)(using Int) = a // OK
   private def f4(a: Int)(using Int) = default_int // error
-  private def f6(a: Int)(using Int) = summon[Int] // error
+  private def f6(a: Int)(using Int) = summon[Int] // ok
   private def f7(a: Int)(using Int) = summon[Int] + a // OK
   /* --- Trivial method check --- */
   private def g1(x: Int) = 1 // OK

From abe1879401d109b19907224fb489b10ce860b788 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Fri, 14 Apr 2023 14:11:20 +0200
Subject: [PATCH 372/657] Fix condition in checking if method is private in
 CHeckUnused

---
 compiler/src/dotty/tools/dotc/transform/CheckUnused.scala | 2 +-
 tests/neg-custom-args/fatal-warnings/i15503e.scala        | 4 ++--
 tests/neg-custom-args/fatal-warnings/i15503f.scala        | 2 +-
 tests/neg-custom-args/fatal-warnings/i15503g.scala        | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index df916fc76a3b..ce05e6c125de 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -118,7 +118,7 @@ class CheckUnused private (phaseMode: CheckUnused.PhaseMode, suffix: String, _ke
 
   override def prepareForDefDef(tree: tpd.DefDef)(using Context): Context =
     unusedDataApply{ ud =>
-      if !tree.rawMods.is(Private) then
+      if !tree.symbol.is(Private) then
         tree.termParamss.flatten.foreach { p =>
           ud.addIgnoredParam(p.symbol)
         }
diff --git a/tests/neg-custom-args/fatal-warnings/i15503e.scala b/tests/neg-custom-args/fatal-warnings/i15503e.scala
index b1b2e73d51a8..57664cd08dcd 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503e.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503e.scala
@@ -8,7 +8,7 @@ object Foo {
   private def f2(a: Int) = default_val // error
   private def f3(a: Int)(using Int) = a // OK
   private def f4(a: Int)(using Int) = default_val // error
-  private def f6(a: Int)(using Int) = summon[Int] // ok
+  private def f6(a: Int)(using Int) = summon[Int] // error
   private def f7(a: Int)(using Int) = summon[Int] + a // OK
 }
 
@@ -49,7 +49,7 @@ package foo.test.trivial:
     private def f6(x: Int) = X // OK
     private def f7(x: Int) = Y // OK
     private def f8(x: Int): List[C] = Nil // OK
-    private def f9(x: Int): List[Int] = List(1,2,3,4) // ok
+    private def f9(x: Int): List[Int] = List(1,2,3,4) // error
     private def foo:Int = 32  // OK
     private def f77(x: Int) = foo // error
   }
diff --git a/tests/neg-custom-args/fatal-warnings/i15503f.scala b/tests/neg-custom-args/fatal-warnings/i15503f.scala
index f909272af732..1dc16283caa8 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503f.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503f.scala
@@ -8,7 +8,7 @@ object Xd {
   private def f2(a: Int) = 1 // OK
   private def f3(a: Int)(using Int) = a // OK
   private def f4(a: Int)(using Int) = default_int // OK
-  private def f6(a: Int)(using Int) = summon[Int] // OK
+  private def f6(a: Int)(using Int) = summon[Int] // error
   private def f7(a: Int)(using Int) = summon[Int] + a // OK
   private def f8(a: Int)(using foo: Int) = a // error
 }
diff --git a/tests/neg-custom-args/fatal-warnings/i15503g.scala b/tests/neg-custom-args/fatal-warnings/i15503g.scala
index da2921351519..2185bfed711d 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503g.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503g.scala
@@ -8,7 +8,7 @@ object Foo {
   private def f2(a: Int) = default_int // error
   private def f3(a: Int)(using Int) = a // OK
   private def f4(a: Int)(using Int) = default_int // error
-  private def f6(a: Int)(using Int) = summon[Int] // ok
+  private def f6(a: Int)(using Int) = summon[Int] // error
   private def f7(a: Int)(using Int) = summon[Int] + a // OK
   /* --- Trivial method check --- */
   private def g1(x: Int) = 1 // OK

From ffa268222a3c989229731cf33e901a2c9cc4edab Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Fri, 14 Apr 2023 18:14:51 +0200
Subject: [PATCH 373/657] Remove unnecessary test

---
 tests/neg-custom-args/fatal-warnings/i15503i.scala | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/tests/neg-custom-args/fatal-warnings/i15503i.scala b/tests/neg-custom-args/fatal-warnings/i15503i.scala
index 3b653bfadb0a..fefead7f01a3 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503i.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503i.scala
@@ -46,9 +46,6 @@ package foo.test.scala.annotation:
   def a1(a: Int) = a // OK
   def a2(a: Int) = default_int // ok
 
-  private def a2_p(a: Int) = default_int // error
-  def a2_p_used = a2_p(3)
-
   def a3(@unused a: Int) = default_int //OK
 
   def b1 =

From 8fdd8d61e6ee9a22f1be7698813d55f37064950b Mon Sep 17 00:00:00 2001
From: Simon R <dev.jaca@gmail.com>
Date: Sat, 15 Apr 2023 11:25:17 +0200
Subject: [PATCH 374/657] Adjust failing expectation in WUnused tests

---
 tests/neg-custom-args/fatal-warnings/i15503f.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/neg-custom-args/fatal-warnings/i15503f.scala b/tests/neg-custom-args/fatal-warnings/i15503f.scala
index 1dc16283caa8..f909272af732 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503f.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503f.scala
@@ -8,7 +8,7 @@ object Xd {
   private def f2(a: Int) = 1 // OK
   private def f3(a: Int)(using Int) = a // OK
   private def f4(a: Int)(using Int) = default_int // OK
-  private def f6(a: Int)(using Int) = summon[Int] // error
+  private def f6(a: Int)(using Int) = summon[Int] // OK
   private def f7(a: Int)(using Int) = summon[Int] + a // OK
   private def f8(a: Int)(using foo: Int) = a // error
 }

From a599381adad45f93bdd0d081d3e3ca8036dc83e2 Mon Sep 17 00:00:00 2001
From: Philippus <philippus@gmail.com>
Date: Sat, 15 Apr 2023 15:39:14 +0200
Subject: [PATCH 375/657] Update asm to 9.5

---
 compiler/src/dotty/tools/backend/jvm/BackendUtils.scala     | 1 +
 compiler/src/dotty/tools/dotc/config/ScalaSettings.scala    | 2 +-
 project/Build.scala                                         | 2 +-
 tests/pos-with-compiler-cc/backend/jvm/BCodeIdiomatic.scala | 3 ++-
 tests/pos-with-compiler-cc/dotc/config/ScalaSettings.scala  | 2 +-
 5 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/compiler/src/dotty/tools/backend/jvm/BackendUtils.scala b/compiler/src/dotty/tools/backend/jvm/BackendUtils.scala
index d54364b1675f..2eaaccdd441d 100644
--- a/compiler/src/dotty/tools/backend/jvm/BackendUtils.scala
+++ b/compiler/src/dotty/tools/backend/jvm/BackendUtils.scala
@@ -35,6 +35,7 @@ class BackendUtils(val postProcessor: PostProcessor) {
     case "18" => asm.Opcodes.V18
     case "19" => asm.Opcodes.V19
     case "20" => asm.Opcodes.V20
+    case "21" => asm.Opcodes.V21
   }
 
   lazy val extraProc: Int = {
diff --git a/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala b/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala
index 32cb030a3296..c06aa304ef72 100644
--- a/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala
+++ b/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala
@@ -17,7 +17,7 @@ class ScalaSettings extends SettingGroup with AllScalaSettings
 object ScalaSettings:
   // Keep synchronized with `classfileVersion` in `BackendUtils`
   private val minTargetVersion = 8
-  private val maxTargetVersion = 20
+  private val maxTargetVersion = 21
 
   def supportedTargetVersions: List[String] =
     (minTargetVersion to maxTargetVersion).toList.map(_.toString)
diff --git a/project/Build.scala b/project/Build.scala
index 82b7fee64879..2689aa65f972 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -547,7 +547,7 @@ object Build {
 
       // get libraries onboard
       libraryDependencies ++= Seq(
-        "org.scala-lang.modules" % "scala-asm" % "9.4.0-scala-1", // used by the backend
+        "org.scala-lang.modules" % "scala-asm" % "9.5.0-scala-1", // used by the backend
         Dependencies.oldCompilerInterface, // we stick to the old version to avoid deprecation warnings
         "org.jline" % "jline-reader" % "3.19.0",   // used by the REPL
         "org.jline" % "jline-terminal" % "3.19.0",
diff --git a/tests/pos-with-compiler-cc/backend/jvm/BCodeIdiomatic.scala b/tests/pos-with-compiler-cc/backend/jvm/BCodeIdiomatic.scala
index 77e58440aa97..5eb8d7a52aa2 100644
--- a/tests/pos-with-compiler-cc/backend/jvm/BCodeIdiomatic.scala
+++ b/tests/pos-with-compiler-cc/backend/jvm/BCodeIdiomatic.scala
@@ -54,7 +54,8 @@ trait BCodeIdiomatic extends caps.Pure {
     case "17" => asm.Opcodes.V17
     case "18" => asm.Opcodes.V18
     case "19" => asm.Opcodes.V19
-    case "20" => asm.Opcodes.V20*/
+    case "20" => asm.Opcodes.V20
+    case "21" => asm.Opcodes.V21*/
   }
 
   lazy val majorVersion: Int = (classfileVersion & 0xFF)
diff --git a/tests/pos-with-compiler-cc/dotc/config/ScalaSettings.scala b/tests/pos-with-compiler-cc/dotc/config/ScalaSettings.scala
index f7743dddda4e..20708b98cc95 100644
--- a/tests/pos-with-compiler-cc/dotc/config/ScalaSettings.scala
+++ b/tests/pos-with-compiler-cc/dotc/config/ScalaSettings.scala
@@ -17,7 +17,7 @@ class ScalaSettings extends SettingGroup with AllScalaSettings
 object ScalaSettings:
   // Keep synchronized with `classfileVersion` in `BCodeIdiomatic`
   private val minTargetVersion = 8
-  private val maxTargetVersion = 20
+  private val maxTargetVersion = 21
 
   def supportedTargetVersions: List[String] =
     (minTargetVersion to maxTargetVersion).toList.map(_.toString)

From 0d2ffb59fb2b23b41ce8f6b7b4aa478e658fdde3 Mon Sep 17 00:00:00 2001
From: Florian3k <mfornal@virtuslab.com>
Date: Fri, 14 Apr 2023 10:19:22 +0200
Subject: [PATCH 376/657] scaladoc: fix crash when processing extends call

---
 scaladoc-testcases/src/tests/extendsCall.scala |  6 ++++++
 .../scaladoc/tasty/ClassLikeSupport.scala      | 18 +++++++++++-------
 .../TranslatableSignaturesTestCases.scala      |  2 ++
 3 files changed, 19 insertions(+), 7 deletions(-)
 create mode 100644 scaladoc-testcases/src/tests/extendsCall.scala

diff --git a/scaladoc-testcases/src/tests/extendsCall.scala b/scaladoc-testcases/src/tests/extendsCall.scala
new file mode 100644
index 000000000000..b90af8162e15
--- /dev/null
+++ b/scaladoc-testcases/src/tests/extendsCall.scala
@@ -0,0 +1,6 @@
+package tests
+package extendsCall
+
+class Impl() extends Base(Seq.empty, c = "-") //expected: class Impl() extends Base
+
+class Base(val a: Seq[String], val b: String = "", val c: String = "") //expected: class Base(val a: Seq[String], val b: String, val c: String)
diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala
index 0c85dff0879f..40548ae97a89 100644
--- a/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala
@@ -64,14 +64,18 @@ trait ClassLikeSupport:
     signatureOnly: Boolean = false,
     modifiers: Seq[Modifier] = classDef.symbol.getExtraModifiers(),
   ): Member =
-    def unpackTreeToClassDef(tree: Tree): ClassDef = tree match
-      case tree: ClassDef => tree
-      case TypeDef(_, tbt: TypeBoundsTree) => unpackTreeToClassDef(tbt.tpe.typeSymbol.tree)
-      case TypeDef(_, tt: TypeTree) => unpackTreeToClassDef(tt.tpe.typeSymbol.tree)
-      case c: Apply =>
-        c.symbol.owner.tree.symbol.tree match
+    def unpackTreeToClassDef(tree: Tree): ClassDef =
+      def unpackApply(a: Apply) =
+        a.symbol.owner.tree.symbol.tree match
           case tree: ClassDef => tree
-      case tt: TypeTree => unpackTreeToClassDef(tt.tpe.typeSymbol.tree)
+
+      tree match
+        case tree: ClassDef => tree
+        case TypeDef(_, tbt: TypeBoundsTree) => unpackTreeToClassDef(tbt.tpe.typeSymbol.tree)
+        case TypeDef(_, tt: TypeTree) => unpackTreeToClassDef(tt.tpe.typeSymbol.tree)
+        case c: Apply => unpackApply(c)
+        case Block(_, c: Apply) => unpackApply(c)
+        case tt: TypeTree => unpackTreeToClassDef(tt.tpe.typeSymbol.tree)
 
     def signatureWithName(s: dotty.tools.scaladoc.Signature): dotty.tools.scaladoc.Signature =
       s match
diff --git a/scaladoc/test/dotty/tools/scaladoc/signatures/TranslatableSignaturesTestCases.scala b/scaladoc/test/dotty/tools/scaladoc/signatures/TranslatableSignaturesTestCases.scala
index 302ee39d6351..a09234be5512 100644
--- a/scaladoc/test/dotty/tools/scaladoc/signatures/TranslatableSignaturesTestCases.scala
+++ b/scaladoc/test/dotty/tools/scaladoc/signatures/TranslatableSignaturesTestCases.scala
@@ -108,3 +108,5 @@ class ImplicitMembers extends SignatureTest(
 )
 
 class NonScala3Parent extends SignatureTest("nonScala3Parent", SignatureTest.all)
+
+class ExtendsCall extends SignatureTest("extendsCall", SignatureTest.all)

From faf70f8dea4d8cde2501530cc289432d5b6755e5 Mon Sep 17 00:00:00 2001
From: Jamie Thompson <bishbashboshjt@gmail.com>
Date: Mon, 17 Apr 2023 13:12:20 +0200
Subject: [PATCH 377/657] test Expr.ofTuple

---
 tests/run-macros/i17257/a.scala | 15 +++++++++++++++
 tests/run-macros/i17257/b.scala |  2 ++
 2 files changed, 17 insertions(+)

diff --git a/tests/run-macros/i17257/a.scala b/tests/run-macros/i17257/a.scala
index 873e8a6e84a2..4a5682327604 100644
--- a/tests/run-macros/i17257/a.scala
+++ b/tests/run-macros/i17257/a.scala
@@ -9,6 +9,9 @@ object Helpers:
   inline def summonAllOptimized[T <: Tuple]: T =
     ${ summonAllOptimizedImpl[T] }
 
+  inline def summon23[E]: (E, E, E, E, E, E, E, E, E, E, E, E, E, E, E, E, E, E, E, E, E, E, E) =
+    ${ summon23Impl[E] }
+
   private def summonAllOptimizedImpl[T <: Tuple: Type](using q: Quotes): Expr[T] = {
     import q.reflect.*
 
@@ -22,6 +25,18 @@ object Helpers:
       .asExprOf[T]
   }
 
+  private def summon23Impl[E: Type](using q: Quotes): Expr[(E, E, E, E, E, E, E, E, E, E, E, E, E, E, E, E, E, E, E, E, E, E, E)] = {
+    import q.reflect.*
+
+    val e = Expr.summon[E].getOrElse(report.errorAndAbort(s"Unable to to find implicit instance for ${TypeRepr.of[E].show}"))
+
+    val tuple = (e, e, e, e, e, e, e, e, e, e, e, e, e, e, e, e, e, e, e, e, e, e, e)
+
+    assert(tuple.size == 23)
+
+    Expr.ofTuple(tuple)
+  }
+
   @tailrec
   private[derivation] def typesOfTuple(
       using q: Quotes
diff --git a/tests/run-macros/i17257/b.scala b/tests/run-macros/i17257/b.scala
index b9159973fbc4..65d66fb20bff 100644
--- a/tests/run-macros/i17257/b.scala
+++ b/tests/run-macros/i17257/b.scala
@@ -7,6 +7,7 @@ package derivation {
       ValueOf["a"], ValueOf["a"], ValueOf["a"], ValueOf["a"], ValueOf["a"],
       ValueOf["a"], ValueOf["a"], ValueOf["a"] //Commenting out the last one here fixes the compile error
     )]
+  val test2 = Helpers.summon23[ValueOf["a"]]
 }
 @main def Test =
   def assertions(list: List[ValueOf["a"]]): Unit =
@@ -19,3 +20,4 @@ package derivation {
       "a", "a", "a"
     ))
   assertions(derivation.test.toList)
+  assertions(derivation.test2.toList)

From b3cfa95119f2041078e1e03f47f040cb0ed61a59 Mon Sep 17 00:00:00 2001
From: Jamie Thompson <bishbashboshjt@gmail.com>
Date: Mon, 17 Apr 2023 13:50:37 +0200
Subject: [PATCH 378/657] small optimisation

---
 library/src/scala/quoted/Expr.scala | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/library/src/scala/quoted/Expr.scala b/library/src/scala/quoted/Expr.scala
index 72ceaa8ffadd..8243e7dc4a4b 100644
--- a/library/src/scala/quoted/Expr.scala
+++ b/library/src/scala/quoted/Expr.scala
@@ -218,14 +218,13 @@ object Expr {
     val tupleTpe = tupleTypeFromSeq(seq)
     tupleTpe.asType match
       case '[tpe] =>
-        '{ Tuple.fromIArray(IArray(${Varargs(seq)}: _*)).asInstanceOf[tpe & Tuple] }
+        '{ Tuple.fromIArray(IArray(${Varargs(seq)}*)).asInstanceOf[tpe & Tuple] }
 
   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) =>
-      expr match
-        case '{ $e: t } => AppliedType(consRef, TypeRepr.of[t] :: ts :: Nil)
+      AppliedType(consRef, expr.asTerm.tpe :: ts :: Nil)
     }
 
   /** Given a tuple of the form `(Expr[A1], ..., Expr[An])`, outputs a tuple `Expr[(A1, ..., An)]`. */

From 75e0460d875d70296c3ea30984b2d44bfc826b26 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 18 Apr 2023 10:55:30 +0200
Subject: [PATCH 379/657] Rename `TreeUnpickler.{readTerm => readTree}`

---
 .../tools/dotc/core/tasty/TreeUnpickler.scala | 118 +++++++++---------
 1 file changed, 59 insertions(+), 59 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
index 9078a8959112..428047d96e0c 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
@@ -114,7 +114,7 @@ class TreeUnpickler(reader: TastyReader,
     val rdr = new TreeReader(reader)
     mode match {
       case UnpickleMode.TopLevel => rdr.readTopLevel()
-      case UnpickleMode.Term => rdr.readTerm() :: Nil
+      case UnpickleMode.Term => rdr.readTree() :: Nil
       case UnpickleMode.TypeTree => rdr.readTpt() :: Nil
     }
   }
@@ -389,7 +389,7 @@ class TreeUnpickler(reader: TastyReader,
                 val hi = readVariances(readType())
                 createNullableTypeBounds(lo, hi)
             case ANNOTATEDtype =>
-              AnnotatedType(readType(), Annotation(readTerm()))
+              AnnotatedType(readType(), Annotation(readTree()))
             case ANDtype =>
               AndType(readType(), readType())
             case ORtype =>
@@ -488,7 +488,7 @@ class TreeUnpickler(reader: TastyReader,
     def readTypeRef(): Type =
       typeAtAddr(readAddr())
 
-    def readTermRef()(using Context): TermRef =
+    def readTreeRef()(using Context): TermRef =
       readType().asInstanceOf[TermRef]
 
     /** Under pureFunctions, map all function types to impure function types,
@@ -656,7 +656,7 @@ class TreeUnpickler(reader: TastyReader,
           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()
+            forkAt(rhsStart).readTree()
           }
         })
       goto(start)
@@ -739,7 +739,7 @@ class TreeUnpickler(reader: TastyReader,
       readByte()
       val end = readEnd()
       val tp = readType()
-      val lazyAnnotTree = readLaterWithOwner(end, _.readTerm())
+      val lazyAnnotTree = readLaterWithOwner(end, _.readTree())
       owner =>
         new DeferredSymAndTree(tp.typeSymbol, lazyAnnotTree(owner).complete):
           // Only force computation of symbol if it has the right name. This added
@@ -790,7 +790,7 @@ class TreeUnpickler(reader: TastyReader,
       if (sctx `ne` ctx) return processPackage(op)(using sctx)
       readByte()
       val end = readEnd()
-      val pid = ref(readTermRef()).asInstanceOf[RefTree]
+      val pid = ref(readTreeRef()).asInstanceOf[RefTree]
       op(pid, end)(using localContext(pid.symbol.moduleClass))
     }
 
@@ -858,7 +858,7 @@ class TreeUnpickler(reader: TastyReader,
             def complete(using Context) = inlines.Inlines.bodyToInline(sym)
           }
         else
-          readLater(end, _.readTerm())
+          readLater(end, _.readTree())
 
       def ValDef(tpt: Tree) =
         ta.assignType(untpd.ValDef(sym.name.asTermName, tpt, readRhs(using localCtx)), sym)
@@ -984,7 +984,7 @@ class TreeUnpickler(reader: TastyReader,
         case SELECTin =>
           val end = readEnd()
           readName()
-          readTerm() match
+          readTree() match
             case nu: New =>
               try nu.tpe
               finally goto(end)
@@ -1000,7 +1000,7 @@ class TreeUnpickler(reader: TastyReader,
       collectWhile(nextByte != SELFDEF && nextByte != DEFDEF) {
         nextUnsharedTag match
           case APPLY | TYPEAPPLY | BLOCK =>
-            if withArgs then readTerm()
+            if withArgs then readTree()
             else InferredTypeTree().withType(readParentType())
           case _ => readTpt()
       }
@@ -1095,7 +1095,7 @@ class TreeUnpickler(reader: TastyReader,
           setSpan(start, PackageDef(pid, readIndexedStats(exprOwner, end)))
         }
       case _ =>
-        readTerm()(using ctx.withOwner(exprOwner))
+        readTree()(using ctx.withOwner(exprOwner))
     }
 
     inline def readImportOrExport(inline mkTree:
@@ -1104,7 +1104,7 @@ class TreeUnpickler(reader: TastyReader,
       assert(sourcePathAt(start).isEmpty)
       readByte()
       readEnd()
-      val expr = readTerm()
+      val expr = readTree()
       setSpan(start, mkTree(expr, readSelectors()))
     }
 
@@ -1162,14 +1162,14 @@ class TreeUnpickler(reader: TastyReader,
 
 // ------ Reading trees -----------------------------------------------------
 
-    def readTerm()(using Context): Tree = {  // TODO: rename to readTree
+    def readTree()(using Context): Tree = {
       val sctx = sourceChangeContext()
-      if (sctx `ne` ctx) return readTerm()(using sctx)
+      if (sctx `ne` ctx) return readTree()(using sctx)
       val start = currentAddr
       val tag = readByte()
       pickling.println(s"reading term ${astTagToString(tag)} at $start, ${ctx.source}")
 
-      def readPathTerm(): Tree = {
+      def readPathTree(): Tree = {
         goto(start)
         readType() match {
           case path: TypeRef => TypeTree(path)
@@ -1189,12 +1189,12 @@ class TreeUnpickler(reader: TastyReader,
         ConstFold.Select(untpd.Select(qual, name).withType(tpe))
 
       def completeSelect(name: Name, sig: Signature, target: Name): Select =
-        val qual = readTerm()
+        val qual = readTree()
         val denot = accessibleDenot(qual.tpe.widenIfUnstable, name, sig, target)
         makeSelect(qual, name, denot)
 
       def readQualId(): (untpd.Ident, TypeRef) =
-        val qual = readTerm().asInstanceOf[untpd.Ident]
+        val qual = readTree().asInstanceOf[untpd.Ident]
         (untpd.Ident(qual.name).withSpan(qual.span), qual.tpe.asInstanceOf[TypeRef])
 
       def accessibleDenot(qualType: Type, name: Name, sig: Signature, target: Name) = {
@@ -1204,9 +1204,9 @@ class TreeUnpickler(reader: TastyReader,
         else qualType.findMember(name, pre, excluded = Private).atSignature(sig, target)
       }
 
-      def readSimpleTerm(): Tree = tag match {
+      def readSimpleTree(): Tree = tag match {
         case SHAREDterm =>
-          forkAt(readAddr()).readTerm()
+          forkAt(readAddr()).readTree()
         case IDENT =>
           untpd.Ident(readName()).withType(readType())
         case IDENTtpt =>
@@ -1225,16 +1225,16 @@ class TreeUnpickler(reader: TastyReader,
         case NEW =>
           New(readTpt())
         case THROW =>
-          Throw(readTerm())
+          Throw(readTree())
         case SINGLETONtpt =>
-          SingletonTypeTree(readTerm())
+          SingletonTypeTree(readTree())
         case BYNAMEtpt =>
           val arg = readTpt()
           ByNameTypeTree(if knowsPureFuns then arg else arg.adaptByNameArgUnderPureFuns)
         case NAMEDARG =>
-          NamedArg(readName(), readTerm())
+          NamedArg(readName(), readTree())
         case _ =>
-          readPathTerm()
+          readPathTree()
       }
 
       /** Adapt constructor calls where class has only using clauses from old to new scheme.
@@ -1271,58 +1271,58 @@ class TreeUnpickler(reader: TastyReader,
         tree.overwriteType(tree.tpe.simplified)
         tree
 
-      def readLengthTerm(): Tree = {
+      def readLengthTree(): Tree = {
         val end = readEnd()
         val result =
           (tag: @switch) match {
             case SUPER =>
-              val qual = readTerm()
+              val qual = readTree()
               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())
+              val fn = readTree()
+              val args = until(end)(readTree())
               if fn.symbol.isConstructor then constructorApply(fn, args)
               else tpd.Apply(fn, args)
             case TYPEAPPLY =>
-              tpd.TypeApply(readTerm(), until(end)(readTpt()))
+              tpd.TypeApply(readTree(), until(end)(readTpt()))
             case APPLYsigpoly =>
-              val fn = readTerm()
+              val fn = readTree()
               val methType = readType()
-              val args = until(end)(readTerm())
+              val args = until(end)(readTree())
               val fun2 = typer.Applications.retypeSignaturePolymorphicFn(fn, methType)
               tpd.Apply(fun2, args)
             case TYPED =>
-              val expr = readTerm()
+              val expr = readTree()
               val tpt = readTpt()
               Typed(expr, tpt)
             case ASSIGN =>
-              Assign(readTerm(), readTerm())
+              Assign(readTree(), readTree())
             case BLOCK =>
               val exprReader = fork
               skipTree()
               readStats(ctx.owner, end,
-                (stats, ctx) => Block(stats, exprReader.readTerm()(using ctx)))
+                (stats, ctx) => Block(stats, exprReader.readTree()(using ctx)))
             case INLINED =>
               val exprReader = fork
               skipTree()
               def maybeCall = nextUnsharedTag match {
                 case VALDEF | DEFDEF => EmptyTree
-                case _ => readTerm()
+                case _ => readTree()
               }
               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
+              val expansion = exprReader.readTree() // need bindings in scope, so needs to be read before
               Inlined(call, bindings, expansion)
             case IF =>
               if (nextByte == INLINE) {
                 readByte()
-                InlineIf(readTerm(), readTerm(), readTerm())
+                InlineIf(readTree(), readTree(), readTree())
               }
               else
-                If(readTerm(), readTerm(), readTerm())
+                If(readTree(), readTree(), readTree())
             case LAMBDA =>
-              val meth = readTerm()
+              val meth = readTree()
               val tpt = ifBefore(end)(readTpt(), EmptyTree)
               Closure(Nil, meth, tpt)
             case MATCH =>
@@ -1333,24 +1333,24 @@ class TreeUnpickler(reader: TastyReader,
                 }
                 else if (nextByte == INLINE) {
                   readByte()
-                  InlineMatch(readTerm(), readCases(end))
+                  InlineMatch(readTree(), readCases(end))
                 }
-                else Match(readTerm(), readCases(end)))
+                else Match(readTree(), readCases(end)))
             case RETURN =>
               val from = readSymRef()
-              val expr = ifBefore(end)(readTerm(), EmptyTree)
+              val expr = ifBefore(end)(readTree(), EmptyTree)
               Return(expr, Ident(from.termRef))
             case WHILE =>
-              WhileDo(readTerm(), readTerm())
+              WhileDo(readTree(), readTree())
             case TRY =>
               simplifyLub(
-                Try(readTerm(), readCases(end), ifBefore(end)(readTerm(), EmptyTree)))
+                Try(readTree(), readCases(end), ifBefore(end)(readTree(), EmptyTree)))
             case SELECTouter =>
               val levels = readNat()
-              readTerm().outerSelect(levels, SkolemType(readType()))
+              readTree().outerSelect(levels, SkolemType(readType()))
             case SELECTin =>
               var sname = readName()
-              val qual = readTerm()
+              val qual = readTree()
               val ownerTpe = readType()
               val owner = ownerTpe.typeSymbol
               val SignedName(name, sig, target) = sname: @unchecked // only methods with params use SELECTin
@@ -1381,26 +1381,26 @@ class TreeUnpickler(reader: TastyReader,
               makeSelect(qual, name, denot)
             case REPEATED =>
               val elemtpt = readTpt()
-              SeqLiteral(until(end)(readTerm()), elemtpt)
+              SeqLiteral(until(end)(readTree()), elemtpt)
             case BIND =>
               val sym = symAtAddr.getOrElse(start, forkAt(start).createSymbol())
               readName()
               readType()
-              val body = readTerm()
+              val body = readTree()
               val (givenFlags, _, _) = readModifiers(end)
               sym.setFlag(givenFlags)
               Bind(sym, body)
             case ALTERNATIVE =>
-              Alternative(until(end)(readTerm()))
+              Alternative(until(end)(readTree()))
             case UNAPPLY =>
-              val fn = readTerm()
+              val fn = readTree()
               val implicitArgs =
                 collectWhile(nextByte == IMPLICITarg) {
                   readByte()
-                  readTerm()
+                  readTree()
                 }
               val patType = readType()
-              val argPats = until(end)(readTerm())
+              val argPats = until(end)(readTree())
               UnApply(fn, implicitArgs, argPats, patType)
             case REFINEDtpt =>
               val refineCls = symAtAddr.getOrElse(start,
@@ -1420,7 +1420,7 @@ class TreeUnpickler(reader: TastyReader,
               val ownType = ctx.typeAssigner.processAppliedType(tree, tycon.tpe.safeAppliedTo(args.tpes))
               tree.withType(postProcessFunction(ownType))
             case ANNOTATEDtpt =>
-              Annotated(readTpt(), readTerm())
+              Annotated(readTpt(), readTree())
             case LAMBDAtpt =>
               val tparams = readParams[TypeDef](TYPEPARAM)
               val body = readTpt()
@@ -1438,16 +1438,16 @@ class TreeUnpickler(reader: TastyReader,
             case HOLE =>
               val idx = readNat()
               val tpe = readType()
-              val args = until(end)(readTerm())
+              val args = until(end)(readTree())
               Hole(true, idx, args, EmptyTree, TypeTree(tpe)).withType(tpe)
             case _ =>
-              readPathTerm()
+              readPathTree()
           }
         assert(currentAddr == end, s"$start $currentAddr $end ${astTagToString(tag)}")
         result
       }
 
-      val tree = if (tag < firstLengthTreeTag) readSimpleTerm() else readLengthTerm()
+      val tree = if (tag < firstLengthTreeTag) readSimpleTree() else readLengthTree()
       setSpan(start, tree)
     }
 
@@ -1472,10 +1472,10 @@ class TreeUnpickler(reader: TastyReader,
           val end = readEnd()
           val idx = readNat()
           val tpe = readType()
-          val args = until(end)(readTerm())
+          val args = until(end)(readTree())
           Hole(false, idx, args, EmptyTree, TypeTree(tpe)).withType(tpe)
         case _ =>
-          if (isTypeTreeTag(nextByte)) readTerm()
+          if (isTypeTreeTag(nextByte)) readTree()
           else {
             val start = currentAddr
             val tp = readType()
@@ -1500,9 +1500,9 @@ class TreeUnpickler(reader: TastyReader,
       val start = currentAddr
       assert(readByte() == CASEDEF)
       val end = readEnd()
-      val pat = readTerm()
-      val rhs = readTerm()
-      val guard = ifBefore(end)(readTerm(), EmptyTree)
+      val pat = readTree()
+      val rhs = readTree()
+      val guard = ifBefore(end)(readTree(), EmptyTree)
       setSpan(start, CaseDef(pat, guard, rhs))
     }
 

From 372d58d81f3ac69b4e2621c002164f93d5e295eb Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Tue, 18 Apr 2023 12:48:15 +0200
Subject: [PATCH 380/657] Add test for issue #17231

---
 compiler/test-resources/repl/i17231 | 2 ++
 1 file changed, 2 insertions(+)
 create mode 100644 compiler/test-resources/repl/i17231

diff --git a/compiler/test-resources/repl/i17231 b/compiler/test-resources/repl/i17231
new file mode 100644
index 000000000000..07a509fea917
--- /dev/null
+++ b/compiler/test-resources/repl/i17231
@@ -0,0 +1,2 @@
+scala> summon[ValueOf["a"]]
+val res0: ValueOf["a"] = scala.ValueOf@61

From fe4478be2ca86e5fe2e4e6860f666c6ff0ec6cfe Mon Sep 17 00:00:00 2001
From: Florian3k <mfornal@virtuslab.com>
Date: Tue, 18 Apr 2023 16:14:30 +0200
Subject: [PATCH 381/657] remove unnecessary .symbol.tree

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

diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala
index 40548ae97a89..49cb74073295 100644
--- a/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala
@@ -66,7 +66,7 @@ trait ClassLikeSupport:
   ): Member =
     def unpackTreeToClassDef(tree: Tree): ClassDef =
       def unpackApply(a: Apply) =
-        a.symbol.owner.tree.symbol.tree match
+        a.symbol.owner.tree match
           case tree: ClassDef => tree
 
       tree match

From 95d7e7941548c6e05361f8b9533dca478dfd426b Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 18 Apr 2023 17:04:59 +0200
Subject: [PATCH 382/657] Use `foreachSubTree` instead of new `TreeTraverser`

---
 .../tools/dotc/ast/TreeMapWithImplicits.scala | 14 ++-----
 .../dotty/tools/dotc/inlines/Inliner.scala    | 39 ++++++++-----------
 .../tools/dotc/quoted/PickledQuotes.scala     |  4 +-
 .../src/dotty/tools/dotc/typer/Checking.scala | 12 ++----
 4 files changed, 26 insertions(+), 43 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/TreeMapWithImplicits.scala b/compiler/src/dotty/tools/dotc/ast/TreeMapWithImplicits.scala
index e52bf1064e4c..ae674c25dc3d 100644
--- a/compiler/src/dotty/tools/dotc/ast/TreeMapWithImplicits.scala
+++ b/compiler/src/dotty/tools/dotc/ast/TreeMapWithImplicits.scala
@@ -30,16 +30,10 @@ class TreeMapWithImplicits extends tpd.TreeMapWithPreciseStatContexts {
 
   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)
+    pattern.foreachSubTree {
+      case d: DefTree if d.symbol.isOneOf(GivenOrImplicitVal) => nestedCtx.enter(d.symbol)
+      case _ =>
+    }
     nestedCtx
   }
 
diff --git a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
index 872dc7793ff4..20124e04abd4 100644
--- a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
@@ -963,29 +963,24 @@ class Inliner(val call: tpd.Tree)(using Context):
         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)
+      def updateRefCount(sym: Symbol, inc: Int) =
+        for (x <- refCount.get(sym)) refCount(sym) = x + inc
+      def updateTermRefCounts(tree: Tree) =
+        tree.typeOpt.foreachPart {
+          case ref: TermRef => updateRefCount(ref.symbol, 2) // can't be inlined, so make sure refCount is at least 2
+          case _ =>
         }
-      }
-      countRefs.traverse(tree)
-      for (binding <- bindings) countRefs.traverse(binding)
+      def countRefs(tree: Tree) =
+        tree.foreachSubTree {
+          case t: RefTree =>
+            updateRefCount(t.symbol, 1)
+            updateTermRefCounts(t)
+          case t @ (_: New | _: TypeTree) =>
+            updateTermRefCounts(t)
+          case _ =>
+        }
+      countRefs(tree)
+      for (binding <- bindings) countRefs(binding)
 
       def retain(boundSym: Symbol) = {
         refCount.get(boundSym) match {
diff --git a/compiler/src/dotty/tools/dotc/quoted/PickledQuotes.scala b/compiler/src/dotty/tools/dotc/quoted/PickledQuotes.scala
index 20bcba417a5e..43e2aae4c58c 100644
--- a/compiler/src/dotty/tools/dotc/quoted/PickledQuotes.scala
+++ b/compiler/src/dotty/tools/dotc/quoted/PickledQuotes.scala
@@ -275,9 +275,7 @@ object PickledQuotes {
           QuotesCache(pickled) = tree
 
           // Make sure trees and positions are fully loaded
-          new TreeTraverser {
-            def traverse(tree: Tree)(using Context): Unit = traverseChildren(tree)
-          }.traverse(tree)
+          tree.foreachSubTree(identity)
 
           quotePickling.println(i"**** unpickled quote\n$tree")
 
diff --git a/compiler/src/dotty/tools/dotc/typer/Checking.scala b/compiler/src/dotty/tools/dotc/typer/Checking.scala
index bff9310dee88..436721a6774b 100644
--- a/compiler/src/dotty/tools/dotc/typer/Checking.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Checking.scala
@@ -1193,15 +1193,11 @@ trait Checking {
    */
   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)
-        }
+      vparam.tpt.foreachSubTree {
+        case id: Ident if vparams.exists(_.symbol == id.symbol) =>
+          report.error(em"illegal forward reference to method parameter", id.srcPos)
+        case _ =>
       }
-      check.traverse(vparam.tpt)
       checkNoForwardDependencies(vparams1)
     case Nil =>
   }

From 35b1d754ef7be055a73a08766a44acdec25635df Mon Sep 17 00:00:00 2001
From: xuwei-k <6b656e6a69@gmail.com>
Date: Tue, 18 Apr 2023 15:37:04 +0900
Subject: [PATCH 383/657] fix incorrect scaladoc `@param`

---
 compiler/src/dotty/tools/dotc/ast/Trees.scala             | 6 +++---
 compiler/src/dotty/tools/dotc/ast/tpd.scala               | 2 +-
 compiler/src/dotty/tools/dotc/core/SymDenotations.scala   | 2 +-
 compiler/src/dotty/tools/dotc/core/Symbols.scala          | 2 +-
 .../tools/dotc/core/unpickleScala2/Scala2Unpickler.scala  | 5 ++---
 compiler/src/dotty/tools/dotc/coverage/Location.scala     | 2 +-
 compiler/src/dotty/tools/dotc/inlines/Inliner.scala       | 2 +-
 .../src/dotty/tools/dotc/inlines/PrepareInlineable.scala  | 2 +-
 compiler/src/dotty/tools/dotc/plugins/Plugin.scala        | 6 +++---
 compiler/src/dotty/tools/dotc/transform/init/Cache.scala  | 4 ++--
 compiler/src/dotty/tools/dotc/typer/Implicits.scala       | 1 -
 compiler/src/dotty/tools/dotc/typer/RefChecks.scala       | 2 +-
 compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala    | 2 +-
 compiler/src/dotty/tools/dotc/util/Signatures.scala       | 2 +-
 compiler/src/dotty/tools/dotc/util/StackTraceOps.scala    | 1 -
 library/src/scala/quoted/Quotes.scala                     | 8 ++++----
 16 files changed, 23 insertions(+), 26 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala
index c0b5987c3875..1c1e80922c05 100644
--- a/compiler/src/dotty/tools/dotc/ast/Trees.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala
@@ -855,9 +855,9 @@ object Trees {
   }
 
   /** 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.
+   *  @param preParentsOrDerived 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], private var preParentsOrDerived: LazyTreeList[T], self: ValDef[T], private var preBody: LazyTreeList[T])(implicit @constructorOnly src: SourceFile)
     extends DefTree[T] with WithLazyFields {
diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
index d1b1cdf607b5..c6e0bc581b59 100644
--- a/compiler/src/dotty/tools/dotc/ast/tpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -1548,7 +1548,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
    *
    *  @param trees  the elements the list represented by
    *                the resulting tree should contain.
-   *  @param tpe    the type of the elements of the resulting list.
+   *  @param tpt    the type of the elements of the resulting list.
    *
    */
   def mkList(trees: List[Tree], tpt: Tree)(using Context): Tree =
diff --git a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
index beeaa2ee922e..bcd91336f627 100644
--- a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -1409,7 +1409,7 @@ object SymDenotations {
 
     /** The symbol overriding this symbol in given subclass `ofclazz`.
      *
-     *  @param ofclazz is a subclass of this symbol's owner
+     *  @pre `inClass` is a subclass of this symbol's owner
      */
     final def overridingSymbol(inClass: ClassSymbol)(using Context): Symbol =
       if (canMatchInheritedSymbols) matchingDecl(inClass, inClass.thisType)
diff --git a/compiler/src/dotty/tools/dotc/core/Symbols.scala b/compiler/src/dotty/tools/dotc/core/Symbols.scala
index aa3ae0c3c513..7397ed1fc705 100644
--- a/compiler/src/dotty/tools/dotc/core/Symbols.scala
+++ b/compiler/src/dotty/tools/dotc/core/Symbols.scala
@@ -40,7 +40,7 @@ object Symbols {
   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 myCoord 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)
diff --git a/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala b/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala
index 50b0b875c1fc..deb022d3c261 100644
--- a/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala
@@ -133,9 +133,8 @@ object Scala2Unpickler {
 /** 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
+ *  @param classRoot  the top-level class which is unpickled, or NoSymbol if inapplicable
+ *  @param moduleClassRoot the top-level module class which is unpickled, or NoSymbol if inapplicable
  */
 class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClassRoot: ClassDenotation)(ictx: Context)
   extends PickleBuffer(bytes, 0, -1) with ClassfileParser.Embedded {
diff --git a/compiler/src/dotty/tools/dotc/coverage/Location.scala b/compiler/src/dotty/tools/dotc/coverage/Location.scala
index c565c2bb1116..aa7a586d4b57 100644
--- a/compiler/src/dotty/tools/dotc/coverage/Location.scala
+++ b/compiler/src/dotty/tools/dotc/coverage/Location.scala
@@ -13,7 +13,7 @@ import dotty.tools.dotc.util.SourceFile
   * @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 methodName     name of the closest enclosing method
   * @param sourcePath     absolute path of the source file
   */
 final case class Location(
diff --git a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
index 872dc7793ff4..54f3c8562f9f 100644
--- a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
@@ -201,7 +201,7 @@ class Inliner(val call: tpd.Tree)(using Context):
    *  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 arg0        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,
diff --git a/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala b/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
index 7a0d3f61cb33..33bc5a7ef10e 100644
--- a/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
@@ -256,7 +256,7 @@ object PrepareInlineable {
 
   /** Register inline info for given inlineable method `sym`.
    *
-   *  @param sym         The symbol denotation of the inlineable method for which info is registered
+   *  @param inlined     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
diff --git a/compiler/src/dotty/tools/dotc/plugins/Plugin.scala b/compiler/src/dotty/tools/dotc/plugins/Plugin.scala
index 21bb0fa2be54..be6fecebb55a 100644
--- a/compiler/src/dotty/tools/dotc/plugins/Plugin.scala
+++ b/compiler/src/dotty/tools/dotc/plugins/Plugin.scala
@@ -44,7 +44,7 @@ sealed trait Plugin {
 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)
+   *  @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]
@@ -57,8 +57,8 @@ trait StandardPlugin extends Plugin {
 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
+   *  @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]]
diff --git a/compiler/src/dotty/tools/dotc/transform/init/Cache.scala b/compiler/src/dotty/tools/dotc/transform/init/Cache.scala
index 054db090c3bc..c0391a05262d 100644
--- a/compiler/src/dotty/tools/dotc/transform/init/Cache.scala
+++ b/compiler/src/dotty/tools/dotc/transform/init/Cache.scala
@@ -50,8 +50,8 @@ import tpd.Tree
  *  need to be decided by the specific analysis and justified by reasoning about
  *  soundness.
  *
- *  @param Config The analysis state that matters for evaluating an expression.
- *  @param Res The result from the evaluation the given expression.
+ *  @tparam Config The analysis state that matters for evaluating an expression.
+ *  @tparam Res The result from the evaluation the given expression.
  */
 class Cache[Config, Res]:
   import Cache.*
diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
index a9631ad45e28..f303bfbc5e19 100644
--- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -1591,7 +1591,6 @@ trait Implicits:
     * 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 =
diff --git a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
index 4ca00ce6366f..73331046b41f 100644
--- a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
+++ b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
@@ -295,7 +295,7 @@ object RefChecks {
    *  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.
    *
-   *   @param makeOverridePairsChecker  A function for creating a OverridePairsChecker instance
+   *   @param makeOverridingPairsChecker A function for creating a OverridePairsChecker instance
    *                                    from the class symbol and the self type
    */
   def checkAllOverrides(clazz: ClassSymbol, makeOverridingPairsChecker: ((ClassSymbol, Type) => Context ?=> OverridingPairsChecker) | Null = null)(using Context): Unit = {
diff --git a/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala b/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
index 98e9cb638c17..6ac45cbcf04d 100644
--- a/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
+++ b/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
@@ -18,7 +18,7 @@ trait TypeAssigner {
   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.
+   *  @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) =
diff --git a/compiler/src/dotty/tools/dotc/util/Signatures.scala b/compiler/src/dotty/tools/dotc/util/Signatures.scala
index ddf89e7dd04d..5513a1f803c6 100644
--- a/compiler/src/dotty/tools/dotc/util/Signatures.scala
+++ b/compiler/src/dotty/tools/dotc/util/Signatures.scala
@@ -54,7 +54,7 @@ object Signatures {
    * 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
+   * @param pos  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).
diff --git a/compiler/src/dotty/tools/dotc/util/StackTraceOps.scala b/compiler/src/dotty/tools/dotc/util/StackTraceOps.scala
index 7fa54606c572..f991005f0c43 100644
--- a/compiler/src/dotty/tools/dotc/util/StackTraceOps.scala
+++ b/compiler/src/dotty/tools/dotc/util/StackTraceOps.scala
@@ -29,7 +29,6 @@ object StackTraceOps:
      *  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 =
diff --git a/library/src/scala/quoted/Quotes.scala b/library/src/scala/quoted/Quotes.scala
index edf8aa61b559..2ead4a8607a3 100644
--- a/library/src/scala/quoted/Quotes.scala
+++ b/library/src/scala/quoted/Quotes.scala
@@ -1429,9 +1429,9 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
        *  )
        *  ```
        *
-       *  @param owner: owner of the generated `meth` symbol
-       *  @param tpe: Type of the definition
-       *  @param rhsFn: Function that receives the `meth` symbol and the a list of references to the `params`
+       *  @param owner owner of the generated `meth` symbol
+       *  @param tpe Type of the definition
+       *  @param rhsFn Function that receives the `meth` symbol and the a list of references to the `params`
        */
       def apply(owner: Symbol, tpe: MethodType, rhsFn: (Symbol, List[Tree]) => Tree): Block
     }
@@ -1764,7 +1764,7 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
 
       /** Returns a type tree reference to the symbol
        *
-       *  @param sym  The type symbol for which we are creating a type tree reference.
+       *  @param typeSymbol The type symbol for which we are creating a type tree reference.
        */
       def ref(typeSymbol: Symbol): TypeTree
     }

From 5ded04cb95137bea026823e06d4b342d0266542d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Marks?= <pmarks@virtuslab.com>
Date: Wed, 19 Apr 2023 10:27:31 +0200
Subject: [PATCH 384/657] Set reference version to 3.3.0-RC4

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

diff --git a/project/Build.scala b/project/Build.scala
index 2689aa65f972..97b4d31f5e02 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -80,7 +80,7 @@ object DottyJSPlugin extends AutoPlugin {
 object Build {
   import ScaladocConfigs._
 
-  val referenceVersion = "3.3.0-RC3"
+  val referenceVersion = "3.3.0-RC4"
 
   val baseVersion = "3.3.1-RC1"
 

From 21ddebefcdf96d0d5d8c840f20e1f82fc5a94701 Mon Sep 17 00:00:00 2001
From: Guillaume Martres <smarter@ubuntu.com>
Date: Wed, 19 Apr 2023 14:30:23 +0200
Subject: [PATCH 385/657] Fix name of variable in comment

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

diff --git a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
index bcd91336f627..7cc8b6fe1c23 100644
--- a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -1407,7 +1407,7 @@ object SymDenotations {
         case Nil => Iterator.empty
       }
 
-    /** The symbol overriding this symbol in given subclass `ofclazz`.
+    /** The symbol overriding this symbol in given subclass `inClass`.
      *
      *  @pre `inClass` is a subclass of this symbol's owner
      */

From 6bf24dfdbc40af63d241b19a14019acae3caaecf Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Wed, 19 Apr 2023 15:50:29 +0200
Subject: [PATCH 386/657] Wunused: Check if symbol exists before
 isValidMemberDef check

closes lampepfl#17309
---
 compiler/src/dotty/tools/dotc/transform/CheckUnused.scala | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index ce05e6c125de..b3083223c555 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -681,7 +681,7 @@ object CheckUnused:
       /** A function is overriden. Either has `override flags` or parent has a matching member (type and name) */
       private def isOverriden(using Context): Boolean =
         sym.is(Flags.Override) ||
-        (if sym.exists then sym.owner.thisType.parents.exists(p => sym.matchingMember(p).exists) else false)
+          (sym.exists && sym.owner.thisType.parents.exists(p => sym.matchingMember(p).exists))
 
     end extension
 
@@ -708,7 +708,11 @@ object CheckUnused:
 
     extension (memDef: tpd.MemberDef)
       private def isValidMemberDef(using Context): Boolean =
-        !memDef.symbol.isUnusedAnnot && !memDef.symbol.isAllOf(Flags.AccessorCreationFlags) && !memDef.name.isWildcard && !memDef.symbol.owner.is(Extension)
+        memDef.symbol.exists
+          && !memDef.symbol.isUnusedAnnot
+          && !memDef.symbol.isAllOf(Flags.AccessorCreationFlags)
+          && !memDef.name.isWildcard
+          && !memDef.symbol.owner.is(ExtensionMethod)
 
       private def isValidParam(using Context): Boolean =
         val sym = memDef.symbol

From 5a1d2d3bc7e79148e23148c0b49cb3dedf84daa2 Mon Sep 17 00:00:00 2001
From: Natsu Kagami <nki@nkagami.me>
Date: Wed, 19 Apr 2023 15:38:00 +0200
Subject: [PATCH 387/657] Allow contextual functions with erased parameters to
 be integrated

- also add test from #17147
---
 .../dotty/tools/dotc/core/Definitions.scala   |  1 -
 .../transform/ContextFunctionResults.scala    | 12 ++++++++---
 tests/pos-custom-args/erased/tailrec.scala    | 20 +++++++++++++++++++
 3 files changed, 29 insertions(+), 4 deletions(-)
 create mode 100644 tests/pos-custom-args/erased/tailrec.scala

diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
index 148b314220a8..85aac4ce601c 100644
--- a/compiler/src/dotty/tools/dotc/core/Definitions.scala
+++ b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -1509,7 +1509,6 @@ class Definitions {
 
   /** Is an context function class.
    *   - ContextFunctionN for N >= 0
-   *   - ErasedContextFunctionN for N > 0
    */
   def isContextFunctionClass(cls: Symbol): Boolean = scalaClassName(cls).isContextFunction
 
diff --git a/compiler/src/dotty/tools/dotc/transform/ContextFunctionResults.scala b/compiler/src/dotty/tools/dotc/transform/ContextFunctionResults.scala
index 5863c360e728..b4eb71c541d3 100644
--- a/compiler/src/dotty/tools/dotc/transform/ContextFunctionResults.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ContextFunctionResults.scala
@@ -20,7 +20,7 @@ object ContextFunctionResults:
    */
   def annotateContextResults(mdef: DefDef)(using Context): Unit =
     def contextResultCount(rhs: Tree, tp: Type): Int = tp match
-      case defn.ContextFunctionType(_, resTpe, erasedParams) if !erasedParams.contains(true) /* Only enable for non-erased functions */ =>
+      case defn.ContextFunctionType(_, resTpe, _) =>
         rhs match
           case closureDef(meth) => 1 + contextResultCount(meth.rhs, resTpe)
           case _ => 0
@@ -116,8 +116,14 @@ object ContextFunctionResults:
       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)
+        if name == nme.apply then
+          qual.tpe match
+            case defn.ContextFunctionType(_, _, _) =>
+              integrateSelect(qual, n + 1)
+            case _ if defn.isContextFunctionClass(tree.symbol.maybeOwner) => // for TermRefs
+              integrateSelect(qual, n + 1)
+            case _ =>
+              n > 0 && contextResultCount(tree.symbol) >= n
         else
           n > 0 && contextResultCount(tree.symbol) >= n
       case Ident(name) =>
diff --git a/tests/pos-custom-args/erased/tailrec.scala b/tests/pos-custom-args/erased/tailrec.scala
new file mode 100644
index 000000000000..cebcf4785c7a
--- /dev/null
+++ b/tests/pos-custom-args/erased/tailrec.scala
@@ -0,0 +1,20 @@
+import scala.annotation.tailrec
+
+erased class Foo1
+class Foo2
+
+@tailrec
+final def test1(n: Int, acc: Int): (Foo1, Foo2) ?=> Int =
+  if n <= 0 then acc
+  else test1(n - 1, acc * n)
+
+@tailrec
+final def test2(n: Int, acc: Int): Foo1 ?=> Int =
+  if n <= 0 then acc
+  else test2(n - 1, acc * n)
+
+@main def Test() =
+  given Foo1 = Foo1()
+  given Foo2 = Foo2()
+  test1(10, 0)
+  test2(10, 0)

From 0ba35e69973e7c53c537539c420f63b357a35cde Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Doeraene?= <sjrdoeraene@gmail.com>
Date: Thu, 20 Apr 2023 15:27:29 +0200
Subject: [PATCH 388/657] Fix #13757: Explicitly disallow higher-kinded
 scrutinees of match types.

---
 .../tools/dotc/reporting/ErrorMessageID.scala    |  1 +
 .../dotty/tools/dotc/reporting/messages.scala    |  5 +++++
 compiler/src/dotty/tools/dotc/typer/Typer.scala  |  5 ++++-
 tests/neg/i13757-match-type-anykind.scala        | 16 ++++++++++++++++
 4 files changed, 26 insertions(+), 1 deletion(-)
 create mode 100644 tests/neg/i13757-match-type-anykind.scala

diff --git a/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala b/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
index 1fe38ce5e801..b3d9b2c1dc49 100644
--- a/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
@@ -192,6 +192,7 @@ enum ErrorMessageID(val isActive: Boolean = true) extends java.lang.Enum[ErrorMe
   case UnusedNonUnitValueID // errorNumber 176
   case ConstrProxyShadowsID // errorNumber 177
   case MissingArgumentListID // errorNumber: 178
+  case MatchTypeScrutineeCannotBeHigherKindedID // errorNumber: 179
 
   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 fba08fd84d0c..1c3bd23de9c6 100644
--- a/compiler/src/dotty/tools/dotc/reporting/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/messages.scala
@@ -2878,3 +2878,8 @@ class UnusedNonUnitValue(tp: Type)(using Context)
     def kind = MessageKind.PotentialIssue
     def msg(using Context) = i"unused value of type $tp"
     def explain(using Context) = ""
+
+class MatchTypeScrutineeCannotBeHigherKinded(tp: Type)(using Context)
+  extends TypeMsg(MatchTypeScrutineeCannotBeHigherKindedID) :
+    def msg(using Context) = i"the scrutinee of a match type cannot be higher-kinded"
+    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 16b256e69059..bfd85a94cc4b 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -2214,8 +2214,11 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       if (tree.bound.isEmpty && isFullyDefined(pt, ForceDegree.none)) TypeTree(pt)
       else typed(tree.bound)
     val sel1 = typed(tree.selector)
+    val sel1Tpe = sel1.tpe
+    if sel1Tpe.isLambdaSub then
+      report.error(MatchTypeScrutineeCannotBeHigherKinded(sel1Tpe), sel1.srcPos)
     val pt1 = if (bound1.isEmpty) pt else bound1.tpe
-    val cases1 = tree.cases.mapconserve(typedTypeCase(_, sel1.tpe, pt1))
+    val cases1 = tree.cases.mapconserve(typedTypeCase(_, sel1Tpe, pt1))
     assignType(cpy.MatchTypeTree(tree)(bound1, sel1, cases1), bound1, sel1, cases1)
   }
 
diff --git a/tests/neg/i13757-match-type-anykind.scala b/tests/neg/i13757-match-type-anykind.scala
new file mode 100644
index 000000000000..d8273e546dab
--- /dev/null
+++ b/tests/neg/i13757-match-type-anykind.scala
@@ -0,0 +1,16 @@
+object Test:
+  type AnyKindMatchType1[X <: AnyKind] = X match // error: the scrutinee of a match type cannot be higher-kinded // error
+    case Option[a] => Int
+
+  type AnyKindMatchType2[X <: AnyKind] = X match // error: the scrutinee of a match type cannot be higher-kinded
+    case Option => Int // error: Missing type parameter for Option
+
+  type AnyKindMatchType3[X <: AnyKind] = X match // error: the scrutinee of a match type cannot be higher-kinded // error
+    case _ => Int
+
+  type AnyKindMatchType4[X <: Option] = X match // error // error: the scrutinee of a match type cannot be higher-kinded // error
+    case _ => Int
+
+  type AnyKindMatchType5[X[_]] = X match // error: the scrutinee of a match type cannot be higher-kinded // error
+    case _ => Int
+end Test

From 7576fbe34e7b8a26774bdea46cb604f8c0cea1e9 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sat, 22 Apr 2023 13:21:57 +0200
Subject: [PATCH 389/657] Some additions and changes in tests

---
 tests/neg-custom-args/captures/filevar.scala  | 18 +++++++++
 tests/pending/pos/i16826.scala                | 10 +++++
 tests/pos-custom-args/captures/filevar.scala  | 37 +++++++++++++++++++
 .../captures/nested-classes.scala             | 21 +++++++++++
 tests/run/errorhandling/Result.scala          |  4 +-
 5 files changed, 88 insertions(+), 2 deletions(-)
 create mode 100644 tests/neg-custom-args/captures/filevar.scala
 create mode 100644 tests/pending/pos/i16826.scala
 create mode 100644 tests/pos-custom-args/captures/filevar.scala
 create mode 100644 tests/pos-custom-args/captures/nested-classes.scala

diff --git a/tests/neg-custom-args/captures/filevar.scala b/tests/neg-custom-args/captures/filevar.scala
new file mode 100644
index 000000000000..9251be8f1592
--- /dev/null
+++ b/tests/neg-custom-args/captures/filevar.scala
@@ -0,0 +1,18 @@
+import language.experimental.captureChecking
+import compiletime.uninitialized
+
+class File:
+  def write(x: String): Unit = ???
+
+class Service:
+  var file: {*} File = uninitialized
+  def log = file.write("log")  // error
+
+def withFile[T](op: (f: {*} File) => T): T =
+  op(new File)
+
+def test =
+  withFile: f =>
+    val o = Service()
+    o.file = f
+    o.log
diff --git a/tests/pending/pos/i16826.scala b/tests/pending/pos/i16826.scala
new file mode 100644
index 000000000000..a938ab42dac3
--- /dev/null
+++ b/tests/pending/pos/i16826.scala
@@ -0,0 +1,10 @@
+import language.experimental.captureChecking
+class A
+class B(a: {*} A)
+class C(a: {*} A):
+  def setB(b: {a} B): Unit = ???
+
+
+def test(a1: {*} A)(b1: {a1} B) =
+  val c = new C(a1)
+  c.setB(b1)
diff --git a/tests/pos-custom-args/captures/filevar.scala b/tests/pos-custom-args/captures/filevar.scala
new file mode 100644
index 000000000000..17a8281c4d29
--- /dev/null
+++ b/tests/pos-custom-args/captures/filevar.scala
@@ -0,0 +1,37 @@
+import language.experimental.captureChecking
+import annotation.capability
+import compiletime.uninitialized
+
+object test1:
+  class File:
+    def write(x: String): Unit = ???
+
+  class Service(f: {*} File):
+    def log = f.write("log")
+
+  def withFile[T](op: (f: {*} File) => T): T =
+    op(new File)
+
+  def test =
+    withFile: f =>
+      val o = Service(f)
+      o.log
+
+object test2:
+  @capability class IO
+
+  class File:
+    def write(x: String): Unit = ???
+
+  class Service(io: IO):
+    var file: {io} File = uninitialized
+    def log = file.write("log")
+
+  def withFile[T](io: IO)(op: (f: {io} File) => T): T =
+    op(new File)
+
+  def test(io: IO) =
+    withFile(io): f =>
+      val o = Service(io)
+      o.file = f
+      o.log
diff --git a/tests/pos-custom-args/captures/nested-classes.scala b/tests/pos-custom-args/captures/nested-classes.scala
new file mode 100644
index 000000000000..2e893b7413a5
--- /dev/null
+++ b/tests/pos-custom-args/captures/nested-classes.scala
@@ -0,0 +1,21 @@
+import language.experimental.captureChecking
+import annotation.{capability, constructorOnly}
+
+@capability class IO
+class Blah
+class Pkg(using @constructorOnly io: IO):
+  class Foo:
+    def m(foo: {io} Blah) = ???
+class Pkg2(using io: IO):
+  class Foo:
+    def m(foo: {io} Blah): Any = io; ???
+
+def main(using io: IO) =
+  val pkg = Pkg()
+  val f = pkg.Foo()
+  f.m(???)
+  val pkg2 = Pkg2()
+  val f2 = pkg2.Foo()
+  f2.m(???)
+
+
diff --git a/tests/run/errorhandling/Result.scala b/tests/run/errorhandling/Result.scala
index 027c07c86769..07d7a9f90c8a 100644
--- a/tests/run/errorhandling/Result.scala
+++ b/tests/run/errorhandling/Result.scala
@@ -29,14 +29,14 @@ object Result:
       case err: Err[_] => err
 
     /** Validate both `r` and `other`; return a pair of successes or a list of failures. */
-    def * [U](other: Result[U, E]): Result[(T, U), List[E]] = (r, other) match
+    def zip[U](other: Result[U, E]): Result[(T, U), List[E]] = (r, other) match
       case (Ok(x), Ok(y))     => Ok((x, y))
       case (Ok(_), Err(e))    => Err(e :: Nil)
       case (Err(e), Ok(_))    => Err(e :: Nil)
       case (Err(e1), Err(e2)) => Err(e1 :: e2 :: Nil)
 
     /** Validate both `r` and `other`; return a tuple of successes or a list of failures.
-     *  Unlike with `*`, the right hand side `other` must be a `Result` returning a `Tuple`,
+     *  Unlike with `zip`, the right hand side `other` must be a `Result` returning a `Tuple`,
      *  and the left hand side is added to it. See `Result.empty` for a convenient
      *  right unit of chains of `*:`s.
      */

From 4e028bf37e28cd13cf9c1bf96078a14221947fdc Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sat, 22 Apr 2023 13:55:50 +0200
Subject: [PATCH 390/657] Support extension methods imported from different
 objects

Add a special case to name resolution so that when expanding an
extension method from `e.m` to `m(e)` and `m` is imported by several
imports on the same level, we try to typecheck under every such import
and pick the successful alternative if it exists and is unambiguous.

Fixes #16920
---
 .../tools/dotc/reporting/ErrorMessageID.scala |  1 +
 .../dotty/tools/dotc/reporting/messages.scala |  9 ++
 .../src/dotty/tools/dotc/typer/Typer.scala    | 95 ++++++++++++++++---
 .../reference/contextual/extension-methods.md | 11 ++-
 tests/neg/i13558.check                        | 26 -----
 tests/neg/i16920.check                        | 88 +++++++++++++++++
 tests/neg/i16920.scala                        | 57 +++++++++++
 tests/{neg => pos}/i13558.scala               |  4 +-
 tests/pos/i16920.scala                        | 76 +++++++++++++++
 9 files changed, 324 insertions(+), 43 deletions(-)
 delete mode 100644 tests/neg/i13558.check
 create mode 100644 tests/neg/i16920.check
 create mode 100644 tests/neg/i16920.scala
 rename tests/{neg => pos}/i13558.scala (87%)
 create mode 100644 tests/pos/i16920.scala

diff --git a/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala b/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
index b3d9b2c1dc49..cc2741bcb614 100644
--- a/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
@@ -193,6 +193,7 @@ enum ErrorMessageID(val isActive: Boolean = true) extends java.lang.Enum[ErrorMe
   case ConstrProxyShadowsID // errorNumber 177
   case MissingArgumentListID // errorNumber: 178
   case MatchTypeScrutineeCannotBeHigherKindedID // errorNumber: 179
+  case AmbiguousExtensionMethodID // errorNumber 180
 
   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 1c3bd23de9c6..423c1cdef264 100644
--- a/compiler/src/dotty/tools/dotc/reporting/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/messages.scala
@@ -1434,6 +1434,15 @@ extends ReferenceMsg(AmbiguousOverloadID), NoDisambiguation {
         |"""
 }
 
+class AmbiguousExtensionMethod(tree: untpd.Tree, expansion1: tpd.Tree, expansion2: tpd.Tree)(using Context)
+  extends ReferenceMsg(AmbiguousExtensionMethodID), NoDisambiguation:
+  def msg(using Context) =
+    i"""Ambiguous extension methods:
+       |both $expansion1
+       |and  $expansion2
+       |are possible expansions of $tree"""
+  def explain(using Context) = ""
+
 class ReassignmentToVal(name: Name)(using Context)
   extends TypeMsg(ReassignmentToValID) {
   def msg(using Context) = i"""Reassignment to val $name"""
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index bfd85a94cc4b..62edd12a00fa 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -159,8 +159,13 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
    *   @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
+   *   @param altImports a ListBuffer in which alternative imported references are
+   *                     collected in case `findRef` is called from an expansion of
+   *                     an extension method, i.e. when `e.m` is expanded to `m(e)` and
+   *                     a reference for `m` is searched. `null` in all other situations.
    */
-  def findRef(name: Name, pt: Type, required: FlagSet, excluded: FlagSet, pos: SrcPos)(using Context): Type = {
+  def findRef(name: Name, pt: Type, required: FlagSet, excluded: FlagSet, pos: SrcPos,
+      altImports: mutable.ListBuffer[TermRef] | Null = null)(using Context): Type = {
     val refctx = ctx
     val noImports = ctx.mode.is(Mode.InPackageClauseName)
     def suppressErrors = excluded.is(ConstructorProxy)
@@ -231,15 +236,52 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
             fail(AmbiguousReference(name, newPrec, prevPrec, prevCtx))
           previous
 
-      /** Recurse in outer context. If final result is same as `previous`, check that it
-       *  is new or shadowed. This order of checking is necessary since an
-       *  outer package-level definition might trump two conflicting inner
-       *  imports, so no error should be issued in that case. See i7876.scala.
+      /** Assemble and check alternatives to an imported reference. This implies:
+       *   - If we expand an extension method (i.e. altImports != null),
+       *     search imports on the same level for other possible resolutions of `name`.
+       *     The result and altImports together then contain all possible imported
+       *     references of the highest possible precedence, where `NamedImport` beats
+       *     `WildImport`.
+       *   - Find a posssibly shadowing reference in an outer context.
+       *     If the result is the 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.
+       *  @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 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 checkImportAlternatives(previous: Type, prevPrec: BindingPrec, prevCtx: Context)(using Context): Type =
+
+        def addAltImport(altImp: TermRef) =
+          if !TypeComparer.isSameRef(previous, altImp)
+              && !altImports.uncheckedNN.exists(TypeComparer.isSameRef(_, altImp))
+          then
+            altImports.uncheckedNN += altImp
+
+        if altImports != null && ctx.isImportContext then
+          val curImport = ctx.importInfo.uncheckedNN
+          namedImportRef(curImport) match
+            case altImp: TermRef =>
+              if prevPrec == WildImport then
+                // Discard all previously found references and continue with `altImp`
+                altImports.clear()
+                checkImportAlternatives(altImp, NamedImport, ctx)(using ctx.outer)
+              else
+                addAltImport(altImp)
+                checkImportAlternatives(previous, prevPrec, 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)
+        else
+          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 =
         imp.importSym.info match
@@ -329,7 +371,6 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         if (ctx.scope eq EmptyScope) previous
         else {
           var result: Type = NoType
-
           val curOwner = ctx.owner
 
           /** Is curOwner a package object that should be skipped?
@@ -450,11 +491,11 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
             else if (isPossibleImport(NamedImport) && (curImport nen outer.importInfo)) {
               val namedImp = namedImportRef(curImport.uncheckedNN)
               if (namedImp.exists)
-                recurAndCheckNewOrShadowed(namedImp, NamedImport, ctx)(using outer)
+                checkImportAlternatives(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)
+                  checkImportAlternatives(wildImp, WildImport, ctx)(using outer)
                 else {
                   updateUnimported()
                   loop(ctx)(using outer)
@@ -3412,11 +3453,37 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     def selectionProto = SelectionProto(tree.name, mbrProto, compat, privateOK = inSelect)
 
     def tryExtension(using Context): Tree =
-      findRef(tree.name, WildcardType, ExtensionMethod, EmptyFlags, qual.srcPos) match
+      val altImports = new mutable.ListBuffer[TermRef]()
+      findRef(tree.name, WildcardType, ExtensionMethod, EmptyFlags, qual.srcPos, altImports) match
         case ref: TermRef =>
-          extMethodApply(untpd.TypedSplice(tpd.ref(ref).withSpan(tree.nameSpan)), qual, pt)
+          def tryExtMethod(ref: TermRef)(using Context) =
+            extMethodApply(untpd.TypedSplice(tpd.ref(ref).withSpan(tree.nameSpan)), qual, pt)
+          if altImports.isEmpty then
+            tryExtMethod(ref)
+          else
+            // Try all possible imports and collect successes and failures
+            val successes, failures = new mutable.ListBuffer[(Tree, TyperState)]
+            for alt <- ref :: altImports.toList do
+              val nestedCtx = ctx.fresh.setNewTyperState()
+              val app = tryExtMethod(alt)(using nestedCtx)
+              (if nestedCtx.reporter.hasErrors then failures else successes)
+                += ((app, nestedCtx.typerState))
+            typr.println(i"multiple extensioin methods, success: ${successes.toList}, failure: ${failures.toList}")
+
+            def pick(alt: (Tree, TyperState)): Tree =
+              val (app, ts) = alt
+              ts.commit()
+              app
+
+            successes.toList match
+              case Nil => pick(failures.head)
+              case success :: Nil => pick(success)
+              case (expansion1, _) :: (expansion2, _) :: _ =>
+                report.error(AmbiguousExtensionMethod(tree, expansion1, expansion2), tree.srcPos)
+                expansion1
         case _ =>
           EmptyTree
+    end tryExtension
 
     def nestedFailure(ex: TypeError) =
       rememberSearchFailure(qual,
diff --git a/docs/_docs/reference/contextual/extension-methods.md b/docs/_docs/reference/contextual/extension-methods.md
index 6a1504c25048..f4e75c4456df 100644
--- a/docs/_docs/reference/contextual/extension-methods.md
+++ b/docs/_docs/reference/contextual/extension-methods.md
@@ -244,7 +244,16 @@ The precise rules for resolving a selection to an extension method are as follow
 Assume a selection `e.m[Ts]` where `m` is not a member of `e`, where the type arguments `[Ts]` are optional, and where `T` is the expected type.
 The following two rewritings are tried in order:
 
- 1. The selection is rewritten to `m[Ts](e)`.
+ 1. The selection is rewritten to `m[Ts](e)` and typechecked, using the following
+    slight modification of the name resolution rules:
+
+  - If `m` is imported by several imports which are all on the nesting level,
+    try each import as an extension method instead of failing with an ambiguity.
+    If only one import leads to an expansion that typechecks without errors, pick
+    that expansion. If there are several such imports, but only one import which is
+    not a wildcard import, pick the expansion from that import. Otherwise, report
+    an ambiguous reference error.    
+
  2. If the first rewriting does not typecheck with expected type `T`,
     and there is an extension method `m` in some eligible object `o`, the selection is rewritten to `o.m[Ts](e)`. An object `o` is _eligible_ if
 
diff --git a/tests/neg/i13558.check b/tests/neg/i13558.check
deleted file mode 100644
index 7b4b5215a0a3..000000000000
--- a/tests/neg/i13558.check
+++ /dev/null
@@ -1,26 +0,0 @@
--- [E008] Not Found Error: tests/neg/i13558.scala:23:14 ----------------------------------------------------------------
-23 |    println(a.id) // error
-   |            ^^^^
-   |            value id is not a member of testcode.A.
-   |            An extension method was tried, but could not be fully constructed:
-   |
-   |                testcode.ExtensionA.id(a)
-   |
-   |                failed with:
-   |
-   |                    Reference to id is ambiguous.
-   |                    It is both imported by import testcode.ExtensionB._
-   |                    and imported subsequently by import testcode.ExtensionA._
--- [E008] Not Found Error: tests/neg/i13558.scala:29:14 ----------------------------------------------------------------
-29 |    println(a.id) // error
-   |            ^^^^
-   |            value id is not a member of testcode.A.
-   |            An extension method was tried, but could not be fully constructed:
-   |
-   |                testcode.ExtensionB.id(a)
-   |
-   |                failed with:
-   |
-   |                    Reference to id is ambiguous.
-   |                    It is both imported by import testcode.ExtensionA._
-   |                    and imported subsequently by import testcode.ExtensionB._
diff --git a/tests/neg/i16920.check b/tests/neg/i16920.check
new file mode 100644
index 000000000000..86496f24ca3c
--- /dev/null
+++ b/tests/neg/i16920.check
@@ -0,0 +1,88 @@
+-- [E008] Not Found Error: tests/neg/i16920.scala:18:11 ----------------------------------------------------------------
+18 |    "five".wow // error
+   |    ^^^^^^^^^^
+   |    value wow is not a member of String.
+   |    An extension method was tried, but could not be fully constructed:
+   |
+   |        Two.wow("five")
+   |
+   |        failed with:
+   |
+   |            Found:    ("five" : String)
+   |            Required: Int
+-- [E008] Not Found Error: tests/neg/i16920.scala:26:6 -----------------------------------------------------------------
+26 |    5.wow // error
+   |    ^^^^^
+   |    value wow is not a member of Int.
+   |    An extension method was tried, but could not be fully constructed:
+   |
+   |        AlsoFails.wow(5)
+   |
+   |        failed with:
+   |
+   |            Found:    (5 : Int)
+   |            Required: Boolean
+-- [E008] Not Found Error: tests/neg/i16920.scala:27:11 ----------------------------------------------------------------
+27 |    "five".wow // error
+   |    ^^^^^^^^^^
+   |    value wow is not a member of String.
+   |    An extension method was tried, but could not be fully constructed:
+   |
+   |        AlsoFails.wow("five")
+   |
+   |        failed with:
+   |
+   |            Found:    ("five" : String)
+   |            Required: Boolean
+-- [E008] Not Found Error: tests/neg/i16920.scala:34:6 -----------------------------------------------------------------
+34 |    5.wow // error
+   |    ^^^^^
+   |    value wow is not a member of Int.
+   |    An extension method was tried, but could not be fully constructed:
+   |
+   |        Three.wow(5)
+   |
+   |        failed with:
+   |
+   |            Ambiguous extension methods:
+   |            both Three.wow(5)
+   |            and  Two.wow(5)
+   |            are possible expansions of 5.wow
+-- [E008] Not Found Error: tests/neg/i16920.scala:42:11 ----------------------------------------------------------------
+42 |    "five".wow // error
+   |    ^^^^^^^^^^
+   |    value wow is not a member of String.
+   |    An extension method was tried, but could not be fully constructed:
+   |
+   |        Two.wow("five")
+   |
+   |        failed with:
+   |
+   |            Found:    ("five" : String)
+   |            Required: Int
+-- [E008] Not Found Error: tests/neg/i16920.scala:49:11 ----------------------------------------------------------------
+49 |    "five".wow // error
+   |    ^^^^^^^^^^
+   |    value wow is not a member of String.
+   |    An extension method was tried, but could not be fully constructed:
+   |
+   |        Two.wow("five")
+   |
+   |        failed with:
+   |
+   |            Found:    ("five" : String)
+   |            Required: Int
+-- [E008] Not Found Error: tests/neg/i16920.scala:56:6 -----------------------------------------------------------------
+56 |    5.wow // error
+   |    ^^^^^
+   |    value wow is not a member of Int.
+   |    An extension method was tried, but could not be fully constructed:
+   |
+   |        Three.wow(5)
+   |
+   |        failed with:
+   |
+   |            Ambiguous extension methods:
+   |            both Three.wow(5)
+   |            and  Two.wow(5)
+   |            are possible expansions of 5.wow
diff --git a/tests/neg/i16920.scala b/tests/neg/i16920.scala
new file mode 100644
index 000000000000..76953f015de2
--- /dev/null
+++ b/tests/neg/i16920.scala
@@ -0,0 +1,57 @@
+object One:
+  extension (s: String)
+    def wow: Unit = println(s)
+
+object Two:
+  extension (i: Int)
+    def wow: Unit = println(i)
+
+object Three:
+  extension (i: Int)
+    def wow: Unit = println(i)
+
+object Fails:
+  import One._
+  def test: Unit =
+    import Two._
+    5.wow
+    "five".wow // error
+
+object AlsoFails:
+  extension (s: Boolean)
+    def wow = println(s)
+  import One._
+  import Two._
+  def test: Unit =
+    5.wow // error
+    "five".wow // error
+
+object Fails2:
+  import One._
+  import Two._
+  import Three._
+  def test: Unit =
+    5.wow // error
+    "five".wow // ok
+
+object Fails3:
+  import One._
+  import Two.wow
+  def test: Unit =
+    5.wow // ok
+    "five".wow // error
+
+object Fails4:
+  import Two.wow
+  import One._
+  def test: Unit =
+    5.wow // ok
+    "five".wow // error
+
+object Fails5:
+  import One.wow
+  import Two.wow
+  import Three.wow
+  def test: Unit =
+    5.wow // error
+    "five".wow // ok
\ No newline at end of file
diff --git a/tests/neg/i13558.scala b/tests/pos/i13558.scala
similarity index 87%
rename from tests/neg/i13558.scala
rename to tests/pos/i13558.scala
index 1d4e1c506e43..6f18b770f467 100644
--- a/tests/neg/i13558.scala
+++ b/tests/pos/i13558.scala
@@ -20,12 +20,12 @@ object Main {
     import ExtensionB._
     import ExtensionA._
     val a = A()
-    println(a.id) // error
+    println(a.id) // now ok
   }
   def main2(args: Array[String]): Unit = {
     import ExtensionA._
     import ExtensionB._
     val a = A()
-    println(a.id) // error
+    println(a.id) // now ok
   }
 }
\ No newline at end of file
diff --git a/tests/pos/i16920.scala b/tests/pos/i16920.scala
new file mode 100644
index 000000000000..b0604b7c9dba
--- /dev/null
+++ b/tests/pos/i16920.scala
@@ -0,0 +1,76 @@
+object One:
+  extension (s: String)
+    def wow: Unit = println(s)
+
+object Two:
+  extension (i: Int)
+    def wow: Unit = println(i)
+
+object Three:
+  extension (s: String)
+    def wow: Unit = println(s)
+  extension (i: Int)
+    def wow: Unit = println(i)
+
+object Four:
+  implicit class WowString(s: String):
+    def wow: Unit = println(s)
+
+object Five:
+  implicit class WowInt(i: Int):
+    def wow: Unit = println(i)
+
+object Compiles:
+  import Three._
+  def test: Unit =
+    5.wow
+    "five".wow
+
+object AlsoCompiles:
+  import Four._
+  import Five._
+  def test: Unit =
+    5.wow
+    "five".wow
+
+object UsedToFail:
+  import One._
+  import Compiles.*
+  import Two._
+  def test: Unit =
+    5.wow
+    "five".wow
+
+object Conflicting:
+  extension (i: Int)
+    def wow: Unit = println(i)
+
+object Named:
+  import One.wow
+  import Two.wow
+  import Conflicting._
+  def test: Unit =
+    5.wow // ok
+    "five".wow // ok
+
+object Named2:
+  import Conflicting._
+  import One.wow
+  import Two.wow
+  def test: Unit =
+    5.wow // ok
+    "five".wow // ok
+
+val Alias = Two
+
+object Named3:
+  import Alias._
+  import Two._
+  def test: Unit =
+    5.wow // ok
+
+object Named4:
+  import Two._
+  import Alias._
+  def test: Unit =
+    5.wow // ok

From abbd01c27e96b4cb19b2960c48651ec4242a9ed4 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Tue, 7 Mar 2023 11:38:02 +0100
Subject: [PATCH 391/657] Put changes under experimental language import

As long as this is not SIP approved, we need to put this under experimental.
---
 .../src/dotty/tools/dotc/config/Feature.scala |  1 +
 .../src/dotty/tools/dotc/typer/Typer.scala    |  2 +-
 .../reference/contextual/extension-methods.md |  4 ++-
 .../runtime/stdLibPatches/language.scala      |  8 +++++
 tests/neg/i13558.scala                        | 31 +++++++++++++++++++
 tests/neg/i16920.check                        | 28 ++++++++---------
 tests/neg/i16920.scala                        |  2 ++
 tests/pos/i13558.scala                        |  1 +
 tests/pos/i16920.scala                        |  2 ++
 9 files changed, 63 insertions(+), 16 deletions(-)
 create mode 100644 tests/neg/i13558.scala

diff --git a/compiler/src/dotty/tools/dotc/config/Feature.scala b/compiler/src/dotty/tools/dotc/config/Feature.scala
index 419ed5868cbf..e5ab8f65f55b 100644
--- a/compiler/src/dotty/tools/dotc/config/Feature.scala
+++ b/compiler/src/dotty/tools/dotc/config/Feature.scala
@@ -29,6 +29,7 @@ object Feature:
   val fewerBraces = experimental("fewerBraces")
   val saferExceptions = experimental("saferExceptions")
   val clauseInterleaving = experimental("clauseInterleaving")
+  val relaxedExtensionImports = experimental("relaxedExtensionImports")
   val pureFunctions = experimental("pureFunctions")
   val captureChecking = experimental("captureChecking")
   val into = experimental("into")
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 62edd12a00fa..4bc012b5b226 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -260,7 +260,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           then
             altImports.uncheckedNN += altImp
 
-        if altImports != null && ctx.isImportContext then
+        if Feature.enabled(Feature.relaxedExtensionImports) && altImports != null && ctx.isImportContext then
           val curImport = ctx.importInfo.uncheckedNN
           namedImportRef(curImport) match
             case altImp: TermRef =>
diff --git a/docs/_docs/reference/contextual/extension-methods.md b/docs/_docs/reference/contextual/extension-methods.md
index f4e75c4456df..d98d80caafc5 100644
--- a/docs/_docs/reference/contextual/extension-methods.md
+++ b/docs/_docs/reference/contextual/extension-methods.md
@@ -252,7 +252,9 @@ The following two rewritings are tried in order:
     If only one import leads to an expansion that typechecks without errors, pick
     that expansion. If there are several such imports, but only one import which is
     not a wildcard import, pick the expansion from that import. Otherwise, report
-    an ambiguous reference error.    
+    an ambiguous reference error.
+
+    **Note**: This relaxation is currently enabled only under the `experimental.relaxedExtensionImports` language import.
 
  2. If the first rewriting does not typecheck with expected type `T`,
     and there is an extension method `m` in some eligible object `o`, the selection is rewritten to `o.m[Ts](e)`. An object `o` is _eligible_ if
diff --git a/library/src/scala/runtime/stdLibPatches/language.scala b/library/src/scala/runtime/stdLibPatches/language.scala
index d92495c6f5aa..091e75fa06e1 100644
--- a/library/src/scala/runtime/stdLibPatches/language.scala
+++ b/library/src/scala/runtime/stdLibPatches/language.scala
@@ -69,6 +69,14 @@ object language:
     @compileTimeOnly("`clauseInterleaving` can only be used at compile time in import statements")
     object clauseInterleaving
 
+    /** Adds support for relaxed imports of extension methods.
+      * Extension methods with the same name can be imported from several places.
+      *
+      * @see [[http://dotty.epfl.ch/docs/reference/contextual/extension-methods]]
+      */
+    @compileTimeOnly("`relaxedExtensionImports` can only be used at compile time in import statements")
+    object relaxedExtensionImports
+
     /** Experimental support for pure function type syntax
      *
      *  @see [[https://dotty.epfl.ch/docs/reference/experimental/purefuns]]
diff --git a/tests/neg/i13558.scala b/tests/neg/i13558.scala
new file mode 100644
index 000000000000..1d4e1c506e43
--- /dev/null
+++ b/tests/neg/i13558.scala
@@ -0,0 +1,31 @@
+package testcode
+
+class A
+
+class B
+
+object ExtensionA {
+  extension (self: A) {
+    def id = "A"
+  }
+}
+object ExtensionB {
+  extension (self: B) {
+    def id = "B"
+  }
+}
+
+object Main {
+  def main1(args: Array[String]): Unit = {
+    import ExtensionB._
+    import ExtensionA._
+    val a = A()
+    println(a.id) // error
+  }
+  def main2(args: Array[String]): Unit = {
+    import ExtensionA._
+    import ExtensionB._
+    val a = A()
+    println(a.id) // error
+  }
+}
\ No newline at end of file
diff --git a/tests/neg/i16920.check b/tests/neg/i16920.check
index 86496f24ca3c..131ba4c6265e 100644
--- a/tests/neg/i16920.check
+++ b/tests/neg/i16920.check
@@ -1,5 +1,5 @@
--- [E008] Not Found Error: tests/neg/i16920.scala:18:11 ----------------------------------------------------------------
-18 |    "five".wow // error
+-- [E008] Not Found Error: tests/neg/i16920.scala:20:11 ----------------------------------------------------------------
+20 |    "five".wow // error
    |    ^^^^^^^^^^
    |    value wow is not a member of String.
    |    An extension method was tried, but could not be fully constructed:
@@ -10,8 +10,8 @@
    |
    |            Found:    ("five" : String)
    |            Required: Int
--- [E008] Not Found Error: tests/neg/i16920.scala:26:6 -----------------------------------------------------------------
-26 |    5.wow // error
+-- [E008] Not Found Error: tests/neg/i16920.scala:28:6 -----------------------------------------------------------------
+28 |    5.wow // error
    |    ^^^^^
    |    value wow is not a member of Int.
    |    An extension method was tried, but could not be fully constructed:
@@ -22,8 +22,8 @@
    |
    |            Found:    (5 : Int)
    |            Required: Boolean
--- [E008] Not Found Error: tests/neg/i16920.scala:27:11 ----------------------------------------------------------------
-27 |    "five".wow // error
+-- [E008] Not Found Error: tests/neg/i16920.scala:29:11 ----------------------------------------------------------------
+29 |    "five".wow // error
    |    ^^^^^^^^^^
    |    value wow is not a member of String.
    |    An extension method was tried, but could not be fully constructed:
@@ -34,8 +34,8 @@
    |
    |            Found:    ("five" : String)
    |            Required: Boolean
--- [E008] Not Found Error: tests/neg/i16920.scala:34:6 -----------------------------------------------------------------
-34 |    5.wow // error
+-- [E008] Not Found Error: tests/neg/i16920.scala:36:6 -----------------------------------------------------------------
+36 |    5.wow // error
    |    ^^^^^
    |    value wow is not a member of Int.
    |    An extension method was tried, but could not be fully constructed:
@@ -48,8 +48,8 @@
    |            both Three.wow(5)
    |            and  Two.wow(5)
    |            are possible expansions of 5.wow
--- [E008] Not Found Error: tests/neg/i16920.scala:42:11 ----------------------------------------------------------------
-42 |    "five".wow // error
+-- [E008] Not Found Error: tests/neg/i16920.scala:44:11 ----------------------------------------------------------------
+44 |    "five".wow // error
    |    ^^^^^^^^^^
    |    value wow is not a member of String.
    |    An extension method was tried, but could not be fully constructed:
@@ -60,8 +60,8 @@
    |
    |            Found:    ("five" : String)
    |            Required: Int
--- [E008] Not Found Error: tests/neg/i16920.scala:49:11 ----------------------------------------------------------------
-49 |    "five".wow // error
+-- [E008] Not Found Error: tests/neg/i16920.scala:51:11 ----------------------------------------------------------------
+51 |    "five".wow // error
    |    ^^^^^^^^^^
    |    value wow is not a member of String.
    |    An extension method was tried, but could not be fully constructed:
@@ -72,8 +72,8 @@
    |
    |            Found:    ("five" : String)
    |            Required: Int
--- [E008] Not Found Error: tests/neg/i16920.scala:56:6 -----------------------------------------------------------------
-56 |    5.wow // error
+-- [E008] Not Found Error: tests/neg/i16920.scala:58:6 -----------------------------------------------------------------
+58 |    5.wow // error
    |    ^^^^^
    |    value wow is not a member of Int.
    |    An extension method was tried, but could not be fully constructed:
diff --git a/tests/neg/i16920.scala b/tests/neg/i16920.scala
index 76953f015de2..38345e811c1f 100644
--- a/tests/neg/i16920.scala
+++ b/tests/neg/i16920.scala
@@ -1,3 +1,5 @@
+import language.experimental.relaxedExtensionImports
+
 object One:
   extension (s: String)
     def wow: Unit = println(s)
diff --git a/tests/pos/i13558.scala b/tests/pos/i13558.scala
index 6f18b770f467..0c8be379f6a9 100644
--- a/tests/pos/i13558.scala
+++ b/tests/pos/i13558.scala
@@ -1,4 +1,5 @@
 package testcode
+import language.experimental.relaxedExtensionImports
 
 class A
 
diff --git a/tests/pos/i16920.scala b/tests/pos/i16920.scala
index b0604b7c9dba..dd4f5804a4fd 100644
--- a/tests/pos/i16920.scala
+++ b/tests/pos/i16920.scala
@@ -1,3 +1,5 @@
+import language.experimental.relaxedExtensionImports
+
 object One:
   extension (s: String)
     def wow: Unit = println(s)

From 81e9e1b09b44fd338270dd7c1ec08f567847de40 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Tue, 7 Mar 2023 13:28:19 +0100
Subject: [PATCH 392/657] Update MiMaFilters

---
 project/MiMaFilters.scala | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/project/MiMaFilters.scala b/project/MiMaFilters.scala
index cb15d82affb8..d53eeb7077a4 100644
--- a/project/MiMaFilters.scala
+++ b/project/MiMaFilters.scala
@@ -26,6 +26,8 @@ object MiMaFilters {
     ProblemFilters.exclude[MissingClassProblem]("scala.runtime.stdLibPatches.language$experimental$clauseInterleaving$"),
     ProblemFilters.exclude[MissingFieldProblem]("scala.runtime.stdLibPatches.language#experimental.into"),
     ProblemFilters.exclude[MissingClassProblem]("scala.runtime.stdLibPatches.language$experimental$into$"),
+    ProblemFilters.exclude[MissingFieldProblem]("scala.runtime.stdLibPatches.language#experimental.relaxedExtensionImports"),
+    ProblemFilters.exclude[MissingClassProblem]("scala.runtime.stdLibPatches.language$experimental$relaxedExtensionImports$"),
     // end of New experimental features in 3.3.X
 
     // Added java.io.Serializable as LazyValControlState supertype

From d1d6c2e9536ce331316f741b9c1c4c0520cef787 Mon Sep 17 00:00:00 2001
From: Decel <8268812+Decel@users.noreply.github.com>
Date: Mon, 24 Apr 2023 12:18:17 +0200
Subject: [PATCH 393/657] Fix Tests and add bounds check for inlined functions

---
 .../src/dotty/tools/dotc/transform/PostTyper.scala |  1 +
 tests/neg/i17168.scala                             |  3 +++
 tests/pos/i13332super.scala                        | 14 --------------
 tests/run/anon-mirror-gen-local.scala              |  6 +++---
 tests/run/i13332a.scala                            |  2 +-
 5 files changed, 8 insertions(+), 18 deletions(-)
 create mode 100644 tests/neg/i17168.scala
 delete mode 100644 tests/pos/i13332super.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/PostTyper.scala b/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
index 7f3e47c14732..597b5aa5885f 100644
--- a/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
@@ -363,6 +363,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
         case Inlined(call, bindings, expansion) if !call.isEmpty =>
           val pos = call.sourcePos
           CrossVersionChecks.checkExperimentalRef(call.symbol, pos)
+          super.transform(call)
           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 =>
diff --git a/tests/neg/i17168.scala b/tests/neg/i17168.scala
new file mode 100644
index 000000000000..6e82cc15abfc
--- /dev/null
+++ b/tests/neg/i17168.scala
@@ -0,0 +1,3 @@
+type F[X <: String] = X
+
+val a = summon[F[Int] =:= Int] // error
\ No newline at end of file
diff --git a/tests/pos/i13332super.scala b/tests/pos/i13332super.scala
deleted file mode 100644
index 1ab695d5d4a5..000000000000
--- a/tests/pos/i13332super.scala
+++ /dev/null
@@ -1,14 +0,0 @@
-import scala.deriving.Mirror
-
-trait MixinAMini {
-  lazy val mixinB = new MixinBMini() {}
-}
-trait MixinBMini {
-  sealed trait Lst // crucially, no companion is defined
-  case class Cn(h: Int, t: Lst) extends Lst
-  case object Nl extends Lst
-}
-trait SubABMini extends MixinAMini with MixinBMini {
-  val mirror_SubABMini_super_mixinB_Lst =
-    summon[Mirror.Of[SubABMini.super[MixinAMini].mixinB.Lst]]
-}
diff --git a/tests/run/anon-mirror-gen-local.scala b/tests/run/anon-mirror-gen-local.scala
index 68fb9500d5ba..ccd1ac4fc602 100644
--- a/tests/run/anon-mirror-gen-local.scala
+++ b/tests/run/anon-mirror-gen-local.scala
@@ -55,7 +55,7 @@ class Outer5 { self =>
     }
   }
 
-  lazy val o = new Outer5() // infinite init
+  final lazy val o = new Outer5() // infinite init
 
 }
 
@@ -142,7 +142,7 @@ def locally3 = {
   class Bar extends Foo {
 
     def hello =
-      val mQux = summon[Mirror.Of[Bar.super.foo.type]]
+      val mQux = summon[Mirror.Of[foo.type]]
       assert(mQux.fromProduct(EmptyTuple) == Qux)
   }
 
@@ -157,4 +157,4 @@ def locally3 = {
   testOuter6
   locally1
   locally2
-  locally3
\ No newline at end of file
+  locally3
diff --git a/tests/run/i13332a.scala b/tests/run/i13332a.scala
index 3478ed325467..c4bd33ede153 100644
--- a/tests/run/i13332a.scala
+++ b/tests/run/i13332a.scala
@@ -150,7 +150,7 @@ class SubUniverse extends Universe {
 
 trait Whole {
   trait MixinA {
-    lazy val mixinB = new MixinB() {}
+    final lazy val mixinB = new MixinB() {}
   }
   trait MixinB {
     object A extends MixinB { // by inheriting `MixinB`, we should not check for inheritance from the right

From d26d076513b7240b4ae4c6393147603d95669ac6 Mon Sep 17 00:00:00 2001
From: Lucas <leblanc.lucas29@gmail.com>
Date: Fri, 14 Apr 2023 11:46:41 +0200
Subject: [PATCH 394/657] Don't render the "$" for module

Change of how to correct the Issue
- Add a new method "normalizedFullName"
- Call the method "ClassLikeSupport"

Add the ownerNameChain function
- To erase the $ in all the hierarchy
---
 .../tools/scaladoc/tasty/ClassLikeSupport.scala      |  2 +-
 .../dotty/tools/scaladoc/tasty/NameNormalizer.scala  | 12 ++++++++++++
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala
index 0c85dff0879f..86c745f12db7 100644
--- a/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/tasty/ClassLikeSupport.scala
@@ -525,7 +525,7 @@ trait ClassLikeSupport:
     experimental: Option[Annotation] = None
   ) = Member(
     name = symbol.normalizedName,
-    fullName = symbol.fullName,
+    fullName = symbol.normalizedFullName,
     dri = symbol.dri,
     kind = kind,
     visibility = symbol.getVisibility(),
diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/NameNormalizer.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/NameNormalizer.scala
index 687ad6ecbf44..196c3e056b36 100644
--- a/scaladoc/src/dotty/tools/scaladoc/tasty/NameNormalizer.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/tasty/NameNormalizer.scala
@@ -17,6 +17,18 @@ object NameNormalizer {
       val escaped = escapedName(constructorNormalizedName)
       escaped
     }
+    
+    def ownerNameChain: List[String] = {
+      import reflect.*
+      if s.isNoSymbol then List.empty
+      else if s == defn.EmptyPackageClass then List.empty
+      else if s == defn.RootPackage then List.empty
+      else if s == defn.RootClass then List.empty
+      else s.owner.ownerNameChain :+ s.normalizedName
+    }  
+      
+    def normalizedFullName: String =
+      s.ownerNameChain.mkString(".")
 
   private val ignoredKeywords: Set[String] = Set("this")
 

From 06226b11d4b81ad3398a46f656e9670d6ee21232 Mon Sep 17 00:00:00 2001
From: Rikito Taniguchi <rikiriki1238@gmail.com>
Date: Fri, 16 Sep 2022 14:23:55 +0200
Subject: [PATCH 395/657] feat: [SemanticDB] support LambdaType (convert from
 HKTypeLambda)

https://github.com/scalameta/scalameta/pull/2867

This commit adds support for LambdaType that is converted from
HKTypeLambda in Scala3
---
 .../dotty/tools/dotc/semanticdb/PPrint.scala  |   4 +
 .../dotty/tools/dotc/semanticdb/TypeOps.scala |  20 ++-
 .../dotc/semanticdb/generated/Type.scala      | 130 ++++++++++++++++++
 tests/semanticdb/expect/hk.expect.scala       |  17 +++
 tests/semanticdb/expect/hk.scala              |  17 +++
 tests/semanticdb/metac.expect                 | 106 +++++++++++++-
 6 files changed, 287 insertions(+), 7 deletions(-)
 create mode 100644 tests/semanticdb/expect/hk.expect.scala
 create mode 100644 tests/semanticdb/expect/hk.scala

diff --git a/compiler/src/dotty/tools/dotc/semanticdb/PPrint.scala b/compiler/src/dotty/tools/dotc/semanticdb/PPrint.scala
index 6814d923a062..b53ee787f501 100644
--- a/compiler/src/dotty/tools/dotc/semanticdb/PPrint.scala
+++ b/compiler/src/dotty/tools/dotc/semanticdb/PPrint.scala
@@ -196,6 +196,10 @@ class SymbolInformationPrinter (symtab: PrinterSymtab):
             s"${pprint(caseType.key)} => ${pprint(caseType.body)}"
           }.mkString(", ")
           s"${pprint(scrutinee)} match { ${casesStr} }"
+        case LambdaType(tparams, res) =>
+          val params = tparams.infos.map(_.displayName).mkString("[", ", ", "]")
+          val resType = normal(res)
+          s"$params =>> $resType"
         case x =>
           "<?>"
 
diff --git a/compiler/src/dotty/tools/dotc/semanticdb/TypeOps.scala b/compiler/src/dotty/tools/dotc/semanticdb/TypeOps.scala
index 0ccaab48889a..b0d032c7d83b 100644
--- a/compiler/src/dotty/tools/dotc/semanticdb/TypeOps.scala
+++ b/compiler/src/dotty/tools/dotc/semanticdb/TypeOps.scala
@@ -483,9 +483,23 @@ class TypeOps:
         case NoPrefix =>
           s.Type.Empty
 
-        // Not yet supported
-        case _: HKTypeLambda =>
-          s.Type.Empty
+        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)
+              }
+          }
+          val parameters =
+            paramSyms.sscopeOpt(using LinkMode.HardlinkChildren)
+          val resType = loop(lambda.resType)
+          s.LambdaType(
+            parameters,
+            resType
+          )
 
         case tvar: TypeVar =>
           loop(tvar.stripped)
diff --git a/compiler/src/dotty/tools/dotc/semanticdb/generated/Type.scala b/compiler/src/dotty/tools/dotc/semanticdb/generated/Type.scala
index da24b4847e19..be9cc6034f2c 100644
--- a/compiler/src/dotty/tools/dotc/semanticdb/generated/Type.scala
+++ b/compiler/src/dotty/tools/dotc/semanticdb/generated/Type.scala
@@ -39,6 +39,7 @@ object Type {
       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 __v: dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.LambdaType => __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 {
@@ -57,6 +58,7 @@ object Type {
       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 __v: dotty.tools.dotc.semanticdb.LambdaType => dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.LambdaType(__v)
       case Empty => dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.Empty
     })
   }
@@ -129,6 +131,10 @@ final case class TypeMessage(
         val __value = sealedValue.matchType.get
         __size += 2 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
       };
+      if (sealedValue.lambdaType.isDefined) {
+        val __value = sealedValue.lambdaType.get
+        __size += 2 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
       __size
     }
     override def serializedSize: _root_.scala.Int = {
@@ -231,6 +237,12 @@ final case class TypeMessage(
         _output__.writeUInt32NoTag(__m.serializedSize)
         __m.writeTo(_output__)
       };
+      sealedValue.lambdaType.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(26, 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))
@@ -262,6 +274,8 @@ final case class TypeMessage(
     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 getLambdaType: dotty.tools.dotc.semanticdb.LambdaType = sealedValue.lambdaType.getOrElse(dotty.tools.dotc.semanticdb.LambdaType.defaultInstance)
+    def withLambdaType(__v: dotty.tools.dotc.semanticdb.LambdaType): TypeMessage = copy(sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.LambdaType(__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)
     
@@ -311,6 +325,8 @@ object TypeMessage  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc
           __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 210 =>
+          __sealedValue = dotty.tools.dotc.semanticdb.TypeMessage.SealedValue.LambdaType(__sealedValue.lambdaType.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.LambdaType](_input__))(LiteParser.readMessage(_input__, _)))
         case tag => _input__.skipField(tag)
       }
     }
@@ -345,6 +361,7 @@ object TypeMessage  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc
     def isByNameType: _root_.scala.Boolean = false
     def isRepeatedType: _root_.scala.Boolean = false
     def isMatchType: _root_.scala.Boolean = false
+    def isLambdaType: _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
@@ -360,6 +377,7 @@ object TypeMessage  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc
     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
+    def lambdaType: _root_.scala.Option[dotty.tools.dotc.semanticdb.LambdaType] = _root_.scala.None
   }
   object SealedValue {
     @SerialVersionUID(0L)
@@ -476,6 +494,13 @@ object TypeMessage  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc
       override def matchType: _root_.scala.Option[dotty.tools.dotc.semanticdb.MatchType] = Some(value)
       override def number: _root_.scala.Int = 25
     }
+    @SerialVersionUID(0L)
+    final case class LambdaType(value: dotty.tools.dotc.semanticdb.LambdaType) extends dotty.tools.dotc.semanticdb.TypeMessage.SealedValue  derives CanEqual {
+      type ValueType = dotty.tools.dotc.semanticdb.LambdaType
+      override def isLambdaType: _root_.scala.Boolean = true
+      override def lambdaType: _root_.scala.Option[dotty.tools.dotc.semanticdb.LambdaType] = Some(value)
+      override def number: _root_.scala.Int = 26
+    }
   }
   final val TYPE_REF_FIELD_NUMBER = 2
   final val SINGLE_TYPE_FIELD_NUMBER = 20
@@ -492,6 +517,7 @@ object TypeMessage  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc
   final val BY_NAME_TYPE_FIELD_NUMBER = 13
   final val REPEATED_TYPE_FIELD_NUMBER = 14
   final val MATCH_TYPE_FIELD_NUMBER = 25
+  final val LAMBDA_TYPE_FIELD_NUMBER = 26
   def of(
     sealedValue: dotty.tools.dotc.semanticdb.TypeMessage.SealedValue
   ): _root_.dotty.tools.dotc.semanticdb.TypeMessage = _root_.dotty.tools.dotc.semanticdb.TypeMessage(
@@ -2034,3 +2060,107 @@ object MatchType  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.s
   )
   // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.MatchType])
 }
+
+@SerialVersionUID(0L)
+final case class LambdaType(
+    parameters: _root_.scala.Option[dotty.tools.dotc.semanticdb.Scope] = _root_.scala.None,
+    returnType: dotty.tools.dotc.semanticdb.Type = dotty.tools.dotc.semanticdb.LambdaType._typemapper_returnType.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 (parameters.isDefined) {
+        val __value = parameters.get
+        __size += 1 + SemanticdbOutputStream.computeUInt32SizeNoTag(__value.serializedSize) + __value.serializedSize
+      };
+      
+      {
+        val __value = dotty.tools.dotc.semanticdb.LambdaType._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 = {
+      parameters.foreach { __v =>
+        val __m = __v
+        _output__.writeTag(1, 2)
+        _output__.writeUInt32NoTag(__m.serializedSize)
+        __m.writeTo(_output__)
+      };
+      {
+        val __v = dotty.tools.dotc.semanticdb.LambdaType._typemapper_returnType.toBase(returnType)
+        if (__v.serializedSize != 0) {
+          _output__.writeTag(2, 2)
+          _output__.writeUInt32NoTag(__v.serializedSize)
+          __v.writeTo(_output__)
+        }
+      };
+    }
+    def getParameters: dotty.tools.dotc.semanticdb.Scope = parameters.getOrElse(dotty.tools.dotc.semanticdb.Scope.defaultInstance)
+    def clearParameters: LambdaType = copy(parameters = _root_.scala.None)
+    def withParameters(__v: dotty.tools.dotc.semanticdb.Scope): LambdaType = copy(parameters = Option(__v))
+    def withReturnType(__v: dotty.tools.dotc.semanticdb.Type): LambdaType = copy(returnType = __v)
+    
+    
+    
+    
+    // @@protoc_insertion_point(GeneratedMessage[dotty.tools.dotc.semanticdb.LambdaType])
+}
+
+object LambdaType  extends SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.LambdaType] {
+  implicit def messageCompanion: SemanticdbGeneratedMessageCompanion[dotty.tools.dotc.semanticdb.LambdaType] = this
+  def parseFrom(`_input__`: SemanticdbInputStream): dotty.tools.dotc.semanticdb.LambdaType = {
+    var __parameters: _root_.scala.Option[dotty.tools.dotc.semanticdb.Scope] = _root_.scala.None
+    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 =>
+          __parameters = Option(__parameters.fold(LiteParser.readMessage[dotty.tools.dotc.semanticdb.Scope](_input__))(LiteParser.readMessage(_input__, _)))
+        case 18 =>
+          __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.LambdaType(
+        parameters = __parameters,
+        returnType = dotty.tools.dotc.semanticdb.LambdaType._typemapper_returnType.toCustom(__returnType.getOrElse(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance))
+    )
+  }
+  
+  
+  
+  
+  
+  
+  lazy val defaultInstance = dotty.tools.dotc.semanticdb.LambdaType(
+    parameters = _root_.scala.None,
+    returnType = dotty.tools.dotc.semanticdb.LambdaType._typemapper_returnType.toCustom(dotty.tools.dotc.semanticdb.TypeMessage.defaultInstance)
+  )
+  final val PARAMETERS_FIELD_NUMBER = 1
+  final val RETURN_TYPE_FIELD_NUMBER = 2
+  @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(
+    parameters: _root_.scala.Option[dotty.tools.dotc.semanticdb.Scope],
+    returnType: dotty.tools.dotc.semanticdb.Type
+  ): _root_.dotty.tools.dotc.semanticdb.LambdaType = _root_.dotty.tools.dotc.semanticdb.LambdaType(
+    parameters,
+    returnType
+  )
+  // @@protoc_insertion_point(GeneratedMessageCompanion[dotty.tools.dotc.semanticdb.LambdaType])
+}
diff --git a/tests/semanticdb/expect/hk.expect.scala b/tests/semanticdb/expect/hk.expect.scala
new file mode 100644
index 000000000000..5c6e6c294ed9
--- /dev/null
+++ b/tests/semanticdb/expect/hk.expect.scala
@@ -0,0 +1,17 @@
+package hk
+
+trait Monad/*<-hk::Monad#*/[M/*<-hk::Monad#[M]*/[_]] {
+  def pure/*<-hk::Monad#pure().*/[A/*<-hk::Monad#pure().[A]*/](a/*<-hk::Monad#pure().(a)*/: A/*->hk::Monad#pure().[A]*/): M/*->hk::Monad#[M]*/[A/*->hk::Monad#pure().[A]*/] = ???/*->scala::Predef.`???`().*/
+  def flatMap/*<-hk::Monad#flatMap().*/[A/*<-hk::Monad#flatMap().[A]*/, B/*<-hk::Monad#flatMap().[B]*/](m/*<-hk::Monad#flatMap().(m)*/: M/*->hk::Monad#[M]*/[A/*->hk::Monad#flatMap().[A]*/])(f/*<-hk::Monad#flatMap().(f)*/: A/*->hk::Monad#flatMap().[A]*/ => M/*->hk::Monad#[M]*/[B/*->hk::Monad#flatMap().[B]*/]): M/*->hk::Monad#[M]*/[B/*->hk::Monad#flatMap().[B]*/] = ???/*->scala::Predef.`???`().*/
+}
+
+class EitherMonad/*<-hk::EitherMonad#*/[T/*<-hk::EitherMonad#[T]*/] extends Monad/*->hk::Monad#*/[[E/*<-hk::EitherMonad#`<init>`().[E]*/] =>> Either/*->scala::package.Either#*/[T/*->hk::EitherMonad#[T]*/, E]] {
+}
+
+type MapKV/*<-hk::hk$package.MapKV#*/ = [K/*<-hk::hk$package.MapKV#[K]*/] =>> [V/*<-hk::hk$package.MapKV#[V]*/] =>> Map/*->scala::Predef.Map#*/[K/*->hk::hk$package.MapKV#[K]*/,V/*->hk::hk$package.MapKV#[V]*/]
+
+type MapV/*<-hk::hk$package.MapV#*/ = [_] =>> [V/*<-hk::hk$package.MapV#[V]*/] =>> Map/*->scala::Predef.Map#*/[String/*->scala::Predef.String#*/, V/*->hk::hk$package.MapV#[V]*/]
+
+type MapEither/*<-hk::hk$package.MapEither#*/ = [K/*<-hk::hk$package.MapEither#[K]*/] =>> [L/*<-hk::hk$package.MapEither#[L]*/] =>> [R/*<-hk::hk$package.MapEither#[R]*/] =>> Map/*->scala::Predef.Map#*/[K/*->hk::hk$package.MapEither#[K]*/, Either/*->scala::package.Either#*/[L/*->hk::hk$package.MapEither#[L]*/, R/*->hk::hk$package.MapEither#[R]*/]]
+
+type Id/*<-hk::hk$package.Id#*/[A/*<-hk::hk$package.Id#[A]*/] = A/*->hk::hk$package.Id#[A]*/
diff --git a/tests/semanticdb/expect/hk.scala b/tests/semanticdb/expect/hk.scala
new file mode 100644
index 000000000000..dd24b6f6819a
--- /dev/null
+++ b/tests/semanticdb/expect/hk.scala
@@ -0,0 +1,17 @@
+package hk
+
+trait Monad[M[_]] {
+  def pure[A](a: A): M[A] = ???
+  def flatMap[A, B](m: M[A])(f: A => M[B]): M[B] = ???
+}
+
+class EitherMonad[T] extends Monad[[E] =>> Either[T, E]] {
+}
+
+type MapKV = [K] =>> [V] =>> Map[K,V]
+
+type MapV = [_] =>> [V] =>> Map[String, V]
+
+type MapEither = [K] =>> [L] =>> [R] =>> Map[K, Either[L, R]]
+
+type Id[A] = A
diff --git a/tests/semanticdb/metac.expect b/tests/semanticdb/metac.expect
index f5556e28bd1b..0ec8a8e5d84c 100644
--- a/tests/semanticdb/metac.expect
+++ b/tests/semanticdb/metac.expect
@@ -48,7 +48,7 @@ Schema => SemanticDB v4
 Uri => Advanced.scala
 Text => empty
 Language => Scala
-Symbols => 60 entries
+Symbols => 61 entries
 Occurrences => 138 entries
 Synthetics => 3 entries
 
@@ -57,10 +57,11 @@ advanced/C# => class C [typeparam T ] extends Object { self: C[T] => +3 decls }
 advanced/C#[T] => typeparam T 
 advanced/C#`<init>`(). => primary ctor <init> [typeparam T ](): C[T]
 advanced/C#t(). => method t => T
-advanced/HKClass# => class HKClass [typeparam F [typeparam T ] <: <?>] extends Object { self: HKClass[F] => +3 decls }
-advanced/HKClass#[F] => typeparam F [typeparam T ] <: <?>
+advanced/HKClass# => class HKClass [typeparam F [typeparam T ] <: [U] =>> Tuple2[U, T]] extends Object { self: HKClass[F] => +3 decls }
+advanced/HKClass#[F] => typeparam F [typeparam T ] <: [U] =>> Tuple2[U, T]
 advanced/HKClass#[F][T] => typeparam T 
-advanced/HKClass#`<init>`(). => primary ctor <init> [typeparam F [typeparam T ] <: <?>](): HKClass[F]
+advanced/HKClass#[F][U] => typeparam U 
+advanced/HKClass#`<init>`(). => primary ctor <init> [typeparam F [typeparam T ] <: [U] =>> Tuple2[U, T]](): HKClass[F]
 advanced/HKClass#`<init>`().[F][T] => typeparam T 
 advanced/HKClass#`<init>`().[F][U] => typeparam U 
 advanced/HKClass#foo(). => method foo [typeparam T , typeparam U ](param x: F[T, U]): String
@@ -3970,6 +3971,103 @@ Occurrences:
 [0:8..0:15): example <- example/
 [2:6..2:24): FilenameWithSpaces <- example/FilenameWithSpaces#
 
+expect/hk.scala
+---------------
+
+Summary:
+Schema => SemanticDB v4
+Uri => hk.scala
+Text => empty
+Language => Scala
+Symbols => 30 entries
+Occurrences => 52 entries
+
+Symbols:
+hk/EitherMonad# => class EitherMonad [typeparam T ] extends Object with Monad[[E] =>> Either[T, E]] { self: EitherMonad[T] => +2 decls }
+hk/EitherMonad#[E] => typeparam E 
+hk/EitherMonad#[T] => typeparam T 
+hk/EitherMonad#`<init>`(). => primary ctor <init> [typeparam T ](): EitherMonad[T]
+hk/EitherMonad#`<init>`().[E] => typeparam E 
+hk/Monad# => trait Monad [typeparam M [type _ ]] extends Object { self: Monad[M] => +4 decls }
+hk/Monad#[M] => typeparam M [type _ ]
+hk/Monad#[M][_] => type _ 
+hk/Monad#`<init>`(). => primary ctor <init> [typeparam M [type _ ]](): Monad[M]
+hk/Monad#flatMap(). => method flatMap [typeparam A , typeparam B ](param m: M[A])(param f: Function1[A, M[B]]): M[B]
+hk/Monad#flatMap().(f) => param f: Function1[A, M[B]]
+hk/Monad#flatMap().(m) => param m: M[A]
+hk/Monad#flatMap().[A] => typeparam A 
+hk/Monad#flatMap().[B] => typeparam B 
+hk/Monad#pure(). => method pure [typeparam A ](param a: A): M[A]
+hk/Monad#pure().(a) => param a: A
+hk/Monad#pure().[A] => typeparam A 
+hk/hk$package. => final package object hk extends Object { self: hk.type => +5 decls }
+hk/hk$package.Id# => type Id [typeparam A ] = A
+hk/hk$package.Id#[A] => typeparam A 
+hk/hk$package.MapEither# => type MapEither [typeparam K ] = [L] =>> [R] =>> Map[K, Either[L, R]]
+hk/hk$package.MapEither#[K] => typeparam K 
+hk/hk$package.MapEither#[L] => typeparam L 
+hk/hk$package.MapEither#[R] => typeparam R 
+hk/hk$package.MapKV# => type MapKV [typeparam K ] = [V] =>> Map[K, V]
+hk/hk$package.MapKV#[K] => typeparam K 
+hk/hk$package.MapKV#[V] => typeparam V 
+hk/hk$package.MapV# => type MapV [type _ ] = [V] =>> Map[String, V]
+hk/hk$package.MapV#[V] => typeparam V 
+hk/hk$package.MapV#[_] => type _ 
+
+Occurrences:
+[0:8..0:10): hk <- hk/
+[2:6..2:11): Monad <- hk/Monad#
+[2:12..2:13): M <- hk/Monad#[M]
+[3:6..3:10): pure <- hk/Monad#pure().
+[3:11..3:12): A <- hk/Monad#pure().[A]
+[3:14..3:15): a <- hk/Monad#pure().(a)
+[3:17..3:18): A -> hk/Monad#pure().[A]
+[3:21..3:22): M -> hk/Monad#[M]
+[3:23..3:24): A -> hk/Monad#pure().[A]
+[3:28..3:31): ??? -> scala/Predef.`???`().
+[4:6..4:13): flatMap <- hk/Monad#flatMap().
+[4:14..4:15): A <- hk/Monad#flatMap().[A]
+[4:17..4:18): B <- hk/Monad#flatMap().[B]
+[4:20..4:21): m <- hk/Monad#flatMap().(m)
+[4:23..4:24): M -> hk/Monad#[M]
+[4:25..4:26): A -> hk/Monad#flatMap().[A]
+[4:29..4:30): f <- hk/Monad#flatMap().(f)
+[4:32..4:33): A -> hk/Monad#flatMap().[A]
+[4:37..4:38): M -> hk/Monad#[M]
+[4:39..4:40): B -> hk/Monad#flatMap().[B]
+[4:44..4:45): M -> hk/Monad#[M]
+[4:46..4:47): B -> hk/Monad#flatMap().[B]
+[4:51..4:54): ??? -> scala/Predef.`???`().
+[7:6..7:17): EitherMonad <- hk/EitherMonad#
+[7:18..7:19): T <- hk/EitherMonad#[T]
+[7:29..7:34): Monad -> hk/Monad#
+[7:36..7:37): E <- hk/EitherMonad#`<init>`().[E]
+[7:43..7:49): Either -> scala/package.Either#
+[7:50..7:51): T -> hk/EitherMonad#[T]
+[10:5..10:10): MapKV <- hk/hk$package.MapKV#
+[10:14..10:15): K <- hk/hk$package.MapKV#[K]
+[10:22..10:23): V <- hk/hk$package.MapKV#[V]
+[10:29..10:32): Map -> scala/Predef.Map#
+[10:33..10:34): K -> hk/hk$package.MapKV#[K]
+[10:35..10:36): V -> hk/hk$package.MapKV#[V]
+[12:5..12:9): MapV <- hk/hk$package.MapV#
+[12:21..12:22): V <- hk/hk$package.MapV#[V]
+[12:28..12:31): Map -> scala/Predef.Map#
+[12:32..12:38): String -> scala/Predef.String#
+[12:40..12:41): V -> hk/hk$package.MapV#[V]
+[14:5..14:14): MapEither <- hk/hk$package.MapEither#
+[14:18..14:19): K <- hk/hk$package.MapEither#[K]
+[14:26..14:27): L <- hk/hk$package.MapEither#[L]
+[14:34..14:35): R <- hk/hk$package.MapEither#[R]
+[14:41..14:44): Map -> scala/Predef.Map#
+[14:45..14:46): K -> hk/hk$package.MapEither#[K]
+[14:48..14:54): Either -> scala/package.Either#
+[14:55..14:56): L -> hk/hk$package.MapEither#[L]
+[14:58..14:59): R -> hk/hk$package.MapEither#[R]
+[16:5..16:7): Id <- hk/hk$package.Id#
+[16:8..16:9): A <- hk/hk$package.Id#[A]
+[16:13..16:14): A -> hk/hk$package.Id#[A]
+
 expect/i5854.scala
 ------------------
 

From 351f602e67f707168c38faf6f2f7eaa6fec1f737 Mon Sep 17 00:00:00 2001
From: Jan-Pieter van den Heuvel <jan-pieter@piozum.com>
Date: Tue, 28 Mar 2023 18:15:24 +0200
Subject: [PATCH 396/657] Fix deprecation check and add tests

---
 .../src/dotty/tools/dotc/core/Flags.scala     |  1 +
 .../tools/dotc/typer/CrossVersionChecks.scala | 12 +++++++----
 .../neg-custom-args/deprecation/i11022.check  | 20 +++++++++++++++++++
 .../neg-custom-args/deprecation/i11022.scala  | 11 ++++++++++
 tests/pos/i11022.scala                        |  3 +++
 5 files changed, 43 insertions(+), 4 deletions(-)
 create mode 100644 tests/neg-custom-args/deprecation/i11022.check
 create mode 100644 tests/neg-custom-args/deprecation/i11022.scala
 create mode 100644 tests/pos/i11022.scala

diff --git a/compiler/src/dotty/tools/dotc/core/Flags.scala b/compiler/src/dotty/tools/dotc/core/Flags.scala
index f23dce020f10..47e7a85952b2 100644
--- a/compiler/src/dotty/tools/dotc/core/Flags.scala
+++ b/compiler/src/dotty/tools/dotc/core/Flags.scala
@@ -604,6 +604,7 @@ object Flags {
   val Scala2Trait: FlagSet                   = Scala2x | Trait
   val SyntheticArtifact: FlagSet             = Synthetic | Artifact
   val SyntheticCase: FlagSet                 = Synthetic | Case
+  val SyntheticMethod: FlagSet               = Synthetic | Method
   val SyntheticModule: FlagSet               = Synthetic | Module
   val SyntheticOpaque: FlagSet               = Synthetic | Opaque
   val SyntheticParam: FlagSet                = Synthetic | Param
diff --git a/compiler/src/dotty/tools/dotc/typer/CrossVersionChecks.scala b/compiler/src/dotty/tools/dotc/typer/CrossVersionChecks.scala
index ef9599be551c..84f4754e3c78 100644
--- a/compiler/src/dotty/tools/dotc/typer/CrossVersionChecks.scala
+++ b/compiler/src/dotty/tools/dotc/typer/CrossVersionChecks.scala
@@ -52,7 +52,8 @@ class CrossVersionChecks extends MiniPhase:
       owner.isDeprecated
       || isEnumOwner(owner)
 
-    /**Scan the chain of outer declaring scopes from the current context
+    /**Skip warnings for synthetic members of case classes during declaration and
+     * 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.
@@ -60,10 +61,13 @@ class CrossVersionChecks extends MiniPhase:
      *   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)
+    def skipWarning(using Context): Boolean =
+      (ctx.owner.is(Synthetic) && sym.is(CaseClass))
+        || ctx.owner.ownersIterator.exists(if sym.isEnumCase then isDeprecatedOrEnum else _.isDeprecated)
 
-    for annot <- sym.getAnnotation(defn.DeprecatedAnnot) do
+    // Also check for deprecation of the companion class for synthetic methods
+    val toCheck = sym :: (if sym.isAllOf(SyntheticMethod) then sym.owner.companionClass :: Nil else Nil)
+    for sym <- toCheck; 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("")
diff --git a/tests/neg-custom-args/deprecation/i11022.check b/tests/neg-custom-args/deprecation/i11022.check
new file mode 100644
index 000000000000..464f2827c49e
--- /dev/null
+++ b/tests/neg-custom-args/deprecation/i11022.check
@@ -0,0 +1,20 @@
+-- Error: tests/neg-custom-args/deprecation/i11022.scala:8:7 -----------------------------------------------------------
+8 |val a: CaseClass = CaseClass(42)        // error: deprecated type // error: deprecated apply method
+  |       ^^^^^^^^^
+  |       class CaseClass is deprecated: no CaseClass
+-- Error: tests/neg-custom-args/deprecation/i11022.scala:8:19 ----------------------------------------------------------
+8 |val a: CaseClass = CaseClass(42)        // error: deprecated type // error: deprecated apply method
+  |                   ^^^^^^^^^
+  |                   class CaseClass is deprecated: no CaseClass
+-- Error: tests/neg-custom-args/deprecation/i11022.scala:9:7 -----------------------------------------------------------
+9 |val b: CaseClass = new CaseClass(42)    // error: deprecated type // error: deprecated class
+  |       ^^^^^^^^^
+  |       class CaseClass is deprecated: no CaseClass
+-- Error: tests/neg-custom-args/deprecation/i11022.scala:9:23 ----------------------------------------------------------
+9 |val b: CaseClass = new CaseClass(42)    // error: deprecated type // error: deprecated class
+  |                       ^^^^^^^^^
+  |                       class CaseClass is deprecated: no CaseClass
+-- Error: tests/neg-custom-args/deprecation/i11022.scala:10:14 ---------------------------------------------------------
+10 |val c: Unit = CaseClass(42).magic()     // error: deprecated apply method
+   |              ^^^^^^^^^
+   |              class CaseClass is deprecated: no CaseClass
diff --git a/tests/neg-custom-args/deprecation/i11022.scala b/tests/neg-custom-args/deprecation/i11022.scala
new file mode 100644
index 000000000000..4608017eeed9
--- /dev/null
+++ b/tests/neg-custom-args/deprecation/i11022.scala
@@ -0,0 +1,11 @@
+@deprecated("no CaseClass")
+case class CaseClass(rgb: Int):
+  def magic(): Unit = ()
+
+object CaseClass:
+  def notDeprecated(): Unit = ()
+
+val a: CaseClass = CaseClass(42)        // error: deprecated type // error: deprecated apply method
+val b: CaseClass = new CaseClass(42)    // error: deprecated type // error: deprecated class
+val c: Unit = CaseClass(42).magic()     // error: deprecated apply method
+val d: Unit = CaseClass.notDeprecated() // compiles
diff --git a/tests/pos/i11022.scala b/tests/pos/i11022.scala
new file mode 100644
index 000000000000..d020669049c5
--- /dev/null
+++ b/tests/pos/i11022.scala
@@ -0,0 +1,3 @@
+// scalac: -Werror -deprecation
+@deprecated("no CaseClass")
+case class CaseClass(rgb: Int)

From 3133d8541d3767c833024fcbb35b0126708db066 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 18 Apr 2023 17:22:50 +0200
Subject: [PATCH 397/657] Remove references to deprecated classes

`scala.{Traversable,TraversableOnce,BufferedIterator}` are deprecated
since 2.13.0. It seems these deprecated references where not found when
the check was performed after `FirstTransform` as the types might have
been dealiased in the `TypeTree`.
---
 compiler/src/dotty/tools/dotc/config/PathResolver.scala     | 2 +-
 compiler/src/dotty/tools/dotc/core/SymDenotations.scala     | 2 +-
 .../dotty/tools/dotc/parsing/xml/MarkupParserCommon.scala   | 3 +--
 .../src/dotty/tools/dotc/parsing/xml/MarkupParsers.scala    | 1 +
 compiler/src/dotty/tools/dotc/printing/Printer.scala        | 6 +++---
 compiler/src/dotty/tools/dotc/printing/Texts.scala          | 4 ++--
 6 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/config/PathResolver.scala b/compiler/src/dotty/tools/dotc/config/PathResolver.scala
index afa30e38dc2a..8b4eedb0e9d2 100644
--- a/compiler/src/dotty/tools/dotc/config/PathResolver.scala
+++ b/compiler/src/dotty/tools/dotc/config/PathResolver.scala
@@ -211,7 +211,7 @@ class PathResolver(using c: Context) {
     import classPathFactory._
 
     // Assemble the elements!
-    def basis: List[Traversable[ClassPath]] =
+    def basis: List[Iterable[ClassPath]] =
       val release = Option(ctx.settings.javaOutputVersion.value).filter(_.nonEmpty)
 
       List(
diff --git a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
index beeaa2ee922e..aac1760fb1f7 100644
--- a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -299,7 +299,7 @@ object SymDenotations {
     }
 
     /** Add all given annotations to this symbol */
-    final def addAnnotations(annots: TraversableOnce[Annotation])(using Context): Unit =
+    final def addAnnotations(annots: IterableOnce[Annotation])(using Context): Unit =
       annots.iterator.foreach(addAnnotation)
 
     @tailrec
diff --git a/compiler/src/dotty/tools/dotc/parsing/xml/MarkupParserCommon.scala b/compiler/src/dotty/tools/dotc/parsing/xml/MarkupParserCommon.scala
index 2c6c5361e51c..0f7d426fbd28 100644
--- a/compiler/src/dotty/tools/dotc/parsing/xml/MarkupParserCommon.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/xml/MarkupParserCommon.scala
@@ -11,8 +11,7 @@ package xml
 
 import Utility._
 import util.Chars.SU
-
-
+import scala.collection.BufferedIterator
 
 /** This is not a public trait - it contains common code shared
  *  between the library level XML parser and the compiler's.
diff --git a/compiler/src/dotty/tools/dotc/parsing/xml/MarkupParsers.scala b/compiler/src/dotty/tools/dotc/parsing/xml/MarkupParsers.scala
index 77c5a1bf376b..b3f41fab9eaa 100644
--- a/compiler/src/dotty/tools/dotc/parsing/xml/MarkupParsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/xml/MarkupParsers.scala
@@ -6,6 +6,7 @@ package xml
 import scala.language.unsafeNulls
 
 import scala.collection.mutable
+import scala.collection.BufferedIterator
 import core.Contexts.Context
 import mutable.{ Buffer, ArrayBuffer, ListBuffer }
 import scala.util.control.ControlThrowable
diff --git a/compiler/src/dotty/tools/dotc/printing/Printer.scala b/compiler/src/dotty/tools/dotc/printing/Printer.scala
index 326630844dde..697ab063a646 100644
--- a/compiler/src/dotty/tools/dotc/printing/Printer.scala
+++ b/compiler/src/dotty/tools/dotc/printing/Printer.scala
@@ -174,15 +174,15 @@ abstract class Printer {
     atPrec(GlobalPrec) { elem.toText(this) }
 
   /** Render elements alternating with `sep` string */
-  def toText(elems: Traversable[Showable], sep: String): Text =
+  def toText(elems: Iterable[Showable], sep: String): Text =
     Text(elems map (_ toText this), sep)
 
   /** Render elements within highest precedence */
-  def toTextLocal(elems: Traversable[Showable], sep: String): Text =
+  def toTextLocal(elems: Iterable[Showable], sep: String): Text =
     atPrec(DotPrec) { toText(elems, sep) }
 
   /** Render elements within lowest precedence */
-  def toTextGlobal(elems: Traversable[Showable], sep: String): Text =
+  def toTextGlobal(elems: Iterable[Showable], sep: String): Text =
     atPrec(GlobalPrec) { toText(elems, sep) }
 
   /** A plain printer without any embellishments */
diff --git a/compiler/src/dotty/tools/dotc/printing/Texts.scala b/compiler/src/dotty/tools/dotc/printing/Texts.scala
index 7c040a78de5e..475e2c6900d5 100644
--- a/compiler/src/dotty/tools/dotc/printing/Texts.scala
+++ b/compiler/src/dotty/tools/dotc/printing/Texts.scala
@@ -173,7 +173,7 @@ object Texts {
     /** A concatenation of elements in `xs` and interspersed with
      *  separator strings `sep`.
      */
-    def apply(xs: Traversable[Text], sep: String = " "): Text =
+    def apply(xs: Iterable[Text], sep: String = " "): Text =
       if (sep == "\n") lines(xs)
       else {
         val ys = xs.filterNot(_.isEmpty)
@@ -182,7 +182,7 @@ object Texts {
       }
 
     /** The given texts `xs`, each on a separate line */
-    def lines(xs: Traversable[Text]): Vertical = Vertical(xs.toList.reverse)
+    def lines(xs: Iterable[Text]): Vertical = Vertical(xs.toList.reverse)
 
     extension (text: => Text)
       def provided(cond: Boolean): Text = if (cond) text else Str("")

From 57c44794449ed53b4bd287960eec69f07d6be6b6 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 18 Apr 2023 16:17:36 +0200
Subject: [PATCH 398/657] Move CrossVersionChecks before FirstTransform

Fixes #17292
---
 compiler/src/dotty/tools/dotc/Compiler.scala  |  6 +--
 .../tools/dotc/typer/CrossVersionChecks.scala | 41 ++++++-------------
 .../neg-custom-args/deprecation/14034b.scala  |  4 +-
 .../no-experimental/14034.scala               |  4 +-
 .../no-experimental/i17292.scala              |  7 ++++
 .../no-experimental/i17292b.scala             | 21 ++++++++++
 6 files changed, 48 insertions(+), 35 deletions(-)
 create mode 100644 tests/neg-custom-args/no-experimental/i17292.scala
 create mode 100644 tests/neg-custom-args/no-experimental/i17292b.scala

diff --git a/compiler/src/dotty/tools/dotc/Compiler.scala b/compiler/src/dotty/tools/dotc/Compiler.scala
index b0f7b0a533d7..a6118732d4ae 100644
--- a/compiler/src/dotty/tools/dotc/Compiler.scala
+++ b/compiler/src/dotty/tools/dotc/Compiler.scala
@@ -59,7 +59,8 @@ class Compiler {
   /** 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
+    List(new CrossVersionChecks,     // Check issues related to deprecated and experimental
+         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.
@@ -71,8 +72,7 @@ class Compiler {
          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
+    List(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
diff --git a/compiler/src/dotty/tools/dotc/typer/CrossVersionChecks.scala b/compiler/src/dotty/tools/dotc/typer/CrossVersionChecks.scala
index ef9599be551c..0d68b0b1f766 100644
--- a/compiler/src/dotty/tools/dotc/typer/CrossVersionChecks.scala
+++ b/compiler/src/dotty/tools/dotc/typer/CrossVersionChecks.scala
@@ -18,9 +18,6 @@ class CrossVersionChecks extends MiniPhase:
 
   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
@@ -69,18 +66,8 @@ class CrossVersionChecks extends MiniPhase:
         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
+    if sym.exists && !sym.isInExperimentalScope then
       for annot <- sym.annotations if annot.symbol.isExperimental do
         Feature.checkExperimentalDef(annot.symbol, annot.tree)
 
@@ -119,13 +106,16 @@ class CrossVersionChecks extends MiniPhase:
   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 transformTypeDef(tree: TypeDef)(using Context): TypeDef =
+    // TODO do we need to check checkDeprecatedOvers(tree)?
+    checkExperimentalAnnots(tree.symbol)
     tree
 
   override def transformIdent(tree: Ident)(using Context): Ident = {
@@ -157,19 +147,14 @@ class CrossVersionChecks extends MiniPhase:
     tree
   }
 
-  override def transformTypeDef(tree: TypeDef)(using Context): TypeDef = {
-    checkExperimentalAnnots(tree.symbol)
+  override def transformOther(tree: Tree)(using Context): Tree =
+    tree.foreachSubTree { // Find references in type trees and imports
+      case tree: Ident => transformIdent(tree)
+      case tree: Select => transformSelect(tree)
+      case tree: TypeTree => transformTypeTree(tree)
+      case _ =>
+    }
     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
 
diff --git a/tests/neg-custom-args/deprecation/14034b.scala b/tests/neg-custom-args/deprecation/14034b.scala
index d22a945fe10d..07960bba9574 100644
--- a/tests/neg-custom-args/deprecation/14034b.scala
+++ b/tests/neg-custom-args/deprecation/14034b.scala
@@ -9,6 +9,6 @@ type Foo0 = Exp // error
 type Foo = Option[Exp] // error
 type Bar = Option[exp.type] // error
 type Baz = Exp | Int // error
-type Quux = [X] =>> X match // error
-  case Exp => Int
+type Quux = [X] =>> X match
+  case Exp => Int // error
 type Quuz[A <: Exp] = Int // error
diff --git a/tests/neg-custom-args/no-experimental/14034.scala b/tests/neg-custom-args/no-experimental/14034.scala
index c0b4cc6899db..ab824c43395e 100644
--- a/tests/neg-custom-args/no-experimental/14034.scala
+++ b/tests/neg-custom-args/no-experimental/14034.scala
@@ -7,6 +7,6 @@ type Foo0 = Exp // error
 type Foo = Option[Exp] // error
 type Bar = Option[exp.type] // error
 type Baz = Exp | Int // error
-type Quux = [X] =>> X match // error
-  case Exp => Int
+type Quux = [X] =>> X match
+  case Exp => Int // error
 type Quuz[A <: Exp] = Int // error
diff --git a/tests/neg-custom-args/no-experimental/i17292.scala b/tests/neg-custom-args/no-experimental/i17292.scala
new file mode 100644
index 000000000000..381d252dbea8
--- /dev/null
+++ b/tests/neg-custom-args/no-experimental/i17292.scala
@@ -0,0 +1,7 @@
+import annotation.experimental
+
+class Foo { @experimental type Bar = (Int, String) }
+
+val f: Foo = Foo()
+
+def g: Tuple.Elem[f.Bar, 0] = ??? // error
diff --git a/tests/neg-custom-args/no-experimental/i17292b.scala b/tests/neg-custom-args/no-experimental/i17292b.scala
new file mode 100644
index 000000000000..f644dd60ecd5
--- /dev/null
+++ b/tests/neg-custom-args/no-experimental/i17292b.scala
@@ -0,0 +1,21 @@
+import annotation.experimental
+type A[T] = Int
+class Foo {
+  @experimental type Bar = (Int, String)
+}
+
+type Elem1[X <: Tuple, N <: Int] = X match { case x *: xs => N match { case 0 => x } }
+type Elem2[X <: Tuple, N <: Int]
+
+val f: Foo = Foo()
+
+def bar1: f.Bar = ??? // error
+def bar2 = // error
+  ??? : f.Bar // error
+
+def g0: Elem1[f.Bar, 0] = ??? // error
+def g1(a: Elem1[f.Bar, 0]) = ??? // error
+def g2 =
+  ??? : Elem1[f.Bar, 0] // error
+
+def h: Elem2[f.Bar, 0] = ??? // error

From c2f63626fc3102945c73db8e4b19d7777aa81332 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Fri, 21 Apr 2023 09:39:21 +0200
Subject: [PATCH 399/657] Rename `Spliced` to `SplicedExpr`

---
 compiler/src/dotty/tools/dotc/ast/TreeInfo.scala              | 2 +-
 compiler/src/dotty/tools/dotc/inlines/Inliner.scala           | 4 ++--
 compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala | 2 +-
 compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala | 4 ++--
 compiler/src/dotty/tools/dotc/transform/Splicer.scala         | 2 +-
 5 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
index c2147b6af2d3..77b34335eeb8 100644
--- a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
+++ b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
@@ -1044,7 +1044,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
   }
 
   /** Extractors for splices */
-  object Spliced {
+  object SplicedExpr {
     /** Extracts the content of a spliced expression tree.
      *  The result can be the contents of a term splice, which
      *  will return a term tree.
diff --git a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
index f4612e49ccac..ba6300d2e3d3 100644
--- a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
@@ -817,7 +817,7 @@ class Inliner(val call: tpd.Tree)(using Context):
     override def typedApply(tree: untpd.Apply, pt: Type)(using Context): Tree =
       def cancelQuotes(tree: Tree): Tree =
         tree match
-          case Quoted(Spliced(inner)) => inner
+          case Quoted(SplicedExpr(inner)) => inner
           case _ => tree
       val locked = ctx.typerState.ownedVars
       val res = cancelQuotes(constToLiteral(BetaReduce(super.typedApply(tree, pt)))) match {
@@ -1071,7 +1071,7 @@ class Inliner(val call: tpd.Tree)(using Context):
             level += 1
             try apply(syms, body)
             finally level -= 1
-          case Spliced(body) =>
+          case SplicedExpr(body) =>
             level -= 1
             try apply(syms, body)
             finally level += 1
diff --git a/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala b/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
index 33bc5a7ef10e..c3aa98e6ef30 100644
--- a/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
@@ -290,7 +290,7 @@ object PrepareInlineable {
     if (inlined.is(Macro) && !ctx.isAfterTyper) {
 
       def checkMacro(tree: Tree): Unit = tree match {
-        case Spliced(code) =>
+        case SplicedExpr(code) =>
           if (code.symbol.flags.is(Inline))
             report.error("Macro cannot be implemented with an `inline` method", code.srcPos)
           Splicer.checkValidMacroBody(code)
diff --git a/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala b/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
index adaacafa764a..49da11afd9b3 100644
--- a/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
+++ b/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
@@ -61,7 +61,7 @@ abstract class TreeMapWithStages extends TreeMapWithImplicits {
           val old = inQuoteOrSplice
           inQuoteOrSplice = true
           try dropEmptyBlocks(quotedTree) match {
-            case Spliced(t) =>
+            case SplicedExpr(t) =>
               // Optimization: `'{ $x }` --> `x`
               // and adapt the refinement of `Quotes { type reflect: ... } ?=> Expr[T]`
               transform(t).asInstance(tree.tpe)
@@ -69,7 +69,7 @@ abstract class TreeMapWithStages extends TreeMapWithImplicits {
           }
           finally inQuoteOrSplice = old
 
-        case tree @ Spliced(splicedTree) =>
+        case tree @ SplicedExpr(splicedTree) =>
           val old = inQuoteOrSplice
           inQuoteOrSplice = true
           try dropEmptyBlocks(splicedTree) match {
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicer.scala b/compiler/src/dotty/tools/dotc/transform/Splicer.scala
index bc4119ad0cff..cd41fb358d30 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicer.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicer.scala
@@ -158,7 +158,7 @@ object Splicer {
         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(_) =>
+              case SplicedExpr(_) =>
                 report.error("Quoted argument of macros may not have splices", tree.srcPos)
               case _ =>
                 traverseChildren(tree)

From 938d3ae5f72192d03b084cc84e37bb677d5dc29a Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Fri, 21 Apr 2023 09:50:10 +0200
Subject: [PATCH 400/657] Split `Quoted` extractor into `QuotedExpr` and
 `QuotedTypeOf`

---
 .../src/dotty/tools/dotc/ast/TreeInfo.scala   | 13 ++++++++++--
 .../dotty/tools/dotc/inlines/Inliner.scala    |  8 ++++++--
 .../dotc/staging/TreeMapWithStages.scala      | 20 ++++++++++---------
 .../dotty/tools/dotc/transform/Splicer.scala  |  4 ++--
 .../tools/dotc/transform/patmat/Space.scala   |  2 +-
 5 files changed, 31 insertions(+), 16 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
index 77b34335eeb8..f2a49254678f 100644
--- a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
+++ b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
@@ -1027,7 +1027,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
     }
 
   /** Extractors for quotes */
-  object Quoted {
+  object QuotedExpr {
     /** 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.
@@ -1036,7 +1036,16 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
       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
+      else None
+  }
+
+  object QuotedTypeOf {
+    /** 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.QuotedTypeModule_of then
         // quoted.Type.of[<body>](quotes)
         val TypeApply(_, body :: _) = tree.fun: @unchecked
         Some(body)
diff --git a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
index ba6300d2e3d3..50cd933532ae 100644
--- a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
@@ -817,7 +817,7 @@ class Inliner(val call: tpd.Tree)(using Context):
     override def typedApply(tree: untpd.Apply, pt: Type)(using Context): Tree =
       def cancelQuotes(tree: Tree): Tree =
         tree match
-          case Quoted(SplicedExpr(inner)) => inner
+          case QuotedExpr(SplicedExpr(inner)) => inner
           case _ => tree
       val locked = ctx.typerState.ownedVars
       val res = cancelQuotes(constToLiteral(BetaReduce(super.typedApply(tree, pt)))) match {
@@ -1067,7 +1067,11 @@ class Inliner(val call: tpd.Tree)(using Context):
         else tree match {
           case tree: RefTree if tree.isTerm && tree.symbol.isDefinedInCurrentRun && !tree.symbol.isLocal =>
             foldOver(tree.symbol :: syms, tree)
-          case Quoted(body) =>
+          case QuotedExpr(body) =>
+            level += 1
+            try apply(syms, body)
+            finally level -= 1
+          case QuotedTypeOf(body) =>
             level += 1
             try apply(syms, body)
             finally level -= 1
diff --git a/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala b/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
index 49da11afd9b3..096454de9a7f 100644
--- a/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
+++ b/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
@@ -49,15 +49,17 @@ abstract class TreeMapWithStages extends TreeMapWithImplicits {
       }
 
       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 Apply(Select(QuotedTypeOf(SplicedType(t)), _), _) =>
+          // Optimization: `quoted.Type.of[x.Underlying]` --> `x`
+          transform(t)
+
+        case tree @ QuotedTypeOf(quotedTree) =>
+          val old = inQuoteOrSplice
+          inQuoteOrSplice = true
+          try transformQuotation(quotedTree, tree)
+          finally inQuoteOrSplice = old
 
-        case tree @ Quoted(quotedTree) =>
+        case tree @ QuotedExpr(quotedTree) =>
           val old = inQuoteOrSplice
           inQuoteOrSplice = true
           try dropEmptyBlocks(quotedTree) match {
@@ -73,7 +75,7 @@ abstract class TreeMapWithStages extends TreeMapWithImplicits {
           val old = inQuoteOrSplice
           inQuoteOrSplice = true
           try dropEmptyBlocks(splicedTree) match {
-            case Quoted(t) =>
+            case QuotedExpr(t) =>
               // Optimization: `${ 'x }` --> `x`
               transform(t)
             case _ => transformSplice(splicedTree, tree)
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicer.scala b/compiler/src/dotty/tools/dotc/transform/Splicer.scala
index cd41fb358d30..11e88585f144 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicer.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicer.scala
@@ -44,7 +44,7 @@ object Splicer {
    *  See: `Staging`
    */
   def splice(tree: Tree, splicePos: SrcPos, spliceExpansionPos: SrcPos, classLoader: ClassLoader)(using Context): Tree = tree match {
-    case Quoted(quotedTree) => quotedTree
+    case QuotedExpr(quotedTree) => quotedTree
     case _ =>
       val macroOwner = newSymbol(ctx.owner, nme.MACROkw, Macro | Synthetic, defn.AnyType, coord = tree.span)
       try
@@ -136,7 +136,7 @@ object Splicer {
     *  See: `Staging`
     */
   def checkValidMacroBody(tree: Tree)(using Context): Unit = tree match {
-    case Quoted(_) => // ok
+    case QuotedExpr(_) => // ok
     case _ =>
       type Env = Set[Symbol]
 
diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index 3e05310d7249..5db7c61aebc0 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -312,7 +312,7 @@ object SpaceEngine {
   def isIrrefutableQuotedPattern(unapp: tpd.Tree, implicits: List[tpd.Tree], pt: Type)(using Context): Boolean = {
     implicits.headOption match
       // pattern '{ $x: T }
-      case Some(tpd.Apply(tpd.Select(tpd.Quoted(tpd.TypeApply(fn, List(tpt))), nme.apply), _))
+      case Some(tpd.Apply(tpd.Select(tpd.QuotedExpr(tpd.TypeApply(fn, List(tpt))), nme.apply), _))
           if unapp.symbol.owner.eq(defn.QuoteMatching_ExprMatchModule)
           && fn.symbol.eq(defn.QuotedRuntimePatterns_patternHole) =>
         pt <:< defn.QuotedExprClass.typeRef.appliedTo(tpt.tpe)

From b7ca9b1e051c5f3dbca6eb07b226b31f5492ba69 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Fri, 21 Apr 2023 10:28:01 +0200
Subject: [PATCH 401/657] Split `transformQuotation` into `transformQuotedExpr`
 and `transformQuotedType`

---
 .../tools/dotc/staging/CrossStageSafety.scala | 67 ++++++++++---------
 .../dotc/staging/TreeMapWithStages.scala      | 20 +++---
 2 files changed, 46 insertions(+), 41 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
index 400a846194e7..9dc12d553abf 100644
--- a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
+++ b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
@@ -98,46 +98,47 @@ class CrossStageSafety extends TreeMapWithStages {
     }
 
   /** Transform quoted trees while maintaining level correctness */
-  override protected def transformQuotation(body: Tree, quote: Apply)(using Context): Tree = {
-    val taggedTypes = new QuoteTypeTags(quote.span)
-
+  override protected def transformQuotedExpr(body: Tree, quote: Apply)(using Context): Tree = {
     if (ctx.property(InAnnotation).isDefined)
       report.error("Cannot have a quote in an annotation", quote.srcPos)
 
     val stripAnnotsDeep: TypeMap = new TypeMap:
       def apply(tp: Type): Type = mapOver(tp.stripAnnots)
+    val transformedBody = transformQuoteBody(body, quote)
+    // `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(healType(quote.fun.srcPos)(stripAnnotsDeep(targ.tpe))))
+    cpy.Apply(quote)(cpy.TypeApply(quote.fun)(fun, targs2), transformedBody :: Nil)
+  }
 
-    def transformBody() =
-      val contextWithQuote =
-        if level == 0 then contextWithQuoteTypeTags(taggedTypes)(using quoteContext)
-        else quoteContext
-      val transformedBody = transform(body)(using contextWithQuote)
-      taggedTypes.getTypeTags match
-        case Nil  => transformedBody
-        case tags => tpd.Block(tags, transformedBody).withSpan(body.span)
-
-    if body.isTerm then
-      val transformedBody = transformBody()
-      // `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(healType(quote.fun.srcPos)(stripAnnotsDeep(targ.tpe))))
-      cpy.Apply(quote)(cpy.TypeApply(quote.fun)(fun, targs2), transformedBody :: Nil)
-    else
-      body.tpe match
-        case DirectTypeOf(termRef) =>
-          // Optimization: `quoted.Type.of[x.Underlying](quotes)`  -->  `x`
-          ref(termRef).withSpan(quote.span)
-        case _ =>
-          transformBody() match
-            case DirectTypeOf.Healed(termRef) =>
-              // Optimization: `quoted.Type.of[@SplicedType type T = x.Underlying; T](quotes)`  -->  `x`
-              ref(termRef).withSpan(quote.span)
-            case transformedBody =>
-              val quotes = quote.args.mapConserve(transform)
-              // `quoted.Type.of[<body>](quotes)`  --> `quoted.Type.of[<body2>](quotes)`
-              val TypeApply(fun, _) = quote.fun: @unchecked
-              cpy.Apply(quote)(cpy.TypeApply(quote.fun)(fun, transformedBody :: Nil), quotes)
+  override protected def transformQuotedType(body: Tree, quote: Apply)(using Context): Tree = {
+    if (ctx.property(InAnnotation).isDefined)
+      report.error("Cannot have a quote in an annotation", quote.srcPos)
+    body.tpe match
+      case DirectTypeOf(termRef) =>
+        // Optimization: `quoted.Type.of[x.Underlying](quotes)`  -->  `x`
+        ref(termRef).withSpan(quote.span)
+      case _ =>
+        transformQuoteBody(body, quote) match
+          case DirectTypeOf.Healed(termRef) =>
+            // Optimization: `quoted.Type.of[@SplicedType type T = x.Underlying; T](quotes)`  -->  `x`
+            ref(termRef).withSpan(quote.span)
+          case transformedBody =>
+            val quotes = quote.args.mapConserve(transform)
+            // `quoted.Type.of[<body>](quotes)`  --> `quoted.Type.of[<body2>](quotes)`
+            val TypeApply(fun, _) = quote.fun: @unchecked
+            cpy.Apply(quote)(cpy.TypeApply(quote.fun)(fun, transformedBody :: Nil), quotes)
+  }
 
+  private def transformQuoteBody(body: Tree, quote: Apply)(using Context): Tree = {
+    val taggedTypes = new QuoteTypeTags(quote.span)
+    val contextWithQuote =
+      if level == 0 then contextWithQuoteTypeTags(taggedTypes)(using quoteContext)
+      else quoteContext
+    val transformedBody = transform(body)(using contextWithQuote)
+    taggedTypes.getTypeTags match
+      case Nil  => transformedBody
+      case tags => tpd.Block(tags, transformedBody).withSpan(body.span)
   }
 
   /** Transform splice
diff --git a/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala b/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
index 096454de9a7f..c88a6aafebe6 100644
--- a/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
+++ b/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
@@ -24,14 +24,17 @@ abstract class TreeMapWithStages extends TreeMapWithImplicits {
   /** Transform the quote `quote` which contains the quoted `body`.
    *
    *  - `quoted.runtime.Expr.quote[T](<body0>)`  --> `quoted.runtime.Expr.quote[T](<body>)`
+   */
+  protected def transformQuotedExpr(body: Tree, quote: Apply)(using Context): Tree =
+    cpy.Apply(quote)(quote.fun, body :: Nil)
+
+  /** Transform the quote `quote` which contains the quoted `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)
+  protected def transformQuotedType(body: Tree, quote: Apply)(using Context): Tree =
+    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
@@ -56,7 +59,7 @@ abstract class TreeMapWithStages extends TreeMapWithImplicits {
         case tree @ QuotedTypeOf(quotedTree) =>
           val old = inQuoteOrSplice
           inQuoteOrSplice = true
-          try transformQuotation(quotedTree, tree)
+          try transformQuotedType(quotedTree, tree)
           finally inQuoteOrSplice = old
 
         case tree @ QuotedExpr(quotedTree) =>
@@ -67,7 +70,8 @@ abstract class TreeMapWithStages extends TreeMapWithImplicits {
               // Optimization: `'{ $x }` --> `x`
               // and adapt the refinement of `Quotes { type reflect: ... } ?=> Expr[T]`
               transform(t).asInstance(tree.tpe)
-            case _ => transformQuotation(quotedTree, tree)
+            case _ =>
+              transformQuotedExpr(quotedTree, tree)
           }
           finally inQuoteOrSplice = old
 

From deb03a7191f5523b8fc787edb8c0cec5022da21a Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Fri, 21 Apr 2023 13:52:40 +0200
Subject: [PATCH 402/657] Add `QuotedExpr` to encode quotes directly in the AST

---
 .../dotty/tools/dotc/CompilationUnit.scala    |  6 ++--
 .../src/dotty/tools/dotc/ast/TreeInfo.scala   | 13 ---------
 compiler/src/dotty/tools/dotc/ast/Trees.scala | 14 ++++++++++
 compiler/src/dotty/tools/dotc/ast/tpd.scala   |  3 ++
 compiler/src/dotty/tools/dotc/ast/untpd.scala |  1 +
 .../tools/dotc/core/tasty/TreePickler.scala   |  8 ++++++
 .../tools/dotc/core/tasty/TreeUnpickler.scala |  5 ++++
 .../dotty/tools/dotc/inlines/Inliner.scala    | 10 +++++--
 .../dotc/inlines/PrepareInlineable.scala      |  3 +-
 .../tools/dotc/printing/RefinedPrinter.scala  |  5 ++--
 .../tools/dotc/staging/CrossStageSafety.scala | 17 +++++------
 .../dotc/staging/TreeMapWithStages.scala      |  8 +++---
 .../dotty/tools/dotc/transform/Inlining.scala |  8 ++++--
 .../tools/dotc/transform/PickleQuotes.scala   |  9 +++---
 .../tools/dotc/transform/PostTyper.scala      |  5 +++-
 .../dotty/tools/dotc/transform/Splicer.scala  | 24 ++++++++--------
 .../dotty/tools/dotc/transform/Splicing.scala | 28 ++++++++-----------
 .../dotty/tools/dotc/transform/SymUtils.scala |  4 ---
 .../tools/dotc/transform/patmat/Space.scala   |  2 +-
 .../tools/dotc/typer/QuotesAndSplices.scala   |  7 +++--
 .../dotty/tools/dotc/typer/TypeAssigner.scala |  6 ++++
 .../src/dotty/tools/dotc/typer/Typer.scala    |  7 +++++
 22 files changed, 115 insertions(+), 78 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/CompilationUnit.scala b/compiler/src/dotty/tools/dotc/CompilationUnit.scala
index 046b649941b1..897befdda4a5 100644
--- a/compiler/src/dotty/tools/dotc/CompilationUnit.scala
+++ b/compiler/src/dotty/tools/dotc/CompilationUnit.scala
@@ -154,11 +154,13 @@ object CompilationUnit {
     var containsCaptureChecking = false
     var containsMacroAnnotation = 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 tpd.QuotedExpr(_, _) =>
+          containsQuote = true
+        case tree: tpd.Apply if tree.symbol == defn.QuotedTypeModule_of =>
+          containsQuote = true
         case Import(qual, selectors) =>
           tpd.languageImport(qual) match
             case Some(prefix) =>
diff --git a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
index f2a49254678f..96f189425180 100644
--- a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
+++ b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
@@ -1026,19 +1026,6 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
       case t => assert(t.span.exists, i"$t")
     }
 
-  /** Extractors for quotes */
-  object QuotedExpr {
-    /** 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 None
-  }
-
   object QuotedTypeOf {
     /** Extracts the content of a quoted tree.
      *  The result can be the contents of a term or type quote, which
diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala
index 1c1e80922c05..0028cf21c244 100644
--- a/compiler/src/dotty/tools/dotc/ast/Trees.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala
@@ -677,6 +677,11 @@ object Trees {
     override def isType = expansion.isType
   }
 
+  case class QuotedExpr[+T <: Untyped] private[ast] (expr: Tree[T], tpt: Tree[T])(implicit @constructorOnly src: SourceFile)
+    extends TermTree[T] {
+    type ThisTree[+T <: Untyped] = QuotedExpr[T]
+  }
+
   /** 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] {
@@ -1087,6 +1092,7 @@ object Trees {
     type SeqLiteral = Trees.SeqLiteral[T]
     type JavaSeqLiteral = Trees.JavaSeqLiteral[T]
     type Inlined = Trees.Inlined[T]
+    type QuotedExpr = Trees.QuotedExpr[T]
     type TypeTree = Trees.TypeTree[T]
     type InferredTypeTree = Trees.InferredTypeTree[T]
     type SingletonTypeTree = Trees.SingletonTypeTree[T]
@@ -1257,6 +1263,10 @@ object Trees {
         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 QuotedExpr(tree: Tree)(expr: Tree, tpt: Tree)(using Context): QuotedExpr = tree match {
+        case tree: QuotedExpr if (expr eq tree.expr) && (tpt eq tree.tpt) => tree
+        case _ => finalize(tree, untpd.QuotedExpr(expr, tpt)(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)))
@@ -1494,6 +1504,8 @@ object Trees {
             case Thicket(trees) =>
               val trees1 = transform(trees)
               if (trees1 eq trees) tree else Thicket(trees1)
+            case tree @ QuotedExpr(expr, tpt) =>
+              cpy.QuotedExpr(tree)(transform(expr), transform(tpt))
             case tree @ Hole(_, _, args, content, tpt) =>
               cpy.Hole(tree)(args = transform(args), content = transform(content), tpt = transform(tpt))
             case _ =>
@@ -1635,6 +1647,8 @@ object Trees {
               this(this(x, arg), annot)
             case Thicket(ts) =>
               this(x, ts)
+            case QuotedExpr(expr, tpt) =>
+              this(this(x, expr), tpt)
             case Hole(_, _, args, content, tpt) =>
               this(this(this(x, args), content), tpt)
             case _ =>
diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
index c6e0bc581b59..88a822876043 100644
--- a/compiler/src/dotty/tools/dotc/ast/tpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -170,6 +170,9 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def Inlined(call: Tree, bindings: List[MemberDef], expansion: Tree)(using Context): Inlined =
     ta.assignType(untpd.Inlined(call, bindings, expansion), bindings, expansion)
 
+  def QuotedExpr(expr: Tree, tpt: Tree)(using Context): QuotedExpr =
+    ta.assignType(untpd.QuotedExpr(expr, tpt), tpt)
+
   def TypeTree(tp: Type, inferred: Boolean = false)(using Context): TypeTree =
     (if inferred then untpd.InferredTypeTree() else untpd.TypeTree()).withType(tp)
 
diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
index a262c3658399..7088739ddef3 100644
--- a/compiler/src/dotty/tools/dotc/ast/untpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -401,6 +401,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   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 QuotedExpr(expr: Tree, tpt: Tree)(implicit src: SourceFile): QuotedExpr = new QuotedExpr(expr, tpt)
   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)
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
index 8a396921f32b..d704c6eac771 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -665,6 +665,14 @@ class TreePickler(pickler: TastyPickler) {
               pickleTree(hi)
               pickleTree(alias)
           }
+        case QuotedExpr(expr, tpt) =>
+          pickleTree(
+            // scala.quoted.runtime.Expr.quoted[<tpt>](<expr>)
+            ref(defn.QuotedRuntime_exprQuote)
+              .appliedToTypeTree(tpt)
+              .appliedTo(expr)
+              .withSpan(tree.span)
+          )
         case Hole(_, idx, args, _, tpt) =>
           writeByte(HOLE)
           withLength {
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
index 428047d96e0c..a982e389f468 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
@@ -1267,6 +1267,10 @@ class TreeUnpickler(reader: TastyReader,
                 res.withAttachment(SuppressedApplyToNone, ())
               else res
 
+      def quotedExpr(fn: Tree, args: List[Tree]): Tree =
+        val TypeApply(_, targs) = fn: @unchecked
+        QuotedExpr(args.head, targs.head)
+
       def simplifyLub(tree: Tree): Tree =
         tree.overwriteType(tree.tpe.simplified)
         tree
@@ -1283,6 +1287,7 @@ class TreeUnpickler(reader: TastyReader,
               val fn = readTree()
               val args = until(end)(readTree())
               if fn.symbol.isConstructor then constructorApply(fn, args)
+              else if fn.symbol == defn.QuotedRuntime_exprQuote then quotedExpr(fn, args)
               else tpd.Apply(fn, args)
             case TYPEAPPLY =>
               tpd.TypeApply(readTree(), until(end)(readTpt()))
diff --git a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
index 50cd933532ae..e4c503206abf 100644
--- a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
@@ -817,7 +817,7 @@ class Inliner(val call: tpd.Tree)(using Context):
     override def typedApply(tree: untpd.Apply, pt: Type)(using Context): Tree =
       def cancelQuotes(tree: Tree): Tree =
         tree match
-          case QuotedExpr(SplicedExpr(inner)) => inner
+          case QuotedExpr(SplicedExpr(inner), _) => inner
           case _ => tree
       val locked = ctx.typerState.ownedVars
       val res = cancelQuotes(constToLiteral(BetaReduce(super.typedApply(tree, pt)))) match {
@@ -835,10 +835,14 @@ class Inliner(val call: tpd.Tree)(using Context):
     override def typedTypeApply(tree: untpd.TypeApply, pt: Type)(using Context): Tree =
       val locked = ctx.typerState.ownedVars
       val tree1 = inlineIfNeeded(constToLiteral(BetaReduce(super.typedTypeApply(tree, pt))), pt, locked)
-      if tree1.symbol.isQuote then
+      if tree1.symbol == defn.QuotedTypeModule_of then
         ctx.compilationUnit.needsStaging = true
       tree1
 
+    override def typedQuotedExpr(tree: untpd.QuotedExpr, pt: Type)(using Context): Tree =
+      ctx.compilationUnit.needsStaging = true
+      super.typedQuotedExpr(tree, pt)
+
     override def typedMatch(tree: untpd.Match, pt: Type)(using Context): Tree =
       val tree1 =
         if tree.isInline then
@@ -1067,7 +1071,7 @@ class Inliner(val call: tpd.Tree)(using Context):
         else tree match {
           case tree: RefTree if tree.isTerm && tree.symbol.isDefinedInCurrentRun && !tree.symbol.isLocal =>
             foldOver(tree.symbol :: syms, tree)
-          case QuotedExpr(body) =>
+          case QuotedExpr(body, _) =>
             level += 1
             try apply(syms, body)
             finally level -= 1
diff --git a/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala b/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
index c3aa98e6ef30..50c6a72a5b12 100644
--- a/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
@@ -91,7 +91,8 @@ object PrepareInlineable {
         }
 
       private def stagingContext(tree: Tree)(using Context): Context = tree match
-        case tree: Apply if tree.symbol.isQuote => StagingLevel.quoteContext
+        case tree: QuotedExpr => StagingLevel.quoteContext
+        case tree: Apply if tree.symbol eq defn.QuotedTypeModule_of => StagingLevel.quoteContext
         case tree: Apply if tree.symbol.isExprSplice => StagingLevel.spliceContext
         case _ => ctx
     }
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index 014e5ddf0d66..2f354259b33c 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -432,8 +432,6 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           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
@@ -724,6 +722,9 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         "Thicket {" ~~ toTextGlobal(trees, "\n") ~~ "}"
       case MacroTree(call) =>
         keywordStr("macro ") ~ toTextGlobal(call)
+      case QuotedExpr(expr, tpt) =>
+        val tptText = (keywordStr("[") ~ toTextGlobal(tpt) ~ keywordStr("]")).provided(printDebug)
+        keywordStr("'") ~ tptText ~ keywordStr("{") ~ toTextGlobal(expr) ~ keywordStr("}")
       case Hole(isTermHole, idx, args, content, tpt) =>
         val (prefix, postfix) = if isTermHole then ("{{{", "}}}") else ("[[[", "]]]")
         val argsText = toTextGlobal(args, ", ")
diff --git a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
index 9dc12d553abf..e432baf9068c 100644
--- a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
+++ b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
@@ -98,17 +98,14 @@ class CrossStageSafety extends TreeMapWithStages {
     }
 
   /** Transform quoted trees while maintaining level correctness */
-  override protected def transformQuotedExpr(body: Tree, quote: Apply)(using Context): Tree = {
+  override protected def transformQuotedExpr(body: Tree, quote: QuotedExpr)(using Context): Tree = {
     if (ctx.property(InAnnotation).isDefined)
       report.error("Cannot have a quote in an annotation", quote.srcPos)
-
+    val transformedBody = transformQuoteBody(body, quote.span)
     val stripAnnotsDeep: TypeMap = new TypeMap:
       def apply(tp: Type): Type = mapOver(tp.stripAnnots)
-    val transformedBody = transformQuoteBody(body, quote)
-    // `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(healType(quote.fun.srcPos)(stripAnnotsDeep(targ.tpe))))
-    cpy.Apply(quote)(cpy.TypeApply(quote.fun)(fun, targs2), transformedBody :: Nil)
+    val tpt1 = TypeTree(healType(quote.tpt.srcPos)(stripAnnotsDeep(quote.tpt.tpe)))
+    cpy.QuotedExpr(quote)(transformedBody, tpt1)
   }
 
   override protected def transformQuotedType(body: Tree, quote: Apply)(using Context): Tree = {
@@ -119,7 +116,7 @@ class CrossStageSafety extends TreeMapWithStages {
         // Optimization: `quoted.Type.of[x.Underlying](quotes)`  -->  `x`
         ref(termRef).withSpan(quote.span)
       case _ =>
-        transformQuoteBody(body, quote) match
+        transformQuoteBody(body, quote.span) match
           case DirectTypeOf.Healed(termRef) =>
             // Optimization: `quoted.Type.of[@SplicedType type T = x.Underlying; T](quotes)`  -->  `x`
             ref(termRef).withSpan(quote.span)
@@ -130,8 +127,8 @@ class CrossStageSafety extends TreeMapWithStages {
             cpy.Apply(quote)(cpy.TypeApply(quote.fun)(fun, transformedBody :: Nil), quotes)
   }
 
-  private def transformQuoteBody(body: Tree, quote: Apply)(using Context): Tree = {
-    val taggedTypes = new QuoteTypeTags(quote.span)
+  private def transformQuoteBody(body: Tree, span: Span)(using Context): Tree = {
+    val taggedTypes = new QuoteTypeTags(span)
     val contextWithQuote =
       if level == 0 then contextWithQuoteTypeTags(taggedTypes)(using quoteContext)
       else quoteContext
diff --git a/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala b/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
index c88a6aafebe6..a35fa363aa6b 100644
--- a/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
+++ b/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
@@ -25,8 +25,8 @@ abstract class TreeMapWithStages extends TreeMapWithImplicits {
    *
    *  - `quoted.runtime.Expr.quote[T](<body0>)`  --> `quoted.runtime.Expr.quote[T](<body>)`
    */
-  protected def transformQuotedExpr(body: Tree, quote: Apply)(using Context): Tree =
-    cpy.Apply(quote)(quote.fun, body :: Nil)
+  protected def transformQuotedExpr(body: Tree, quote: QuotedExpr)(using Context): Tree =
+    cpy.QuotedExpr(quote)(body, quote.tpt)
 
   /** Transform the quote `quote` which contains the quoted `body`.
    *
@@ -62,7 +62,7 @@ abstract class TreeMapWithStages extends TreeMapWithImplicits {
           try transformQuotedType(quotedTree, tree)
           finally inQuoteOrSplice = old
 
-        case tree @ QuotedExpr(quotedTree) =>
+        case tree @ QuotedExpr(quotedTree, _) =>
           val old = inQuoteOrSplice
           inQuoteOrSplice = true
           try dropEmptyBlocks(quotedTree) match {
@@ -79,7 +79,7 @@ abstract class TreeMapWithStages extends TreeMapWithImplicits {
           val old = inQuoteOrSplice
           inQuoteOrSplice = true
           try dropEmptyBlocks(splicedTree) match {
-            case QuotedExpr(t) =>
+            case QuotedExpr(t, _) =>
               // Optimization: `${ 'x }` --> `x`
               transform(t)
             case _ => transformSplice(splicedTree, tree)
diff --git a/compiler/src/dotty/tools/dotc/transform/Inlining.scala b/compiler/src/dotty/tools/dotc/transform/Inlining.scala
index d6b7f3141b96..a7644fa2a528 100644
--- a/compiler/src/dotty/tools/dotc/transform/Inlining.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Inlining.scala
@@ -46,7 +46,9 @@ class Inlining extends MacroTransform {
         new TreeTraverser {
           def traverse(tree: Tree)(using Context): Unit =
             tree match
-              case _: GenericApply if tree.symbol.isQuote =>
+              case _: QuotedExpr =>
+                traverseChildren(tree)(using StagingLevel.quoteContext)
+              case _: GenericApply if tree.symbol == defn.QuotedTypeModule_of =>
                 traverseChildren(tree)(using StagingLevel.quoteContext)
               case _: GenericApply if tree.symbol.isExprSplice =>
                 traverseChildren(tree)(using StagingLevel.spliceContext)
@@ -98,7 +100,9 @@ class Inlining extends MacroTransform {
           val tree1 = super.transform(tree)
           if tree1.tpe.isError then tree1
           else Inlines.inlineCall(tree1)
-        case _: GenericApply if tree.symbol.isQuote =>
+        case _: QuotedExpr =>
+          super.transform(tree)(using StagingLevel.quoteContext)
+        case _: GenericApply if tree.symbol == defn.QuotedTypeModule_of =>
           super.transform(tree)(using StagingLevel.quoteContext)
         case _: GenericApply if tree.symbol.isExprSplice =>
           super.transform(tree)(using StagingLevel.spliceContext)
diff --git a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
index 62174c806f09..6507bed179c3 100644
--- a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
@@ -83,8 +83,10 @@ class PickleQuotes extends MacroTransform {
 
   override def checkPostCondition(tree: Tree)(using Context): Unit =
     tree match
+      case tree: QuotedExpr =>
+        assert(Inlines.inInlineMethod)
       case tree: RefTree if !Inlines.inInlineMethod =>
-        assert(!tree.symbol.isQuote)
+        assert(tree.symbol != defn.QuotedTypeModule_of)
         assert(!tree.symbol.isExprSplice)
       case _ : TypeDef if !Inlines.inInlineMethod =>
         assert(!tree.symbol.hasAnnotation(defn.QuotedRuntime_SplicedTypeAnnot),
@@ -97,9 +99,8 @@ class PickleQuotes extends MacroTransform {
   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)
+        case Apply(Select(QuotedExpr(expr, tpt), nme.apply), List(quotes)) =>
+          val (contents, codeWithHoles) = makeHoles(expr)
           val sourceRef = Inlines.inlineCallTrace(ctx.owner, tree.sourcePos)
           val codeWithHoles2 = Inlined(sourceRef, Nil, codeWithHoles)
           val pickled = PickleQuotes(quotes, codeWithHoles2, contents, tpt.tpe, false)
diff --git a/compiler/src/dotty/tools/dotc/transform/PostTyper.scala b/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
index 7f3e47c14732..5cfa74fd5610 100644
--- a/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
@@ -342,7 +342,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
           val patterns1 = transform(patterns)
           cpy.UnApply(tree)(transform(fun), transform(implicits), patterns1)
         case tree: TypeApply =>
-          if tree.symbol.isQuote then
+          if tree.symbol == defn.QuotedTypeModule_of then
             ctx.compilationUnit.needsStaging = true
           if tree.symbol.is(Inline) then
             ctx.compilationUnit.needsInlining = true
@@ -485,6 +485,9 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
           )
         case Block(_, Closure(_, _, tpt)) if ExpandSAMs.needsWrapperClass(tpt.tpe) =>
           superAcc.withInvalidCurrentClass(super.transform(tree))
+        case QuotedExpr(expr, _) =>
+          ctx.compilationUnit.needsStaging = true
+          super.transform(tree)
         case tree =>
           super.transform(tree)
       }
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicer.scala b/compiler/src/dotty/tools/dotc/transform/Splicer.scala
index 11e88585f144..2981bdafc958 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicer.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicer.scala
@@ -44,7 +44,7 @@ object Splicer {
    *  See: `Staging`
    */
   def splice(tree: Tree, splicePos: SrcPos, spliceExpansionPos: SrcPos, classLoader: ClassLoader)(using Context): Tree = tree match {
-    case QuotedExpr(quotedTree) => quotedTree
+    case QuotedExpr(quotedTree, _) => quotedTree
     case _ =>
       val macroOwner = newSymbol(ctx.owner, nme.MACROkw, Macro | Synthetic, defn.AnyType, coord = tree.span)
       try
@@ -136,7 +136,7 @@ object Splicer {
     *  See: `Staging`
     */
   def checkValidMacroBody(tree: Tree)(using Context): Unit = tree match {
-    case QuotedExpr(_) => // ok
+    case QuotedExpr(_, _) => // ok
     case _ =>
       type Env = Set[Symbol]
 
@@ -155,7 +155,7 @@ object Splicer {
         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 =>
+        case Apply(Select(QuotedExpr(expr, tpt), nme.apply), _) =>
           val noSpliceChecker = new TreeTraverser {
             def traverse(tree: Tree)(using Context): Unit = tree match
               case SplicedExpr(_) =>
@@ -163,7 +163,7 @@ object Splicer {
               case _ =>
                 traverseChildren(tree)
           }
-          noSpliceChecker.traverse(quoted)
+          noSpliceChecker.traverse(expr)
 
         case Apply(TypeApply(fn, List(quoted)), _)if fn.symbol == defn.QuotedTypeModule_of =>
           // OK
@@ -203,7 +203,7 @@ object Splicer {
         case Typed(expr, _) =>
           checkIfValidStaticCall(expr)
 
-        case Apply(Select(Apply(fn, quoted :: Nil), nme.apply), _) if fn.symbol == defn.QuotedRuntime_exprQuote =>
+        case Apply(Select(QuotedExpr(quoted, tpt), nme.apply), _) =>
           // OK, canceled and warning emitted
 
         case Call(fn, args)
@@ -240,15 +240,15 @@ object Splicer {
 
     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) =>
+      case Apply(Select(QuotedExpr(expr, _), nme.apply), _) =>
+        val expr1 = expr match {
+          case expr: Ident if expr.symbol.isAllOf(InlineByNameProxy) =>
             // inline proxy for by-name parameter
-            quoted.symbol.defTree.asInstanceOf[DefDef].rhs
-          case Inlined(EmptyTree, _, quoted) => quoted
-          case _ => quoted
+            expr.symbol.defTree.asInstanceOf[DefDef].rhs
+          case Inlined(EmptyTree, _, expr1) => expr1
+          case _ => expr
         }
-        new ExprImpl(Inlined(EmptyTree, Nil, QuoteUtils.changeOwnerOfTree(quoted1, ctx.owner)).withSpan(quoted1.span), SpliceScope.getCurrent)
+        new ExprImpl(Inlined(EmptyTree, Nil, QuoteUtils.changeOwnerOfTree(expr1, ctx.owner)).withSpan(expr1.span), SpliceScope.getCurrent)
 
       // Interpret level -1 `Type.of[T]`
       case Apply(TypeApply(fn, quoted :: Nil), _) if fn.symbol == defn.QuotedTypeModule_of =>
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicing.scala b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
index e959f5d1451d..f5e536d85a55 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicing.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
@@ -87,8 +87,7 @@ class Splicing extends MacroTransform:
     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 =>
+        case Apply(Select(QuotedExpr(expr, _), nme.apply),List(quotes)) =>
           QuoteTransformer().transform(tree)
         case TypeApply(_, _) if tree.symbol == defn.QuotedTypeModule_of =>
           QuoteTransformer().transform(tree)
@@ -136,8 +135,7 @@ class Splicing extends MacroTransform:
               typeHoles.put(qual, 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 =>
+        case Apply(Select(QuotedExpr(expr, tpt), nme.apply),List(quotes)) =>
           super.transform(tree)(using quoteContext)
         case _: Template =>
           for sym <- tree.symbol.owner.info.decls do
@@ -240,17 +238,16 @@ class Splicing extends MacroTransform:
         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 Apply(sel @ Select(app @ QuotedExpr(expr, tpt), nme.apply), quotesArgs) =>
+          expr match
+            case expr: RefTree if isCaptured(expr.symbol) =>
+              capturedTerm(expr)
             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))
+              val newExpr = withCurrentQuote(quotesArgs.head) {
+                if level > 1 then transform(expr)(using quoteContext)
+                else transformLevel0QuoteContent(expr)(using quoteContext)
               }
-              cpy.Apply(tree)(cpy.Select(sel)(cpy.Apply(app)(fn, newArgs), nme.apply), quotesArgs)
+              cpy.Apply(tree)(cpy.Select(sel)(cpy.QuotedExpr(app)(newExpr, tpt), nme.apply), quotesArgs)
         case Apply(TypeApply(typeof, List(tpt)), List(quotes))
         if tree.symbol == defn.QuotedTypeModule_of && containsCapturedType(tpt.tpe) =>
           val newContent = capturedPartTypes(tpt)
@@ -419,10 +416,7 @@ class Splicing extends MacroTransform:
         .appliedTo(closure)
 
     private def quoted(expr: Tree)(using Context): Tree =
-      val tpe = expr.tpe.widenTermRefExpr
-      ref(defn.QuotedRuntime_exprQuote)
-        .appliedToType(tpe)
-        .appliedTo(expr)
+      QuotedExpr(expr, TypeTree(expr.tpe.widenTermRefExpr))
         .select(nme.apply)
         .appliedTo(quotes.nn)
 
diff --git a/compiler/src/dotty/tools/dotc/transform/SymUtils.scala b/compiler/src/dotty/tools/dotc/transform/SymUtils.scala
index b945f5820523..a5844dc0b538 100644
--- a/compiler/src/dotty/tools/dotc/transform/SymUtils.scala
+++ b/compiler/src/dotty/tools/dotc/transform/SymUtils.scala
@@ -315,10 +315,6 @@ object SymUtils:
     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
diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index 5db7c61aebc0..f7518ec8b9f5 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -312,7 +312,7 @@ object SpaceEngine {
   def isIrrefutableQuotedPattern(unapp: tpd.Tree, implicits: List[tpd.Tree], pt: Type)(using Context): Boolean = {
     implicits.headOption match
       // pattern '{ $x: T }
-      case Some(tpd.Apply(tpd.Select(tpd.QuotedExpr(tpd.TypeApply(fn, List(tpt))), nme.apply), _))
+      case Some(tpd.Apply(tpd.Select(tpd.QuotedExpr(tpd.TypeApply(fn, List(tpt)), _), nme.apply), _))
           if unapp.symbol.owner.eq(defn.QuoteMatching_ExprMatchModule)
           && fn.symbol.eq(defn.QuotedRuntimePatterns_patternHole) =>
         pt <:< defn.QuotedExprClass.typeRef.appliedTo(tpt.tpe)
diff --git a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
index 8473bd168bc5..e8e0ad7cf4a2 100644
--- a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
+++ b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
@@ -60,7 +60,9 @@ trait QuotesAndSplices {
       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))
+      val quotedExpr = typedApply(exprQuoteTree, pt)(using pushQuotes(qctx)) match
+        case Apply(TypeApply(fn, tpt :: Nil), quotedExpr :: Nil) => QuotedExpr(quotedExpr, tpt)
+      makeInlineable(quotedExpr.select(nme.apply).appliedTo(qctx).withSpan(tree.span))
   }
 
   private def makeInlineable(tree: Tree)(using Context): Tree =
@@ -75,6 +77,7 @@ trait QuotesAndSplices {
     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)
+        return typed(innerExpr, pt)
       case _ =>
     }
     if (ctx.mode.is(Mode.QuotedPattern))
@@ -441,7 +444,7 @@ trait QuotesAndSplices {
 
     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)
+      if (tree.quoted.isTerm) tpd.QuotedExpr(shape, TypeTree(defn.AnyType)).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
diff --git a/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala b/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
index 6ac45cbcf04d..2d921f4dbcb1 100644
--- a/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
+++ b/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
@@ -392,6 +392,12 @@ trait TypeAssigner {
   def assignType(tree: untpd.Inlined, bindings: List[Tree], expansion: Tree)(using Context): Inlined =
     tree.withType(avoidingType(expansion, bindings))
 
+  def assignType(tree: untpd.QuotedExpr, tpt: Tree)(using Context): QuotedExpr =
+    val lambdaType = // Quotes ?=> Expr[T]
+      defn.FunctionType(1, isContextual = true)
+        .appliedTo(defn.QuotesClass.typeRef, defn.QuotedExprClass.typeRef.appliedTo(tpt.tpe))
+    tree.withType(lambdaType)
+
   def assignType(tree: untpd.If, thenp: Tree, elsep: Tree)(using Context): If =
     tree.withType(thenp.tpe | elsep.tpe)
 
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 4bc012b5b226..ddf16f213676 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -2045,6 +2045,12 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         bindings1, expansion1)
   }
 
+  def typedQuotedExpr(tree: untpd.QuotedExpr, pt: Type)(using Context): Tree =
+    val tpt1 = checkSimpleKinded(typedType(tree.tpt, mapPatternBounds = true))
+    val expr1 = typed(tree.expr, tpt1.tpe.widenSkolem)
+    assignType(cpy.QuotedExpr(tree)(expr1, tpt1), tpt1)
+      .withNotNullInfo(expr1.notNullInfo)
+
   def completeTypeTree(tree: untpd.TypeTree, pt: Type, original: untpd.Tree)(using Context): TypeTree =
     tree.withSpan(original.span).withAttachmentsFrom(original)
       .withType(
@@ -3076,6 +3082,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           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.QuotedExpr => typedQuotedExpr(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)

From b7a7227e55558de2c483731d34b829d2d4018203 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Fri, 21 Apr 2023 17:28:25 +0200
Subject: [PATCH 403/657] Add `SplicedExpr` to encode splices directly in the
 AST

---
 .../src/dotty/tools/dotc/ast/TreeInfo.scala   | 10 ------
 compiler/src/dotty/tools/dotc/ast/Trees.scala | 16 +++++++++
 compiler/src/dotty/tools/dotc/ast/tpd.scala   |  3 ++
 compiler/src/dotty/tools/dotc/ast/untpd.scala |  1 +
 .../tools/dotc/core/tasty/TreePickler.scala   | 17 +++++++++
 .../tools/dotc/core/tasty/TreeUnpickler.scala | 13 +++++++
 .../dotty/tools/dotc/inlines/Inliner.scala    | 35 +++++++++----------
 .../dotc/inlines/PrepareInlineable.scala      |  6 ++--
 .../tools/dotc/printing/RefinedPrinter.scala  |  6 ++--
 .../tools/dotc/staging/CrossStageSafety.scala | 20 +++++------
 .../dotc/staging/TreeMapWithStages.scala      |  9 ++---
 .../tools/dotc/transform/ElimByName.scala     |  6 ++++
 .../tools/dotc/transform/FirstTransform.scala |  3 ++
 .../dotty/tools/dotc/transform/Inlining.scala |  4 +--
 .../tools/dotc/transform/PickleQuotes.scala   |  3 +-
 .../dotty/tools/dotc/transform/Splicer.scala  |  2 +-
 .../dotty/tools/dotc/transform/Splicing.scala | 19 +++++-----
 .../dotty/tools/dotc/transform/SymUtils.scala |  4 ---
 .../tools/dotc/typer/QuotesAndSplices.scala   | 18 ++++++----
 .../dotty/tools/dotc/typer/TypeAssigner.scala |  3 ++
 .../src/dotty/tools/dotc/typer/Typer.scala    | 11 +++++-
 21 files changed, 134 insertions(+), 75 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
index 96f189425180..5b409b6fec9a 100644
--- a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
+++ b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
@@ -1039,16 +1039,6 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
       else None
   }
 
-  /** Extractors for splices */
-  object SplicedExpr {
-    /** 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.
diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala
index 0028cf21c244..63e4ab859899 100644
--- a/compiler/src/dotty/tools/dotc/ast/Trees.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala
@@ -682,6 +682,11 @@ object Trees {
     type ThisTree[+T <: Untyped] = QuotedExpr[T]
   }
 
+  case class SplicedExpr[+T <: Untyped] private[ast] (spliced: Tree[T], tpt: Tree[T], outerQuotes: Tree[T])(implicit @constructorOnly src: SourceFile)
+    extends TermTree[T] {
+    type ThisTree[+T <: Untyped] = SplicedExpr[T]
+  }
+
   /** 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] {
@@ -1093,6 +1098,7 @@ object Trees {
     type JavaSeqLiteral = Trees.JavaSeqLiteral[T]
     type Inlined = Trees.Inlined[T]
     type QuotedExpr = Trees.QuotedExpr[T]
+    type SplicedExpr = Trees.SplicedExpr[T]
     type TypeTree = Trees.TypeTree[T]
     type InferredTypeTree = Trees.InferredTypeTree[T]
     type SingletonTypeTree = Trees.SingletonTypeTree[T]
@@ -1267,6 +1273,10 @@ object Trees {
         case tree: QuotedExpr if (expr eq tree.expr) && (tpt eq tree.tpt) => tree
         case _ => finalize(tree, untpd.QuotedExpr(expr, tpt)(sourceFile(tree)))
       }
+      def SplicedExpr(tree: Tree)(spliced: Tree, tpt: Tree, outerQuotes: Tree)(using Context): SplicedExpr = tree match {
+        case tree: SplicedExpr if (spliced eq tree.spliced) && (tpt eq tree.tpt) && (outerQuotes eq tree.outerQuotes) => tree
+        case _ => finalize(tree, untpd.SplicedExpr(spliced, tpt, outerQuotes)(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)))
@@ -1372,6 +1382,8 @@ object Trees {
         TypeDef(tree: Tree)(name, rhs)
       def Template(tree: Template)(using Context)(constr: DefDef = tree.constr, parents: List[Tree] = tree.parents, derived: List[untpd.Tree] = tree.derived, self: ValDef = tree.self, body: LazyTreeList = tree.unforcedBody): Template =
         Template(tree: Tree)(constr, parents, derived, self, body)
+      def SplicedExpr(tree: SplicedExpr)(spliced: Tree = tree.spliced, tpt: Tree = tree.tpt, outerQuotes: Tree = tree.outerQuotes)(using Context): SplicedExpr =
+        SplicedExpr(tree: Tree)(spliced, tpt, outerQuotes)
       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)
 
@@ -1506,6 +1518,8 @@ object Trees {
               if (trees1 eq trees) tree else Thicket(trees1)
             case tree @ QuotedExpr(expr, tpt) =>
               cpy.QuotedExpr(tree)(transform(expr), transform(tpt))
+            case tree @ SplicedExpr(spliced, tpt, outerQuotes) =>
+              cpy.SplicedExpr(tree)(transform(spliced), transform(tpt), transform(outerQuotes))
             case tree @ Hole(_, _, args, content, tpt) =>
               cpy.Hole(tree)(args = transform(args), content = transform(content), tpt = transform(tpt))
             case _ =>
@@ -1649,6 +1663,8 @@ object Trees {
               this(x, ts)
             case QuotedExpr(expr, tpt) =>
               this(this(x, expr), tpt)
+            case SplicedExpr(spliced, tpt, outerQuotes) =>
+              this(this(this(x, spliced), tpt), outerQuotes)
             case Hole(_, _, args, content, tpt) =>
               this(this(this(x, args), content), tpt)
             case _ =>
diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
index 88a822876043..e7c3ba93f72c 100644
--- a/compiler/src/dotty/tools/dotc/ast/tpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -173,6 +173,9 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def QuotedExpr(expr: Tree, tpt: Tree)(using Context): QuotedExpr =
     ta.assignType(untpd.QuotedExpr(expr, tpt), tpt)
 
+  def SplicedExpr(spliced: Tree, tpt: Tree, outerQuotes: Tree)(using Context): SplicedExpr =
+    ta.assignType(untpd.SplicedExpr(spliced, tpt, outerQuotes), tpt)
+
   def TypeTree(tp: Type, inferred: Boolean = false)(using Context): TypeTree =
     (if inferred then untpd.InferredTypeTree() else untpd.TypeTree()).withType(tp)
 
diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
index 7088739ddef3..b63df5f6999b 100644
--- a/compiler/src/dotty/tools/dotc/ast/untpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -402,6 +402,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   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 QuotedExpr(expr: Tree, tpt: Tree)(implicit src: SourceFile): QuotedExpr = new QuotedExpr(expr, tpt)
+  def SplicedExpr(spliced: Tree, tpt: Tree, outerQuotes: Tree)(implicit src: SourceFile): SplicedExpr = new SplicedExpr(spliced, tpt, outerQuotes)
   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)
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
index d704c6eac771..a57ce2c00a5d 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -673,6 +673,23 @@ class TreePickler(pickler: TastyPickler) {
               .appliedTo(expr)
               .withSpan(tree.span)
           )
+        case SplicedExpr(spliced, tpt, EmptyTree) =>
+          pickleTree(
+            // scala.quoted.runtime.Expr.splice[<tpt>](<spliced>)
+            ref(defn.QuotedRuntime_exprSplice)
+              .appliedToTypeTree(tpt)
+              .appliedTo(spliced)
+              .withSpan(tree.span)
+          )
+        case SplicedExpr(spliced, tpt, quotes) =>
+          pickleTree(
+            // scala.quoted.runtime.Expr.nestedSplice[<tpt>](<quotes>)(<spliced>)
+            ref(defn.QuotedRuntime_exprNestedSplice)
+              .appliedToTypeTree(tpt)
+              .appliedTo(quotes)
+              .appliedTo(spliced)
+              .withSpan(tree.span)
+          )
         case Hole(_, idx, args, _, tpt) =>
           writeByte(HOLE)
           withLength {
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
index a982e389f468..eb0dbdbc8bbb 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
@@ -1271,6 +1271,17 @@ class TreeUnpickler(reader: TastyReader,
         val TypeApply(_, targs) = fn: @unchecked
         QuotedExpr(args.head, targs.head)
 
+      def splicedExpr(fn: Tree, args: List[Tree]): Tree =
+        val TypeApply(_, targs) = fn: @unchecked
+        SplicedExpr(args.head, targs.head, EmptyTree)
+
+      def nestedSpliceExpr(fn: Tree, args: List[Tree]): Tree =
+        fn match
+          case Apply(TypeApply(_, targs), outerQuotes :: Nil) =>
+            SplicedExpr(args.head, targs.head, outerQuotes)
+          case _ => // nestedSplice[T](quotes)
+            tpd.Apply(fn, args)
+
       def simplifyLub(tree: Tree): Tree =
         tree.overwriteType(tree.tpe.simplified)
         tree
@@ -1288,6 +1299,8 @@ class TreeUnpickler(reader: TastyReader,
               val args = until(end)(readTree())
               if fn.symbol.isConstructor then constructorApply(fn, args)
               else if fn.symbol == defn.QuotedRuntime_exprQuote then quotedExpr(fn, args)
+              else if fn.symbol == defn.QuotedRuntime_exprSplice then splicedExpr(fn, args)
+              else if fn.symbol == defn.QuotedRuntime_exprNestedSplice then nestedSpliceExpr(fn, args)
               else tpd.Apply(fn, args)
             case TYPEAPPLY =>
               tpd.TypeApply(readTree(), until(end)(readTpt()))
diff --git a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
index e4c503206abf..bb16cf7f84b3 100644
--- a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
@@ -815,22 +815,8 @@ class Inliner(val call: tpd.Tree)(using Context):
       super.typedValDef(vdef1, sym)
 
     override def typedApply(tree: untpd.Apply, pt: Type)(using Context): Tree =
-      def cancelQuotes(tree: Tree): Tree =
-        tree match
-          case QuotedExpr(SplicedExpr(inner), _) => inner
-          case _ => tree
       val locked = ctx.typerState.ownedVars
-      val res = cancelQuotes(constToLiteral(BetaReduce(super.typedApply(tree, pt)))) match {
-        case res: Apply if res.symbol == defn.QuotedRuntime_exprSplice
-                        && StagingLevel.level == 0
-                        && !hasInliningErrors =>
-          val expanded = expandMacro(res.args.head, tree.srcPos)
-          transform.TreeChecker.checkMacroGeneratedTree(res, expanded)
-          typedExpr(expanded) // Inline calls and constant fold code generated by the macro
-        case res =>
-          specializeEq(inlineIfNeeded(res, pt, locked))
-      }
-      res
+      specializeEq(inlineIfNeeded(constToLiteral(BetaReduce(super.typedApply(tree, pt))), pt, locked))
 
     override def typedTypeApply(tree: untpd.TypeApply, pt: Type)(using Context): Tree =
       val locked = ctx.typerState.ownedVars
@@ -840,8 +826,21 @@ class Inliner(val call: tpd.Tree)(using Context):
       tree1
 
     override def typedQuotedExpr(tree: untpd.QuotedExpr, pt: Type)(using Context): Tree =
-      ctx.compilationUnit.needsStaging = true
-      super.typedQuotedExpr(tree, pt)
+      super.typedQuotedExpr(tree, pt) match
+        case QuotedExpr(SplicedExpr(inner, _, _), _) => inner
+        case tree1 =>
+          ctx.compilationUnit.needsStaging = true
+          tree1
+
+    override def typedSplicedExpr(tree: untpd.SplicedExpr, pt: Type)(using Context): Tree =
+      super.typedSplicedExpr(tree, pt) match
+        case tree1 @ SplicedExpr(spliced, tpt, EmptyTree)
+            if StagingLevel.level == 0
+            && !hasInliningErrors =>
+          val expanded = expandMacro(spliced, tree1.srcPos)
+          transform.TreeChecker.checkMacroGeneratedTree(tree1, expanded)
+          typedExpr(expanded) // Inline calls and constant fold code generated by the macro
+        case tree1 => tree1
 
     override def typedMatch(tree: untpd.Match, pt: Type)(using Context): Tree =
       val tree1 =
@@ -1079,7 +1078,7 @@ class Inliner(val call: tpd.Tree)(using Context):
             level += 1
             try apply(syms, body)
             finally level -= 1
-          case SplicedExpr(body) =>
+          case SplicedExpr(body, _, _) =>
             level -= 1
             try apply(syms, body)
             finally level += 1
diff --git a/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala b/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
index 50c6a72a5b12..c26b9bd21362 100644
--- a/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
@@ -93,7 +93,7 @@ object PrepareInlineable {
       private def stagingContext(tree: Tree)(using Context): Context = tree match
         case tree: QuotedExpr => StagingLevel.quoteContext
         case tree: Apply if tree.symbol eq defn.QuotedTypeModule_of => StagingLevel.quoteContext
-        case tree: Apply if tree.symbol.isExprSplice => StagingLevel.spliceContext
+        case tree: SplicedExpr => StagingLevel.spliceContext
         case _ => ctx
     }
 
@@ -155,7 +155,7 @@ object PrepareInlineable {
           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
+          // Need to dealias in order to catch all possible references to abstracted over types in
           // substitutions
           val dealiasMap = new TypeMap {
             def apply(t: Type) = mapOver(t.dealias)
@@ -291,7 +291,7 @@ object PrepareInlineable {
     if (inlined.is(Macro) && !ctx.isAfterTyper) {
 
       def checkMacro(tree: Tree): Unit = tree match {
-        case SplicedExpr(code) =>
+        case SplicedExpr(code, _, _) =>
           if (code.symbol.flags.is(Inline))
             report.error("Macro cannot be implemented with an `inline` method", code.srcPos)
           Splicer.checkValidMacroBody(code)
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index 2f354259b33c..42ce138c52c7 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -432,8 +432,6 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           changePrec (GlobalPrec) {
             keywordStr("throw ") ~ toText(args.head)
           }
-        else if (!printDebug && fun.hasType && fun.symbol.isExprSplice)
-          keywordStr("${") ~ toTextGlobal(args, ", ") ~ keywordStr("}")
         else
           toTextLocal(fun)
           ~ "("
@@ -725,6 +723,10 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case QuotedExpr(expr, tpt) =>
         val tptText = (keywordStr("[") ~ toTextGlobal(tpt) ~ keywordStr("]")).provided(printDebug)
         keywordStr("'") ~ tptText ~ keywordStr("{") ~ toTextGlobal(expr) ~ keywordStr("}")
+      case SplicedExpr(spliced, tpt, quotes) =>
+        val tptText = (keywordStr("[") ~ toTextGlobal(tpt) ~ keywordStr("]")).provided(printDebug)
+        val quotesText = (keywordStr("(using ") ~ toTextGlobal(quotes) ~ keywordStr(")")).provided(printDebug)
+        keywordStr("$") ~ tptText ~ keywordStr("{") ~ toTextGlobal(spliced) ~ keywordStr("}") ~ quotesText
       case Hole(isTermHole, idx, args, content, tpt) =>
         val (prefix, postfix) = if isTermHole then ("{{{", "}}}") else ("[[[", "]]]")
         val argsText = toTextGlobal(args, ", ")
diff --git a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
index e432baf9068c..e514043d515b 100644
--- a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
+++ b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
@@ -143,20 +143,16 @@ class CrossStageSafety extends TreeMapWithStages {
    *  - 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 = {
+  protected def transformSplice(body: Tree, splice: SplicedExpr)(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 tpt1 =
+      if level == 0 then
+        transform(splice.tpt)
+      else
         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(_, _), quotes :: 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), quotes :: Nil), body1 :: Nil)
-    }
+        TypeTree(tp).withSpan(splice.tpt.span)
+    val outerQuotes1 = splice.outerQuotes
+    cpy.SplicedExpr(splice)(body1, tpt1, outerQuotes1)
   }
 
   protected def transformSpliceType(body: Tree, splice: Select)(using Context): Tree = {
diff --git a/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala b/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
index a35fa363aa6b..ac750677c6b2 100644
--- a/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
+++ b/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
@@ -37,7 +37,7 @@ abstract class TreeMapWithStages extends TreeMapWithImplicits {
     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
+  protected def transformSplice(body: Tree, splice: SplicedExpr)(using Context): Tree
 
   /** Transform the type splice `splice` which contains the spliced `body`. */
   protected def transformSpliceType(body: Tree, splice: Select)(using Context): Tree
@@ -66,7 +66,7 @@ abstract class TreeMapWithStages extends TreeMapWithImplicits {
           val old = inQuoteOrSplice
           inQuoteOrSplice = true
           try dropEmptyBlocks(quotedTree) match {
-            case SplicedExpr(t) =>
+            case SplicedExpr(t, _, _) =>
               // Optimization: `'{ $x }` --> `x`
               // and adapt the refinement of `Quotes { type reflect: ... } ?=> Expr[T]`
               transform(t).asInstance(tree.tpe)
@@ -75,14 +75,15 @@ abstract class TreeMapWithStages extends TreeMapWithImplicits {
           }
           finally inQuoteOrSplice = old
 
-        case tree @ SplicedExpr(splicedTree) =>
+        case tree @ SplicedExpr(splicedTree, _, _) =>
           val old = inQuoteOrSplice
           inQuoteOrSplice = true
           try dropEmptyBlocks(splicedTree) match {
             case QuotedExpr(t, _) =>
               // Optimization: `${ 'x }` --> `x`
               transform(t)
-            case _ => transformSplice(splicedTree, tree)
+            case _ =>
+              transformSplice(splicedTree, tree)
           }
           finally inQuoteOrSplice = old
 
diff --git a/compiler/src/dotty/tools/dotc/transform/ElimByName.scala b/compiler/src/dotty/tools/dotc/transform/ElimByName.scala
index 151e841f0e48..34be121070ea 100644
--- a/compiler/src/dotty/tools/dotc/transform/ElimByName.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ElimByName.scala
@@ -159,6 +159,12 @@ class ElimByName extends MiniPhase, InfoTransformer:
       else tree
     }
 
+  override def transformOther(tree: Tree)(using Context): Tree = tree match
+    case tree @ SplicedExpr(spliced, tpt, outerQuotes) =>
+      assert(dotty.tools.dotc.inlines.Inlines.inInlineMethod)
+      cpy.SplicedExpr(tree)(transformAllDeep(spliced), tpt, outerQuotes)
+    case tree => tree
+
 object ElimByName:
   val name: String = "elimByName"
   val description: String = "map by-name parameters to functions"
diff --git a/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala b/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala
index a7e0795ce195..1094c3c0bd0a 100644
--- a/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala
+++ b/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala
@@ -153,6 +153,9 @@ class FirstTransform extends MiniPhase with InfoTransformer { thisPhase =>
   override def transformOther(tree: Tree)(using Context): Tree = tree match {
     case tree: Export => EmptyTree
     case tree: NamedArg => transformAllDeep(tree.arg)
+    case tree @ SplicedExpr(spliced, tpt, outerQuotes) =>
+      assert(dotty.tools.dotc.inlines.Inlines.inInlineMethod)
+      cpy.SplicedExpr(tree)(transformAllDeep(spliced), transformAllDeep(tpt), outerQuotes)
     case tree => if (tree.isType) toTypeTree(tree) else tree
   }
 
diff --git a/compiler/src/dotty/tools/dotc/transform/Inlining.scala b/compiler/src/dotty/tools/dotc/transform/Inlining.scala
index a7644fa2a528..1fd719251421 100644
--- a/compiler/src/dotty/tools/dotc/transform/Inlining.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Inlining.scala
@@ -50,7 +50,7 @@ class Inlining extends MacroTransform {
                 traverseChildren(tree)(using StagingLevel.quoteContext)
               case _: GenericApply if tree.symbol == defn.QuotedTypeModule_of =>
                 traverseChildren(tree)(using StagingLevel.quoteContext)
-              case _: GenericApply if tree.symbol.isExprSplice =>
+              case _: SplicedExpr =>
                 traverseChildren(tree)(using StagingLevel.spliceContext)
               case tree: RefTree if !Inlines.inInlineMethod && StagingLevel.level == 0 =>
                 assert(!tree.symbol.isInlineMethod, tree.show)
@@ -104,7 +104,7 @@ class Inlining extends MacroTransform {
           super.transform(tree)(using StagingLevel.quoteContext)
         case _: GenericApply if tree.symbol == defn.QuotedTypeModule_of =>
           super.transform(tree)(using StagingLevel.quoteContext)
-        case _: GenericApply if tree.symbol.isExprSplice =>
+        case _: SplicedExpr =>
           super.transform(tree)(using StagingLevel.spliceContext)
         case _: PackageDef =>
           super.transform(tree) match
diff --git a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
index 6507bed179c3..c020a53e7fdf 100644
--- a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
@@ -85,9 +85,10 @@ class PickleQuotes extends MacroTransform {
     tree match
       case tree: QuotedExpr =>
         assert(Inlines.inInlineMethod)
+      case tree: SplicedExpr =>
+        assert(Inlines.inInlineMethod)
       case tree: RefTree if !Inlines.inInlineMethod =>
         assert(tree.symbol != defn.QuotedTypeModule_of)
-        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")
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicer.scala b/compiler/src/dotty/tools/dotc/transform/Splicer.scala
index 2981bdafc958..c448cb20900b 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicer.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicer.scala
@@ -158,7 +158,7 @@ object Splicer {
         case Apply(Select(QuotedExpr(expr, tpt), nme.apply), _) =>
           val noSpliceChecker = new TreeTraverser {
             def traverse(tree: Tree)(using Context): Unit = tree match
-              case SplicedExpr(_) =>
+              case SplicedExpr(_, _, _) =>
                 report.error("Quoted argument of macros may not have splices", tree.srcPos)
               case _ =>
                 traverseChildren(tree)
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicing.scala b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
index f5e536d85a55..d25c1e9a9895 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicing.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
@@ -112,15 +112,15 @@ class Splicing extends MacroTransform:
 
     override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
       tree match
-        case Apply(fn, List(splicedCode)) if fn.symbol == defn.QuotedRuntime_exprNestedSplice =>
+        case tree: SplicedExpr =>
           if level > 1 then
-            val splicedCode1 = super.transform(splicedCode)(using spliceContext)
-            cpy.Apply(tree)(fn, List(splicedCode1))
+            val spliced1 = super.transform(tree.spliced)(using spliceContext)
+            cpy.SplicedExpr(tree)(spliced1, tree.tpt, tree.outerQuotes)
           else
             val holeIdx = numHoles
             numHoles += 1
             val splicer = SpliceTransformer(ctx.owner, quotedDefs.contains)
-            val newSplicedCode1 = splicer.transformSplice(splicedCode, tree.tpe, holeIdx)(using spliceContext)
+            val newSplicedCode1 = splicer.transformSplice(tree.spliced, tree.tpe, holeIdx)(using spliceContext)
             val newSplicedCode2 = Level0QuoteTransformer.transform(newSplicedCode1)(using spliceContext)
             newSplicedCode2
         case tree: TypeDef if tree.symbol.hasAnnotation(defn.QuotedRuntime_SplicedTypeAnnot) =>
@@ -235,9 +235,9 @@ class Splicing extends MacroTransform:
         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 SplicedExpr(spliced, tpt, outerQuotes) =>
+          val spliced1 = transform(spliced)(using spliceContext)
+          cpy.SplicedExpr(tree)(spliced1, tpt, outerQuotes)
         case Apply(sel @ Select(app @ QuotedExpr(expr, tpt), nme.apply), quotesArgs) =>
           expr match
             case expr: RefTree if isCaptured(expr.symbol) =>
@@ -410,10 +410,7 @@ class Splicing extends MacroTransform:
             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)
+      SplicedExpr(closure, TypeTree(tpe), Literal(Constant(null)))
 
     private def quoted(expr: Tree)(using Context): Tree =
       QuotedExpr(expr, TypeTree(expr.tpe.widenTermRefExpr))
diff --git a/compiler/src/dotty/tools/dotc/transform/SymUtils.scala b/compiler/src/dotty/tools/dotc/transform/SymUtils.scala
index a5844dc0b538..feb841ba5c6c 100644
--- a/compiler/src/dotty/tools/dotc/transform/SymUtils.scala
+++ b/compiler/src/dotty/tools/dotc/transform/SymUtils.scala
@@ -315,10 +315,6 @@ object SymUtils:
     def reachableRawTypeRef(using Context) =
       self.reachableTypeRef.appliedTo(self.typeParams.map(_ => TypeBounds.emptyPolyKind))
 
-    /** 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
diff --git a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
index e8e0ad7cf4a2..e562470aea5e 100644
--- a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
+++ b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
@@ -88,7 +88,7 @@ trait QuotesAndSplices {
           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)
+        SplicedExpr(pat, TypeTree(argType), EmptyTree).withSpan(tree.span)
       }
       else {
         report.error(em"Type must be fully defined.\nConsider annotating the splice using a type ascription:\n  ($tree: XYZ).", tree.expr.srcPos)
@@ -108,11 +108,17 @@ trait QuotesAndSplices {
       val (outerQctx, ctx1) = popQuotes()
 
       val internalSplice =
+        untpd.Apply(untpd.ref(defn.QuotedRuntime_exprSplice.termRef), tree.expr)
         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)
+      typedApply(internalSplice, pt)(using ctx1).withSpan(tree.span) match
+        case tree @ Apply(TypeApply(_, tpt :: Nil), spliced :: Nil) if tree.symbol == defn.QuotedRuntime_exprSplice =>
+          cpy.SplicedExpr(tree)(spliced, tpt, EmptyTree)
+        case tree @ Apply(Apply(TypeApply(_, tpt :: Nil), quotes :: Nil), spliced :: Nil) if tree.symbol == defn.QuotedRuntime_exprNestedSplice =>
+          cpy.SplicedExpr(tree)(spliced, tpt, quotes)
+        case tree => tree
     }
   }
 
@@ -228,12 +234,12 @@ trait QuotesAndSplices {
       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) =>
+        case Typed(SplicedExpr(pat, _, outerQuotes), tpt) if !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))
+          val newSplice = cpy.SplicedExpr(tree)(pat, tpt1, outerQuotes)
           transform(newSplice)
-        case Apply(TypeApply(fn, targs), Apply(sp, pat :: Nil) :: args :: Nil) if fn.symbol == defn.QuotedRuntimePatterns_patternHigherOrderHole =>
+        case Apply(TypeApply(fn, targs), SplicedExpr(pat, _, _) :: 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
@@ -245,7 +251,7 @@ trait QuotesAndSplices {
             val pat1 = if (patType eq patType1) pat else pat.withType(patType1)
             patBuf += pat1
           }
-        case Apply(fn, pat :: Nil) if fn.symbol.isExprSplice =>
+        case SplicedExpr(pat, _, _) =>
           try ref(defn.QuotedRuntimePatterns_patternHole.termRef).appliedToType(tree.tpe).withSpan(tree.span)
           finally {
             val patType = pat.tpe.widen
diff --git a/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala b/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
index 2d921f4dbcb1..9fe679a0583b 100644
--- a/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
+++ b/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
@@ -398,6 +398,9 @@ trait TypeAssigner {
         .appliedTo(defn.QuotesClass.typeRef, defn.QuotedExprClass.typeRef.appliedTo(tpt.tpe))
     tree.withType(lambdaType)
 
+  def assignType(tree: untpd.SplicedExpr, tpt: Tree)(using Context): SplicedExpr =
+    tree.withType(tpt.tpe)
+
   def assignType(tree: untpd.If, thenp: Tree, elsep: Tree)(using Context): If =
     tree.withType(thenp.tpe | elsep.tpe)
 
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index ddf16f213676..822f8e253932 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -2049,7 +2049,15 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     val tpt1 = checkSimpleKinded(typedType(tree.tpt, mapPatternBounds = true))
     val expr1 = typed(tree.expr, tpt1.tpe.widenSkolem)
     assignType(cpy.QuotedExpr(tree)(expr1, tpt1), tpt1)
-      .withNotNullInfo(expr1.notNullInfo)
+
+  def typedSplicedExpr(tree: untpd.SplicedExpr, pt: Type)(using Context): Tree =
+    val tpt1 = checkSimpleKinded(typedType(tree.tpt, mapPatternBounds = true))
+    val splicedType = // Quotes ?=> Expr[T]
+      defn.FunctionType(1, isContextual = true)
+        .appliedTo(defn.QuotesClass.typeRef, defn.QuotedExprClass.typeRef.appliedTo(tpt1.tpe.widenSkolem))
+    val spliced1 = typed(tree.spliced, splicedType)
+    val outerQuotes1 = typed(tree.outerQuotes, defn.QuotesClass.typeRef)
+    assignType(cpy.SplicedExpr(tree)(spliced1, tpt1, outerQuotes1), tpt1)
 
   def completeTypeTree(tree: untpd.TypeTree, pt: Type, original: untpd.Tree)(using Context): TypeTree =
     tree.withSpan(original.span).withAttachmentsFrom(original)
@@ -3084,6 +3092,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           case tree: untpd.Quote => typedQuote(tree, pt)
           case tree: untpd.QuotedExpr => typedQuotedExpr(tree, pt)
           case tree: untpd.Splice => typedSplice(tree, pt)
+          case tree: untpd.SplicedExpr => typedSplicedExpr(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)

From fe64a3e6fc3c45acaf88ad40d73471a152ba5713 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 25 Apr 2023 11:19:35 +0200
Subject: [PATCH 404/657] Remove splice outer quotes context

This field is no longer used and can be removed. Removing it is backwards
compatible with 3.0 and later releases.
---
 compiler/src/dotty/tools/dotc/ast/Trees.scala | 20 +++++-----
 compiler/src/dotty/tools/dotc/ast/tpd.scala   |  4 +-
 compiler/src/dotty/tools/dotc/ast/untpd.scala |  2 +-
 .../tools/dotc/core/tasty/TreePickler.scala   | 11 +-----
 .../tools/dotc/core/tasty/TreeUnpickler.scala |  6 +--
 .../dotty/tools/dotc/inlines/Inliner.scala    |  6 +--
 .../dotc/inlines/PrepareInlineable.scala      |  2 +-
 .../tools/dotc/printing/RefinedPrinter.scala  |  5 +--
 .../dotty/tools/dotc/quoted/Interpreter.scala |  1 -
 .../tools/dotc/staging/CrossStageSafety.scala |  4 +-
 .../dotty/tools/dotc/staging/HealType.scala   |  1 -
 .../tools/dotc/staging/QuoteContext.scala     | 34 -----------------
 .../dotc/staging/TreeMapWithStages.scala      |  4 +-
 .../tools/dotc/transform/ElimByName.scala     |  4 +-
 .../tools/dotc/transform/FirstTransform.scala |  4 +-
 .../dotty/tools/dotc/transform/Inlining.scala |  1 -
 .../dotty/tools/dotc/transform/Splicer.scala  |  2 +-
 .../dotty/tools/dotc/transform/Splicing.scala |  9 ++---
 .../dotty/tools/dotc/transform/Staging.scala  |  1 -
 .../tools/dotc/typer/QuotesAndSplices.scala   | 38 ++++++++-----------
 .../src/dotty/tools/dotc/typer/Typer.scala    |  7 ++--
 21 files changed, 53 insertions(+), 113 deletions(-)
 delete mode 100644 compiler/src/dotty/tools/dotc/staging/QuoteContext.scala

diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala
index 63e4ab859899..dc37b1ef7180 100644
--- a/compiler/src/dotty/tools/dotc/ast/Trees.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala
@@ -682,7 +682,7 @@ object Trees {
     type ThisTree[+T <: Untyped] = QuotedExpr[T]
   }
 
-  case class SplicedExpr[+T <: Untyped] private[ast] (spliced: Tree[T], tpt: Tree[T], outerQuotes: Tree[T])(implicit @constructorOnly src: SourceFile)
+  case class SplicedExpr[+T <: Untyped] private[ast] (spliced: Tree[T], tpt: Tree[T])(implicit @constructorOnly src: SourceFile)
     extends TermTree[T] {
     type ThisTree[+T <: Untyped] = SplicedExpr[T]
   }
@@ -1273,9 +1273,9 @@ object Trees {
         case tree: QuotedExpr if (expr eq tree.expr) && (tpt eq tree.tpt) => tree
         case _ => finalize(tree, untpd.QuotedExpr(expr, tpt)(sourceFile(tree)))
       }
-      def SplicedExpr(tree: Tree)(spliced: Tree, tpt: Tree, outerQuotes: Tree)(using Context): SplicedExpr = tree match {
-        case tree: SplicedExpr if (spliced eq tree.spliced) && (tpt eq tree.tpt) && (outerQuotes eq tree.outerQuotes) => tree
-        case _ => finalize(tree, untpd.SplicedExpr(spliced, tpt, outerQuotes)(sourceFile(tree)))
+      def SplicedExpr(tree: Tree)(spliced: Tree, tpt: Tree)(using Context): SplicedExpr = tree match {
+        case tree: SplicedExpr if (spliced eq tree.spliced) && (tpt eq tree.tpt) => tree
+        case _ => finalize(tree, untpd.SplicedExpr(spliced, tpt)(sourceFile(tree)))
       }
       def SingletonTypeTree(tree: Tree)(ref: Tree)(using Context): SingletonTypeTree = tree match {
         case tree: SingletonTypeTree if (ref eq tree.ref) => tree
@@ -1382,8 +1382,8 @@ object Trees {
         TypeDef(tree: Tree)(name, rhs)
       def Template(tree: Template)(using Context)(constr: DefDef = tree.constr, parents: List[Tree] = tree.parents, derived: List[untpd.Tree] = tree.derived, self: ValDef = tree.self, body: LazyTreeList = tree.unforcedBody): Template =
         Template(tree: Tree)(constr, parents, derived, self, body)
-      def SplicedExpr(tree: SplicedExpr)(spliced: Tree = tree.spliced, tpt: Tree = tree.tpt, outerQuotes: Tree = tree.outerQuotes)(using Context): SplicedExpr =
-        SplicedExpr(tree: Tree)(spliced, tpt, outerQuotes)
+      def SplicedExpr(tree: SplicedExpr)(spliced: Tree = tree.spliced, tpt: Tree = tree.tpt)(using Context): SplicedExpr =
+        SplicedExpr(tree: Tree)(spliced, tpt)
       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)
 
@@ -1518,8 +1518,8 @@ object Trees {
               if (trees1 eq trees) tree else Thicket(trees1)
             case tree @ QuotedExpr(expr, tpt) =>
               cpy.QuotedExpr(tree)(transform(expr), transform(tpt))
-            case tree @ SplicedExpr(spliced, tpt, outerQuotes) =>
-              cpy.SplicedExpr(tree)(transform(spliced), transform(tpt), transform(outerQuotes))
+            case tree @ SplicedExpr(spliced, tpt) =>
+              cpy.SplicedExpr(tree)(transform(spliced), transform(tpt))
             case tree @ Hole(_, _, args, content, tpt) =>
               cpy.Hole(tree)(args = transform(args), content = transform(content), tpt = transform(tpt))
             case _ =>
@@ -1663,8 +1663,8 @@ object Trees {
               this(x, ts)
             case QuotedExpr(expr, tpt) =>
               this(this(x, expr), tpt)
-            case SplicedExpr(spliced, tpt, outerQuotes) =>
-              this(this(this(x, spliced), tpt), outerQuotes)
+            case SplicedExpr(spliced, tpt) =>
+              this(this(x, spliced), tpt)
             case Hole(_, _, args, content, tpt) =>
               this(this(this(x, args), content), tpt)
             case _ =>
diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
index e7c3ba93f72c..bc2498e7ca9b 100644
--- a/compiler/src/dotty/tools/dotc/ast/tpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -173,8 +173,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def QuotedExpr(expr: Tree, tpt: Tree)(using Context): QuotedExpr =
     ta.assignType(untpd.QuotedExpr(expr, tpt), tpt)
 
-  def SplicedExpr(spliced: Tree, tpt: Tree, outerQuotes: Tree)(using Context): SplicedExpr =
-    ta.assignType(untpd.SplicedExpr(spliced, tpt, outerQuotes), tpt)
+  def SplicedExpr(spliced: Tree, tpt: Tree)(using Context): SplicedExpr =
+    ta.assignType(untpd.SplicedExpr(spliced, tpt), tpt)
 
   def TypeTree(tp: Type, inferred: Boolean = false)(using Context): TypeTree =
     (if inferred then untpd.InferredTypeTree() else untpd.TypeTree()).withType(tp)
diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
index b63df5f6999b..c8d083ef792d 100644
--- a/compiler/src/dotty/tools/dotc/ast/untpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -402,7 +402,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   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 QuotedExpr(expr: Tree, tpt: Tree)(implicit src: SourceFile): QuotedExpr = new QuotedExpr(expr, tpt)
-  def SplicedExpr(spliced: Tree, tpt: Tree, outerQuotes: Tree)(implicit src: SourceFile): SplicedExpr = new SplicedExpr(spliced, tpt, outerQuotes)
+  def SplicedExpr(spliced: Tree, tpt: Tree)(implicit src: SourceFile): SplicedExpr = new SplicedExpr(spliced, tpt)
   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)
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
index a57ce2c00a5d..0762ea476021 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -673,7 +673,7 @@ class TreePickler(pickler: TastyPickler) {
               .appliedTo(expr)
               .withSpan(tree.span)
           )
-        case SplicedExpr(spliced, tpt, EmptyTree) =>
+        case SplicedExpr(spliced, tpt) =>
           pickleTree(
             // scala.quoted.runtime.Expr.splice[<tpt>](<spliced>)
             ref(defn.QuotedRuntime_exprSplice)
@@ -681,15 +681,6 @@ class TreePickler(pickler: TastyPickler) {
               .appliedTo(spliced)
               .withSpan(tree.span)
           )
-        case SplicedExpr(spliced, tpt, quotes) =>
-          pickleTree(
-            // scala.quoted.runtime.Expr.nestedSplice[<tpt>](<quotes>)(<spliced>)
-            ref(defn.QuotedRuntime_exprNestedSplice)
-              .appliedToTypeTree(tpt)
-              .appliedTo(quotes)
-              .appliedTo(spliced)
-              .withSpan(tree.span)
-          )
         case Hole(_, idx, args, _, tpt) =>
           writeByte(HOLE)
           withLength {
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
index eb0dbdbc8bbb..153fc7b3922d 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
@@ -1273,12 +1273,12 @@ class TreeUnpickler(reader: TastyReader,
 
       def splicedExpr(fn: Tree, args: List[Tree]): Tree =
         val TypeApply(_, targs) = fn: @unchecked
-        SplicedExpr(args.head, targs.head, EmptyTree)
+        SplicedExpr(args.head, targs.head)
 
       def nestedSpliceExpr(fn: Tree, args: List[Tree]): Tree =
         fn match
-          case Apply(TypeApply(_, targs), outerQuotes :: Nil) =>
-            SplicedExpr(args.head, targs.head, outerQuotes)
+          case Apply(TypeApply(_, targs), _ :: Nil) => // nestedSplice[T](quotes)(expr)
+            SplicedExpr(args.head, targs.head)
           case _ => // nestedSplice[T](quotes)
             tpd.Apply(fn, args)
 
diff --git a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
index bb16cf7f84b3..02e1bbdeacce 100644
--- a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
@@ -827,14 +827,14 @@ class Inliner(val call: tpd.Tree)(using Context):
 
     override def typedQuotedExpr(tree: untpd.QuotedExpr, pt: Type)(using Context): Tree =
       super.typedQuotedExpr(tree, pt) match
-        case QuotedExpr(SplicedExpr(inner, _, _), _) => inner
+        case QuotedExpr(SplicedExpr(inner, _), _) => inner
         case tree1 =>
           ctx.compilationUnit.needsStaging = true
           tree1
 
     override def typedSplicedExpr(tree: untpd.SplicedExpr, pt: Type)(using Context): Tree =
       super.typedSplicedExpr(tree, pt) match
-        case tree1 @ SplicedExpr(spliced, tpt, EmptyTree)
+        case tree1 @ SplicedExpr(spliced, tpt)
             if StagingLevel.level == 0
             && !hasInliningErrors =>
           val expanded = expandMacro(spliced, tree1.srcPos)
@@ -1078,7 +1078,7 @@ class Inliner(val call: tpd.Tree)(using Context):
             level += 1
             try apply(syms, body)
             finally level -= 1
-          case SplicedExpr(body, _, _) =>
+          case SplicedExpr(body, _) =>
             level -= 1
             try apply(syms, body)
             finally level += 1
diff --git a/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala b/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
index c26b9bd21362..b94b76316b1b 100644
--- a/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
@@ -291,7 +291,7 @@ object PrepareInlineable {
     if (inlined.is(Macro) && !ctx.isAfterTyper) {
 
       def checkMacro(tree: Tree): Unit = tree match {
-        case SplicedExpr(code, _, _) =>
+        case SplicedExpr(code, _) =>
           if (code.symbol.flags.is(Inline))
             report.error("Macro cannot be implemented with an `inline` method", code.srcPos)
           Splicer.checkValidMacroBody(code)
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index 42ce138c52c7..0d899b8b5909 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -723,10 +723,9 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case QuotedExpr(expr, tpt) =>
         val tptText = (keywordStr("[") ~ toTextGlobal(tpt) ~ keywordStr("]")).provided(printDebug)
         keywordStr("'") ~ tptText ~ keywordStr("{") ~ toTextGlobal(expr) ~ keywordStr("}")
-      case SplicedExpr(spliced, tpt, quotes) =>
+      case SplicedExpr(spliced, tpt) =>
         val tptText = (keywordStr("[") ~ toTextGlobal(tpt) ~ keywordStr("]")).provided(printDebug)
-        val quotesText = (keywordStr("(using ") ~ toTextGlobal(quotes) ~ keywordStr(")")).provided(printDebug)
-        keywordStr("$") ~ tptText ~ keywordStr("{") ~ toTextGlobal(spliced) ~ keywordStr("}") ~ quotesText
+        keywordStr("$") ~ tptText ~ keywordStr("{") ~ toTextGlobal(spliced) ~ keywordStr("}")
       case Hole(isTermHole, idx, args, content, tpt) =>
         val (prefix, postfix) = if isTermHole then ("{{{", "}}}") else ("[[[", "]]]")
         val argsText = toTextGlobal(args, ", ")
diff --git a/compiler/src/dotty/tools/dotc/quoted/Interpreter.scala b/compiler/src/dotty/tools/dotc/quoted/Interpreter.scala
index a98284f4078d..c9a77dbfa151 100644
--- a/compiler/src/dotty/tools/dotc/quoted/Interpreter.scala
+++ b/compiler/src/dotty/tools/dotc/quoted/Interpreter.scala
@@ -24,7 +24,6 @@ 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.staging.QuoteContext.*
 import dotty.tools.dotc.typer.ImportInfo.withRootImports
 import dotty.tools.dotc.util.SrcPos
 import dotty.tools.dotc.reporting.Message
diff --git a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
index e514043d515b..512e5ab6ab4c 100644
--- a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
+++ b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
@@ -10,7 +10,6 @@ import dotty.tools.dotc.core.NameKinds._
 import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.Types._
-import dotty.tools.dotc.staging.QuoteContext.*
 import dotty.tools.dotc.staging.StagingLevel.*
 import dotty.tools.dotc.staging.QuoteTypeTags.*
 import dotty.tools.dotc.util.Property
@@ -151,8 +150,7 @@ class CrossStageSafety extends TreeMapWithStages {
       else
         val tp = healType(splice.srcPos)(splice.tpe.widenTermRefExpr)
         TypeTree(tp).withSpan(splice.tpt.span)
-    val outerQuotes1 = splice.outerQuotes
-    cpy.SplicedExpr(splice)(body1, tpt1, outerQuotes1)
+    cpy.SplicedExpr(splice)(body1, tpt1)
   }
 
   protected def transformSpliceType(body: Tree, splice: Select)(using Context): Tree = {
diff --git a/compiler/src/dotty/tools/dotc/staging/HealType.scala b/compiler/src/dotty/tools/dotc/staging/HealType.scala
index 50c2584b2fd0..337c7e8c9b3b 100644
--- a/compiler/src/dotty/tools/dotc/staging/HealType.scala
+++ b/compiler/src/dotty/tools/dotc/staging/HealType.scala
@@ -7,7 +7,6 @@ import dotty.tools.dotc.core.Flags._
 import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.Types._
-import dotty.tools.dotc.staging.QuoteContext.*
 import dotty.tools.dotc.staging.StagingLevel.*
 import dotty.tools.dotc.staging.QuoteTypeTags.*
 import dotty.tools.dotc.transform.SymUtils._
diff --git a/compiler/src/dotty/tools/dotc/staging/QuoteContext.scala b/compiler/src/dotty/tools/dotc/staging/QuoteContext.scala
deleted file mode 100644
index 8e25bba7110c..000000000000
--- a/compiler/src/dotty/tools/dotc/staging/QuoteContext.scala
+++ /dev/null
@@ -1,34 +0,0 @@
-package dotty.tools.dotc.staging
-
-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.staging.StagingLevel.*
-
-object QuoteContext {
-
-  /** 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]]
-
-  /** Context with an incremented quotation level and pushes a reference to a Quotes on the quote context stack */
-  def pushQuotes(quotes: tpd.Tree)(using Context): Context =
-    val old = ctx.property(QuotesStack).getOrElse(List.empty)
-    quoteContext.setProperty(QuotesStack, quotes :: old)
-
-  /** Context with a decremented quotation level and pops the Some of top of the quote context stack or None if the stack is empty.
-   *  The quotation stack could be empty if we are in a top level splice or an erroneous splice directly within a top level splice.
-   */
-  def popQuotes()(using Context): (Option[tpd.Tree], Context) =
-    val ctx1 = spliceContext
-    val head =
-      ctx.property(QuotesStack) match
-        case Some(x :: xs) =>
-          ctx1.setProperty(QuotesStack, xs)
-          Some(x)
-        case _ =>
-          None // Splice at level 0 or lower
-    (head, ctx1)
-}
diff --git a/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala b/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
index ac750677c6b2..1ed6d4c37e19 100644
--- a/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
+++ b/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
@@ -66,7 +66,7 @@ abstract class TreeMapWithStages extends TreeMapWithImplicits {
           val old = inQuoteOrSplice
           inQuoteOrSplice = true
           try dropEmptyBlocks(quotedTree) match {
-            case SplicedExpr(t, _, _) =>
+            case SplicedExpr(t, _) =>
               // Optimization: `'{ $x }` --> `x`
               // and adapt the refinement of `Quotes { type reflect: ... } ?=> Expr[T]`
               transform(t).asInstance(tree.tpe)
@@ -75,7 +75,7 @@ abstract class TreeMapWithStages extends TreeMapWithImplicits {
           }
           finally inQuoteOrSplice = old
 
-        case tree @ SplicedExpr(splicedTree, _, _) =>
+        case tree @ SplicedExpr(splicedTree, _) =>
           val old = inQuoteOrSplice
           inQuoteOrSplice = true
           try dropEmptyBlocks(splicedTree) match {
diff --git a/compiler/src/dotty/tools/dotc/transform/ElimByName.scala b/compiler/src/dotty/tools/dotc/transform/ElimByName.scala
index 34be121070ea..6e264385fd3e 100644
--- a/compiler/src/dotty/tools/dotc/transform/ElimByName.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ElimByName.scala
@@ -160,9 +160,9 @@ class ElimByName extends MiniPhase, InfoTransformer:
     }
 
   override def transformOther(tree: Tree)(using Context): Tree = tree match
-    case tree @ SplicedExpr(spliced, tpt, outerQuotes) =>
+    case tree @ SplicedExpr(spliced, tpt) =>
       assert(dotty.tools.dotc.inlines.Inlines.inInlineMethod)
-      cpy.SplicedExpr(tree)(transformAllDeep(spliced), tpt, outerQuotes)
+      cpy.SplicedExpr(tree)(transformAllDeep(spliced), tpt)
     case tree => tree
 
 object ElimByName:
diff --git a/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala b/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala
index 1094c3c0bd0a..7a9e3cc324d3 100644
--- a/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala
+++ b/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala
@@ -153,9 +153,9 @@ class FirstTransform extends MiniPhase with InfoTransformer { thisPhase =>
   override def transformOther(tree: Tree)(using Context): Tree = tree match {
     case tree: Export => EmptyTree
     case tree: NamedArg => transformAllDeep(tree.arg)
-    case tree @ SplicedExpr(spliced, tpt, outerQuotes) =>
+    case tree @ SplicedExpr(spliced, tpt) =>
       assert(dotty.tools.dotc.inlines.Inlines.inInlineMethod)
-      cpy.SplicedExpr(tree)(transformAllDeep(spliced), transformAllDeep(tpt), outerQuotes)
+      cpy.SplicedExpr(tree)(transformAllDeep(spliced), transformAllDeep(tpt))
     case tree => if (tree.isType) toTypeTree(tree) else tree
   }
 
diff --git a/compiler/src/dotty/tools/dotc/transform/Inlining.scala b/compiler/src/dotty/tools/dotc/transform/Inlining.scala
index 1fd719251421..341633e30960 100644
--- a/compiler/src/dotty/tools/dotc/transform/Inlining.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Inlining.scala
@@ -12,7 +12,6 @@ import dotty.tools.dotc.quoted._
 import dotty.tools.dotc.inlines.Inlines
 import dotty.tools.dotc.ast.TreeMapWithImplicits
 import dotty.tools.dotc.core.DenotTransformers.IdentityDenotTransformer
-import dotty.tools.dotc.staging.QuoteContext.*
 import dotty.tools.dotc.staging.StagingLevel
 
 import scala.collection.mutable.ListBuffer
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicer.scala b/compiler/src/dotty/tools/dotc/transform/Splicer.scala
index c448cb20900b..2e6549bc8ec8 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicer.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicer.scala
@@ -158,7 +158,7 @@ object Splicer {
         case Apply(Select(QuotedExpr(expr, tpt), nme.apply), _) =>
           val noSpliceChecker = new TreeTraverser {
             def traverse(tree: Tree)(using Context): Unit = tree match
-              case SplicedExpr(_, _, _) =>
+              case SplicedExpr(_, _) =>
                 report.error("Quoted argument of macros may not have splices", tree.srcPos)
               case _ =>
                 traverseChildren(tree)
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicing.scala b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
index d25c1e9a9895..ed271f20c5bf 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicing.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
@@ -21,7 +21,6 @@ import dotty.tools.dotc.core.Names._
 import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.quoted._
 import dotty.tools.dotc.config.ScalaRelease.*
-import dotty.tools.dotc.staging.QuoteContext.*
 import dotty.tools.dotc.staging.StagingLevel.*
 import dotty.tools.dotc.staging.QuoteTypeTags
 
@@ -115,7 +114,7 @@ class Splicing extends MacroTransform:
         case tree: SplicedExpr =>
           if level > 1 then
             val spliced1 = super.transform(tree.spliced)(using spliceContext)
-            cpy.SplicedExpr(tree)(spliced1, tree.tpt, tree.outerQuotes)
+            cpy.SplicedExpr(tree)(spliced1, tree.tpt)
           else
             val holeIdx = numHoles
             numHoles += 1
@@ -235,9 +234,9 @@ class Splicing extends MacroTransform:
         case tree @ Assign(lhs: RefTree, rhs) =>
           if isCaptured(lhs.symbol) then transformSplicedAssign(tree)
           else super.transform(tree)
-        case SplicedExpr(spliced, tpt, outerQuotes) =>
+        case SplicedExpr(spliced, tpt) =>
           val spliced1 = transform(spliced)(using spliceContext)
-          cpy.SplicedExpr(tree)(spliced1, tpt, outerQuotes)
+          cpy.SplicedExpr(tree)(spliced1, tpt)
         case Apply(sel @ Select(app @ QuotedExpr(expr, tpt), nme.apply), quotesArgs) =>
           expr match
             case expr: RefTree if isCaptured(expr.symbol) =>
@@ -410,7 +409,7 @@ class Splicing extends MacroTransform:
             body(using ctx.withOwner(meth)).changeOwner(ctx.owner, meth)
           }
         })
-      SplicedExpr(closure, TypeTree(tpe), Literal(Constant(null)))
+      SplicedExpr(closure, TypeTree(tpe))
 
     private def quoted(expr: Tree)(using Context): Tree =
       QuotedExpr(expr, TypeTree(expr.tpe.widenTermRefExpr))
diff --git a/compiler/src/dotty/tools/dotc/transform/Staging.scala b/compiler/src/dotty/tools/dotc/transform/Staging.scala
index 4fb5f5910440..a025f86a1db6 100644
--- a/compiler/src/dotty/tools/dotc/transform/Staging.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Staging.scala
@@ -10,7 +10,6 @@ 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.staging.QuoteContext.*
 import dotty.tools.dotc.staging.StagingLevel.*
 import dotty.tools.dotc.staging.CrossStageSafety
 import dotty.tools.dotc.staging.HealType
diff --git a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
index e562470aea5e..1f3b5c758324 100644
--- a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
+++ b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
@@ -15,7 +15,6 @@ 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.staging.QuoteContext.*
 import dotty.tools.dotc.staging.StagingLevel.*
 import dotty.tools.dotc.transform.SymUtils._
 import dotty.tools.dotc.typer.Implicits._
@@ -42,15 +41,15 @@ trait QuotesAndSplices {
         report.warning("Canceled splice directly inside a quote. '{ ${ XYZ } } is equivalent to XYZ.", tree.srcPos)
       case _ =>
     }
-    val qctx = inferImplicitArg(defn.QuotesClass.typeRef, tree.span)
+    val quotes = 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 quotes.tpe.isInstanceOf[SearchFailureType] then
+      report.error(missingArgMsg(quotes, defn.QuotesClass.typeRef, ""), ctx.source.atSpan(tree.span))
+    else if !quotes.tpe.isStable then
+      report.error(em"Quotes require stable Quotes, but found non stable $quotes", quotes.srcPos)
 
     if ctx.mode.is(Mode.Pattern) then
-      typedQuotePattern(tree, pt, qctx).withSpan(tree.span)
+      typedQuotePattern(tree, pt, quotes).withSpan(tree.span)
     else if tree.quoted.isType then
       val msg = em"""Quoted types `'[..]` can only be used in patterns.
                     |
@@ -60,9 +59,9 @@ trait QuotesAndSplices {
       EmptyTree
     else
       val exprQuoteTree = untpd.Apply(untpd.ref(defn.QuotedRuntime_exprQuote.termRef), tree.quoted)
-      val quotedExpr = typedApply(exprQuoteTree, pt)(using pushQuotes(qctx)) match
+      val quotedExpr = typedApply(exprQuoteTree, pt)(using quoteContext) match
         case Apply(TypeApply(fn, tpt :: Nil), quotedExpr :: Nil) => QuotedExpr(quotedExpr, tpt)
-      makeInlineable(quotedExpr.select(nme.apply).appliedTo(qctx).withSpan(tree.span))
+      makeInlineable(quotedExpr.select(nme.apply).appliedTo(quotes).withSpan(tree.span))
   }
 
   private def makeInlineable(tree: Tree)(using Context): Tree =
@@ -88,7 +87,7 @@ trait QuotesAndSplices {
           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
-        SplicedExpr(pat, TypeTree(argType), EmptyTree).withSpan(tree.span)
+        SplicedExpr(pat, TypeTree(argType)).withSpan(tree.span)
       }
       else {
         report.error(em"Type must be fully defined.\nConsider annotating the splice using a type ascription:\n  ($tree: XYZ).", tree.expr.srcPos)
@@ -105,19 +104,12 @@ trait QuotesAndSplices {
         markAsMacro(ctx)
       }
 
-      val (outerQctx, ctx1) = popQuotes()
-
       val internalSplice =
         untpd.Apply(untpd.ref(defn.QuotedRuntime_exprSplice.termRef), tree.expr)
-        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) match
+      typedApply(internalSplice, pt)(using spliceContext).withSpan(tree.span) match
         case tree @ Apply(TypeApply(_, tpt :: Nil), spliced :: Nil) if tree.symbol == defn.QuotedRuntime_exprSplice =>
-          cpy.SplicedExpr(tree)(spliced, tpt, EmptyTree)
-        case tree @ Apply(Apply(TypeApply(_, tpt :: Nil), quotes :: Nil), spliced :: Nil) if tree.symbol == defn.QuotedRuntime_exprNestedSplice =>
-          cpy.SplicedExpr(tree)(spliced, tpt, quotes)
+          cpy.SplicedExpr(tree)(spliced, tpt)
         case tree => tree
     }
   }
@@ -234,12 +226,12 @@ trait QuotesAndSplices {
       val freshTypeBindingsBuff = new mutable.ListBuffer[Tree]
       val typePatBuf = new mutable.ListBuffer[Tree]
       override def transform(tree: Tree)(using Context) = tree match {
-        case Typed(SplicedExpr(pat, _, outerQuotes), tpt) if !tpt.tpe.derivesFrom(defn.RepeatedParamClass) =>
+        case Typed(SplicedExpr(pat, _), tpt) if !tpt.tpe.derivesFrom(defn.RepeatedParamClass) =>
           val tpt1 = transform(tpt) // Transform type bindings
           val exprTpt = AppliedTypeTree(TypeTree(defn.QuotedExprClass.typeRef), tpt1 :: Nil)
-          val newSplice = cpy.SplicedExpr(tree)(pat, tpt1, outerQuotes)
+          val newSplice = cpy.SplicedExpr(tree)(pat, tpt1)
           transform(newSplice)
-        case Apply(TypeApply(fn, targs), SplicedExpr(pat, _, _) :: args :: Nil) if fn.symbol == defn.QuotedRuntimePatterns_patternHigherOrderHole =>
+        case Apply(TypeApply(fn, targs), SplicedExpr(pat, _) :: 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
@@ -251,7 +243,7 @@ trait QuotesAndSplices {
             val pat1 = if (patType eq patType1) pat else pat.withType(patType1)
             patBuf += pat1
           }
-        case SplicedExpr(pat, _, _) =>
+        case SplicedExpr(pat, _) =>
           try ref(defn.QuotedRuntimePatterns_patternHole.termRef).appliedToType(tree.tpe).withSpan(tree.span)
           finally {
             val patType = pat.tpe.widen
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 822f8e253932..b1d281f35976 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -2047,7 +2047,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
 
   def typedQuotedExpr(tree: untpd.QuotedExpr, pt: Type)(using Context): Tree =
     val tpt1 = checkSimpleKinded(typedType(tree.tpt, mapPatternBounds = true))
-    val expr1 = typed(tree.expr, tpt1.tpe.widenSkolem)
+    val expr1 = typed(tree.expr, tpt1.tpe.widenSkolem)(using StagingLevel.quoteContext)
     assignType(cpy.QuotedExpr(tree)(expr1, tpt1), tpt1)
 
   def typedSplicedExpr(tree: untpd.SplicedExpr, pt: Type)(using Context): Tree =
@@ -2055,9 +2055,8 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     val splicedType = // Quotes ?=> Expr[T]
       defn.FunctionType(1, isContextual = true)
         .appliedTo(defn.QuotesClass.typeRef, defn.QuotedExprClass.typeRef.appliedTo(tpt1.tpe.widenSkolem))
-    val spliced1 = typed(tree.spliced, splicedType)
-    val outerQuotes1 = typed(tree.outerQuotes, defn.QuotesClass.typeRef)
-    assignType(cpy.SplicedExpr(tree)(spliced1, tpt1, outerQuotes1), tpt1)
+    val spliced1 = typed(tree.spliced, splicedType)(using StagingLevel.spliceContext)
+    assignType(cpy.SplicedExpr(tree)(spliced1, tpt1), tpt1)
 
   def completeTypeTree(tree: untpd.TypeTree, pt: Type, original: untpd.Tree)(using Context): TypeTree =
     tree.withSpan(original.span).withAttachmentsFrom(original)

From 161ef49f6be3a8a7adb1cdf835ae78abd9f95393 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 25 Apr 2023 11:34:27 +0200
Subject: [PATCH 405/657] Rename `SplicedExpr.{spliced=>expr}`

---
 compiler/src/dotty/tools/dotc/ast/Trees.scala | 20 +++++++++----------
 compiler/src/dotty/tools/dotc/ast/tpd.scala   |  4 ++--
 compiler/src/dotty/tools/dotc/ast/untpd.scala |  2 +-
 .../tools/dotc/core/tasty/TreePickler.scala   |  4 ++--
 .../dotty/tools/dotc/inlines/Inliner.scala    |  4 ++--
 .../tools/dotc/printing/RefinedPrinter.scala  |  4 ++--
 .../tools/dotc/transform/FirstTransform.scala |  4 ++--
 .../dotty/tools/dotc/transform/Splicing.scala | 12 +++++------
 .../src/dotty/tools/dotc/typer/Typer.scala    |  4 ++--
 9 files changed, 29 insertions(+), 29 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala
index dc37b1ef7180..b95e2a41ff09 100644
--- a/compiler/src/dotty/tools/dotc/ast/Trees.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala
@@ -682,7 +682,7 @@ object Trees {
     type ThisTree[+T <: Untyped] = QuotedExpr[T]
   }
 
-  case class SplicedExpr[+T <: Untyped] private[ast] (spliced: Tree[T], tpt: Tree[T])(implicit @constructorOnly src: SourceFile)
+  case class SplicedExpr[+T <: Untyped] private[ast] (expr: Tree[T], tpt: Tree[T])(implicit @constructorOnly src: SourceFile)
     extends TermTree[T] {
     type ThisTree[+T <: Untyped] = SplicedExpr[T]
   }
@@ -1273,9 +1273,9 @@ object Trees {
         case tree: QuotedExpr if (expr eq tree.expr) && (tpt eq tree.tpt) => tree
         case _ => finalize(tree, untpd.QuotedExpr(expr, tpt)(sourceFile(tree)))
       }
-      def SplicedExpr(tree: Tree)(spliced: Tree, tpt: Tree)(using Context): SplicedExpr = tree match {
-        case tree: SplicedExpr if (spliced eq tree.spliced) && (tpt eq tree.tpt) => tree
-        case _ => finalize(tree, untpd.SplicedExpr(spliced, tpt)(sourceFile(tree)))
+      def SplicedExpr(tree: Tree)(expr: Tree, tpt: Tree)(using Context): SplicedExpr = tree match {
+        case tree: SplicedExpr if (expr eq tree.expr) && (tpt eq tree.tpt) => tree
+        case _ => finalize(tree, untpd.SplicedExpr(expr, tpt)(sourceFile(tree)))
       }
       def SingletonTypeTree(tree: Tree)(ref: Tree)(using Context): SingletonTypeTree = tree match {
         case tree: SingletonTypeTree if (ref eq tree.ref) => tree
@@ -1382,8 +1382,8 @@ object Trees {
         TypeDef(tree: Tree)(name, rhs)
       def Template(tree: Template)(using Context)(constr: DefDef = tree.constr, parents: List[Tree] = tree.parents, derived: List[untpd.Tree] = tree.derived, self: ValDef = tree.self, body: LazyTreeList = tree.unforcedBody): Template =
         Template(tree: Tree)(constr, parents, derived, self, body)
-      def SplicedExpr(tree: SplicedExpr)(spliced: Tree = tree.spliced, tpt: Tree = tree.tpt)(using Context): SplicedExpr =
-        SplicedExpr(tree: Tree)(spliced, tpt)
+      def SplicedExpr(tree: SplicedExpr)(expr: Tree = tree.expr, tpt: Tree = tree.tpt)(using Context): SplicedExpr =
+        SplicedExpr(tree: Tree)(expr, tpt)
       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)
 
@@ -1518,8 +1518,8 @@ object Trees {
               if (trees1 eq trees) tree else Thicket(trees1)
             case tree @ QuotedExpr(expr, tpt) =>
               cpy.QuotedExpr(tree)(transform(expr), transform(tpt))
-            case tree @ SplicedExpr(spliced, tpt) =>
-              cpy.SplicedExpr(tree)(transform(spliced), transform(tpt))
+            case tree @ SplicedExpr(expr, tpt) =>
+              cpy.SplicedExpr(tree)(transform(expr), transform(tpt))
             case tree @ Hole(_, _, args, content, tpt) =>
               cpy.Hole(tree)(args = transform(args), content = transform(content), tpt = transform(tpt))
             case _ =>
@@ -1663,8 +1663,8 @@ object Trees {
               this(x, ts)
             case QuotedExpr(expr, tpt) =>
               this(this(x, expr), tpt)
-            case SplicedExpr(spliced, tpt) =>
-              this(this(x, spliced), tpt)
+            case SplicedExpr(expr, tpt) =>
+              this(this(x, expr), tpt)
             case Hole(_, _, args, content, tpt) =>
               this(this(this(x, args), content), tpt)
             case _ =>
diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
index bc2498e7ca9b..50b288f6ddc1 100644
--- a/compiler/src/dotty/tools/dotc/ast/tpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -173,8 +173,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def QuotedExpr(expr: Tree, tpt: Tree)(using Context): QuotedExpr =
     ta.assignType(untpd.QuotedExpr(expr, tpt), tpt)
 
-  def SplicedExpr(spliced: Tree, tpt: Tree)(using Context): SplicedExpr =
-    ta.assignType(untpd.SplicedExpr(spliced, tpt), tpt)
+  def SplicedExpr(expr: Tree, tpt: Tree)(using Context): SplicedExpr =
+    ta.assignType(untpd.SplicedExpr(expr, tpt), tpt)
 
   def TypeTree(tp: Type, inferred: Boolean = false)(using Context): TypeTree =
     (if inferred then untpd.InferredTypeTree() else untpd.TypeTree()).withType(tp)
diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
index c8d083ef792d..151851d89a43 100644
--- a/compiler/src/dotty/tools/dotc/ast/untpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -402,7 +402,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   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 QuotedExpr(expr: Tree, tpt: Tree)(implicit src: SourceFile): QuotedExpr = new QuotedExpr(expr, tpt)
-  def SplicedExpr(spliced: Tree, tpt: Tree)(implicit src: SourceFile): SplicedExpr = new SplicedExpr(spliced, tpt)
+  def SplicedExpr(expr: Tree, tpt: Tree)(implicit src: SourceFile): SplicedExpr = new SplicedExpr(expr, tpt)
   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)
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
index 0762ea476021..f41d3b57f8f0 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -673,12 +673,12 @@ class TreePickler(pickler: TastyPickler) {
               .appliedTo(expr)
               .withSpan(tree.span)
           )
-        case SplicedExpr(spliced, tpt) =>
+        case SplicedExpr(expr, tpt) =>
           pickleTree(
             // scala.quoted.runtime.Expr.splice[<tpt>](<spliced>)
             ref(defn.QuotedRuntime_exprSplice)
               .appliedToTypeTree(tpt)
-              .appliedTo(spliced)
+              .appliedTo(expr)
               .withSpan(tree.span)
           )
         case Hole(_, idx, args, _, tpt) =>
diff --git a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
index 02e1bbdeacce..c03e86970d90 100644
--- a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
@@ -834,10 +834,10 @@ class Inliner(val call: tpd.Tree)(using Context):
 
     override def typedSplicedExpr(tree: untpd.SplicedExpr, pt: Type)(using Context): Tree =
       super.typedSplicedExpr(tree, pt) match
-        case tree1 @ SplicedExpr(spliced, tpt)
+        case tree1 @ SplicedExpr(expr, tpt)
             if StagingLevel.level == 0
             && !hasInliningErrors =>
-          val expanded = expandMacro(spliced, tree1.srcPos)
+          val expanded = expandMacro(expr, tree1.srcPos)
           transform.TreeChecker.checkMacroGeneratedTree(tree1, expanded)
           typedExpr(expanded) // Inline calls and constant fold code generated by the macro
         case tree1 => tree1
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index 0d899b8b5909..be407ded2f82 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -723,9 +723,9 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case QuotedExpr(expr, tpt) =>
         val tptText = (keywordStr("[") ~ toTextGlobal(tpt) ~ keywordStr("]")).provided(printDebug)
         keywordStr("'") ~ tptText ~ keywordStr("{") ~ toTextGlobal(expr) ~ keywordStr("}")
-      case SplicedExpr(spliced, tpt) =>
+      case SplicedExpr(expr, tpt) =>
         val tptText = (keywordStr("[") ~ toTextGlobal(tpt) ~ keywordStr("]")).provided(printDebug)
-        keywordStr("$") ~ tptText ~ keywordStr("{") ~ toTextGlobal(spliced) ~ keywordStr("}")
+        keywordStr("$") ~ tptText ~ keywordStr("{") ~ toTextGlobal(expr) ~ keywordStr("}")
       case Hole(isTermHole, idx, args, content, tpt) =>
         val (prefix, postfix) = if isTermHole then ("{{{", "}}}") else ("[[[", "]]]")
         val argsText = toTextGlobal(args, ", ")
diff --git a/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala b/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala
index 7a9e3cc324d3..cad54982d10d 100644
--- a/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala
+++ b/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala
@@ -153,9 +153,9 @@ class FirstTransform extends MiniPhase with InfoTransformer { thisPhase =>
   override def transformOther(tree: Tree)(using Context): Tree = tree match {
     case tree: Export => EmptyTree
     case tree: NamedArg => transformAllDeep(tree.arg)
-    case tree @ SplicedExpr(spliced, tpt) =>
+    case tree @ SplicedExpr(expr, tpt) =>
       assert(dotty.tools.dotc.inlines.Inlines.inInlineMethod)
-      cpy.SplicedExpr(tree)(transformAllDeep(spliced), transformAllDeep(tpt))
+      cpy.SplicedExpr(tree)(transformAllDeep(expr), transformAllDeep(tpt))
     case tree => if (tree.isType) toTypeTree(tree) else tree
   }
 
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicing.scala b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
index ed271f20c5bf..ca3acb6b8fac 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicing.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
@@ -113,13 +113,13 @@ class Splicing extends MacroTransform:
       tree match
         case tree: SplicedExpr =>
           if level > 1 then
-            val spliced1 = super.transform(tree.spliced)(using spliceContext)
-            cpy.SplicedExpr(tree)(spliced1, tree.tpt)
+            val expr1 = super.transform(tree.expr)(using spliceContext)
+            cpy.SplicedExpr(tree)(expr1, tree.tpt)
           else
             val holeIdx = numHoles
             numHoles += 1
             val splicer = SpliceTransformer(ctx.owner, quotedDefs.contains)
-            val newSplicedCode1 = splicer.transformSplice(tree.spliced, tree.tpe, holeIdx)(using spliceContext)
+            val newSplicedCode1 = splicer.transformSplice(tree.expr, tree.tpe, holeIdx)(using spliceContext)
             val newSplicedCode2 = Level0QuoteTransformer.transform(newSplicedCode1)(using spliceContext)
             newSplicedCode2
         case tree: TypeDef if tree.symbol.hasAnnotation(defn.QuotedRuntime_SplicedTypeAnnot) =>
@@ -234,9 +234,9 @@ class Splicing extends MacroTransform:
         case tree @ Assign(lhs: RefTree, rhs) =>
           if isCaptured(lhs.symbol) then transformSplicedAssign(tree)
           else super.transform(tree)
-        case SplicedExpr(spliced, tpt) =>
-          val spliced1 = transform(spliced)(using spliceContext)
-          cpy.SplicedExpr(tree)(spliced1, tpt)
+        case SplicedExpr(expr, tpt) =>
+          val expr1 = transform(expr)(using spliceContext)
+          cpy.SplicedExpr(tree)(expr1, tpt)
         case Apply(sel @ Select(app @ QuotedExpr(expr, tpt), nme.apply), quotesArgs) =>
           expr match
             case expr: RefTree if isCaptured(expr.symbol) =>
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index b1d281f35976..b13bc5ec0bea 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -2055,8 +2055,8 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     val splicedType = // Quotes ?=> Expr[T]
       defn.FunctionType(1, isContextual = true)
         .appliedTo(defn.QuotesClass.typeRef, defn.QuotedExprClass.typeRef.appliedTo(tpt1.tpe.widenSkolem))
-    val spliced1 = typed(tree.spliced, splicedType)(using StagingLevel.spliceContext)
-    assignType(cpy.SplicedExpr(tree)(spliced1, tpt1), tpt1)
+    val expr1 = typed(tree.expr, splicedType)(using StagingLevel.spliceContext)
+    assignType(cpy.SplicedExpr(tree)(expr1, tpt1), tpt1)
 
   def completeTypeTree(tree: untpd.TypeTree, pt: Type, original: untpd.Tree)(using Context): TypeTree =
     tree.withSpan(original.span).withAttachmentsFrom(original)

From cf30d30cc60bfc1d5a8e2e87b040ebbd3ffd98e3 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 25 Apr 2023 11:51:41 +0200
Subject: [PATCH 406/657] Use QuotedExpr instead of Quote trees

---
 .../src/dotty/tools/dotc/ast/Desugar.scala    |  2 +-
 compiler/src/dotty/tools/dotc/ast/untpd.scala |  9 -------
 .../dotty/tools/dotc/parsing/Parsers.scala    |  6 ++---
 .../tools/dotc/printing/RefinedPrinter.scala  |  4 +---
 .../tools/dotc/typer/QuotesAndSplices.scala   | 24 +++++++++----------
 .../src/dotty/tools/dotc/typer/Typer.scala    | 10 ++++----
 6 files changed, 23 insertions(+), 32 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index c1dd78451bae..bf24702e4036 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -1986,7 +1986,7 @@ object desugar {
         trees foreach collect
       case Block(Nil, expr) =>
         collect(expr)
-      case Quote(expr) =>
+      case QuotedExpr(expr, _) =>
         new UntypedTreeTraverser {
           def traverse(tree: untpd.Tree)(using Context): Unit = tree match {
             case Splice(expr) => collect(expr)
diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
index 151851d89a43..e2f0a44cea99 100644
--- a/compiler/src/dotty/tools/dotc/ast/untpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -111,7 +111,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     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
   }
@@ -624,10 +623,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
       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))
@@ -713,8 +708,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         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) =>
@@ -774,8 +767,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         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) =>
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 15a639743c15..12e038f560d3 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -1262,7 +1262,7 @@ object Parsers {
               }
             }
             in.nextToken()
-            Quote(t)
+            QuotedExpr(t, EmptyTree)
           }
           else
             if !in.featureEnabled(Feature.symbolLiterals) then
@@ -2494,10 +2494,10 @@ object Parsers {
         case QUOTE =>
           atSpan(in.skipToken()) {
             withinStaged(StageKind.Quoted | (if (location.inPattern) StageKind.QuotedPattern else 0)) {
-              Quote {
+              val expr =
                 if (in.token == LBRACKET) inBrackets(typ())
                 else stagedBlock()
-              }
+              QuotedExpr(expr, EmptyTree)
             }
           }
         case NEW =>
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index be407ded2f82..9910f471756e 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -712,8 +712,6 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         }
       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) =>
@@ -721,7 +719,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case MacroTree(call) =>
         keywordStr("macro ") ~ toTextGlobal(call)
       case QuotedExpr(expr, tpt) =>
-        val tptText = (keywordStr("[") ~ toTextGlobal(tpt) ~ keywordStr("]")).provided(printDebug)
+        val tptText = (keywordStr("[") ~ toTextGlobal(tpt) ~ keywordStr("]")).provided(!tpt.isEmpty && printDebug)
         keywordStr("'") ~ tptText ~ keywordStr("{") ~ toTextGlobal(expr) ~ keywordStr("}")
       case SplicedExpr(expr, tpt) =>
         val tptText = (keywordStr("[") ~ toTextGlobal(tpt) ~ keywordStr("]")).provided(printDebug)
diff --git a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
index 1f3b5c758324..5e9279dbc819 100644
--- a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
+++ b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
@@ -34,9 +34,9 @@ trait QuotesAndSplices {
   /** 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 = {
+  def typedQuote(tree: untpd.QuotedExpr, pt: Type)(using Context): Tree = {
     record("typedQuote")
-    tree.quoted match {
+    tree.expr 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 _ =>
@@ -50,7 +50,7 @@ trait QuotesAndSplices {
 
     if ctx.mode.is(Mode.Pattern) then
       typedQuotePattern(tree, pt, quotes).withSpan(tree.span)
-    else if tree.quoted.isType then
+    else if tree.expr.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.
@@ -58,7 +58,7 @@ trait QuotesAndSplices {
       report.error(msg, tree.srcPos)
       EmptyTree
     else
-      val exprQuoteTree = untpd.Apply(untpd.ref(defn.QuotedRuntime_exprQuote.termRef), tree.quoted)
+      val exprQuoteTree = untpd.Apply(untpd.ref(defn.QuotedRuntime_exprQuote.termRef), tree.expr)
       val quotedExpr = typedApply(exprQuoteTree, pt)(using quoteContext) match
         case Apply(TypeApply(fn, tpt :: Nil), quotedExpr :: Nil) => QuotedExpr(quotedExpr, tpt)
       makeInlineable(quotedExpr.select(nme.apply).appliedTo(quotes).withSpan(tree.span))
@@ -74,7 +74,7 @@ trait QuotesAndSplices {
     record("typedSplice")
     checkSpliceOutsideQuote(tree)
     tree.expr match {
-      case untpd.Quote(innerExpr) if innerExpr.isTerm =>
+      case untpd.QuotedExpr(innerExpr, _) if innerExpr.isTerm =>
         report.warning("Canceled quote directly inside a splice. ${ '{ XYZ } } is equivalent to XYZ.", tree.srcPos)
         return typed(innerExpr, pt)
       case _ =>
@@ -382,13 +382,13 @@ trait QuotesAndSplices {
    *        ) => ...
    *  ```
    */
-  private def typedQuotePattern(tree: untpd.Quote, pt: Type, qctx: Tree)(using Context): Tree = {
-    if tree.quoted.isTerm && !pt.derivesFrom(defn.QuotedExprClass) then
+  private def typedQuotePattern(tree: untpd.QuotedExpr, pt: Type, qctx: Tree)(using Context): Tree = {
+    val quoted = tree.expr
+    if 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
+    else if 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
@@ -440,12 +440,12 @@ trait QuotesAndSplices {
       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 quoteClass = if (quoted.isTerm) defn.QuotedExprClass else defn.QuotedTypeClass
     val quotedPattern =
-      if (tree.quoted.isTerm) tpd.QuotedExpr(shape, TypeTree(defn.AnyType)).select(nme.apply).appliedTo(qctx)
+      if (quoted.isTerm) tpd.QuotedExpr(shape, TypeTree(defn.AnyType)).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 matchModule = if quoted.isTerm then defn.QuoteMatching_ExprMatch else defn.QuoteMatching_TypeMatch
     val unapplyFun = qctx.asInstance(defn.QuoteMatchingClass.typeRef).select(matchModule).select(nme.unapply)
 
     UnApply(
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index b13bc5ec0bea..cf239ab4fc33 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -2046,9 +2046,12 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
   }
 
   def typedQuotedExpr(tree: untpd.QuotedExpr, pt: Type)(using Context): Tree =
-    val tpt1 = checkSimpleKinded(typedType(tree.tpt, mapPatternBounds = true))
-    val expr1 = typed(tree.expr, tpt1.tpe.widenSkolem)(using StagingLevel.quoteContext)
-    assignType(cpy.QuotedExpr(tree)(expr1, tpt1), tpt1)
+    if tree.tpt.isEmpty then
+      typedQuote(tree, pt)
+    else
+      val tpt1 = checkSimpleKinded(typedType(tree.tpt, mapPatternBounds = true))
+      val expr1 = typed(tree.expr, tpt1.tpe.widenSkolem)(using StagingLevel.quoteContext)
+      assignType(cpy.QuotedExpr(tree)(expr1, tpt1), tpt1)
 
   def typedSplicedExpr(tree: untpd.SplicedExpr, pt: Type)(using Context): Tree =
     val tpt1 = checkSimpleKinded(typedType(tree.tpt, mapPatternBounds = true))
@@ -3088,7 +3091,6 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           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.QuotedExpr => typedQuotedExpr(tree, pt)
           case tree: untpd.Splice => typedSplice(tree, pt)
           case tree: untpd.SplicedExpr => typedSplicedExpr(tree, pt)

From f0d758b2620106273eeb6387fdd6fc95d025e348 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 25 Apr 2023 12:54:35 +0200
Subject: [PATCH 407/657] Use SplicedExpr instead of Splice trees

---
 compiler/src/dotty/tools/dotc/ast/Desugar.scala  |  6 +++---
 compiler/src/dotty/tools/dotc/ast/Trees.scala    |  1 +
 compiler/src/dotty/tools/dotc/ast/untpd.scala    | 11 -----------
 .../src/dotty/tools/dotc/parsing/Parsers.scala   |  2 +-
 .../tools/dotc/printing/RefinedPrinter.scala     |  4 +---
 .../dotty/tools/dotc/typer/Applications.scala    |  2 +-
 .../tools/dotc/typer/QuotesAndSplices.scala      |  6 +++---
 compiler/src/dotty/tools/dotc/typer/Typer.scala  | 16 +++++++++-------
 8 files changed, 19 insertions(+), 29 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index bf24702e4036..1c519a602d5a 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -338,9 +338,9 @@ object desugar {
   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 =>
+      case _: untpd.SplicedExpr =>
         untpd.Typed(tree, expectedTpt).withSpan(tree.span)
-      case Typed(expr: untpd.Splice, tpt) =>
+      case Typed(expr: untpd.SplicedExpr, tpt) =>
         cpy.Typed(tree)(expr, untpd.makeAndType(tpt, expectedTpt).withSpan(tpt.span))
 
       // Propagate down the expected type to the leafs of the expression
@@ -1989,7 +1989,7 @@ object desugar {
       case QuotedExpr(expr, _) =>
         new UntypedTreeTraverser {
           def traverse(tree: untpd.Tree)(using Context): Unit = tree match {
-            case Splice(expr) => collect(expr)
+            case SplicedExpr(expr, _) => collect(expr)
             case _ => traverseChildren(tree)
           }
         }.traverse(expr)
diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala
index b95e2a41ff09..9d487c46ff88 100644
--- a/compiler/src/dotty/tools/dotc/ast/Trees.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala
@@ -685,6 +685,7 @@ object Trees {
   case class SplicedExpr[+T <: Untyped] private[ast] (expr: Tree[T], tpt: Tree[T])(implicit @constructorOnly src: SourceFile)
     extends TermTree[T] {
     type ThisTree[+T <: Untyped] = SplicedExpr[T]
+    def isInBraces: Boolean = span.end != expr.span.end
   }
 
   /** A type tree that represents an existing or inferred type */
diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
index e2f0a44cea99..b9f5bb751862 100644
--- a/compiler/src/dotty/tools/dotc/ast/untpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -111,9 +111,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     override def isType: Boolean = !isTerm
   }
   case class Throw(expr: 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
@@ -623,10 +620,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
       case tree: Throw if expr eq tree.expr => tree
       case _ => finalize(tree, untpd.Throw(expr)(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))
@@ -708,8 +701,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         cpy.Tuple(tree)(transform(trees))
       case Throw(expr) =>
         cpy.Throw(tree)(transform(expr))
-      case Splice(expr) =>
-        cpy.Splice(tree)(transform(expr))
       case ForYield(enums, expr) =>
         cpy.ForYield(tree)(transform(enums), transform(expr))
       case ForDo(enums, body) =>
@@ -767,8 +758,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         this(x, trees)
       case Throw(expr) =>
         this(x, expr)
-      case Splice(expr) =>
-        this(x, expr)
       case ForYield(enums, expr) =>
         this(this(x, enums), expr)
       case ForDo(enums, body) =>
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 12e038f560d3..8fa5fe54bc28 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -1764,7 +1764,7 @@ object Parsers {
           syntaxError(em"$msg\n\nHint: $hint", Span(start, in.lastOffset))
           Ident(nme.ERROR.toTypeName)
         else
-          Splice(expr)
+          SplicedExpr(expr, EmptyTree)
       }
 
     /**  SimpleType      ::=  SimpleLiteral
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index 9910f471756e..5b8b367e21be 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -712,8 +712,6 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         }
       case Number(digits, kind) =>
         digits
-      case Splice(tree) =>
-        keywordStr("${") ~ toTextGlobal(dropBlock(tree)) ~ keywordStr("}")
       case Thicket(trees) =>
         "Thicket {" ~~ toTextGlobal(trees, "\n") ~~ "}"
       case MacroTree(call) =>
@@ -722,7 +720,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         val tptText = (keywordStr("[") ~ toTextGlobal(tpt) ~ keywordStr("]")).provided(!tpt.isEmpty && printDebug)
         keywordStr("'") ~ tptText ~ keywordStr("{") ~ toTextGlobal(expr) ~ keywordStr("}")
       case SplicedExpr(expr, tpt) =>
-        val tptText = (keywordStr("[") ~ toTextGlobal(tpt) ~ keywordStr("]")).provided(printDebug)
+        val tptText = (keywordStr("[") ~ toTextGlobal(tpt) ~ keywordStr("]")).provided(!tpt.isEmpty && printDebug)
         keywordStr("$") ~ tptText ~ keywordStr("{") ~ toTextGlobal(expr) ~ keywordStr("}")
       case Hole(isTermHole, idx, args, content, tpt) =>
         val (prefix, postfix) = if isTermHole then ("{{{", "}}}") else ("[[[", "]]]")
diff --git a/compiler/src/dotty/tools/dotc/typer/Applications.scala b/compiler/src/dotty/tools/dotc/typer/Applications.scala
index 79d6501ccb2d..77c9eb519db1 100644
--- a/compiler/src/dotty/tools/dotc/typer/Applications.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Applications.scala
@@ -1097,7 +1097,7 @@ trait Applications extends Compatibility {
         }
       else {
         val app = tree.fun match
-          case _: untpd.Splice if ctx.mode.is(Mode.QuotedPattern) => typedAppliedSplice(tree, pt)
+          case _: untpd.SplicedExpr if ctx.mode.is(Mode.QuotedPattern) => typedAppliedSplice(tree, pt)
           case _ => realApply
         app match {
           case Apply(fn @ Select(left, _), right :: Nil) if fn.hasType =>
diff --git a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
index 5e9279dbc819..a61798fab4b7 100644
--- a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
+++ b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
@@ -37,7 +37,7 @@ trait QuotesAndSplices {
   def typedQuote(tree: untpd.QuotedExpr, pt: Type)(using Context): Tree = {
     record("typedQuote")
     tree.expr match {
-      case untpd.Splice(innerExpr) if tree.isTerm && !ctx.mode.is(Mode.Pattern) =>
+      case untpd.SplicedExpr(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 _ =>
     }
@@ -70,7 +70,7 @@ trait QuotesAndSplices {
     }
 
   /** 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 = {
+  def typedSplice(tree: untpd.SplicedExpr, pt: Type)(using Context): Tree = {
     record("typedSplice")
     checkSpliceOutsideQuote(tree)
     tree.expr match {
@@ -123,7 +123,7 @@ trait QuotesAndSplices {
    */
   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
+    val untpd.Apply(splice: untpd.SplicedExpr, args) = tree: @unchecked
     if !isFullyDefined(pt, ForceDegree.flipBottom) then
       report.error(em"Type must be fully defined.", splice.srcPos)
       tree.withType(UnspecifiedErrorType)
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index cf239ab4fc33..0a20335bc1d1 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -2054,12 +2054,15 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       assignType(cpy.QuotedExpr(tree)(expr1, tpt1), tpt1)
 
   def typedSplicedExpr(tree: untpd.SplicedExpr, pt: Type)(using Context): Tree =
-    val tpt1 = checkSimpleKinded(typedType(tree.tpt, mapPatternBounds = true))
-    val splicedType = // Quotes ?=> Expr[T]
-      defn.FunctionType(1, isContextual = true)
-        .appliedTo(defn.QuotesClass.typeRef, defn.QuotedExprClass.typeRef.appliedTo(tpt1.tpe.widenSkolem))
-    val expr1 = typed(tree.expr, splicedType)(using StagingLevel.spliceContext)
-    assignType(cpy.SplicedExpr(tree)(expr1, tpt1), tpt1)
+    if tree.tpt.isEmpty then
+      typedSplice(tree, pt)
+    else
+      val tpt1 = checkSimpleKinded(typedType(tree.tpt, mapPatternBounds = true))
+      val splicedType = // Quotes ?=> Expr[T]
+        defn.FunctionType(1, isContextual = true)
+          .appliedTo(defn.QuotesClass.typeRef, defn.QuotedExprClass.typeRef.appliedTo(tpt1.tpe.widenSkolem))
+      val expr1 = typed(tree.expr, splicedType)(using StagingLevel.spliceContext)
+      assignType(cpy.SplicedExpr(tree)(expr1, tpt1), tpt1)
 
   def completeTypeTree(tree: untpd.TypeTree, pt: Type, original: untpd.Tree)(using Context): TypeTree =
     tree.withSpan(original.span).withAttachmentsFrom(original)
@@ -3092,7 +3095,6 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           case tree @ untpd.PostfixOp(qual, Ident(nme.WILDCARD)) => typedAsFunction(tree, pt)
           case untpd.EmptyTree => tpd.EmptyTree
           case tree: untpd.QuotedExpr => typedQuotedExpr(tree, pt)
-          case tree: untpd.Splice => typedSplice(tree, pt)
           case tree: untpd.SplicedExpr => typedSplicedExpr(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)

From c6adab8e942d5cb0d428e9a12690e02cb9c2ed33 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 25 Apr 2023 13:03:33 +0200
Subject: [PATCH 408/657] Move typedQuotedExpr/typedSplicedExpr to
 QuotesAndSplices

---
 .../tools/dotc/typer/QuotesAndSplices.scala   | 35 ++++++++++++++-----
 .../src/dotty/tools/dotc/typer/Typer.scala    | 19 ----------
 2 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
index a61798fab4b7..d47c7abf3fc3 100644
--- a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
+++ b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
@@ -31,10 +31,33 @@ trait QuotesAndSplices {
 
   import tpd._
 
+  def typedQuotedExpr(tree: untpd.QuotedExpr, pt: Type)(using Context): Tree =
+    if tree.tpt.isEmpty then
+      typedQuoteSyntactic(tree, pt)
+    else
+      val tpt1 = checkSimpleKinded(typedType(tree.tpt, mapPatternBounds = true))
+      val expr1 = typed(tree.expr, tpt1.tpe.widenSkolem)(using quoteContext)
+      assignType(untpd.cpy.QuotedExpr(tree)(expr1, tpt1), tpt1)
+
+  def typedSplicedExpr(tree: untpd.SplicedExpr, pt: Type)(using Context): Tree =
+    if tree.tpt.isEmpty then
+      typedSpliceSyntactic(tree, pt)
+    else
+      val tpt1 = checkSimpleKinded(typedType(tree.tpt, mapPatternBounds = true))
+      val splicedType = // Quotes ?=> Expr[T]
+        defn.FunctionType(1, isContextual = true)
+          .appliedTo(defn.QuotesClass.typeRef, defn.QuotedExprClass.typeRef.appliedTo(tpt1.tpe.widenSkolem))
+      val expr1 = typed(tree.expr, splicedType)(using spliceContext)
+      assignType(untpd.cpy.SplicedExpr(tree)(expr1, tpt1), tpt1)
+
+  def typedHole(tree: untpd.Hole, pt: Type)(using Context): Tree =
+    val tpt = typedType(tree.tpt)
+    assignType(tree, tpt)
+
   /** 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.QuotedExpr, pt: Type)(using Context): Tree = {
+  private def typedQuoteSyntactic(tree: untpd.QuotedExpr, pt: Type)(using Context): Tree = {
     record("typedQuote")
     tree.expr match {
       case untpd.SplicedExpr(innerExpr, _) if tree.isTerm && !ctx.mode.is(Mode.Pattern) =>
@@ -70,7 +93,7 @@ trait QuotesAndSplices {
     }
 
   /** Translate `${ t: Expr[T] }` into expression `t.splice` while tracking the quotation level in the context */
-  def typedSplice(tree: untpd.SplicedExpr, pt: Type)(using Context): Tree = {
+  private def typedSpliceSyntactic(tree: untpd.SplicedExpr, pt: Type)(using Context): Tree = {
     record("typedSplice")
     checkSpliceOutsideQuote(tree)
     tree.expr match {
@@ -130,7 +153,7 @@ trait QuotesAndSplices {
     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))
+      val splice1 = typedSpliceSyntactic(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 {
@@ -143,7 +166,7 @@ trait QuotesAndSplices {
       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))
+      val typedPat = typedSpliceSyntactic(splice, defn.FunctionOf(argTypes, pt))
       ref(defn.QuotedRuntimePatterns_patternHigherOrderHole).appliedToType(pt).appliedTo(typedPat, SeqLiteral(typedArgs, TypeTree(defn.AnyType)))
   }
 
@@ -165,10 +188,6 @@ trait QuotesAndSplices {
         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)
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 0a20335bc1d1..aa0243146241 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -2045,25 +2045,6 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         bindings1, expansion1)
   }
 
-  def typedQuotedExpr(tree: untpd.QuotedExpr, pt: Type)(using Context): Tree =
-    if tree.tpt.isEmpty then
-      typedQuote(tree, pt)
-    else
-      val tpt1 = checkSimpleKinded(typedType(tree.tpt, mapPatternBounds = true))
-      val expr1 = typed(tree.expr, tpt1.tpe.widenSkolem)(using StagingLevel.quoteContext)
-      assignType(cpy.QuotedExpr(tree)(expr1, tpt1), tpt1)
-
-  def typedSplicedExpr(tree: untpd.SplicedExpr, pt: Type)(using Context): Tree =
-    if tree.tpt.isEmpty then
-      typedSplice(tree, pt)
-    else
-      val tpt1 = checkSimpleKinded(typedType(tree.tpt, mapPatternBounds = true))
-      val splicedType = // Quotes ?=> Expr[T]
-        defn.FunctionType(1, isContextual = true)
-          .appliedTo(defn.QuotesClass.typeRef, defn.QuotedExprClass.typeRef.appliedTo(tpt1.tpe.widenSkolem))
-      val expr1 = typed(tree.expr, splicedType)(using StagingLevel.spliceContext)
-      assignType(cpy.SplicedExpr(tree)(expr1, tpt1), tpt1)
-
   def completeTypeTree(tree: untpd.TypeTree, pt: Type, original: untpd.Tree)(using Context): TypeTree =
     tree.withSpan(original.span).withAttachmentsFrom(original)
       .withType(

From 3a045c4f6a63f7b5bcd04ae0a8c6163eef4800ce Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 25 Apr 2023 13:18:56 +0200
Subject: [PATCH 409/657] Rename QuotedExpr to Quote and SplicedExpr to Splice

---
 .../dotty/tools/dotc/CompilationUnit.scala    |  2 +-
 .../src/dotty/tools/dotc/ast/Desugar.scala    |  8 ++--
 compiler/src/dotty/tools/dotc/ast/Trees.scala | 40 +++++++++----------
 compiler/src/dotty/tools/dotc/ast/tpd.scala   |  8 ++--
 compiler/src/dotty/tools/dotc/ast/untpd.scala |  4 +-
 .../tools/dotc/core/tasty/TreePickler.scala   |  4 +-
 .../tools/dotc/core/tasty/TreeUnpickler.scala |  6 +--
 .../dotty/tools/dotc/inlines/Inliner.scala    | 16 ++++----
 .../dotc/inlines/PrepareInlineable.scala      |  6 +--
 .../dotty/tools/dotc/parsing/Parsers.scala    |  6 +--
 .../tools/dotc/printing/RefinedPrinter.scala  |  4 +-
 .../tools/dotc/staging/CrossStageSafety.scala |  8 ++--
 .../dotc/staging/TreeMapWithStages.scala      | 16 ++++----
 .../tools/dotc/transform/ElimByName.scala     |  4 +-
 .../tools/dotc/transform/FirstTransform.scala |  4 +-
 .../dotty/tools/dotc/transform/Inlining.scala |  8 ++--
 .../tools/dotc/transform/PickleQuotes.scala   |  6 +--
 .../tools/dotc/transform/PostTyper.scala      |  2 +-
 .../dotty/tools/dotc/transform/Splicer.scala  | 12 +++---
 .../dotty/tools/dotc/transform/Splicing.scala | 20 +++++-----
 .../tools/dotc/transform/patmat/Space.scala   |  2 +-
 .../dotty/tools/dotc/typer/Applications.scala |  2 +-
 .../tools/dotc/typer/QuotesAndSplices.scala   | 36 ++++++++---------
 .../dotty/tools/dotc/typer/TypeAssigner.scala |  4 +-
 .../src/dotty/tools/dotc/typer/Typer.scala    |  4 +-
 25 files changed, 116 insertions(+), 116 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/CompilationUnit.scala b/compiler/src/dotty/tools/dotc/CompilationUnit.scala
index 897befdda4a5..9a41f685f6c3 100644
--- a/compiler/src/dotty/tools/dotc/CompilationUnit.scala
+++ b/compiler/src/dotty/tools/dotc/CompilationUnit.scala
@@ -157,7 +157,7 @@ object CompilationUnit {
       if tree.symbol.is(Flags.Inline) then
         containsInline = true
       tree match
-        case tpd.QuotedExpr(_, _) =>
+        case tpd.Quote(_, _) =>
           containsQuote = true
         case tree: tpd.Apply if tree.symbol == defn.QuotedTypeModule_of =>
           containsQuote = true
diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index 1c519a602d5a..5c2410d3fbdc 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -338,9 +338,9 @@ object desugar {
   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.SplicedExpr =>
+      case _: untpd.Splice =>
         untpd.Typed(tree, expectedTpt).withSpan(tree.span)
-      case Typed(expr: untpd.SplicedExpr, tpt) =>
+      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
@@ -1986,10 +1986,10 @@ object desugar {
         trees foreach collect
       case Block(Nil, expr) =>
         collect(expr)
-      case QuotedExpr(expr, _) =>
+      case Quote(expr, _) =>
         new UntypedTreeTraverser {
           def traverse(tree: untpd.Tree)(using Context): Unit = tree match {
-            case SplicedExpr(expr, _) => collect(expr)
+            case Splice(expr, _) => collect(expr)
             case _ => traverseChildren(tree)
           }
         }.traverse(expr)
diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala
index 9d487c46ff88..65a0cd6ba710 100644
--- a/compiler/src/dotty/tools/dotc/ast/Trees.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala
@@ -677,14 +677,14 @@ object Trees {
     override def isType = expansion.isType
   }
 
-  case class QuotedExpr[+T <: Untyped] private[ast] (expr: Tree[T], tpt: Tree[T])(implicit @constructorOnly src: SourceFile)
+  case class Quote[+T <: Untyped] private[ast] (expr: Tree[T], tpt: Tree[T])(implicit @constructorOnly src: SourceFile)
     extends TermTree[T] {
-    type ThisTree[+T <: Untyped] = QuotedExpr[T]
+    type ThisTree[+T <: Untyped] = Quote[T]
   }
 
-  case class SplicedExpr[+T <: Untyped] private[ast] (expr: Tree[T], tpt: Tree[T])(implicit @constructorOnly src: SourceFile)
+  case class Splice[+T <: Untyped] private[ast] (expr: Tree[T], tpt: Tree[T])(implicit @constructorOnly src: SourceFile)
     extends TermTree[T] {
-    type ThisTree[+T <: Untyped] = SplicedExpr[T]
+    type ThisTree[+T <: Untyped] = Splice[T]
     def isInBraces: Boolean = span.end != expr.span.end
   }
 
@@ -1098,8 +1098,8 @@ object Trees {
     type SeqLiteral = Trees.SeqLiteral[T]
     type JavaSeqLiteral = Trees.JavaSeqLiteral[T]
     type Inlined = Trees.Inlined[T]
-    type QuotedExpr = Trees.QuotedExpr[T]
-    type SplicedExpr = Trees.SplicedExpr[T]
+    type Quote = Trees.Quote[T]
+    type Splice = Trees.Splice[T]
     type TypeTree = Trees.TypeTree[T]
     type InferredTypeTree = Trees.InferredTypeTree[T]
     type SingletonTypeTree = Trees.SingletonTypeTree[T]
@@ -1270,13 +1270,13 @@ object Trees {
         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 QuotedExpr(tree: Tree)(expr: Tree, tpt: Tree)(using Context): QuotedExpr = tree match {
-        case tree: QuotedExpr if (expr eq tree.expr) && (tpt eq tree.tpt) => tree
-        case _ => finalize(tree, untpd.QuotedExpr(expr, tpt)(sourceFile(tree)))
+      def Quote(tree: Tree)(expr: Tree, tpt: Tree)(using Context): Quote = tree match {
+        case tree: Quote if (expr eq tree.expr) && (tpt eq tree.tpt) => tree
+        case _ => finalize(tree, untpd.Quote(expr, tpt)(sourceFile(tree)))
       }
-      def SplicedExpr(tree: Tree)(expr: Tree, tpt: Tree)(using Context): SplicedExpr = tree match {
-        case tree: SplicedExpr if (expr eq tree.expr) && (tpt eq tree.tpt) => tree
-        case _ => finalize(tree, untpd.SplicedExpr(expr, tpt)(sourceFile(tree)))
+      def Splice(tree: Tree)(expr: Tree, tpt: Tree)(using Context): Splice = tree match {
+        case tree: Splice if (expr eq tree.expr) && (tpt eq tree.tpt) => tree
+        case _ => finalize(tree, untpd.Splice(expr, tpt)(sourceFile(tree)))
       }
       def SingletonTypeTree(tree: Tree)(ref: Tree)(using Context): SingletonTypeTree = tree match {
         case tree: SingletonTypeTree if (ref eq tree.ref) => tree
@@ -1383,8 +1383,8 @@ object Trees {
         TypeDef(tree: Tree)(name, rhs)
       def Template(tree: Template)(using Context)(constr: DefDef = tree.constr, parents: List[Tree] = tree.parents, derived: List[untpd.Tree] = tree.derived, self: ValDef = tree.self, body: LazyTreeList = tree.unforcedBody): Template =
         Template(tree: Tree)(constr, parents, derived, self, body)
-      def SplicedExpr(tree: SplicedExpr)(expr: Tree = tree.expr, tpt: Tree = tree.tpt)(using Context): SplicedExpr =
-        SplicedExpr(tree: Tree)(expr, tpt)
+      def Splice(tree: Splice)(expr: Tree = tree.expr, tpt: Tree = tree.tpt)(using Context): Splice =
+        Splice(tree: Tree)(expr, tpt)
       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)
 
@@ -1517,10 +1517,10 @@ object Trees {
             case Thicket(trees) =>
               val trees1 = transform(trees)
               if (trees1 eq trees) tree else Thicket(trees1)
-            case tree @ QuotedExpr(expr, tpt) =>
-              cpy.QuotedExpr(tree)(transform(expr), transform(tpt))
-            case tree @ SplicedExpr(expr, tpt) =>
-              cpy.SplicedExpr(tree)(transform(expr), transform(tpt))
+            case tree @ Quote(expr, tpt) =>
+              cpy.Quote(tree)(transform(expr), transform(tpt))
+            case tree @ Splice(expr, tpt) =>
+              cpy.Splice(tree)(transform(expr), transform(tpt))
             case tree @ Hole(_, _, args, content, tpt) =>
               cpy.Hole(tree)(args = transform(args), content = transform(content), tpt = transform(tpt))
             case _ =>
@@ -1662,9 +1662,9 @@ object Trees {
               this(this(x, arg), annot)
             case Thicket(ts) =>
               this(x, ts)
-            case QuotedExpr(expr, tpt) =>
+            case Quote(expr, tpt) =>
               this(this(x, expr), tpt)
-            case SplicedExpr(expr, tpt) =>
+            case Splice(expr, tpt) =>
               this(this(x, expr), tpt)
             case Hole(_, _, args, content, tpt) =>
               this(this(this(x, args), content), tpt)
diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
index 50b288f6ddc1..66c0bedc12c3 100644
--- a/compiler/src/dotty/tools/dotc/ast/tpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -170,11 +170,11 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def Inlined(call: Tree, bindings: List[MemberDef], expansion: Tree)(using Context): Inlined =
     ta.assignType(untpd.Inlined(call, bindings, expansion), bindings, expansion)
 
-  def QuotedExpr(expr: Tree, tpt: Tree)(using Context): QuotedExpr =
-    ta.assignType(untpd.QuotedExpr(expr, tpt), tpt)
+  def Quote(expr: Tree, tpt: Tree)(using Context): Quote =
+    ta.assignType(untpd.Quote(expr, tpt), tpt)
 
-  def SplicedExpr(expr: Tree, tpt: Tree)(using Context): SplicedExpr =
-    ta.assignType(untpd.SplicedExpr(expr, tpt), tpt)
+  def Splice(expr: Tree, tpt: Tree)(using Context): Splice =
+    ta.assignType(untpd.Splice(expr, tpt), tpt)
 
   def TypeTree(tp: Type, inferred: Boolean = false)(using Context): TypeTree =
     (if inferred then untpd.InferredTypeTree() else untpd.TypeTree()).withType(tp)
diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
index b9f5bb751862..45b2fcd49595 100644
--- a/compiler/src/dotty/tools/dotc/ast/untpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -397,8 +397,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   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 QuotedExpr(expr: Tree, tpt: Tree)(implicit src: SourceFile): QuotedExpr = new QuotedExpr(expr, tpt)
-  def SplicedExpr(expr: Tree, tpt: Tree)(implicit src: SourceFile): SplicedExpr = new SplicedExpr(expr, tpt)
+  def Quote(expr: Tree, tpt: Tree)(implicit src: SourceFile): Quote = new Quote(expr, tpt)
+  def Splice(expr: Tree, tpt: Tree)(implicit src: SourceFile): Splice = new Splice(expr, tpt)
   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)
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
index f41d3b57f8f0..864004a3e5ec 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -665,7 +665,7 @@ class TreePickler(pickler: TastyPickler) {
               pickleTree(hi)
               pickleTree(alias)
           }
-        case QuotedExpr(expr, tpt) =>
+        case Quote(expr, tpt) =>
           pickleTree(
             // scala.quoted.runtime.Expr.quoted[<tpt>](<expr>)
             ref(defn.QuotedRuntime_exprQuote)
@@ -673,7 +673,7 @@ class TreePickler(pickler: TastyPickler) {
               .appliedTo(expr)
               .withSpan(tree.span)
           )
-        case SplicedExpr(expr, tpt) =>
+        case Splice(expr, tpt) =>
           pickleTree(
             // scala.quoted.runtime.Expr.splice[<tpt>](<spliced>)
             ref(defn.QuotedRuntime_exprSplice)
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
index 153fc7b3922d..79d2008eb698 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
@@ -1269,16 +1269,16 @@ class TreeUnpickler(reader: TastyReader,
 
       def quotedExpr(fn: Tree, args: List[Tree]): Tree =
         val TypeApply(_, targs) = fn: @unchecked
-        QuotedExpr(args.head, targs.head)
+        Quote(args.head, targs.head)
 
       def splicedExpr(fn: Tree, args: List[Tree]): Tree =
         val TypeApply(_, targs) = fn: @unchecked
-        SplicedExpr(args.head, targs.head)
+        Splice(args.head, targs.head)
 
       def nestedSpliceExpr(fn: Tree, args: List[Tree]): Tree =
         fn match
           case Apply(TypeApply(_, targs), _ :: Nil) => // nestedSplice[T](quotes)(expr)
-            SplicedExpr(args.head, targs.head)
+            Splice(args.head, targs.head)
           case _ => // nestedSplice[T](quotes)
             tpd.Apply(fn, args)
 
diff --git a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
index c03e86970d90..e2fd4c6688c1 100644
--- a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
@@ -825,16 +825,16 @@ class Inliner(val call: tpd.Tree)(using Context):
         ctx.compilationUnit.needsStaging = true
       tree1
 
-    override def typedQuotedExpr(tree: untpd.QuotedExpr, pt: Type)(using Context): Tree =
-      super.typedQuotedExpr(tree, pt) match
-        case QuotedExpr(SplicedExpr(inner, _), _) => inner
+    override def typedQuote(tree: untpd.Quote, pt: Type)(using Context): Tree =
+      super.typedQuote(tree, pt) match
+        case Quote(Splice(inner, _), _) => inner
         case tree1 =>
           ctx.compilationUnit.needsStaging = true
           tree1
 
-    override def typedSplicedExpr(tree: untpd.SplicedExpr, pt: Type)(using Context): Tree =
-      super.typedSplicedExpr(tree, pt) match
-        case tree1 @ SplicedExpr(expr, tpt)
+    override def typedSplice(tree: untpd.Splice, pt: Type)(using Context): Tree =
+      super.typedSplice(tree, pt) match
+        case tree1 @ Splice(expr, tpt)
             if StagingLevel.level == 0
             && !hasInliningErrors =>
           val expanded = expandMacro(expr, tree1.srcPos)
@@ -1070,7 +1070,7 @@ class Inliner(val call: tpd.Tree)(using Context):
         else tree match {
           case tree: RefTree if tree.isTerm && tree.symbol.isDefinedInCurrentRun && !tree.symbol.isLocal =>
             foldOver(tree.symbol :: syms, tree)
-          case QuotedExpr(body, _) =>
+          case Quote(body, _) =>
             level += 1
             try apply(syms, body)
             finally level -= 1
@@ -1078,7 +1078,7 @@ class Inliner(val call: tpd.Tree)(using Context):
             level += 1
             try apply(syms, body)
             finally level -= 1
-          case SplicedExpr(body, _) =>
+          case Splice(body, _) =>
             level -= 1
             try apply(syms, body)
             finally level += 1
diff --git a/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala b/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
index b94b76316b1b..11d4d9881230 100644
--- a/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
@@ -91,9 +91,9 @@ object PrepareInlineable {
         }
 
       private def stagingContext(tree: Tree)(using Context): Context = tree match
-        case tree: QuotedExpr => StagingLevel.quoteContext
+        case tree: Quote => StagingLevel.quoteContext
         case tree: Apply if tree.symbol eq defn.QuotedTypeModule_of => StagingLevel.quoteContext
-        case tree: SplicedExpr => StagingLevel.spliceContext
+        case tree: Splice => StagingLevel.spliceContext
         case _ => ctx
     }
 
@@ -291,7 +291,7 @@ object PrepareInlineable {
     if (inlined.is(Macro) && !ctx.isAfterTyper) {
 
       def checkMacro(tree: Tree): Unit = tree match {
-        case SplicedExpr(code, _) =>
+        case Splice(code, _) =>
           if (code.symbol.flags.is(Inline))
             report.error("Macro cannot be implemented with an `inline` method", code.srcPos)
           Splicer.checkValidMacroBody(code)
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 8fa5fe54bc28..c2e2e4466d98 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -1262,7 +1262,7 @@ object Parsers {
               }
             }
             in.nextToken()
-            QuotedExpr(t, EmptyTree)
+            Quote(t, EmptyTree)
           }
           else
             if !in.featureEnabled(Feature.symbolLiterals) then
@@ -1764,7 +1764,7 @@ object Parsers {
           syntaxError(em"$msg\n\nHint: $hint", Span(start, in.lastOffset))
           Ident(nme.ERROR.toTypeName)
         else
-          SplicedExpr(expr, EmptyTree)
+          Splice(expr, EmptyTree)
       }
 
     /**  SimpleType      ::=  SimpleLiteral
@@ -2497,7 +2497,7 @@ object Parsers {
               val expr =
                 if (in.token == LBRACKET) inBrackets(typ())
                 else stagedBlock()
-              QuotedExpr(expr, EmptyTree)
+              Quote(expr, EmptyTree)
             }
           }
         case NEW =>
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index 5b8b367e21be..b2b9196b0a13 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -716,10 +716,10 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         "Thicket {" ~~ toTextGlobal(trees, "\n") ~~ "}"
       case MacroTree(call) =>
         keywordStr("macro ") ~ toTextGlobal(call)
-      case QuotedExpr(expr, tpt) =>
+      case Quote(expr, tpt) =>
         val tptText = (keywordStr("[") ~ toTextGlobal(tpt) ~ keywordStr("]")).provided(!tpt.isEmpty && printDebug)
         keywordStr("'") ~ tptText ~ keywordStr("{") ~ toTextGlobal(expr) ~ keywordStr("}")
-      case SplicedExpr(expr, tpt) =>
+      case Splice(expr, tpt) =>
         val tptText = (keywordStr("[") ~ toTextGlobal(tpt) ~ keywordStr("]")).provided(!tpt.isEmpty && printDebug)
         keywordStr("$") ~ tptText ~ keywordStr("{") ~ toTextGlobal(expr) ~ keywordStr("}")
       case Hole(isTermHole, idx, args, content, tpt) =>
diff --git a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
index 512e5ab6ab4c..748b053d7eaa 100644
--- a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
+++ b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
@@ -97,14 +97,14 @@ class CrossStageSafety extends TreeMapWithStages {
     }
 
   /** Transform quoted trees while maintaining level correctness */
-  override protected def transformQuotedExpr(body: Tree, quote: QuotedExpr)(using Context): Tree = {
+  override protected def transformQuote(body: Tree, quote: Quote)(using Context): Tree = {
     if (ctx.property(InAnnotation).isDefined)
       report.error("Cannot have a quote in an annotation", quote.srcPos)
     val transformedBody = transformQuoteBody(body, quote.span)
     val stripAnnotsDeep: TypeMap = new TypeMap:
       def apply(tp: Type): Type = mapOver(tp.stripAnnots)
     val tpt1 = TypeTree(healType(quote.tpt.srcPos)(stripAnnotsDeep(quote.tpt.tpe)))
-    cpy.QuotedExpr(quote)(transformedBody, tpt1)
+    cpy.Quote(quote)(transformedBody, tpt1)
   }
 
   override protected def transformQuotedType(body: Tree, quote: Apply)(using Context): Tree = {
@@ -142,7 +142,7 @@ class CrossStageSafety extends TreeMapWithStages {
    *  - 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: SplicedExpr)(using Context): Tree = {
+  protected def transformSplice(body: Tree, splice: Splice)(using Context): Tree = {
     val body1 = transform(body)(using spliceContext)
     val tpt1 =
       if level == 0 then
@@ -150,7 +150,7 @@ class CrossStageSafety extends TreeMapWithStages {
       else
         val tp = healType(splice.srcPos)(splice.tpe.widenTermRefExpr)
         TypeTree(tp).withSpan(splice.tpt.span)
-    cpy.SplicedExpr(splice)(body1, tpt1)
+    cpy.Splice(splice)(body1, tpt1)
   }
 
   protected def transformSpliceType(body: Tree, splice: Select)(using Context): Tree = {
diff --git a/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala b/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
index 1ed6d4c37e19..a292b4b079be 100644
--- a/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
+++ b/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
@@ -25,8 +25,8 @@ abstract class TreeMapWithStages extends TreeMapWithImplicits {
    *
    *  - `quoted.runtime.Expr.quote[T](<body0>)`  --> `quoted.runtime.Expr.quote[T](<body>)`
    */
-  protected def transformQuotedExpr(body: Tree, quote: QuotedExpr)(using Context): Tree =
-    cpy.QuotedExpr(quote)(body, quote.tpt)
+  protected def transformQuote(body: Tree, quote: Quote)(using Context): Tree =
+    cpy.Quote(quote)(body, quote.tpt)
 
   /** Transform the quote `quote` which contains the quoted `body`.
    *
@@ -37,7 +37,7 @@ abstract class TreeMapWithStages extends TreeMapWithImplicits {
     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: SplicedExpr)(using Context): Tree
+  protected def transformSplice(body: Tree, splice: Splice)(using Context): Tree
 
   /** Transform the type splice `splice` which contains the spliced `body`. */
   protected def transformSpliceType(body: Tree, splice: Select)(using Context): Tree
@@ -62,24 +62,24 @@ abstract class TreeMapWithStages extends TreeMapWithImplicits {
           try transformQuotedType(quotedTree, tree)
           finally inQuoteOrSplice = old
 
-        case tree @ QuotedExpr(quotedTree, _) =>
+        case tree @ Quote(quotedTree, _) =>
           val old = inQuoteOrSplice
           inQuoteOrSplice = true
           try dropEmptyBlocks(quotedTree) match {
-            case SplicedExpr(t, _) =>
+            case Splice(t, _) =>
               // Optimization: `'{ $x }` --> `x`
               // and adapt the refinement of `Quotes { type reflect: ... } ?=> Expr[T]`
               transform(t).asInstance(tree.tpe)
             case _ =>
-              transformQuotedExpr(quotedTree, tree)
+              transformQuote(quotedTree, tree)
           }
           finally inQuoteOrSplice = old
 
-        case tree @ SplicedExpr(splicedTree, _) =>
+        case tree @ Splice(splicedTree, _) =>
           val old = inQuoteOrSplice
           inQuoteOrSplice = true
           try dropEmptyBlocks(splicedTree) match {
-            case QuotedExpr(t, _) =>
+            case Quote(t, _) =>
               // Optimization: `${ 'x }` --> `x`
               transform(t)
             case _ =>
diff --git a/compiler/src/dotty/tools/dotc/transform/ElimByName.scala b/compiler/src/dotty/tools/dotc/transform/ElimByName.scala
index 6e264385fd3e..976df4f436f7 100644
--- a/compiler/src/dotty/tools/dotc/transform/ElimByName.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ElimByName.scala
@@ -160,9 +160,9 @@ class ElimByName extends MiniPhase, InfoTransformer:
     }
 
   override def transformOther(tree: Tree)(using Context): Tree = tree match
-    case tree @ SplicedExpr(spliced, tpt) =>
+    case tree @ Splice(spliced, tpt) =>
       assert(dotty.tools.dotc.inlines.Inlines.inInlineMethod)
-      cpy.SplicedExpr(tree)(transformAllDeep(spliced), tpt)
+      cpy.Splice(tree)(transformAllDeep(spliced), tpt)
     case tree => tree
 
 object ElimByName:
diff --git a/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala b/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala
index cad54982d10d..9d874bf6b00f 100644
--- a/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala
+++ b/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala
@@ -153,9 +153,9 @@ class FirstTransform extends MiniPhase with InfoTransformer { thisPhase =>
   override def transformOther(tree: Tree)(using Context): Tree = tree match {
     case tree: Export => EmptyTree
     case tree: NamedArg => transformAllDeep(tree.arg)
-    case tree @ SplicedExpr(expr, tpt) =>
+    case tree @ Splice(expr, tpt) =>
       assert(dotty.tools.dotc.inlines.Inlines.inInlineMethod)
-      cpy.SplicedExpr(tree)(transformAllDeep(expr), transformAllDeep(tpt))
+      cpy.Splice(tree)(transformAllDeep(expr), transformAllDeep(tpt))
     case tree => if (tree.isType) toTypeTree(tree) else tree
   }
 
diff --git a/compiler/src/dotty/tools/dotc/transform/Inlining.scala b/compiler/src/dotty/tools/dotc/transform/Inlining.scala
index 341633e30960..60714d273bf0 100644
--- a/compiler/src/dotty/tools/dotc/transform/Inlining.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Inlining.scala
@@ -45,11 +45,11 @@ class Inlining extends MacroTransform {
         new TreeTraverser {
           def traverse(tree: Tree)(using Context): Unit =
             tree match
-              case _: QuotedExpr =>
+              case _: Quote =>
                 traverseChildren(tree)(using StagingLevel.quoteContext)
               case _: GenericApply if tree.symbol == defn.QuotedTypeModule_of =>
                 traverseChildren(tree)(using StagingLevel.quoteContext)
-              case _: SplicedExpr =>
+              case _: Splice =>
                 traverseChildren(tree)(using StagingLevel.spliceContext)
               case tree: RefTree if !Inlines.inInlineMethod && StagingLevel.level == 0 =>
                 assert(!tree.symbol.isInlineMethod, tree.show)
@@ -99,11 +99,11 @@ class Inlining extends MacroTransform {
           val tree1 = super.transform(tree)
           if tree1.tpe.isError then tree1
           else Inlines.inlineCall(tree1)
-        case _: QuotedExpr =>
+        case _: Quote =>
           super.transform(tree)(using StagingLevel.quoteContext)
         case _: GenericApply if tree.symbol == defn.QuotedTypeModule_of =>
           super.transform(tree)(using StagingLevel.quoteContext)
-        case _: SplicedExpr =>
+        case _: Splice =>
           super.transform(tree)(using StagingLevel.spliceContext)
         case _: PackageDef =>
           super.transform(tree) match
diff --git a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
index c020a53e7fdf..c60562baaa7f 100644
--- a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
@@ -83,9 +83,9 @@ class PickleQuotes extends MacroTransform {
 
   override def checkPostCondition(tree: Tree)(using Context): Unit =
     tree match
-      case tree: QuotedExpr =>
+      case tree: Quote =>
         assert(Inlines.inInlineMethod)
-      case tree: SplicedExpr =>
+      case tree: Splice =>
         assert(Inlines.inInlineMethod)
       case tree: RefTree if !Inlines.inInlineMethod =>
         assert(tree.symbol != defn.QuotedTypeModule_of)
@@ -100,7 +100,7 @@ class PickleQuotes extends MacroTransform {
   protected def newTransformer(using Context): Transformer = new Transformer {
     override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
       tree match
-        case Apply(Select(QuotedExpr(expr, tpt), nme.apply), List(quotes)) =>
+        case Apply(Select(Quote(expr, tpt), nme.apply), List(quotes)) =>
           val (contents, codeWithHoles) = makeHoles(expr)
           val sourceRef = Inlines.inlineCallTrace(ctx.owner, tree.sourcePos)
           val codeWithHoles2 = Inlined(sourceRef, Nil, codeWithHoles)
diff --git a/compiler/src/dotty/tools/dotc/transform/PostTyper.scala b/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
index 5cfa74fd5610..eac9a8d70654 100644
--- a/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
@@ -485,7 +485,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
           )
         case Block(_, Closure(_, _, tpt)) if ExpandSAMs.needsWrapperClass(tpt.tpe) =>
           superAcc.withInvalidCurrentClass(super.transform(tree))
-        case QuotedExpr(expr, _) =>
+        case Quote(expr, _) =>
           ctx.compilationUnit.needsStaging = true
           super.transform(tree)
         case tree =>
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicer.scala b/compiler/src/dotty/tools/dotc/transform/Splicer.scala
index 2e6549bc8ec8..4b6d434d80b0 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicer.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicer.scala
@@ -44,7 +44,7 @@ object Splicer {
    *  See: `Staging`
    */
   def splice(tree: Tree, splicePos: SrcPos, spliceExpansionPos: SrcPos, classLoader: ClassLoader)(using Context): Tree = tree match {
-    case QuotedExpr(quotedTree, _) => quotedTree
+    case Quote(quotedTree, _) => quotedTree
     case _ =>
       val macroOwner = newSymbol(ctx.owner, nme.MACROkw, Macro | Synthetic, defn.AnyType, coord = tree.span)
       try
@@ -136,7 +136,7 @@ object Splicer {
     *  See: `Staging`
     */
   def checkValidMacroBody(tree: Tree)(using Context): Unit = tree match {
-    case QuotedExpr(_, _) => // ok
+    case Quote(_, _) => // ok
     case _ =>
       type Env = Set[Symbol]
 
@@ -155,10 +155,10 @@ object Splicer {
         case Block(Nil, expr) => checkIfValidArgument(expr)
         case Typed(expr, _) => checkIfValidArgument(expr)
 
-        case Apply(Select(QuotedExpr(expr, tpt), nme.apply), _) =>
+        case Apply(Select(Quote(expr, tpt), nme.apply), _) =>
           val noSpliceChecker = new TreeTraverser {
             def traverse(tree: Tree)(using Context): Unit = tree match
-              case SplicedExpr(_, _) =>
+              case Splice(_, _) =>
                 report.error("Quoted argument of macros may not have splices", tree.srcPos)
               case _ =>
                 traverseChildren(tree)
@@ -203,7 +203,7 @@ object Splicer {
         case Typed(expr, _) =>
           checkIfValidStaticCall(expr)
 
-        case Apply(Select(QuotedExpr(quoted, tpt), nme.apply), _) =>
+        case Apply(Select(Quote(quoted, tpt), nme.apply), _) =>
           // OK, canceled and warning emitted
 
         case Call(fn, args)
@@ -240,7 +240,7 @@ object Splicer {
 
     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(QuotedExpr(expr, _), nme.apply), _) =>
+      case Apply(Select(Quote(expr, _), nme.apply), _) =>
         val expr1 = expr match {
           case expr: Ident if expr.symbol.isAllOf(InlineByNameProxy) =>
             // inline proxy for by-name parameter
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicing.scala b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
index ca3acb6b8fac..af77588419b5 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicing.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
@@ -86,7 +86,7 @@ class Splicing extends MacroTransform:
     override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
       assert(level == 0)
       tree match
-        case Apply(Select(QuotedExpr(expr, _), nme.apply),List(quotes)) =>
+        case Apply(Select(Quote(expr, _), nme.apply),List(quotes)) =>
           QuoteTransformer().transform(tree)
         case TypeApply(_, _) if tree.symbol == defn.QuotedTypeModule_of =>
           QuoteTransformer().transform(tree)
@@ -111,10 +111,10 @@ class Splicing extends MacroTransform:
 
     override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
       tree match
-        case tree: SplicedExpr =>
+        case tree: Splice =>
           if level > 1 then
             val expr1 = super.transform(tree.expr)(using spliceContext)
-            cpy.SplicedExpr(tree)(expr1, tree.tpt)
+            cpy.Splice(tree)(expr1, tree.tpt)
           else
             val holeIdx = numHoles
             numHoles += 1
@@ -134,7 +134,7 @@ class Splicing extends MacroTransform:
               typeHoles.put(qual, hole)
               hole
           cpy.TypeDef(tree)(rhs = hole)
-        case Apply(Select(QuotedExpr(expr, tpt), nme.apply),List(quotes)) =>
+        case Apply(Select(Quote(expr, tpt), nme.apply),List(quotes)) =>
           super.transform(tree)(using quoteContext)
         case _: Template =>
           for sym <- tree.symbol.owner.info.decls do
@@ -234,10 +234,10 @@ class Splicing extends MacroTransform:
         case tree @ Assign(lhs: RefTree, rhs) =>
           if isCaptured(lhs.symbol) then transformSplicedAssign(tree)
           else super.transform(tree)
-        case SplicedExpr(expr, tpt) =>
+        case Splice(expr, tpt) =>
           val expr1 = transform(expr)(using spliceContext)
-          cpy.SplicedExpr(tree)(expr1, tpt)
-        case Apply(sel @ Select(app @ QuotedExpr(expr, tpt), nme.apply), quotesArgs) =>
+          cpy.Splice(tree)(expr1, tpt)
+        case Apply(sel @ Select(app @ Quote(expr, tpt), nme.apply), quotesArgs) =>
           expr match
             case expr: RefTree if isCaptured(expr.symbol) =>
               capturedTerm(expr)
@@ -246,7 +246,7 @@ class Splicing extends MacroTransform:
                 if level > 1 then transform(expr)(using quoteContext)
                 else transformLevel0QuoteContent(expr)(using quoteContext)
               }
-              cpy.Apply(tree)(cpy.Select(sel)(cpy.QuotedExpr(app)(newExpr, tpt), nme.apply), quotesArgs)
+              cpy.Apply(tree)(cpy.Select(sel)(cpy.Quote(app)(newExpr, tpt), nme.apply), quotesArgs)
         case Apply(TypeApply(typeof, List(tpt)), List(quotes))
         if tree.symbol == defn.QuotedTypeModule_of && containsCapturedType(tpt.tpe) =>
           val newContent = capturedPartTypes(tpt)
@@ -409,10 +409,10 @@ class Splicing extends MacroTransform:
             body(using ctx.withOwner(meth)).changeOwner(ctx.owner, meth)
           }
         })
-      SplicedExpr(closure, TypeTree(tpe))
+      Splice(closure, TypeTree(tpe))
 
     private def quoted(expr: Tree)(using Context): Tree =
-      QuotedExpr(expr, TypeTree(expr.tpe.widenTermRefExpr))
+      Quote(expr, TypeTree(expr.tpe.widenTermRefExpr))
         .select(nme.apply)
         .appliedTo(quotes.nn)
 
diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index f7518ec8b9f5..23c851a33408 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -312,7 +312,7 @@ object SpaceEngine {
   def isIrrefutableQuotedPattern(unapp: tpd.Tree, implicits: List[tpd.Tree], pt: Type)(using Context): Boolean = {
     implicits.headOption match
       // pattern '{ $x: T }
-      case Some(tpd.Apply(tpd.Select(tpd.QuotedExpr(tpd.TypeApply(fn, List(tpt)), _), nme.apply), _))
+      case Some(tpd.Apply(tpd.Select(tpd.Quote(tpd.TypeApply(fn, List(tpt)), _), nme.apply), _))
           if unapp.symbol.owner.eq(defn.QuoteMatching_ExprMatchModule)
           && fn.symbol.eq(defn.QuotedRuntimePatterns_patternHole) =>
         pt <:< defn.QuotedExprClass.typeRef.appliedTo(tpt.tpe)
diff --git a/compiler/src/dotty/tools/dotc/typer/Applications.scala b/compiler/src/dotty/tools/dotc/typer/Applications.scala
index 77c9eb519db1..79d6501ccb2d 100644
--- a/compiler/src/dotty/tools/dotc/typer/Applications.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Applications.scala
@@ -1097,7 +1097,7 @@ trait Applications extends Compatibility {
         }
       else {
         val app = tree.fun match
-          case _: untpd.SplicedExpr if ctx.mode.is(Mode.QuotedPattern) => typedAppliedSplice(tree, pt)
+          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 =>
diff --git a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
index d47c7abf3fc3..9ec4a8648695 100644
--- a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
+++ b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
@@ -31,15 +31,15 @@ trait QuotesAndSplices {
 
   import tpd._
 
-  def typedQuotedExpr(tree: untpd.QuotedExpr, pt: Type)(using Context): Tree =
+  def typedQuote(tree: untpd.Quote, pt: Type)(using Context): Tree =
     if tree.tpt.isEmpty then
       typedQuoteSyntactic(tree, pt)
     else
       val tpt1 = checkSimpleKinded(typedType(tree.tpt, mapPatternBounds = true))
       val expr1 = typed(tree.expr, tpt1.tpe.widenSkolem)(using quoteContext)
-      assignType(untpd.cpy.QuotedExpr(tree)(expr1, tpt1), tpt1)
+      assignType(untpd.cpy.Quote(tree)(expr1, tpt1), tpt1)
 
-  def typedSplicedExpr(tree: untpd.SplicedExpr, pt: Type)(using Context): Tree =
+  def typedSplice(tree: untpd.Splice, pt: Type)(using Context): Tree =
     if tree.tpt.isEmpty then
       typedSpliceSyntactic(tree, pt)
     else
@@ -48,7 +48,7 @@ trait QuotesAndSplices {
         defn.FunctionType(1, isContextual = true)
           .appliedTo(defn.QuotesClass.typeRef, defn.QuotedExprClass.typeRef.appliedTo(tpt1.tpe.widenSkolem))
       val expr1 = typed(tree.expr, splicedType)(using spliceContext)
-      assignType(untpd.cpy.SplicedExpr(tree)(expr1, tpt1), tpt1)
+      assignType(untpd.cpy.Splice(tree)(expr1, tpt1), tpt1)
 
   def typedHole(tree: untpd.Hole, pt: Type)(using Context): Tree =
     val tpt = typedType(tree.tpt)
@@ -57,10 +57,10 @@ trait QuotesAndSplices {
   /** Translate `'{ e }` into `scala.quoted.Expr.apply(e)` and `'[T]` into `scala.quoted.Type.apply[T]`
    *  while tracking the quotation level in the context.
    */
-  private def typedQuoteSyntactic(tree: untpd.QuotedExpr, pt: Type)(using Context): Tree = {
+  private def typedQuoteSyntactic(tree: untpd.Quote, pt: Type)(using Context): Tree = {
     record("typedQuote")
     tree.expr match {
-      case untpd.SplicedExpr(innerExpr, _) if tree.isTerm && !ctx.mode.is(Mode.Pattern) =>
+      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 _ =>
     }
@@ -83,7 +83,7 @@ trait QuotesAndSplices {
     else
       val exprQuoteTree = untpd.Apply(untpd.ref(defn.QuotedRuntime_exprQuote.termRef), tree.expr)
       val quotedExpr = typedApply(exprQuoteTree, pt)(using quoteContext) match
-        case Apply(TypeApply(fn, tpt :: Nil), quotedExpr :: Nil) => QuotedExpr(quotedExpr, tpt)
+        case Apply(TypeApply(fn, tpt :: Nil), quotedExpr :: Nil) => Quote(quotedExpr, tpt)
       makeInlineable(quotedExpr.select(nme.apply).appliedTo(quotes).withSpan(tree.span))
   }
 
@@ -93,11 +93,11 @@ trait QuotesAndSplices {
     }
 
   /** Translate `${ t: Expr[T] }` into expression `t.splice` while tracking the quotation level in the context */
-  private def typedSpliceSyntactic(tree: untpd.SplicedExpr, pt: Type)(using Context): Tree = {
+  private def typedSpliceSyntactic(tree: untpd.Splice, pt: Type)(using Context): Tree = {
     record("typedSplice")
     checkSpliceOutsideQuote(tree)
     tree.expr match {
-      case untpd.QuotedExpr(innerExpr, _) if innerExpr.isTerm =>
+      case untpd.Quote(innerExpr, _) if innerExpr.isTerm =>
         report.warning("Canceled quote directly inside a splice. ${ '{ XYZ } } is equivalent to XYZ.", tree.srcPos)
         return typed(innerExpr, pt)
       case _ =>
@@ -110,7 +110,7 @@ trait QuotesAndSplices {
           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
-        SplicedExpr(pat, TypeTree(argType)).withSpan(tree.span)
+        Splice(pat, TypeTree(argType)).withSpan(tree.span)
       }
       else {
         report.error(em"Type must be fully defined.\nConsider annotating the splice using a type ascription:\n  ($tree: XYZ).", tree.expr.srcPos)
@@ -132,7 +132,7 @@ trait QuotesAndSplices {
 
       typedApply(internalSplice, pt)(using spliceContext).withSpan(tree.span) match
         case tree @ Apply(TypeApply(_, tpt :: Nil), spliced :: Nil) if tree.symbol == defn.QuotedRuntime_exprSplice =>
-          cpy.SplicedExpr(tree)(spliced, tpt)
+          cpy.Splice(tree)(spliced, tpt)
         case tree => tree
     }
   }
@@ -146,7 +146,7 @@ trait QuotesAndSplices {
    */
   def typedAppliedSplice(tree: untpd.Apply, pt: Type)(using Context): Tree = {
     assert(ctx.mode.is(Mode.QuotedPattern))
-    val untpd.Apply(splice: untpd.SplicedExpr, args) = tree: @unchecked
+    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)
@@ -245,12 +245,12 @@ trait QuotesAndSplices {
       val freshTypeBindingsBuff = new mutable.ListBuffer[Tree]
       val typePatBuf = new mutable.ListBuffer[Tree]
       override def transform(tree: Tree)(using Context) = tree match {
-        case Typed(SplicedExpr(pat, _), tpt) if !tpt.tpe.derivesFrom(defn.RepeatedParamClass) =>
+        case Typed(Splice(pat, _), tpt) if !tpt.tpe.derivesFrom(defn.RepeatedParamClass) =>
           val tpt1 = transform(tpt) // Transform type bindings
           val exprTpt = AppliedTypeTree(TypeTree(defn.QuotedExprClass.typeRef), tpt1 :: Nil)
-          val newSplice = cpy.SplicedExpr(tree)(pat, tpt1)
+          val newSplice = cpy.Splice(tree)(pat, tpt1)
           transform(newSplice)
-        case Apply(TypeApply(fn, targs), SplicedExpr(pat, _) :: args :: Nil) if fn.symbol == defn.QuotedRuntimePatterns_patternHigherOrderHole =>
+        case Apply(TypeApply(fn, targs), Splice(pat, _) :: 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
@@ -262,7 +262,7 @@ trait QuotesAndSplices {
             val pat1 = if (patType eq patType1) pat else pat.withType(patType1)
             patBuf += pat1
           }
-        case SplicedExpr(pat, _) =>
+        case Splice(pat, _) =>
           try ref(defn.QuotedRuntimePatterns_patternHole.termRef).appliedToType(tree.tpe).withSpan(tree.span)
           finally {
             val patType = pat.tpe.widen
@@ -401,7 +401,7 @@ trait QuotesAndSplices {
    *        ) => ...
    *  ```
    */
-  private def typedQuotePattern(tree: untpd.QuotedExpr, pt: Type, qctx: Tree)(using Context): Tree = {
+  private def typedQuotePattern(tree: untpd.Quote, pt: Type, qctx: Tree)(using Context): Tree = {
     val quoted = tree.expr
     if quoted.isTerm && !pt.derivesFrom(defn.QuotedExprClass) then
       report.error("Quote pattern can only match scrutinees of type scala.quoted.Expr", tree.srcPos)
@@ -461,7 +461,7 @@ trait QuotesAndSplices {
 
     val quoteClass = if (quoted.isTerm) defn.QuotedExprClass else defn.QuotedTypeClass
     val quotedPattern =
-      if (quoted.isTerm) tpd.QuotedExpr(shape, TypeTree(defn.AnyType)).select(nme.apply).appliedTo(qctx)
+      if (quoted.isTerm) tpd.Quote(shape, TypeTree(defn.AnyType)).select(nme.apply).appliedTo(qctx)
       else ref(defn.QuotedTypeModule_of.termRef).appliedToTypeTree(shape).appliedTo(qctx)
 
     val matchModule = if quoted.isTerm then defn.QuoteMatching_ExprMatch else defn.QuoteMatching_TypeMatch
diff --git a/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala b/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
index 9fe679a0583b..fc51af646b17 100644
--- a/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
+++ b/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
@@ -392,13 +392,13 @@ trait TypeAssigner {
   def assignType(tree: untpd.Inlined, bindings: List[Tree], expansion: Tree)(using Context): Inlined =
     tree.withType(avoidingType(expansion, bindings))
 
-  def assignType(tree: untpd.QuotedExpr, tpt: Tree)(using Context): QuotedExpr =
+  def assignType(tree: untpd.Quote, tpt: Tree)(using Context): Quote =
     val lambdaType = // Quotes ?=> Expr[T]
       defn.FunctionType(1, isContextual = true)
         .appliedTo(defn.QuotesClass.typeRef, defn.QuotedExprClass.typeRef.appliedTo(tpt.tpe))
     tree.withType(lambdaType)
 
-  def assignType(tree: untpd.SplicedExpr, tpt: Tree)(using Context): SplicedExpr =
+  def assignType(tree: untpd.Splice, tpt: Tree)(using Context): Splice =
     tree.withType(tpt.tpe)
 
   def assignType(tree: untpd.If, thenp: Tree, elsep: Tree)(using Context): If =
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index aa0243146241..4bc012b5b226 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -3075,8 +3075,8 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           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.QuotedExpr => typedQuotedExpr(tree, pt)
-          case tree: untpd.SplicedExpr => typedSplicedExpr(tree, pt)
+          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)

From 76d0daf885f10041bbf9ee8bea89dcb089fa817e Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 25 Apr 2023 13:25:50 +0200
Subject: [PATCH 410/657] Add documentation

---
 compiler/src/dotty/tools/dotc/ast/Trees.scala | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala
index 65a0cd6ba710..546e55ee22e3 100644
--- a/compiler/src/dotty/tools/dotc/ast/Trees.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala
@@ -677,11 +677,23 @@ object Trees {
     override def isType = expansion.isType
   }
 
+  /** A tree representing a quote `'{ expr }
+   *
+   *  @param  expr  The tree that was quoted
+   *  @param  tpt   The type of the tree that was quoted,
+   *                EmptyTree if this tree comes from the parser.
+   */
   case class Quote[+T <: Untyped] private[ast] (expr: Tree[T], tpt: Tree[T])(implicit @constructorOnly src: SourceFile)
     extends TermTree[T] {
     type ThisTree[+T <: Untyped] = Quote[T]
   }
 
+  /** A tree representing a splice `${ expr }`
+    *
+    * @param expr The tree that was spliced
+    * @param tpt  The type of the tree that was spliced,
+    *             EmptyTree if this tree comes from the parser.
+    */
   case class Splice[+T <: Untyped] private[ast] (expr: Tree[T], tpt: Tree[T])(implicit @constructorOnly src: SourceFile)
     extends TermTree[T] {
     type ThisTree[+T <: Untyped] = Splice[T]

From 75bacdbadf9ecc9db4c39223e05669e0a329b526 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 25 Apr 2023 13:37:10 +0200
Subject: [PATCH 411/657] Backwards compatibility support for quotes and splice
 in reflection API

---
 .../quoted/runtime/impl/QuotesImpl.scala      | 23 ++++++++++++++++---
 tests/run-staging/multi-staging.check         |  2 +-
 tests/run-staging/quote-nested-5.check        |  4 ++--
 3 files changed, 23 insertions(+), 6 deletions(-)

diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
index 1949304ca287..f63ef3feb041 100644
--- a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
+++ b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
@@ -609,11 +609,13 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
       end extension
     end NamedArgMethods
 
-    type Apply = tpd.Apply
+    type Apply = tpd.Apply | tpd.Quote | tpd.Splice
 
     object ApplyTypeTest extends TypeTest[Tree, Apply]:
       def unapply(x: Tree): Option[Apply & x.type] = x match
         case x: (tpd.Apply & x.type) => Some(x)
+        case x: (tpd.Quote & x.type) => Some(x) // TODO expose Quote AST in Quotes
+        case x: (tpd.Splice & x.type) => Some(x) // TODO expose Splice AST in Quotes
         case _ => None
     end ApplyTypeTest
 
@@ -630,8 +632,23 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     given ApplyMethods: ApplyMethods with
       extension (self: Apply)
-        def fun: Term = self.fun
-        def args: List[Term] = self.args
+        def fun: Term = self match
+          case self: tpd.Apply => self.fun
+          case self: tpd.Quote => // TODO expose Quote AST in Quotes
+            import dotty.tools.dotc.ast.tpd.TreeOps
+            tpd.ref(dotc.core.Symbols.defn.QuotedRuntime_exprQuote)
+              .appliedToTypeTree(self.tpt)
+              .withSpan(self.span)
+          case self: tpd.Splice => // TODO expose Splice AST in Quotes
+            import dotty.tools.dotc.ast.tpd.TreeOps
+            tpd.ref(dotc.core.Symbols.defn.QuotedRuntime_exprSplice)
+              .appliedToTypeTree(self.tpt)
+              .withSpan(self.span)
+
+        def args: List[Term] = self match
+          case self: tpd.Apply => self.args
+          case self: tpd.Quote => List(self.expr) // TODO expose Quote AST in Quotes
+          case self: tpd.Splice => List(self.expr) // TODO expose Splice AST in Quotes
       end extension
     end ApplyMethods
 
diff --git a/tests/run-staging/multi-staging.check b/tests/run-staging/multi-staging.check
index 5d12306ba4ef..76adcfec3034 100644
--- a/tests/run-staging/multi-staging.check
+++ b/tests/run-staging/multi-staging.check
@@ -1,5 +1,5 @@
 stage1 code: ((q1: scala.quoted.Quotes) ?=> {
   val x1: scala.Int = 2
-  scala.quoted.runtime.Expr.quote[scala.Int](1.+(scala.quoted.runtime.Expr.nestedSplice[scala.Int](q1)(((evidence$5: scala.quoted.Quotes) ?=> scala.quoted.Expr.apply[scala.Int](x1)(scala.quoted.ToExpr.IntToExpr[scala.Int])(evidence$5))))).apply(using q1)
+  scala.quoted.runtime.Expr.quote[scala.Int](1.+(scala.quoted.runtime.Expr.splice[scala.Int](((evidence$5: scala.quoted.Quotes) ?=> scala.quoted.Expr.apply[scala.Int](x1)(scala.quoted.ToExpr.IntToExpr[scala.Int])(evidence$5))))).apply(using q1)
 })
 3
diff --git a/tests/run-staging/quote-nested-5.check b/tests/run-staging/quote-nested-5.check
index f29acb3b347a..d5fee708c460 100644
--- a/tests/run-staging/quote-nested-5.check
+++ b/tests/run-staging/quote-nested-5.check
@@ -1,4 +1,4 @@
 ((q: scala.quoted.Quotes) ?=> {
   val a: scala.quoted.Expr[scala.Int] = scala.quoted.runtime.Expr.quote[scala.Int](4).apply(using q)
-  ((q2: scala.quoted.Quotes) ?=> ((evidence$3: scala.quoted.Quotes) ?=> a).asInstanceOf[scala.ContextFunction1[scala.quoted.Quotes, scala.quoted.Expr[scala.Int]]].apply(using q2)).apply(using q)
-})
+  ((q2: scala.quoted.Quotes) ?=> ((evidence$2: scala.quoted.Quotes) ?=> a).asInstanceOf[scala.ContextFunction1[scala.quoted.Quotes, scala.quoted.Expr[scala.Int]]].apply(using q2))
+}.apply(using q))

From 0e6dc2eee80a5aed21876355a62906a84166ffb3 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 25 Apr 2023 13:48:25 +0200
Subject: [PATCH 412/657] Add regression test

Closes #6991
---
 tests/neg-macros/i6991.check | 10 ++++++++++
 tests/neg-macros/i6991.scala | 16 ++++++++++++++++
 2 files changed, 26 insertions(+)
 create mode 100644 tests/neg-macros/i6991.check
 create mode 100644 tests/neg-macros/i6991.scala

diff --git a/tests/neg-macros/i6991.check b/tests/neg-macros/i6991.check
new file mode 100644
index 000000000000..57d611a09053
--- /dev/null
+++ b/tests/neg-macros/i6991.check
@@ -0,0 +1,10 @@
+-- [E050] Type Error: tests/neg-macros/i6991.scala:11:14 ---------------------------------------------------------------
+11 |      case '{($x: Foo)($bar: String)} => '{"Hello World"} // error
+   |              ^^^^^^^
+   |              expression does not take parameters
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E008] Not Found Error: tests/neg-macros/i6991.scala:12:23 ----------------------------------------------------------
+12 |      case '{($x: Foo).apply($bar: String)} => '{"Hello World"} // error
+   |             ^^^^^^^^^^^^^^^
+   |             value apply is not a member of macros.Foo
diff --git a/tests/neg-macros/i6991.scala b/tests/neg-macros/i6991.scala
new file mode 100644
index 000000000000..c6838261ed7a
--- /dev/null
+++ b/tests/neg-macros/i6991.scala
@@ -0,0 +1,16 @@
+import scala.quoted._
+
+object macros {
+  inline def mcr(x: => Any): Any = ${mcrImpl('x)}
+
+  class Foo // { def apply(str: String) = "100" }
+  class Bar { def apply(str: String) = "100" }
+
+  def mcrImpl(body: Expr[Any])(using ctx: Quotes): Expr[Any] = {
+    body match {
+      case '{($x: Foo)($bar: String)} => '{"Hello World"} // error
+      case '{($x: Foo).apply($bar: String)} => '{"Hello World"} // error
+      case '{($x: Bar)($bar: String)} => '{"Hello World"}
+    }
+  }
+}

From 709060952c452240201b0def95949dd333a6569b Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Tue, 25 Apr 2023 14:04:49 +0200
Subject: [PATCH 413/657] Fix compiler crash in WUnused

---
 compiler/src/dotty/tools/dotc/transform/CheckUnused.scala | 3 ++-
 tests/neg-custom-args/fatal-warnings/i17335.scala         | 4 ++++
 2 files changed, 6 insertions(+), 1 deletion(-)
 create mode 100644 tests/neg-custom-args/fatal-warnings/i17335.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index ce05e6c125de..32afe9c8a1e7 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -47,7 +47,8 @@ class CheckUnused private (phaseMode: CheckUnused.PhaseMode, suffix: String, _ke
 
   override def isRunnable(using Context): Boolean =
     ctx.settings.Wunused.value.nonEmpty &&
-    !ctx.isJava
+    !ctx.isJava &&
+    super.isRunnable
 
   // ========== SETUP ============
 
diff --git a/tests/neg-custom-args/fatal-warnings/i17335.scala b/tests/neg-custom-args/fatal-warnings/i17335.scala
new file mode 100644
index 000000000000..6629e2f151c9
--- /dev/null
+++ b/tests/neg-custom-args/fatal-warnings/i17335.scala
@@ -0,0 +1,4 @@
+// scalac: -Wunused:all
+
+def aMethod() =
+  doStuff { (x) => x } // error

From 8cbde30aa634d52c3e3bfb4104df224a19405e85 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Tue, 25 Apr 2023 14:12:56 +0200
Subject: [PATCH 414/657] Change the order of checks

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

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index 32afe9c8a1e7..371df57045b4 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -46,9 +46,9 @@ class CheckUnused private (phaseMode: CheckUnused.PhaseMode, suffix: String, _ke
   override def description: String = CheckUnused.description
 
   override def isRunnable(using Context): Boolean =
+    super.isRunnable &&
     ctx.settings.Wunused.value.nonEmpty &&
-    !ctx.isJava &&
-    super.isRunnable
+    !ctx.isJava
 
   // ========== SETUP ============
 

From aae9ec1dfbe695ae481be5d6740898d9bd54d624 Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Fri, 21 Apr 2023 01:35:46 +0200
Subject: [PATCH 415/657] Wunused: Include import selector bounds in unused
 checks

closes lampepfl#17314
---
 .../tools/dotc/transform/CheckUnused.scala    | 34 ++++++++++++-------
 .../fatal-warnings/i17314b.scala              | 14 ++++++++
 tests/pos-special/fatal-warnings/i17314.scala | 33 ++++++++++++++++++
 .../pos-special/fatal-warnings/i17314a.scala  | 12 +++++++
 4 files changed, 81 insertions(+), 12 deletions(-)
 create mode 100644 tests/neg-custom-args/fatal-warnings/i17314b.scala
 create mode 100644 tests/pos-special/fatal-warnings/i17314.scala
 create mode 100644 tests/pos-special/fatal-warnings/i17314a.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index ce05e6c125de..baef470c8e88 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -202,8 +202,11 @@ class CheckUnused private (phaseMode: CheckUnused.PhaseMode, suffix: String, _ke
     override def traverse(tree: tpd.Tree)(using Context): Unit =
       val newCtx = if tree.symbol.exists then ctx.withOwner(tree.symbol) else ctx
       tree match
-        case imp:tpd.Import =>
+        case imp: tpd.Import =>
           unusedDataApply(_.registerImport(imp))
+          imp.selectors.filter(_.isGiven).map(_.bound).collect {
+            case untpd.TypedSplice(tree1) => tree1
+          }.foreach(traverse(_)(using newCtx))
           traverseChildren(tree)(using newCtx)
         case ident: Ident =>
           prepareForIdent(ident)
@@ -449,13 +452,12 @@ object CheckUnused:
       val used = usedInScope.pop().toSet
       // used imports in this scope
       val imports = impInScope.pop()
-      val kept = used.filterNot { t =>
-        val (sym, isAccessible, optName, isDerived) = t
+      val kept = used.filterNot { (sym, isAccessible, optName, isDerived) =>
         // keep the symbol for outer scope, if it matches **no** import
         // This is the first matching wildcard selector
         var selWildCard: Option[ImportSelector] = None
 
-        val exists = imports.exists { imp =>
+        val matchedExplicitImport = imports.exists { imp =>
           sym.isInImport(imp, isAccessible, optName, isDerived) match
             case None => false
             case optSel@Some(sel) if sel.isWildcard =>
@@ -466,11 +468,11 @@ object CheckUnused:
               unusedImport -= sel
               true
         }
-        if !exists && selWildCard.isDefined then
+        if !matchedExplicitImport && selWildCard.isDefined then
           unusedImport -= selWildCard.get
           true // a matching import exists so the symbol won't be kept for outer scope
         else
-          exists
+          matchedExplicitImport
       }
 
       // if there's an outer scope
@@ -610,12 +612,17 @@ object CheckUnused:
      * return true
      */
     private def shouldSelectorBeReported(imp: tpd.Import, sel: ImportSelector)(using Context): Boolean =
-      if ctx.settings.WunusedHas.strictNoImplicitWarn then
+      ctx.settings.WunusedHas.strictNoImplicitWarn && (
         sel.isWildcard ||
         imp.expr.tpe.member(sel.name.toTermName).alternatives.exists(_.symbol.isOneOf(GivenOrImplicit)) ||
         imp.expr.tpe.member(sel.name.toTypeName).alternatives.exists(_.symbol.isOneOf(GivenOrImplicit))
-      else
-        false
+      )
+
+    extension (tree: ImportSelector)
+      def boundTpe: Type = tree.bound match {
+        case untpd.TypedSplice(tree1) => tree1.tpe
+        case _ => NoType
+      }
 
     extension (sym: Symbol)
       /** is accessible without import in current context */
@@ -628,7 +635,7 @@ object CheckUnused:
                 && c.owner.thisType.member(sym.name).alternatives.contains(sym)
           }
 
-      /** Given an import and accessibility, return an option of selector that match import<->symbol */
+      /** Given an import and accessibility, return selector that matches import<->symbol */
       private def isInImport(imp: tpd.Import, isAccessible: Boolean, symName: Option[Name], isDerived: Boolean)(using Context): Option[ImportSelector] =
         val tpd.Import(qual, sels) = imp
         val dealiasedSym = dealias(sym)
@@ -641,9 +648,12 @@ object CheckUnused:
         def dealiasedSelector = if(isDerived) sels.flatMap(sel => selectionsToDealias.map(m => (sel, m.symbol))).collect {
           case (sel, sym) if dealias(sym) == dealiasedSym => sel
         }.headOption else None
-        def wildcard = sels.find(sel => sel.isWildcard && ((sym.is(Given) == sel.isGiven) || sym.is(Implicit)))
+        def givenSelector = if sym.is(Given) || sym.is(Implicit)
+          then sels.filter(sel => sel.isGiven && !sel.bound.isEmpty).find(sel => sel.boundTpe =:= sym.info)
+          else None
+        def wildcard = sels.find(sel => sel.isWildcard && ((sym.is(Given) == sel.isGiven && sel.bound.isEmpty) || sym.is(Implicit)))
         if qualHasSymbol && (!isAccessible || sym.isRenamedSymbol(symName)) && sym.exists then
-          selector.orElse(dealiasedSelector).orElse(wildcard) // selector with name or wildcard (or given)
+          selector.orElse(dealiasedSelector).orElse(givenSelector).orElse(wildcard) // selector with name or wildcard (or given)
         else
           None
 
diff --git a/tests/neg-custom-args/fatal-warnings/i17314b.scala b/tests/neg-custom-args/fatal-warnings/i17314b.scala
new file mode 100644
index 000000000000..384767765cf4
--- /dev/null
+++ b/tests/neg-custom-args/fatal-warnings/i17314b.scala
@@ -0,0 +1,14 @@
+// scalac: -Wunused:all
+
+package foo:
+  class Foo[T]
+  given Foo[Int] = new Foo[Int]
+
+
+package bar:
+  import foo.{given foo.Foo[Int]} // error
+  import foo.Foo
+
+  given Foo[Int] = ???
+
+  val repro: Foo[Int] = summon[Foo[Int]]
diff --git a/tests/pos-special/fatal-warnings/i17314.scala b/tests/pos-special/fatal-warnings/i17314.scala
new file mode 100644
index 000000000000..23f988741bed
--- /dev/null
+++ b/tests/pos-special/fatal-warnings/i17314.scala
@@ -0,0 +1,33 @@
+// scalac: "-Wunused:all"
+
+import java.net.URI
+
+object circelike {
+  import scala.compiletime.summonInline
+  import scala.deriving.Mirror
+
+  type Codec[T]
+  type Configuration
+  trait ConfiguredCodec[T]
+  object ConfiguredCodec:
+    inline final def derived[A](using conf: Configuration)(using
+      inline mirror: Mirror.Of[A]
+    ): ConfiguredCodec[A] =
+      new ConfiguredCodec[A]:
+        val codec = summonInline[Codec[URI]] // simplification
+}
+
+object foo {
+  import circelike.{Codec, Configuration}
+
+  given Configuration = ???
+  given Codec[URI] = ???
+}
+
+object bar {
+  import circelike.Codec
+  import circelike.{Configuration, ConfiguredCodec}
+  import foo.{given Configuration, given Codec[URI]}
+
+  case class Operator(url: URI) derives ConfiguredCodec
+}
diff --git a/tests/pos-special/fatal-warnings/i17314a.scala b/tests/pos-special/fatal-warnings/i17314a.scala
new file mode 100644
index 000000000000..468b956fb04c
--- /dev/null
+++ b/tests/pos-special/fatal-warnings/i17314a.scala
@@ -0,0 +1,12 @@
+// scalac: -Wunused:all
+
+package foo:
+  class Foo[T]
+  given Foo[Int] = new Foo[Int]
+
+
+package bar:
+  import foo.{given foo.Foo[Int]}
+  import foo.Foo
+
+  val repro: Foo[Int] = summon[Foo[Int]]

From cdd5ffb3f47211a8fb9805f11f76234846c1fba8 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Wed, 26 Apr 2023 08:30:13 +0200
Subject: [PATCH 416/657] Adapt REPL test output

---
 compiler/test-resources/repl-macros/i5551 | 2 +-
 compiler/test-resources/repl/i10355       | 6 ++++--
 staging/test-resources/repl-staging/i6007 | 2 +-
 3 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/compiler/test-resources/repl-macros/i5551 b/compiler/test-resources/repl-macros/i5551
index d71251e9a824..984551438b51 100644
--- a/compiler/test-resources/repl-macros/i5551
+++ b/compiler/test-resources/repl-macros/i5551
@@ -1,7 +1,7 @@
 scala> import scala.quoted._
 scala> def assertImpl(expr: Expr[Boolean])(using q: Quotes) = '{ if !($expr) then throw new AssertionError("failed assertion")}
 def assertImpl
-  (expr: quoted.Expr[Boolean])(using q: quoted.Quotes): quoted.Expr[Unit]
+  (expr: quoted.Expr[Boolean])(using q: quoted.Quotes): scala.quoted.Expr[Unit]
 scala>   inline def assert(expr: => Boolean): Unit =  ${ assertImpl('{expr}) }
 def assert(expr: => Boolean): Unit
 
diff --git a/compiler/test-resources/repl/i10355 b/compiler/test-resources/repl/i10355
index bfe3af835c87..294b9d7f1101 100644
--- a/compiler/test-resources/repl/i10355
+++ b/compiler/test-resources/repl/i10355
@@ -1,5 +1,7 @@
 scala> import scala.quoted._
 scala> def foo(expr: Expr[Any])(using Quotes) = expr match { case '{ $x: t } => '{ $x: Any } }
-def foo(expr: quoted.Expr[Any])(using x$2: quoted.Quotes): quoted.Expr[Any]
+def foo
+  (expr: quoted.Expr[Any])(using x$2: quoted.Quotes): scala.quoted.Expr[Any]
 scala> def bar(expr: Expr[Any])(using Quotes) = expr match { case '{ $x: t } => '{ val a: t = ??? ; ???} }
-def bar(expr: quoted.Expr[Any])(using x$2: quoted.Quotes): quoted.Expr[Nothing]
+def bar
+  (expr: quoted.Expr[Any])(using x$2: quoted.Quotes): scala.quoted.Expr[Nothing]
diff --git a/staging/test-resources/repl-staging/i6007 b/staging/test-resources/repl-staging/i6007
index be9d5c0f92d6..0d6fbd0cffb1 100644
--- a/staging/test-resources/repl-staging/i6007
+++ b/staging/test-resources/repl-staging/i6007
@@ -3,7 +3,7 @@ scala> import quoted.staging.{Compiler => StagingCompiler, _}
 scala> implicit def compiler: StagingCompiler = StagingCompiler.make(getClass.getClassLoader)
 def compiler: quoted.staging.Compiler
 scala> def v(using Quotes) = '{ (if true then Some(1) else None).map(v => v+1) }
-def v(using x$1: quoted.Quotes): quoted.Expr[Option[Int]]
+def v(using x$1: quoted.Quotes): scala.quoted.Expr[Option[Int]]
 scala> scala.quoted.staging.withQuotes(v.show)
 val res0: String = (if (true) scala.Some.apply[scala.Int](1) else scala.None).map[scala.Int](((v: scala.Int) => v.+(1)))
 scala> scala.quoted.staging.run(v)

From 7c96eed5fc8bd726480e005281e1a02608c5c0fb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Doeraene?= <sjrdoeraene@gmail.com>
Date: Wed, 26 Apr 2023 16:00:49 +0200
Subject: [PATCH 417/657] Fix #17344: Make implicit references to this above
 dynamic imports explicit.

Implicit references to the `this` of an outer class are made
explicit by the typer, and they need to be for `explicitOuter` to
do its job correctly.

When we desugar a `js.dynamicImport`, we move the code inside a
synthetic inner class. If it contains implicit references to an
enclosing class, we must make them explicit at that point.
---
 .../dotc/transform/sjs/PrepJSInterop.scala    | 33 ++++++++++++++++++-
 project/Build.scala                           | 12 +++++++
 .../SJSDynamicImportTestScala3.scala          | 29 ++++++++++++++++
 3 files changed, 73 insertions(+), 1 deletion(-)
 create mode 100644 tests/sjs-junit/test-require-multi-modules/org/scalajs/testsuite/jsinterop/SJSDynamicImportTestScala3.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/sjs/PrepJSInterop.scala b/compiler/src/dotty/tools/dotc/transform/sjs/PrepJSInterop.scala
index 8a430991e378..a2f9a0fb45a3 100644
--- a/compiler/src/dotty/tools/dotc/transform/sjs/PrepJSInterop.scala
+++ b/compiler/src/dotty/tools/dotc/transform/sjs/PrepJSInterop.scala
@@ -93,6 +93,24 @@ class PrepJSInterop extends MacroTransform with IdentityDenotTransformer { thisP
       }
     }
 
+    private var dynamicImportEnclosingClasses: Set[Symbol] = Set.empty
+
+    private def enterDynamicImportEnclosingClass[A](cls: Symbol)(body: => A): A = {
+      val saved = dynamicImportEnclosingClasses
+      dynamicImportEnclosingClasses = saved + cls
+      try
+        body
+      finally
+        dynamicImportEnclosingClasses = saved
+    }
+
+    private def hasImplicitThisPrefixToDynamicImportEnclosingClass(tpe: Type)(using Context): Boolean =
+      tpe match
+        case tpe: ThisType      => dynamicImportEnclosingClasses.contains(tpe.cls)
+        case TermRef(prefix, _) => hasImplicitThisPrefixToDynamicImportEnclosingClass(prefix)
+        case _                  => false
+    end hasImplicitThisPrefixToDynamicImportEnclosingClass
+
     /** DefDefs in class templates that export methods to JavaScript */
     private val exporters = mutable.Map.empty[Symbol, mutable.ListBuffer[Tree]]
 
@@ -297,10 +315,15 @@ class PrepJSInterop extends MacroTransform with IdentityDenotTransformer { thisP
 
           assert(currentOwner.isTerm, s"unexpected owner: $currentOwner at ${tree.sourcePos}")
 
+          val enclosingClass = currentOwner.enclosingClass
+
           // 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 transformedBody = enterDynamicImportEnclosingClass(enclosingClass) {
+              transform(body)
+            }
+            val newBody = transformedBody.changeOwnerAfter(currentOwner, applySym, thisPhase)
             val applyDefDef = DefDef(applySym, newBody)
             List(applyDefDef)
           }
@@ -310,6 +333,14 @@ class PrepJSInterop extends MacroTransform with IdentityDenotTransformer { thisP
             .appliedToTypeTree(tpeArg)
             .appliedTo(dynamicImportThunkAnonClass)
 
+        // #17344 Make `ThisType`-based references to enclosing classes of `js.dynamicImport` explicit
+        case tree: Ident if hasImplicitThisPrefixToDynamicImportEnclosingClass(tree.tpe) =>
+          def rec(tpe: Type): Tree = (tpe: @unchecked) match // exhaustive because of the `if ... =>`
+            case tpe: ThisType            => This(tpe.cls)
+            case tpe @ TermRef(prefix, _) => rec(prefix).select(tpe.symbol)
+
+          rec(tree.tpe).withSpan(tree.span)
+
         // Compile-time errors and warnings for js.Dynamic.literal
         case Apply(Apply(fun, nameArgs), args)
             if fun.symbol == jsdefn.JSDynamicLiteral_applyDynamic ||
diff --git a/project/Build.scala b/project/Build.scala
index 97b4d31f5e02..a1245dfd8460 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -1219,6 +1219,18 @@ object Build {
         org.scalajs.jsenv.Input.Script(f) +: (Test / jsEnvInput).value
       },
 
+      Test / unmanagedSourceDirectories ++= {
+        val linkerConfig = scalaJSStage.value match {
+          case FastOptStage => (Test / fastLinkJS / scalaJSLinkerConfig).value
+          case FullOptStage => (Test / fullLinkJS / scalaJSLinkerConfig).value
+        }
+
+        if (linkerConfig.moduleKind != ModuleKind.NoModule && !linkerConfig.closureCompiler)
+          Seq(baseDirectory.value / "test-require-multi-modules")
+        else
+          Nil
+      },
+
       (Compile / managedSources) ++= {
         val dir = fetchScalaJSSource.value
         (
diff --git a/tests/sjs-junit/test-require-multi-modules/org/scalajs/testsuite/jsinterop/SJSDynamicImportTestScala3.scala b/tests/sjs-junit/test-require-multi-modules/org/scalajs/testsuite/jsinterop/SJSDynamicImportTestScala3.scala
new file mode 100644
index 000000000000..b7c9060fcce1
--- /dev/null
+++ b/tests/sjs-junit/test-require-multi-modules/org/scalajs/testsuite/jsinterop/SJSDynamicImportTestScala3.scala
@@ -0,0 +1,29 @@
+package org.scalajs.testsuite.jsinterop
+
+import org.junit.Assert.*
+import org.junit.Test
+
+import org.scalajs.junit.async._
+
+import scala.scalajs.js
+import scala.scalajs.js.annotation.*
+
+class SJSDynamicImportTestScala3 {
+  import scala.concurrent.ExecutionContext.Implicits.global
+
+  @Test def implicitThisReferenceInDynamicImport_Issue17344(): AsyncResult = await {
+    class Foo() {
+      def foo(): Int = 1
+    }
+    class Bar(foo: Foo) {
+      def bar(): js.Promise[Int] = js.dynamicImport(foo.foo())
+    }
+
+    val bar = new Bar(new Foo())
+    val promise = bar.bar()
+
+    promise.toFuture.map { r =>
+      assertEquals(1, r)
+    }
+  }
+}

From d4bd097da79b6322ba8f23b66bfa07fa02dd949d Mon Sep 17 00:00:00 2001
From: Carl <carl.schutz@epfl.ch>
Date: Thu, 27 Apr 2023 01:52:12 +0200
Subject: [PATCH 418/657] Add unset vars warning for Wunused:locals, privates

---
 .../tools/dotc/transform/CheckUnused.scala    |  83 ++++---
 .../fatal-warnings/i15503b.scala              |  58 ++++-
 .../fatal-warnings/i15503c.scala              |  19 +-
 .../fatal-warnings/i15503i.scala              |  10 +-
 .../fatal-warnings/i16639a.scala              | 207 ++++++++++++++++++
 tests/pos/i16639false-pos-on-trait.scala      |  40 ++++
 6 files changed, 370 insertions(+), 47 deletions(-)
 create mode 100644 tests/neg-custom-args/fatal-warnings/i16639a.scala
 create mode 100644 tests/pos/i16639false-pos-on-trait.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index 69ec9f0d7b2b..4eba6b525b01 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -27,6 +27,7 @@ import dotty.tools.dotc.core.Symbols.Symbol
 import dotty.tools.dotc.core.StdNames.nme
 import scala.math.Ordering
 
+
 /**
  * A compiler phase that checks for unused imports or definitions
  *
@@ -146,6 +147,13 @@ class CheckUnused private (phaseMode: CheckUnused.PhaseMode, suffix: String, _ke
     if !tree.isInstanceOf[tpd.InferredTypeTree] then typeTraverser(unusedDataApply).traverse(tree.tpe)
     ctx
 
+  override def prepareForAssign(tree: tpd.Assign)(using Context): Context =
+    unusedDataApply{ ud =>
+      val sym = tree.lhs.symbol
+      if sym.exists then
+        ud.registerSetVar(sym)
+    }
+
   // ========== MiniPhase Transform ==========
 
   override def transformBlock(tree: tpd.Block)(using Context): tpd.Tree =
@@ -172,6 +180,7 @@ class CheckUnused private (phaseMode: CheckUnused.PhaseMode, suffix: String, _ke
     unusedDataApply(_.removeIgnoredUsage(tree.symbol))
     tree
 
+
   // ---------- MiniPhase HELPERS -----------
 
   private def pushInBlockTemplatePackageDef(tree: tpd.Block | tpd.Template | tpd.PackageDef)(using Context): Context =
@@ -215,11 +224,11 @@ class CheckUnused private (phaseMode: CheckUnused.PhaseMode, suffix: String, _ke
         case sel: Select =>
           prepareForSelect(sel)
           traverseChildren(tree)(using newCtx)
-        case _: (tpd.Block | tpd.Template | tpd.PackageDef) =>
+        case tree: (tpd.Block | tpd.Template | tpd.PackageDef) =>
           //! DIFFERS FROM MINIPHASE
-          unusedDataApply { ud =>
-            ud.inNewScope(ScopeType.fromTree(tree))(traverseChildren(tree)(using newCtx))
-          }
+          pushInBlockTemplatePackageDef(tree)
+          traverseChildren(tree)(using newCtx)
+          popOutBlockTemplatePackageDef()
         case t:tpd.ValDef =>
           prepareForValDef(t)
           traverseChildren(tree)(using newCtx)
@@ -235,6 +244,9 @@ class CheckUnused private (phaseMode: CheckUnused.PhaseMode, suffix: String, _ke
         case t: tpd.Bind =>
           prepareForBind(t)
           traverseChildren(tree)(using newCtx)
+        case t:tpd.Assign =>
+          prepareForAssign(t)
+          traverseChildren(tree)
         case _: tpd.InferredTypeTree =>
         case t@tpd.TypeTree() =>
           //! DIFFERS FROM MINIPHASE
@@ -278,6 +290,10 @@ class CheckUnused private (phaseMode: CheckUnused.PhaseMode, suffix: String, _ke
           report.warning(s"unused private member", t)
         case UnusedSymbol(t, _, WarnTypes.PatVars) =>
           report.warning(s"unused pattern variable", t)
+        case UnusedSymbol(t, _, WarnTypes.UnsetLocals) =>
+          report.warning(s"unset local variable", t)
+        case UnusedSymbol(t, _, WarnTypes.UnsetPrivates) =>
+          report.warning(s"unset private variable", t)
     }
 
 end CheckUnused
@@ -297,6 +313,8 @@ object CheckUnused:
     case ImplicitParams
     case PrivateMembers
     case PatVars
+    case UnsetLocals
+    case UnsetPrivates
 
   /**
    * The key used to retrieve the "unused entity" analysis metadata,
@@ -343,12 +361,8 @@ object CheckUnused:
     private val implicitParamInScope = MutSet[tpd.MemberDef]()
     private val patVarsInScope = MutSet[tpd.Bind]()
 
-    /* Unused collection collected at the end */
-    private val unusedLocalDef = MutSet[tpd.MemberDef]()
-    private val unusedPrivateDef = MutSet[tpd.MemberDef]()
-    private val unusedExplicitParams = MutSet[tpd.MemberDef]()
-    private val unusedImplicitParams = MutSet[tpd.MemberDef]()
-    private val unusedPatVars = MutSet[tpd.Bind]()
+    /** All variables sets*/
+    private val setVars = MutSet[Symbol]()
 
     /** All used symbols */
     private val usedDef = MutSet[Symbol]()
@@ -360,15 +374,6 @@ object CheckUnused:
 
     private val paramsToSkip = MutSet[Symbol]()
 
-    /**
-     * Push a new Scope of the given type, executes the given Unit and
-     * pop it back to the original type.
-     */
-    def inNewScope(newScope: ScopeType)(execInNewScope: => Unit)(using Context): Unit =
-      val prev = currScopeType
-      pushScope(newScope)
-      execInNewScope
-      popScope()
 
     def finishAggregation(using Context)(): Unit =
       val unusedInThisStage = this.getUnused
@@ -443,6 +448,9 @@ object CheckUnused:
       impInScope.push(MutSet())
       usedInScope.push(MutSet())
 
+    def registerSetVar(sym: Symbol): Unit =
+      setVars += sym
+
     /**
      * leave the current scope and do :
      *
@@ -501,15 +509,19 @@ object CheckUnused:
           unusedImport.map(d => UnusedSymbol(d.srcPos, d.name, WarnTypes.Imports)).toList
         else
           Nil
-      val sortedLocalDefs =
+      // Partition to extract unset local variables from usedLocalDefs
+      val (usedLocalDefs, unusedLocalDefs) =
         if ctx.settings.WunusedHas.locals then
-          localDefInScope
-            .filterNot(d => d.symbol.usedDefContains)
-            .filterNot(d => usedInPosition.exists { case (pos, name) => d.span.contains(pos.span) && name == d.symbol.name})
-            .filterNot(d => containsSyntheticSuffix(d.symbol))
-            .map(d => UnusedSymbol(d.namePos, d.name, WarnTypes.LocalDefs)).toList
+          localDefInScope.partition(d => d.symbol.usedDefContains)
         else
-          Nil
+          (Nil, Nil)
+      val sortedLocalDefs =
+        unusedLocalDefs
+          .filterNot(d => usedInPosition.exists { case (pos, name) => d.span.contains(pos.span) && name == d.symbol.name})
+          .filterNot(d => containsSyntheticSuffix(d.symbol))
+          .map(d => UnusedSymbol(d.namePos, d.name, WarnTypes.LocalDefs)).toList
+      val unsetLocalDefs = unsetVarsFromUsedSym(usedLocalDefs).map(d => UnusedSymbol(d.namePos, d.name, WarnTypes.UnsetLocals)).toList
+
       val sortedExplicitParams =
         if ctx.settings.WunusedHas.explicits then
           explicitParamInScope
@@ -527,14 +539,14 @@ object CheckUnused:
             .map(d => UnusedSymbol(d.namePos, d.name, WarnTypes.ImplicitParams)).toList
         else
           Nil
-      val sortedPrivateDefs =
+      // Partition to extract unset private variables from usedPrivates
+      val (usedPrivates, unusedPrivates) =
         if ctx.settings.WunusedHas.privates then
-          privateDefInScope
-            .filterNot(d => d.symbol.usedDefContains)
-            .filterNot(d => containsSyntheticSuffix(d.symbol))
-            .map(d => UnusedSymbol(d.namePos, d.name, WarnTypes.PrivateMembers)).toList
+          privateDefInScope.partition(d => d.symbol.usedDefContains)
         else
-          Nil
+          (Nil, Nil)
+      val sortedPrivateDefs = unusedPrivates.filterNot(d => containsSyntheticSuffix(d.symbol)).map(d => UnusedSymbol(d.namePos, d.name, WarnTypes.PrivateMembers)).toList
+      val unsetPrivateDefs = unsetVarsFromUsedSym(usedPrivates).map(d => UnusedSymbol(d.namePos, d.name, WarnTypes.UnsetPrivates)).toList
       val sortedPatVars =
         if ctx.settings.WunusedHas.patvars then
           patVarsInScope
@@ -544,7 +556,9 @@ object CheckUnused:
             .map(d => UnusedSymbol(d.namePos, d.name, WarnTypes.PatVars)).toList
         else
           Nil
-      val warnings = List(sortedImp, sortedLocalDefs, sortedExplicitParams, sortedImplicitParams, sortedPrivateDefs, sortedPatVars).flatten.sortBy { s =>
+      val warnings =
+        List(sortedImp, sortedLocalDefs, sortedExplicitParams, sortedImplicitParams,
+                  sortedPrivateDefs, sortedPatVars, unsetLocalDefs, unsetPrivateDefs).flatten.sortBy { s =>
         val pos = s.pos.sourcePos
         (pos.line, pos.column)
       }
@@ -744,6 +758,9 @@ object CheckUnused:
       private def isWildcard: Boolean =
         thisName == StdNames.nme.WILDCARD || thisName.is(WildcardParamName)
 
+    def unsetVarsFromUsedSym(usedDefs: Iterable[tpd.MemberDef])(using Context): Iterable[tpd.MemberDef] =
+      usedDefs.filter(d => d.symbol.is(Mutable) && !setVars(d.symbol))
+
   end UnusedData
 
   private object UnusedData:
diff --git a/tests/neg-custom-args/fatal-warnings/i15503b.scala b/tests/neg-custom-args/fatal-warnings/i15503b.scala
index 8a4a055150f9..c8a2d6bc2074 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503b.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503b.scala
@@ -2,49 +2,91 @@
 
 val a = 1 // OK
 
+var cs = 3 // OK
+
 val b = // OK
+  var e3 = 2 // error
   val e1 = 1 // error
   def e2 = 2 // error
   1
 
 val c = // OK
-  val e1 = 1 // OK
+  var e1 = 1 // error not set
+  def e2 = e1 // OK
+  val e3 = e2 // OK
+    e3
+
+val g = // OK
+  var e1 = 1 // OK
   def e2 = e1 // OK
-    e2
+  val e3 = e2 // OK
+  e1 = e3 // OK
+    e3
 
 def d = 1 // OK
 
 def e = // OK
   val e1 = 1 // error
   def e2 = 2 // error
+  var e3 = 4 // error
   1
 
 def f = // OK
   val f1 = 1 // OK
-  def f2 = f1 // OK
+  var f2 = f1 // error not set
+  def f3 = f2 // OK
+  f3
+
+def h = // OK
+  val f1 = 1 // OK
+  var f2 = f1 // OK
+  def f3 = f2 // OK
+  f2 = f3 // OK
   f2
 
 class Foo {
+  val a = 1 // OK
+
+  var cs = 3 // OK
+
   val b = // OK
+    var e3 = 2 // error
     val e1 = 1 // error
     def e2 = 2 // error
     1
 
   val c = // OK
-    val e1 = 1 // OK
+    var e1 = 1 // error not set
+    def e2 = e1 // OK
+    val e3 = e2 // OK
+    e3
+
+  val g = // OK
+    var e1 = 1 // OK
     def e2 = e1 // OK
-      e2
+    val e3 = e2 // OK
+    e1 = e3 // OK
+    e3
 
   def d = 1 // OK
 
   def e = // OK
     val e1 = 1 // error
     def e2 = 2 // error
+    var e3 = 4 // error
     1
 
   def f = // OK
     val f1 = 1 // OK
-    def f2 = f1 // OK
+    var f2 = f1 // error not set
+    def f3 = f2 // OK
+    f3
+
+  def h = // OK
+    val f1 = 1 // OK
+    var f2 = f1 // OK
+    def f3 = f2 // OK
+    f2 = f3 // OK
     f2
 }
 
@@ -68,7 +110,7 @@ package foo.scala2.tests:
       new a.Inner
     }
     def f2 = {
-      var x = 100
+      var x = 100 // error not set
       x
     }
   }
@@ -89,7 +131,7 @@ package foo.scala2.tests:
   }
 
 package test.foo.twisted.i16682:
-  def myPackage = 
+  def myPackage =
     object IntExtractor: // OK
       def unapply(s: String): Option[Int] = s.toIntOption
 
diff --git a/tests/neg-custom-args/fatal-warnings/i15503c.scala b/tests/neg-custom-args/fatal-warnings/i15503c.scala
index 630846df4e5d..e4e15116bf0d 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503c.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503c.scala
@@ -12,12 +12,24 @@ class A:
     private[this] val f = e // OK
     private val g = f // OK
 
+    private[A] var h = 1 // OK
+    private[this] var i = h // error not set
+    private var j = i // error not set
+
+    private[this] var k = 1 // OK
+    private var l = 2 // OK
+    private val m = // error
+      k = l
+      l = k
+      l
+
     private def fac(x: Int): Int = // error
       if x == 0 then 1 else x * fac(x - 1)
 
     val x = 1 // OK
     def y = 2 // OK
     def z = g // OK
+    var w = 2 // OK
 
 package foo.test.contructors:
   case class A private (x:Int) // OK
@@ -25,7 +37,12 @@ package foo.test.contructors:
   class C private (private val x: Int) // error
   class D private (private val x: Int): // OK
     def y = x
-
+  class E private (private var x: Int): // error not set
+    def y = x
+  class F private (private var x: Int): // OK
+    def y =
+      x = 3
+      x
 
 package test.foo.i16682:
   object myPackage:
diff --git a/tests/neg-custom-args/fatal-warnings/i15503i.scala b/tests/neg-custom-args/fatal-warnings/i15503i.scala
index fefead7f01a3..ea84c176eee4 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503i.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503i.scala
@@ -142,8 +142,8 @@ package foo.test.possibleclasses.withvar:
     private var y: Int // OK
   )(
     s: Int, // OK
-    var t: Int, // OK
-    private var z: Int // OK
+    var t: Int, // OK global scope can be set somewhere else
+    private var z: Int // error not set
   ) {
     def a = k + y + s + t + z
   }
@@ -159,11 +159,11 @@ package foo.test.possibleclasses.withvar:
 
   class AllUsed(
     k: Int, // OK
-    private var y: Int // OK
+    private var y: Int // error not set
   )(
     s: Int, // OK
-    var t: Int, // OK
-    private var z: Int // OK
+    var t: Int, // OK global scope can be set somewhere else
+    private var z: Int // error not set
   ) {
     def a = k + y + s + t + z
   }
diff --git a/tests/neg-custom-args/fatal-warnings/i16639a.scala b/tests/neg-custom-args/fatal-warnings/i16639a.scala
new file mode 100644
index 000000000000..c62910b7f566
--- /dev/null
+++ b/tests/neg-custom-args/fatal-warnings/i16639a.scala
@@ -0,0 +1,207 @@
+// scalac: -Wunused:all
+//
+class Bippy(a: Int, b: Int) {
+  private def this(c: Int) = this(c, c)           // warn /Dotty:NoWarn
+  private def boop(x: Int)            = x+a+b     // error
+    private def bippy(x: Int): Int      = bippy(x)  // error TODO: could warn
+  final private val MILLIS1           = 2000      // error no warn, /Dotty:Warn
+  final private val MILLIS2: Int      = 1000      // error
+  final private val HI_COMPANION: Int = 500       // no warn, accessed from companion
+  def hi() = Bippy.HI_INSTANCE
+}
+object Bippy {
+  def hi(x: Bippy) = x.HI_COMPANION
+  private val HI_INSTANCE: Int = 500      // no warn, accessed from instance
+  private val HEY_INSTANCE: Int = 1000    // error warn
+  private lazy val BOOL: Boolean = true   // error warn
+}
+
+class A(val msg: String)
+class B1(msg: String) extends A(msg)
+class B2(msg0: String) extends A(msg0)
+class B3(msg0: String) extends A("msg") // error /Dotty: unused explicit parameter
+
+trait Bing
+
+trait Accessors {
+  private var v1: Int = 0 // error warn
+  private var v2: Int = 0 // error warn, never set
+  private var v3: Int = 0 // warn, never got /Dotty: no warn even if not used
+  private var v4: Int = 0 // no warn
+
+  private[this] var v5 = 0 // error warn, never set
+  private[this] var v6 = 0 // warn, never got /Dotty: no warn even if not used
+  private[this] var v7 = 0 // no warn
+
+  def bippy(): Int = {
+    v3 = 3
+    v4 = 4
+    v6 = 6
+    v7 = 7
+    v2 + v4 + v5 + v7
+  }
+}
+
+class StableAccessors {
+  private var s1: Int = 0 // error warn
+  private var s2: Int = 0 // error warn, never set
+  private var s3: Int = 0 // warn, never got /Dotty: no warn even if not usued
+  private var s4: Int = 0 // no warn
+
+  private[this] var s5 = 0 // error warn, never set
+  private[this] var s6 = 0 // no warn, limitation /Dotty: Why limitation ?
+  private[this] var s7 = 0 // no warn
+
+  def bippy(): Int = {
+    s3 = 3
+    s4 = 4
+    s6 = 6
+    s7 = 7
+    s2 + s4 + s5 + s7
+  }
+}
+
+trait DefaultArgs {
+  // warn about default getters for x2 and x3
+  private def bippy(x1: Int, x2: Int = 10, x3: Int = 15): Int = x1 + x2 + x3 // no more warn warn since #17061
+
+  def boppy() = bippy(5, 100, 200)
+}
+
+
+class Outer {
+  class Inner
+}
+
+trait Locals {
+  def f0 = {
+    var x = 1 // error warn
+    var y = 2
+    y = 3
+    y + y
+  }
+  def f1 = {
+    val a = new Outer // no warn
+    val b = new Outer // error warn
+    new a.Inner
+  }
+  def f2 = {
+    var x = 100 // error warn about it being a var, var not set
+    x
+  }
+}
+
+object Types {
+  private object Dongo { def f = this } // no more warn since #17061
+  private class Bar1 // error warn
+  private class Bar2 // no warn
+  private type Alias1 = String // error warn
+  private type Alias2 = String // no warn
+  def bippo = (new Bar2).toString
+
+  def f(x: Alias2) = x.length
+
+  def l1() = {
+    object HiObject { def f = this } // no more warn since #17061
+    class Hi { // error warn
+      def f1: Hi = new Hi
+      def f2(x: Hi) = x
+    }
+    class DingDongDoobie // error warn
+    class Bippy // no warn
+    type Something = Bippy // no warn
+    type OtherThing = String // error warn
+    (new Bippy): Something
+  }
+}
+
+trait Underwarn {
+  def f(): Seq[Int]
+
+  def g() = {
+    val Seq(_, _) = f()  // no warn
+    true
+  }
+}
+
+class OtherNames {
+  private def x_=(i: Int): Unit = () // no more warn since #17061
+  private def x: Int = 42 // error Dotty triggers unused private member : To investigate
+  private def y_=(i: Int): Unit = () // // no more warn since #17061
+  private def y: Int = 42
+
+  def f = y
+}
+
+
+trait Forever {
+  def f = {
+    val t = Option((17, 42))
+    for {
+      ns <- t
+      (i, j) = ns                        // no warn
+    } yield (i + j)
+  }
+  def g = {
+    val t = Option((17, 42))
+    for {
+      ns <- t
+      (i, j) = ns                        // no warn
+    } yield 42                           // val emitted only if needed, hence nothing unused
+  }
+}
+
+trait Ignorance {
+  private val readResolve = 42      // error ignore /dotty triggers unused private member/ why should we ignore ?
+}
+
+trait CaseyKasem {
+  def f = 42 match {
+    case x if x < 25 => "no warn"
+    case y if toString.nonEmpty => "no warn" + y
+    case z => "warn"
+  }
+}
+trait CaseyAtTheBat {
+  def f = Option(42) match {
+    case Some(x) if x < 25 => "no warn"
+    case Some(y @ _) if toString.nonEmpty => "no warn"
+    case Some(z) => "warn"
+    case None => "no warn"
+  }
+}
+
+class `not even using companion privates`
+
+object `not even using companion privates` {
+  private implicit class `for your eyes only`(i: Int) {  // no more warn since #17061
+    def f = i
+  }
+}
+
+class `no warn in patmat anonfun isDefinedAt` {
+  def f(pf: PartialFunction[String, Int]) = pf("42")
+  def g = f {
+    case s => s.length        // no warn (used to warn case s => true in isDefinedAt)
+  }
+}
+
+// this is the ordinary case, as AnyRef is an alias of Object
+class `nonprivate alias is enclosing` {
+  class C
+  type C2 = C
+  private class D extends C2   // error warn
+}
+
+object `classof something` {
+  private class intrinsically
+  def f = classOf[intrinsically].toString()
+}
+
+trait `short comings` {
+  def f: Int = {
+    val x = 42 // error /Dotty only triggers in dotty
+    17
+  }
+}
+
diff --git a/tests/pos/i16639false-pos-on-trait.scala b/tests/pos/i16639false-pos-on-trait.scala
new file mode 100644
index 000000000000..67e304f556e1
--- /dev/null
+++ b/tests/pos/i16639false-pos-on-trait.scala
@@ -0,0 +1,40 @@
+// scalac -Wunsued:all
+//Avoid warning on setter in trait Regression test : issue10154 scala
+
+trait T {
+  private var x: String = _
+
+  def y: String = {
+    if (x eq null) x = "hello, world"
+    x
+  }
+}
+
+/*
+➜  skalac -version
+Scala compiler version 2.13.10-20220920-001308-98972e5 -- Copyright 2002-2022, LAMP/EPFL and Lightbend, Inc.
+
+➜  skalac -d /tmp -Wunused -Vprint:typer t12646.scala
+t12646.scala:3: warning: parameter value x_= in variable x is never used
+  private var x: String = _
+              ^
+[[syntax trees at end of                     typer]] // t12646.scala
+package <empty> {
+  abstract trait T extends scala.AnyRef {
+    def /*T*/$init$(): Unit = {
+      ()
+    };
+    <accessor> private val x: String = _;
+    <accessor> private def x_=(x$1: String): Unit;
+    def y: String = {
+      if (T.this.x.eq(null))
+        T.this.x_=("hello, world")
+      else
+        ();
+      T.this.x
+    }
+  }
+}
+
+1 warning
+*/

From 04f020f8a824f3a73f47de6e74a52becfb26410a Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Thu, 27 Apr 2023 08:18:36 +0200
Subject: [PATCH 419/657] Remove `Splice.isInBraces`

---
 compiler/src/dotty/tools/dotc/ast/Trees.scala              | 1 -
 compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala | 3 ++-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala
index 546e55ee22e3..d748d531845f 100644
--- a/compiler/src/dotty/tools/dotc/ast/Trees.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala
@@ -697,7 +697,6 @@ object Trees {
   case class Splice[+T <: Untyped] private[ast] (expr: Tree[T], tpt: Tree[T])(implicit @constructorOnly src: SourceFile)
     extends TermTree[T] {
     type ThisTree[+T <: Untyped] = Splice[T]
-    def isInBraces: Boolean = span.end != expr.span.end
   }
 
   /** A type tree that represents an existing or inferred type */
diff --git a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
index 9ec4a8648695..ed026d331b60 100644
--- a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
+++ b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
@@ -147,10 +147,11 @@ trait QuotesAndSplices {
   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
+    def isInBraces: Boolean = splice.span.end != splice.expr.span.end
     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
+    else if isInBraces then // ${x}(...) match an application
       val typedArgs = args.map(arg => typedExpr(arg))
       val argTypes = typedArgs.map(_.tpe.widenTermRefExpr)
       val splice1 = typedSpliceSyntactic(splice, defn.FunctionOf(argTypes, pt))

From 35db4a1c7015781556962e0a07f4f5e099f85495 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Thu, 27 Apr 2023 09:16:29 +0200
Subject: [PATCH 420/657] Move Quote/Splice retyping into ReTyper

---
 .../tools/dotc/typer/QuotesAndSplices.scala   | 37 +++++--------------
 .../src/dotty/tools/dotc/typer/ReTyper.scala  | 14 +++++++
 2 files changed, 24 insertions(+), 27 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
index ed026d331b60..f81c0c2de56a 100644
--- a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
+++ b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
@@ -31,34 +31,12 @@ trait QuotesAndSplices {
 
   import tpd._
 
-  def typedQuote(tree: untpd.Quote, pt: Type)(using Context): Tree =
-    if tree.tpt.isEmpty then
-      typedQuoteSyntactic(tree, pt)
-    else
-      val tpt1 = checkSimpleKinded(typedType(tree.tpt, mapPatternBounds = true))
-      val expr1 = typed(tree.expr, tpt1.tpe.widenSkolem)(using quoteContext)
-      assignType(untpd.cpy.Quote(tree)(expr1, tpt1), tpt1)
-
-  def typedSplice(tree: untpd.Splice, pt: Type)(using Context): Tree =
-    if tree.tpt.isEmpty then
-      typedSpliceSyntactic(tree, pt)
-    else
-      val tpt1 = checkSimpleKinded(typedType(tree.tpt, mapPatternBounds = true))
-      val splicedType = // Quotes ?=> Expr[T]
-        defn.FunctionType(1, isContextual = true)
-          .appliedTo(defn.QuotesClass.typeRef, defn.QuotedExprClass.typeRef.appliedTo(tpt1.tpe.widenSkolem))
-      val expr1 = typed(tree.expr, splicedType)(using spliceContext)
-      assignType(untpd.cpy.Splice(tree)(expr1, tpt1), tpt1)
-
-  def typedHole(tree: untpd.Hole, pt: Type)(using Context): Tree =
-    val tpt = typedType(tree.tpt)
-    assignType(tree, tpt)
-
   /** Translate `'{ e }` into `scala.quoted.Expr.apply(e)` and `'[T]` into `scala.quoted.Type.apply[T]`
    *  while tracking the quotation level in the context.
    */
-  private def typedQuoteSyntactic(tree: untpd.Quote, pt: Type)(using Context): Tree = {
+  def typedQuote(tree: untpd.Quote, pt: Type)(using Context): Tree = {
     record("typedQuote")
+    assert(tree.tpt.isEmpty)
     tree.expr 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)
@@ -93,8 +71,9 @@ trait QuotesAndSplices {
     }
 
   /** Translate `${ t: Expr[T] }` into expression `t.splice` while tracking the quotation level in the context */
-  private def typedSpliceSyntactic(tree: untpd.Splice, pt: Type)(using Context): Tree = {
+  def typedSplice(tree: untpd.Splice, pt: Type)(using Context): Tree = {
     record("typedSplice")
+    assert(tree.tpt.isEmpty)
     checkSpliceOutsideQuote(tree)
     tree.expr match {
       case untpd.Quote(innerExpr, _) if innerExpr.isTerm =>
@@ -137,6 +116,10 @@ trait QuotesAndSplices {
     }
   }
 
+  def typedHole(tree: untpd.Hole, pt: Type)(using Context): Tree =
+    val tpt = typedType(tree.tpt)
+    assignType(tree, tpt)
+
   /** 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`
@@ -154,7 +137,7 @@ trait QuotesAndSplices {
     else if isInBraces then // ${x}(...) match an application
       val typedArgs = args.map(arg => typedExpr(arg))
       val argTypes = typedArgs.map(_.tpe.widenTermRefExpr)
-      val splice1 = typedSpliceSyntactic(splice, defn.FunctionOf(argTypes, pt))
+      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 {
@@ -167,7 +150,7 @@ trait QuotesAndSplices {
       if args.isEmpty then
         report.error("Missing arguments for open pattern", tree.srcPos)
       val argTypes = typedArgs.map(_.tpe.widenTermRefExpr)
-      val typedPat = typedSpliceSyntactic(splice, defn.FunctionOf(argTypes, pt))
+      val typedPat = typedSplice(splice, defn.FunctionOf(argTypes, pt))
       ref(defn.QuotedRuntimePatterns_patternHigherOrderHole).appliedToType(pt).appliedTo(typedPat, SeqLiteral(typedArgs, TypeTree(defn.AnyType)))
   }
 
diff --git a/compiler/src/dotty/tools/dotc/typer/ReTyper.scala b/compiler/src/dotty/tools/dotc/typer/ReTyper.scala
index c64f541fd811..9efe3b31a356 100644
--- a/compiler/src/dotty/tools/dotc/typer/ReTyper.scala
+++ b/compiler/src/dotty/tools/dotc/typer/ReTyper.scala
@@ -12,6 +12,7 @@ import ast.{tpd, untpd}
 import scala.util.control.NonFatal
 import util.Spans.Span
 import Nullables._
+import staging.StagingLevel.*
 
 /** A version of Typer that keeps all symbols defined and referenced in a
  *  previously typed tree.
@@ -94,6 +95,19 @@ class ReTyper(nestingLevel: Int = 0) extends Typer(nestingLevel) with ReChecking
   override def typedUnApply(tree: untpd.Apply, selType: Type)(using Context): Tree =
     typedApply(tree, selType)
 
+  override def typedQuote(tree: untpd.Quote, pt: Type)(using Context): Tree =
+    val tpt1 = checkSimpleKinded(typedType(tree.tpt, mapPatternBounds = true))
+    val expr1 = typed(tree.expr, tpt1.tpe.widenSkolem)(using quoteContext)
+    assignType(untpd.cpy.Quote(tree)(expr1, tpt1), tpt1)
+
+  override def typedSplice(tree: untpd.Splice, pt: Type)(using Context): Tree =
+    val tpt1 = checkSimpleKinded(typedType(tree.tpt, mapPatternBounds = true))
+    val splicedType = // Quotes ?=> Expr[T]
+      defn.FunctionType(1, isContextual = true)
+        .appliedTo(defn.QuotesClass.typeRef, defn.QuotedExprClass.typeRef.appliedTo(tpt1.tpe.widenSkolem))
+    val expr1 = typed(tree.expr, splicedType)(using spliceContext)
+    assignType(untpd.cpy.Splice(tree)(expr1, tpt1), tpt1)
+
   override def localDummy(cls: ClassSymbol, impl: untpd.Template)(using Context): Symbol = impl.symbol
 
   override def retrieveSym(tree: untpd.Tree)(using Context): Symbol = tree.symbol

From 1ef7f59095b901201074f662fb9af6b4f4ad0c76 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Thu, 27 Apr 2023 09:55:45 +0200
Subject: [PATCH 421/657] Add documentation

---
 compiler/src/dotty/tools/dotc/ast/Trees.scala | 34 ++++++++++++++-----
 1 file changed, 26 insertions(+), 8 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala
index d748d531845f..3427146a6baa 100644
--- a/compiler/src/dotty/tools/dotc/ast/Trees.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala
@@ -677,11 +677,20 @@ object Trees {
     override def isType = expansion.isType
   }
 
-  /** A tree representing a quote `'{ expr }
+  /** A tree representing a quote `'{ expr }`
+   *  `Quote`s are created by the `Parser` with an empty `tpt`. In typer
+   *  they can be typed as a `Quote` with a known `tpt` or desugared and
+   *  typed as a quote pattern.
+   *
+   *  `Quotes` are checked transformed in the `staging`, `splicing` and `pickleQuotes`
+   *  phases. After `pickleQuotes` phase, the only quotes that exist are in `inline`
+   *  methods. These are dropped when we remove the inline method implementations.
+   *
+   *  The `tpt` will be transformed in `staging` and used in `pickleQuotes` to create the
+   *  pickled representation of the quote.
    *
    *  @param  expr  The tree that was quoted
-   *  @param  tpt   The type of the tree that was quoted,
-   *                EmptyTree if this tree comes from the parser.
+   *  @param  tpt   The type of the tree that was quoted
    */
   case class Quote[+T <: Untyped] private[ast] (expr: Tree[T], tpt: Tree[T])(implicit @constructorOnly src: SourceFile)
     extends TermTree[T] {
@@ -689,11 +698,20 @@ object Trees {
   }
 
   /** A tree representing a splice `${ expr }`
-    *
-    * @param expr The tree that was spliced
-    * @param tpt  The type of the tree that was spliced,
-    *             EmptyTree if this tree comes from the parser.
-    */
+   *
+   *  `Splice`s are created by the `Parser` with an empty `tpt`. In typer
+   *  they can be typed as a `Splice` with a known `tpt` or desugared and
+   *  typed as a quote pattern holes.
+   *
+   *  `Splice` are checked transformed in the `staging` and `splicing` phases.
+   *  After `splicing` phase, the only quotes that exist are in `inline`
+   *  methods. These are dropped when we remove the inline method implementations.
+   *
+   *  The `tpt` will be transformed in `staging` and used in `splicing` to create `Hole`s.
+   *
+   *  @param expr The tree that was spliced
+   *  @param tpt  The type of the spliced tree
+   */
   case class Splice[+T <: Untyped] private[ast] (expr: Tree[T], tpt: Tree[T])(implicit @constructorOnly src: SourceFile)
     extends TermTree[T] {
     type ThisTree[+T <: Untyped] = Splice[T]

From 687d06ea78087cdca1ef4161427c166ae02df9e1 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Thu, 27 Apr 2023 10:13:47 +0200
Subject: [PATCH 422/657] Transform Quote/Splice in MiniPhase

To transform quotes and splices in inline methods.
---
 .../tools/dotc/transform/ElimByName.scala     |  6 ---
 .../tools/dotc/transform/FirstTransform.scala |  3 --
 .../tools/dotc/transform/MegaPhase.scala      | 51 +++++++++++++++++++
 3 files changed, 51 insertions(+), 9 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/ElimByName.scala b/compiler/src/dotty/tools/dotc/transform/ElimByName.scala
index 976df4f436f7..151e841f0e48 100644
--- a/compiler/src/dotty/tools/dotc/transform/ElimByName.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ElimByName.scala
@@ -159,12 +159,6 @@ class ElimByName extends MiniPhase, InfoTransformer:
       else tree
     }
 
-  override def transformOther(tree: Tree)(using Context): Tree = tree match
-    case tree @ Splice(spliced, tpt) =>
-      assert(dotty.tools.dotc.inlines.Inlines.inInlineMethod)
-      cpy.Splice(tree)(transformAllDeep(spliced), tpt)
-    case tree => tree
-
 object ElimByName:
   val name: String = "elimByName"
   val description: String = "map by-name parameters to functions"
diff --git a/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala b/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala
index 9d874bf6b00f..a7e0795ce195 100644
--- a/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala
+++ b/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala
@@ -153,9 +153,6 @@ class FirstTransform extends MiniPhase with InfoTransformer { thisPhase =>
   override def transformOther(tree: Tree)(using Context): Tree = tree match {
     case tree: Export => EmptyTree
     case tree: NamedArg => transformAllDeep(tree.arg)
-    case tree @ Splice(expr, tpt) =>
-      assert(dotty.tools.dotc.inlines.Inlines.inInlineMethod)
-      cpy.Splice(tree)(transformAllDeep(expr), transformAllDeep(tpt))
     case tree => if (tree.isType) toTypeTree(tree) else tree
   }
 
diff --git a/compiler/src/dotty/tools/dotc/transform/MegaPhase.scala b/compiler/src/dotty/tools/dotc/transform/MegaPhase.scala
index d4dd911241d3..77d6b2f3ac61 100644
--- a/compiler/src/dotty/tools/dotc/transform/MegaPhase.scala
+++ b/compiler/src/dotty/tools/dotc/transform/MegaPhase.scala
@@ -5,6 +5,7 @@ package transform
 import core._
 import Contexts._, Phases._, Symbols._, Decorators._
 import Flags.PackageVal
+import staging.StagingLevel.*
 
 /** A MegaPhase combines a number of mini-phases which are all executed in
  *  a single tree traversal.
@@ -66,6 +67,8 @@ object MegaPhase {
     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 prepareForQuote(tree: Quote)(using Context): Context = ctx
+    def prepareForSplice(tree: Splice)(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
@@ -100,6 +103,8 @@ object MegaPhase {
     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 transformQuote(tree: Quote)(using Context): Tree = tree
+    def transformSplice(tree: Splice)(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
@@ -394,6 +399,18 @@ class MegaPhase(val miniPhases: Array[MiniPhase]) extends Phase {
           val expansion = transformTree(tree.expansion, start)(using inlineContext(tree.call))
           goInlined(cpy.Inlined(tree)(tree.call, bindings, expansion), start)
         }
+      case tree: Quote =>
+        inContext(prepQuote(tree, start)(using outerCtx)) {
+          val expr = transformTree(tree.expr, start)(using quoteContext)
+          val tpt = transformTree(tree.tpt, start)
+          goQuote(cpy.Quote(tree)(expr, tpt), start)
+        }
+      case tree: Splice =>
+        inContext(prepSplice(tree, start)(using outerCtx)) {
+          val expr = transformTree(tree.expr, start)(using spliceContext)
+          val tpt = transformTree(tree.tpt, start)
+          goSplice(cpy.Splice(tree)(expr, tpt), start)
+        }
       case tree: Return =>
         inContext(prepReturn(tree, start)(using outerCtx)) {
           val expr = transformTree(tree.expr, start)
@@ -546,6 +563,10 @@ class MegaPhase(val miniPhases: Array[MiniPhase]) extends Phase {
   private val nxSeqLiteralTransPhase = init("transformSeqLiteral")
   private val nxInlinedPrepPhase = init("prepareForInlined")
   private val nxInlinedTransPhase = init("transformInlined")
+  private val nxQuotePrepPhase = init("prepareForQuote")
+  private val nxQuoteTransPhase = init("transformQuote")
+  private val nxSplicePrepPhase = init("prepareForPrep")
+  private val nxSpliceTransPhase = init("transformSplice")
   private val nxTypeTreePrepPhase = init("prepareForTypeTree")
   private val nxTypeTreeTransPhase = init("transformTypeTree")
   private val nxBindPrepPhase = init("prepareForBind")
@@ -893,6 +914,36 @@ class MegaPhase(val miniPhases: Array[MiniPhase]) extends Phase {
     }
   }
 
+  def prepQuote(tree: Quote, start: Int)(using Context): Context = {
+    val phase = nxQuotePrepPhase(start)
+    if (phase == null) ctx
+    else prepQuote(tree, phase.idxInGroup + 1)(using phase.prepareForQuote(tree))
+  }
+
+  def goQuote(tree: Quote, start: Int)(using Context): Tree = {
+    val phase = nxQuoteTransPhase(start)
+    if (phase == null) tree
+    else phase.transformQuote(tree) match {
+      case tree1: Quote => goQuote(tree1, phase.idxInGroup + 1)
+      case tree1 => transformNode(tree1, phase.idxInGroup + 1)
+    }
+  }
+
+  def prepSplice(tree: Splice, start: Int)(using Context): Context = {
+    val phase = nxSplicePrepPhase(start)
+    if (phase == null) ctx
+    else prepSplice(tree, phase.idxInGroup + 1)(using phase.prepareForSplice(tree))
+  }
+
+  def goSplice(tree: Splice, start: Int)(using Context): Tree = {
+    val phase = nxSpliceTransPhase(start)
+    if (phase == null) tree
+    else phase.transformSplice(tree) match {
+      case tree1: Splice => goSplice(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

From 76ec7050d323b06a453656b16203fb02346b046a Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Wed, 26 Apr 2023 12:43:54 +0200
Subject: [PATCH 423/657] Assert that symbols created using reflect API have
 correct privateWithin symbols

closes lampepfl#17351
---
 compiler/src/dotty/tools/dotc/core/Symbols.scala |  2 +-
 .../scala/quoted/runtime/impl/QuotesImpl.scala   |  3 +++
 tests/neg/i17351/Macro_1.scala                   | 16 ++++++++++++++++
 tests/neg/i17351/Test_2.scala                    |  1 +
 4 files changed, 21 insertions(+), 1 deletion(-)
 create mode 100644 tests/neg/i17351/Macro_1.scala
 create mode 100644 tests/neg/i17351/Test_2.scala

diff --git a/compiler/src/dotty/tools/dotc/core/Symbols.scala b/compiler/src/dotty/tools/dotc/core/Symbols.scala
index aa3ae0c3c513..37adaf3ab008 100644
--- a/compiler/src/dotty/tools/dotc/core/Symbols.scala
+++ b/compiler/src/dotty/tools/dotc/core/Symbols.scala
@@ -170,7 +170,7 @@ object Symbols {
       asInstanceOf[TermSymbol]
     }
     final def asType(using Context): TypeSymbol = {
-      assert(isType, s"isType called on not-a-Type $this");
+      assert(isType, s"asType called on not-a-Type $this");
       asInstanceOf[TypeSymbol]
     }
 
diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
index 1949304ca287..cf967242a715 100644
--- a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
+++ b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
@@ -2504,6 +2504,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
       def newModule(owner: Symbol, name: String, modFlags: Flags, clsFlags: Flags, parents: List[TypeRepr], decls: Symbol => List[Symbol], privateWithin: Symbol): Symbol =
         assert(parents.nonEmpty && !parents.head.typeSymbol.is(dotc.core.Flags.Trait), "First parent must be a class")
+        assert(!privateWithin.exists || privateWithin.isType, "privateWithin must be a type symbol or `Symbol.noSymbol`")
         val mod = dotc.core.Symbols.newNormalizedModuleSymbol(
           owner,
           name.toTermName,
@@ -2520,8 +2521,10 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
       def newMethod(owner: Symbol, name: String, tpe: TypeRepr): Symbol =
         newMethod(owner, name, tpe, Flags.EmptyFlags, noSymbol)
       def newMethod(owner: Symbol, name: String, tpe: TypeRepr, flags: Flags, privateWithin: Symbol): Symbol =
+        assert(!privateWithin.exists || privateWithin.isType, "privateWithin must be a type symbol or `Symbol.noSymbol`")
         dotc.core.Symbols.newSymbol(owner, name.toTermName, flags | dotc.core.Flags.Method, tpe, privateWithin)
       def newVal(owner: Symbol, name: String, tpe: TypeRepr, flags: Flags, privateWithin: Symbol): Symbol =
+        assert(!privateWithin.exists || privateWithin.isType, "privateWithin must be a type symbol or `Symbol.noSymbol`")
         dotc.core.Symbols.newSymbol(owner, name.toTermName, flags, tpe, privateWithin)
       def newBind(owner: Symbol, name: String, flags: Flags, tpe: TypeRepr): Symbol =
         dotc.core.Symbols.newSymbol(owner, name.toTermName, flags | Case, tpe)
diff --git a/tests/neg/i17351/Macro_1.scala b/tests/neg/i17351/Macro_1.scala
new file mode 100644
index 000000000000..b80999e1bce5
--- /dev/null
+++ b/tests/neg/i17351/Macro_1.scala
@@ -0,0 +1,16 @@
+import scala.quoted.*
+
+inline def gen: Unit = ${ genImpl }
+
+def genImpl(using Quotes): Expr[Unit] = {
+  import quotes.reflect.*
+
+  val valDefSymbol = Symbol.newVal(Symbol.spliceOwner, "bar", TypeRepr.of[Unit], Flags.EmptyFlags, Symbol.spliceOwner)
+
+  val valDef = ValDef(valDefSymbol, Some('{ () }.asTerm))
+
+  Block(
+    List(valDef),
+    '{ () }.asTerm
+  ).asExprOf[Unit]
+}
diff --git a/tests/neg/i17351/Test_2.scala b/tests/neg/i17351/Test_2.scala
new file mode 100644
index 000000000000..209c23204ad3
--- /dev/null
+++ b/tests/neg/i17351/Test_2.scala
@@ -0,0 +1 @@
+val foo = gen // error

From 1ca9e8f96f08eec8a837a691c8afb418fceae5da Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Wed, 12 Oct 2022 14:19:46 +0200
Subject: [PATCH 424/657] Apply delayed-init.md

---
 docs/_spec/05-classes-and-objects.md                   | 10 ----------
 .../dropped-features/delayed-init.md                   |  0
 2 files changed, 10 deletions(-)
 rename docs/_spec/{TODOreference => APPLIEDreference}/dropped-features/delayed-init.md (100%)

diff --git a/docs/_spec/05-classes-and-objects.md b/docs/_spec/05-classes-and-objects.md
index c40bd49cae16..c6cb1dc113de 100644
--- a/docs/_spec/05-classes-and-objects.md
+++ b/docs/_spec/05-classes-and-objects.md
@@ -96,16 +96,6 @@ If this is not a template of a trait, then its _evaluation_ consists of the foll
 Mixin-evaluation happens in reverse order of occurrence in the linearization.
 - Finally, the statement sequence ´\mathit{stats}\,´ is evaluated.
 
-###### Delayed Initialization
-This statement sequence constitutes the initialization code for an object or class after the superclass constructor invocation and the mixin-evaluation of the template's base classes as described above.
-Normally, this code is passed to a special hook, inaccessible to user code, which simply executes it.
-
-However, in objects and classes (but not traits) which extend `scala.DelayedInit`, the initialization code is passed to a `delayedInit` method which can be overridden to implement arbitrary semantics.
-
-```scala
-def delayedInit(body: => Unit): Unit
-```
-
 ### Constructor Invocations
 
 ```ebnf
diff --git a/docs/_spec/TODOreference/dropped-features/delayed-init.md b/docs/_spec/APPLIEDreference/dropped-features/delayed-init.md
similarity index 100%
rename from docs/_spec/TODOreference/dropped-features/delayed-init.md
rename to docs/_spec/APPLIEDreference/dropped-features/delayed-init.md

From eb2a02133eff6c54699c33b35870815c5c5170cd Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Wed, 12 Oct 2022 14:25:31 +0200
Subject: [PATCH 425/657] Apply do-while.md

---
 docs/_spec/06-expressions.md                           | 10 ----------
 .../dropped-features/do-while.md                       |  0
 2 files changed, 10 deletions(-)
 rename docs/_spec/{TODOreference => APPLIEDreference}/dropped-features/do-while.md (100%)

diff --git a/docs/_spec/06-expressions.md b/docs/_spec/06-expressions.md
index 92697e64f0ac..c2c4d1f56afa 100644
--- a/docs/_spec/06-expressions.md
+++ b/docs/_spec/06-expressions.md
@@ -12,7 +12,6 @@ Expr         ::=  (Bindings | id | ‘_’) ‘=>’ Expr
 Expr1        ::=  ‘if’ ‘(’ Expr ‘)’ {nl} Expr [[semi] ‘else’ Expr]
                |  ‘while’ ‘(’ Expr ‘)’ {nl} Expr
                |  ‘try’ Expr [‘catch’ Expr] [‘finally’ Expr]
-               |  ‘do’ Expr [semi] ‘while’ ‘(’ Expr ‘)’
                |  ‘for’ (‘(’ Enumerators ‘)’ | ‘{’ Enumerators ‘}’) {nl} [‘yield’] Expr
                |  ‘throw’ Expr
                |  ‘return’ [Expr]
@@ -717,15 +716,6 @@ def whileLoop(cond: => Boolean)(body: => Unit): Unit  =
   if (cond) { body ; whileLoop(cond)(body) } else {}
 ```
 
-## Do Loop Expressions
-
-```ebnf
-Expr1          ::=  ‘do’ Expr [semi] ‘while’ ‘(’ Expr ‘)’
-```
-
-The _do loop expression_ `do ´e_1´ while (´e_2´)` is typed and evaluated as if it was the expression `(´e_1´ ; while (´e_2´) ´e_1´)`.
-A semicolon preceding the `while` symbol of a do loop expression is ignored.
-
 ## For Comprehensions and For Loops
 
 ```ebnf
diff --git a/docs/_spec/TODOreference/dropped-features/do-while.md b/docs/_spec/APPLIEDreference/dropped-features/do-while.md
similarity index 100%
rename from docs/_spec/TODOreference/dropped-features/do-while.md
rename to docs/_spec/APPLIEDreference/dropped-features/do-while.md

From 3ab8ae822f845d04ff9b45e977471a3715921e74 Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Wed, 12 Oct 2022 14:25:59 +0200
Subject: [PATCH 426/657] Cleanup

---
 .../dropped-features/dropped-features.md                          | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename docs/_spec/{TODOreference => APPLIEDreference}/dropped-features/dropped-features.md (100%)

diff --git a/docs/_spec/TODOreference/dropped-features/dropped-features.md b/docs/_spec/APPLIEDreference/dropped-features/dropped-features.md
similarity index 100%
rename from docs/_spec/TODOreference/dropped-features/dropped-features.md
rename to docs/_spec/APPLIEDreference/dropped-features/dropped-features.md

From 1ab9d9bfda87492f0ac642b120276dbd975c8d9b Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Wed, 12 Oct 2022 14:33:47 +0200
Subject: [PATCH 427/657] Apply early-initializers.md

---
 docs/_spec/05-classes-and-objects.md          | 53 +------------------
 .../dropped-features/early-initializers.md    |  0
 2 files changed, 1 insertion(+), 52 deletions(-)
 rename docs/_spec/{TODOreference => APPLIEDreference}/dropped-features/early-initializers.md (100%)

diff --git a/docs/_spec/05-classes-and-objects.md b/docs/_spec/05-classes-and-objects.md
index c6cb1dc113de..b73a4aa56071 100644
--- a/docs/_spec/05-classes-and-objects.md
+++ b/docs/_spec/05-classes-and-objects.md
@@ -295,57 +295,6 @@ It is a static error if the inheritance closure of a class type consists of an i
 
 [^kennedy]: Kennedy, Pierce. [On Decidability of Nominal Subtyping with Variance.]( https://research.microsoft.com/pubs/64041/fool2007.pdf) in FOOL 2007
 
-### Early Definitions
-
-```ebnf
-EarlyDefs         ::= ‘{’ [EarlyDef {semi EarlyDef}] ‘}’ ‘with’
-EarlyDef          ::=  {Annotation} {Modifier} PatVarDef
-```
-
-A template may start with an _early field definition_ clause, which serves to define certain field values before the supertype constructor is called.
-In a template
-
-```scala
-{ val ´p_1´: ´T_1´ = ´e_1´
-  ...
-  val ´p_n´: ´T_n´ = ´e_n´
-} with ´sc´ with ´mt_1´ with ´mt_n´ { ´\mathit{stats}´ }
-```
-
-The initial pattern definitions of ´p_1 , \ldots , p_n´ are called _early definitions_.
-They define fields which form part of the template.
-Every early definition must define at least one variable.
-
-An early definition is type-checked and evaluated in the scope which is in effect just before the template being defined, augmented by any type parameters of the enclosing class and by any early definitions preceding the one being defined.
-In particular, any reference to `this` in an early definition refers to the identity of `this` just outside the template.
-Consequently, it is impossible for an early definition to refer to the object being constructed by the template, or to refer to one of its fields and methods, except for any other preceding early definition in the same section.
-Furthermore, references to preceding early definitions always refer to the value that's defined there and do not take into account overriding definitions.
-In other words, a block of early definitions is evaluated exactly as if it were a local block containing a number of value definitions.
-
-Early definitions are evaluated before the superclass constructor of the template is called, in the order they are defined.
-
-###### Example
-Early definitions are particularly useful for traits, which do not have normal constructor parameters.
-Example:
-
-```scala
-trait Greeting {
-  val name: String
-  val msg = "How are you, "+name
-}
-class C extends {
-  val name = "Bob"
-} with Greeting {
-  println(msg)
-}
-```
-
-In the code above, the field `name` is initialized before the constructor of `Greeting` is called.
-Therefore, field `msg` in class `Greeting` is properly initialized to `"How are you, Bob"`.
-
-If `name` had been initialized instead in `C`'s normal class body, it would be initialized after the constructor of `Greeting`.
-In that case, `msg` would be initialized to `"How are you, <null>"`.
-
 ## Modifiers
 
 ```ebnf
@@ -592,7 +541,7 @@ A constructor expression is either a self constructor invocation `this(´\mathit
 The self constructor invocation must construct a generic instance of the class. 
 I.e. if the class in question has name ´C´ and type parameters `[´\mathit{tps}\,´]`, then a self constructor invocation must generate an instance of `´C´[´\mathit{tps}\,´]`; it is not permitted to instantiate formal type parameters.
 
-The signature and the self constructor invocation of a constructor definition are type-checked and evaluated in the scope which is in effect at the point of the enclosing class definition, augmented by any type parameters of the enclosing class and by any [early definitions](#early-definitions) of the enclosing template.
+The signature and the self constructor invocation of a constructor definition are type-checked and evaluated in the scope which is in effect at the point of the enclosing class definition, augmented by any type parameters of the enclosing class.
 The rest of the constructor expression is type-checked and evaluated as a method body in the current class.
 
 If there are auxiliary constructors of a class ´C´, they form together with ´C´'s primary [constructor](#class-definitions) an overloaded constructor definition.
diff --git a/docs/_spec/TODOreference/dropped-features/early-initializers.md b/docs/_spec/APPLIEDreference/dropped-features/early-initializers.md
similarity index 100%
rename from docs/_spec/TODOreference/dropped-features/early-initializers.md
rename to docs/_spec/APPLIEDreference/dropped-features/early-initializers.md

From 1578032e99e0fb6133a80913072ef26f25c8d163 Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Wed, 12 Oct 2022 15:22:55 +0200
Subject: [PATCH 428/657] Apply existential-types.md

---
 docs/_spec/03-types.md                        | 109 +-----------------
 docs/_spec/06-expressions.md                  |  21 +---
 docs/_spec/07-implicits.md                    |   3 +-
 docs/_spec/A2-scala-2-compatibility.md        |  19 +++
 .../dropped-features/existential-types.md     |   0
 5 files changed, 29 insertions(+), 123 deletions(-)
 create mode 100644 docs/_spec/A2-scala-2-compatibility.md
 rename docs/_spec/{TODOreference => APPLIEDreference}/dropped-features/existential-types.md (100%)

diff --git a/docs/_spec/03-types.md b/docs/_spec/03-types.md
index 42157b176888..29427bafbfce 100644
--- a/docs/_spec/03-types.md
+++ b/docs/_spec/03-types.md
@@ -349,50 +349,12 @@ trait Function´_n´[-´T_1´, ..., -´T_n´, +´U´] {
 
 Hence, function types are [covariant](04-basic-declarations-and-definitions.html#variance-annotations) in their result type and contravariant in their argument types.
 
-### Existential Types
-
-```ebnf
-Type               ::= InfixType ExistentialClauses
-ExistentialClauses ::= ‘forSome’ ‘{’ ExistentialDcl
-                       {semi ExistentialDcl} ‘}’
-ExistentialDcl     ::= ‘type’ TypeDcl
-                    |  ‘val’ ValDcl
-```
-
-An _existential type_ has the form `´T´ forSome { ´Q´ }` where ´Q´ is a sequence of [type declarations](04-basic-declarations-and-definitions.html#type-declarations-and-type-aliases).
-
-Let ´t_1[\mathit{tps}\_1] >: L_1 <: U_1 , \ldots , t_n[\mathit{tps}\_n] >: L_n <: U_n´ be the types declared in ´Q´ (any of the type parameter sections `[ ´\mathit{tps}_i´ ]` might be missing).
-The scope of each type ´t_i´ includes the type ´T´ and the existential clause ´Q´.
-The type variables ´t_i´ are said to be _bound_ in the type `´T´ forSome { ´Q´ }`.
-Type variables which occur in a type ´T´ but which are not bound in ´T´ are said to be _free_ in ´T´.
-
-A _type instance_ of `´T´ forSome { ´Q´ }` is a type ´\sigma T´ where ´\sigma´ is a substitution over ´t_1 , \ldots , t_n´ such that, for each ´i´, ´\sigma L_i <: \sigma t_i <: \sigma U_i´.
-The set of values denoted by the existential type `´T´ forSome {´\,Q\,´}` is the union of the set of values of all its type instances.
-
-A _skolemization_ of `´T´ forSome { ´Q´ }` is a type instance ´\sigma T´, where ´\sigma´ is the substitution ´[t_1'/t_1 , \ldots , t_n'/t_n]´ and each ´t_i'´ is a fresh abstract type with lower bound ´\sigma L_i´ and upper bound ´\sigma U_i´.
-
-#### Simplification Rules
-
-Existential types obey the following four equivalences:
-
-1. Multiple for-clauses in an existential type can be merged. E.g., `´T´ forSome { ´Q´ } forSome { ´Q'´ }` is equivalent to `´T´ forSome { ´Q´ ; ´Q'´}`.
-1. Unused quantifications can be dropped. 
-E.g., `´T´ forSome { ´Q´ ; ´Q'´}` where none of the types defined in ´Q'´ are referred to by ´T´ or ´Q´, is equivalent to `´T´ forSome {´ Q ´}`.
-1. An empty quantification can be dropped. E.g., `´T´ forSome { }` is equivalent to ´T´.
-1. An existential type `´T´ forSome { ´Q´ }` where ´Q´ contains a clause `type ´t[\mathit{tps}] >: L <: U´` is equivalent to the type `´T'´ forSome { ´Q´ }` where ´T'´ results from ´T´ by replacing every [covariant occurrence](04-basic-declarations-and-definitions.html#variance-annotations) of ´t´ in ´T´ by ´U´ and by replacing every contravariant occurrence of ´t´ in ´T´ by ´L´.
-
-#### Existential Quantification over Values
-
-As a syntactic convenience, the bindings clause in an existential type may also contain value declarations `val ´x´: ´T´`.
-An existential type `´T´ forSome { ´Q´; val ´x´: ´S\,´;´\,Q'´ }` is treated as a shorthand for the type `´T'´ forSome { ´Q´; type ´t´ <: ´S´ with Singleton; ´Q'´ }`, where ´t´ is a fresh type name and ´T'´ results from ´T´ by replacing every occurrence of `´x´.type` with ´t´.
-
-#### Placeholder Syntax for Existential Types
+#### Wildcard Types
 
 ```ebnf
 WildcardType   ::=  ‘_’ TypeBounds
 ```
-
-Scala supports a placeholder syntax for existential types.
+<!-- TODO: Update this to use new mechanism -->
 A _wildcard type_ is of the form `_´\;´>:´\,L\,´<:´\,U´`.
 Both bound clauses may be omitted.
 If a lower bound clause `>:´\,L´` is missing, `>:´\,´scala.Nothing` is assumed.
@@ -411,60 +373,6 @@ where ´t´ is some fresh type variable.
 Wildcard types may also appear as parts of [infix types](#infix-types), [function types](#function-types), or [tuple types](#tuple-types).
 Their expansion is then the expansion in the equivalent parameterized type.
 
-###### Example
-
-Assume the class definitions
-
-```scala
-class Ref[T]
-abstract class Outer { type T }
-```
-
-Here are some examples of existential types:
-
-```scala
-Ref[T] forSome { type T <: java.lang.Number }
-Ref[x.T] forSome { val x: Outer }
-Ref[x_type # T] forSome { type x_type <: Outer with Singleton }
-```
-
-The last two types in this list are equivalent.
-An alternative formulation of the first type above using wildcard syntax is:
-
-```scala
-Ref[_ <: java.lang.Number]
-```
-
-###### Example
-
-The type `List[List[_]]` is equivalent to the existential type
-
-```scala
-List[List[t] forSome { type t }]
-```
-
-###### Example
-
-Assume a covariant type
-
-```scala
-class List[+T]
-```
-
-The type
-
-```scala
-List[T] forSome { type T <: java.lang.Number }
-```
-
-is equivalent (by simplification rule 4 above) to
-
-```scala
-List[java.lang.Number] forSome { type T <: java.lang.Number }
-```
-
-which is in turn equivalent (by simplification rules 2 and 3 above) to `List[java.lang.Number]`.
-
 ## Non-Value Types
 
 The types explained in the following do not denote sets of values, nor do they appear explicitly in programs. 
@@ -599,18 +507,15 @@ These notions are defined mutually recursively as follows.
   If ´T´ is an alias or abstract type, the previous clauses apply.
   Otherwise, ´T´ must be a (possibly parameterized) class type, which is defined in some class ´B´.
   Then the base types of `´S´#´T´` are the base types of ´T´ in ´B´ seen from the prefix type ´S´.
-  - The base types of an existential type `´T´ forSome { ´Q´ }` are all types `´S´ forSome { ´Q´ }` where ´S´ is a base type of ´T´.
 
 1. The notion of a type ´T´ _in class ´C´ seen from some prefix type ´S´_ makes sense only if the prefix type ´S´ has a type instance of class ´C´ as a base type, say `´S'´#´C´[´T_1, ..., T_n´]`.
 Then we define as follows.
   - If `´S´ = ´\epsilon´.type`, then ´T´ in ´C´ seen from ´S´ is ´T´ itself.
-  - Otherwise, if ´S´ is an existential type `´S'´ forSome { ´Q´ }`, and ´T´ in ´C´ seen from ´S'´ is ´T'´, then ´T´ in ´C´ seen from ´S´ is `´T'´ forSome {´\,Q\,´}`.
   - Otherwise, if ´T´ is the ´i´'th type parameter of some class ´D´, then
     - If ´S´ has a base type `´D´[´U_1, ..., U_n´]`, for some type parameters `[´U_1, ..., U_n´]`, then ´T´ in ´C´ seen from ´S´ is ´U_i´.
     - Otherwise, if ´C´ is defined in a class ´C'´, then ´T´ in ´C´ seen from ´S´ is the same as ´T´ in ´C'´ seen from ´S'´.
     - Otherwise, if ´C´ is not defined in another class, then ´T´ in ´C´ seen from ´S´ is ´T´ itself.
-  - Otherwise, if ´T´ is the singleton type `´D´.this.type` for some class ´D´
-    then
+  - Otherwise, if ´T´ is the singleton type `´D´.this.type` for some class ´D´ then
     - If ´D´ is a subclass of ´C´ and ´S´ has a type instance of class ´D´ among its base types, then ´T´ in ´C´ seen from ´S´ is ´S´.
     - Otherwise, if ´C´ is defined in a class ´C'´, then ´T´ in ´C´ seen from ´S´ is the same as ´T´ in ´C'´ seen from ´S'´.
     - Otherwise, if ´C´ is not defined in another class, then ´T´ in ´C´ seen from ´S´ is ´T´ itself.
@@ -676,11 +581,10 @@ The conformance relation ´(<:)´ is the smallest transitive relation that satis
   1. If the ´i´'th type parameter of ´T´ is declared neither covariant nor contravariant, then ´U_i \equiv T_i´.
 - A compound type `´T_1´ with ... with ´T_n´ {´R\,´}` conforms to each of its component types ´T_i´.
 - If ´T <: U_i´ for ´i \in \{ 1, ..., n \}´ and for every binding ´d´ of a type or value ´x´ in ´R´ there exists a member binding of ´x´ in ´T´ which subsumes ´d´, then ´T´ conforms to the compound type `´U_1´ with ... with ´U_n´ {´R\,´}`.
-- The existential type `´T´ forSome {´\,Q\,´}` conforms to ´U´ if its [skolemization](#existential-types) conforms to ´U´.
-- The type ´T´ conforms to the existential type `´U´ forSome {´\,Q\,´}` if ´T´ conforms to one of the [type instances](#existential-types) of `´U´ forSome {´\,Q\,´}`.
 - If ´T_i \equiv T_i'´ for ´i \in \{ 1, ..., n\}´ and ´U´ conforms to ´U'´ then the method type ´(p_1:T_1, ..., p_n:T_n) U´ conforms to ´(p_1':T_1', ..., p_n':T_n') U'´.
 - The polymorphic type ´[a_1 >: L_1 <: U_1, ..., a_n >: L_n <: U_n] T´ conforms to the polymorphic type ´[a_1 >: L_1' <: U_1', ..., a_n >: L_n' <: U_n'] T'´ if, assuming ´L_1' <: a_1 <: U_1', ..., L_n' <: a_n <: U_n'´ one has ´T <: T'´ and ´L_i <: L_i'´ and ´U_i' <: U_i´ for ´i \in \{ 1, ..., n \}´.
-- Type constructors ´T´ and ´T'´ follow a similar discipline. We characterize ´T´ and ´T'´ by their type parameter clauses ´[a_1, ..., a_n]´ and ´[a_1', ..., a_n']´, where an ´a_i´ or ´a_i'´ may include a variance annotation, a higher-order type parameter clause, and bounds.
+- Type constructors ´T´ and ´T'´ follow a similar discipline.
+We characterize ´T´ and ´T'´ by their type parameter clauses ´[a_1, ..., a_n]´ and ´[a_1', ..., a_n']´, where an ´a_i´ or ´a_i'´ may include a variance annotation, a higher-order type parameter clause, and bounds.
 Then, ´T´ conforms to ´T'´ if any list ´[t_1, ..., t_n]´ -- with declared variances, bounds and higher-order type parameter clauses -- of valid type arguments for ´T'´ is also a valid list of type arguments for ´T´ and ´T[t_1, ..., t_n] <: T'[t_1, ..., t_n]´.
 Note that this entails that:
   - The bounds on ´a_i´ must be weaker than the corresponding bounds declared for ´a'_i´.
@@ -790,8 +694,6 @@ A type designator is volatile if it is an alias of a volatile type, or if it des
 
 A singleton type `´p´.type` is volatile, if the underlying type of path ´p´ is volatile.
 
-An existential type `´T´ forSome {´\,Q\,´}` is volatile if ´T´ is volatile.
-
 ## Type Erasure
 
 A type is called _generic_ if it contains type arguments or type variables.
@@ -806,7 +708,6 @@ The erasure mapping is defined as follows.
 - The erasure of a singleton type `´p´.type` is the erasure of the type of ´p´.
 - The erasure of a type projection `´T´#´x´` is `|´T´|#´x´`.
 - The erasure of a compound type `´T_1´ with ... with ´T_n´ {´R\,´}` is the erasure of the intersection dominator of ´T_1, ..., T_n´.
-- The erasure of an existential type `´T´ forSome {´\,Q\,´}` is ´|T|´.
 
 The _intersection dominator_ of a list of types ´T_1, ..., T_n´ is computed as follows.
 Let ´T_{i_1}, ..., T_{i_m}´ be the subsequence of types ´T_i´ which are not supertypes of some other type ´T_j´.
diff --git a/docs/_spec/06-expressions.md b/docs/_spec/06-expressions.md
index c2c4d1f56afa..3b39dec25829 100644
--- a/docs/_spec/06-expressions.md
+++ b/docs/_spec/06-expressions.md
@@ -59,6 +59,7 @@ When we write "expression ´e´ is expected to conform to type ´T´", we mean:
 The following skolemization rule is applied universally for every expression:
 If the type of an expression would be an existential type ´T´, then the type of the expression is assumed instead to be a [skolemization](03-types.html#existential-types) of ´T´.
 
+<!-- TODO: Replace by description of Scala 3 skolemization -->
 Skolemization is reversed by type packing.
 Assume an expression ´e´ of type ´T´ and let ´t_1[\mathit{tps}\_1] >: L_1 <: U_1, ..., t_n[\mathit{tps}\_n] >: L_n <: U_n´ be all the type variables created by skolemization of some part of ´e´ which are free in ´T´.
 Then the _packed type_ of ´e´ is
@@ -454,6 +455,7 @@ The final expression can be omitted, in which case the unit value `()` is assume
 The expected type of the final expression ´e´ is the expected type of the block.
 The expected type of all preceding statements is undefined.
 
+<!-- TODO: Rewrite when type avoidance section is done -->
 The type of a block `´s_1´; ...; ´s_n´; ´e´` is `´T´ forSome {´\,Q\,´}`, where ´T´ is the type of ´e´ and ´Q´ contains [existential clauses](03-types.html#existential-types) for every value or type name which is free in ´T´ and which is defined locally in one of the statements ´s_1, ..., s_n´.
 We say the existential clause _binds_ the occurrence of the value or type name.
 Specifically,
@@ -467,23 +469,7 @@ It is an error if ´c´ carries type parameters.
 
 Evaluation of the block entails evaluation of its statement sequence, followed by an evaluation of the final expression ´e´, which defines the result of the block.
 
-A block expression `{´c_1´; ...; ´c_n´}` where ´s_1, ..., s_n´ are case clauses forms a [pattern matching anonymous function](08-pattern-matching.html#pattern-matching-anonymous-functions).
-
-###### Example
-Assuming a class `Ref[T](x: T)`, the block
-
-```scala
-{ class C extends B {´\ldots´} ; new Ref(new C) }
-```
-
-has the type `Ref[_1] forSome { type _1 <: B }`.
-The block
-
-```scala
-{ class C extends B {´\ldots´} ; new C }
-```
-
-simply has type `B`, because with the rules [here](03-types.html#simplification-rules) the existentially quantified type `_1 forSome { type _1 <: B }` can be simplified to `B`.
+A block expression `{´c_1´; ...; ´c_n´}` where ´c_1, ..., c_n´ are case clauses forms a [pattern matching anonymous function](08-pattern-matching.html#pattern-matching-anonymous-functions).
 
 ## Prefix, Infix, and Postfix Operations
 
@@ -1190,6 +1176,7 @@ question: given
 - A parameterized method ´m´ of type `(´p_1:T_1, ..., p_n:T_n´)´U´` is _as specific as_ some other member ´m'´ of type ´S´ if ´m'´ is [applicable](#method-applications) to arguments `(´p_1, ..., p_n´)` of types ´T_1, ..., T_n´.
 - A polymorphic method of type `[´a_1´ >: ´L_1´ <: ´U_1, ..., a_n´ >: ´L_n´ <: ´U_n´]´T´` is as specific as some other member of type ´S´ if ´T´ is as specific as ´S´ under the assumption that for ´i = 1, ..., n´ each ´a_i´ is an abstract type name bounded from below by ´L_i´ and from above by ´U_i´.
 - A member of any other type is always as specific as a parameterized method or a polymorphic method.
+<!-- TODO: check the following, as it reduces to "the member of type ´T´ is as specific as the member of type ´U´ if the ´T´ conforms to ´U´." -->
 - Given two members of types ´T´ and ´U´ which are neither parameterized nor polymorphic method types, the member of type ´T´ is as specific as the member of type ´U´ if the existential dual of ´T´ conforms to the existential dual of ´U´.
 Here, the existential dual of a polymorphic type `[´a_1´ >: ´L_1´ <: ´U_1, ..., a_n´ >: ´L_n´ <: ´U_n´]´T´` is `´T´ forSome { type ´a_1´ >: ´L_1´ <: ´U_1´, ..., type ´a_n´ >: ´L_n´ <: ´U_n´}`.
 The existential dual of every other type is the type itself.
diff --git a/docs/_spec/07-implicits.md b/docs/_spec/07-implicits.md
index a0db9dd9b418..85aaadda87e1 100644
--- a/docs/_spec/07-implicits.md
+++ b/docs/_spec/07-implicits.md
@@ -54,7 +54,7 @@ If there are no eligible identifiers under this rule, then, second, eligible are
 
 The _implicit scope_ of a type ´T´ consists of all [companion modules](05-classes-and-objects.html#object-definitions) of classes that are associated with the implicit parameter's type.
 Here, we say a class ´C´ is _associated_ with a type ´T´ if it is a [base class](05-classes-and-objects.html#class-linearization) of some part of ´T´.
-
+<!-- TODO: Check if this is still accurate -->
 The _parts_ of a type ´T´ are:
 
 - if ´T´ is a compound type `´T_1´ with ... with ´T_n´`, the union of the parts of ´T_1, ..., T_n´, as well as ´T´ itself;
@@ -64,7 +64,6 @@ The _parts_ of a type ´T´ are:
 - if ´T´ is a type alias, the parts of its expansion;
 - if ´T´ is an abstract type, the parts of its upper bound;
 - if ´T´ denotes an implicit conversion to a type with a method with argument types ´T_1, ..., T_n´ and result type ´U´, the union of the parts of ´T_1, ..., T_n´ and ´U´;
-- the parts of quantified (existential or universal) and annotated types are defined as the parts of the underlying types (e.g., the parts of `T forSome { ... }` are the parts of `T`);
 - in all other cases, just ´T´ itself.
 
 Note that packages are internally represented as classes with companion modules to hold the package members.
diff --git a/docs/_spec/A2-scala-2-compatibility.md b/docs/_spec/A2-scala-2-compatibility.md
new file mode 100644
index 000000000000..f4a4970cb81a
--- /dev/null
+++ b/docs/_spec/A2-scala-2-compatibility.md
@@ -0,0 +1,19 @@
+
+### Existential Types
+
+Existential types using `forSome` (as in [SLS §3.2.12](https://www.scala-lang.org/files/archive/spec/2.13/03-types.html#existential-types)) are not available in Scala 3.
+Therefore when reading an existential type from Scala 2, the following happens:
+
+Existential types that can be expressed using only wildcards (but not
+`forSome`) are treated as refined types.
+For instance, the type
+```scala
+Map[_ <: AnyRef, Int]
+```
+is treated as the type `Map`, where the first type parameter
+is upper-bounded by `AnyRef` and the second type parameter is an alias
+of `Int`.
+
+When reading class files compiled with Scala 2, Scala 3 will do a best
+effort to approximate existential types with its own types. It will
+issue a warning that a precise emulation is not possible.
\ No newline at end of file
diff --git a/docs/_spec/TODOreference/dropped-features/existential-types.md b/docs/_spec/APPLIEDreference/dropped-features/existential-types.md
similarity index 100%
rename from docs/_spec/TODOreference/dropped-features/existential-types.md
rename to docs/_spec/APPLIEDreference/dropped-features/existential-types.md

From 4ef7f6047a65179d0b6baa7c65969048c385c478 Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Wed, 12 Oct 2022 17:11:27 +0200
Subject: [PATCH 429/657] Add TODOs for later, Cleanup

---
 docs/_spec/03-types.md                        | 16 ++------
 .../04-basic-declarations-and-definitions.md  | 40 +------------------
 2 files changed, 4 insertions(+), 52 deletions(-)

diff --git a/docs/_spec/03-types.md b/docs/_spec/03-types.md
index 29427bafbfce..95da81d19850 100644
--- a/docs/_spec/03-types.md
+++ b/docs/_spec/03-types.md
@@ -63,7 +63,7 @@ StableId        ::=  id
                   |  [id ‘.’] ‘super’ [ClassQualifier] ‘.’ id
 ClassQualifier  ::= ‘[’ id ‘]’
 ```
-
+<!-- TODO: Clarify paragraph -->
 Paths are not types themselves, but they can be a part of named types and in that function form a central role in Scala's type system.
 
 A path is one of the following.
@@ -388,6 +388,7 @@ Method types associate to the right: ´(\mathit{Ps}\_1)(\mathit{Ps}\_2)U´ is tr
 A special case are types of methods without any parameters.
 They are written here `=> T`. Parameterless methods name expressions that are re-evaluated each time the parameterless method name is referenced.
 
+<!-- TODO: replace by reference to eta-expansion instead -->
 Method types do not exist as types of values.
 If a method name is used as a value, its type is [implicitly converted](06-expressions.html#implicit-conversions) to a corresponding function type.
 
@@ -642,20 +643,9 @@ A _weak least upper bound_ is a least upper bound with respect to weak conforman
 A type ´T´ is _compatible_ to a type ´U´ if ´T´ (or its corresponding function type) [weakly conforms](#weak-conformance) to ´U´ after applying [eta-expansion](06-expressions.html#eta-expansion).
 If ´T´ is a method type, it's converted to the corresponding function type.
 If the types do not weakly conform, the following alternatives are checked in order:
-- [view application](07-implicits.html#views): there's an implicit view from ´T´ to ´U´;
 - dropping by-name modifiers: if ´U´ is of the shape `´=> U'´` (and ´T´ is not), `´T <:_w U'´`;
 - SAM conversion: if ´T´ corresponds to a function type, and ´U´ declares a single abstract method whose type [corresponds](06-expressions.html#sam-conversion) to the function type ´U'´, `´T <:_w U'´`.
-
-<!--- TODO: include other implicit conversions in addition to view application?
-
-  trait Proc { def go(x: Any): Unit }
-
-  def foo(x: Any => Unit): Unit = ???
-  def foo(x: Proc): Unit = ???
-
-  foo((x: Any) => 1) // works when you drop either foo overload since value discarding is applied
-
--->
+- [implicit conversion](07-implicits.html#views): there's an implicit conversion from ´T´ to ´U´ in scope;
 
 #### Examples
 
diff --git a/docs/_spec/04-basic-declarations-and-definitions.md b/docs/_spec/04-basic-declarations-and-definitions.md
index af98eef2a37d..a4f5b6d307c2 100644
--- a/docs/_spec/04-basic-declarations-and-definitions.md
+++ b/docs/_spec/04-basic-declarations-and-definitions.md
@@ -40,53 +40,15 @@ by commas. These are expanded according to the following scheme:
 \VAL;x, y: T = e && \VAL; x: T = e \\
                  && \VAL; y: T = x \\[0.5em]
 
-\LET;x, y: T = e && \LET; x: T = e \\
-                 && \VAL; y: T = x \\[0.5em]
-
-\DEF;x, y (ps): T = e &\tab\mbox{expands to}\tab& \DEF; x(ps): T = e \\
-                      && \DEF; y(ps): T = x(ps)\\[0.5em]
-
 \VAR;x, y: T := e && \VAR;x: T := e\\
                   && \VAR;y: T := x\\[0.5em]
-
-\TYPE;t,u = T && \TYPE; t = T\\
-              && \TYPE; u = t\\[0.5em]
 \eda
 
-All definitions have a ``repeated form`` where the initial
-definition keyword is followed by several constituent definitions
-which are separated by commas.  A repeated definition is
-always interpreted as a sequence formed from the
-constituent definitions. E.g. the function definition
-`def f(x) = x, g(y) = y` expands to
-`def f(x) = x; def g(y) = y` and
-the type definition
-`type T, U <: B` expands to
-`type T; type U <: B`.
-}
-\comment{
-If an element in such a sequence introduces only the defined name,
-possibly with some type or value parameters, but leaves out any
-additional parts in the definition, then those parts are implicitly
-copied from the next subsequent sequence element which consists of
-more than just a defined name and parameters. Examples:
-
-- []
 The variable declaration `var x, y: Int`
 expands to `var x: Int; var y: Int`.
-- []
+
 The value definition `val x, y: Int = 1`
 expands to `val x: Int = 1; val y: Int = 1`.
-- []
-The class definition `case class X(), Y(n: Int) extends Z` expands to
-`case class X extends Z; case class Y(n: Int) extends Z`.
-- The object definition `case object Red, Green, Blue extends Color`~
-expands to
-```scala
-case object Red extends Color
-case object Green extends Color
-case object Blue extends Color
-```
 -->
 
 ## Value Declarations and Definitions

From d5e2a69cc3eaa17dc04e3937d3ba072d2f02e0aa Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Wed, 19 Oct 2022 14:55:57 +0200
Subject: [PATCH 430/657] Apply limit22.md

---
 docs/_spec/03-types.md                        | 38 +++++++++++--------
 docs/_spec/06-expressions.md                  | 13 ++++++-
 docs/_spec/08-pattern-matching.md             | 10 ++++-
 docs/_spec/12-the-scala-standard-library.md   | 36 ++++++++++++++----
 .../dropped-features/limit22.md               |  0
 5 files changed, 70 insertions(+), 27 deletions(-)
 rename docs/_spec/{TODOreference => APPLIEDreference}/dropped-features/limit22.md (100%)

diff --git a/docs/_spec/03-types.md b/docs/_spec/03-types.md
index 95da81d19850..acb3a37faf14 100644
--- a/docs/_spec/03-types.md
+++ b/docs/_spec/03-types.md
@@ -217,22 +217,27 @@ G[S, Int]             // illegal: S constrains its parameter to
 SimpleType    ::=   ‘(’ Types ‘)’
 ```
 
-A _tuple type_ ´(T_1 , ... , T_n)´ is an alias for the class `scala.Tuple´n´[´T_1´, ... , ´T_n´]`, where ´n \geq 2´.
+A _tuple type_ ´(T_1, ..., T_n)´ where ´n \geq 2´ is an alias for the type `´T_1´ *: ... *: ´T_n´ *: scala.EmptyTuple`.
+
+Note:
+`(´T´)` is just the type ´T´, and not `´T´ *: scala.EmptyTuple`.
+`()` is not a valid type, and not `scala.EmptyTuple`.
+
+If ´n \leq 22´, the type `´T_1´ *: ... *: ´T_n´ *: scala.EmptyTuple` is both a subtype and a supertype of tuple class `scala.Tuple´_n´[´T_1´, ..., ´T_n´]`.
 
 Tuple classes are case classes whose fields can be accessed using selectors `_1`, ..., `_n`.
-Their functionality is abstracted in a corresponding `Product` trait.
+Their functionality is abstracted in the corresponding `scala.Product_´n´` trait.
 The _n_-ary tuple class and product trait are defined at least as follows in the standard Scala library (they might also add other methods and implement other traits).
 
 ```scala
 case class Tuple´_n´[+´T_1´, ..., +´T_n´](_1: ´T_1´, ..., _n: ´T_n´)
 extends Product´_n´[´T_1´, ..., ´T_n´]
 
-trait Product´_n´[+´T_1´, ..., +´T_n´] {
+trait Product´_n´[+´T_1´, ..., +´T_n´] extends Product:
   override def productArity = ´n´
   def _1: ´T_1´
   ...
   def _n: ´T_n´
-}
 ```
 
 ### Annotated Types
@@ -329,25 +334,26 @@ FunctionArgs      ::=  InfixType
                     |  ‘(’ [ ParamType {‘,’ ParamType } ] ‘)’
 ```
 
-The type ´(T_1, ..., T_n) \Rightarrow U´ represents the set of function values that take arguments of types ´T_1, ..., Tn´ and yield results of type ´U´.
-In the case of exactly one argument type ´T \Rightarrow U´ is a shorthand for ´(T) \Rightarrow U´.
-An argument type of the form ´\Rightarrow T´ represents a [call-by-name parameter](04-basic-declarations-and-definitions.html#by-name-parameters) of type ´T´.
+The type ´(T_1, ..., T_n) \Rightarrow R´ represents the set of function values that take arguments of types ´T_1, ..., Tn´ and yield results of type ´R´.
+The case of exactly one argument type ´T \Rightarrow R´ is a shorthand for ´(T) \Rightarrow R´.
+An argument type of the form ´\Rightarrow T´ represents a [call-by-name parameter](04-basic-declarations-and-definitions.md#by-name-parameters) of type ´T´.
 
-Function types associate to the right, e.g. ´S \Rightarrow T \Rightarrow U´ is the same as ´S \Rightarrow (T \Rightarrow U)´.
+Function types associate to the right, e.g. ´S \Rightarrow T \Rightarrow R´ is the same as ´S \Rightarrow (T \Rightarrow R)´.
+
+Function types are [covariant](04-basic-declarations-and-definitions.md#variance-annotations) in their result type and [contravariant](04-basic-declarations-and-definitions.md#variance-annotations) in their argument types.
 
 Function types are shorthands for class types that define an `apply` method.
-Specifically, the ´n´-ary function type ´(T_1 , \ldots , T_n) \Rightarrow U´ is a shorthand for the class type `Function´_n´[´T_1´ , … , ´T_n´, ´U´]`.
-Such class types are defined in the Scala library for ´n´ between 0 and 22 as follows.
+Specifically, the ´n´-ary function type ´(T_1, ..., T_n) \Rightarrow R´ is a shorthand for the class type `Function´_n´[´T_1´, ..., ´T_n´, ´R´]`. 
+In particular ´() \Rightarrow R´ is a shorthand for class type `Function´_0´[´R´]`.
+
+Such class types behave as if they were instances of the following trait:
 
 ```scala
-package scala
-trait Function´_n´[-´T_1´, ..., -´T_n´, +´U´] {
-  def apply(´x_1´: ´T_1´, ..., ´x_n´: ´T_n´): ´U´
-  override def toString = "<function>"
-}
+trait Function´_n´[-´T_1´, ..., -´T_n´, +´R´]:
+  def apply(´x_1´: ´T_1´, ..., ´x_n´: ´T_n´): ´R´
 ```
 
-Hence, function types are [covariant](04-basic-declarations-and-definitions.html#variance-annotations) in their result type and contravariant in their argument types.
+Their exact supertype and implementation can be consulted in the [function classes section](./12-the-scala-standard-library.md#the-function-classes) of the standard library page in this document.
 
 #### Wildcard Types
 
diff --git a/docs/_spec/06-expressions.md b/docs/_spec/06-expressions.md
index 3b39dec25829..8db2c1e66c98 100644
--- a/docs/_spec/06-expressions.md
+++ b/docs/_spec/06-expressions.md
@@ -381,9 +381,15 @@ Type applications can be omitted if [local type inference](#local-type-inference
 ```ebnf
 SimpleExpr   ::=  ‘(’ [Exprs] ‘)’
 ```
+A _tuple expression_ `(´e_1´, ..., ´e_n´)` where ´n \geq 2´ is equivalent to the expression `´e_1´ *: ... *: ´e_n´ *: scala.EmptyTuple`.
 
-A _tuple expression_ `(´e_1´, ..., ´e_n´)` is an alias for the class instance creation `scala.Tuple´n´(´e_1´, ..., ´e_n´)`, where ´n \geq 2´.
-The empty tuple `()` is the unique value of type `scala.Unit`.
+Note:
+As calls to `*:` are slow, a more efficient translation is free to be implemented.
+For example, `(´e_1´, ´e_2´)` could be translated to `scala.Tuple2(´e_1´, ´e_2´)`, which is indeed equivalent to `´e_1´ *: ´e_2´ *: scala.EmptyTuple`.
+
+Note:
+The expression `(´e_1´)` is not equivalent to `´e_1´ *: scala.EmptyTuple`, but instead a regular parenthesized expression.
+The expression `()` is not an alias for `scala.EmptyTuple`, but instead the unique value of type `scala.Unit`.
 
 ## Instance Creation Expressions
 
@@ -909,6 +915,9 @@ Binding         ::=  (id | ‘_’) [‘:’ Type]
 The anonymous function of arity ´n´, `(´x_1´: ´T_1, ..., x_n´: ´T_n´) => e` maps parameters ´x_i´ of types ´T_i´ to a result given by expression ´e´.
 The scope of each formal parameter ´x_i´ is ´e´.
 Formal parameters must have pairwise distinct names.
+Type bindings can be omitted, in which case the compiler will attempt to infer valid bindings.
+
+Note: `() => ´e´` defines a nullary function (´n´ = 0), and not for example `(_: Unit) => ´e´`.
 
 In the case of a single untyped formal parameter, `(´x\,´) => ´e´` can be abbreviated to `´x´ => ´e´`.
 If an anonymous function `(´x´: ´T\,´) => ´e´` with a single typed parameter appears as the result expression of a block, it can be abbreviated to `´x´: ´T´ => e`.
diff --git a/docs/_spec/08-pattern-matching.md b/docs/_spec/08-pattern-matching.md
index 97fb73d58b06..df1c396631ea 100644
--- a/docs/_spec/08-pattern-matching.md
+++ b/docs/_spec/08-pattern-matching.md
@@ -185,7 +185,15 @@ This is further discussed [here](#pattern-sequences).
   SimplePattern   ::=  ‘(’ [Patterns] ‘)’
 ```
 
-A _tuple pattern_ `(´p_1´, ..., ´p_n´)` is an alias for the constructor pattern `scala.Tuple´n´(´p_1´, ..., ´p_n´)`, where ´n \geq 2´. The empty tuple `()` is the unique value of type `scala.Unit`.
+A _tuple pattern_ `(´p_1´, ..., ´p_n´)` where ´n \geq 2´ is equivalent to `´p_1´ *: ... *: ´p_n´ *: scala.EmptyTuple`.
+
+Note:
+`()` is equivalent to `_: scala.Unit`, and not `scala.EmptyTuple`.
+`(´pat´)` is a pattern matching ´pat´, and not `´pat´ *: scala.EmptyTuple`.
+
+Note:
+As such patterns with `*:` are slow, a more efficient translation is free to be implemented.
+For example, `(´p_1´, ´p_2´)` could be translated to `scala.Tuple2(´p_1´, ´p_2´)`, which is indeed equivalent to `´p_1´ *: ´p_2´ *: scala.EmptyTuple`.
 
 ### Extractor Patterns
 
diff --git a/docs/_spec/12-the-scala-standard-library.md b/docs/_spec/12-the-scala-standard-library.md
index 401735286a51..bea9c9c574d4 100644
--- a/docs/_spec/12-the-scala-standard-library.md
+++ b/docs/_spec/12-the-scala-standard-library.md
@@ -288,6 +288,7 @@ def + (that: Any): String
 
 which concatenates its left operand with the textual representation of its right operand.
 
+<!-- TODO: re-add ? with explanations of: EmptyTuple, *:, NonEmptyTuple, TupleXXL
 ### The `Tuple` classes
 
 Scala defines tuple classes `Tuple´n´` for ´n = 2, ..., 22´.
@@ -299,20 +300,36 @@ case class Tuple´n´[+T_1, ..., +T_n](_1: T_1, ..., _´n´: T_´n´) {
   def toString = "(" ++ _1 ++ "," ++ ... ++ "," ++ _´n´ ++ ")"
 }
 ```
-
+-->
 ### The `Function` Classes
 
-Scala defines function classes `Function´n´` for ´n = 1 , \ldots , 22´.
-These are defined as follows.
+For each class type `Function´n´` where ´n = 0, ..., 22´, Scala defines the following function class:
 
 ```scala
 package scala
-trait Function´n´[-T_1, ..., -T_´n´, +R] {
-  def apply(x_1: T_1, ..., x_´n´: T_´n´): R
-  def toString = "<function>"
-}
+trait Function´_n´[-´T_1´, ..., -´T_n´, +´R´]:
+  def apply(´x_1´: ´T_1´, ..., ´x_n´: ´T_n´): ´R´
+  override def toString = "<function´_n´>"
+  def curried: ´T_1´ => ... => ´T_n´ => R = ...
+  def tupled: ((´T_1´, ..., ´T_n´)) => R = ...
+```
+
+For function types `Function´n´` where ´n > 22´, Scala defines a unique function class:
+
+```scala
+package scala
+trait FunctionXXL:
+  def apply(xs: IArray[Object]): Object
+  override def toString = "<functionXXL>"
 ```
 
+There is no loss of type safety, as the internal representation is still `Function´n´` for all ´n´.
+However this means methods `curried` and `tupled` are not available on functions with more than 22 parameters.
+
+The implicitly imported [`Predef`](#the-predef-object) object defines the name
+`Function` as an alias of `Function1`.
+
+<!-- TODO: Remove below ? -->
 The `PartialFunction` subclass of `Function1` represents functions that (indirectly) specify their domain.
 Use the `isDefined` method to query whether the partial function is defined for a given input (i.e., whether the input is part of the function's domain).
 
@@ -322,7 +339,10 @@ class PartialFunction[-A, +B] extends Function1[A, B] {
 }
 ```
 
-The implicitly imported [`Predef`](#the-predef-object) object defines the name `Function` as an alias of `Function1`.
+### Trait `Product`
+<!-- TODO: Move somewhere else ? -->
+<!-- TODO: Could not find more info on which non-Product methods case class automatically define  -->
+All case classes automatically extend the `Product` trait (and generate synthetic methods to conform to it) (but not `Product´n´`), and define a `_´n´` method for each of their arguments.
 
 ### Class `Array`
 
diff --git a/docs/_spec/TODOreference/dropped-features/limit22.md b/docs/_spec/APPLIEDreference/dropped-features/limit22.md
similarity index 100%
rename from docs/_spec/TODOreference/dropped-features/limit22.md
rename to docs/_spec/APPLIEDreference/dropped-features/limit22.md

From 3b27b5793c615bda71e69fc4a947bc218f9723d4 Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Fri, 14 Oct 2022 14:00:21 +0200
Subject: [PATCH 431/657] Small fixes

---
 docs/_spec/06-expressions.md                | 2 +-
 docs/_spec/12-the-scala-standard-library.md | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/_spec/06-expressions.md b/docs/_spec/06-expressions.md
index 8db2c1e66c98..16f2f527a9dc 100644
--- a/docs/_spec/06-expressions.md
+++ b/docs/_spec/06-expressions.md
@@ -967,7 +967,7 @@ x => x                             // The identity function
 
 f => g => x => f(g(x))             // Curried function composition
 
-(x: Int,y: Int) => x + y           // A summation function
+(x: Int, y: Int) => x + y          // A summation function
 
 () => { count += 1; count }        // The function which takes an
                                    // empty parameter list ´()´,
diff --git a/docs/_spec/12-the-scala-standard-library.md b/docs/_spec/12-the-scala-standard-library.md
index bea9c9c574d4..631596e0d272 100644
--- a/docs/_spec/12-the-scala-standard-library.md
+++ b/docs/_spec/12-the-scala-standard-library.md
@@ -621,7 +621,7 @@ object Predef {
 
   def assume(assumption: Boolean, message: => Any) {
     if (!assumption)
-      throw new IllegalArgumentException(message.toString)
+      throw new IllegalArgumentException("assumption failed: " + message.toString)
   }
 
   def require(requirement: Boolean) {

From 7cd5073b7b8251e76354c56b94fe982a7c5a86c1 Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Fri, 14 Oct 2022 14:00:39 +0200
Subject: [PATCH 432/657] Add TODO: Update as Implicit Conversion

---
 docs/_spec/07-implicits.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/docs/_spec/07-implicits.md b/docs/_spec/07-implicits.md
index 85aaadda87e1..2cd80f227cd4 100644
--- a/docs/_spec/07-implicits.md
+++ b/docs/_spec/07-implicits.md
@@ -270,6 +270,7 @@ Throwable => Ordered[Throwable],
 
 Since the second type in the sequence is equal to the first, the compiler will issue an error signalling a divergent implicit expansion.
 
+<!-- TODO: Update as Implicit Conversion -->
 ## Views
 
 Implicit parameters and methods can also define implicit conversions called views.

From d88f3b86d48bdf88f592f249cb352e18e24d462a Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Thu, 20 Oct 2022 14:07:36 +0200
Subject: [PATCH 433/657] Apply macros.md As Scala 2 macros were an
 experimental feature, they were not included in the spec, and the macro
 keyword is still a keyword there is thus nothing to do (Scala 3 macros  will
 get their own commits through the corresponding pages)

---
 .../dropped-features/macros.md                                    | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename docs/_spec/{TODOreference => APPLIEDreference}/dropped-features/macros.md (100%)

diff --git a/docs/_spec/TODOreference/dropped-features/macros.md b/docs/_spec/APPLIEDreference/dropped-features/macros.md
similarity index 100%
rename from docs/_spec/TODOreference/dropped-features/macros.md
rename to docs/_spec/APPLIEDreference/dropped-features/macros.md

From 04ceaefa9b49d2f19883b5d34435809d70eeb82c Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Thu, 20 Oct 2022 15:38:52 +0200
Subject: [PATCH 434/657] Apply procedure-syntax.md

---
 .../04-basic-declarations-and-definitions.md  | 37 -------------------
 docs/_spec/A2-scala-2-compatibility.md        | 18 ++++++++-
 .../dropped-features/procedure-syntax.md      |  0
 3 files changed, 17 insertions(+), 38 deletions(-)
 rename docs/_spec/{TODOreference => APPLIEDreference}/dropped-features/procedure-syntax.md (100%)

diff --git a/docs/_spec/04-basic-declarations-and-definitions.md b/docs/_spec/04-basic-declarations-and-definitions.md
index a4f5b6d307c2..4145f2b8c2e0 100644
--- a/docs/_spec/04-basic-declarations-and-definitions.md
+++ b/docs/_spec/04-basic-declarations-and-definitions.md
@@ -609,43 +609,6 @@ By contrast, the following application is well formed and yields again the resul
 sum(xs: _*)
 ```
 
-### Procedures
-
-```ebnf
-FunDcl   ::=  FunSig
-FunDef   ::=  FunSig [nl] ‘{’ Block ‘}’
-```
-
-Special syntax exists for procedures, i.e. methods that return the `Unit` value `()`.
-A _procedure declaration_ is a method declaration where the result type is omitted.
-The result type is then implicitly completed to the `Unit` type. E.g., `def ´f´(´\mathit{ps}´)` is equivalent to `def ´f´(´\mathit{ps}´): Unit`.
-
-A _procedure definition_ is a method definition where the result type and the equals sign are omitted; its defining expression must be a block.
-E.g., `def ´f´(´\mathit{ps}´) {´\mathit{stats}´}` is equivalent to `def ´f´(´\mathit{ps}´): Unit = {´\mathit{stats}´}`.
-
-###### Example
-Here is a declaration and a definition of a procedure named `write`:
-
-```scala
-trait Writer {
-  def write(str: String)
-}
-object Terminal extends Writer {
-  def write(str: String) { System.out.println(str) }
-}
-```
-
-The code above is implicitly completed to the following code:
-
-```scala
-trait Writer {
-  def write(str: String): Unit
-}
-object Terminal extends Writer {
-  def write(str: String): Unit = { System.out.println(str) }
-}
-```
-
 ### Method Return Type Inference
 
 A class member definition ´m´ that overrides some other method ´m'´ in a base class of ´C´ may leave out the return type, even if it is recursive.
diff --git a/docs/_spec/A2-scala-2-compatibility.md b/docs/_spec/A2-scala-2-compatibility.md
index f4a4970cb81a..3621887581a6 100644
--- a/docs/_spec/A2-scala-2-compatibility.md
+++ b/docs/_spec/A2-scala-2-compatibility.md
@@ -16,4 +16,20 @@ of `Int`.
 
 When reading class files compiled with Scala 2, Scala 3 will do a best
 effort to approximate existential types with its own types. It will
-issue a warning that a precise emulation is not possible.
\ No newline at end of file
+issue a warning that a precise emulation is not possible.
+
+### Procedure Syntax
+
+Procedure syntax
+```scala
+def f() { ... }
+```
+has been dropped. You need to write one of the following instead:
+```scala
+def f() = { ... }
+def f(): Unit = { ... }
+```
+Scala 3 accepts the old syntax under the `-source:3.0-migration` option.
+If the `-migration` option is set, it can even rewrite old syntax to new.
+The [Scalafix](https://scalacenter.github.io/scalafix/) tool also
+can rewrite procedure syntax to make it Scala 3 compatible.
\ No newline at end of file
diff --git a/docs/_spec/TODOreference/dropped-features/procedure-syntax.md b/docs/_spec/APPLIEDreference/dropped-features/procedure-syntax.md
similarity index 100%
rename from docs/_spec/TODOreference/dropped-features/procedure-syntax.md
rename to docs/_spec/APPLIEDreference/dropped-features/procedure-syntax.md

From d76177002f03b14dea11721f939a6e6b05eed119 Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Thu, 20 Oct 2022 16:07:09 +0200
Subject: [PATCH 435/657] Update return type inference Scala 3 does not infer
 more precise types for the return type of overriding methods. This can be
 seen in the following example: ```scala type T type U <: T

abstract class A{
	def m: T
}
class B extends A{
	def m = ??? : U
}
val res: U = (new B).m
```
---
 docs/_spec/04-basic-declarations-and-definitions.md | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/docs/_spec/04-basic-declarations-and-definitions.md b/docs/_spec/04-basic-declarations-and-definitions.md
index 4145f2b8c2e0..1d50fd649efd 100644
--- a/docs/_spec/04-basic-declarations-and-definitions.md
+++ b/docs/_spec/04-basic-declarations-and-definitions.md
@@ -612,9 +612,7 @@ sum(xs: _*)
 ### Method Return Type Inference
 
 A class member definition ´m´ that overrides some other method ´m'´ in a base class of ´C´ may leave out the return type, even if it is recursive.
-In this case, the return type ´R'´ of the overridden method ´m'´, seen as a member of ´C´, is taken as the return type of ´m´ for each recursive invocation of ´m´.
-That way, a type ´R´ for the right-hand side of ´m´ can be determined, which is then taken as the return type of ´m´.
-Note that ´R´ may be different from ´R'´, as long as ´R´ conforms to ´R'´.
+In this case, whether or not `m` is recursive, its return type will be the return type of ´m'´.
 
 ###### Example
 Assume the following definitions:

From b61f22bf8af0128b47b1dcbd22d560ee1ba7f7fb Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Thu, 20 Oct 2022 16:20:30 +0200
Subject: [PATCH 436/657] Apply symlits.md

---
 docs/_spec/01-lexical-syntax.md               | 13 +-----------
 docs/_spec/A1-deprecated.md                   | 21 +++++++++++++++++++
 .../dropped-features/symlits.md               |  0
 3 files changed, 22 insertions(+), 12 deletions(-)
 create mode 100644 docs/_spec/A1-deprecated.md
 rename docs/_spec/{TODOreference => APPLIEDreference}/dropped-features/symlits.md (100%)

diff --git a/docs/_spec/01-lexical-syntax.md b/docs/_spec/01-lexical-syntax.md
index 862e85a014be..e2470e27d2e0 100644
--- a/docs/_spec/01-lexical-syntax.md
+++ b/docs/_spec/01-lexical-syntax.md
@@ -259,7 +259,7 @@ A single new line token is accepted
 
 ## Literals
 
-There are literals for integer numbers, floating point numbers, characters, booleans, symbols, strings.
+There are literals for integer numbers, floating point numbers, characters, booleans, strings.
 The syntax of these literals is in each case as in Java.
 
 <!-- TODO
@@ -274,7 +274,6 @@ Literal  ::=  [‘-’] integerLiteral
            |  characterLiteral
            |  stringLiteral
            |  interpolatedString
-           |  symbolLiteral
            |  ‘null’
 ```
 
@@ -490,16 +489,6 @@ In addition, Unicode escape sequences of the form `\uxxxx`, where each `x` is a
 
 It is a compile time error if a backslash character in a character or string literal does not start a valid escape sequence.
 
-### Symbol literals
-
-```ebnf
-symbolLiteral  ::=  ‘'’ plainid
-```
-
-A symbol literal `'x` is deprecated shorthand for the expression `scala.Symbol("x")`.
-
-The `apply` method of `Symbol`'s companion object caches weak references to `Symbol`s, thus ensuring that identical symbol literals are equivalent with respect to reference equality.
-
 ## Whitespace and Comments
 
 Tokens may be separated by whitespace characters and/or comments.
diff --git a/docs/_spec/A1-deprecated.md b/docs/_spec/A1-deprecated.md
new file mode 100644
index 000000000000..e2ebc8af1d35
--- /dev/null
+++ b/docs/_spec/A1-deprecated.md
@@ -0,0 +1,21 @@
+
+### Symbol Literals
+
+Symbol literals are no longer supported.
+
+The [`scala.Symbol`](https://scala-lang.org/api/3.x/scala/Symbol.html) class still exists, so a literal translation of the symbol literal `'xyz` is `Symbol("xyz")`. However, it is recommended to use a plain string literal `"xyz"` instead. (The `Symbol` class will be deprecated and removed in the future). Example:
+
+
+```
+scalac Test.scala
+-- Error: Test.scala:1:25 ------------------------------------------------------------------------------------------------
+
+1 |@main def test = println('abc)
+  |                         ^
+  |                         symbol literal 'abc is no longer supported,
+  |                         use a string literal "abc" or an application Symbol("abc") instead,
+  |                         or enclose in braces '{abc} 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.
+1 error found
+```
\ No newline at end of file
diff --git a/docs/_spec/TODOreference/dropped-features/symlits.md b/docs/_spec/APPLIEDreference/dropped-features/symlits.md
similarity index 100%
rename from docs/_spec/TODOreference/dropped-features/symlits.md
rename to docs/_spec/APPLIEDreference/dropped-features/symlits.md

From 4dcce2158600d9f4896ac2abebfba8aca48e6278 Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Thu, 20 Oct 2022 16:21:00 +0200
Subject: [PATCH 437/657] Add TODO to 12.md

---
 docs/_spec/12-the-scala-standard-library.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/docs/_spec/12-the-scala-standard-library.md b/docs/_spec/12-the-scala-standard-library.md
index 631596e0d272..14d1fb82aea4 100644
--- a/docs/_spec/12-the-scala-standard-library.md
+++ b/docs/_spec/12-the-scala-standard-library.md
@@ -11,6 +11,7 @@ Some of these classes are described in the following.
 
 ![Class hierarchy of Scala](public/images/classhierarchy.png)
 
+<!-- TODO: Briefly mention scala.deprecated somewhere, and link to [deprecated page](./A%3F-deprecated.md) -->
 ## Root Classes
 
 The root of this hierarchy is formed by class `Any`.

From 60f528abc5ebe7fd8116b14461503ead44aeec5c Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Mon, 24 Oct 2022 16:03:41 +0200
Subject: [PATCH 438/657] Apply this-qualifier.md As the feature is not
 actually deprecated, no changes to the spec are needed

---
 docs/_spec/A3-to-be-deprecated.md                             | 4 ++++
 .../dropped-features/this-qualifier.md                        | 2 +-
 2 files changed, 5 insertions(+), 1 deletion(-)
 create mode 100644 docs/_spec/A3-to-be-deprecated.md
 rename docs/_spec/{TODOreference => APPLIEDreference}/dropped-features/this-qualifier.md (93%)

diff --git a/docs/_spec/A3-to-be-deprecated.md b/docs/_spec/A3-to-be-deprecated.md
new file mode 100644
index 000000000000..adc37111520c
--- /dev/null
+++ b/docs/_spec/A3-to-be-deprecated.md
@@ -0,0 +1,4 @@
+This is a simple list of feature that are not deprecated yet, but will be in the future.
+They should emit warnings or errors only when using the `-source:future` compiler flag.
+
+- [private[this] and protected[this]](../_docs/reference/dropped-features/this-qualifier.md)
\ No newline at end of file
diff --git a/docs/_spec/TODOreference/dropped-features/this-qualifier.md b/docs/_spec/APPLIEDreference/dropped-features/this-qualifier.md
similarity index 93%
rename from docs/_spec/TODOreference/dropped-features/this-qualifier.md
rename to docs/_spec/APPLIEDreference/dropped-features/this-qualifier.md
index 4fcadff8fae3..3fcaefb7e0d8 100644
--- a/docs/_spec/TODOreference/dropped-features/this-qualifier.md
+++ b/docs/_spec/APPLIEDreference/dropped-features/this-qualifier.md
@@ -4,7 +4,7 @@ title: "Dropped: private[this] and protected[this]"
 nightlyOf: https://docs.scala-lang.org/scala3/reference/dropped-features/this-qualifier.html
 ---
 
-The `private[this]` and `protected[this]` access modifiers are deprecated and will be phased out.
+The `private[this]` and `protected[this]` access modifiers will be deprecated and phased out.
 
 Previously, these modifiers were needed for
 

From d546f59f56021dabf7c7cb954d6700210d51ce14 Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Mon, 24 Oct 2022 18:08:07 +0200
Subject: [PATCH 439/657] TOFIXUP Disable indented blocks

---
 docs/_spec/_config.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/_spec/_config.yml b/docs/_spec/_config.yml
index bd1f691c65d0..3cb9c8f0d440 100644
--- a/docs/_spec/_config.yml
+++ b/docs/_spec/_config.yml
@@ -8,4 +8,4 @@ highlighter: false
 markdown: redcarpet
 encoding: utf-8
 redcarpet:
-  extensions: ["no_intra_emphasis", "fenced_code_blocks", "autolink", "tables", "with_toc_data", "strikethrough", "lax_spacing", "space_after_headers", "superscript", "footnotes"]
+  extensions: ["no_intra_emphasis", "fenced_code_blocks", "autolink", "tables", "with_toc_data", "strikethrough", "lax_spacing", "space_after_headers", "superscript", "footnotes", "disable_indented_code_blocks"]

From 0ed921586903da9be28ccb732a77088b29442b11 Mon Sep 17 00:00:00 2001
From: Quentin Bernet <quentin.bernet@epfl.ch>
Date: Fri, 3 Feb 2023 16:46:54 +0100
Subject: [PATCH 440/657] Reword section Method Application

Will make it easier to explain later what happens when you apply a using method to explicit parameters
---
 docs/_spec/06-expressions.md | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/docs/_spec/06-expressions.md b/docs/_spec/06-expressions.md
index 16f2f527a9dc..662f460af0e1 100644
--- a/docs/_spec/06-expressions.md
+++ b/docs/_spec/06-expressions.md
@@ -201,8 +201,8 @@ ArgumentExprs ::=  ‘(’ [Exprs] ‘)’
 Exprs         ::=  Expr {‘,’ Expr}
 ```
 
-An application `´f(e_1, ..., e_m)´` applies the expression `´f´` to the argument expressions `´e_1, ..., e_m´`.
-For the overal expression to be well-typed, ´f´ must be *applicable* to its arguments, which is defined next by case analysis on ´f´'s type.
+An application `´f(e_1, ..., e_m)´` applies the method `´f´` to the argument expressions `´e_1, ..., e_m´`.
+For this expression to be well-typed, the method must be *applicable* to its arguments:
 
 If ´f´ has a method type `(´p_1´:´T_1, ..., p_n´:´T_n´)´U´`, each argument expression ´e_i´ is typed with the corresponding parameter type ´T_i´ as expected type.
 Let ´S_i´ be the type of argument ´e_i´ ´(i = 1, ..., m)´.
@@ -214,12 +214,12 @@ Once the types ´S_i´ have been determined, the method ´f´ of the above metho
   - for every positional argument ´e_i´ the type ´S_i´ is [compatible](03-types.html#compatibility) with ´T_i´;
   - if the expected type is defined, the result type ´U´ is [compatible](03-types.html#compatibility) to it.
 
-If ´f´ is a polymorphic method, [local type inference](#local-type-inference) is used to instantiate ´f´'s type parameters.
-The polymorphic method is applicable if type inference can determine type arguments so that the instantiated method is applicable.
-
-If ´f´ has some value type, the application is taken to be equivalent to `´f´.apply(´e_1, ..., e_m´)`, i.e. the application of an `apply` method defined by ´f´.
-The value `´f´` is applicable to the given arguments if `´f´.apply` is applicable.
+If ´f´ is instead of some value type, the application is taken to be equivalent to `´f´.apply(´e_1, ..., e_m´)`, i.e. the application of an `apply` method defined by ´f´.
+Value `´f´` is applicable to the given arguments if `´f´.apply` is applicable.
 
+Note:
+In the case where ´f´ or `´f´.apply` is a polymorphic method, this is taken as an [ommitted type application](#type-applications).
+`´f´` is applicable to the given arguments if the result of this type application is applicable.
 
 The application `´f´(´e_1, ..., e_n´)` evaluates ´f´ and then each argument ´e_1, ..., e_n´ from left to right, except for arguments that correspond to a by-name parameter (see below).
 Each argument expression is converted to the type of its corresponding formal parameter.

From 1f62049a67d8119102269c2f0ed26d1742354505 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Fri, 28 Apr 2023 10:37:27 +0200
Subject: [PATCH 441/657] Add TODOs and fix typos

---
 compiler/src/dotty/tools/dotc/ast/Trees.scala              | 6 +++---
 compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala | 3 ++-
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala
index 3427146a6baa..215998353816 100644
--- a/compiler/src/dotty/tools/dotc/ast/Trees.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala
@@ -682,7 +682,7 @@ object Trees {
    *  they can be typed as a `Quote` with a known `tpt` or desugared and
    *  typed as a quote pattern.
    *
-   *  `Quotes` are checked transformed in the `staging`, `splicing` and `pickleQuotes`
+   *  `Quotes` are checked and transformed in the `staging`, `splicing` and `pickleQuotes`
    *  phases. After `pickleQuotes` phase, the only quotes that exist are in `inline`
    *  methods. These are dropped when we remove the inline method implementations.
    *
@@ -703,8 +703,8 @@ object Trees {
    *  they can be typed as a `Splice` with a known `tpt` or desugared and
    *  typed as a quote pattern holes.
    *
-   *  `Splice` are checked transformed in the `staging` and `splicing` phases.
-   *  After `splicing` phase, the only quotes that exist are in `inline`
+   *  `Splice` are checked and transformed in the `staging` and `splicing` phases.
+   *  After `splicing` phase, the only splices that exist are in `inline`
    *  methods. These are dropped when we remove the inline method implementations.
    *
    *  The `tpt` will be transformed in `staging` and used in `splicing` to create `Hole`s.
diff --git a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
index f81c0c2de56a..749fbe423dd3 100644
--- a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
+++ b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
@@ -59,6 +59,7 @@ trait QuotesAndSplices {
       report.error(msg, tree.srcPos)
       EmptyTree
     else
+      // TODO typecheck directly (without `exprQuote`)
       val exprQuoteTree = untpd.Apply(untpd.ref(defn.QuotedRuntime_exprQuote.termRef), tree.expr)
       val quotedExpr = typedApply(exprQuoteTree, pt)(using quoteContext) match
         case Apply(TypeApply(fn, tpt :: Nil), quotedExpr :: Nil) => Quote(quotedExpr, tpt)
@@ -106,9 +107,9 @@ trait QuotesAndSplices {
         markAsMacro(ctx)
       }
 
+      // TODO typecheck directly (without `exprSplice`)
       val internalSplice =
         untpd.Apply(untpd.ref(defn.QuotedRuntime_exprSplice.termRef), tree.expr)
-
       typedApply(internalSplice, pt)(using spliceContext).withSpan(tree.span) match
         case tree @ Apply(TypeApply(_, tpt :: Nil), spliced :: Nil) if tree.symbol == defn.QuotedRuntime_exprSplice =>
           cpy.Splice(tree)(spliced, tpt)

From 100f7bf48093644717b3363144722ee39938b6f4 Mon Sep 17 00:00:00 2001
From: Julien Richard-Foy <julien@richard-foy.fr>
Date: Fri, 28 Apr 2023 11:36:10 +0200
Subject: [PATCH 442/657] fixup formatting

---
 docs/_spec/03-types.md            |  6 +++---
 docs/_spec/06-expressions.md      | 16 +++++++---------
 docs/_spec/08-pattern-matching.md | 11 ++++-------
 3 files changed, 14 insertions(+), 19 deletions(-)

diff --git a/docs/_spec/03-types.md b/docs/_spec/03-types.md
index acb3a37faf14..5e1da82f1f11 100644
--- a/docs/_spec/03-types.md
+++ b/docs/_spec/03-types.md
@@ -219,9 +219,9 @@ SimpleType    ::=   ‘(’ Types ‘)’
 
 A _tuple type_ ´(T_1, ..., T_n)´ where ´n \geq 2´ is an alias for the type `´T_1´ *: ... *: ´T_n´ *: scala.EmptyTuple`.
 
-Note:
-`(´T´)` is just the type ´T´, and not `´T´ *: scala.EmptyTuple`.
-`()` is not a valid type, and not `scala.EmptyTuple`.
+Notes:
+- `(´T´)` is just the type ´T´, and not `´T´ *: scala.EmptyTuple`.
+- `()` is not a valid type, and not `scala.EmptyTuple`.
 
 If ´n \leq 22´, the type `´T_1´ *: ... *: ´T_n´ *: scala.EmptyTuple` is both a subtype and a supertype of tuple class `scala.Tuple´_n´[´T_1´, ..., ´T_n´]`.
 
diff --git a/docs/_spec/06-expressions.md b/docs/_spec/06-expressions.md
index 662f460af0e1..bb90c2b071a4 100644
--- a/docs/_spec/06-expressions.md
+++ b/docs/_spec/06-expressions.md
@@ -217,9 +217,9 @@ Once the types ´S_i´ have been determined, the method ´f´ of the above metho
 If ´f´ is instead of some value type, the application is taken to be equivalent to `´f´.apply(´e_1, ..., e_m´)`, i.e. the application of an `apply` method defined by ´f´.
 Value `´f´` is applicable to the given arguments if `´f´.apply` is applicable.
 
-Note:
-In the case where ´f´ or `´f´.apply` is a polymorphic method, this is taken as an [ommitted type application](#type-applications).
-`´f´` is applicable to the given arguments if the result of this type application is applicable.
+Notes:
+- In the case where ´f´ or `´f´.apply` is a polymorphic method, this is taken as an [ommitted type application](#type-applications).
+- `´f´` is applicable to the given arguments if the result of this type application is applicable.
 
 The application `´f´(´e_1, ..., e_n´)` evaluates ´f´ and then each argument ´e_1, ..., e_n´ from left to right, except for arguments that correspond to a by-name parameter (see below).
 Each argument expression is converted to the type of its corresponding formal parameter.
@@ -383,13 +383,11 @@ SimpleExpr   ::=  ‘(’ [Exprs] ‘)’
 ```
 A _tuple expression_ `(´e_1´, ..., ´e_n´)` where ´n \geq 2´ is equivalent to the expression `´e_1´ *: ... *: ´e_n´ *: scala.EmptyTuple`.
 
-Note:
-As calls to `*:` are slow, a more efficient translation is free to be implemented.
-For example, `(´e_1´, ´e_2´)` could be translated to `scala.Tuple2(´e_1´, ´e_2´)`, which is indeed equivalent to `´e_1´ *: ´e_2´ *: scala.EmptyTuple`.
+Note: as calls to `*:` are slow, a more efficient translation is free to be implemented. For example, `(´e_1´, ´e_2´)` could be translated to `scala.Tuple2(´e_1´, ´e_2´)`, which is indeed equivalent to `´e_1´ *: ´e_2´ *: scala.EmptyTuple`.
 
-Note:
-The expression `(´e_1´)` is not equivalent to `´e_1´ *: scala.EmptyTuple`, but instead a regular parenthesized expression.
-The expression `()` is not an alias for `scala.EmptyTuple`, but instead the unique value of type `scala.Unit`.
+Notes:
+- The expression `(´e_1´)` is not equivalent to `´e_1´ *: scala.EmptyTuple`, but instead a regular parenthesized expression.
+- The expression `()` is not an alias for `scala.EmptyTuple`, but instead the unique value of type `scala.Unit`.
 
 ## Instance Creation Expressions
 
diff --git a/docs/_spec/08-pattern-matching.md b/docs/_spec/08-pattern-matching.md
index df1c396631ea..f16f4c3dfa88 100644
--- a/docs/_spec/08-pattern-matching.md
+++ b/docs/_spec/08-pattern-matching.md
@@ -187,13 +187,10 @@ This is further discussed [here](#pattern-sequences).
 
 A _tuple pattern_ `(´p_1´, ..., ´p_n´)` where ´n \geq 2´ is equivalent to `´p_1´ *: ... *: ´p_n´ *: scala.EmptyTuple`.
 
-Note:
-`()` is equivalent to `_: scala.Unit`, and not `scala.EmptyTuple`.
-`(´pat´)` is a pattern matching ´pat´, and not `´pat´ *: scala.EmptyTuple`.
-
-Note:
-As such patterns with `*:` are slow, a more efficient translation is free to be implemented.
-For example, `(´p_1´, ´p_2´)` could be translated to `scala.Tuple2(´p_1´, ´p_2´)`, which is indeed equivalent to `´p_1´ *: ´p_2´ *: scala.EmptyTuple`.
+Notes:
+- `()` is equivalent to `_: scala.Unit`, and not `scala.EmptyTuple`.
+- `(´pat´)` is a pattern matching ´pat´, and not `´pat´ *: scala.EmptyTuple`.
+- As such patterns with `*:` are slow, a more efficient translation is free to be implemented. For example, `(´p_1´, ´p_2´)` could be translated to `scala.Tuple2(´p_1´, ´p_2´)`, which is indeed equivalent to `´p_1´ *: ´p_2´ *: scala.EmptyTuple`.
 
 ### Extractor Patterns
 

From 1cd9bd263e2fcd557c6779e29ad10f6d8299cf99 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Marks?= <pmarks@virtuslab.com>
Date: Fri, 28 Apr 2023 13:29:31 +0200
Subject: [PATCH 443/657] Set reference version to 3.3.0-RC5

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

diff --git a/project/Build.scala b/project/Build.scala
index a1245dfd8460..c5586c68f981 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -80,7 +80,7 @@ object DottyJSPlugin extends AutoPlugin {
 object Build {
   import ScaladocConfigs._
 
-  val referenceVersion = "3.3.0-RC4"
+  val referenceVersion = "3.3.0-RC5"
 
   val baseVersion = "3.3.1-RC1"
 

From 5ae7861eb246461bc0f970d0e446c2b080440d18 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Fri, 28 Apr 2023 12:32:34 +0200
Subject: [PATCH 444/657] Remove `tpt` from `Quote`

---
 .../dotty/tools/dotc/CompilationUnit.scala    |  2 +-
 .../src/dotty/tools/dotc/ast/Desugar.scala    |  2 +-
 compiler/src/dotty/tools/dotc/ast/Trees.scala | 40 ++++++++++++-------
 compiler/src/dotty/tools/dotc/ast/tpd.scala   |  4 +-
 compiler/src/dotty/tools/dotc/ast/untpd.scala |  2 +-
 .../tools/dotc/core/tasty/TreePickler.scala   |  6 +--
 .../tools/dotc/core/tasty/TreeUnpickler.scala |  2 +-
 .../dotty/tools/dotc/inlines/Inliner.scala    |  4 +-
 .../dotty/tools/dotc/parsing/Parsers.scala    |  4 +-
 .../tools/dotc/printing/RefinedPrinter.scala  |  6 +--
 .../tools/dotc/staging/CrossStageSafety.scala |  4 +-
 .../dotc/staging/TreeMapWithStages.scala      |  6 +--
 .../tools/dotc/transform/MegaPhase.scala      |  3 +-
 .../tools/dotc/transform/PickleQuotes.scala   |  6 +--
 .../tools/dotc/transform/PostTyper.scala      |  2 +-
 .../dotty/tools/dotc/transform/Splicer.scala  | 10 ++---
 .../dotty/tools/dotc/transform/Splicing.scala | 10 ++---
 .../tools/dotc/transform/patmat/Space.scala   |  2 +-
 .../tools/dotc/typer/QuotesAndSplices.scala   |  7 ++--
 .../src/dotty/tools/dotc/typer/ReTyper.scala  |  6 +--
 .../dotty/tools/dotc/typer/TypeAssigner.scala |  6 ---
 .../quoted/runtime/impl/QuotesImpl.scala      |  2 +-
 22 files changed, 69 insertions(+), 67 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/CompilationUnit.scala b/compiler/src/dotty/tools/dotc/CompilationUnit.scala
index 9a41f685f6c3..8e4989f13c3d 100644
--- a/compiler/src/dotty/tools/dotc/CompilationUnit.scala
+++ b/compiler/src/dotty/tools/dotc/CompilationUnit.scala
@@ -157,7 +157,7 @@ object CompilationUnit {
       if tree.symbol.is(Flags.Inline) then
         containsInline = true
       tree match
-        case tpd.Quote(_, _) =>
+        case tpd.Quote(_) =>
           containsQuote = true
         case tree: tpd.Apply if tree.symbol == defn.QuotedTypeModule_of =>
           containsQuote = true
diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index 5c2410d3fbdc..60962f0d1996 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -1986,7 +1986,7 @@ object desugar {
         trees foreach collect
       case Block(Nil, expr) =>
         collect(expr)
-      case Quote(expr, _) =>
+      case Quote(expr) =>
         new UntypedTreeTraverser {
           def traverse(tree: untpd.Tree)(using Context): Unit = tree match {
             case Splice(expr, _) => collect(expr)
diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala
index 215998353816..e626a06829dd 100644
--- a/compiler/src/dotty/tools/dotc/ast/Trees.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala
@@ -678,23 +678,33 @@ object Trees {
   }
 
   /** A tree representing a quote `'{ expr }`
-   *  `Quote`s are created by the `Parser` with an empty `tpt`. In typer
-   *  they can be typed as a `Quote` with a known `tpt` or desugared and
-   *  typed as a quote pattern.
+   *  `Quote`s are created by the `Parser`. In typer they can be typed as a
+   *  `Quote` with a known `tpt` or desugared and typed as a quote pattern.
    *
    *  `Quotes` are checked and transformed in the `staging`, `splicing` and `pickleQuotes`
    *  phases. After `pickleQuotes` phase, the only quotes that exist are in `inline`
    *  methods. These are dropped when we remove the inline method implementations.
    *
-   *  The `tpt` will be transformed in `staging` and used in `pickleQuotes` to create the
-   *  pickled representation of the quote.
-   *
    *  @param  expr  The tree that was quoted
-   *  @param  tpt   The type of the tree that was quoted
    */
-  case class Quote[+T <: Untyped] private[ast] (expr: Tree[T], tpt: Tree[T])(implicit @constructorOnly src: SourceFile)
+  case class Quote[+T <: Untyped] private[ast] (expr: Tree[T])(implicit @constructorOnly src: SourceFile)
     extends TermTree[T] {
     type ThisTree[+T <: Untyped] = Quote[T]
+
+    /** Type of the quoted expression as seen from outside the quote */
+    def exprType(using Context): Type =
+      val quoteType = typeOpt // Quotes ?=> Expr[T]
+      val exprType = quoteType.argInfos.last // Expr[T]
+      exprType.argInfos.head // T
+
+    /** Set the type of the quoted expression as seen from outside the quote */
+    def withExprType(tpe: Type)(using Context): Quote[Type] =
+      val exprType = // Expr[T]
+        defn.QuotedExprClass.typeRef.appliedTo(tpe)
+      val quoteType = // Quotes ?=> Expr[T]
+        defn.FunctionType(1, isContextual = true)
+          .appliedTo(defn.QuotesClass.typeRef, exprType)
+      withType(quoteType)
   }
 
   /** A tree representing a splice `${ expr }`
@@ -1299,9 +1309,9 @@ object Trees {
         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 Quote(tree: Tree)(expr: Tree, tpt: Tree)(using Context): Quote = tree match {
-        case tree: Quote if (expr eq tree.expr) && (tpt eq tree.tpt) => tree
-        case _ => finalize(tree, untpd.Quote(expr, tpt)(sourceFile(tree)))
+      def Quote(tree: Tree)(expr: Tree)(using Context): Quote = tree match {
+        case tree: Quote if (expr eq tree.expr) => tree
+        case _ => finalize(tree, untpd.Quote(expr)(sourceFile(tree)))
       }
       def Splice(tree: Tree)(expr: Tree, tpt: Tree)(using Context): Splice = tree match {
         case tree: Splice if (expr eq tree.expr) && (tpt eq tree.tpt) => tree
@@ -1546,8 +1556,8 @@ object Trees {
             case Thicket(trees) =>
               val trees1 = transform(trees)
               if (trees1 eq trees) tree else Thicket(trees1)
-            case tree @ Quote(expr, tpt) =>
-              cpy.Quote(tree)(transform(expr), transform(tpt))
+            case tree @ Quote(expr) =>
+              cpy.Quote(tree)(transform(expr))
             case tree @ Splice(expr, tpt) =>
               cpy.Splice(tree)(transform(expr), transform(tpt))
             case tree @ Hole(_, _, args, content, tpt) =>
@@ -1691,8 +1701,8 @@ object Trees {
               this(this(x, arg), annot)
             case Thicket(ts) =>
               this(x, ts)
-            case Quote(expr, tpt) =>
-              this(this(x, expr), tpt)
+            case Quote(expr) =>
+              this(x, expr)
             case Splice(expr, tpt) =>
               this(this(x, expr), tpt)
             case Hole(_, _, args, content, tpt) =>
diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
index 66c0bedc12c3..78de609850db 100644
--- a/compiler/src/dotty/tools/dotc/ast/tpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -170,8 +170,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def Inlined(call: Tree, bindings: List[MemberDef], expansion: Tree)(using Context): Inlined =
     ta.assignType(untpd.Inlined(call, bindings, expansion), bindings, expansion)
 
-  def Quote(expr: Tree, tpt: Tree)(using Context): Quote =
-    ta.assignType(untpd.Quote(expr, tpt), tpt)
+  def Quote(expr: Tree, tpe: Type)(using Context): Quote =
+    untpd.Quote(expr).withExprType(tpe)
 
   def Splice(expr: Tree, tpt: Tree)(using Context): Splice =
     ta.assignType(untpd.Splice(expr, tpt), tpt)
diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
index 45b2fcd49595..4fdd9115f2c9 100644
--- a/compiler/src/dotty/tools/dotc/ast/untpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -397,7 +397,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   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 Quote(expr: Tree, tpt: Tree)(implicit src: SourceFile): Quote = new Quote(expr, tpt)
+  def Quote(expr: Tree)(implicit src: SourceFile): Quote = new Quote(expr)
   def Splice(expr: Tree, tpt: Tree)(implicit src: SourceFile): Splice = new Splice(expr, tpt)
   def TypeTree()(implicit src: SourceFile): TypeTree = new TypeTree()
   def InferredTypeTree()(implicit src: SourceFile): TypeTree = new InferredTypeTree()
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
index 864004a3e5ec..6346c2f3dd03 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -665,11 +665,11 @@ class TreePickler(pickler: TastyPickler) {
               pickleTree(hi)
               pickleTree(alias)
           }
-        case Quote(expr, tpt) =>
+        case tree @ Quote(expr) =>
           pickleTree(
-            // scala.quoted.runtime.Expr.quoted[<tpt>](<expr>)
+            // scala.quoted.runtime.Expr.quoted[<exprType>](<expr>)
             ref(defn.QuotedRuntime_exprQuote)
-              .appliedToTypeTree(tpt)
+              .appliedToType(tree.exprType)
               .appliedTo(expr)
               .withSpan(tree.span)
           )
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
index 79d2008eb698..02e79854c666 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
@@ -1269,7 +1269,7 @@ class TreeUnpickler(reader: TastyReader,
 
       def quotedExpr(fn: Tree, args: List[Tree]): Tree =
         val TypeApply(_, targs) = fn: @unchecked
-        Quote(args.head, targs.head)
+        Quote(args.head, targs.head.tpe)
 
       def splicedExpr(fn: Tree, args: List[Tree]): Tree =
         val TypeApply(_, targs) = fn: @unchecked
diff --git a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
index e2fd4c6688c1..8f3c4df237a6 100644
--- a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
@@ -827,7 +827,7 @@ class Inliner(val call: tpd.Tree)(using Context):
 
     override def typedQuote(tree: untpd.Quote, pt: Type)(using Context): Tree =
       super.typedQuote(tree, pt) match
-        case Quote(Splice(inner, _), _) => inner
+        case Quote(Splice(inner, _)) => inner
         case tree1 =>
           ctx.compilationUnit.needsStaging = true
           tree1
@@ -1070,7 +1070,7 @@ class Inliner(val call: tpd.Tree)(using Context):
         else tree match {
           case tree: RefTree if tree.isTerm && tree.symbol.isDefinedInCurrentRun && !tree.symbol.isLocal =>
             foldOver(tree.symbol :: syms, tree)
-          case Quote(body, _) =>
+          case Quote(body) =>
             level += 1
             try apply(syms, body)
             finally level -= 1
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index c2e2e4466d98..d98f407edc73 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -1262,7 +1262,7 @@ object Parsers {
               }
             }
             in.nextToken()
-            Quote(t, EmptyTree)
+            Quote(t)
           }
           else
             if !in.featureEnabled(Feature.symbolLiterals) then
@@ -2497,7 +2497,7 @@ object Parsers {
               val expr =
                 if (in.token == LBRACKET) inBrackets(typ())
                 else stagedBlock()
-              Quote(expr, EmptyTree)
+              Quote(expr)
             }
           }
         case NEW =>
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index b2b9196b0a13..8cf9ab00b091 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -716,9 +716,9 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         "Thicket {" ~~ toTextGlobal(trees, "\n") ~~ "}"
       case MacroTree(call) =>
         keywordStr("macro ") ~ toTextGlobal(call)
-      case Quote(expr, tpt) =>
-        val tptText = (keywordStr("[") ~ toTextGlobal(tpt) ~ keywordStr("]")).provided(!tpt.isEmpty && printDebug)
-        keywordStr("'") ~ tptText ~ keywordStr("{") ~ toTextGlobal(expr) ~ keywordStr("}")
+      case tree @ Quote(expr) =>
+        val exprTypeText = (keywordStr("[") ~ toTextGlobal(tree.exprType) ~ keywordStr("]")).provided(printDebug)
+        keywordStr("'") ~ exprTypeText ~ keywordStr("{") ~ toTextGlobal(expr) ~ keywordStr("}")
       case Splice(expr, tpt) =>
         val tptText = (keywordStr("[") ~ toTextGlobal(tpt) ~ keywordStr("]")).provided(!tpt.isEmpty && printDebug)
         keywordStr("$") ~ tptText ~ keywordStr("{") ~ toTextGlobal(expr) ~ keywordStr("}")
diff --git a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
index 748b053d7eaa..36b2b9caa050 100644
--- a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
+++ b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
@@ -103,8 +103,8 @@ class CrossStageSafety extends TreeMapWithStages {
     val transformedBody = transformQuoteBody(body, quote.span)
     val stripAnnotsDeep: TypeMap = new TypeMap:
       def apply(tp: Type): Type = mapOver(tp.stripAnnots)
-    val tpt1 = TypeTree(healType(quote.tpt.srcPos)(stripAnnotsDeep(quote.tpt.tpe)))
-    cpy.Quote(quote)(transformedBody, tpt1)
+    val exprType1 = healType(quote.srcPos)(stripAnnotsDeep(quote.exprType))
+    cpy.Quote(quote)(transformedBody).withExprType(exprType1)
   }
 
   override protected def transformQuotedType(body: Tree, quote: Apply)(using Context): Tree = {
diff --git a/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala b/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
index a292b4b079be..0a85ef5e9e84 100644
--- a/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
+++ b/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
@@ -26,7 +26,7 @@ abstract class TreeMapWithStages extends TreeMapWithImplicits {
    *  - `quoted.runtime.Expr.quote[T](<body0>)`  --> `quoted.runtime.Expr.quote[T](<body>)`
    */
   protected def transformQuote(body: Tree, quote: Quote)(using Context): Tree =
-    cpy.Quote(quote)(body, quote.tpt)
+    cpy.Quote(quote)(body)
 
   /** Transform the quote `quote` which contains the quoted `body`.
    *
@@ -62,7 +62,7 @@ abstract class TreeMapWithStages extends TreeMapWithImplicits {
           try transformQuotedType(quotedTree, tree)
           finally inQuoteOrSplice = old
 
-        case tree @ Quote(quotedTree, _) =>
+        case tree @ Quote(quotedTree) =>
           val old = inQuoteOrSplice
           inQuoteOrSplice = true
           try dropEmptyBlocks(quotedTree) match {
@@ -79,7 +79,7 @@ abstract class TreeMapWithStages extends TreeMapWithImplicits {
           val old = inQuoteOrSplice
           inQuoteOrSplice = true
           try dropEmptyBlocks(splicedTree) match {
-            case Quote(t, _) =>
+            case Quote(t) =>
               // Optimization: `${ 'x }` --> `x`
               transform(t)
             case _ =>
diff --git a/compiler/src/dotty/tools/dotc/transform/MegaPhase.scala b/compiler/src/dotty/tools/dotc/transform/MegaPhase.scala
index 77d6b2f3ac61..86393cf2d466 100644
--- a/compiler/src/dotty/tools/dotc/transform/MegaPhase.scala
+++ b/compiler/src/dotty/tools/dotc/transform/MegaPhase.scala
@@ -402,8 +402,7 @@ class MegaPhase(val miniPhases: Array[MiniPhase]) extends Phase {
       case tree: Quote =>
         inContext(prepQuote(tree, start)(using outerCtx)) {
           val expr = transformTree(tree.expr, start)(using quoteContext)
-          val tpt = transformTree(tree.tpt, start)
-          goQuote(cpy.Quote(tree)(expr, tpt), start)
+          goQuote(cpy.Quote(tree)(expr), start)
         }
       case tree: Splice =>
         inContext(prepSplice(tree, start)(using outerCtx)) {
diff --git a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
index c60562baaa7f..f23558e8fe9a 100644
--- a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
@@ -100,11 +100,11 @@ class PickleQuotes extends MacroTransform {
   protected def newTransformer(using Context): Transformer = new Transformer {
     override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
       tree match
-        case Apply(Select(Quote(expr, tpt), nme.apply), List(quotes)) =>
-          val (contents, codeWithHoles) = makeHoles(expr)
+        case Apply(Select(quote: Quote, nme.apply), List(quotes)) =>
+          val (contents, codeWithHoles) = makeHoles(quote.expr)
           val sourceRef = Inlines.inlineCallTrace(ctx.owner, tree.sourcePos)
           val codeWithHoles2 = Inlined(sourceRef, Nil, codeWithHoles)
-          val pickled = PickleQuotes(quotes, codeWithHoles2, contents, tpt.tpe, false)
+          val pickled = PickleQuotes(quotes, codeWithHoles2, contents, quote.exprType, 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
diff --git a/compiler/src/dotty/tools/dotc/transform/PostTyper.scala b/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
index eac9a8d70654..6861084b1dcb 100644
--- a/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
@@ -485,7 +485,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
           )
         case Block(_, Closure(_, _, tpt)) if ExpandSAMs.needsWrapperClass(tpt.tpe) =>
           superAcc.withInvalidCurrentClass(super.transform(tree))
-        case Quote(expr, _) =>
+        case Quote(expr) =>
           ctx.compilationUnit.needsStaging = true
           super.transform(tree)
         case tree =>
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicer.scala b/compiler/src/dotty/tools/dotc/transform/Splicer.scala
index 4b6d434d80b0..d65823ff9407 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicer.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicer.scala
@@ -44,7 +44,7 @@ object Splicer {
    *  See: `Staging`
    */
   def splice(tree: Tree, splicePos: SrcPos, spliceExpansionPos: SrcPos, classLoader: ClassLoader)(using Context): Tree = tree match {
-    case Quote(quotedTree, _) => quotedTree
+    case Quote(quotedTree) => quotedTree
     case _ =>
       val macroOwner = newSymbol(ctx.owner, nme.MACROkw, Macro | Synthetic, defn.AnyType, coord = tree.span)
       try
@@ -136,7 +136,7 @@ object Splicer {
     *  See: `Staging`
     */
   def checkValidMacroBody(tree: Tree)(using Context): Unit = tree match {
-    case Quote(_, _) => // ok
+    case Quote(_) => // ok
     case _ =>
       type Env = Set[Symbol]
 
@@ -155,7 +155,7 @@ object Splicer {
         case Block(Nil, expr) => checkIfValidArgument(expr)
         case Typed(expr, _) => checkIfValidArgument(expr)
 
-        case Apply(Select(Quote(expr, tpt), nme.apply), _) =>
+        case Apply(Select(Quote(expr), nme.apply), _) =>
           val noSpliceChecker = new TreeTraverser {
             def traverse(tree: Tree)(using Context): Unit = tree match
               case Splice(_, _) =>
@@ -203,7 +203,7 @@ object Splicer {
         case Typed(expr, _) =>
           checkIfValidStaticCall(expr)
 
-        case Apply(Select(Quote(quoted, tpt), nme.apply), _) =>
+        case Apply(Select(Quote(quoted), nme.apply), _) =>
           // OK, canceled and warning emitted
 
         case Call(fn, args)
@@ -240,7 +240,7 @@ object Splicer {
 
     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(Quote(expr, _), nme.apply), _) =>
+      case Apply(Select(Quote(expr), nme.apply), _) =>
         val expr1 = expr match {
           case expr: Ident if expr.symbol.isAllOf(InlineByNameProxy) =>
             // inline proxy for by-name parameter
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicing.scala b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
index af77588419b5..1b3013bdcfff 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicing.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
@@ -86,7 +86,7 @@ class Splicing extends MacroTransform:
     override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
       assert(level == 0)
       tree match
-        case Apply(Select(Quote(expr, _), nme.apply),List(quotes)) =>
+        case Apply(Select(Quote(expr), nme.apply),List(quotes)) =>
           QuoteTransformer().transform(tree)
         case TypeApply(_, _) if tree.symbol == defn.QuotedTypeModule_of =>
           QuoteTransformer().transform(tree)
@@ -134,7 +134,7 @@ class Splicing extends MacroTransform:
               typeHoles.put(qual, hole)
               hole
           cpy.TypeDef(tree)(rhs = hole)
-        case Apply(Select(Quote(expr, tpt), nme.apply),List(quotes)) =>
+        case Apply(Select(Quote(expr), nme.apply),List(quotes)) =>
           super.transform(tree)(using quoteContext)
         case _: Template =>
           for sym <- tree.symbol.owner.info.decls do
@@ -237,7 +237,7 @@ class Splicing extends MacroTransform:
         case Splice(expr, tpt) =>
           val expr1 = transform(expr)(using spliceContext)
           cpy.Splice(tree)(expr1, tpt)
-        case Apply(sel @ Select(app @ Quote(expr, tpt), nme.apply), quotesArgs) =>
+        case Apply(sel @ Select(app @ Quote(expr), nme.apply), quotesArgs) =>
           expr match
             case expr: RefTree if isCaptured(expr.symbol) =>
               capturedTerm(expr)
@@ -246,7 +246,7 @@ class Splicing extends MacroTransform:
                 if level > 1 then transform(expr)(using quoteContext)
                 else transformLevel0QuoteContent(expr)(using quoteContext)
               }
-              cpy.Apply(tree)(cpy.Select(sel)(cpy.Quote(app)(newExpr, tpt), nme.apply), quotesArgs)
+              cpy.Apply(tree)(cpy.Select(sel)(cpy.Quote(app)(newExpr), nme.apply), quotesArgs)
         case Apply(TypeApply(typeof, List(tpt)), List(quotes))
         if tree.symbol == defn.QuotedTypeModule_of && containsCapturedType(tpt.tpe) =>
           val newContent = capturedPartTypes(tpt)
@@ -412,7 +412,7 @@ class Splicing extends MacroTransform:
       Splice(closure, TypeTree(tpe))
 
     private def quoted(expr: Tree)(using Context): Tree =
-      Quote(expr, TypeTree(expr.tpe.widenTermRefExpr))
+      Quote(expr, expr.tpe.widenTermRefExpr)
         .select(nme.apply)
         .appliedTo(quotes.nn)
 
diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index 23c851a33408..2a2c15f95774 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -312,7 +312,7 @@ object SpaceEngine {
   def isIrrefutableQuotedPattern(unapp: tpd.Tree, implicits: List[tpd.Tree], pt: Type)(using Context): Boolean = {
     implicits.headOption match
       // pattern '{ $x: T }
-      case Some(tpd.Apply(tpd.Select(tpd.Quote(tpd.TypeApply(fn, List(tpt)), _), nme.apply), _))
+      case Some(tpd.Apply(tpd.Select(tpd.Quote(tpd.TypeApply(fn, List(tpt))), nme.apply), _))
           if unapp.symbol.owner.eq(defn.QuoteMatching_ExprMatchModule)
           && fn.symbol.eq(defn.QuotedRuntimePatterns_patternHole) =>
         pt <:< defn.QuotedExprClass.typeRef.appliedTo(tpt.tpe)
diff --git a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
index 749fbe423dd3..01b4a4384e9f 100644
--- a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
+++ b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
@@ -36,7 +36,6 @@ trait QuotesAndSplices {
    */
   def typedQuote(tree: untpd.Quote, pt: Type)(using Context): Tree = {
     record("typedQuote")
-    assert(tree.tpt.isEmpty)
     tree.expr 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)
@@ -62,7 +61,7 @@ trait QuotesAndSplices {
       // TODO typecheck directly (without `exprQuote`)
       val exprQuoteTree = untpd.Apply(untpd.ref(defn.QuotedRuntime_exprQuote.termRef), tree.expr)
       val quotedExpr = typedApply(exprQuoteTree, pt)(using quoteContext) match
-        case Apply(TypeApply(fn, tpt :: Nil), quotedExpr :: Nil) => Quote(quotedExpr, tpt)
+        case Apply(TypeApply(fn, tpt :: Nil), quotedExpr :: Nil) => Quote(quotedExpr, tpt.tpe)
       makeInlineable(quotedExpr.select(nme.apply).appliedTo(quotes).withSpan(tree.span))
   }
 
@@ -77,7 +76,7 @@ trait QuotesAndSplices {
     assert(tree.tpt.isEmpty)
     checkSpliceOutsideQuote(tree)
     tree.expr match {
-      case untpd.Quote(innerExpr, _) if innerExpr.isTerm =>
+      case untpd.Quote(innerExpr) if innerExpr.isTerm =>
         report.warning("Canceled quote directly inside a splice. ${ '{ XYZ } } is equivalent to XYZ.", tree.srcPos)
         return typed(innerExpr, pt)
       case _ =>
@@ -446,7 +445,7 @@ trait QuotesAndSplices {
 
     val quoteClass = if (quoted.isTerm) defn.QuotedExprClass else defn.QuotedTypeClass
     val quotedPattern =
-      if (quoted.isTerm) tpd.Quote(shape, TypeTree(defn.AnyType)).select(nme.apply).appliedTo(qctx)
+      if (quoted.isTerm) tpd.Quote(shape, defn.AnyType).select(nme.apply).appliedTo(qctx)
       else ref(defn.QuotedTypeModule_of.termRef).appliedToTypeTree(shape).appliedTo(qctx)
 
     val matchModule = if quoted.isTerm then defn.QuoteMatching_ExprMatch else defn.QuoteMatching_TypeMatch
diff --git a/compiler/src/dotty/tools/dotc/typer/ReTyper.scala b/compiler/src/dotty/tools/dotc/typer/ReTyper.scala
index 9efe3b31a356..c96dbad2d01a 100644
--- a/compiler/src/dotty/tools/dotc/typer/ReTyper.scala
+++ b/compiler/src/dotty/tools/dotc/typer/ReTyper.scala
@@ -96,9 +96,9 @@ class ReTyper(nestingLevel: Int = 0) extends Typer(nestingLevel) with ReChecking
     typedApply(tree, selType)
 
   override def typedQuote(tree: untpd.Quote, pt: Type)(using Context): Tree =
-    val tpt1 = checkSimpleKinded(typedType(tree.tpt, mapPatternBounds = true))
-    val expr1 = typed(tree.expr, tpt1.tpe.widenSkolem)(using quoteContext)
-    assignType(untpd.cpy.Quote(tree)(expr1, tpt1), tpt1)
+    assertTyped(tree)
+    val expr1 = typed(tree.expr, tree.exprType)(using quoteContext)
+    untpd.cpy.Quote(tree)(expr1).withType(tree.typeOpt)
 
   override def typedSplice(tree: untpd.Splice, pt: Type)(using Context): Tree =
     val tpt1 = checkSimpleKinded(typedType(tree.tpt, mapPatternBounds = true))
diff --git a/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala b/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
index fc51af646b17..c22d1eb72aa6 100644
--- a/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
+++ b/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
@@ -392,12 +392,6 @@ trait TypeAssigner {
   def assignType(tree: untpd.Inlined, bindings: List[Tree], expansion: Tree)(using Context): Inlined =
     tree.withType(avoidingType(expansion, bindings))
 
-  def assignType(tree: untpd.Quote, tpt: Tree)(using Context): Quote =
-    val lambdaType = // Quotes ?=> Expr[T]
-      defn.FunctionType(1, isContextual = true)
-        .appliedTo(defn.QuotesClass.typeRef, defn.QuotedExprClass.typeRef.appliedTo(tpt.tpe))
-    tree.withType(lambdaType)
-
   def assignType(tree: untpd.Splice, tpt: Tree)(using Context): Splice =
     tree.withType(tpt.tpe)
 
diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
index f63ef3feb041..dc72962401cc 100644
--- a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
+++ b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
@@ -637,7 +637,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
           case self: tpd.Quote => // TODO expose Quote AST in Quotes
             import dotty.tools.dotc.ast.tpd.TreeOps
             tpd.ref(dotc.core.Symbols.defn.QuotedRuntime_exprQuote)
-              .appliedToTypeTree(self.tpt)
+              .appliedToType(self.exprType)
               .withSpan(self.span)
           case self: tpd.Splice => // TODO expose Splice AST in Quotes
             import dotty.tools.dotc.ast.tpd.TreeOps

From 3976d062314e12eda6af23b57537064228e4f9b1 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Fri, 28 Apr 2023 14:20:29 +0200
Subject: [PATCH 445/657] Remove `tpt` from `Splice`

---
 .../src/dotty/tools/dotc/ast/Desugar.scala    |  2 +-
 compiler/src/dotty/tools/dotc/ast/Trees.scala | 26 +++++++------------
 compiler/src/dotty/tools/dotc/ast/tpd.scala   |  4 +--
 compiler/src/dotty/tools/dotc/ast/untpd.scala |  2 +-
 .../tools/dotc/core/tasty/TreePickler.scala   |  8 +++---
 .../tools/dotc/core/tasty/TreeUnpickler.scala |  4 +--
 .../dotty/tools/dotc/inlines/Inliner.scala    |  6 ++---
 .../dotc/inlines/PrepareInlineable.scala      |  2 +-
 .../dotty/tools/dotc/parsing/Parsers.scala    |  2 +-
 .../tools/dotc/printing/RefinedPrinter.scala  |  8 +++---
 .../tools/dotc/staging/CrossStageSafety.scala | 11 +++-----
 .../dotc/staging/TreeMapWithStages.scala      |  4 +--
 .../tools/dotc/transform/MegaPhase.scala      |  3 +--
 .../dotty/tools/dotc/transform/Splicer.scala  |  2 +-
 .../dotty/tools/dotc/transform/Splicing.scala |  8 +++---
 .../tools/dotc/typer/QuotesAndSplices.scala   | 19 ++++++--------
 .../src/dotty/tools/dotc/typer/ReTyper.scala  | 12 +++++----
 .../dotty/tools/dotc/typer/TypeAssigner.scala |  3 ---
 .../quoted/runtime/impl/QuotesImpl.scala      |  2 +-
 19 files changed, 57 insertions(+), 71 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index 60962f0d1996..c1dd78451bae 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -1989,7 +1989,7 @@ object desugar {
       case Quote(expr) =>
         new UntypedTreeTraverser {
           def traverse(tree: untpd.Tree)(using Context): Unit = tree match {
-            case Splice(expr, _) => collect(expr)
+            case Splice(expr) => collect(expr)
             case _ => traverseChildren(tree)
           }
         }.traverse(expr)
diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala
index e626a06829dd..e5b7f32a674d 100644
--- a/compiler/src/dotty/tools/dotc/ast/Trees.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala
@@ -709,20 +709,16 @@ object Trees {
 
   /** A tree representing a splice `${ expr }`
    *
-   *  `Splice`s are created by the `Parser` with an empty `tpt`. In typer
-   *  they can be typed as a `Splice` with a known `tpt` or desugared and
-   *  typed as a quote pattern holes.
+   *  `Splice`s are created by the `Parser`. In typer they can be typed as a
+   *  `Splice` with a known `tpt` or desugared and typed as a quote pattern holes.
    *
    *  `Splice` are checked and transformed in the `staging` and `splicing` phases.
    *  After `splicing` phase, the only splices that exist are in `inline`
    *  methods. These are dropped when we remove the inline method implementations.
    *
-   *  The `tpt` will be transformed in `staging` and used in `splicing` to create `Hole`s.
-   *
    *  @param expr The tree that was spliced
-   *  @param tpt  The type of the spliced tree
    */
-  case class Splice[+T <: Untyped] private[ast] (expr: Tree[T], tpt: Tree[T])(implicit @constructorOnly src: SourceFile)
+  case class Splice[+T <: Untyped] private[ast] (expr: Tree[T])(implicit @constructorOnly src: SourceFile)
     extends TermTree[T] {
     type ThisTree[+T <: Untyped] = Splice[T]
   }
@@ -1313,9 +1309,9 @@ object Trees {
         case tree: Quote if (expr eq tree.expr) => tree
         case _ => finalize(tree, untpd.Quote(expr)(sourceFile(tree)))
       }
-      def Splice(tree: Tree)(expr: Tree, tpt: Tree)(using Context): Splice = tree match {
-        case tree: Splice if (expr eq tree.expr) && (tpt eq tree.tpt) => tree
-        case _ => finalize(tree, untpd.Splice(expr, tpt)(sourceFile(tree)))
+      def Splice(tree: Tree)(expr: Tree)(using Context): Splice = tree match {
+        case tree: Splice if (expr eq tree.expr) => tree
+        case _ => finalize(tree, untpd.Splice(expr)(sourceFile(tree)))
       }
       def SingletonTypeTree(tree: Tree)(ref: Tree)(using Context): SingletonTypeTree = tree match {
         case tree: SingletonTypeTree if (ref eq tree.ref) => tree
@@ -1422,8 +1418,6 @@ object Trees {
         TypeDef(tree: Tree)(name, rhs)
       def Template(tree: Template)(using Context)(constr: DefDef = tree.constr, parents: List[Tree] = tree.parents, derived: List[untpd.Tree] = tree.derived, self: ValDef = tree.self, body: LazyTreeList = tree.unforcedBody): Template =
         Template(tree: Tree)(constr, parents, derived, self, body)
-      def Splice(tree: Splice)(expr: Tree = tree.expr, tpt: Tree = tree.tpt)(using Context): Splice =
-        Splice(tree: Tree)(expr, tpt)
       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)
 
@@ -1558,8 +1552,8 @@ object Trees {
               if (trees1 eq trees) tree else Thicket(trees1)
             case tree @ Quote(expr) =>
               cpy.Quote(tree)(transform(expr))
-            case tree @ Splice(expr, tpt) =>
-              cpy.Splice(tree)(transform(expr), transform(tpt))
+            case tree @ Splice(expr) =>
+              cpy.Splice(tree)(transform(expr))
             case tree @ Hole(_, _, args, content, tpt) =>
               cpy.Hole(tree)(args = transform(args), content = transform(content), tpt = transform(tpt))
             case _ =>
@@ -1703,8 +1697,8 @@ object Trees {
               this(x, ts)
             case Quote(expr) =>
               this(x, expr)
-            case Splice(expr, tpt) =>
-              this(this(x, expr), tpt)
+            case Splice(expr) =>
+              this(x, expr)
             case Hole(_, _, args, content, tpt) =>
               this(this(this(x, args), content), tpt)
             case _ =>
diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
index 78de609850db..ce9bd3ea0595 100644
--- a/compiler/src/dotty/tools/dotc/ast/tpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -173,8 +173,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def Quote(expr: Tree, tpe: Type)(using Context): Quote =
     untpd.Quote(expr).withExprType(tpe)
 
-  def Splice(expr: Tree, tpt: Tree)(using Context): Splice =
-    ta.assignType(untpd.Splice(expr, tpt), tpt)
+  def Splice(expr: Tree, tpe: Type)(using Context): Splice =
+    untpd.Splice(expr).withType(tpe)
 
   def TypeTree(tp: Type, inferred: Boolean = false)(using Context): TypeTree =
     (if inferred then untpd.InferredTypeTree() else untpd.TypeTree()).withType(tp)
diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
index 4fdd9115f2c9..ec85ffa689b6 100644
--- a/compiler/src/dotty/tools/dotc/ast/untpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -398,7 +398,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   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 Quote(expr: Tree)(implicit src: SourceFile): Quote = new Quote(expr)
-  def Splice(expr: Tree, tpt: Tree)(implicit src: SourceFile): Splice = new Splice(expr, tpt)
+  def Splice(expr: Tree)(implicit src: SourceFile): Splice = new Splice(expr)
   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)
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
index 6346c2f3dd03..7682e042304a 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -667,17 +667,17 @@ class TreePickler(pickler: TastyPickler) {
           }
         case tree @ Quote(expr) =>
           pickleTree(
-            // scala.quoted.runtime.Expr.quoted[<exprType>](<expr>)
+            // scala.quoted.runtime.Expr.quoted[<tree.exprType>](<expr>)
             ref(defn.QuotedRuntime_exprQuote)
               .appliedToType(tree.exprType)
               .appliedTo(expr)
               .withSpan(tree.span)
           )
-        case Splice(expr, tpt) =>
+        case Splice(expr) =>
           pickleTree(
-            // scala.quoted.runtime.Expr.splice[<tpt>](<spliced>)
+            // scala.quoted.runtime.Expr.splice[<tree.tpe>](<expr>)
             ref(defn.QuotedRuntime_exprSplice)
-              .appliedToTypeTree(tpt)
+              .appliedToType(tree.tpe)
               .appliedTo(expr)
               .withSpan(tree.span)
           )
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
index 02e79854c666..4f81e1477ea7 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
@@ -1273,12 +1273,12 @@ class TreeUnpickler(reader: TastyReader,
 
       def splicedExpr(fn: Tree, args: List[Tree]): Tree =
         val TypeApply(_, targs) = fn: @unchecked
-        Splice(args.head, targs.head)
+        Splice(args.head, targs.head.tpe)
 
       def nestedSpliceExpr(fn: Tree, args: List[Tree]): Tree =
         fn match
           case Apply(TypeApply(_, targs), _ :: Nil) => // nestedSplice[T](quotes)(expr)
-            Splice(args.head, targs.head)
+            Splice(args.head, targs.head.tpe)
           case _ => // nestedSplice[T](quotes)
             tpd.Apply(fn, args)
 
diff --git a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
index 8f3c4df237a6..9179e92527e6 100644
--- a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
@@ -827,14 +827,14 @@ class Inliner(val call: tpd.Tree)(using Context):
 
     override def typedQuote(tree: untpd.Quote, pt: Type)(using Context): Tree =
       super.typedQuote(tree, pt) match
-        case Quote(Splice(inner, _)) => inner
+        case Quote(Splice(inner)) => inner
         case tree1 =>
           ctx.compilationUnit.needsStaging = true
           tree1
 
     override def typedSplice(tree: untpd.Splice, pt: Type)(using Context): Tree =
       super.typedSplice(tree, pt) match
-        case tree1 @ Splice(expr, tpt)
+        case tree1 @ Splice(expr)
             if StagingLevel.level == 0
             && !hasInliningErrors =>
           val expanded = expandMacro(expr, tree1.srcPos)
@@ -1078,7 +1078,7 @@ class Inliner(val call: tpd.Tree)(using Context):
             level += 1
             try apply(syms, body)
             finally level -= 1
-          case Splice(body, _) =>
+          case Splice(body) =>
             level -= 1
             try apply(syms, body)
             finally level += 1
diff --git a/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala b/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
index 11d4d9881230..c771eff9e840 100644
--- a/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
@@ -291,7 +291,7 @@ object PrepareInlineable {
     if (inlined.is(Macro) && !ctx.isAfterTyper) {
 
       def checkMacro(tree: Tree): Unit = tree match {
-        case Splice(code, _) =>
+        case Splice(code) =>
           if (code.symbol.flags.is(Inline))
             report.error("Macro cannot be implemented with an `inline` method", code.srcPos)
           Splicer.checkValidMacroBody(code)
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index d98f407edc73..9e169d334bd5 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -1764,7 +1764,7 @@ object Parsers {
           syntaxError(em"$msg\n\nHint: $hint", Span(start, in.lastOffset))
           Ident(nme.ERROR.toTypeName)
         else
-          Splice(expr, EmptyTree)
+          Splice(expr)
       }
 
     /**  SimpleType      ::=  SimpleLiteral
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index 8cf9ab00b091..7ed8ede8aaf9 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -717,11 +717,11 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case MacroTree(call) =>
         keywordStr("macro ") ~ toTextGlobal(call)
       case tree @ Quote(expr) =>
-        val exprTypeText = (keywordStr("[") ~ toTextGlobal(tree.exprType) ~ keywordStr("]")).provided(printDebug)
+        val exprTypeText = (keywordStr("[") ~ toTextGlobal(tree.exprType) ~ keywordStr("]")).provided(printDebug && tree.typeOpt.exists)
         keywordStr("'") ~ exprTypeText ~ keywordStr("{") ~ toTextGlobal(expr) ~ keywordStr("}")
-      case Splice(expr, tpt) =>
-        val tptText = (keywordStr("[") ~ toTextGlobal(tpt) ~ keywordStr("]")).provided(!tpt.isEmpty && printDebug)
-        keywordStr("$") ~ tptText ~ keywordStr("{") ~ toTextGlobal(expr) ~ keywordStr("}")
+      case Splice(expr) =>
+        val spliceTypeText = (keywordStr("[") ~ toTextGlobal(tree.typeOpt) ~ keywordStr("]")).provided(printDebug && tree.typeOpt.exists)
+        keywordStr("$") ~ spliceTypeText ~ keywordStr("{") ~ toTextGlobal(expr) ~ keywordStr("}")
       case Hole(isTermHole, idx, args, content, tpt) =>
         val (prefix, postfix) = if isTermHole then ("{{{", "}}}") else ("[[[", "]]]")
         val argsText = toTextGlobal(args, ", ")
diff --git a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
index 36b2b9caa050..32b54ffa7ff8 100644
--- a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
+++ b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
@@ -144,13 +144,10 @@ class CrossStageSafety extends TreeMapWithStages {
    */
   protected def transformSplice(body: Tree, splice: Splice)(using Context): Tree = {
     val body1 = transform(body)(using spliceContext)
-    val tpt1 =
-      if level == 0 then
-        transform(splice.tpt)
-      else
-        val tp = healType(splice.srcPos)(splice.tpe.widenTermRefExpr)
-        TypeTree(tp).withSpan(splice.tpt.span)
-    cpy.Splice(splice)(body1, tpt1)
+    val tpe1 =
+      if level == 0 then splice.tpe
+      else healType(splice.srcPos)(splice.tpe.widenTermRefExpr)
+    untpd.cpy.Splice(splice)(body1).withType(tpe1)
   }
 
   protected def transformSpliceType(body: Tree, splice: Select)(using Context): Tree = {
diff --git a/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala b/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
index 0a85ef5e9e84..ddf2017af368 100644
--- a/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
+++ b/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
@@ -66,7 +66,7 @@ abstract class TreeMapWithStages extends TreeMapWithImplicits {
           val old = inQuoteOrSplice
           inQuoteOrSplice = true
           try dropEmptyBlocks(quotedTree) match {
-            case Splice(t, _) =>
+            case Splice(t) =>
               // Optimization: `'{ $x }` --> `x`
               // and adapt the refinement of `Quotes { type reflect: ... } ?=> Expr[T]`
               transform(t).asInstance(tree.tpe)
@@ -75,7 +75,7 @@ abstract class TreeMapWithStages extends TreeMapWithImplicits {
           }
           finally inQuoteOrSplice = old
 
-        case tree @ Splice(splicedTree, _) =>
+        case tree @ Splice(splicedTree) =>
           val old = inQuoteOrSplice
           inQuoteOrSplice = true
           try dropEmptyBlocks(splicedTree) match {
diff --git a/compiler/src/dotty/tools/dotc/transform/MegaPhase.scala b/compiler/src/dotty/tools/dotc/transform/MegaPhase.scala
index 86393cf2d466..cf34c60330fa 100644
--- a/compiler/src/dotty/tools/dotc/transform/MegaPhase.scala
+++ b/compiler/src/dotty/tools/dotc/transform/MegaPhase.scala
@@ -407,8 +407,7 @@ class MegaPhase(val miniPhases: Array[MiniPhase]) extends Phase {
       case tree: Splice =>
         inContext(prepSplice(tree, start)(using outerCtx)) {
           val expr = transformTree(tree.expr, start)(using spliceContext)
-          val tpt = transformTree(tree.tpt, start)
-          goSplice(cpy.Splice(tree)(expr, tpt), start)
+          goSplice(cpy.Splice(tree)(expr), start)
         }
       case tree: Return =>
         inContext(prepReturn(tree, start)(using outerCtx)) {
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicer.scala b/compiler/src/dotty/tools/dotc/transform/Splicer.scala
index d65823ff9407..38f1005cd813 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicer.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicer.scala
@@ -158,7 +158,7 @@ object Splicer {
         case Apply(Select(Quote(expr), nme.apply), _) =>
           val noSpliceChecker = new TreeTraverser {
             def traverse(tree: Tree)(using Context): Unit = tree match
-              case Splice(_, _) =>
+              case Splice(_) =>
                 report.error("Quoted argument of macros may not have splices", tree.srcPos)
               case _ =>
                 traverseChildren(tree)
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicing.scala b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
index 1b3013bdcfff..fd195e8f068f 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicing.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
@@ -114,7 +114,7 @@ class Splicing extends MacroTransform:
         case tree: Splice =>
           if level > 1 then
             val expr1 = super.transform(tree.expr)(using spliceContext)
-            cpy.Splice(tree)(expr1, tree.tpt)
+            cpy.Splice(tree)(expr1)
           else
             val holeIdx = numHoles
             numHoles += 1
@@ -234,9 +234,9 @@ class Splicing extends MacroTransform:
         case tree @ Assign(lhs: RefTree, rhs) =>
           if isCaptured(lhs.symbol) then transformSplicedAssign(tree)
           else super.transform(tree)
-        case Splice(expr, tpt) =>
+        case Splice(expr) =>
           val expr1 = transform(expr)(using spliceContext)
-          cpy.Splice(tree)(expr1, tpt)
+          cpy.Splice(tree)(expr1)
         case Apply(sel @ Select(app @ Quote(expr), nme.apply), quotesArgs) =>
           expr match
             case expr: RefTree if isCaptured(expr.symbol) =>
@@ -409,7 +409,7 @@ class Splicing extends MacroTransform:
             body(using ctx.withOwner(meth)).changeOwner(ctx.owner, meth)
           }
         })
-      Splice(closure, TypeTree(tpe))
+      Splice(closure, tpe)
 
     private def quoted(expr: Tree)(using Context): Tree =
       Quote(expr, expr.tpe.widenTermRefExpr)
diff --git a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
index 01b4a4384e9f..4642bdbbb9ba 100644
--- a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
+++ b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
@@ -37,7 +37,7 @@ trait QuotesAndSplices {
   def typedQuote(tree: untpd.Quote, pt: Type)(using Context): Tree = {
     record("typedQuote")
     tree.expr match {
-      case untpd.Splice(innerExpr, _) if tree.isTerm && !ctx.mode.is(Mode.Pattern) =>
+      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 _ =>
     }
@@ -73,7 +73,6 @@ trait QuotesAndSplices {
   /** 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")
-    assert(tree.tpt.isEmpty)
     checkSpliceOutsideQuote(tree)
     tree.expr match {
       case untpd.Quote(innerExpr) if innerExpr.isTerm =>
@@ -89,7 +88,7 @@ trait QuotesAndSplices {
           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
-        Splice(pat, TypeTree(argType)).withSpan(tree.span)
+        Splice(pat, argType).withSpan(tree.span)
       }
       else {
         report.error(em"Type must be fully defined.\nConsider annotating the splice using a type ascription:\n  ($tree: XYZ).", tree.expr.srcPos)
@@ -111,7 +110,7 @@ trait QuotesAndSplices {
         untpd.Apply(untpd.ref(defn.QuotedRuntime_exprSplice.termRef), tree.expr)
       typedApply(internalSplice, pt)(using spliceContext).withSpan(tree.span) match
         case tree @ Apply(TypeApply(_, tpt :: Nil), spliced :: Nil) if tree.symbol == defn.QuotedRuntime_exprSplice =>
-          cpy.Splice(tree)(spliced, tpt)
+          cpy.Splice(tree)(spliced)
         case tree => tree
     }
   }
@@ -229,12 +228,10 @@ trait QuotesAndSplices {
       val freshTypeBindingsBuff = new mutable.ListBuffer[Tree]
       val typePatBuf = new mutable.ListBuffer[Tree]
       override def transform(tree: Tree)(using Context) = tree match {
-        case Typed(Splice(pat, _), tpt) if !tpt.tpe.derivesFrom(defn.RepeatedParamClass) =>
-          val tpt1 = transform(tpt) // Transform type bindings
-          val exprTpt = AppliedTypeTree(TypeTree(defn.QuotedExprClass.typeRef), tpt1 :: Nil)
-          val newSplice = cpy.Splice(tree)(pat, tpt1)
-          transform(newSplice)
-        case Apply(TypeApply(fn, targs), Splice(pat, _) :: args :: Nil) if fn.symbol == defn.QuotedRuntimePatterns_patternHigherOrderHole =>
+        case Typed(splice: Splice, tpt) if !tpt.tpe.derivesFrom(defn.RepeatedParamClass) =>
+          transform(tpt) // Collect type bindings
+          transform(splice)
+        case Apply(TypeApply(fn, targs), Splice(pat) :: 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
@@ -246,7 +243,7 @@ trait QuotesAndSplices {
             val pat1 = if (patType eq patType1) pat else pat.withType(patType1)
             patBuf += pat1
           }
-        case Splice(pat, _) =>
+        case Splice(pat) =>
           try ref(defn.QuotedRuntimePatterns_patternHole.termRef).appliedToType(tree.tpe).withSpan(tree.span)
           finally {
             val patType = pat.tpe.widen
diff --git a/compiler/src/dotty/tools/dotc/typer/ReTyper.scala b/compiler/src/dotty/tools/dotc/typer/ReTyper.scala
index c96dbad2d01a..b43722d54cc7 100644
--- a/compiler/src/dotty/tools/dotc/typer/ReTyper.scala
+++ b/compiler/src/dotty/tools/dotc/typer/ReTyper.scala
@@ -101,12 +101,14 @@ class ReTyper(nestingLevel: Int = 0) extends Typer(nestingLevel) with ReChecking
     untpd.cpy.Quote(tree)(expr1).withType(tree.typeOpt)
 
   override def typedSplice(tree: untpd.Splice, pt: Type)(using Context): Tree =
-    val tpt1 = checkSimpleKinded(typedType(tree.tpt, mapPatternBounds = true))
-    val splicedType = // Quotes ?=> Expr[T]
+    assertTyped(tree)
+    val exprType = // Expr[T]
+        defn.QuotedExprClass.typeRef.appliedTo(tree.typeOpt)
+    val quoteType = // Quotes ?=> Expr[T]
       defn.FunctionType(1, isContextual = true)
-        .appliedTo(defn.QuotesClass.typeRef, defn.QuotedExprClass.typeRef.appliedTo(tpt1.tpe.widenSkolem))
-    val expr1 = typed(tree.expr, splicedType)(using spliceContext)
-    assignType(untpd.cpy.Splice(tree)(expr1, tpt1), tpt1)
+        .appliedTo(defn.QuotesClass.typeRef, exprType)
+    val expr1 = typed(tree.expr, quoteType)(using spliceContext)
+    untpd.cpy.Splice(tree)(expr1).withType(tree.typeOpt)
 
   override def localDummy(cls: ClassSymbol, impl: untpd.Template)(using Context): Symbol = impl.symbol
 
diff --git a/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala b/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
index c22d1eb72aa6..6ac45cbcf04d 100644
--- a/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
+++ b/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
@@ -392,9 +392,6 @@ trait TypeAssigner {
   def assignType(tree: untpd.Inlined, bindings: List[Tree], expansion: Tree)(using Context): Inlined =
     tree.withType(avoidingType(expansion, bindings))
 
-  def assignType(tree: untpd.Splice, tpt: Tree)(using Context): Splice =
-    tree.withType(tpt.tpe)
-
   def assignType(tree: untpd.If, thenp: Tree, elsep: Tree)(using Context): If =
     tree.withType(thenp.tpe | elsep.tpe)
 
diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
index dc72962401cc..c0b778756d41 100644
--- a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
+++ b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
@@ -642,7 +642,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
           case self: tpd.Splice => // TODO expose Splice AST in Quotes
             import dotty.tools.dotc.ast.tpd.TreeOps
             tpd.ref(dotc.core.Symbols.defn.QuotedRuntime_exprSplice)
-              .appliedToTypeTree(self.tpt)
+              .appliedToType(self.tpe)
               .withSpan(self.span)
 
         def args: List[Term] = self match

From d4b2f0933f7b38c30ce1fb16ddbfaa74834282b0 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Fri, 28 Apr 2023 16:19:20 +0200
Subject: [PATCH 446/657] Rename `Quote.{expr=>body}`

Quotes can contain terms `'{..}` or types `'[..]`.
---
 compiler/src/dotty/tools/dotc/ast/Desugar.scala  |  4 ++--
 compiler/src/dotty/tools/dotc/ast/Trees.scala    | 16 ++++++++--------
 compiler/src/dotty/tools/dotc/ast/tpd.scala      |  4 ++--
 compiler/src/dotty/tools/dotc/ast/untpd.scala    |  2 +-
 .../tools/dotc/core/tasty/TreePickler.scala      |  6 +++---
 .../src/dotty/tools/dotc/parsing/Parsers.scala   |  4 ++--
 .../tools/dotc/printing/RefinedPrinter.scala     |  4 ++--
 .../dotty/tools/dotc/transform/MegaPhase.scala   |  4 ++--
 .../tools/dotc/transform/PickleQuotes.scala      |  2 +-
 .../dotty/tools/dotc/transform/PostTyper.scala   |  2 +-
 .../src/dotty/tools/dotc/transform/Splicer.scala | 14 +++++++-------
 .../dotty/tools/dotc/transform/Splicing.scala    |  4 ++--
 .../tools/dotc/typer/QuotesAndSplices.scala      | 10 +++++-----
 .../src/dotty/tools/dotc/typer/ReTyper.scala     |  4 ++--
 .../scala/quoted/runtime/impl/QuotesImpl.scala   |  2 +-
 15 files changed, 41 insertions(+), 41 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index c1dd78451bae..d6f9e0d24c91 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -1986,13 +1986,13 @@ object desugar {
         trees foreach collect
       case Block(Nil, expr) =>
         collect(expr)
-      case Quote(expr) =>
+      case Quote(body) =>
         new UntypedTreeTraverser {
           def traverse(tree: untpd.Tree)(using Context): Unit = tree match {
             case Splice(expr) => collect(expr)
             case _ => traverseChildren(tree)
           }
-        }.traverse(expr)
+        }.traverse(body)
       case CapturingTypeTree(refs, parent) =>
         collect(parent)
       case _ =>
diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala
index e5b7f32a674d..0bcc28d360e9 100644
--- a/compiler/src/dotty/tools/dotc/ast/Trees.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala
@@ -687,7 +687,7 @@ object Trees {
    *
    *  @param  expr  The tree that was quoted
    */
-  case class Quote[+T <: Untyped] private[ast] (expr: Tree[T])(implicit @constructorOnly src: SourceFile)
+  case class Quote[+T <: Untyped] private[ast] (body: Tree[T])(implicit @constructorOnly src: SourceFile)
     extends TermTree[T] {
     type ThisTree[+T <: Untyped] = Quote[T]
 
@@ -1305,9 +1305,9 @@ object Trees {
         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 Quote(tree: Tree)(expr: Tree)(using Context): Quote = tree match {
-        case tree: Quote if (expr eq tree.expr) => tree
-        case _ => finalize(tree, untpd.Quote(expr)(sourceFile(tree)))
+      def Quote(tree: Tree)(body: Tree)(using Context): Quote = tree match {
+        case tree: Quote if (body eq tree.body) => tree
+        case _ => finalize(tree, untpd.Quote(body)(sourceFile(tree)))
       }
       def Splice(tree: Tree)(expr: Tree)(using Context): Splice = tree match {
         case tree: Splice if (expr eq tree.expr) => tree
@@ -1550,8 +1550,8 @@ object Trees {
             case Thicket(trees) =>
               val trees1 = transform(trees)
               if (trees1 eq trees) tree else Thicket(trees1)
-            case tree @ Quote(expr) =>
-              cpy.Quote(tree)(transform(expr))
+            case tree @ Quote(body) =>
+              cpy.Quote(tree)(transform(body))
             case tree @ Splice(expr) =>
               cpy.Splice(tree)(transform(expr))
             case tree @ Hole(_, _, args, content, tpt) =>
@@ -1695,8 +1695,8 @@ object Trees {
               this(this(x, arg), annot)
             case Thicket(ts) =>
               this(x, ts)
-            case Quote(expr) =>
-              this(x, expr)
+            case Quote(body) =>
+              this(x, body)
             case Splice(expr) =>
               this(x, expr)
             case Hole(_, _, args, content, tpt) =>
diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
index ce9bd3ea0595..a44472fed658 100644
--- a/compiler/src/dotty/tools/dotc/ast/tpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -170,8 +170,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def Inlined(call: Tree, bindings: List[MemberDef], expansion: Tree)(using Context): Inlined =
     ta.assignType(untpd.Inlined(call, bindings, expansion), bindings, expansion)
 
-  def Quote(expr: Tree, tpe: Type)(using Context): Quote =
-    untpd.Quote(expr).withExprType(tpe)
+  def Quote(body: Tree, tpe: Type)(using Context): Quote =
+    untpd.Quote(body).withExprType(tpe)
 
   def Splice(expr: Tree, tpe: Type)(using Context): Splice =
     untpd.Splice(expr).withType(tpe)
diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
index ec85ffa689b6..30f58fba44ec 100644
--- a/compiler/src/dotty/tools/dotc/ast/untpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -397,7 +397,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   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 Quote(expr: Tree)(implicit src: SourceFile): Quote = new Quote(expr)
+  def Quote(body: Tree)(implicit src: SourceFile): Quote = new Quote(body)
   def Splice(expr: Tree)(implicit src: SourceFile): Splice = new Splice(expr)
   def TypeTree()(implicit src: SourceFile): TypeTree = new TypeTree()
   def InferredTypeTree()(implicit src: SourceFile): TypeTree = new InferredTypeTree()
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
index 7682e042304a..97bfe4d28854 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -665,12 +665,12 @@ class TreePickler(pickler: TastyPickler) {
               pickleTree(hi)
               pickleTree(alias)
           }
-        case tree @ Quote(expr) =>
+        case tree @ Quote(body) =>
           pickleTree(
-            // scala.quoted.runtime.Expr.quoted[<tree.exprType>](<expr>)
+            // scala.quoted.runtime.Expr.quoted[<tree.exprType>](<body>)
             ref(defn.QuotedRuntime_exprQuote)
               .appliedToType(tree.exprType)
-              .appliedTo(expr)
+              .appliedTo(body)
               .withSpan(tree.span)
           )
         case Splice(expr) =>
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 9e169d334bd5..324c3037d8ce 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -2494,10 +2494,10 @@ object Parsers {
         case QUOTE =>
           atSpan(in.skipToken()) {
             withinStaged(StageKind.Quoted | (if (location.inPattern) StageKind.QuotedPattern else 0)) {
-              val expr =
+              val body =
                 if (in.token == LBRACKET) inBrackets(typ())
                 else stagedBlock()
-              Quote(expr)
+              Quote(body)
             }
           }
         case NEW =>
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index 7ed8ede8aaf9..d93cf1d87e02 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -716,9 +716,9 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         "Thicket {" ~~ toTextGlobal(trees, "\n") ~~ "}"
       case MacroTree(call) =>
         keywordStr("macro ") ~ toTextGlobal(call)
-      case tree @ Quote(expr) =>
+      case tree @ Quote(body) =>
         val exprTypeText = (keywordStr("[") ~ toTextGlobal(tree.exprType) ~ keywordStr("]")).provided(printDebug && tree.typeOpt.exists)
-        keywordStr("'") ~ exprTypeText ~ keywordStr("{") ~ toTextGlobal(expr) ~ keywordStr("}")
+        keywordStr("'") ~ exprTypeText ~ keywordStr("{") ~ toTextGlobal(body) ~ keywordStr("}")
       case Splice(expr) =>
         val spliceTypeText = (keywordStr("[") ~ toTextGlobal(tree.typeOpt) ~ keywordStr("]")).provided(printDebug && tree.typeOpt.exists)
         keywordStr("$") ~ spliceTypeText ~ keywordStr("{") ~ toTextGlobal(expr) ~ keywordStr("}")
diff --git a/compiler/src/dotty/tools/dotc/transform/MegaPhase.scala b/compiler/src/dotty/tools/dotc/transform/MegaPhase.scala
index cf34c60330fa..7ad109b67751 100644
--- a/compiler/src/dotty/tools/dotc/transform/MegaPhase.scala
+++ b/compiler/src/dotty/tools/dotc/transform/MegaPhase.scala
@@ -401,8 +401,8 @@ class MegaPhase(val miniPhases: Array[MiniPhase]) extends Phase {
         }
       case tree: Quote =>
         inContext(prepQuote(tree, start)(using outerCtx)) {
-          val expr = transformTree(tree.expr, start)(using quoteContext)
-          goQuote(cpy.Quote(tree)(expr), start)
+          val body = transformTree(tree.body, start)(using quoteContext)
+          goQuote(cpy.Quote(tree)(body), start)
         }
       case tree: Splice =>
         inContext(prepSplice(tree, start)(using outerCtx)) {
diff --git a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
index f23558e8fe9a..a0ea03f238df 100644
--- a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
@@ -101,7 +101,7 @@ class PickleQuotes extends MacroTransform {
     override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
       tree match
         case Apply(Select(quote: Quote, nme.apply), List(quotes)) =>
-          val (contents, codeWithHoles) = makeHoles(quote.expr)
+          val (contents, codeWithHoles) = makeHoles(quote.body)
           val sourceRef = Inlines.inlineCallTrace(ctx.owner, tree.sourcePos)
           val codeWithHoles2 = Inlined(sourceRef, Nil, codeWithHoles)
           val pickled = PickleQuotes(quotes, codeWithHoles2, contents, quote.exprType, false)
diff --git a/compiler/src/dotty/tools/dotc/transform/PostTyper.scala b/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
index 6861084b1dcb..d74392f201ba 100644
--- a/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
@@ -485,7 +485,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
           )
         case Block(_, Closure(_, _, tpt)) if ExpandSAMs.needsWrapperClass(tpt.tpe) =>
           superAcc.withInvalidCurrentClass(super.transform(tree))
-        case Quote(expr) =>
+        case _: Quote =>
           ctx.compilationUnit.needsStaging = true
           super.transform(tree)
         case tree =>
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicer.scala b/compiler/src/dotty/tools/dotc/transform/Splicer.scala
index 38f1005cd813..8f45fd94d205 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicer.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicer.scala
@@ -155,7 +155,7 @@ object Splicer {
         case Block(Nil, expr) => checkIfValidArgument(expr)
         case Typed(expr, _) => checkIfValidArgument(expr)
 
-        case Apply(Select(Quote(expr), nme.apply), _) =>
+        case Apply(Select(Quote(body), nme.apply), _) =>
           val noSpliceChecker = new TreeTraverser {
             def traverse(tree: Tree)(using Context): Unit = tree match
               case Splice(_) =>
@@ -163,7 +163,7 @@ object Splicer {
               case _ =>
                 traverseChildren(tree)
           }
-          noSpliceChecker.traverse(expr)
+          noSpliceChecker.traverse(body)
 
         case Apply(TypeApply(fn, List(quoted)), _)if fn.symbol == defn.QuotedTypeModule_of =>
           // OK
@@ -240,15 +240,15 @@ object Splicer {
 
     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(Quote(expr), nme.apply), _) =>
-        val expr1 = expr match {
+      case Apply(Select(Quote(body), nme.apply), _) =>
+        val body1 = body match {
           case expr: Ident if expr.symbol.isAllOf(InlineByNameProxy) =>
             // inline proxy for by-name parameter
             expr.symbol.defTree.asInstanceOf[DefDef].rhs
-          case Inlined(EmptyTree, _, expr1) => expr1
-          case _ => expr
+          case Inlined(EmptyTree, _, body1) => body1
+          case _ => body
         }
-        new ExprImpl(Inlined(EmptyTree, Nil, QuoteUtils.changeOwnerOfTree(expr1, ctx.owner)).withSpan(expr1.span), SpliceScope.getCurrent)
+        new ExprImpl(Inlined(EmptyTree, Nil, QuoteUtils.changeOwnerOfTree(body1, ctx.owner)).withSpan(body1.span), SpliceScope.getCurrent)
 
       // Interpret level -1 `Type.of[T]`
       case Apply(TypeApply(fn, quoted :: Nil), _) if fn.symbol == defn.QuotedTypeModule_of =>
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicing.scala b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
index fd195e8f068f..a0f105fa9745 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicing.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
@@ -86,7 +86,7 @@ class Splicing extends MacroTransform:
     override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
       assert(level == 0)
       tree match
-        case Apply(Select(Quote(expr), nme.apply),List(quotes)) =>
+        case Apply(Select(_: Quote, nme.apply), _) =>
           QuoteTransformer().transform(tree)
         case TypeApply(_, _) if tree.symbol == defn.QuotedTypeModule_of =>
           QuoteTransformer().transform(tree)
@@ -134,7 +134,7 @@ class Splicing extends MacroTransform:
               typeHoles.put(qual, hole)
               hole
           cpy.TypeDef(tree)(rhs = hole)
-        case Apply(Select(Quote(expr), nme.apply),List(quotes)) =>
+        case Apply(Select(_: Quote, nme.apply),List(quotes)) =>
           super.transform(tree)(using quoteContext)
         case _: Template =>
           for sym <- tree.symbol.owner.info.decls do
diff --git a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
index 4642bdbbb9ba..ebff31414d68 100644
--- a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
+++ b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
@@ -36,8 +36,8 @@ trait QuotesAndSplices {
    */
   def typedQuote(tree: untpd.Quote, pt: Type)(using Context): Tree = {
     record("typedQuote")
-    tree.expr match {
-      case untpd.Splice(innerExpr) if tree.isTerm && !ctx.mode.is(Mode.Pattern) =>
+    tree.body match {
+      case _: untpd.Splice if tree.isTerm && !ctx.mode.is(Mode.Pattern) =>
         report.warning("Canceled splice directly inside a quote. '{ ${ XYZ } } is equivalent to XYZ.", tree.srcPos)
       case _ =>
     }
@@ -50,7 +50,7 @@ trait QuotesAndSplices {
 
     if ctx.mode.is(Mode.Pattern) then
       typedQuotePattern(tree, pt, quotes).withSpan(tree.span)
-    else if tree.expr.isType then
+    else if tree.body.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.
@@ -59,7 +59,7 @@ trait QuotesAndSplices {
       EmptyTree
     else
       // TODO typecheck directly (without `exprQuote`)
-      val exprQuoteTree = untpd.Apply(untpd.ref(defn.QuotedRuntime_exprQuote.termRef), tree.expr)
+      val exprQuoteTree = untpd.Apply(untpd.ref(defn.QuotedRuntime_exprQuote.termRef), tree.body)
       val quotedExpr = typedApply(exprQuoteTree, pt)(using quoteContext) match
         case Apply(TypeApply(fn, tpt :: Nil), quotedExpr :: Nil) => Quote(quotedExpr, tpt.tpe)
       makeInlineable(quotedExpr.select(nme.apply).appliedTo(quotes).withSpan(tree.span))
@@ -383,7 +383,7 @@ trait QuotesAndSplices {
    *  ```
    */
   private def typedQuotePattern(tree: untpd.Quote, pt: Type, qctx: Tree)(using Context): Tree = {
-    val quoted = tree.expr
+    val quoted = tree.body
     if quoted.isTerm && !pt.derivesFrom(defn.QuotedExprClass) then
       report.error("Quote pattern can only match scrutinees of type scala.quoted.Expr", tree.srcPos)
     else if quoted.isType && !pt.derivesFrom(defn.QuotedTypeClass) then
diff --git a/compiler/src/dotty/tools/dotc/typer/ReTyper.scala b/compiler/src/dotty/tools/dotc/typer/ReTyper.scala
index b43722d54cc7..d8e9b115ea49 100644
--- a/compiler/src/dotty/tools/dotc/typer/ReTyper.scala
+++ b/compiler/src/dotty/tools/dotc/typer/ReTyper.scala
@@ -97,8 +97,8 @@ class ReTyper(nestingLevel: Int = 0) extends Typer(nestingLevel) with ReChecking
 
   override def typedQuote(tree: untpd.Quote, pt: Type)(using Context): Tree =
     assertTyped(tree)
-    val expr1 = typed(tree.expr, tree.exprType)(using quoteContext)
-    untpd.cpy.Quote(tree)(expr1).withType(tree.typeOpt)
+    val body1 = typed(tree.body, tree.exprType)(using quoteContext)
+    untpd.cpy.Quote(tree)(body1).withType(tree.typeOpt)
 
   override def typedSplice(tree: untpd.Splice, pt: Type)(using Context): Tree =
     assertTyped(tree)
diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
index c0b778756d41..1df2abcf0453 100644
--- a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
+++ b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
@@ -647,7 +647,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
         def args: List[Term] = self match
           case self: tpd.Apply => self.args
-          case self: tpd.Quote => List(self.expr) // TODO expose Quote AST in Quotes
+          case self: tpd.Quote => List(self.body) // TODO expose Quote AST in Quotes
           case self: tpd.Splice => List(self.expr) // TODO expose Splice AST in Quotes
       end extension
     end ApplyMethods

From 35408ec652effb8ecd03cb6b76128cd561ba2245 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Fri, 28 Apr 2023 16:29:24 +0200
Subject: [PATCH 447/657] Fix staging level tracking in Transformer

---
 compiler/src/dotty/tools/dotc/ast/Trees.scala |  5 +++--
 .../dotty/tools/dotc/transform/Splicing.scala | 20 +++++++------------
 2 files changed, 10 insertions(+), 15 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala
index 0bcc28d360e9..c9840cd36cdf 100644
--- a/compiler/src/dotty/tools/dotc/ast/Trees.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala
@@ -17,6 +17,7 @@ import annotation.unchecked.uncheckedVariance
 import annotation.constructorOnly
 import compiletime.uninitialized
 import Decorators._
+import staging.StagingLevel.*
 
 object Trees {
 
@@ -1551,9 +1552,9 @@ object Trees {
               val trees1 = transform(trees)
               if (trees1 eq trees) tree else Thicket(trees1)
             case tree @ Quote(body) =>
-              cpy.Quote(tree)(transform(body))
+              cpy.Quote(tree)(transform(body)(using quoteContext))
             case tree @ Splice(expr) =>
-              cpy.Splice(tree)(transform(expr))
+              cpy.Splice(tree)(transform(expr)(using spliceContext))
             case tree @ Hole(_, _, args, content, tpt) =>
               cpy.Hole(tree)(args = transform(args), content = transform(content), tpt = transform(tpt))
             case _ =>
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicing.scala b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
index a0f105fa9745..0b50343905f8 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicing.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
@@ -111,17 +111,13 @@ class Splicing extends MacroTransform:
 
     override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
       tree match
-        case tree: Splice =>
-          if level > 1 then
-            val expr1 = super.transform(tree.expr)(using spliceContext)
-            cpy.Splice(tree)(expr1)
-          else
-            val holeIdx = numHoles
-            numHoles += 1
-            val splicer = SpliceTransformer(ctx.owner, quotedDefs.contains)
-            val newSplicedCode1 = splicer.transformSplice(tree.expr, tree.tpe, holeIdx)(using spliceContext)
-            val newSplicedCode2 = Level0QuoteTransformer.transform(newSplicedCode1)(using spliceContext)
-            newSplicedCode2
+        case tree: Splice if level == 1 =>
+          val holeIdx = numHoles
+          numHoles += 1
+          val splicer = SpliceTransformer(ctx.owner, quotedDefs.contains)
+          val newSplicedCode1 = splicer.transformSplice(tree.expr, 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
@@ -134,8 +130,6 @@ class Splicing extends MacroTransform:
               typeHoles.put(qual, hole)
               hole
           cpy.TypeDef(tree)(rhs = hole)
-        case Apply(Select(_: Quote, nme.apply),List(quotes)) =>
-          super.transform(tree)(using quoteContext)
         case _: Template =>
           for sym <- tree.symbol.owner.info.decls do
             quotedDefs += sym

From e73eab74b8d681bbf9ce61d9a8df50addfe00e62 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Fri, 28 Apr 2023 16:40:01 +0200
Subject: [PATCH 448/657] Cleanup unnecessary staging level updates

---
 .../dotc/inlines/PrepareInlineable.scala      |  2 --
 .../dotty/tools/dotc/transform/Inlining.scala |  8 --------
 .../dotty/tools/dotc/transform/Splicing.scala | 20 +++++++------------
 3 files changed, 7 insertions(+), 23 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala b/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
index c771eff9e840..ed8683bf210e 100644
--- a/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
@@ -91,9 +91,7 @@ object PrepareInlineable {
         }
 
       private def stagingContext(tree: Tree)(using Context): Context = tree match
-        case tree: Quote => StagingLevel.quoteContext
         case tree: Apply if tree.symbol eq defn.QuotedTypeModule_of => StagingLevel.quoteContext
-        case tree: Splice => StagingLevel.spliceContext
         case _ => ctx
     }
 
diff --git a/compiler/src/dotty/tools/dotc/transform/Inlining.scala b/compiler/src/dotty/tools/dotc/transform/Inlining.scala
index 60714d273bf0..f5b72759b57e 100644
--- a/compiler/src/dotty/tools/dotc/transform/Inlining.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Inlining.scala
@@ -45,12 +45,8 @@ class Inlining extends MacroTransform {
         new TreeTraverser {
           def traverse(tree: Tree)(using Context): Unit =
             tree match
-              case _: Quote =>
-                traverseChildren(tree)(using StagingLevel.quoteContext)
               case _: GenericApply if tree.symbol == defn.QuotedTypeModule_of =>
                 traverseChildren(tree)(using StagingLevel.quoteContext)
-              case _: Splice =>
-                traverseChildren(tree)(using StagingLevel.spliceContext)
               case tree: RefTree if !Inlines.inInlineMethod && StagingLevel.level == 0 =>
                 assert(!tree.symbol.isInlineMethod, tree.show)
               case _ =>
@@ -99,12 +95,8 @@ class Inlining extends MacroTransform {
           val tree1 = super.transform(tree)
           if tree1.tpe.isError then tree1
           else Inlines.inlineCall(tree1)
-        case _: Quote =>
-          super.transform(tree)(using StagingLevel.quoteContext)
         case _: GenericApply if tree.symbol == defn.QuotedTypeModule_of =>
           super.transform(tree)(using StagingLevel.quoteContext)
-        case _: Splice =>
-          super.transform(tree)(using StagingLevel.spliceContext)
         case _: PackageDef =>
           super.transform(tree) match
             case tree1: PackageDef  =>
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicing.scala b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
index 0b50343905f8..e8102a5db224 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicing.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
@@ -228,19 +228,10 @@ class Splicing extends MacroTransform:
         case tree @ Assign(lhs: RefTree, rhs) =>
           if isCaptured(lhs.symbol) then transformSplicedAssign(tree)
           else super.transform(tree)
-        case Splice(expr) =>
-          val expr1 = transform(expr)(using spliceContext)
-          cpy.Splice(tree)(expr1)
-        case Apply(sel @ Select(app @ Quote(expr), nme.apply), quotesArgs) =>
-          expr match
-            case expr: RefTree if isCaptured(expr.symbol) =>
-              capturedTerm(expr)
-            case _ =>
-              val newExpr = withCurrentQuote(quotesArgs.head) {
-                if level > 1 then transform(expr)(using quoteContext)
-                else transformLevel0QuoteContent(expr)(using quoteContext)
-              }
-              cpy.Apply(tree)(cpy.Select(sel)(cpy.Quote(app)(newExpr), nme.apply), quotesArgs)
+        case Apply(sel @ Select(app @ Quote(body), nme.apply), quotesArgs) =>
+          body match
+            case body: RefTree if isCaptured(body.symbol) => capturedTerm(body)
+            case _ => withCurrentQuote(quotesArgs.head) { super.transform(tree) }
         case Apply(TypeApply(typeof, List(tpt)), List(quotes))
         if tree.symbol == defn.QuotedTypeModule_of && containsCapturedType(tpt.tpe) =>
           val newContent = capturedPartTypes(tpt)
@@ -253,6 +244,9 @@ class Splicing extends MacroTransform:
               ref(capturedType(newContent))(using ctx.withSource(tree.source)).withSpan(tree.span)
         case CapturedApplication(fn, argss) =>
           transformCapturedApplication(tree, fn, argss)
+        case Quote(expr) if level == 0 =>
+          val newExpr = transformLevel0QuoteContent(expr)(using quoteContext)
+          cpy.Quote(tree)(newExpr)
         case _ =>
           super.transform(tree)
 

From 48a610c326a97e3ee4efd56176d5e02322cd694c Mon Sep 17 00:00:00 2001
From: Adrien Piquerez <adrien.piquerez@gmail.com>
Date: Fri, 28 Apr 2023 14:40:34 +0200
Subject: [PATCH 449/657] Fix #17187: allow patches with same span

---
 .../dotty/tools/dotc/parsing/Parsers.scala    |  9 ++--
 .../dotty/tools/dotc/rewrites/Rewrites.scala  |  5 +--
 .../dotty/tools/dotc/CompilationTests.scala   |  1 +
 tests/rewrites/i12340.check                   |  9 ++++
 tests/rewrites/i12340.scala                   |  7 +++
 tests/rewrites/i17187.check                   | 44 +++++++++++++++++++
 tests/rewrites/i17187.scala                   | 33 ++++++++++++++
 7 files changed, 100 insertions(+), 8 deletions(-)
 create mode 100644 tests/rewrites/i17187.check
 create mode 100644 tests/rewrites/i17187.scala

diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 15a639743c15..f773e10bc80d 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -715,7 +715,11 @@ object Parsers {
       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")
+        val next = in.next
+        def closedByEndMarker =
+          next.token == END && (next.offset - next.lineOffset) == indentWidth.toPrefix.size
+        if closedByEndMarker then patch(source, Span(next.offset), "} // ")
+        else patch(source, Span(closingOffset(source.nextLine(in.lastOffset))), indentWidth.toPrefix ++ "}\n")
       t
     end indentedToBraces
 
@@ -1422,9 +1426,6 @@ object Parsers {
         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
diff --git a/compiler/src/dotty/tools/dotc/rewrites/Rewrites.scala b/compiler/src/dotty/tools/dotc/rewrites/Rewrites.scala
index 96e88e5c68ae..f2dfac88d464 100644
--- a/compiler/src/dotty/tools/dotc/rewrites/Rewrites.scala
+++ b/compiler/src/dotty/tools/dotc/rewrites/Rewrites.scala
@@ -23,10 +23,7 @@ object Rewrites {
     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)
-      }
+      pbuf += Patch(span, replacement)
 
     def apply(cs: Array[Char]): Array[Char] = {
       val delta = pbuf.map(_.delta).sum
diff --git a/compiler/test/dotty/tools/dotc/CompilationTests.scala b/compiler/test/dotty/tools/dotc/CompilationTests.scala
index ed531aa404c2..d75afc330f5f 100644
--- a/compiler/test/dotty/tools/dotc/CompilationTests.scala
+++ b/compiler/test/dotty/tools/dotc/CompilationTests.scala
@@ -81,6 +81,7 @@ class CompilationTests {
       compileFile("tests/rewrites/i9632.scala", defaultOptions.and("-indent", "-rewrite")),
       compileFile("tests/rewrites/i11895.scala", defaultOptions.and("-indent", "-rewrite")),
       compileFile("tests/rewrites/i12340.scala", unindentOptions.and("-rewrite")),
+      compileFile("tests/rewrites/i17187.scala", unindentOptions.and("-rewrite")),
     ).checkRewrites()
   }
 
diff --git a/tests/rewrites/i12340.check b/tests/rewrites/i12340.check
index c6cb9af8bb57..3ee2867f3e62 100644
--- a/tests/rewrites/i12340.check
+++ b/tests/rewrites/i12340.check
@@ -3,6 +3,15 @@ class C {
   def f = 42
 } // end C
 
+class A {
+  class B {
+    class C {
+      def foo = 42
+    }
+
+  } // end B
+}
+
 def f(i: Int) = {
   if i < 42 then
     println(i)
diff --git a/tests/rewrites/i12340.scala b/tests/rewrites/i12340.scala
index bf907ef9f276..10fcdd256f5b 100644
--- a/tests/rewrites/i12340.scala
+++ b/tests/rewrites/i12340.scala
@@ -3,6 +3,13 @@ class C:
   def f = 42
 end C
 
+class A:
+  class B:
+    class C:
+      def foo = 42
+
+  end B
+
 def f(i: Int) =
   if i < 42 then
     println(i)
diff --git a/tests/rewrites/i17187.check b/tests/rewrites/i17187.check
new file mode 100644
index 000000000000..1e6a07c79738
--- /dev/null
+++ b/tests/rewrites/i17187.check
@@ -0,0 +1,44 @@
+
+object A {
+  object B {
+    def a = 2
+  }
+}
+
+def m1 = {
+  def b = {
+    def c = 2
+  }
+}
+
+def m2 =
+  if true then {
+    val x = 3
+    if (false)
+      x
+    else {
+      val y = 4
+      y
+    }
+  }
+
+def m3 =
+  try {
+    val n2 = 21
+    val n1 = 4
+    n2 / n1
+  }
+  catch {
+    case _ => 4
+  }
+
+def m4 = {
+  val n2 = 21
+  try {
+    val n1 = 4
+    n2 / n1
+  }
+  catch {
+    case _ => 4
+  }
+}
diff --git a/tests/rewrites/i17187.scala b/tests/rewrites/i17187.scala
new file mode 100644
index 000000000000..e6a55e00b39a
--- /dev/null
+++ b/tests/rewrites/i17187.scala
@@ -0,0 +1,33 @@
+
+object A:
+  object B:
+    def a = 2
+
+def m1 =
+  def b =
+    def c = 2
+
+def m2 =
+  if true then
+    val x = 3
+    if (false)
+      x
+    else
+      val y = 4
+      y
+
+def m3 =
+  try
+    val n2 = 21
+    val n1 = 4
+    n2 / n1
+  catch
+    case _ => 4
+
+def m4 =
+  val n2 = 21
+  try
+    val n1 = 4
+    n2 / n1
+  catch
+    case _ => 4

From d6696d87ec0a9e9e3eb5a6e4b01b59a18e54f4ab Mon Sep 17 00:00:00 2001
From: Carl <carl.schutz@epfl.ch>
Date: Sat, 29 Apr 2023 13:31:14 +0200
Subject: [PATCH 450/657] Refactor unsetVarsFromUsedSym to .isUnsetVarDef

---
 .../src/dotty/tools/dotc/transform/CheckUnused.scala | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index 4eba6b525b01..bd521c8679d0 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -520,7 +520,7 @@ object CheckUnused:
           .filterNot(d => usedInPosition.exists { case (pos, name) => d.span.contains(pos.span) && name == d.symbol.name})
           .filterNot(d => containsSyntheticSuffix(d.symbol))
           .map(d => UnusedSymbol(d.namePos, d.name, WarnTypes.LocalDefs)).toList
-      val unsetLocalDefs = unsetVarsFromUsedSym(usedLocalDefs).map(d => UnusedSymbol(d.namePos, d.name, WarnTypes.UnsetLocals)).toList
+      val unsetLocalDefs = usedLocalDefs.filter(isUnsetVarDef).map(d => UnusedSymbol(d.namePos, d.name, WarnTypes.UnsetLocals)).toList
 
       val sortedExplicitParams =
         if ctx.settings.WunusedHas.explicits then
@@ -546,7 +546,7 @@ object CheckUnused:
         else
           (Nil, Nil)
       val sortedPrivateDefs = unusedPrivates.filterNot(d => containsSyntheticSuffix(d.symbol)).map(d => UnusedSymbol(d.namePos, d.name, WarnTypes.PrivateMembers)).toList
-      val unsetPrivateDefs = unsetVarsFromUsedSym(usedPrivates).map(d => UnusedSymbol(d.namePos, d.name, WarnTypes.UnsetPrivates)).toList
+      val unsetPrivateDefs = usedPrivates.filter(isUnsetVarDef).map(d => UnusedSymbol(d.namePos, d.name, WarnTypes.UnsetPrivates)).toList
       val sortedPatVars =
         if ctx.settings.WunusedHas.patvars then
           patVarsInScope
@@ -745,10 +745,13 @@ object CheckUnused:
         !isSyntheticMainParam(sym) &&
         !sym.shouldNotReportParamOwner
 
-
       private def shouldReportPrivateDef(using Context): Boolean =
         currScopeType.top == ScopeType.Template && !memDef.symbol.isConstructor && memDef.symbol.is(Private, butNot = SelfName | Synthetic | CaseAccessor)
 
+      private def isUnsetVarDef(using Context): Boolean =
+        val sym = memDef.symbol
+        sym.is(Mutable) && !setVars(sym)
+
     extension (imp: tpd.Import)
       /** Enum generate an import for its cases (but outside them), which should be ignored */
       def isGeneratedByEnum(using Context): Boolean =
@@ -758,9 +761,6 @@ object CheckUnused:
       private def isWildcard: Boolean =
         thisName == StdNames.nme.WILDCARD || thisName.is(WildcardParamName)
 
-    def unsetVarsFromUsedSym(usedDefs: Iterable[tpd.MemberDef])(using Context): Iterable[tpd.MemberDef] =
-      usedDefs.filter(d => d.symbol.is(Mutable) && !setVars(d.symbol))
-
   end UnusedData
 
   private object UnusedData:

From 9d3f270b674204535c45ec6b44fe9a7ec4596d32 Mon Sep 17 00:00:00 2001
From: Adrien Piquerez <adrien.piquerez@gmail.com>
Date: Mon, 1 May 2023 09:43:44 +0200
Subject: [PATCH 451/657] Revert exact match in overlaps

As suggested by @som-snytt in
https://github.com/lampepfl/dotty/pull/17366#pullrequestreview-1406509043
---
 compiler/src/dotty/tools/dotc/util/Spans.scala | 1 -
 1 file changed, 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/util/Spans.scala b/compiler/src/dotty/tools/dotc/util/Spans.scala
index ba537e9aec01..e1487408f36b 100644
--- a/compiler/src/dotty/tools/dotc/util/Spans.scala
+++ b/compiler/src/dotty/tools/dotc/util/Spans.scala
@@ -86,7 +86,6 @@ object Spans {
       || 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
       )
     }
 

From e06b0f95809f22c6dfb5c1e6283584d88bfa102d Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 1 May 2023 10:19:46 +0200
Subject: [PATCH 452/657] Use `Quote to encode `Type.of` in the `staging phase`

---
 compiler/src/dotty/tools/dotc/ast/Trees.scala | 28 +++++++++++------
 compiler/src/dotty/tools/dotc/ast/tpd.scala   |  4 +--
 .../tools/dotc/core/tasty/TreePickler.scala   | 10 ++++--
 .../tools/dotc/core/tasty/TreeUnpickler.scala |  2 +-
 .../tools/dotc/printing/RefinedPrinter.scala  |  6 ++--
 .../tools/dotc/staging/CrossStageSafety.scala | 11 ++++---
 .../dotc/staging/TreeMapWithStages.scala      |  4 ---
 .../tools/dotc/transform/PickleQuotes.scala   | 24 ++++++--------
 .../tools/dotc/transform/ReifiedReflect.scala |  4 +--
 .../dotty/tools/dotc/transform/Splicing.scala | 31 +++++++------------
 .../dotty/tools/dotc/transform/Staging.scala  |  7 +++++
 .../tools/dotc/typer/QuotesAndSplices.scala   | 10 +++---
 .../src/dotty/tools/dotc/typer/ReTyper.scala  |  2 +-
 .../quoted/runtime/impl/QuotesImpl.scala      |  2 +-
 14 files changed, 74 insertions(+), 71 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala
index c9840cd36cdf..19c189047c6d 100644
--- a/compiler/src/dotty/tools/dotc/ast/Trees.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala
@@ -678,7 +678,7 @@ object Trees {
     override def isType = expansion.isType
   }
 
-  /** A tree representing a quote `'{ expr }`
+  /** A tree representing a quote `'{ body }` or `'[ body ]`.
    *  `Quote`s are created by the `Parser`. In typer they can be typed as a
    *  `Quote` with a known `tpt` or desugared and typed as a quote pattern.
    *
@@ -686,23 +686,31 @@ object Trees {
    *  phases. After `pickleQuotes` phase, the only quotes that exist are in `inline`
    *  methods. These are dropped when we remove the inline method implementations.
    *
-   *  @param  expr  The tree that was quoted
+   *  Type quotes `'[body]` from the parser are desugared into quote patterns (using a `Type.of[T]]`)
+   *  when type checking. TASTy files will not contain type quotes. Type quotes are used again
+   *  in the `staging` phase to represent the reification of `Type.of[T]]`.
+   *
+   *  @param  body  The tree that was quoted
    */
   case class Quote[+T <: Untyped] private[ast] (body: Tree[T])(implicit @constructorOnly src: SourceFile)
     extends TermTree[T] {
     type ThisTree[+T <: Untyped] = Quote[T]
 
+    /** Is this a type quote `'[tpe]' */
+    def isTypeQuote = body.isType
+
     /** Type of the quoted expression as seen from outside the quote */
-    def exprType(using Context): Type =
-      val quoteType = typeOpt // Quotes ?=> Expr[T]
-      val exprType = quoteType.argInfos.last // Expr[T]
+    def bodyType(using Context): Type =
+      val quoteType = typeOpt // `Quotes ?=> Expr[T]` or `Quotes ?=> Type[T]`
+      val exprType = quoteType.argInfos.last // `Expr[T]` or `Type[T]`
       exprType.argInfos.head // T
 
-    /** Set the type of the quoted expression as seen from outside the quote */
-    def withExprType(tpe: Type)(using Context): Quote[Type] =
-      val exprType = // Expr[T]
-        defn.QuotedExprClass.typeRef.appliedTo(tpe)
-      val quoteType = // Quotes ?=> Expr[T]
+    /** Set the type of the body of the quote */
+    def withBodyType(tpe: Type)(using Context): Quote[Type] =
+      val exprType = // `Expr[T]` or `Type[T]`
+        if body.isTerm then defn.QuotedExprClass.typeRef.appliedTo(tpe)
+        else defn.QuotedTypeClass.typeRef.appliedTo(tpe)
+      val quoteType = // `Quotes ?=> Expr[T]` or `Quotes ?=> Type[T]`
         defn.FunctionType(1, isContextual = true)
           .appliedTo(defn.QuotesClass.typeRef, exprType)
       withType(quoteType)
diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
index a44472fed658..3a957c8f4612 100644
--- a/compiler/src/dotty/tools/dotc/ast/tpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -170,8 +170,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def Inlined(call: Tree, bindings: List[MemberDef], expansion: Tree)(using Context): Inlined =
     ta.assignType(untpd.Inlined(call, bindings, expansion), bindings, expansion)
 
-  def Quote(body: Tree, tpe: Type)(using Context): Quote =
-    untpd.Quote(body).withExprType(tpe)
+  def Quote(body: Tree)(using Context): Quote =
+    untpd.Quote(body).withBodyType(body.tpe)
 
   def Splice(expr: Tree, tpe: Type)(using Context): Splice =
     untpd.Splice(expr).withType(tpe)
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
index 97bfe4d28854..87620db36482 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -666,15 +666,19 @@ class TreePickler(pickler: TastyPickler) {
               pickleTree(alias)
           }
         case tree @ Quote(body) =>
+          // Add QUOTE tag to TASTy
+          assert(body.isTerm,
+            """Quote with type should not be pickled.
+              |Quote with type should only exists after staging phase at level staging level 0.""".stripMargin)
           pickleTree(
-            // scala.quoted.runtime.Expr.quoted[<tree.exprType>](<body>)
+            // scala.quoted.runtime.Expr.quoted[<tree.bodyType>](<body>)
             ref(defn.QuotedRuntime_exprQuote)
-              .appliedToType(tree.exprType)
+              .appliedToType(tree.bodyType)
               .appliedTo(body)
               .withSpan(tree.span)
           )
         case Splice(expr) =>
-          pickleTree(
+          pickleTree( // Add SPLICE tag to TASTy
             // scala.quoted.runtime.Expr.splice[<tree.tpe>](<expr>)
             ref(defn.QuotedRuntime_exprSplice)
               .appliedToType(tree.tpe)
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
index 4f81e1477ea7..10395a488640 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
@@ -1269,7 +1269,7 @@ class TreeUnpickler(reader: TastyReader,
 
       def quotedExpr(fn: Tree, args: List[Tree]): Tree =
         val TypeApply(_, targs) = fn: @unchecked
-        Quote(args.head, targs.head.tpe)
+        untpd.Quote(args.head).withBodyType(targs.head.tpe)
 
       def splicedExpr(fn: Tree, args: List[Tree]): Tree =
         val TypeApply(_, targs) = fn: @unchecked
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index d93cf1d87e02..93de33778750 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -717,8 +717,10 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case MacroTree(call) =>
         keywordStr("macro ") ~ toTextGlobal(call)
       case tree @ Quote(body) =>
-        val exprTypeText = (keywordStr("[") ~ toTextGlobal(tree.exprType) ~ keywordStr("]")).provided(printDebug && tree.typeOpt.exists)
-        keywordStr("'") ~ exprTypeText ~ keywordStr("{") ~ toTextGlobal(body) ~ keywordStr("}")
+        val exprTypeText = (keywordStr("[") ~ toTextGlobal(tree.bodyType) ~ keywordStr("]")).provided(printDebug && tree.typeOpt.exists)
+        val open = if (body.isTerm) keywordStr("{") else keywordStr("[")
+        val close = if (body.isTerm) keywordStr("}") else keywordStr("]")
+        keywordStr("'") ~ exprTypeText ~ open ~ toTextGlobal(body) ~ close
       case Splice(expr) =>
         val spliceTypeText = (keywordStr("[") ~ toTextGlobal(tree.typeOpt) ~ keywordStr("]")).provided(printDebug && tree.typeOpt.exists)
         keywordStr("$") ~ spliceTypeText ~ keywordStr("{") ~ toTextGlobal(expr) ~ keywordStr("}")
diff --git a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
index 32b54ffa7ff8..cb5f3520429a 100644
--- a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
+++ b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
@@ -101,10 +101,10 @@ class CrossStageSafety extends TreeMapWithStages {
     if (ctx.property(InAnnotation).isDefined)
       report.error("Cannot have a quote in an annotation", quote.srcPos)
     val transformedBody = transformQuoteBody(body, quote.span)
-    val stripAnnotsDeep: TypeMap = new TypeMap:
+    val stripAnnotationsDeep: TypeMap = new TypeMap:
       def apply(tp: Type): Type = mapOver(tp.stripAnnots)
-    val exprType1 = healType(quote.srcPos)(stripAnnotsDeep(quote.exprType))
-    cpy.Quote(quote)(transformedBody).withExprType(exprType1)
+    val bodyType1 = healType(quote.srcPos)(stripAnnotationsDeep(quote.bodyType))
+    cpy.Quote(quote)(transformedBody).withBodyType(bodyType1)
   }
 
   override protected def transformQuotedType(body: Tree, quote: Apply)(using Context): Tree = {
@@ -120,10 +120,11 @@ class CrossStageSafety extends TreeMapWithStages {
             // Optimization: `quoted.Type.of[@SplicedType type T = x.Underlying; T](quotes)`  -->  `x`
             ref(termRef).withSpan(quote.span)
           case transformedBody =>
-            val quotes = quote.args.mapConserve(transform)
+            val quotes = transform(quote.args.head)
             // `quoted.Type.of[<body>](quotes)`  --> `quoted.Type.of[<body2>](quotes)`
             val TypeApply(fun, _) = quote.fun: @unchecked
-            cpy.Apply(quote)(cpy.TypeApply(quote.fun)(fun, transformedBody :: Nil), quotes)
+            if level != 0 then cpy.Apply(quote)(cpy.TypeApply(quote.fun)(fun, transformedBody :: Nil), quotes :: Nil)
+            else tpd.Quote(transformedBody).select(nme.apply).appliedTo(quotes).withSpan(quote.span)
   }
 
   private def transformQuoteBody(body: Tree, span: Span)(using Context): Tree = {
diff --git a/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala b/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
index ddf2017af368..e262530ba11e 100644
--- a/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
+++ b/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
@@ -52,10 +52,6 @@ abstract class TreeMapWithStages extends TreeMapWithImplicits {
       }
 
       tree match {
-        case Apply(Select(QuotedTypeOf(SplicedType(t)), _), _) =>
-          // Optimization: `quoted.Type.of[x.Underlying]` --> `x`
-          transform(t)
-
         case tree @ QuotedTypeOf(quotedTree) =>
           val old = inQuoteOrSplice
           inQuoteOrSplice = true
diff --git a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
index a0ea03f238df..b1a707a70cb1 100644
--- a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
@@ -103,17 +103,11 @@ class PickleQuotes extends MacroTransform {
         case Apply(Select(quote: Quote, nme.apply), List(quotes)) =>
           val (contents, codeWithHoles) = makeHoles(quote.body)
           val sourceRef = Inlines.inlineCallTrace(ctx.owner, tree.sourcePos)
-          val codeWithHoles2 = Inlined(sourceRef, Nil, codeWithHoles)
-          val pickled = PickleQuotes(quotes, codeWithHoles2, contents, quote.exprType, false)
+          val bodyWithHoles2 =
+            if quote.body.isType then codeWithHoles
+            else Inlined(sourceRef, Nil, codeWithHoles)
+          val pickled = PickleQuotes.pickle(quotes, bodyWithHoles2, contents, quote.bodyType)
           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.rhs.isEmpty && tree.symbol.isInlineMethod =>
           // Shrink size of the tree. The methods have already been inlined.
           // TODO move to FirstTransform to trigger even without quotes
@@ -208,7 +202,7 @@ object PickleQuotes {
   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) = {
+  def pickle(quotes: Tree, body: Tree, contents: List[Tree], originalTp: Type)(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
@@ -340,14 +334,14 @@ object PickleQuotes {
                 case _ => Match(args(0).annotated(New(ref(defn.UncheckedAnnot.typeRef))), cases)
           )
 
-      val quoteClass = if isType then defn.QuotedTypeClass else defn.QuotedExprClass
+      val quoteClass = if body.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
+        if body.isType then defn.QuoteUnpickler_unpickleTypeV2
         else defn.QuoteUnpickler_unpickleExprV2
       val unpickleArgs =
-        if isType then List(pickledQuoteStrings, types)
+        if body.isType then List(pickledQuoteStrings, types)
         else List(pickledQuoteStrings, types, termHoles)
       quotes
         .asInstance(defn.QuoteUnpicklerClass.typeRef)
@@ -378,7 +372,7 @@ object PickleQuotes {
       case Inlined(_, Nil, e) => getLiteral(e)
       case _ => None
 
-    if (isType) then
+    if body.isType then
       if contents.isEmpty && body.symbol.isPrimitiveValueClass then taggedType()
       else pickleAsTasty()
     else
diff --git a/compiler/src/dotty/tools/dotc/transform/ReifiedReflect.scala b/compiler/src/dotty/tools/dotc/transform/ReifiedReflect.scala
index b2059195b8e4..bd0c063cd21a 100644
--- a/compiler/src/dotty/tools/dotc/transform/ReifiedReflect.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ReifiedReflect.scala
@@ -75,8 +75,8 @@ trait ReifiedReflect:
       .select(defn.Quotes_reflect_TypeRepr_of)
       .appliedToType(tpe)
       .appliedTo(
-        ref(defn.QuotedTypeModule_of)
-          .appliedToType(tpe)
+        tpd.Quote(TypeTree(tpe))
+          .select(nme.apply)
           .appliedTo(quotesTree)
       )
 
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicing.scala b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
index e8102a5db224..c833a0800e87 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicing.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
@@ -88,8 +88,6 @@ class Splicing extends MacroTransform:
       tree match
         case Apply(Select(_: Quote, nme.apply), _) =>
           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
@@ -228,25 +226,18 @@ class Splicing extends MacroTransform:
         case tree @ Assign(lhs: RefTree, rhs) =>
           if isCaptured(lhs.symbol) then transformSplicedAssign(tree)
           else super.transform(tree)
-        case Apply(sel @ Select(app @ Quote(body), nme.apply), quotesArgs) =>
-          body match
-            case body: RefTree if isCaptured(body.symbol) => capturedTerm(body)
-            case _ => withCurrentQuote(quotesArgs.head) { super.transform(tree) }
-        case Apply(TypeApply(typeof, List(tpt)), List(quotes))
-        if tree.symbol == defn.QuotedTypeModule_of && containsCapturedType(tpt.tpe) =>
-          val newContent = capturedPartTypes(tpt)
-          newContent match
-            case block: Block =>
-              inContext(ctx.withSource(tree.source)) {
-                Apply(TypeApply(typeof, List(newContent)), List(quotes)).withSpan(tree.span)
-              }
-            case _ =>
-              ref(capturedType(newContent))(using ctx.withSource(tree.source)).withSpan(tree.span)
         case CapturedApplication(fn, argss) =>
           transformCapturedApplication(tree, fn, argss)
-        case Quote(expr) if level == 0 =>
-          val newExpr = transformLevel0QuoteContent(expr)(using quoteContext)
-          cpy.Quote(tree)(newExpr)
+        case Apply(sel @ Select(app @ Quote(body), nme.apply), quotes :: Nil) if level == 0 && body.isTerm =>
+          body match
+            case _: RefTree if isCaptured(body.symbol) => capturedTerm(body)
+            case _ => withCurrentQuote(quotes) { super.transform(tree) }
+        case Quote(body) if level == 0 =>
+          val newBody =
+            if body.isTerm then transformLevel0QuoteContent(body)(using quoteContext)
+            else if containsCapturedType(body.tpe) then capturedPartTypes(body)
+            else body
+          cpy.Quote(tree)(newBody)
         case _ =>
           super.transform(tree)
 
@@ -400,7 +391,7 @@ class Splicing extends MacroTransform:
       Splice(closure, tpe)
 
     private def quoted(expr: Tree)(using Context): Tree =
-      Quote(expr, expr.tpe.widenTermRefExpr)
+      untpd.Quote(expr).withBodyType(expr.tpe.widenTermRefExpr) // TODO do we need widenTermRefExpr?
         .select(nme.apply)
         .appliedTo(quotes.nn)
 
diff --git a/compiler/src/dotty/tools/dotc/transform/Staging.scala b/compiler/src/dotty/tools/dotc/transform/Staging.scala
index a025f86a1db6..581fd2753504 100644
--- a/compiler/src/dotty/tools/dotc/transform/Staging.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Staging.scala
@@ -57,6 +57,13 @@ class Staging extends MacroTransform {
         case _ =>
       }
 
+      tree match {
+        case tree: RefTree =>
+          assert(level != 0 || tree.symbol != defn.QuotedTypeModule_of,
+            "scala.quoted.Type.of at level 0 should have been replaced with Quote AST in staging phase")
+        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
diff --git a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
index ebff31414d68..5372dc4d04b6 100644
--- a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
+++ b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
@@ -61,7 +61,7 @@ trait QuotesAndSplices {
       // TODO typecheck directly (without `exprQuote`)
       val exprQuoteTree = untpd.Apply(untpd.ref(defn.QuotedRuntime_exprQuote.termRef), tree.body)
       val quotedExpr = typedApply(exprQuoteTree, pt)(using quoteContext) match
-        case Apply(TypeApply(fn, tpt :: Nil), quotedExpr :: Nil) => Quote(quotedExpr, tpt.tpe)
+        case Apply(TypeApply(fn, tpt :: Nil), quotedExpr :: Nil) => untpd.Quote(quotedExpr).withBodyType(tpt.tpe)
       makeInlineable(quotedExpr.select(nme.apply).appliedTo(quotes).withSpan(tree.span))
   }
 
@@ -382,7 +382,7 @@ trait QuotesAndSplices {
    *        ) => ...
    *  ```
    */
-  private def typedQuotePattern(tree: untpd.Quote, pt: Type, qctx: Tree)(using Context): Tree = {
+  private def typedQuotePattern(tree: untpd.Quote, pt: Type, quotes: Tree)(using Context): Tree = {
     val quoted = tree.body
     if quoted.isTerm && !pt.derivesFrom(defn.QuotedExprClass) then
       report.error("Quote pattern can only match scrutinees of type scala.quoted.Expr", tree.srcPos)
@@ -442,11 +442,11 @@ trait QuotesAndSplices {
 
     val quoteClass = if (quoted.isTerm) defn.QuotedExprClass else defn.QuotedTypeClass
     val quotedPattern =
-      if (quoted.isTerm) tpd.Quote(shape, defn.AnyType).select(nme.apply).appliedTo(qctx)
-      else ref(defn.QuotedTypeModule_of.termRef).appliedToTypeTree(shape).appliedTo(qctx)
+      if (quoted.isTerm) tpd.Quote(shape).select(nme.apply).appliedTo(quotes)
+      else ref(defn.QuotedTypeModule_of.termRef).appliedToTypeTree(shape).appliedTo(quotes)
 
     val matchModule = if quoted.isTerm then defn.QuoteMatching_ExprMatch else defn.QuoteMatching_TypeMatch
-    val unapplyFun = qctx.asInstance(defn.QuoteMatchingClass.typeRef).select(matchModule).select(nme.unapply)
+    val unapplyFun = quotes.asInstance(defn.QuoteMatchingClass.typeRef).select(matchModule).select(nme.unapply)
 
     UnApply(
       fun = unapplyFun.appliedToTypeTrees(typeBindingsTuple :: TypeTree(patType) :: Nil),
diff --git a/compiler/src/dotty/tools/dotc/typer/ReTyper.scala b/compiler/src/dotty/tools/dotc/typer/ReTyper.scala
index d8e9b115ea49..f8cfd4ca3ae0 100644
--- a/compiler/src/dotty/tools/dotc/typer/ReTyper.scala
+++ b/compiler/src/dotty/tools/dotc/typer/ReTyper.scala
@@ -97,7 +97,7 @@ class ReTyper(nestingLevel: Int = 0) extends Typer(nestingLevel) with ReChecking
 
   override def typedQuote(tree: untpd.Quote, pt: Type)(using Context): Tree =
     assertTyped(tree)
-    val body1 = typed(tree.body, tree.exprType)(using quoteContext)
+    val body1 = typed(tree.body, tree.bodyType)(using quoteContext)
     untpd.cpy.Quote(tree)(body1).withType(tree.typeOpt)
 
   override def typedSplice(tree: untpd.Splice, pt: Type)(using Context): Tree =
diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
index 1df2abcf0453..245bcdac70af 100644
--- a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
+++ b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
@@ -637,7 +637,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
           case self: tpd.Quote => // TODO expose Quote AST in Quotes
             import dotty.tools.dotc.ast.tpd.TreeOps
             tpd.ref(dotc.core.Symbols.defn.QuotedRuntime_exprQuote)
-              .appliedToType(self.exprType)
+              .appliedToType(self.bodyType)
               .withSpan(self.span)
           case self: tpd.Splice => // TODO expose Splice AST in Quotes
             import dotty.tools.dotc.ast.tpd.TreeOps

From 3a4e1ccca3a49268ac5a348becd5d9657586469b Mon Sep 17 00:00:00 2001
From: Julien Richard-Foy <julien@richard-foy.fr>
Date: Fri, 28 Apr 2023 15:17:02 +0200
Subject: [PATCH 453/657] =?UTF-8?q?Move=20=E2=80=9CWildcard=20Types?=
 =?UTF-8?q?=E2=80=9D=20to=20a=20subsection=20of=20=E2=80=9CParameterized?=
 =?UTF-8?q?=20Types=E2=80=9D.?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Specify them independently of `forSome`.
---
 docs/_spec/03-types.md       | 105 +++++++++++++++++++++--------------
 docs/_spec/06-expressions.md |  26 ++++-----
 2 files changed, 73 insertions(+), 58 deletions(-)

diff --git a/docs/_spec/03-types.md b/docs/_spec/03-types.md
index 5e1da82f1f11..a1ad1ddffa57 100644
--- a/docs/_spec/03-types.md
+++ b/docs/_spec/03-types.md
@@ -8,13 +8,9 @@ chapter: 3
 
 ```ebnf
   Type              ::=  FunctionArgTypes ‘=>’ Type
-                      |  InfixType [ExistentialClause]
+                      |  InfixType
   FunctionArgTypes  ::=  InfixType
                       |  ‘(’ [ ParamType {‘,’ ParamType } ] ‘)’
-  ExistentialClause ::=  ‘forSome’ ‘{’ ExistentialDcl
-                             {semi ExistentialDcl} ‘}’
-  ExistentialDcl    ::=  ‘type’ TypeDcl
-                      |  ‘val’ ValDcl
   InfixType         ::=  CompoundType {id [nl] CompoundType}
   CompoundType      ::=  AnnotType {‘with’ AnnotType} [Refinement]
                       |  Refinement
@@ -163,13 +159,14 @@ SimpleType      ::=  SimpleType TypeArgs
 TypeArgs        ::=  ‘[’ Types ‘]’
 ```
 
-A _parameterized type_ ´T[ T_1, ..., T_n ]´ consists of a type designator ´T´ and type parameters ´T_1, ..., T_n´ where ´n \geq 1´.
+A _parameterized type_ ´T[ T_1, ..., T_n ]´ consists of a type designator ´T´ and type arguments ´T_1, ..., T_n´ where ´n \geq 1´.
 ´T´ must refer to a type constructor which takes ´n´ type parameters ´a_1, ..., a_n´.
 
+<!-- TODO Mention well-kinded conformance when we introduce kind-polymorphism -->
 Say the type parameters have lower bounds ´L_1, ..., L_n´ and upper bounds ´U_1, ..., U_n´.
-The parameterized type is well-formed if each actual type parameter _conforms to its bounds_, i.e. ´\sigma L_i <: T_i <: \sigma U_i´ where ´\sigma´ is the substitution ´[ a_1 := T_1, ..., a_n := T_n ]´.
+The parameterized type is well-formed if each type argument _conforms to its bounds_, i.e. ´\sigma L_i <: T_i <: \sigma U_i´ where ´\sigma´ is the substitution ´[ a_1 := T_1, ..., a_n := T_n ]´.
 
-###### Example Parameterized Types
+#### Example Parameterized Types
 
 Given the partial type definitions:
 
@@ -178,9 +175,9 @@ class TreeMap[A <: Comparable[A], B] { ... }
 class List[A] { ... }
 class I extends Comparable[I] { ... }
 
-class F[M[_], X] { ... }
+class F[M[A], X] { ... }
 class S[K <: String] { ... }
-class G[M[ Z <: I ], I] { ... }
+class G[M[Z <: I], I] { ... }
 ```
 
 the following parameterized types are well-formed:
@@ -194,9 +191,7 @@ F[List, Int]
 G[S, String]
 ```
 
-###### Example
-
-Given the [above type definitions](#example-parameterized-types), the following types are ill-formed:
+and the following types are ill-formed:
 
 ```scala
 TreeMap[I]            // illegal: wrong number of parameters
@@ -211,6 +206,50 @@ G[S, Int]             // illegal: S constrains its parameter to
                       //   that conforms to Int
 ```
 
+#### Wildcard Type Argument
+
+<!-- TODO Update the syntax to use '?' -->
+```ebnf
+WildcardType   ::=  ‘_’ TypeBounds
+```
+
+A _wildcard type argument_ is of the form `_´\;´>:´\,L\,´<:´\,U´`.
+A wildcard type must appear as a type argument of a parameterized type.
+The parameterized type to which the wildcard type is applied cannot be an abstract type constructor.
+
+Both bound clauses may be omitted.
+If both bounds are omitted, the real bounds are inferred from the bounds of the corresponding type parameter in the target type constructor.
+Otherwise, if a lower bound clause `>:´\,L´` is missing, `>:´\,´scala.Nothing` is assumed.
+Otherwise, if an upper bound clause `<:´\,U´` is missing, `<:´\,´scala.Any` is assumed.
+
+Given the [above type definitions](#example-parameterized-types), the following types are well-formed:
+
+```scala
+List[_] // inferred as List[_ >: Nothing <: Any]
+List[_ <: java.lang.Number]
+S[_ <: String]
+F[_, Boolean]
+```
+
+and the following code contains an ill-formed type:
+
+```scala
+trait H[F[A]]:
+  def f: F[_] // illegal : an abstract type constructor
+              // cannot be applied to wildcard arguments.
+```
+
+Wildcard types may also appear as parts of [infix types](#infix-types), [function types](#function-types), or [tuple types](#tuple-types).
+Their expansion is then the expansion in the equivalent parameterized type.
+
+##### Simplification Rules
+
+Let ´T[T_1, ..., T_n]´ be a parameterized type.
+Then, applying a wildcard type argument ´t´ of the form ´\\_ >: L <: U´ at the ´i´'th position obeys the following equivalences:
+
+- If the type parameter ´T_i´ is declared covariant, then ´t \equiv U´
+- If the type parameter ´T_i´ is declared contravariant, then ´t \equiv L´
+
 ### Tuple Types
 
 ```ebnf
@@ -355,30 +394,6 @@ trait Function´_n´[-´T_1´, ..., -´T_n´, +´R´]:
 
 Their exact supertype and implementation can be consulted in the [function classes section](./12-the-scala-standard-library.md#the-function-classes) of the standard library page in this document.
 
-#### Wildcard Types
-
-```ebnf
-WildcardType   ::=  ‘_’ TypeBounds
-```
-<!-- TODO: Update this to use new mechanism -->
-A _wildcard type_ is of the form `_´\;´>:´\,L\,´<:´\,U´`.
-Both bound clauses may be omitted.
-If a lower bound clause `>:´\,L´` is missing, `>:´\,´scala.Nothing` is assumed.
-If an upper bound clause `<:´\,U´` is missing, `<:´\,´scala.Any` is assumed.
-A wildcard type is a shorthand for an existentially quantified type variable, where the existential quantification is implicit.
-
-A wildcard type must appear as a type argument of a parameterized type.
-Let ´T = p.c[\mathit{targs},T,\mathit{targs}']´ be a parameterized type where ´\mathit{targs}, \mathit{targs}'´ may be empty and ´T´ is a wildcard type `_´\ ´>:´\,L\,´<:´\,U´`.
-Then ´T´ is equivalent to the existential type
-
-```scala
-´p.c[\mathit{targs},t,\mathit{targs}']´ forSome { type ´t´ >: ´L´ <: ´U´ }
-```
-
-where ´t´ is some fresh type variable.
-Wildcard types may also appear as parts of [infix types](#infix-types), [function types](#function-types), or [tuple types](#tuple-types).
-Their expansion is then the expansion in the equivalent parameterized type.
-
 ## Non-Value Types
 
 The types explained in the following do not denote sets of values, nor do they appear explicitly in programs. 
@@ -563,7 +578,6 @@ Equivalence ´(\equiv)´ between types is the smallest congruence [^congruence]
   - corresponding parameters have equivalent types.
     Note that the names of parameters do not matter for method type equivalence.
 - Two [polymorphic method types](#polymorphic-method-types) are equivalent if they have the same number of type parameters, and, after renaming one set of type parameters by another, the result types as well as lower and upper bounds of corresponding type parameters are equivalent.
-- Two [existential types](#existential-types) are equivalent if they have the same number of quantifiers, and, after renaming one list of type quantifiers by another, the quantified types as well as lower and upper bounds of corresponding quantifiers are equivalent.
 - Two [type constructors](#type-constructors) are equivalent if they have the same number of type parameters, and, after renaming one list of type parameters by another, the result types as well as variances, lower and upper bounds of corresponding type parameters are equivalent.
 
 [^congruence]: A congruence is an equivalence relation which is closed under formation of contexts.
@@ -573,7 +587,7 @@ Equivalence ´(\equiv)´ between types is the smallest congruence [^congruence]
 
 The conformance relation ´(<:)´ is the smallest transitive relation that satisfies the following conditions.
 
-- Conformance includes equivalence. If `T \equiv U` then `T <: U`.
+- Conformance includes equivalence. If ´T \equiv U´ then ´T <: U´.
 - For every value type `T`, `scala.Nothing <: ´T´ <: scala.Any`.
 - For every type constructor ´T´ (with any number of type parameters), `scala.Nothing <: ´T´ <: scala.Any`.
 - For every value type ´T´, `scala.Null <: ´T´` unless `´T´ <: scala.AnyVal`.
@@ -582,10 +596,13 @@ The conformance relation ´(<:)´ is the smallest transitive relation that satis
 - A singleton type `´p´.type` conforms to the type of the path ´p´.
 - A singleton type `´p´.type` conforms to the type `scala.Singleton`.
 - A type projection `´T´#´t´` conforms to `´U´#´t´` if ´T´ conforms to ´U´.
-- A parameterized type `´T´[´T_1´, ..., ´T_n´]` conforms to `´T´[´U_1´, ..., ´U_n´]` if the following three conditions hold for ´i \in \{ 1, ..., n \}´:
-  1. If the ´i´'th type parameter of ´T´ is declared covariant, then ´T_i <: U_i´.
-  1. If the ´i´'th type parameter of ´T´ is declared contravariant, then ´U_i <: T_i´.
-  1. If the ´i´'th type parameter of ´T´ is declared neither covariant nor contravariant, then ´U_i \equiv T_i´.
+- A parameterized type `´T´[´T_1´, ..., ´T_n´]` conforms to `´T´[´U_1´, ..., ´U_n´]` if the following conditions hold for ´i \in \{ 1, ..., n \}´:
+  1. If the ´i´'th type parameter of ´T´ is declared covariant, then ´T_i <: U_i´. [^argisnotwildcard]
+  1. If the ´i´'th type parameter of ´T´ is declared contravariant, then ´U_i <: T_i´. [^argisnotwildcard]
+  1. If the ´i´'th type parameter of ´T´ is declared neither covariant nor contravariant:
+     1. If neither ´T_i´ nor ´U_i´ are wildcard type arguments, then ´U_i \equiv T_i´.
+     1. If ´T_i´ is a wildcard type argument of the form ´\\_ >: L_1 <: U_1´ and ´U_i´ is a wildcard argument of the form ´\\_ >: L_2 <: U_2´, then ´L_2 <: L_1´ and ´H_1 <: H_2´ (i.e., the ´T_i´ "interval" is contained in the ´U_i´ "interval").
+     1. If ´U_i´ is a wildcard type argument of the form ´\\_ >: L_2 <: U_2´, then ´L_2 <: T_i´ and ´T_i <: U_2´.
 - A compound type `´T_1´ with ... with ´T_n´ {´R\,´}` conforms to each of its component types ´T_i´.
 - If ´T <: U_i´ for ´i \in \{ 1, ..., n \}´ and for every binding ´d´ of a type or value ´x´ in ´R´ there exists a member binding of ´x´ in ´T´ which subsumes ´d´, then ´T´ conforms to the compound type `´U_1´ with ... with ´U_n´ {´R\,´}`.
 - If ´T_i \equiv T_i'´ for ´i \in \{ 1, ..., n\}´ and ´U´ conforms to ´U'´ then the method type ´(p_1:T_1, ..., p_n:T_n) U´ conforms to ´(p_1':T_1', ..., p_n':T_n') U'´.
@@ -598,6 +615,8 @@ Note that this entails that:
   - The variance of ´a_i´ must match the variance of ´a'_i´, where covariance matches covariance, contravariance matches contravariance and any variance matches invariance.
   - Recursively, these restrictions apply to the corresponding higher-order type parameter clauses of ´a_i´ and ´a'_i´.
 
+ [^argisnotwildcard]: In these cases, if `T_i` and/or `U_i` are wildcard type arguments, the [simplification rules](#simplification-rules) for parameterized types allow to reduce them to real types.
+
 A declaration or definition in some compound type of class type ´C´ _subsumes_ another declaration of the same name in some compound type or class type ´C'´, if one of the following holds.
 
 - A value declaration or definition that defines a name ´x´ with type ´T´ subsumes a value or method declaration that defines ´x´ with type ´T'´, provided ´T <: T'´.
diff --git a/docs/_spec/06-expressions.md b/docs/_spec/06-expressions.md
index bb90c2b071a4..5adb58ec626c 100644
--- a/docs/_spec/06-expressions.md
+++ b/docs/_spec/06-expressions.md
@@ -460,16 +460,13 @@ The expected type of the final expression ´e´ is the expected type of the bloc
 The expected type of all preceding statements is undefined.
 
 <!-- TODO: Rewrite when type avoidance section is done -->
-The type of a block `´s_1´; ...; ´s_n´; ´e´` is `´T´ forSome {´\,Q\,´}`, where ´T´ is the type of ´e´ and ´Q´ contains [existential clauses](03-types.html#existential-types) for every value or type name which is free in ´T´ and which is defined locally in one of the statements ´s_1, ..., s_n´.
-We say the existential clause _binds_ the occurrence of the value or type name.
-Specifically,
+The type of a block `´s_1´; ...; ´s_n´; ´e´` is some type ´T´ such that:
 
-- A locally defined type definition  `type´\;t = T´` is bound by the existential clause `type´\;t >: T <: T´`.
-It is an error if ´t´ carries type parameters.
-- A locally defined value definition `val´\;x: T = e´` is bound by the existential clause `val´\;x: T´`.
-- A locally defined class definition `class´\;c´ extends´\;t´` is bound by the existential clause `type´\;c <: T´` where ´T´ is the least class type or refinement type which is a proper supertype of the type ´c´.
-It is an error if ´c´ carries type parameters.
-- A locally defined object definition `object´\;x\;´extends´\;t´` is bound by the existential clause `val´\;x: T´` where ´T´ is the least class type or refinement type which is a proper supertype of the type `´x´.type`.
+- ´U <: T´ where ´U´ is the type of ´e´.
+- No value or type name is free in ´T´, i.e., ´T´ does not refer to any value or type locally defined in one of the statements ´s_1, ..., s_n´.
+- ´T´ is "as small as possible" (this is a soft requirement).
+
+The precise way in which we compute ´T´, called _type avoidance_, is currently not defined in this specification.
 
 Evaluation of the block entails evaluation of its statement sequence, followed by an evaluation of the final expression ´e´, which defines the result of the block.
 
@@ -1181,12 +1178,11 @@ question: given
 -->
 
 - A parameterized method ´m´ of type `(´p_1:T_1, ..., p_n:T_n´)´U´` is _as specific as_ some other member ´m'´ of type ´S´ if ´m'´ is [applicable](#method-applications) to arguments `(´p_1, ..., p_n´)` of types ´T_1, ..., T_n´.
-- A polymorphic method of type `[´a_1´ >: ´L_1´ <: ´U_1, ..., a_n´ >: ´L_n´ <: ´U_n´]´T´` is as specific as some other member of type ´S´ if ´T´ is as specific as ´S´ under the assumption that for ´i = 1, ..., n´ each ´a_i´ is an abstract type name bounded from below by ´L_i´ and from above by ´U_i´.
-- A member of any other type is always as specific as a parameterized method or a polymorphic method.
-<!-- TODO: check the following, as it reduces to "the member of type ´T´ is as specific as the member of type ´U´ if the ´T´ conforms to ´U´." -->
-- Given two members of types ´T´ and ´U´ which are neither parameterized nor polymorphic method types, the member of type ´T´ is as specific as the member of type ´U´ if the existential dual of ´T´ conforms to the existential dual of ´U´.
-Here, the existential dual of a polymorphic type `[´a_1´ >: ´L_1´ <: ´U_1, ..., a_n´ >: ´L_n´ <: ´U_n´]´T´` is `´T´ forSome { type ´a_1´ >: ´L_1´ <: ´U_1´, ..., type ´a_n´ >: ´L_n´ <: ´U_n´}`.
-The existential dual of every other type is the type itself.
+  If the last parameter `´p_n´` has a vararg type `´T*´`, then `m` must be applicable to arbitrary numbers of `´T´` parameters (which implies that it must be a varargs method as well).
+- A polymorphic method of type `[´a_1´ >: ´L_1´ <: ´U_1, ..., a_n´ >: ´L_n´ <: ´U_n´]´T´` is as specific as some other member ´m'´ of type ´S´ if ´T´ is as specific as ´S´ under the assumption that for ´i = 1, ..., n´ each ´a_i´ is an abstract type name bounded from below by ´L_i´ and from above by ´U_i´.
+- A member of any other type ´T´ is:
+  - always as specific as a parameterized method or a polymorphic method.
+  - as specific as a member ´m'´ of any other type ´S´ if ´T´ is [compatible](03-types.html#compatibility) with ´S´.
 
 The _relative weight_ of an alternative ´A´ over an alternative ´B´ is a
 number from 0 to 2, defined as the sum of

From 095a7f1e53b8339c21b238e77245f0027e0c5719 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 1 May 2023 11:00:07 +0200
Subject: [PATCH 454/657] Remove state from TreeMapWithStages

---
 .../tools/dotc/staging/CrossStageSafety.scala |  2 +-
 .../tools/dotc/staging/StagingLevel.scala     |  4 +++
 .../dotc/staging/TreeMapWithStages.scala      | 27 +++----------------
 3 files changed, 9 insertions(+), 24 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
index cb5f3520429a..fbf9eac7af03 100644
--- a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
+++ b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
@@ -50,7 +50,7 @@ class CrossStageSafety extends TreeMapWithStages {
   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
+    else if !inQuoteOrSpliceScope then
       checkAnnotations(tree)
       super.transform(tree)
     else tree match {
diff --git a/compiler/src/dotty/tools/dotc/staging/StagingLevel.scala b/compiler/src/dotty/tools/dotc/staging/StagingLevel.scala
index 4704501e38ff..05b3efab408c 100644
--- a/compiler/src/dotty/tools/dotc/staging/StagingLevel.scala
+++ b/compiler/src/dotty/tools/dotc/staging/StagingLevel.scala
@@ -31,6 +31,10 @@ object StagingLevel {
   def spliceContext(using Context): FreshContext =
     ctx.fresh.setProperty(LevelKey, level - 1)
 
+  /** If we are inside a quote or a splice */
+  def inQuoteOrSpliceScope(using Context): Boolean =
+    ctx.property(LevelKey).isDefined
+
   /** The quotation level of the definition of the locally defined symbol */
   def levelOf(sym: Symbol)(using Context): Int =
     ctx.property(LevelOfKey) match
diff --git a/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala b/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
index e262530ba11e..6c193ee7a34b 100644
--- a/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
+++ b/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
@@ -15,12 +15,6 @@ import scala.collection.mutable
 abstract class TreeMapWithStages extends TreeMapWithImplicits {
   import tpd._
 
-  /** If we are inside a quote or a splice */
-  private[this] var inQuoteOrSplice = false
-
-  /** If we are inside a quote or a splice */
-  protected def isInQuoteOrSplice: Boolean = inQuoteOrSplice
-
   /** Transform the quote `quote` which contains the quoted `body`.
    *
    *  - `quoted.runtime.Expr.quote[T](<body0>)`  --> `quoted.runtime.Expr.quote[T](<body>)`
@@ -53,15 +47,9 @@ abstract class TreeMapWithStages extends TreeMapWithImplicits {
 
       tree match {
         case tree @ QuotedTypeOf(quotedTree) =>
-          val old = inQuoteOrSplice
-          inQuoteOrSplice = true
-          try transformQuotedType(quotedTree, tree)
-          finally inQuoteOrSplice = old
-
+          transformQuotedType(quotedTree, tree)
         case tree @ Quote(quotedTree) =>
-          val old = inQuoteOrSplice
-          inQuoteOrSplice = true
-          try dropEmptyBlocks(quotedTree) match {
+          dropEmptyBlocks(quotedTree) match {
             case Splice(t) =>
               // Optimization: `'{ $x }` --> `x`
               // and adapt the refinement of `Quotes { type reflect: ... } ?=> Expr[T]`
@@ -69,25 +57,18 @@ abstract class TreeMapWithStages extends TreeMapWithImplicits {
             case _ =>
               transformQuote(quotedTree, tree)
           }
-          finally inQuoteOrSplice = old
 
         case tree @ Splice(splicedTree) =>
-          val old = inQuoteOrSplice
-          inQuoteOrSplice = true
-          try dropEmptyBlocks(splicedTree) match {
+          dropEmptyBlocks(splicedTree) match {
             case Quote(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
+          transformSpliceType(splicedTree, tree)
 
         case Block(stats, _) =>
           val defSyms = stats.collect { case defTree: DefTree => defTree.symbol }

From 10cbc605f9ead7a144b70af607c72e46fa105e54 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 1 May 2023 11:13:43 +0200
Subject: [PATCH 455/657] Fix wrong staging level error message

The tests were failing when the code was correct. The wrong message was
```
access to parameter t from wrong staging level:
  - the definition is at level 0,
  - but the access is at level -1.
```
The access to `t.Underlying` or `t.x.Underlying` are fine when we have
an implicit `Type.of[t.Underlying]` or `Type.of[t.x.Underlying]`. These
will probably be of the type of the aliased type of `A`, wherefore
summoning `Type.of[A]`.
---
 .../src/dotty/tools/dotc/staging/CrossStageSafety.scala   | 4 +++-
 .../src/dotty/tools/dotc/staging/TreeMapWithStages.scala  | 6 ------
 tests/neg-macros/i10127-a.scala                           | 2 +-
 tests/neg-macros/i10127-b.scala                           | 2 +-
 tests/pos-macros/i10127-a.scala                           | 8 ++++++++
 5 files changed, 13 insertions(+), 9 deletions(-)
 create mode 100644 tests/pos-macros/i10127-a.scala

diff --git a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
index fbf9eac7af03..02404337db80 100644
--- a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
+++ b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
@@ -92,6 +92,8 @@ class CrossStageSafety extends TreeMapWithStages {
       case tree: TypeDef if tree.symbol.is(Case) && level > 0 =>
         report.error(reporting.CaseClassInInlinedCode(tree), tree)
         super.transform(tree)
+      case tree @ SplicedType(splicedTree) =>
+        transformSpliceType(splicedTree, tree)
       case _ =>
         super.transform(tree)
     }
@@ -151,7 +153,7 @@ class CrossStageSafety extends TreeMapWithStages {
     untpd.cpy.Splice(splice)(body1).withType(tpe1)
   }
 
-  protected def transformSpliceType(body: Tree, splice: Select)(using Context): Tree = {
+  private def transformSpliceType(body: Tree, splice: Select)(using Context): Tree = {
     val body1 = transform(body)(using spliceContext)
     if ctx.reporter.hasErrors then
       splice
diff --git a/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala b/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
index 6c193ee7a34b..31a764fe7040 100644
--- a/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
+++ b/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
@@ -33,9 +33,6 @@ abstract class TreeMapWithStages extends TreeMapWithImplicits {
   /** Transform the expression splice `splice` which contains the spliced `body`. */
   protected def transformSplice(body: Tree, splice: Splice)(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))
@@ -67,9 +64,6 @@ abstract class TreeMapWithStages extends TreeMapWithImplicits {
               transformSplice(splicedTree, tree)
           }
 
-        case tree @ SplicedType(splicedTree) =>
-          transformSpliceType(splicedTree, tree)
-
         case Block(stats, _) =>
           val defSyms = stats.collect { case defTree: DefTree => defTree.symbol }
           super.transform(tree)(using symbolsInCurrentLevel(defSyms))
diff --git a/tests/neg-macros/i10127-a.scala b/tests/neg-macros/i10127-a.scala
index 3e23cf10bd30..2da4d0924870 100644
--- a/tests/neg-macros/i10127-a.scala
+++ b/tests/neg-macros/i10127-a.scala
@@ -1,7 +1,7 @@
 import scala.quoted.*
 
 object T {
-  def impl[A](using t: Type[A])(using Quotes): Expr[Unit] = {
+  def impl[A](t: Type[A])(using Quotes): Expr[Unit] = {
     Expr.summon[t.Underlying] // error
     '{}
   }
diff --git a/tests/neg-macros/i10127-b.scala b/tests/neg-macros/i10127-b.scala
index 2e87e92efa63..13992bf95362 100644
--- a/tests/neg-macros/i10127-b.scala
+++ b/tests/neg-macros/i10127-b.scala
@@ -4,7 +4,7 @@ case class T(x: Type[_ <: Any])
 
 object T {
   def impl[A](t: T)(using ctx: Quotes): Expr[Unit] = {
-    Expr.summon[t.x.Underlying] // error // error
+    Expr.summon[t.x.Underlying] // error
     '{}
   }
 }
\ No newline at end of file
diff --git a/tests/pos-macros/i10127-a.scala b/tests/pos-macros/i10127-a.scala
new file mode 100644
index 000000000000..3b9efc2a829d
--- /dev/null
+++ b/tests/pos-macros/i10127-a.scala
@@ -0,0 +1,8 @@
+import scala.quoted.*
+
+object T {
+  def impl[A](using t: Type[A])(using Quotes): Expr[Unit] = {
+    Expr.summon[t.Underlying]
+    '{}
+  }
+}
\ No newline at end of file

From 3097f490dc3e56a7ff6146753f93285216477bc0 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 1 May 2023 11:28:55 +0200
Subject: [PATCH 456/657] Simplify quoted type transformation in
 CrossStageSafety

---
 .../dotty/tools/dotc/staging/CrossStageSafety.scala    |  9 +++++++--
 .../dotty/tools/dotc/staging/TreeMapWithStages.scala   | 10 ----------
 2 files changed, 7 insertions(+), 12 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
index 02404337db80..d4ccf3321222 100644
--- a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
+++ b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
@@ -52,7 +52,10 @@ class CrossStageSafety extends TreeMapWithStages {
       transform(tree)(using ctx.withSource(tree.source))
     else if !inQuoteOrSpliceScope then
       checkAnnotations(tree)
-      super.transform(tree)
+      tree match
+        case tree @ QuotedTypeOf(quotedTree) =>
+          transformQuotedType(quotedTree, tree)
+        case _ => super.transform(tree)
     else tree match {
       case _: TypeTree =>
         val tp1 = transformTypeAnnotationSplices(tree.tpe)
@@ -92,6 +95,8 @@ class CrossStageSafety extends TreeMapWithStages {
       case tree: TypeDef if tree.symbol.is(Case) && level > 0 =>
         report.error(reporting.CaseClassInInlinedCode(tree), tree)
         super.transform(tree)
+      case tree @ QuotedTypeOf(quotedTree) =>
+        transformQuotedType(quotedTree, tree)
       case tree @ SplicedType(splicedTree) =>
         transformSpliceType(splicedTree, tree)
       case _ =>
@@ -109,7 +114,7 @@ class CrossStageSafety extends TreeMapWithStages {
     cpy.Quote(quote)(transformedBody).withBodyType(bodyType1)
   }
 
-  override protected def transformQuotedType(body: Tree, quote: Apply)(using Context): Tree = {
+  private def transformQuotedType(body: Tree, quote: Apply)(using Context): Tree = {
     if (ctx.property(InAnnotation).isDefined)
       report.error("Cannot have a quote in an annotation", quote.srcPos)
     body.tpe match
diff --git a/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala b/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
index 31a764fe7040..67fb17551253 100644
--- a/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
+++ b/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
@@ -22,14 +22,6 @@ abstract class TreeMapWithStages extends TreeMapWithImplicits {
   protected def transformQuote(body: Tree, quote: Quote)(using Context): Tree =
     cpy.Quote(quote)(body)
 
-  /** Transform the quote `quote` which contains the quoted `body`.
-   *
-   *  - `quoted.Type.of[<body0>](quotes)`  --> `quoted.Type.of[<body>](quotes)`
-   */
-  protected def transformQuotedType(body: Tree, quote: Apply)(using Context): Tree =
-    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: Splice)(using Context): Tree
 
@@ -43,8 +35,6 @@ abstract class TreeMapWithStages extends TreeMapWithImplicits {
       }
 
       tree match {
-        case tree @ QuotedTypeOf(quotedTree) =>
-          transformQuotedType(quotedTree, tree)
         case tree @ Quote(quotedTree) =>
           dropEmptyBlocks(quotedTree) match {
             case Splice(t) =>

From 8a9871fe5c0599ae42bb8378157b265e4269d247 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 1 May 2023 11:45:39 +0200
Subject: [PATCH 457/657] Simplify Quote/Splice transformations in
 CrossStageSafety

---
 compiler/src/dotty/tools/dotc/ast/Trees.scala | 21 +++++++++++
 .../tools/dotc/staging/CrossStageSafety.scala | 20 +++++++++-
 .../dotc/staging/TreeMapWithStages.scala      | 37 +------------------
 3 files changed, 40 insertions(+), 38 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala
index 19c189047c6d..fbc68ebe63d7 100644
--- a/compiler/src/dotty/tools/dotc/ast/Trees.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala
@@ -714,6 +714,17 @@ object Trees {
         defn.FunctionType(1, isContextual = true)
           .appliedTo(defn.QuotesClass.typeRef, exprType)
       withType(quoteType)
+
+    /** Cancel this Quote if it contains a Splice */
+    def cancelled(using Context): Option[Tree[T]] =
+      def rec(tree: Tree[T]): Option[Tree[T]] = tree match
+        case Block(Nil, expr) => rec(expr)
+        case Splice(inner) =>
+          // Optimization: `'{ $x }` --> `x`
+          // and adapt the refinement of `Quotes { type reflect: ... } ?=> Expr[T]`
+          Some(inner)
+        case _ => None
+      rec(body)
   }
 
   /** A tree representing a splice `${ expr }`
@@ -730,6 +741,16 @@ object Trees {
   case class Splice[+T <: Untyped] private[ast] (expr: Tree[T])(implicit @constructorOnly src: SourceFile)
     extends TermTree[T] {
     type ThisTree[+T <: Untyped] = Splice[T]
+
+    /** Cancel this Splice if it contains a Quote */
+    def cancelled(using Context): Option[Tree[T]] =
+      def rec(tree: Tree[T]): Option[Tree[T]] = tree match
+        case Block(Nil, expr1) => rec(expr1)
+        case Quote(body) =>
+          // Optimization: `${ 'x }` --> `x`
+          Some(body)
+        case _ => None
+      rec(expr)
   }
 
   /** A type tree that represents an existing or inferred type */
diff --git a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
index d4ccf3321222..37654bc0673b 100644
--- a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
+++ b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
@@ -53,6 +53,14 @@ class CrossStageSafety extends TreeMapWithStages {
     else if !inQuoteOrSpliceScope then
       checkAnnotations(tree)
       tree match
+        case tree @ Quote(quotedTree) =>
+          tree.cancelled match
+            case Some(tree1) => transform(tree1.asInstance(tree.tpe)) // TODO is this asInstance still needed?
+            case None => transformQuote(quotedTree, tree)
+        case tree @ Splice(splicedTree) =>
+          tree.cancelled match
+            case Some(tree1) => transform(tree1)
+            case None => transformSplice(splicedTree, tree)
         case tree @ QuotedTypeOf(quotedTree) =>
           transformQuotedType(quotedTree, tree)
         case _ => super.transform(tree)
@@ -95,6 +103,14 @@ class CrossStageSafety extends TreeMapWithStages {
       case tree: TypeDef if tree.symbol.is(Case) && level > 0 =>
         report.error(reporting.CaseClassInInlinedCode(tree), tree)
         super.transform(tree)
+      case tree @ Quote(quotedTree) =>
+        tree.cancelled match
+          case Some(tree1) => transform(tree1.asInstance(tree.tpe)) // TODO is this asInstance still needed?
+          case None => transformQuote(quotedTree, tree)
+      case tree @ Splice(splicedTree) =>
+        tree.cancelled match
+          case Some(tree1) => transform(tree1)
+          case None => transformSplice(splicedTree, tree)
       case tree @ QuotedTypeOf(quotedTree) =>
         transformQuotedType(quotedTree, tree)
       case tree @ SplicedType(splicedTree) =>
@@ -104,7 +120,7 @@ class CrossStageSafety extends TreeMapWithStages {
     }
 
   /** Transform quoted trees while maintaining level correctness */
-  override protected def transformQuote(body: Tree, quote: Quote)(using Context): Tree = {
+  private def transformQuote(body: Tree, quote: Quote)(using Context): Tree = {
     if (ctx.property(InAnnotation).isDefined)
       report.error("Cannot have a quote in an annotation", quote.srcPos)
     val transformedBody = transformQuoteBody(body, quote.span)
@@ -150,7 +166,7 @@ class CrossStageSafety extends TreeMapWithStages {
    *  - 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: Splice)(using Context): Tree = {
+  private def transformSplice(body: Tree, splice: Splice)(using Context): Tree = {
     val body1 = transform(body)(using spliceContext)
     val tpe1 =
       if level == 0 then splice.tpe
diff --git a/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala b/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
index 67fb17551253..674dfff2f642 100644
--- a/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
+++ b/compiler/src/dotty/tools/dotc/staging/TreeMapWithStages.scala
@@ -6,7 +6,6 @@ import dotty.tools.dotc.config.Printers.staging
 import dotty.tools.dotc.core.Decorators._
 import dotty.tools.dotc.core.Contexts._
 import dotty.tools.dotc.core.Symbols._
-import dotty.tools.dotc.util.Property
 import dotty.tools.dotc.staging.StagingLevel.*
 
 import scala.collection.mutable
@@ -15,45 +14,11 @@ import scala.collection.mutable
 abstract class TreeMapWithStages extends TreeMapWithImplicits {
   import tpd._
 
-  /** Transform the quote `quote` which contains the quoted `body`.
-   *
-   *  - `quoted.runtime.Expr.quote[T](<body0>)`  --> `quoted.runtime.Expr.quote[T](<body>)`
-   */
-  protected def transformQuote(body: Tree, quote: Quote)(using Context): Tree =
-    cpy.Quote(quote)(body)
-
-  /** Transform the expression splice `splice` which contains the spliced `body`. */
-  protected def transformSplice(body: Tree, splice: Splice)(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 dropEmptyBlocks(tree: Tree): Tree = tree match {
-        case Block(Nil, expr) => dropEmptyBlocks(expr)
-        case _ => tree
-      }
-
+    else reporting.trace(i"TreeMapWithStages.transform $tree at $level", staging, show = true) {
       tree match {
-        case tree @ Quote(quotedTree) =>
-          dropEmptyBlocks(quotedTree) match {
-            case Splice(t) =>
-              // Optimization: `'{ $x }` --> `x`
-              // and adapt the refinement of `Quotes { type reflect: ... } ?=> Expr[T]`
-              transform(t).asInstance(tree.tpe)
-            case _ =>
-              transformQuote(quotedTree, tree)
-          }
-
-        case tree @ Splice(splicedTree) =>
-          dropEmptyBlocks(splicedTree) match {
-            case Quote(t) =>
-              // Optimization: `${ 'x }` --> `x`
-              transform(t)
-            case _ =>
-              transformSplice(splicedTree, tree)
-          }
-
         case Block(stats, _) =>
           val defSyms = stats.collect { case defTree: DefTree => defTree.symbol }
           super.transform(tree)(using symbolsInCurrentLevel(defSyms))

From 966835b1b20f61c65fd60c6fc68dfbd20e2e0add Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 1 May 2023 11:50:57 +0200
Subject: [PATCH 458/657] Deduplicate code that transforms `Quote`, `Splice`,
 `Type.of`

---
 .../tools/dotc/staging/CrossStageSafety.scala | 41 +++++++------------
 1 file changed, 15 insertions(+), 26 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
index 37654bc0673b..350f90216ba4 100644
--- a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
+++ b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
@@ -50,21 +50,20 @@ class CrossStageSafety extends TreeMapWithStages {
   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 !inQuoteOrSpliceScope then
-      checkAnnotations(tree)
-      tree match
-        case tree @ Quote(quotedTree) =>
-          tree.cancelled match
-            case Some(tree1) => transform(tree1.asInstance(tree.tpe)) // TODO is this asInstance still needed?
-            case None => transformQuote(quotedTree, tree)
-        case tree @ Splice(splicedTree) =>
-          tree.cancelled match
-            case Some(tree1) => transform(tree1)
-            case None => transformSplice(splicedTree, tree)
-        case tree @ QuotedTypeOf(quotedTree) =>
-          transformQuotedType(quotedTree, tree)
-        case _ => super.transform(tree)
-    else tree match {
+    else tree match
+      case tree @ Quote(quotedTree) =>
+        tree.cancelled match
+          case Some(tree1) => transform(tree1.asInstance(tree.tpe)) // TODO is this asInstance still needed?
+          case None => transformQuote(quotedTree, tree)
+      case tree @ Splice(splicedTree) =>
+        tree.cancelled match
+          case Some(tree1) => transform(tree1)
+          case None => transformSplice(splicedTree, tree)
+      case tree @ QuotedTypeOf(quotedTree) =>
+        transformQuotedType(quotedTree, tree)
+      case _ if !inQuoteOrSpliceScope =>
+        checkAnnotations(tree)
+        super.transform(tree)
       case _: TypeTree =>
         val tp1 = transformTypeAnnotationSplices(tree.tpe)
         val healedType = healType(tree.srcPos)(tp1)
@@ -103,21 +102,11 @@ class CrossStageSafety extends TreeMapWithStages {
       case tree: TypeDef if tree.symbol.is(Case) && level > 0 =>
         report.error(reporting.CaseClassInInlinedCode(tree), tree)
         super.transform(tree)
-      case tree @ Quote(quotedTree) =>
-        tree.cancelled match
-          case Some(tree1) => transform(tree1.asInstance(tree.tpe)) // TODO is this asInstance still needed?
-          case None => transformQuote(quotedTree, tree)
-      case tree @ Splice(splicedTree) =>
-        tree.cancelled match
-          case Some(tree1) => transform(tree1)
-          case None => transformSplice(splicedTree, tree)
-      case tree @ QuotedTypeOf(quotedTree) =>
-        transformQuotedType(quotedTree, tree)
       case tree @ SplicedType(splicedTree) =>
         transformSpliceType(splicedTree, tree)
       case _ =>
         super.transform(tree)
-    }
+  end transform
 
   /** Transform quoted trees while maintaining level correctness */
   private def transformQuote(body: Tree, quote: Quote)(using Context): Tree = {

From 038dc9c7fbca231ace7025df3f38bffe54ea2f7c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Doeraene?= <sjrdoeraene@gmail.com>
Date: Mon, 1 May 2023 13:55:37 +0200
Subject: [PATCH 459/657] Remove extra whitespace in the spec.

And ensure there is a single EOL at EOF.
---
 docs/_spec/01-lexical-syntax.md                    |  2 +-
 docs/_spec/03-types.md                             | 14 +++++++-------
 .../_spec/04-basic-declarations-and-definitions.md |  4 ++--
 docs/_spec/05-classes-and-objects.md               |  2 +-
 docs/_spec/06-expressions.md                       |  2 +-
 docs/_spec/08-pattern-matching.md                  |  8 ++++----
 docs/_spec/11-annotations.md                       |  2 +-
 docs/_spec/A1-deprecated.md                        |  2 +-
 docs/_spec/A2-scala-2-compatibility.md             |  2 +-
 docs/_spec/A3-to-be-deprecated.md                  |  2 +-
 10 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/docs/_spec/01-lexical-syntax.md b/docs/_spec/01-lexical-syntax.md
index e2470e27d2e0..d12c778cb7de 100644
--- a/docs/_spec/01-lexical-syntax.md
+++ b/docs/_spec/01-lexical-syntax.md
@@ -448,7 +448,7 @@ Inside an interpolated string none of the usual escape characters are interprete
 Note that the sequence `\"` does not close a normal string literal (enclosed in single quotes).
 
 There are three forms of dollar sign escape.
-The most general form encloses an expression in `${` and `}`, i.e. `${expr}`. 
+The most general form encloses an expression in `${` and `}`, i.e. `${expr}`.
 The expression enclosed in the braces that follow the leading `$` character is of syntactical category BlockExpr.
 Hence, it can contain multiple statements, and newlines are significant.
 Single ‘$’-signs are not permitted in isolation in an interpolated string.
diff --git a/docs/_spec/03-types.md b/docs/_spec/03-types.md
index a1ad1ddffa57..c1cdb110bda8 100644
--- a/docs/_spec/03-types.md
+++ b/docs/_spec/03-types.md
@@ -45,7 +45,7 @@ Non-value types capture properties of identifiers that [are not values](#non-val
 For example, a [type constructor](#type-constructors) does not directly specify a type of values.
 However, when a type constructor is applied to the correct type arguments, it yields a proper type, which may be a value type.
 
-Non-value types are expressed indirectly in Scala. 
+Non-value types are expressed indirectly in Scala.
 E.g., a method type is described by writing down a method signature, which in itself is not a real type, although it  gives rise to a corresponding [method type](#method-types).
 Type constructors are another example, as one can write `type Swap[m[_, _], a,b] = m[b, a]`, but there is no syntax to write the corresponding anonymous type function directly.
 
@@ -130,7 +130,7 @@ SimpleType  ::=  StableId
 ```
 
 A _type designator_ refers to a named value type.
-It can be simple or qualified. 
+It can be simple or qualified.
 All such type designators are shorthands for type projections.
 
 Specifically, the unqualified type name ´t´ where ´t´ is bound in some class, object, or package ´C´ is taken as a shorthand for
@@ -306,14 +306,14 @@ RefineStat      ::=  Dcl
                   |
 ```
 
-A _compound type_ ´T_1´ `with` ... `with` ´T_n \\{ R \\}´ represents objects with members as given in the component types ´T_1, ..., T_n´ and the refinement ´\\{ R \\}´. 
+A _compound type_ ´T_1´ `with` ... `with` ´T_n \\{ R \\}´ represents objects with members as given in the component types ´T_1, ..., T_n´ and the refinement ´\\{ R \\}´.
 A refinement ´\\{ R \\}´ contains declarations and type definitions.
 If a declaration or definition overrides a declaration or definition in one of the component types ´T_1, ..., T_n´, the usual rules for [overriding](05-classes-and-objects.html#overriding) apply; otherwise the declaration or definition is said to be “structural” [^2].
 
 [^2]: A reference to a structurally defined member (method call or access to a value or variable) may generate binary code that is significantly slower than an equivalent code to a non-structural member.
 
-Within a method declaration in a structural refinement, the type of any value parameter may only refer to type parameters or abstract types that are contained inside the refinement. 
-That is, it must refer either to a type parameter of the method itself, or to a type definition within the refinement. 
+Within a method declaration in a structural refinement, the type of any value parameter may only refer to type parameters or abstract types that are contained inside the refinement.
+That is, it must refer either to a type parameter of the method itself, or to a type definition within the refinement.
 This restriction does not apply to the method's result type.
 
 If no refinement is given, the empty refinement is implicitly added, i.e. ´T_1´ `with` ... `with` ´T_n´ is a shorthand for ´T_1´ `with` ... `with` ´T_n \\{\\}´.
@@ -382,7 +382,7 @@ Function types associate to the right, e.g. ´S \Rightarrow T \Rightarrow R´ is
 Function types are [covariant](04-basic-declarations-and-definitions.md#variance-annotations) in their result type and [contravariant](04-basic-declarations-and-definitions.md#variance-annotations) in their argument types.
 
 Function types are shorthands for class types that define an `apply` method.
-Specifically, the ´n´-ary function type ´(T_1, ..., T_n) \Rightarrow R´ is a shorthand for the class type `Function´_n´[´T_1´, ..., ´T_n´, ´R´]`. 
+Specifically, the ´n´-ary function type ´(T_1, ..., T_n) \Rightarrow R´ is a shorthand for the class type `Function´_n´[´T_1´, ..., ´T_n´, ´R´]`.
 In particular ´() \Rightarrow R´ is a shorthand for class type `Function´_0´[´R´]`.
 
 Such class types behave as if they were instances of the following trait:
@@ -396,7 +396,7 @@ Their exact supertype and implementation can be consulted in the [function class
 
 ## Non-Value Types
 
-The types explained in the following do not denote sets of values, nor do they appear explicitly in programs. 
+The types explained in the following do not denote sets of values, nor do they appear explicitly in programs.
 They are introduced in this report as the internal types of defined identifiers.
 
 ### Method Types
diff --git a/docs/_spec/04-basic-declarations-and-definitions.md b/docs/_spec/04-basic-declarations-and-definitions.md
index 1d50fd649efd..e0985c68dbc6 100644
--- a/docs/_spec/04-basic-declarations-and-definitions.md
+++ b/docs/_spec/04-basic-declarations-and-definitions.md
@@ -79,7 +79,7 @@ final val x = e
 ```
 
 where `e` is a [constant expression](06-expressions.html#constant-expressions).
-The `final` modifier must be present and no type annotation may be given. 
+The `final` modifier must be present and no type annotation may be given.
 References to the constant value `x` are themselves treated as constant expressions; in the generated code they are replaced by the definition's right-hand side `e`.
 
 Value definitions can alternatively have a [pattern](08-pattern-matching.html#patterns) as left-hand side.
@@ -311,7 +311,7 @@ TypeParam        ::= (id | ‘_’) [TypeParamClause] [‘>:’ Type] [‘<:’
 Type parameters appear in type definitions, class definitions, and method definitions.
 In this section we consider only type parameter definitions with lower bounds `>: ´L´` and upper bounds `<: ´U´` whereas a discussion of context bounds `: ´U´` and view bounds `<% ´U´` is deferred to [here](07-implicits.html#context-bounds-and-view-bounds).
 
-The most general form of a proper type parameter is 
+The most general form of a proper type parameter is
 `´@a_1 ... @a_n´ ´\pm´ ´t´ >: ´L´ <: ´U´`.
 Here, ´L´, and ´U´ are lower and upper bounds that constrain possible type arguments for the parameter.
 It is a compile-time error if ´L´ does not conform to ´U´.
diff --git a/docs/_spec/05-classes-and-objects.md b/docs/_spec/05-classes-and-objects.md
index b73a4aa56071..f02aa5368b30 100644
--- a/docs/_spec/05-classes-and-objects.md
+++ b/docs/_spec/05-classes-and-objects.md
@@ -538,7 +538,7 @@ These are defined by constructor definitions of the form `def this(´\mathit{ps}
 Such a definition introduces an additional constructor for the enclosing class, with parameters as given in the formal parameter lists ´\mathit{ps}_1 , ..., \mathit{ps}_n´, and whose evaluation is defined by the constructor expression ´e´.
 The scope of each formal parameter is the subsequent parameter sections and the constructor expression ´e´.
 A constructor expression is either a self constructor invocation `this(´\mathit{args}_1´)...(´\mathit{args}_n´)` or a block which begins with a self constructor invocation.
-The self constructor invocation must construct a generic instance of the class. 
+The self constructor invocation must construct a generic instance of the class.
 I.e. if the class in question has name ´C´ and type parameters `[´\mathit{tps}\,´]`, then a self constructor invocation must generate an instance of `´C´[´\mathit{tps}\,´]`; it is not permitted to instantiate formal type parameters.
 
 The signature and the self constructor invocation of a constructor definition are type-checked and evaluated in the scope which is in effect at the point of the enclosing class definition, augmented by any type parameters of the enclosing class.
diff --git a/docs/_spec/06-expressions.md b/docs/_spec/06-expressions.md
index 5adb58ec626c..fa21b4330728 100644
--- a/docs/_spec/06-expressions.md
+++ b/docs/_spec/06-expressions.md
@@ -713,7 +713,7 @@ Generator      ::=  [‘case’] Pattern1 ‘<-’ Expr {[semi] Guard | semi Pat
 Guard          ::=  ‘if’ PostfixExpr
 ```
 
-A _for loop_ `for (´\mathit{enums}\,´) ´e´` executes expression ´e´ for each binding generated by the enumerators ´\mathit{enums}´. 
+A _for loop_ `for (´\mathit{enums}\,´) ´e´` executes expression ´e´ for each binding generated by the enumerators ´\mathit{enums}´.
 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.
 
diff --git a/docs/_spec/08-pattern-matching.md b/docs/_spec/08-pattern-matching.md
index f16f4c3dfa88..ee7b0d246aa7 100644
--- a/docs/_spec/08-pattern-matching.md
+++ b/docs/_spec/08-pattern-matching.md
@@ -113,10 +113,10 @@ Taking XML as an example
 implicit class XMLinterpolation(s: StringContext) = {
     object xml {
         def apply(exprs: Any*) =
-            // parse ‘s’ and build an XML tree with ‘exprs’ 
+            // parse ‘s’ and build an XML tree with ‘exprs’
             //in the holes
         def unapplySeq(xml: Node): Option[Seq[Node]] =
-          // match `s’ against `xml’ tree and produce 
+          // match `s’ against `xml’ tree and produce
           //subtrees in holes
     }
 }
@@ -500,7 +500,7 @@ Each case consists of a (possibly guarded) pattern ´p_i´ and a block ´b_i´.
 Each ´p_i´ might be complemented by a guard `if ´e´` where ´e´ is a boolean expression.
 The scope of the pattern variables in ´p_i´ comprises the pattern's guard and the corresponding block ´b_i´.
 
-Let ´T´ be the type of the selector expression ´e´ and let ´a_1, ..., a_m´ be the type parameters of all methods enclosing the pattern matching expression.  
+Let ´T´ be the type of the selector expression ´e´ and let ´a_1, ..., a_m´ be the type parameters of all methods enclosing the pattern matching expression.
 For every ´a_i´, let ´L_i´ be its lower bound and ´U_i´ be its higher bound.
 Every pattern ´p \in \{p_1,, ..., p_n\}´ can be typed in two ways.
 First, it is attempted to type ´p´ with ´T´ as its expected type.
@@ -566,7 +566,7 @@ def eval[T](t: Term[T]): T = t match {
 
 Note that the evaluator makes crucial use of the fact that type parameters of enclosing methods can acquire new bounds through pattern matching.
 
-For instance, the type of the pattern in the second case, `Succ(u)`, is `Int`. 
+For instance, the type of the pattern in the second case, `Succ(u)`, is `Int`.
 It conforms to the selector type `T` only if we assume an upper and lower bound of `Int` for `T`.
 Under the assumption `Int <: T <: Int` we can also verify that the type right hand side of the second case, `Int` conforms to its expected type, `T`.
 
diff --git a/docs/_spec/11-annotations.md b/docs/_spec/11-annotations.md
index 11325a1639f0..3388d55318ea 100644
--- a/docs/_spec/11-annotations.md
+++ b/docs/_spec/11-annotations.md
@@ -109,7 +109,7 @@ trait Function0[@specialized(Unit, Int, Double) T] {
 ```
 Whenever the static type of an expression matches a specialized variant of a definition, the compiler will instead use the specialized version.
 See the [specialization sid](https://docs.scala-lang.org/sips/scala-specialization.html) for more details of the implementation.
-    
+
 
 ## User-defined Annotations
 
diff --git a/docs/_spec/A1-deprecated.md b/docs/_spec/A1-deprecated.md
index e2ebc8af1d35..649c2d7d92e6 100644
--- a/docs/_spec/A1-deprecated.md
+++ b/docs/_spec/A1-deprecated.md
@@ -18,4 +18,4 @@ scalac Test.scala
   |                         For now, you can also `import language.deprecated.symbolLiterals` to accept
   |                         the idiom, but this possibility might no longer be available in the future.
 1 error found
-```
\ No newline at end of file
+```
diff --git a/docs/_spec/A2-scala-2-compatibility.md b/docs/_spec/A2-scala-2-compatibility.md
index 3621887581a6..461bd37592b0 100644
--- a/docs/_spec/A2-scala-2-compatibility.md
+++ b/docs/_spec/A2-scala-2-compatibility.md
@@ -32,4 +32,4 @@ def f(): Unit = { ... }
 Scala 3 accepts the old syntax under the `-source:3.0-migration` option.
 If the `-migration` option is set, it can even rewrite old syntax to new.
 The [Scalafix](https://scalacenter.github.io/scalafix/) tool also
-can rewrite procedure syntax to make it Scala 3 compatible.
\ No newline at end of file
+can rewrite procedure syntax to make it Scala 3 compatible.
diff --git a/docs/_spec/A3-to-be-deprecated.md b/docs/_spec/A3-to-be-deprecated.md
index adc37111520c..98f758dee2d4 100644
--- a/docs/_spec/A3-to-be-deprecated.md
+++ b/docs/_spec/A3-to-be-deprecated.md
@@ -1,4 +1,4 @@
 This is a simple list of feature that are not deprecated yet, but will be in the future.
 They should emit warnings or errors only when using the `-source:future` compiler flag.
 
-- [private[this] and protected[this]](../_docs/reference/dropped-features/this-qualifier.md)
\ No newline at end of file
+- [private[this] and protected[this]](../_docs/reference/dropped-features/this-qualifier.md)

From e6c0b58d9a346c521945743eb2ccad243082e024 Mon Sep 17 00:00:00 2001
From: Fengyun Liu <fengyun.liu.cs@gmail.com>
Date: Mon, 1 May 2023 13:55:36 +0200
Subject: [PATCH 460/657] Fix #16899: Better handle X instanceOf P where X is
 T1 | T2

---
 .../tools/dotc/transform/TypeTestsCasts.scala | 46 +++++++++++++++++--
 1 file changed, 42 insertions(+), 4 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala b/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
index 3763af243881..378ad0679fe9 100644
--- a/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
@@ -16,6 +16,8 @@ import util.Spans._
 import reporting._
 import config.Printers.{ transforms => debug }
 
+import patmat.Typ
+
 /** This transform normalizes type tests and type casts,
  *  also replacing type tests with singleton argument type with reference equality check
  *  Any remaining type tests
@@ -51,7 +53,8 @@ object TypeTestsCasts {
    *  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, ""
+   *  9. if `X` is `T1 | T2`, (isCheckDefinitelyFalse(T1, P) && checkable(T2, P)) or (checkable(T1, P) && isCheckDefinitelyFalse(T2, P)).
+   *  10. 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
@@ -129,6 +132,34 @@ object TypeTestsCasts {
 
     }
 
+    /** Whether the check X.isInstanceOf[P] is definitely false? */
+    def isCheckDefinitelyFalse(X: Type, P: Type)(using Context): Boolean = trace(s"isCheckDefinitelyFalse(${X.show}, ${P.show})") {
+      X.dealias match
+      case AndType(x1, x2) =>
+        isCheckDefinitelyFalse(x1, P) || isCheckDefinitelyFalse(x2, P)
+
+      case x =>
+        P.dealias match
+        case AndType(p1, p2) =>
+          isCheckDefinitelyFalse(x, p1) || isCheckDefinitelyFalse(x, p2)
+
+        case p =>
+          val pSpace = Typ(p)
+          val xSpace = Typ(x)
+          if pSpace.canDecompose then
+            val ps = pSpace.decompose.map(_.tp)
+            ps.forall(p => isCheckDefinitelyFalse(x, p))
+          else if xSpace.canDecompose then
+            val xs = xSpace.decompose.map(_.tp)
+            xs.exists(x => isCheckDefinitelyFalse(x, p))
+          else
+            val xClass = effectiveClass(x.widen)
+            val pClass = effectiveClass(p.widen)
+
+            !xClass.derivesFrom(pClass)
+            && (xClass.is(Final) || pClass.is(Final) || !xClass.is(Trait) && !pClass.is(Trait))
+    }
+
     def recur(X: Type, P: Type): String = (X <:< P) ||| (P.dealias match {
       case _: SingletonType     => ""
       case _: TypeProxy
@@ -146,7 +177,14 @@ object TypeTestsCasts {
             //   - T1 <:< T2 | T3
             //   - T1 & T2 <:< T3
             // See TypeComparer#either
-            recur(tp1, P) && recur(tp2, P)
+            val res1 = recur(tp1, P)
+            val res2 = recur(tp2, P)
+
+            if res1.isEmpty && res2.isEmpty then res1
+            else if isCheckDefinitelyFalse(tp1, P) && res2.isEmpty then res2
+            else if res1.isEmpty && isCheckDefinitelyFalse(tp2, P) then res1
+            else res1
+
           case _ =>
             // always false test warnings are emitted elsewhere
             X.classSymbol.exists && P.classSymbol.exists &&
@@ -302,8 +340,8 @@ object TypeTestsCasts {
 
         /** Transform isInstanceOf
          *
-         *    expr.isInstanceOf[A | B]  ~~>  expr.isInstanceOf[A] | expr.isInstanceOf[B]
-         *    expr.isInstanceOf[A & B]  ~~>  expr.isInstanceOf[A] & expr.isInstanceOf[B]
+         *    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)

From 6f370fd997df863730f16e35e94272f36b2edca0 Mon Sep 17 00:00:00 2001
From: Fengyun Liu <fengyun.liu.cs@gmail.com>
Date: Mon, 1 May 2023 13:56:22 +0200
Subject: [PATCH 461/657] Add test

---
 tests/pos-special/isInstanceOf/i16899.scala | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 tests/pos-special/isInstanceOf/i16899.scala

diff --git a/tests/pos-special/isInstanceOf/i16899.scala b/tests/pos-special/isInstanceOf/i16899.scala
new file mode 100644
index 000000000000..650e1e5c7b23
--- /dev/null
+++ b/tests/pos-special/isInstanceOf/i16899.scala
@@ -0,0 +1,5 @@
+sealed trait Unset
+
+def foo(v: Unset|Option[Int]): Unit = v match
+  case v: Unset => ()
+  case v: Option[Int] => ()

From 8b3eee87544530464dfe8bfabbfcaeade6287775 Mon Sep 17 00:00:00 2001
From: Fengyun Liu <fengyun.liu.cs@gmail.com>
Date: Mon, 1 May 2023 13:56:38 +0200
Subject: [PATCH 462/657] Fix tests

---
 .../dotty/tools/dotc/transform/TypeTestsCasts.scala | 13 +++++++++----
 tests/neg-custom-args/isInstanceOf/i5826.scala      |  2 +-
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala b/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
index 378ad0679fe9..7684d7f2867e 100644
--- a/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
@@ -151,7 +151,7 @@ object TypeTestsCasts {
             ps.forall(p => isCheckDefinitelyFalse(x, p))
           else if xSpace.canDecompose then
             val xs = xSpace.decompose.map(_.tp)
-            xs.exists(x => isCheckDefinitelyFalse(x, p))
+            xs.forall(x => isCheckDefinitelyFalse(x, p))
           else
             val xClass = effectiveClass(x.widen)
             val pClass = effectiveClass(p.widen)
@@ -181,9 +181,14 @@ object TypeTestsCasts {
             val res2 = recur(tp2, P)
 
             if res1.isEmpty && res2.isEmpty then res1
-            else if isCheckDefinitelyFalse(tp1, P) && res2.isEmpty then res2
-            else if res1.isEmpty && isCheckDefinitelyFalse(tp2, P) then res1
-            else res1
+            else if res2.isEmpty then
+              if isCheckDefinitelyFalse(tp1, P) then res2
+              else i"it cannot be checked against the type $tp1"
+            else if res1.isEmpty then
+              if isCheckDefinitelyFalse(tp2, P) then res1
+              else i"it cannot be checked against the type $tp2"
+            else
+              i"it cannot be checked against the type $tp2"
 
           case _ =>
             // always false test warnings are emitted elsewhere
diff --git a/tests/neg-custom-args/isInstanceOf/i5826.scala b/tests/neg-custom-args/isInstanceOf/i5826.scala
index bff95e740b4f..89af39958541 100644
--- a/tests/neg-custom-args/isInstanceOf/i5826.scala
+++ b/tests/neg-custom-args/isInstanceOf/i5826.scala
@@ -1,6 +1,6 @@
 class Foo {
   def test[A]: List[Int] | A => Int = {
-    case ls: List[Int] => ls.head       // error
+    case ls: List[Int] => ls.head       // ok, List decomposes to Some and None
     case _ => 0
   }
 

From 128c7a1682738d5167c393ee2c74e1ed7ab8acc3 Mon Sep 17 00:00:00 2001
From: Fengyun Liu <fengyun.liu.cs@gmail.com>
Date: Mon, 1 May 2023 13:57:39 +0200
Subject: [PATCH 463/657] Fix doc

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

diff --git a/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala b/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
index 7684d7f2867e..15503b475d65 100644
--- a/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
@@ -53,7 +53,7 @@ object TypeTestsCasts {
    *  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. if `X` is `T1 | T2`, (isCheckDefinitelyFalse(T1, P) && checkable(T2, P)) or (checkable(T1, P) && isCheckDefinitelyFalse(T2, P)).
+   *  9. if `X` is `T1 | T2`, checkable(T1, P) && checkable(T2, P) or (isCheckDefinitelyFalse(T1, P) && checkable(T2, P)) or (checkable(T1, P) && isCheckDefinitelyFalse(T2, P)).
    *  10. otherwise, ""
    */
   def whyUncheckable(X: Type, P: Type, span: Span)(using Context): String = atPhase(Phases.refchecksPhase.next) {

From 757d01dd65d578ed929d83d8c1ec46bfe7fb3718 Mon Sep 17 00:00:00 2001
From: Guillaume Martres <smarter@ubuntu.com>
Date: Fri, 28 Apr 2023 10:55:21 +0200
Subject: [PATCH 464/657] =?UTF-8?q?docs:=20Replace=20=E2=80=A6=20by=20...?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This is the same change already applied to docs/_spec in
38e79aae2f11522e55948f4073e852ac90d821fb, made here to make it easier to
port changes between docs/_docs and doc/_spec.
---
 docs/_docs/internals/syntax-3.1.md                 | 14 +++++++-------
 docs/_docs/internals/syntax.md                     | 14 +++++++-------
 .../changed-features/overload-resolution.md        |  4 ++--
 docs/_docs/reference/syntax.md                     | 14 +++++++-------
 4 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/docs/_docs/internals/syntax-3.1.md b/docs/_docs/internals/syntax-3.1.md
index 4d4d3b6d858d..0104222f50f5 100644
--- a/docs/_docs/internals/syntax-3.1.md
+++ b/docs/_docs/internals/syntax-3.1.md
@@ -11,7 +11,7 @@ hexadecimal code:
 
 ```ebnf
 UnicodeEscape ::= ‘\’ ‘u’ {‘u’} hexDigit hexDigit hexDigit hexDigit
-hexDigit      ::= ‘0’ | … | ‘9’ | ‘A’ | … | ‘F’ | ‘a’ | … | ‘f’
+hexDigit      ::= ‘0’ | ... | ‘9’ | ‘A’ | ... | ‘F’ | ‘a’ | ... | ‘f’
 ```
 
 Informal descriptions are typeset as `“some comment”`.
@@ -22,15 +22,15 @@ form.
 
 ```ebnf
 whiteSpace       ::=  ‘\u0020’ | ‘\u0009’ | ‘\u000D’ | ‘\u000A’
-upper            ::=  ‘A’ | … | ‘Z’ | ‘\$’ | ‘_’  “… and Unicode category Lu”
-lower            ::=  ‘a’ | … | ‘z’ “… and Unicode category Ll”
-letter           ::=  upper | lower “… and Unicode categories Lo, Lt, Lm, Nl”
-digit            ::=  ‘0’ | … | ‘9’
+upper            ::=  ‘A’ | ... | ‘Z’ | ‘\$’ | ‘_’  “... and Unicode category Lu”
+lower            ::=  ‘a’ | ... | ‘z’ “... and Unicode category Ll”
+letter           ::=  upper | lower “... and Unicode categories Lo, Lt, Lm, Nl”
+digit            ::=  ‘0’ | ... | ‘9’
 paren            ::=  ‘(’ | ‘)’ | ‘[’ | ‘]’ | ‘{’ | ‘}’ | ‘'(’ | ‘'[’ | ‘'{’
 delim            ::=  ‘`’ | ‘'’ | ‘"’ | ‘.’ | ‘;’ | ‘,’
 opchar           ::=  ‘!’ | ‘#’ | ‘%’ | ‘&’ | ‘*’ | ‘+’ | ‘-’ | ‘/’ | ‘:’ |
                       ‘<’ | ‘=’ | ‘>’ | ‘?’ | ‘@’ | ‘\’ | ‘^’ | ‘|’ | ‘~’
-                      “… and Unicode categories Sm, So”
+                      “... and Unicode categories Sm, So”
 printableChar    ::=  “all characters in [\u0020, \u007E] inclusive”
 charEscapeSeq    ::=  ‘\’ (‘b’ | ‘t’ | ‘n’ | ‘f’ | ‘r’ | ‘"’ | ‘'’ | ‘\’)
 
@@ -49,7 +49,7 @@ integerLiteral   ::=  (decimalNumeral | hexNumeral) [‘L’ | ‘l’]
 decimalNumeral   ::=  ‘0’ | nonZeroDigit {digit}
 hexNumeral       ::=  ‘0’ (‘x’ | ‘X’) hexDigit {hexDigit}
 digit            ::=  ‘0’ | nonZeroDigit
-nonZeroDigit     ::=  ‘1’ | … | ‘9’
+nonZeroDigit     ::=  ‘1’ | ... | ‘9’
 
 floatingPointLiteral
                  ::=  digit {digit} ‘.’ {digit} [exponentPart] [floatType]
diff --git a/docs/_docs/internals/syntax.md b/docs/_docs/internals/syntax.md
index 445e86ee2408..35ec4955d27d 100644
--- a/docs/_docs/internals/syntax.md
+++ b/docs/_docs/internals/syntax.md
@@ -25,7 +25,7 @@ hexadecimal code:
 
 ```ebnf
 UnicodeEscape ::= ‘\’ ‘u’ {‘u’} hexDigit hexDigit hexDigit hexDigit
-hexDigit      ::= ‘0’ | … | ‘9’ | ‘A’ | … | ‘F’ | ‘a’ | … | ‘f’
+hexDigit      ::= ‘0’ | ... | ‘9’ | ‘A’ | ... | ‘F’ | ‘a’ | ... | ‘f’
 ```
 
 Informal descriptions are typeset as `“some comment”`.
@@ -37,15 +37,15 @@ form.
 
 ```ebnf
 whiteSpace       ::=  ‘\u0020’ | ‘\u0009’ | ‘\u000D’ | ‘\u000A’
-upper            ::=  ‘A’ | … | ‘Z’ | ‘\$’ | ‘_’  “… and Unicode category Lu”
-lower            ::=  ‘a’ | … | ‘z’ “… and Unicode category Ll”
-letter           ::=  upper | lower “… and Unicode categories Lo, Lt, Lm, Nl”
-digit            ::=  ‘0’ | … | ‘9’
+upper            ::=  ‘A’ | ... | ‘Z’ | ‘\$’ | ‘_’  “... and Unicode category Lu”
+lower            ::=  ‘a’ | ... | ‘z’ “... and Unicode category Ll”
+letter           ::=  upper | lower “... and Unicode categories Lo, Lt, Lm, Nl”
+digit            ::=  ‘0’ | ... | ‘9’
 paren            ::=  ‘(’ | ‘)’ | ‘[’ | ‘]’ | ‘{’ | ‘}’
 delim            ::=  ‘`’ | ‘'’ | ‘"’ | ‘.’ | ‘;’ | ‘,’
 opchar           ::=  ‘!’ | ‘#’ | ‘%’ | ‘&’ | ‘*’ | ‘+’ | ‘-’ | ‘/’ | ‘:’ |
                       ‘<’ | ‘=’ | ‘>’ | ‘?’ | ‘@’ | ‘\’ | ‘^’ | ‘|’ | ‘~’
-                      “… and Unicode categories Sm, So”
+                      “... and Unicode categories Sm, So”
 printableChar    ::=  “all characters in [\u0020, \u007E] inclusive”
 charEscapeSeq    ::=  ‘\’ (‘b’ | ‘t’ | ‘n’ | ‘f’ | ‘r’ | ‘"’ | ‘'’ | ‘\’)
 
@@ -64,7 +64,7 @@ spliceId         ::=  ‘$’ alphaid ;
 integerLiteral   ::=  (decimalNumeral | hexNumeral) [‘L’ | ‘l’]
 decimalNumeral   ::=  ‘0’ | nonZeroDigit [{digit | ‘_’} digit]
 hexNumeral       ::=  ‘0’ (‘x’ | ‘X’) hexDigit [{hexDigit | ‘_’} hexDigit]
-nonZeroDigit     ::=  ‘1’ | … | ‘9’
+nonZeroDigit     ::=  ‘1’ | ... | ‘9’
 
 floatingPointLiteral
                  ::=  [decimalNumeral] ‘.’ digit [{digit | ‘_’} digit] [exponentPart] [floatType]
diff --git a/docs/_docs/reference/changed-features/overload-resolution.md b/docs/_docs/reference/changed-features/overload-resolution.md
index bd7782ded520..621515c2a7f8 100644
--- a/docs/_docs/reference/changed-features/overload-resolution.md
+++ b/docs/_docs/reference/changed-features/overload-resolution.md
@@ -66,11 +66,11 @@ as follows:
 
 Replace the sentence
 
-> Otherwise, let `S1,…,Sm` be the vector of types obtained by typing each argument with an undefined expected type.
+> Otherwise, let `S1,...,Sm` be the vector of types obtained by typing each argument with an undefined expected type.
 
 with the following paragraph:
 
-> Otherwise, let `S1,…,Sm` be the vector of known types of all argument types, where the _known type_ of an argument `E`
+> Otherwise, let `S1,...,Sm` be the vector of known types of all argument types, where the _known type_ of an argument `E`
 is determined as followed:
 
  - If `E` is a function value `(p_1, ..., p_n) => B` that misses some parameter types, the known type
diff --git a/docs/_docs/reference/syntax.md b/docs/_docs/reference/syntax.md
index 6abc3b2011d1..96d88dc5932a 100644
--- a/docs/_docs/reference/syntax.md
+++ b/docs/_docs/reference/syntax.md
@@ -26,7 +26,7 @@ hexadecimal code:
 
 ```
 UnicodeEscape ::= ‘\’ ‘u’ {‘u’} hexDigit hexDigit hexDigit hexDigit
-hexDigit      ::= ‘0’ | … | ‘9’ | ‘A’ | … | ‘F’ | ‘a’ | … | ‘f’
+hexDigit      ::= ‘0’ | ... | ‘9’ | ‘A’ | ... | ‘F’ | ‘a’ | ... | ‘f’
 ```
 
 Informal descriptions are typeset as `“some comment”`.
@@ -38,15 +38,15 @@ form.
 
 ```
 whiteSpace       ::=  ‘\u0020’ | ‘\u0009’ | ‘\u000D’ | ‘\u000A’
-upper            ::=  ‘A’ | … | ‘Z’ | ‘\$’ | ‘_’  “… and Unicode category Lu”
-lower            ::=  ‘a’ | … | ‘z’ “… and Unicode category Ll”
-letter           ::=  upper | lower “… and Unicode categories Lo, Lt, Nl”
-digit            ::=  ‘0’ | … | ‘9’
+upper            ::=  ‘A’ | ... | ‘Z’ | ‘\$’ | ‘_’  “... and Unicode category Lu”
+lower            ::=  ‘a’ | ... | ‘z’ “... and Unicode category Ll”
+letter           ::=  upper | lower “... and Unicode categories Lo, Lt, Nl”
+digit            ::=  ‘0’ | ... | ‘9’
 paren            ::=  ‘(’ | ‘)’ | ‘[’ | ‘]’ | ‘{’ | ‘}’
 delim            ::=  ‘`’ | ‘'’ | ‘"’ | ‘.’ | ‘;’ | ‘,’
 opchar           ::=  ‘!’ | ‘#’ | ‘%’ | ‘&’ | ‘*’ | ‘+’ | ‘-’ | ‘/’ | ‘:’ |
                       ‘<’ | ‘=’ | ‘>’ | ‘?’ | ‘@’ | ‘\’ | ‘^’ | ‘|’ | ‘~’
-                      “… and Unicode categories Sm, So”
+                      “... and Unicode categories Sm, So”
 printableChar    ::=  “all characters in [\u0020, \u007E] inclusive”
 charEscapeSeq    ::=  ‘\’ (‘b’ | ‘t’ | ‘n’ | ‘f’ | ‘r’ | ‘"’ | ‘'’ | ‘\’)
 
@@ -65,7 +65,7 @@ spliceId         ::=  ‘$’ alphaid ;
 integerLiteral   ::=  (decimalNumeral | hexNumeral) [‘L’ | ‘l’]
 decimalNumeral   ::=  ‘0’ | nonZeroDigit [{digit | ‘_’} digit]
 hexNumeral       ::=  ‘0’ (‘x’ | ‘X’) hexDigit [{hexDigit | ‘_’} hexDigit]
-nonZeroDigit     ::=  ‘1’ | … | ‘9’
+nonZeroDigit     ::=  ‘1’ | ... | ‘9’
 
 floatingPointLiteral
                  ::=  [decimalNumeral] ‘.’ digit [{digit | ‘_’} digit] [exponentPart] [floatType]

From e5b41152c4abc833d5c24e840d422537b573ab28 Mon Sep 17 00:00:00 2001
From: Guillaume Martres <smarter@ubuntu.com>
Date: Fri, 28 Apr 2023 10:58:24 +0200
Subject: [PATCH 465/657] Synchronize {reference,TODOreference}/syntax.md

---
 docs/_spec/TODOreference/syntax.md | 48 ++++++++++++++++++++----------
 1 file changed, 32 insertions(+), 16 deletions(-)

diff --git a/docs/_spec/TODOreference/syntax.md b/docs/_spec/TODOreference/syntax.md
index d3526783a5eb..96d88dc5932a 100644
--- a/docs/_spec/TODOreference/syntax.md
+++ b/docs/_spec/TODOreference/syntax.md
@@ -105,7 +105,10 @@ semi             ::=  ‘;’ |  nl {nl}
 
 ## Optional Braces
 
-The lexical analyzer also inserts `indent` and `outdent` tokens that represent regions of indented code [at certain points](./other-new-features/indentation.md).
+The principle of optional braces is that any keyword that can be followed by `{` can also be followed by an indented block, without needing an intervening `:`.
+(Allowing an optional `:` would be counterproductive since it would introduce several ways to do the same thing.)
+
+The lexical analyzer inserts `indent` and `outdent` tokens that represent regions of indented code [at certain points](./other-new-features/indentation.md).
 
 In the context-free productions below we use the notation `<<< ts >>>`
 to indicate a token sequence `ts` that is either enclosed in a pair of braces `{ ts }` or that constitutes an indented region `indent ts outdent`. Analogously, the
@@ -249,6 +252,7 @@ Catches           ::=  ‘catch’ (Expr | ExprCaseClause)
 PostfixExpr       ::=  InfixExpr [id]                                          -- only if language.postfixOperators is enabled
 InfixExpr         ::=  PrefixExpr
                     |  InfixExpr id [nl] InfixExpr
+                    |  InfixExpr id ColonArgument
                     |  InfixExpr MatchClause
 MatchClause       ::=  ‘match’ <<< CaseClauses >>>
 PrefixExpr        ::=  [PrefixOperator] SimpleExpr
@@ -267,6 +271,11 @@ SimpleExpr        ::=  SimpleRef
                     |  SimpleExpr ‘.’ MatchClause
                     |  SimpleExpr TypeArgs
                     |  SimpleExpr ArgumentExprs
+                    |  SimpleExpr ColonArgument
+ColonArgument     ::=  colon [LambdaStart]
+                       indent (CaseClauses | Block) outdent
+LambdaStart       ::=  FunParams (‘=>’ | ‘?=>’)
+                    |  HkTypeParamClause ‘=>’
 Quoted            ::=  ‘'’ ‘{’ Block ‘}’
                     |  ‘'’ ‘[’ Type ‘]’
 ExprSplice        ::= spliceId                                                  -- if inside quoted block
@@ -306,7 +315,10 @@ TypeCaseClauses   ::=  TypeCaseClause { TypeCaseClause }
 TypeCaseClause    ::=  ‘case’ (InfixType | ‘_’) ‘=>’ Type [semi]
 
 Pattern           ::=  Pattern1 { ‘|’ Pattern1 }
-Pattern1          ::=  Pattern2 [‘:’ RefinedType]
+Pattern1          ::=  PatVar ‘:’ RefinedType
+                    | [‘-’] integerLiteral ‘:’ RefinedType
+                    | [‘-’] floatingPointLiteral ‘:’ RefinedType
+                    |  Pattern2
 Pattern2          ::=  [id ‘@’] InfixPattern [‘*’]
 InfixPattern      ::=  SimplePattern { id [nl] SimplePattern }
 SimplePattern     ::=  PatVar
@@ -329,9 +341,6 @@ ArgumentPatterns  ::=  ‘(’ [Patterns] ‘)’
 ClsTypeParamClause::=  ‘[’ ClsTypeParam {‘,’ ClsTypeParam} ‘]’
 ClsTypeParam      ::=  {Annotation} [‘+’ | ‘-’] id [HkTypeParamClause] TypeParamBounds
 
-DefTypeParamClause::=  ‘[’ DefTypeParam {‘,’ DefTypeParam} ‘]’
-DefTypeParam      ::=  {Annotation} id [HkTypeParamClause] TypeParamBounds
-
 TypTypeParamClause::=  ‘[’ TypTypeParam {‘,’ TypTypeParam} ‘]’
 TypTypeParam      ::=  {Annotation} id [HkTypeParamClause] TypeBounds
 
@@ -343,13 +352,20 @@ ClsParamClause    ::=  [nl] ‘(’ ClsParams ‘)’
                     |  [nl] ‘(’ ‘using’ (ClsParams | FunArgTypes) ‘)’
 ClsParams         ::=  ClsParam {‘,’ ClsParam}
 ClsParam          ::=  {Annotation} [{Modifier} (‘val’ | ‘var’) | ‘inline’] Param
-Param             ::=  id ‘:’ ParamType [‘=’ Expr]
 
-DefParamClauses   ::=  {DefParamClause} [[nl] ‘(’ [‘implicit’] DefParams ‘)’]
-DefParamClause    ::=  [nl] ‘(’ DefParams ‘)’ | UsingParamClause
-UsingParamClause  ::=  [nl] ‘(’ ‘using’ (DefParams | FunArgTypes) ‘)’
-DefParams         ::=  DefParam {‘,’ DefParam}
-DefParam          ::=  {Annotation} [‘inline’] Param
+TypelessClauses   ::=  TypelessClause {TypelessClause}
+TypelessClause    ::=  DefTermParamClause
+                    |  UsingParamClause
+
+DefTypeParamClause::=  [nl] ‘[’ DefTypeParam {‘,’ DefTypeParam} ‘]’
+DefTypeParam      ::=  {Annotation} id [HkTypeParamClause] TypeParamBounds
+DefTermParamClause::=  [nl] ‘(’ [DefTermParams] ‘)’
+UsingParamClause  ::=  [nl] ‘(’ ‘using’ (DefTermParams | FunArgTypes) ‘)’
+DefImplicitClause ::=  [nl] ‘(’ ‘implicit’ DefTermParams ‘)’
+
+DefTermParams     ::= DefTermParam {‘,’ DefTermParam}
+DefTermParam      ::= {Annotation} [‘inline’] Param
+Param             ::=  id ‘:’ ParamType [‘=’ Expr]
 ```
 
 ### Bindings and Imports
@@ -400,8 +416,8 @@ Dcl               ::=  RefineDcl
 ValDcl            ::=  ids ‘:’ Type
 VarDcl            ::=  ids ‘:’ Type
 DefDcl            ::=  DefSig ‘:’ Type
-DefSig            ::=  id [DefTypeParamClause] DefParamClauses
-TypeDcl           ::=  id [TypeParamClause] {FunParamClause} TypeBounds [‘=’ Type]
+DefSig            ::=  id [DefTypeParamClause] [TypelessClauses] [DefImplicitClause]
+TypeDcl           ::=  id [TypeParamClause] {FunParamClause} TypeBounds
 
 Def               ::=  ‘val’ PatDef
                     |  ‘var’ PatDef
@@ -411,7 +427,7 @@ Def               ::=  ‘val’ PatDef
 PatDef            ::=  ids [‘:’ Type] ‘=’ Expr
                     |  Pattern2 [‘:’ Type] ‘=’ Expr
 DefDef            ::=  DefSig [‘:’ Type] ‘=’ Expr
-                    |  ‘this’ DefParamClause DefParamClauses ‘=’ ConstrExpr
+                    |  ‘this’ TypelessClauses [DefImplicitClause] ‘=’ ConstrExpr
 
 TmplDef           ::=  ([‘case’] ‘class’ | ‘trait’) ClassDef
                     |  [‘case’] ‘object’ ObjectDef
@@ -423,10 +439,10 @@ ConstrMods        ::=  {Annotation} [AccessModifier]
 ObjectDef         ::=  id [Template]
 EnumDef           ::=  id ClassConstr InheritClauses EnumBody
 GivenDef          ::=  [GivenSig] (AnnotType [‘=’ Expr] | StructuralInstance)
-GivenSig          ::=  [id] [DefTypeParamClause] {UsingParamClause} ‘:’         -- one of `id`, `DefParamClause`, `UsingParamClause` must be present
+GivenSig          ::=  [id] [DefTypeParamClause] {UsingParamClause} ‘:’         -- one of `id`, `DefTypeParamClause`, `UsingParamClause` must be present
 StructuralInstance ::=  ConstrApp {‘with’ ConstrApp} [‘with’ WithTemplateBody]
 Extension         ::=  ‘extension’ [DefTypeParamClause] {UsingParamClause}
-                       ‘(’ DefParam ‘)’ {UsingParamClause} ExtMethods
+                       ‘(’ DefTermParam ‘)’ {UsingParamClause} ExtMethods
 ExtMethods        ::=  ExtMethod | [nl] <<< ExtMethod {semi ExtMethod} >>>
 ExtMethod         ::=  {Annotation [nl]} {Modifier} ‘def’ DefDef
                     |  Export

From 692b2b376069222b57af8e798d1dff497eb167a7 Mon Sep 17 00:00:00 2001
From: Guillaume Martres <smarter@ubuntu.com>
Date: Fri, 28 Apr 2023 11:36:07 +0200
Subject: [PATCH 466/657] Align lexical syntax between docs and spec

Scala 3 changes compared to the existing Scala 2 spec:
- Reusing alphaid in the definition of plainid (this does not change its meaning)
- Addition of quoteId and spliceId
- Correctly specifying the use of _ in numeric literals.
- Dropping symbolLiteral

Scala 2 changes compared to the existing Scala 3 spec:
- Various refactorings
- Specifying the new Unicode escape handling stuff, this was already implemented
  in Scala 3 but not part of syntax.md (see #8480).
---
 docs/_docs/internals/syntax.md     | 71 ++++++++++++++----------------
 docs/_docs/reference/syntax.md     | 71 ++++++++++++++----------------
 docs/_spec/01-lexical-syntax.md    | 20 ++++-----
 docs/_spec/13-syntax-summary.md    | 25 ++++++-----
 docs/_spec/TODOreference/syntax.md | 11 +++--
 5 files changed, 97 insertions(+), 101 deletions(-)

diff --git a/docs/_docs/internals/syntax.md b/docs/_docs/internals/syntax.md
index 35ec4955d27d..c4e71ad11612 100644
--- a/docs/_docs/internals/syntax.md
+++ b/docs/_docs/internals/syntax.md
@@ -20,51 +20,46 @@ productions map to AST nodes.
 The following description of Scala tokens uses literal characters `‘c’` when
 referring to the ASCII fragment `\u0000` – `\u007F`.
 
-_Unicode escapes_ are used to represent the [Unicode character](https://www.w3.org/International/articles/definitions-characters/) with the given
-hexadecimal code:
-
-```ebnf
-UnicodeEscape ::= ‘\’ ‘u’ {‘u’} hexDigit hexDigit hexDigit hexDigit
-hexDigit      ::= ‘0’ | ... | ‘9’ | ‘A’ | ... | ‘F’ | ‘a’ | ... | ‘f’
-```
-
-Informal descriptions are typeset as `“some comment”`.
-
 ## Lexical Syntax
 
-The lexical syntax of Scala is given by the following grammar in EBNF
-form.
+The lexical syntax of Scala is given by the following grammar in EBNF form:
 
 ```ebnf
 whiteSpace       ::=  ‘\u0020’ | ‘\u0009’ | ‘\u000D’ | ‘\u000A’
-upper            ::=  ‘A’ | ... | ‘Z’ | ‘\$’ | ‘_’  “... and Unicode category Lu”
-lower            ::=  ‘a’ | ... | ‘z’ “... and Unicode category Ll”
-letter           ::=  upper | lower “... and Unicode categories Lo, Lt, Lm, Nl”
+upper            ::=  ‘A’ | ... | ‘Z’ | ‘$’ and any character in Unicode categories Lu, Lt or Nl,
+                      and any character in Unicode categories Lo and Lm that doesn't have
+                      contributory property Other_Lowercase
+lower            ::=  ‘a’ | ... | ‘z’ | ‘_’ and any character in Unicode category Ll,
+                      and any character in Unicode categories Lo or Lm that has contributory
+                      property Other_Lowercase
+letter           ::=  upper | lower
 digit            ::=  ‘0’ | ... | ‘9’
 paren            ::=  ‘(’ | ‘)’ | ‘[’ | ‘]’ | ‘{’ | ‘}’
 delim            ::=  ‘`’ | ‘'’ | ‘"’ | ‘.’ | ‘;’ | ‘,’
 opchar           ::=  ‘!’ | ‘#’ | ‘%’ | ‘&’ | ‘*’ | ‘+’ | ‘-’ | ‘/’ | ‘:’ |
                       ‘<’ | ‘=’ | ‘>’ | ‘?’ | ‘@’ | ‘\’ | ‘^’ | ‘|’ | ‘~’
-                      “... and Unicode categories Sm, So”
-printableChar    ::=  “all characters in [\u0020, \u007E] inclusive”
+                      and any character in Unicode categories Sm or So
+printableChar    ::=  all characters in [\u0020, \u007E] inclusive
+UnicodeEscape    ::=  ‘\’ ‘u’ {‘u’} hexDigit hexDigit hexDigit hexDigit
+hexDigit         ::=  ‘0’ | ... | ‘9’ | ‘A’ | ... | ‘F’ | ‘a’ | ... | ‘f’
 charEscapeSeq    ::=  ‘\’ (‘b’ | ‘t’ | ‘n’ | ‘f’ | ‘r’ | ‘"’ | ‘'’ | ‘\’)
+escapeSeq        ::=  UnicodeEscape | charEscapeSeq
 
 op               ::=  opchar {opchar}
 varid            ::=  lower idrest
-alphaid          ::=  upper idrest
-                   |  varid
+boundvarid       ::=  varid
+                   |  ‘`’ varid ‘`’
 plainid          ::=  alphaid
                    |  op
 id               ::=  plainid
-                   |  ‘`’ { charNoBackQuoteOrNewline | UnicodeEscape | charEscapeSeq } ‘`’
+                   |  ‘`’ { charNoBackQuoteOrNewline | escapeSeq } ‘`’
 idrest           ::=  {letter | digit} [‘_’ op]
 quoteId          ::=  ‘'’ alphaid
 spliceId         ::=  ‘$’ alphaid ;
 
 integerLiteral   ::=  (decimalNumeral | hexNumeral) [‘L’ | ‘l’]
-decimalNumeral   ::=  ‘0’ | nonZeroDigit [{digit | ‘_’} digit]
+decimalNumeral   ::=  ‘0’ | digit [{digit | ‘_’} digit]
 hexNumeral       ::=  ‘0’ (‘x’ | ‘X’) hexDigit [{hexDigit | ‘_’} hexDigit]
-nonZeroDigit     ::=  ‘1’ | ... | ‘9’
 
 floatingPointLiteral
                  ::=  [decimalNumeral] ‘.’ digit [{digit | ‘_’} digit] [exponentPart] [floatType]
@@ -75,25 +70,25 @@ floatType        ::=  ‘F’ | ‘f’ | ‘D’ | ‘d’
 
 booleanLiteral   ::=  ‘true’ | ‘false’
 
-characterLiteral ::=  ‘'’ (printableChar | charEscapeSeq) ‘'’
+characterLiteral ::=  ‘'’ (charNoQuoteOrNewline | escapeSeq) ‘'’
 
 stringLiteral    ::=  ‘"’ {stringElement} ‘"’
                    |  ‘"""’ multiLineChars ‘"""’
-stringElement    ::=  printableChar \ (‘"’ | ‘\’)
-                   |  UnicodeEscape
-                   |  charEscapeSeq
-multiLineChars   ::=  {[‘"’] [‘"’] char \ ‘"’} {‘"’}
-processedStringLiteral
-                 ::=  alphaid ‘"’ {[‘\’] processedStringPart | ‘\\’ | ‘\"’} ‘"’
-                   |  alphaid ‘"""’ {[‘"’] [‘"’] char \ (‘"’ | ‘$’) | escape} {‘"’} ‘"""’
-processedStringPart
+stringElement    ::=  charNoDoubleQuoteOrNewline
+                   |  escapeSeq
+multiLineChars   ::=  {[‘"’] [‘"’] charNoDoubleQuote} {‘"’}
+
+interpolatedString
+                 ::=  alphaid ‘"’ {[‘\’] interpolatedStringPart | ‘\\’ | ‘\"’} ‘"’
+                   |  alphaid ‘"""’ {[‘"’] [‘"’] char \ (‘"’ | ‘\$’) | escape} {‘"’} ‘"""’
+interpolatedStringPart
                  ::= printableChar \ (‘"’ | ‘$’ | ‘\’) | escape
-escape           ::=  ‘$$’
-                   |  ‘$’ letter { letter | digit }
-                   |  ‘{’ Block  [‘;’ whiteSpace stringFormat whiteSpace] ‘}’
-stringFormat     ::=  {printableChar \ (‘"’ | ‘}’ | ‘ ’ | ‘\t’ | ‘\n’)}
-
-symbolLiteral    ::=  ‘'’ plainid // until 2.13
+escape           ::=  ‘\$\$’
+                   |  ‘\$"’
+                   |  ‘\$’ alphaid
+                   |  ‘\$’ BlockExpr
+alphaid          ::=  upper idrest
+                   |  varid
 
 comment          ::=  ‘/*’ “any sequence of characters; nested comments are allowed” ‘*/’
                    |  ‘//’ “any sequence of characters up to end of line”
@@ -159,7 +154,7 @@ SimpleLiteral     ::=  [‘-’] integerLiteral
                     |  characterLiteral
                     |  stringLiteral
 Literal           ::=  SimpleLiteral
-                    |  processedStringLiteral
+                    |  interpolatedStringLiteral
                     |  symbolLiteral
                     |  ‘null’
 
diff --git a/docs/_docs/reference/syntax.md b/docs/_docs/reference/syntax.md
index 96d88dc5932a..dd2e7ce118c4 100644
--- a/docs/_docs/reference/syntax.md
+++ b/docs/_docs/reference/syntax.md
@@ -21,51 +21,48 @@ productions map to AST nodes.
 The following description of Scala tokens uses literal characters `‘c’` when
 referring to the ASCII fragment `\u0000` – `\u007F`.
 
-_Unicode escapes_ are used to represent the [Unicode character](https://www.w3.org/International/articles/definitions-characters/) with the given
-hexadecimal code:
-
-```
-UnicodeEscape ::= ‘\’ ‘u’ {‘u’} hexDigit hexDigit hexDigit hexDigit
-hexDigit      ::= ‘0’ | ... | ‘9’ | ‘A’ | ... | ‘F’ | ‘a’ | ... | ‘f’
-```
-
 Informal descriptions are typeset as `“some comment”`.
 
 ## Lexical Syntax
 
-The lexical syntax of Scala is given by the following grammar in EBNF
-form.
+The lexical syntax of Scala is given by the following grammar in EBNF form:
 
-```
+```ebnf
 whiteSpace       ::=  ‘\u0020’ | ‘\u0009’ | ‘\u000D’ | ‘\u000A’
-upper            ::=  ‘A’ | ... | ‘Z’ | ‘\$’ | ‘_’  “... and Unicode category Lu”
-lower            ::=  ‘a’ | ... | ‘z’ “... and Unicode category Ll”
-letter           ::=  upper | lower “... and Unicode categories Lo, Lt, Nl”
+upper            ::=  ‘A’ | ... | ‘Z’ | ‘$’ and any character in Unicode categories Lu, Lt or Nl,
+                      and any character in Unicode categories Lo and Lm that doesn't have
+                      contributory property Other_Lowercase
+lower            ::=  ‘a’ | ... | ‘z’ | ‘_’ and any character in Unicode category Ll,
+                      and any character in Unicode categories Lo or Lm that has contributory
+                      property Other_Lowercase
+letter           ::=  upper | lower
 digit            ::=  ‘0’ | ... | ‘9’
 paren            ::=  ‘(’ | ‘)’ | ‘[’ | ‘]’ | ‘{’ | ‘}’
 delim            ::=  ‘`’ | ‘'’ | ‘"’ | ‘.’ | ‘;’ | ‘,’
 opchar           ::=  ‘!’ | ‘#’ | ‘%’ | ‘&’ | ‘*’ | ‘+’ | ‘-’ | ‘/’ | ‘:’ |
                       ‘<’ | ‘=’ | ‘>’ | ‘?’ | ‘@’ | ‘\’ | ‘^’ | ‘|’ | ‘~’
-                      “... and Unicode categories Sm, So”
-printableChar    ::=  “all characters in [\u0020, \u007E] inclusive”
+                      and any character in Unicode categories Sm or So
+printableChar    ::=  all characters in [\u0020, \u007E] inclusive
+UnicodeEscape    ::=  ‘\’ ‘u’ {‘u’} hexDigit hexDigit hexDigit hexDigit
+hexDigit         ::=  ‘0’ | ... | ‘9’ | ‘A’ | ... | ‘F’ | ‘a’ | ... | ‘f’
 charEscapeSeq    ::=  ‘\’ (‘b’ | ‘t’ | ‘n’ | ‘f’ | ‘r’ | ‘"’ | ‘'’ | ‘\’)
+escapeSeq        ::=  UnicodeEscape | charEscapeSeq
 
 op               ::=  opchar {opchar}
 varid            ::=  lower idrest
-alphaid          ::=  upper idrest
-                   |  varid
+boundvarid       ::=  varid
+                   |  ‘`’ varid ‘`’
 plainid          ::=  alphaid
                    |  op
 id               ::=  plainid
-                   |  ‘`’ { charNoBackQuoteOrNewline | UnicodeEscape | charEscapeSeq } ‘`’
+                   |  ‘`’ { charNoBackQuoteOrNewline | escapeSeq } ‘`’
 idrest           ::=  {letter | digit} [‘_’ op]
 quoteId          ::=  ‘'’ alphaid
 spliceId         ::=  ‘$’ alphaid ;
 
 integerLiteral   ::=  (decimalNumeral | hexNumeral) [‘L’ | ‘l’]
-decimalNumeral   ::=  ‘0’ | nonZeroDigit [{digit | ‘_’} digit]
+decimalNumeral   ::=  ‘0’ | digit [{digit | ‘_’} digit]
 hexNumeral       ::=  ‘0’ (‘x’ | ‘X’) hexDigit [{hexDigit | ‘_’} hexDigit]
-nonZeroDigit     ::=  ‘1’ | ... | ‘9’
 
 floatingPointLiteral
                  ::=  [decimalNumeral] ‘.’ digit [{digit | ‘_’} digit] [exponentPart] [floatType]
@@ -76,25 +73,25 @@ floatType        ::=  ‘F’ | ‘f’ | ‘D’ | ‘d’
 
 booleanLiteral   ::=  ‘true’ | ‘false’
 
-characterLiteral ::=  ‘'’ (printableChar | charEscapeSeq) ‘'’
+characterLiteral ::=  ‘'’ (charNoQuoteOrNewline | escapeSeq) ‘'’
 
 stringLiteral    ::=  ‘"’ {stringElement} ‘"’
                    |  ‘"""’ multiLineChars ‘"""’
-stringElement    ::=  printableChar \ (‘"’ | ‘\’)
-                   |  UnicodeEscape
-                   |  charEscapeSeq
-multiLineChars   ::=  {[‘"’] [‘"’] char \ ‘"’} {‘"’}
-processedStringLiteral
-                 ::=  alphaid ‘"’ {[‘\’] processedStringPart | ‘\\’ | ‘\"’} ‘"’
-                   |  alphaid ‘"""’ {[‘"’] [‘"’] char \ (‘"’ | ‘$’) | escape} {‘"’} ‘"""’
-processedStringPart
+stringElement    ::=  charNoDoubleQuoteOrNewline
+                   |  escapeSeq
+multiLineChars   ::=  {[‘"’] [‘"’] charNoDoubleQuote} {‘"’}
+
+interpolatedString
+                 ::=  alphaid ‘"’ {[‘\’] interpolatedStringPart | ‘\\’ | ‘\"’} ‘"’
+                   |  alphaid ‘"""’ {[‘"’] [‘"’] char \ (‘"’ | ‘\$’) | escape} {‘"’} ‘"""’
+interpolatedStringPart
                  ::= printableChar \ (‘"’ | ‘$’ | ‘\’) | escape
-escape           ::=  ‘$$’
-                   |  ‘$’ letter { letter | digit }
-                   |  ‘{’ Block  [‘;’ whiteSpace stringFormat whiteSpace] ‘}’
-stringFormat     ::=  {printableChar \ (‘"’ | ‘}’ | ‘ ’ | ‘\t’ | ‘\n’)}
-
-symbolLiteral    ::=  ‘'’ plainid // until 2.13
+escape           ::=  ‘\$\$’
+                   |  ‘\$"’
+                   |  ‘\$’ alphaid
+                   |  ‘\$’ BlockExpr
+alphaid          ::=  upper idrest
+                   |  varid
 
 comment          ::=  ‘/*’ “any sequence of characters; nested comments are allowed” ‘*/’
                    |  ‘//’ “any sequence of characters up to end of line”
@@ -163,7 +160,7 @@ SimpleLiteral     ::=  [‘-’] integerLiteral
                     |  characterLiteral
                     |  stringLiteral
 Literal           ::=  SimpleLiteral
-                    |  processedStringLiteral
+                    |  interpolatedStringLiteral
                     |  symbolLiteral
                     |  ‘null’
 
diff --git a/docs/_spec/01-lexical-syntax.md b/docs/_spec/01-lexical-syntax.md
index d12c778cb7de..b042fab2e984 100644
--- a/docs/_spec/01-lexical-syntax.md
+++ b/docs/_spec/01-lexical-syntax.md
@@ -27,8 +27,9 @@ op       ::=  opchar {opchar}
 varid    ::=  lower idrest
 boundvarid ::=  varid
              | ‘`’ varid ‘`’
-plainid  ::=  upper idrest
-           |  varid
+alphaid    ::=  upper idrest
+             |  varid
+plainid  ::=  alphaid
            |  op
 id       ::=  plainid
            |  ‘`’ { charNoBackQuoteOrNewline | escapeSeq } ‘`’
@@ -282,8 +283,8 @@ Literal  ::=  [‘-’] integerLiteral
 ```ebnf
 integerLiteral  ::=  (decimalNumeral | hexNumeral)
                        [‘L’ | ‘l’]
-decimalNumeral  ::=  digit {digit}
-hexNumeral      ::=  ‘0’ (‘x’ | ‘X’) hexDigit {hexDigit}
+decimalNumeral   ::=  ‘0’ | digit [{digit | ‘_’} digit]
+hexNumeral       ::=  ‘0’ (‘x’ | ‘X’) hexDigit [{hexDigit | ‘_’} hexDigit]
 ```
 
 Values of type `Int` are all integer numbers between $-2\^{31}$ and $2\^{31}-1$, inclusive.
@@ -312,12 +313,11 @@ The digits of a numeric literal may be separated by arbitrarily many underscores
 ### Floating Point Literals
 
 ```ebnf
-floatingPointLiteral  ::=  digit {digit} ‘.’ digit {digit} [exponentPart] [floatType]
-                        |  ‘.’ digit {digit} [exponentPart] [floatType]
-                        |  digit {digit} exponentPart [floatType]
-                        |  digit {digit} [exponentPart] floatType
-exponentPart          ::=  (‘E’ | ‘e’) [‘+’ | ‘-’] digit {digit}
-floatType             ::=  ‘F’ | ‘f’ | ‘D’ | ‘d’
+floatingPointLiteral
+                 ::=  [decimalNumeral] ‘.’ digit [{digit | ‘_’} digit] [exponentPart] [floatType]
+                   |  decimalNumeral exponentPart [floatType]
+                   |  decimalNumeral floatType
+exponentPart     ::=  (‘E’ | ‘e’) [‘+’ | ‘-’] digit [{digit | ‘_’} digit]
 ```
 
 Floating point literals are of type `Float` when followed by a floating point type suffix `F` or `f`, and are of type `Double` otherwise.
diff --git a/docs/_spec/13-syntax-summary.md b/docs/_spec/13-syntax-summary.md
index 7c1d394bd4e1..3de2298788b7 100644
--- a/docs/_spec/13-syntax-summary.md
+++ b/docs/_spec/13-syntax-summary.md
@@ -8,6 +8,8 @@ chapter: 13
 
 The following descriptions of Scala tokens uses literal characters `‘c’` when referring to the ASCII fragment `\u0000` – `\u007F`.
 
+Informal descriptions are typeset as `“some comment”`.
+
 ## Lexical Syntax
 
 The lexical syntax of Scala is given by the following grammar in EBNF form:
@@ -32,27 +34,30 @@ UnicodeEscape    ::=  ‘\’ ‘u’ {‘u’} hexDigit hexDigit hexDigit hexDi
 hexDigit         ::=  ‘0’ | ... | ‘9’ | ‘A’ | ... | ‘F’ | ‘a’ | ... | ‘f’
 charEscapeSeq    ::=  ‘\’ (‘b’ | ‘t’ | ‘n’ | ‘f’ | ‘r’ | ‘"’ | ‘'’ | ‘\’)
 escapeSeq        ::=  UnicodeEscape | charEscapeSeq
+
 op               ::=  opchar {opchar}
 varid            ::=  lower idrest
 boundvarid       ::=  varid
                    |  ‘`’ varid ‘`’
-plainid          ::=  upper idrest
+alphaid          ::=  upper idrest
                    |  varid
+plainid          ::=  alphaid
                    |  op
 id               ::=  plainid
                    |  ‘`’ { charNoBackQuoteOrNewline | escapeSeq } ‘`’
 idrest           ::=  {letter | digit} [‘_’ op]
+quoteId          ::=  ‘'’ alphaid
+spliceId         ::=  ‘$’ alphaid ;
 
 integerLiteral   ::=  (decimalNumeral | hexNumeral) [‘L’ | ‘l’]
-decimalNumeral   ::=  digit {digit}
-hexNumeral       ::=  ‘0’ (‘x’ | ‘X’) hexDigit {hexDigit}
+decimalNumeral   ::=  ‘0’ | digit [{digit | ‘_’} digit]
+hexNumeral       ::=  ‘0’ (‘x’ | ‘X’) hexDigit [{hexDigit | ‘_’} hexDigit]
 
 floatingPointLiteral
-                 ::=  digit {digit} ‘.’ digit {digit} [exponentPart] [floatType]
-                   |  ‘.’ digit {digit} [exponentPart] [floatType]
-                   |  digit {digit} exponentPart [floatType]
-                   |  digit {digit} [exponentPart] floatType
-exponentPart     ::=  (‘E’ | ‘e’) [‘+’ | ‘-’] digit {digit}
+                 ::=  [decimalNumeral] ‘.’ digit [{digit | ‘_’} digit] [exponentPart] [floatType]
+                   |  decimalNumeral exponentPart [floatType]
+                   |  decimalNumeral floatType
+exponentPart     ::=  (‘E’ | ‘e’) [‘+’ | ‘-’] digit [{digit | ‘_’} digit]
 floatType        ::=  ‘F’ | ‘f’ | ‘D’ | ‘d’
 
 booleanLiteral   ::=  ‘true’ | ‘false’
@@ -74,10 +79,6 @@ escape           ::=  ‘\$\$’
                    |  ‘\$"’
                    |  ‘\$’ alphaid
                    |  ‘\$’ BlockExpr
-alphaid          ::=  upper idrest
-                   |  varid
-
-symbolLiteral    ::=  ‘'’ plainid
 
 comment          ::=  ‘/*’ “any sequence of characters; nested comments are allowed” ‘*/’
                    |  ‘//’ “any sequence of characters up to end of line”
diff --git a/docs/_spec/TODOreference/syntax.md b/docs/_spec/TODOreference/syntax.md
index 96d88dc5932a..c92bc2532e87 100644
--- a/docs/_spec/TODOreference/syntax.md
+++ b/docs/_spec/TODOreference/syntax.md
@@ -18,6 +18,8 @@ productions map to AST nodes.
 
 -->
 
+<!-- Lexical syntax already merged into _spec. -->
+<!--
 The following description of Scala tokens uses literal characters `‘c’` when
 referring to the ASCII fragment `\u0000` – `\u007F`.
 
@@ -84,10 +86,10 @@ stringElement    ::=  printableChar \ (‘"’ | ‘\’)
                    |  UnicodeEscape
                    |  charEscapeSeq
 multiLineChars   ::=  {[‘"’] [‘"’] char \ ‘"’} {‘"’}
-processedStringLiteral
-                 ::=  alphaid ‘"’ {[‘\’] processedStringPart | ‘\\’ | ‘\"’} ‘"’
+interpolatedStringLiteral
+                 ::=  alphaid ‘"’ {[‘\’] interpolatedStringPart | ‘\\’ | ‘\"’} ‘"’
                    |  alphaid ‘"""’ {[‘"’] [‘"’] char \ (‘"’ | ‘$’) | escape} {‘"’} ‘"""’
-processedStringPart
+interpolatedStringPart
                  ::= printableChar \ (‘"’ | ‘$’ | ‘\’) | escape
 escape           ::=  ‘$$’
                    |  ‘$’ letter { letter | digit }
@@ -102,6 +104,7 @@ comment          ::=  ‘/*’ “any sequence of characters; nested comments ar
 nl               ::=  “new line character”
 semi             ::=  ‘;’ |  nl {nl}
 ```
+-->
 
 ## Optional Braces
 
@@ -163,7 +166,7 @@ SimpleLiteral     ::=  [‘-’] integerLiteral
                     |  characterLiteral
                     |  stringLiteral
 Literal           ::=  SimpleLiteral
-                    |  processedStringLiteral
+                    |  interpolatedStringLiteral
                     |  symbolLiteral
                     |  ‘null’
 

From 45900c44f16fd8ffb9e250dbf4b42589a2133418 Mon Sep 17 00:00:00 2001
From: Guillaume Martres <smarter@ubuntu.com>
Date: Fri, 28 Apr 2023 12:21:40 +0200
Subject: [PATCH 467/657] Port most of syntax.md except context-free syntax
 section.

---
 docs/_spec/01-lexical-syntax.md    | 56 +++++++++++++++++++++---------
 docs/_spec/TODOreference/syntax.md |  5 +--
 2 files changed, 43 insertions(+), 18 deletions(-)

diff --git a/docs/_spec/01-lexical-syntax.md b/docs/_spec/01-lexical-syntax.md
index b042fab2e984..de11de10402f 100644
--- a/docs/_spec/01-lexical-syntax.md
+++ b/docs/_spec/01-lexical-syntax.md
@@ -20,6 +20,28 @@ To construct tokens, characters are distinguished according to the following cla
 1. Delimiter characters ``‘`’ | ‘'’ | ‘"’ | ‘.’ | ‘;’ | ‘,’ ``.
 1. Operator characters. These consist of all printable ASCII characters (`\u0020` - `\u007E`) that are in none of the sets above, mathematical symbols (`Sm`) and other symbols (`So`).
 
+## Optional Braces
+
+The principle of optional braces is that any keyword that can be followed by `{` can also be followed by an indented block, without needing an intervening `:`.
+(Allowing an optional `:` would be counterproductive since it would introduce several ways to do the same thing.)
+
+The lexical analyzer inserts `indent` and `outdent` tokens that represent regions of indented code [at certain points](./other-new-features/indentation.md).
+
+´\color{red}{\text{TODO SCALA3: Port soft-modifier.md and link it here.}}´
+
+In the context-free productions below we use the notation `<<< ts >>>` to indicate a token sequence `ts` that is either enclosed in a pair of braces `{ ts }` or that constitutes an indented region `indent ts outdent`.
+Analogously, the notation `:<<< ts >>>` indicates a token sequence `ts` that is either enclosed in a pair of braces `{ ts }` or that constitutes an indented region `indent ts outdent` that follows a `colon` token.
+
+A `colon` token reads as the standard colon "`:`" but is generated instead of it where `colon` is legal according to the context free syntax, but only if the previous token is an alphanumeric identifier, a backticked identifier, or one of the tokens `this`, `super`, `new`, "`)`", and "`]`".
+
+```
+colon         ::=  ':'    -- with side conditions explained above
+ <<< ts >>>   ::=  ‘{’ ts ‘}’
+                |  indent ts outdent
+:<<< ts >>>   ::=  [nl] ‘{’ ts ‘}’
+                |  colon indent ts outdent
+```
+
 ## Identifiers
 
 ```ebnf
@@ -80,28 +102,30 @@ Some examples of constant identifiers are
 The ‘$’ character is reserved for compiler-synthesized identifiers.
 User programs should not define identifiers that contain ‘$’ characters.
 
+### Regular keywords
+
 The following names are reserved words instead of being members of the syntactic class `id` of lexical identifiers.
 
 ```scala
-abstract    case        catch       class       def
-do          else        extends     false       final
-finally     for         forSome     if          implicit
-import      lazy        macro       match       new
-null        object      override    package     private
-protected   return      sealed      super       this
-throw       trait       try         true        type
-val         var         while       with        yield
-_    :    =    =>    <-    <:    <%     >:    #    @
+abstract  case      catch     class     def       do        else
+enum      export    extends   false     final     finally   for
+given     if        implicit  import    lazy      match     new
+null      object    override  package   private   protected return
+sealed    super     then      throw     trait     true      try
+type      val       var       while     with      yield
+:         =         <-        =>        <:        >:        #
+@         =>>       ?=>
 ```
 
-The Unicode operators `\u21D2` ‘´\Rightarrow´’ and `\u2190` ‘´\leftarrow´’, which have the ASCII equivalents `=>` and `<-`, are also reserved.
+### Soft keywords
 
-> Here are examples of identifiers:
-> ```scala
->     x         Object        maxIndex   p2p      empty_?
->     +         `yield`       αρετη     _y       dot_product_*
->     __system  _MAX_LEN_
-> ```
+Additionally, the following soft keywords are reserved only in some situations.
+
+´\color{red}{\text{TODO SCALA3: Port soft-modifier.md and link it here.}}´
+
+```
+as  derives  end  extension  infix  inline  opaque  open  transparent  using  |  *  +  -
+```
 
 <!-- -->
 
diff --git a/docs/_spec/TODOreference/syntax.md b/docs/_spec/TODOreference/syntax.md
index c92bc2532e87..bfffb8c4a618 100644
--- a/docs/_spec/TODOreference/syntax.md
+++ b/docs/_spec/TODOreference/syntax.md
@@ -18,7 +18,7 @@ productions map to AST nodes.
 
 -->
 
-<!-- Lexical syntax already merged into _spec. -->
+<!-- Everything but "Context-free Syntax" already merged into _spec. -->
 <!--
 The following description of Scala tokens uses literal characters `‘c’` when
 referring to the ASCII fragment `\u0000` – `\u007F`.
@@ -104,7 +104,6 @@ comment          ::=  ‘/*’ “any sequence of characters; nested comments ar
 nl               ::=  “new line character”
 semi             ::=  ‘;’ |  nl {nl}
 ```
--->
 
 ## Optional Braces
 
@@ -153,6 +152,8 @@ as  derives  end  extension  infix  inline  opaque  open  transparent  using  |
 See the [separate section on soft keywords](./soft-modifier.md) for additional
 details on where a soft keyword is recognized.
 
+-->
+
 ## Context-free Syntax
 
 The context-free syntax of Scala is given by the following EBNF

From 410ee0a98dc7abefe2564a953a3d0789a84305fe Mon Sep 17 00:00:00 2001
From: Guillaume Martres <smarter@ubuntu.com>
Date: Fri, 28 Apr 2023 13:24:41 +0200
Subject: [PATCH 468/657] Port context-free syntax.

---
 docs/_spec/13-syntax-summary.md               | 315 +++++-------------
 .../syntax.md                                 |   4 -
 2 files changed, 80 insertions(+), 239 deletions(-)
 rename docs/_spec/{TODOreference => APPLIEDreference}/syntax.md (99%)

diff --git a/docs/_spec/13-syntax-summary.md b/docs/_spec/13-syntax-summary.md
index 3de2298788b7..d16ff538441c 100644
--- a/docs/_spec/13-syntax-summary.md
+++ b/docs/_spec/13-syntax-summary.md
@@ -89,242 +89,87 @@ semi             ::=  ‘;’ |  nl {nl}
 
 ## Context-free Syntax
 
+´\color{red}{\text{TODO SCALA3: Once we're done porting the spec, make sure that
+the references to grammar productions in the rest of the spec match this.}}´
+
 The context-free syntax of Scala is given by the following EBNF grammar:
 
 ```ebnf
-  Literal           ::=  [‘-’] integerLiteral
-                      |  [‘-’] floatingPointLiteral
-                      |  booleanLiteral
-                      |  characterLiteral
-                      |  stringLiteral
-                      |  interpolatedString
-                      |  symbolLiteral
-                      |  ‘null’
-
-  QualId            ::=  id {‘.’ id}
-  ids               ::=  id {‘,’ id}
-
-  Path              ::=  StableId
-                      |  [id ‘.’] ‘this’
-  StableId          ::=  id
-                      |  Path ‘.’ id
-                      |  [id ‘.’] ‘super’ [ClassQualifier] ‘.’ id
-  ClassQualifier    ::=  ‘[’ id ‘]’
-
-  Type              ::=  FunctionArgTypes ‘=>’ Type
-                      |  InfixType [ExistentialClause]
-  FunctionArgTypes  ::= InfixType
-                      | ‘(’ [ ParamType {‘,’ ParamType } ] ‘)’
-  ExistentialClause ::=  ‘forSome’ ‘{’ ExistentialDcl {semi ExistentialDcl} ‘}’
-  ExistentialDcl    ::=  ‘type’ TypeDcl
-                      |  ‘val’ ValDcl
-  InfixType         ::=  CompoundType {id [nl] CompoundType}
-  CompoundType      ::=  AnnotType {‘with’ AnnotType} [Refinement]
-                      |  Refinement
-  AnnotType         ::=  SimpleType {Annotation}
-  SimpleType        ::=  SimpleType TypeArgs
-                      |  SimpleType ‘#’ id
-                      |  StableId
-                      |  Path ‘.’ ‘type’
-                      |  ‘(’ Types ‘)’
-  TypeArgs          ::=  ‘[’ Types ‘]’
-  Types             ::=  Type {‘,’ Type}
-  Refinement        ::=  [nl] ‘{’ RefineStat {semi RefineStat} ‘}’
-  RefineStat        ::=  Dcl
-                      |  ‘type’ TypeDef
-                      |
-  TypePat           ::=  Type
-
-  Ascription        ::=  ‘:’ InfixType
-                      |  ‘:’ Annotation {Annotation}
-                      |  ‘:’ ‘_’ ‘*’
-
-  Expr              ::=  (Bindings | [‘implicit’] id | ‘_’) ‘=>’ Expr
-                      |  Expr1
-  Expr1             ::=  ‘if’ ‘(’ Expr ‘)’ {nl} Expr [[semi] ‘else’ Expr]
-                      |  ‘while’ ‘(’ Expr ‘)’ {nl} Expr
-                      |  ‘try’ Expr [‘catch’ Expr] [‘finally’ Expr]
-                      |  ‘do’ Expr [semi] ‘while’ ‘(’ Expr ‘)’
-                      |  ‘for’ (‘(’ Enumerators ‘)’ | ‘{’ Enumerators ‘}’) {nl} [‘yield’] Expr
-                      |  ‘throw’ Expr
-                      |  ‘return’ [Expr]
-                      |  [SimpleExpr ‘.’] id ‘=’ Expr
-                      |  PrefixOperator SimpleExpr ‘=’ Expr
-                      |  SimpleExpr1 ArgumentExprs ‘=’ Expr
-                      |  PostfixExpr
-                      |  PostfixExpr Ascription
-                      |  PostfixExpr ‘match’ ‘{’ CaseClauses ‘}’
-  PostfixExpr       ::=  InfixExpr [id [nl]]
-  InfixExpr         ::=  PrefixExpr
-                      |  InfixExpr id [nl] InfixExpr
-  PrefixExpr        ::=  [PrefixOperator] SimpleExpr
-  PrefixOperator    ::=  ‘-’ | ‘+’ | ‘~’ | ‘!’
-  SimpleExpr        ::=  ‘new’ (ClassTemplate | TemplateBody)
-                      |  BlockExpr
-                      |  SimpleExpr1 [‘_’]
-  SimpleExpr1       ::=  Literal
-                      |  Path
-                      |  ‘_’
-                      |  ‘(’ [Exprs] ‘)’
-                      |  SimpleExpr ‘.’ id
-                      |  SimpleExpr TypeArgs
-                      |  SimpleExpr1 ArgumentExprs
-                      |  XmlExpr
-  Exprs             ::=  Expr {‘,’ Expr}
-  ArgumentExprs     ::=  ‘(’ [Exprs] ‘)’
-                      |  ‘(’ [Exprs ‘,’] PostfixExpr ‘:’ ‘_’ ‘*’ ‘)’
-                      |  [nl] BlockExpr
-  BlockExpr         ::=  ‘{’ CaseClauses ‘}’
-                      |  ‘{’ Block ‘}’
-  Block             ::=  BlockStat {semi BlockStat} [ResultExpr]
-  BlockStat         ::=  Import
-                      |  {Annotation} [‘implicit’] [‘lazy’] Def
-                      |  {Annotation} {LocalModifier} TmplDef
-                      |  Expr1
-                      |
-  ResultExpr        ::=  Expr1
-                      |  (Bindings | ([‘implicit’] id | ‘_’) ‘:’ CompoundType) ‘=>’ Block
-
-  Enumerators       ::=  Generator {semi Generator}
-  Generator         ::=  [‘case’] Pattern1 ‘<-’ Expr {[semi] Guard | semi Pattern1 ‘=’ Expr}
-
-  CaseClauses       ::=  CaseClause { CaseClause }
-  CaseClause        ::=  ‘case’ Pattern [Guard] ‘=>’ Block
-  Guard             ::=  ‘if’ PostfixExpr
-
-  Pattern           ::=  Pattern1 { ‘|’ Pattern1 }
-  Pattern1          ::=  boundvarid ‘:’ TypePat
-                      |  ‘_’ ‘:’ TypePat
-                      |  Pattern2
-  Pattern2          ::=  id [‘@’ Pattern3]
-                      |  Pattern3
-  Pattern3          ::=  SimplePattern
-                      |  SimplePattern { id [nl] SimplePattern }
-  SimplePattern     ::=  ‘_’
-                      |  varid
-                      |  Literal
-                      |  StableId
-                      |  StableId ‘(’ [Patterns] ‘)’
-                      |  StableId ‘(’ [Patterns ‘,’] [id ‘@’] ‘_’ ‘*’ ‘)’
-                      |  ‘(’ [Patterns] ‘)’
-                      |  XmlPattern
-  Patterns          ::=  Pattern [‘,’ Patterns]
-                      |  ‘_’ ‘*’
-
-  TypeParamClause   ::=  ‘[’ VariantTypeParam {‘,’ VariantTypeParam} ‘]’
-  FunTypeParamClause::=  ‘[’ TypeParam {‘,’ TypeParam} ‘]’
-  VariantTypeParam  ::=  {Annotation} [‘+’ | ‘-’] TypeParam
-  TypeParam         ::=  (id | ‘_’) [TypeParamClause] [‘>:’ Type] [‘<:’ Type]
-                         {‘<%’ Type} {‘:’ Type}
-  ParamClauses      ::=  {ParamClause} [[nl] ‘(’ ‘implicit’ Params ‘)’]
-  ParamClause       ::=  [nl] ‘(’ [Params] ‘)’
-  Params            ::=  Param {‘,’ Param}
-  Param             ::=  {Annotation} id [‘:’ ParamType] [‘=’ Expr]
-  ParamType         ::=  Type
-                      |  ‘=>’ Type
-                      |  Type ‘*’
-  ClassParamClauses ::=  {ClassParamClause}
-                         [[nl] ‘(’ ‘implicit’ ClassParams ‘)’]
-  ClassParamClause  ::=  [nl] ‘(’ [ClassParams] ‘)’
-  ClassParams       ::=  ClassParam {‘,’ ClassParam}
-  ClassParam        ::=  {Annotation} {Modifier} [(‘val’ | ‘var’)]
-                         id ‘:’ ParamType [‘=’ Expr]
-  Bindings          ::=  ‘(’ Binding {‘,’ Binding} ‘)’
-  Binding           ::=  (id | ‘_’) [‘:’ Type]
-
-  Modifier          ::=  LocalModifier
-                      |  AccessModifier
-                      |  ‘override’
-  LocalModifier     ::=  ‘abstract’
-                      |  ‘final’
-                      |  ‘sealed’
-                      |  ‘implicit’
-                      |  ‘lazy’
-  AccessModifier    ::=  (‘private’ | ‘protected’) [AccessQualifier]
-  AccessQualifier   ::=  ‘[’ (id | ‘this’) ‘]’
-
-  Annotation        ::=  ‘@’ SimpleType {ArgumentExprs}
-  ConstrAnnotation  ::=  ‘@’ SimpleType ArgumentExprs
-
-  TemplateBody      ::=  [nl] ‘{’ [SelfType] TemplateStat {semi TemplateStat} ‘}’
-  TemplateStat      ::=  Import
-                      |  {Annotation [nl]} {Modifier} Def
-                      |  {Annotation [nl]} {Modifier} Dcl
-                      |  Expr
-                      |
-  SelfType          ::=  id [‘:’ Type] ‘=>’
-                      |  ‘this’ ‘:’ Type ‘=>’
-
-  Import            ::=  ‘import’ ImportExpr {‘,’ ImportExpr}
-  ImportExpr        ::=  StableId ‘.’ (id | ‘_’ | ImportSelectors)
-  ImportSelectors   ::=  ‘{’ {ImportSelector ‘,’} (ImportSelector | ‘_’) ‘}’
-  ImportSelector    ::=  id [‘=>’ id | ‘=>’ ‘_’]
-
-  Dcl               ::=  ‘val’ ValDcl
-                      |  ‘var’ VarDcl
-                      |  ‘def’ FunDcl
-                      |  ‘type’ {nl} TypeDcl
-
-  ValDcl            ::=  ids ‘:’ Type
-  VarDcl            ::=  ids ‘:’ Type
-  FunDcl            ::=  FunSig [‘:’ Type]
-  FunSig            ::=  id [FunTypeParamClause] ParamClauses
-  TypeDcl           ::=  id [TypeParamClause] [‘>:’ Type] [‘<:’ Type]
-
-  PatVarDef         ::=  ‘val’ PatDef
-                      |  ‘var’ VarDef
-  Def               ::=  PatVarDef
-                      |  ‘def’ FunDef
-                      |  ‘type’ {nl} TypeDef
-                      |  TmplDef
-  PatDef            ::=  Pattern2 {‘,’ Pattern2} [‘:’ Type] ‘=’ Expr
-  VarDef            ::=  PatDef
-                      |  ids ‘:’ Type ‘=’ ‘_’
-  FunDef            ::=  FunSig [‘:’ Type] ‘=’ Expr
-                      |  FunSig [nl] ‘{’ Block ‘}’
-                      |  ‘this’ ParamClause ParamClauses
-                         (‘=’ ConstrExpr | [nl] ConstrBlock)
-  TypeDef           ::=  id [TypeParamClause] ‘=’ Type
-
-  TmplDef           ::=  [‘case’] ‘class’ ClassDef
-                      |  [‘case’] ‘object’ ObjectDef
-                      |  ‘trait’ TraitDef
-  ClassDef          ::=  id [TypeParamClause] {ConstrAnnotation} [AccessModifier]
-                         ClassParamClauses ClassTemplateOpt
-  TraitDef          ::=  id [TypeParamClause] TraitTemplateOpt
-  ObjectDef         ::=  id ClassTemplateOpt
-  ClassTemplateOpt  ::=  ‘extends’ ClassTemplate | [[‘extends’] TemplateBody]
-  TraitTemplateOpt  ::=  ‘extends’ TraitTemplate | [[‘extends’] TemplateBody]
-  ClassTemplate     ::=  [EarlyDefs] ClassParents [TemplateBody]
-  TraitTemplate     ::=  [EarlyDefs] TraitParents [TemplateBody]
-  ClassParents      ::=  Constr {‘with’ AnnotType}
-  TraitParents      ::=  AnnotType {‘with’ AnnotType}
-  Constr            ::=  AnnotType {ArgumentExprs}
-  EarlyDefs         ::=  ‘{’ [EarlyDef {semi EarlyDef}] ‘}’ ‘with’
-  EarlyDef          ::=  {Annotation [nl]} {Modifier} PatVarDef
-
-  ConstrExpr        ::=  SelfInvocation
-                      |  ConstrBlock
-  ConstrBlock       ::=  ‘{’ SelfInvocation {semi BlockStat} ‘}’
-  SelfInvocation    ::=  ‘this’ ArgumentExprs {ArgumentExprs}
-
-  TopStatSeq        ::=  TopStat {semi TopStat}
-  TopStat           ::=  {Annotation [nl]} {Modifier} TmplDef
-                      |  Import
-                      |  Packaging
-                      |  PackageObject
-                      |
-  Packaging         ::=  ‘package’ QualId [nl] ‘{’ TopStatSeq ‘}’
-  PackageObject     ::=  ‘package’ ‘object’ ObjectDef
-
-  CompilationUnit   ::=  {‘package’ QualId semi} TopStatSeq
+RefineDcl         ::=  ‘val’ ValDcl
+                    |  ‘def’ DefDcl
+                    |  ‘type’ {nl} TypeDcl
+Dcl               ::=  RefineDcl
+                    |  ‘var’ VarDcl
+ValDcl            ::=  ids ‘:’ Type
+VarDcl            ::=  ids ‘:’ Type
+DefDcl            ::=  DefSig ‘:’ Type
+DefSig            ::=  id [DefTypeParamClause] [TypelessClauses] [DefImplicitClause]
+TypeDcl           ::=  id [TypeParamClause] {FunParamClause} TypeBounds
+
+Def               ::=  ‘val’ PatDef
+                    |  ‘var’ PatDef
+                    |  ‘def’ DefDef
+                    |  ‘type’ {nl} TypeDcl
+                    |  TmplDef
+PatDef            ::=  ids [‘:’ Type] ‘=’ Expr
+                    |  Pattern2 [‘:’ Type] ‘=’ Expr
+DefDef            ::=  DefSig [‘:’ Type] ‘=’ Expr
+                    |  ‘this’ TypelessClauses [DefImplicitClause] ‘=’ ConstrExpr
+
+TmplDef           ::=  ([‘case’] ‘class’ | ‘trait’) ClassDef
+                    |  [‘case’] ‘object’ ObjectDef
+                    |  ‘enum’ EnumDef
+                    |  ‘given’ GivenDef
+ClassDef          ::=  id ClassConstr [Template]
+ClassConstr       ::=  [ClsTypeParamClause] [ConstrMods] ClsParamClauses
+ConstrMods        ::=  {Annotation} [AccessModifier]
+ObjectDef         ::=  id [Template]
+EnumDef           ::=  id ClassConstr InheritClauses EnumBody
+GivenDef          ::=  [GivenSig] (AnnotType [‘=’ Expr] | StructuralInstance)
+GivenSig          ::=  [id] [DefTypeParamClause] {UsingParamClause} ‘:’         -- one of `id`, `DefTypeParamClause`, `UsingParamClause` must be present
+StructuralInstance ::=  ConstrApp {‘with’ ConstrApp} [‘with’ WithTemplateBody]
+Extension         ::=  ‘extension’ [DefTypeParamClause] {UsingParamClause}
+                       ‘(’ DefTermParam ‘)’ {UsingParamClause} ExtMethods
+ExtMethods        ::=  ExtMethod | [nl] <<< ExtMethod {semi ExtMethod} >>>
+ExtMethod         ::=  {Annotation [nl]} {Modifier} ‘def’ DefDef
+                    |  Export
+Template          ::=  InheritClauses [TemplateBody]
+InheritClauses    ::=  [‘extends’ ConstrApps] [‘derives’ QualId {‘,’ QualId}]
+ConstrApps        ::=  ConstrApp ({‘,’ ConstrApp} | {‘with’ ConstrApp})
+ConstrApp         ::=  SimpleType1 {Annotation} {ParArgumentExprs}
+ConstrExpr        ::=  SelfInvocation
+                    |  <<< SelfInvocation {semi BlockStat} >>>
+SelfInvocation    ::=  ‘this’ ArgumentExprs {ArgumentExprs}
+
+WithTemplateBody  ::=  <<< [SelfType] TemplateStat {semi TemplateStat} >>>
+TemplateBody      ::=  :<<< [SelfType] TemplateStat {semi TemplateStat} >>>
+TemplateStat      ::=  Import
+                    |  Export
+                    |  {Annotation [nl]} {Modifier} Def
+                    |  {Annotation [nl]} {Modifier} Dcl
+                    |  Extension
+                    |  Expr1
+                    |  EndMarker
+                    |
+SelfType          ::=  id [‘:’ InfixType] ‘=>’
+                    |  ‘this’ ‘:’ InfixType ‘=>’
+
+EnumBody          ::=  :<<< [SelfType] EnumStat {semi EnumStat} >>>
+EnumStat          ::=  TemplateStat
+                    |  {Annotation [nl]} {Modifier} EnumCase
+EnumCase          ::=  ‘case’ (id ClassConstr [‘extends’ ConstrApps]] | ids)
+
+TopStats          ::=  TopStat {semi TopStat}
+TopStat           ::=  Import
+                    |  Export
+                    |  {Annotation [nl]} {Modifier} Def
+                    |  Extension
+                    |  Packaging
+                    |  PackageObject
+                    |  EndMarker
+                    |
+Packaging         ::=  ‘package’ QualId :<<< TopStats >>>
+PackageObject     ::=  ‘package’ ‘object’ ObjectDef
+
+CompilationUnit   ::=  {‘package’ QualId semi} TopStats
 ```
-
-<!-- TODO add:
-SeqPattern ::= ...
-
-SimplePattern    ::= StableId  [TypePatArgs] [‘(’ [SeqPatterns] ‘)’]
-TypePatArgs ::= ‘[’ TypePatArg {‘,’ TypePatArg} ‘]’
-TypePatArg    ::=  ‘_’ |   varid}
-
--->
diff --git a/docs/_spec/TODOreference/syntax.md b/docs/_spec/APPLIEDreference/syntax.md
similarity index 99%
rename from docs/_spec/TODOreference/syntax.md
rename to docs/_spec/APPLIEDreference/syntax.md
index bfffb8c4a618..0a2fad157566 100644
--- a/docs/_spec/TODOreference/syntax.md
+++ b/docs/_spec/APPLIEDreference/syntax.md
@@ -18,8 +18,6 @@ productions map to AST nodes.
 
 -->
 
-<!-- Everything but "Context-free Syntax" already merged into _spec. -->
-<!--
 The following description of Scala tokens uses literal characters `‘c’` when
 referring to the ASCII fragment `\u0000` – `\u007F`.
 
@@ -152,8 +150,6 @@ as  derives  end  extension  infix  inline  opaque  open  transparent  using  |
 See the [separate section on soft keywords](./soft-modifier.md) for additional
 details on where a soft keyword is recognized.
 
--->
-
 ## Context-free Syntax
 
 The context-free syntax of Scala is given by the following EBNF

From 2e2a55e986a457ca3111605669f6cefc1dd0d20d Mon Sep 17 00:00:00 2001
From: Guillaume Martres <smarter@ubuntu.com>
Date: Fri, 28 Apr 2023 13:26:39 +0200
Subject: [PATCH 469/657] Context-free syntax refers to the weird optional
 brace meta-syntax

Copied from 01-lexical-syntax.md
---
 docs/_spec/13-syntax-summary.md | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/docs/_spec/13-syntax-summary.md b/docs/_spec/13-syntax-summary.md
index d16ff538441c..2dc971fc9840 100644
--- a/docs/_spec/13-syntax-summary.md
+++ b/docs/_spec/13-syntax-summary.md
@@ -87,6 +87,16 @@ nl               ::=  ´\mathit{“new line character”}´
 semi             ::=  ‘;’ |  nl {nl}
 ```
 
+## Optional Braces
+
+```
+colon         ::=  ':'    -- with side conditions explained in 01-literal-syntax.md
+ <<< ts >>>   ::=  ‘{’ ts ‘}’
+                |  indent ts outdent
+:<<< ts >>>   ::=  [nl] ‘{’ ts ‘}’
+                |  colon indent ts outdent
+```
+
 ## Context-free Syntax
 
 ´\color{red}{\text{TODO SCALA3: Once we're done porting the spec, make sure that

From 645e149b82a1956a4e974501695897333d3d2747 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Doeraene?= <sjrdoeraene@gmail.com>
Date: Mon, 1 May 2023 14:15:55 +0200
Subject: [PATCH 470/657] Remove APPLIEDreference/syntax.md, as the syntax now
 lives in the spec.

---
 docs/_spec/APPLIEDreference/syntax.md | 488 --------------------------
 1 file changed, 488 deletions(-)
 delete mode 100644 docs/_spec/APPLIEDreference/syntax.md

diff --git a/docs/_spec/APPLIEDreference/syntax.md b/docs/_spec/APPLIEDreference/syntax.md
deleted file mode 100644
index 0a2fad157566..000000000000
--- a/docs/_spec/APPLIEDreference/syntax.md
+++ /dev/null
@@ -1,488 +0,0 @@
----
-layout: doc-page
-title: "Scala 3 Syntax Summary"
-nightlyOf: https://docs.scala-lang.org/scala3/reference/syntax.html
----
-
-<!--
-
-This page has a companion page at _docs/internals/syntax.md.
-
-!! Make sure to edit both pages in sync. !!
-
-reference/syntax.md shows the official Scala 3 syntax, without deprecated or experimental features.
-
-internals/syntax.md shows the Scala 3 syntax as supported by the parser, including
-deprecated and experimental features. It also gives some indications how
-productions map to AST nodes.
-
--->
-
-The following description of Scala tokens uses literal characters `‘c’` when
-referring to the ASCII fragment `\u0000` – `\u007F`.
-
-_Unicode escapes_ are used to represent the [Unicode character](https://www.w3.org/International/articles/definitions-characters/) with the given
-hexadecimal code:
-
-```
-UnicodeEscape ::= ‘\’ ‘u’ {‘u’} hexDigit hexDigit hexDigit hexDigit
-hexDigit      ::= ‘0’ | ... | ‘9’ | ‘A’ | ... | ‘F’ | ‘a’ | ... | ‘f’
-```
-
-Informal descriptions are typeset as `“some comment”`.
-
-## Lexical Syntax
-
-The lexical syntax of Scala is given by the following grammar in EBNF
-form.
-
-```
-whiteSpace       ::=  ‘\u0020’ | ‘\u0009’ | ‘\u000D’ | ‘\u000A’
-upper            ::=  ‘A’ | ... | ‘Z’ | ‘\$’ | ‘_’  “... and Unicode category Lu”
-lower            ::=  ‘a’ | ... | ‘z’ “... and Unicode category Ll”
-letter           ::=  upper | lower “... and Unicode categories Lo, Lt, Nl”
-digit            ::=  ‘0’ | ... | ‘9’
-paren            ::=  ‘(’ | ‘)’ | ‘[’ | ‘]’ | ‘{’ | ‘}’
-delim            ::=  ‘`’ | ‘'’ | ‘"’ | ‘.’ | ‘;’ | ‘,’
-opchar           ::=  ‘!’ | ‘#’ | ‘%’ | ‘&’ | ‘*’ | ‘+’ | ‘-’ | ‘/’ | ‘:’ |
-                      ‘<’ | ‘=’ | ‘>’ | ‘?’ | ‘@’ | ‘\’ | ‘^’ | ‘|’ | ‘~’
-                      “... and Unicode categories Sm, So”
-printableChar    ::=  “all characters in [\u0020, \u007E] inclusive”
-charEscapeSeq    ::=  ‘\’ (‘b’ | ‘t’ | ‘n’ | ‘f’ | ‘r’ | ‘"’ | ‘'’ | ‘\’)
-
-op               ::=  opchar {opchar}
-varid            ::=  lower idrest
-alphaid          ::=  upper idrest
-                   |  varid
-plainid          ::=  alphaid
-                   |  op
-id               ::=  plainid
-                   |  ‘`’ { charNoBackQuoteOrNewline | UnicodeEscape | charEscapeSeq } ‘`’
-idrest           ::=  {letter | digit} [‘_’ op]
-quoteId          ::=  ‘'’ alphaid
-spliceId         ::=  ‘$’ alphaid ;
-
-integerLiteral   ::=  (decimalNumeral | hexNumeral) [‘L’ | ‘l’]
-decimalNumeral   ::=  ‘0’ | nonZeroDigit [{digit | ‘_’} digit]
-hexNumeral       ::=  ‘0’ (‘x’ | ‘X’) hexDigit [{hexDigit | ‘_’} hexDigit]
-nonZeroDigit     ::=  ‘1’ | ... | ‘9’
-
-floatingPointLiteral
-                 ::=  [decimalNumeral] ‘.’ digit [{digit | ‘_’} digit] [exponentPart] [floatType]
-                   |  decimalNumeral exponentPart [floatType]
-                   |  decimalNumeral floatType
-exponentPart     ::=  (‘E’ | ‘e’) [‘+’ | ‘-’] digit [{digit | ‘_’} digit]
-floatType        ::=  ‘F’ | ‘f’ | ‘D’ | ‘d’
-
-booleanLiteral   ::=  ‘true’ | ‘false’
-
-characterLiteral ::=  ‘'’ (printableChar | charEscapeSeq) ‘'’
-
-stringLiteral    ::=  ‘"’ {stringElement} ‘"’
-                   |  ‘"""’ multiLineChars ‘"""’
-stringElement    ::=  printableChar \ (‘"’ | ‘\’)
-                   |  UnicodeEscape
-                   |  charEscapeSeq
-multiLineChars   ::=  {[‘"’] [‘"’] char \ ‘"’} {‘"’}
-interpolatedStringLiteral
-                 ::=  alphaid ‘"’ {[‘\’] interpolatedStringPart | ‘\\’ | ‘\"’} ‘"’
-                   |  alphaid ‘"""’ {[‘"’] [‘"’] char \ (‘"’ | ‘$’) | escape} {‘"’} ‘"""’
-interpolatedStringPart
-                 ::= printableChar \ (‘"’ | ‘$’ | ‘\’) | escape
-escape           ::=  ‘$$’
-                   |  ‘$’ letter { letter | digit }
-                   |  ‘{’ Block  [‘;’ whiteSpace stringFormat whiteSpace] ‘}’
-stringFormat     ::=  {printableChar \ (‘"’ | ‘}’ | ‘ ’ | ‘\t’ | ‘\n’)}
-
-symbolLiteral    ::=  ‘'’ plainid // until 2.13
-
-comment          ::=  ‘/*’ “any sequence of characters; nested comments are allowed” ‘*/’
-                   |  ‘//’ “any sequence of characters up to end of line”
-
-nl               ::=  “new line character”
-semi             ::=  ‘;’ |  nl {nl}
-```
-
-## Optional Braces
-
-The principle of optional braces is that any keyword that can be followed by `{` can also be followed by an indented block, without needing an intervening `:`.
-(Allowing an optional `:` would be counterproductive since it would introduce several ways to do the same thing.)
-
-The lexical analyzer inserts `indent` and `outdent` tokens that represent regions of indented code [at certain points](./other-new-features/indentation.md).
-
-In the context-free productions below we use the notation `<<< ts >>>`
-to indicate a token sequence `ts` that is either enclosed in a pair of braces `{ ts }` or that constitutes an indented region `indent ts outdent`. Analogously, the
-notation `:<<< ts >>>` indicates a token sequence `ts` that is either enclosed in a pair of braces `{ ts }` or that constitutes an indented region `indent ts outdent` that follows
-a `colon` token.
-
-A `colon` token reads as the standard colon "`:`" but is generated instead of it where `colon` is legal according to the context free syntax, but only if the previous token
-is an alphanumeric identifier, a backticked identifier, or one of the tokens `this`, `super`, `new`, "`)`", and "`]`".
-
-```
-colon         ::=  ':'    -- with side conditions explained above
- <<< ts >>>   ::=  ‘{’ ts ‘}’
-                |  indent ts outdent
-:<<< ts >>>   ::=  [nl] ‘{’ ts ‘}’
-                |  colon indent ts outdent
-```
-
-## Keywords
-
-### Regular keywords
-
-```
-abstract  case      catch     class     def       do        else
-enum      export    extends   false     final     finally   for
-given     if        implicit  import    lazy      match     new
-null      object    override  package   private   protected return
-sealed    super     then      throw     trait     true      try
-type      val       var       while     with      yield
-:         =         <-        =>        <:        >:        #
-@         =>>       ?=>
-```
-
-### Soft keywords
-
-```
-as  derives  end  extension  infix  inline  opaque  open  transparent  using  |  *  +  -
-```
-
-See the [separate section on soft keywords](./soft-modifier.md) for additional
-details on where a soft keyword is recognized.
-
-## Context-free Syntax
-
-The context-free syntax of Scala is given by the following EBNF
-grammar:
-
-### Literals and Paths
-```
-SimpleLiteral     ::=  [‘-’] integerLiteral
-                    |  [‘-’] floatingPointLiteral
-                    |  booleanLiteral
-                    |  characterLiteral
-                    |  stringLiteral
-Literal           ::=  SimpleLiteral
-                    |  interpolatedStringLiteral
-                    |  symbolLiteral
-                    |  ‘null’
-
-QualId            ::=  id {‘.’ id}
-ids               ::=  id {‘,’ id}
-
-SimpleRef         ::=  id
-                    |  [id ‘.’] ‘this’
-                    |  [id ‘.’] ‘super’ [ClassQualifier] ‘.’ id
-
-ClassQualifier    ::=  ‘[’ id ‘]’
-```
-
-### Types
-```
-Type              ::=  FunType
-                    |  HkTypeParamClause ‘=>>’ Type
-                    |  FunParamClause ‘=>>’ Type
-                    |  MatchType
-                    |  InfixType
-FunType           ::=  FunTypeArgs (‘=>’ | ‘?=>’) Type
-                    |  HKTypeParamClause '=>' Type
-FunTypeArgs       ::=  InfixType
-                    |  ‘(’ [ FunArgTypes ] ‘)’
-                    |  FunParamClause
-FunParamClause    ::=  ‘(’ TypedFunParam {‘,’ TypedFunParam } ‘)’
-TypedFunParam     ::=  id ‘:’ Type
-MatchType         ::=  InfixType `match` <<< TypeCaseClauses >>>
-InfixType         ::=  RefinedType {id [nl] RefinedType}
-RefinedType       ::=  AnnotType {[nl] Refinement}
-AnnotType         ::=  SimpleType {Annotation}
-
-SimpleType        ::=  SimpleLiteral
-                    |  ‘?’ TypeBounds
-                    |  id
-                    |  Singleton ‘.’ id
-                    |  Singleton ‘.’ ‘type’
-                    |  ‘(’ Types ‘)’
-                    |  Refinement
-                    |  SimpleType1 TypeArgs
-                    |  SimpleType1 ‘#’ id
-Singleton         ::=  SimpleRef
-                    |  SimpleLiteral
-                    |  Singleton ‘.’ id
-
-FunArgType        ::=  Type
-                    |  ‘=>’ Type
-FunArgTypes       ::=  FunArgType { ‘,’ FunArgType }
-ParamType         ::=  [‘=>’] ParamValueType
-ParamValueType    ::=  Type [‘*’]
-TypeArgs          ::=  ‘[’ Types ‘]’
-Refinement        ::=  :<<< [RefineDcl] {semi [RefineDcl]} >>>
-TypeBounds        ::=  [‘>:’ Type] [‘<:’ Type]
-TypeParamBounds   ::=  TypeBounds {‘:’ Type}
-Types             ::=  Type {‘,’ Type}
-```
-
-### Expressions
-```
-Expr              ::=  FunParams (‘=>’ | ‘?=>’) Expr
-                    |  HkTypeParamClause ‘=>’ Expr
-                    |  Expr1
-BlockResult       ::=  FunParams (‘=>’ | ‘?=>’) Block
-                    |  HkTypeParamClause ‘=>’ Block
-                    |  Expr1
-FunParams         ::=  Bindings
-                    |  id
-                    |  ‘_’
-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
-                    |  SimpleExpr ArgumentExprs ‘=’ Expr
-                    |  PostfixExpr [Ascription]
-                    |  ‘inline’ InfixExpr MatchClause
-Ascription        ::=  ‘:’ InfixType
-                    |  ‘:’ Annotation {Annotation}
-Catches           ::=  ‘catch’ (Expr | ExprCaseClause)
-PostfixExpr       ::=  InfixExpr [id]                                          -- only if language.postfixOperators is enabled
-InfixExpr         ::=  PrefixExpr
-                    |  InfixExpr id [nl] InfixExpr
-                    |  InfixExpr id ColonArgument
-                    |  InfixExpr MatchClause
-MatchClause       ::=  ‘match’ <<< CaseClauses >>>
-PrefixExpr        ::=  [PrefixOperator] SimpleExpr
-PrefixOperator    ::=  ‘-’ | ‘+’ | ‘~’ | ‘!’                                    -- unless backquoted
-SimpleExpr        ::=  SimpleRef
-                    |  Literal
-                    |  ‘_’
-                    |  BlockExpr
-                    |  ExprSplice
-                    |  Quoted
-                    |  quoteId                                                  -- only inside splices
-                    |  ‘new’ ConstrApp {‘with’ ConstrApp} [TemplateBody]
-                    |  ‘new’ TemplateBody
-                    |  ‘(’ ExprsInParens ‘)’
-                    |  SimpleExpr ‘.’ id
-                    |  SimpleExpr ‘.’ MatchClause
-                    |  SimpleExpr TypeArgs
-                    |  SimpleExpr ArgumentExprs
-                    |  SimpleExpr ColonArgument
-ColonArgument     ::=  colon [LambdaStart]
-                       indent (CaseClauses | Block) outdent
-LambdaStart       ::=  FunParams (‘=>’ | ‘?=>’)
-                    |  HkTypeParamClause ‘=>’
-Quoted            ::=  ‘'’ ‘{’ Block ‘}’
-                    |  ‘'’ ‘[’ Type ‘]’
-ExprSplice        ::= spliceId                                                  -- if inside quoted block
-                    |  ‘$’ ‘{’ Block ‘}’                                        -- unless inside quoted pattern
-                    |  ‘$’ ‘{’ Pattern ‘}’                                      -- when inside quoted pattern
-ExprsInParens     ::=  ExprInParens {‘,’ ExprInParens}
-ExprInParens      ::=  PostfixExpr ‘:’ Type
-                    |  Expr
-ParArgumentExprs  ::=  ‘(’ [ExprsInParens] ‘)’
-                    |  ‘(’ ‘using’ ExprsInParens ‘)’
-                    |  ‘(’ [ExprsInParens ‘,’] PostfixExpr ‘*’ ‘)’
-ArgumentExprs     ::=  ParArgumentExprs
-                    |  BlockExpr
-BlockExpr         ::=  <<< (CaseClauses | Block) >>>
-Block             ::=  {BlockStat semi} [BlockResult]
-BlockStat         ::=  Import
-                    |  {Annotation {nl}} {LocalModifier} Def
-                    |  Extension
-                    |  Expr1
-                    |  EndMarker
-
-ForExpr           ::=  ‘for’ ‘(’ Enumerators0 ‘)’ {nl} [‘do‘ | ‘yield’] Expr
-                    |  ‘for’ ‘{’ Enumerators0 ‘}’ {nl} [‘do‘ | ‘yield’] Expr
-                    |  ‘for’     Enumerators0          (‘do‘ | ‘yield’) Expr
-Enumerators0      ::=  {nl} Enumerators [semi]
-Enumerators       ::=  Generator {semi Enumerator | Guard}
-Enumerator        ::=  Generator
-                    |  Guard {Guard}
-                    |  Pattern1 ‘=’ Expr
-Generator         ::=  [‘case’] Pattern1 ‘<-’ Expr
-Guard             ::=  ‘if’ PostfixExpr
-
-CaseClauses       ::=  CaseClause { CaseClause }
-CaseClause        ::=  ‘case’ Pattern [Guard] ‘=>’ Block
-ExprCaseClause    ::=  ‘case’ Pattern [Guard] ‘=>’ Expr
-TypeCaseClauses   ::=  TypeCaseClause { TypeCaseClause }
-TypeCaseClause    ::=  ‘case’ (InfixType | ‘_’) ‘=>’ Type [semi]
-
-Pattern           ::=  Pattern1 { ‘|’ Pattern1 }
-Pattern1          ::=  PatVar ‘:’ RefinedType
-                    | [‘-’] integerLiteral ‘:’ RefinedType
-                    | [‘-’] floatingPointLiteral ‘:’ RefinedType
-                    |  Pattern2
-Pattern2          ::=  [id ‘@’] InfixPattern [‘*’]
-InfixPattern      ::=  SimplePattern { id [nl] SimplePattern }
-SimplePattern     ::=  PatVar
-                    |  Literal
-                    |  ‘(’ [Patterns] ‘)’
-                    |  Quoted
-                    |  SimplePattern1 [TypeArgs] [ArgumentPatterns]
-                    |  ‘given’ RefinedType
-SimplePattern1    ::=  SimpleRef
-                    |  SimplePattern1 ‘.’ id
-PatVar            ::=  varid
-                    |  ‘_’
-Patterns          ::=  Pattern {‘,’ Pattern}
-ArgumentPatterns  ::=  ‘(’ [Patterns] ‘)’
-                    |  ‘(’ [Patterns ‘,’] PatVar ‘*’ ‘)’
-```
-
-### Type and Value Parameters
-```
-ClsTypeParamClause::=  ‘[’ ClsTypeParam {‘,’ ClsTypeParam} ‘]’
-ClsTypeParam      ::=  {Annotation} [‘+’ | ‘-’] id [HkTypeParamClause] TypeParamBounds
-
-TypTypeParamClause::=  ‘[’ TypTypeParam {‘,’ TypTypeParam} ‘]’
-TypTypeParam      ::=  {Annotation} id [HkTypeParamClause] TypeBounds
-
-HkTypeParamClause ::=  ‘[’ HkTypeParam {‘,’ HkTypeParam} ‘]’
-HkTypeParam       ::=  {Annotation} [‘+’ | ‘-’] (id [HkTypeParamClause] | ‘_’) TypeBounds
-
-ClsParamClauses   ::=  {ClsParamClause} [[nl] ‘(’ [‘implicit’] ClsParams ‘)’]
-ClsParamClause    ::=  [nl] ‘(’ ClsParams ‘)’
-                    |  [nl] ‘(’ ‘using’ (ClsParams | FunArgTypes) ‘)’
-ClsParams         ::=  ClsParam {‘,’ ClsParam}
-ClsParam          ::=  {Annotation} [{Modifier} (‘val’ | ‘var’) | ‘inline’] Param
-
-TypelessClauses   ::=  TypelessClause {TypelessClause}
-TypelessClause    ::=  DefTermParamClause
-                    |  UsingParamClause
-
-DefTypeParamClause::=  [nl] ‘[’ DefTypeParam {‘,’ DefTypeParam} ‘]’
-DefTypeParam      ::=  {Annotation} id [HkTypeParamClause] TypeParamBounds
-DefTermParamClause::=  [nl] ‘(’ [DefTermParams] ‘)’
-UsingParamClause  ::=  [nl] ‘(’ ‘using’ (DefTermParams | FunArgTypes) ‘)’
-DefImplicitClause ::=  [nl] ‘(’ ‘implicit’ DefTermParams ‘)’
-
-DefTermParams     ::= DefTermParam {‘,’ DefTermParam}
-DefTermParam      ::= {Annotation} [‘inline’] Param
-Param             ::=  id ‘:’ ParamType [‘=’ Expr]
-```
-
-### Bindings and Imports
-```
-Bindings          ::=  ‘(’ [Binding {‘,’ Binding}] ‘)’
-Binding           ::=  (id | ‘_’) [‘:’ Type]
-
-Modifier          ::=  LocalModifier
-                    |  AccessModifier
-                    |  ‘override’
-                    |  ‘opaque’
-LocalModifier     ::=  ‘abstract’
-                    |  ‘final’
-                    |  ‘sealed’
-                    |  ‘open’
-                    |  ‘implicit’
-                    |  ‘lazy’
-                    |  ‘inline’
-AccessModifier    ::=  (‘private’ | ‘protected’) [AccessQualifier]
-AccessQualifier   ::=  ‘[’ id ‘]’
-
-Annotation        ::=  ‘@’ SimpleType1 {ParArgumentExprs}
-
-Import            ::=  ‘import’ ImportExpr {‘,’ ImportExpr}
-Export            ::=  ‘export’ ImportExpr {‘,’ ImportExpr}
-ImportExpr        ::=  SimpleRef {‘.’ id} ‘.’ ImportSpec
-                    |  SimpleRef ‘as’ id
-ImportSpec        ::=  NamedSelector
-                    |  WildcardSelector
-                    | ‘{’ ImportSelectors) ‘}’
-NamedSelector     ::=  id [‘as’ (id | ‘_’)]
-WildCardSelector  ::=  ‘*' | ‘given’ [InfixType]
-ImportSelectors   ::=  NamedSelector [‘,’ ImportSelectors]
-                    |  WildCardSelector {‘,’ WildCardSelector}
-
-EndMarker         ::=  ‘end’ EndMarkerTag    -- when followed by EOL
-EndMarkerTag      ::=  id | ‘if’ | ‘while’ | ‘for’ | ‘match’ | ‘try’
-                    |  ‘new’ | ‘this’ | ‘given’ | ‘extension’ | ‘val’
-```
-
-### Declarations and Definitions
-```
-RefineDcl         ::=  ‘val’ ValDcl
-                    |  ‘def’ DefDcl
-                    |  ‘type’ {nl} TypeDcl
-Dcl               ::=  RefineDcl
-                    |  ‘var’ VarDcl
-ValDcl            ::=  ids ‘:’ Type
-VarDcl            ::=  ids ‘:’ Type
-DefDcl            ::=  DefSig ‘:’ Type
-DefSig            ::=  id [DefTypeParamClause] [TypelessClauses] [DefImplicitClause]
-TypeDcl           ::=  id [TypeParamClause] {FunParamClause} TypeBounds
-
-Def               ::=  ‘val’ PatDef
-                    |  ‘var’ PatDef
-                    |  ‘def’ DefDef
-                    |  ‘type’ {nl} TypeDcl
-                    |  TmplDef
-PatDef            ::=  ids [‘:’ Type] ‘=’ Expr
-                    |  Pattern2 [‘:’ Type] ‘=’ Expr
-DefDef            ::=  DefSig [‘:’ Type] ‘=’ Expr
-                    |  ‘this’ TypelessClauses [DefImplicitClause] ‘=’ ConstrExpr
-
-TmplDef           ::=  ([‘case’] ‘class’ | ‘trait’) ClassDef
-                    |  [‘case’] ‘object’ ObjectDef
-                    |  ‘enum’ EnumDef
-                    |  ‘given’ GivenDef
-ClassDef          ::=  id ClassConstr [Template]
-ClassConstr       ::=  [ClsTypeParamClause] [ConstrMods] ClsParamClauses
-ConstrMods        ::=  {Annotation} [AccessModifier]
-ObjectDef         ::=  id [Template]
-EnumDef           ::=  id ClassConstr InheritClauses EnumBody
-GivenDef          ::=  [GivenSig] (AnnotType [‘=’ Expr] | StructuralInstance)
-GivenSig          ::=  [id] [DefTypeParamClause] {UsingParamClause} ‘:’         -- one of `id`, `DefTypeParamClause`, `UsingParamClause` must be present
-StructuralInstance ::=  ConstrApp {‘with’ ConstrApp} [‘with’ WithTemplateBody]
-Extension         ::=  ‘extension’ [DefTypeParamClause] {UsingParamClause}
-                       ‘(’ DefTermParam ‘)’ {UsingParamClause} ExtMethods
-ExtMethods        ::=  ExtMethod | [nl] <<< ExtMethod {semi ExtMethod} >>>
-ExtMethod         ::=  {Annotation [nl]} {Modifier} ‘def’ DefDef
-                    |  Export
-Template          ::=  InheritClauses [TemplateBody]
-InheritClauses    ::=  [‘extends’ ConstrApps] [‘derives’ QualId {‘,’ QualId}]
-ConstrApps        ::=  ConstrApp ({‘,’ ConstrApp} | {‘with’ ConstrApp})
-ConstrApp         ::=  SimpleType1 {Annotation} {ParArgumentExprs}
-ConstrExpr        ::=  SelfInvocation
-                    |  <<< SelfInvocation {semi BlockStat} >>>
-SelfInvocation    ::=  ‘this’ ArgumentExprs {ArgumentExprs}
-
-WithTemplateBody  ::=  <<< [SelfType] TemplateStat {semi TemplateStat} >>>
-TemplateBody      ::=  :<<< [SelfType] TemplateStat {semi TemplateStat} >>>
-TemplateStat      ::=  Import
-                    |  Export
-                    |  {Annotation [nl]} {Modifier} Def
-                    |  {Annotation [nl]} {Modifier} Dcl
-                    |  Extension
-                    |  Expr1
-                    |  EndMarker
-                    |
-SelfType          ::=  id [‘:’ InfixType] ‘=>’
-                    |  ‘this’ ‘:’ InfixType ‘=>’
-
-EnumBody          ::=  :<<< [SelfType] EnumStat {semi EnumStat} >>>
-EnumStat          ::=  TemplateStat
-                    |  {Annotation [nl]} {Modifier} EnumCase
-EnumCase          ::=  ‘case’ (id ClassConstr [‘extends’ ConstrApps]] | ids)
-
-TopStats          ::=  TopStat {semi TopStat}
-TopStat           ::=  Import
-                    |  Export
-                    |  {Annotation [nl]} {Modifier} Def
-                    |  Extension
-                    |  Packaging
-                    |  PackageObject
-                    |  EndMarker
-                    |
-Packaging         ::=  ‘package’ QualId :<<< TopStats >>>
-PackageObject     ::=  ‘package’ ‘object’ ObjectDef
-
-CompilationUnit   ::=  {‘package’ QualId semi} TopStats
-```

From d9dfc2174d7f53900d5719e64063ff0b46e5d2dc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Doeraene?= <sjrdoeraene@gmail.com>
Date: Fri, 28 Apr 2023 14:10:55 +0200
Subject: [PATCH 471/657] Apply kind-polymorphism.md.

---
 docs/_spec/03-types.md                        | 51 +++++++++++++++++--
 .../other-new-features/kind-polymorphism.md   |  6 ---
 2 files changed, 47 insertions(+), 10 deletions(-)
 rename docs/_spec/{TODOreference => APPLIEDreference}/other-new-features/kind-polymorphism.md (85%)

diff --git a/docs/_spec/03-types.md b/docs/_spec/03-types.md
index c1cdb110bda8..27b04308138c 100644
--- a/docs/_spec/03-types.md
+++ b/docs/_spec/03-types.md
@@ -26,15 +26,16 @@ chapter: 3
 ```
 
 We distinguish between proper types and type constructors, which take type parameters and yield types.
+All types have a _kind_, either the kind of proper types or a _higher kind_.
 A subset of proper types called _value types_ represents sets of (first-class) values.
-Value types are either _concrete_ or _abstract_.
+Types are either _concrete_ or _abstract_.
 
 Every concrete value type can be represented as a _class type_, i.e. a [type designator](#type-designators) that refers to a [class or a trait](05-classes-and-objects.html#class-definitions) [^1], or as a [compound type](#compound-types) representing an intersection of types, possibly with a [refinement](#compound-types) that further constrains the types of its members.
 
 <!--
 A shorthand exists for denoting [function types](#function-types)
 -->
-Abstract value types are introduced by [type parameters](04-basic-declarations-and-definitions.html#type-parameters) and [abstract type bindings](04-basic-declarations-and-definitions.html#type-declarations-and-type-aliases).
+Abstract types are introduced by [type parameters](04-basic-declarations-and-definitions.html#type-parameters) and [abstract type bindings](04-basic-declarations-and-definitions.html#type-declarations-and-type-aliases).
 Parentheses in types can be used for grouping.
 
 [^1]: We assume that objects and packages also implicitly
@@ -49,6 +50,10 @@ Non-value types are expressed indirectly in Scala.
 E.g., a method type is described by writing down a method signature, which in itself is not a real type, although it  gives rise to a corresponding [method type](#method-types).
 Type constructors are another example, as one can write `type Swap[m[_, _], a,b] = m[b, a]`, but there is no syntax to write the corresponding anonymous type function directly.
 
+`AnyKind` is the super type of all types in the Scala type system.
+It has all possible kinds to encode [kind polymorphism](#kind-polymorphism).
+As such, it is neither a value type nor a type constructor.
+
 ## Paths
 
 ```ebnf
@@ -502,6 +507,42 @@ val f = 0
 define a function `f} which has type `(x: T)T ´\overload´ Int`.
 -->
 
+## Kind Polymorphism
+
+Type parameters are normally partitioned into _kinds_, indicated by the top type of which it is a subtype.
+Proper types are the types of values and are subtypes of `Any`.
+Higher-kinded types are type constructors such as `List` or `Map`.
+Covariant single argument type constructors such as `List` are subtypes of `[+X] =>> Any`.
+The `Map` type constructor is a subtype of `[X, +Y] =>> Any`.
+
+A type can be used only as prescribed by its kind.
+Subtypes of `Any` cannot be applied to type arguments whereas subtypes of `[X] =>> Any` _must_ be applied to a type argument, unless they are passed to type parameters of the same kind.
+
+A type parameter whose upper bound is [`scala.AnyKind`](https://scala-lang.org/api/3.x/scala/AnyKind.html) can have any kind and is called an _any-kinded type_.
+
+```scala
+def f[T <: AnyKind] = ...
+```
+
+The actual type arguments of `f` can then be types of arbitrary kinds.
+So the following are all legal:
+
+```scala
+f[Int]
+f[List]
+f[Map]
+f[[X] =>> String]
+```
+
+Since the actual kind of an any-kinded type is unknown, its usage is heavily restricted.
+An any-kinded type can neither be the type of a value, nor be instantiated with type parameters.
+The only thing one can do with an any-kinded type is to pass it to another any-kinded type argument.
+
+`AnyKind` plays a special role in Scala's subtype system.
+It is a supertype of all other types, no matter what their kind is.
+It is also assumed to be kind-compatible with all other types.
+Furthermore, `AnyKind` is itself an any-kinded type, so it cannot be the type of values and it cannot be instantiated.
+
 ## Base Types and Member Definitions
 
 Types of class members depend on the way the members are referenced.
@@ -588,8 +629,9 @@ Equivalence ´(\equiv)´ between types is the smallest congruence [^congruence]
 The conformance relation ´(<:)´ is the smallest transitive relation that satisfies the following conditions.
 
 - Conformance includes equivalence. If ´T \equiv U´ then ´T <: U´.
-- For every value type `T`, `scala.Nothing <: ´T´ <: scala.Any`.
-- For every type constructor ´T´ (with any number of type parameters), `scala.Nothing <: ´T´ <: scala.Any`.
+- For every type `´T´` (of any kind), `scala.Nothing <: ´T´ <: scala.AnyKind`.
+- For every value type `´T´`, `´T´ <: scala.Any`.
+- For every type constructor `´T´` with type parameters `[´U_1´, ..., ´U_n´]`, `[´U_1´, ..., ´U_n´] =>> scala.Nothing <: ´T´ <: [´U_1´, ..., ´U_n´] =>> scala.Any`.
 - For every value type ´T´, `scala.Null <: ´T´` unless `´T´ <: scala.AnyVal`.
 - A type variable or abstract type ´t´ conforms to its upper bound and its lower bound conforms to ´t´.
 - A class type or parameterized type conforms to any of its base-types.
@@ -716,6 +758,7 @@ _Type erasure_ is a mapping from (possibly generic) types to non-generic types.
 We write ´|T|´ for the erasure of type ´T´.
 The erasure mapping is defined as follows.
 
+- The erasure of `scala.AnyKind` is `Object`.
 - The erasure of an alias type is the erasure of its right-hand side.
 - The erasure of an abstract type is the erasure of its upper bound.
 - The erasure of the parameterized type `scala.Array´[T_1]´` is `scala.Array´[|T_1|]´`.
diff --git a/docs/_spec/TODOreference/other-new-features/kind-polymorphism.md b/docs/_spec/APPLIEDreference/other-new-features/kind-polymorphism.md
similarity index 85%
rename from docs/_spec/TODOreference/other-new-features/kind-polymorphism.md
rename to docs/_spec/APPLIEDreference/other-new-features/kind-polymorphism.md
index 8f0172c4c04b..685630b86f73 100644
--- a/docs/_spec/TODOreference/other-new-features/kind-polymorphism.md
+++ b/docs/_spec/APPLIEDreference/other-new-features/kind-polymorphism.md
@@ -38,10 +38,4 @@ through advanced uses of implicits.
 
 (todo: insert good concise example)
 
-Some technical details: [`AnyKind`](https://scala-lang.org/api/3.x/scala/AnyKind.html) is a synthesized class just like `Any`, but without any members. It extends no other class.
-It is declared `abstract` and `final`, so it can be neither instantiated nor extended.
-
 `AnyKind` plays a special role in Scala's subtype system: It is a supertype of all other types no matter what their kind is. It is also assumed to be kind-compatible with all other types. Furthermore, `AnyKind` is treated as a higher-kinded type (so it cannot be used as a type of values), but at the same time it has no type parameters (so it cannot be instantiated).
-
-**Note**: This feature is considered experimental but stable and it can be disabled under compiler flag
-(i.e. `-Yno-kind-polymorphism`).

From 5913c89b5c9feaf4370526a7258d865c9b429325 Mon Sep 17 00:00:00 2001
From: Julien Richard-Foy <julien@richard-foy.fr>
Date: Fri, 28 Apr 2023 09:53:08 +0200
Subject: [PATCH 472/657] Apply `auto-apply` to the Spec

- Move `auto-apply.md` from TODOreference to APPLIEDreference with minor changes
- Remove the related content from the specification
- Also move the index file `dropped-features.md`
---
 docs/_spec/05-classes-and-objects.md                          | 4 ++--
 .../dropped-features/auto-apply.md                            | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)
 rename docs/_spec/{TODOreference => APPLIEDreference}/dropped-features/auto-apply.md (98%)

diff --git a/docs/_spec/05-classes-and-objects.md b/docs/_spec/05-classes-and-objects.md
index f02aa5368b30..5de7048ba00e 100644
--- a/docs/_spec/05-classes-and-objects.md
+++ b/docs/_spec/05-classes-and-objects.md
@@ -186,7 +186,7 @@ A member definition ´M´ _matches_ a member definition ´M'´, if ´M´ and ´M
 
 1. Neither ´M´ nor ´M'´ is a method definition.
 2. ´M´ and ´M'´ define both monomorphic methods with equivalent argument types.
-3. ´M´ defines a parameterless method and ´M'´ defines a method with an empty parameter list `()` or _vice versa_.
+3. ´M´ is defined in Java and defines a method with an empty parameter list `()` and ´M'´ defines a parameterless method.
 4. ´M´ and ´M'´ define both polymorphic methods with equal number of argument types ´\overline T´, ´\overline T'´ and equal numbers of type parameters ´\overline t´, ´\overline t'´, say, and  ´\overline T' = [\overline t'/\overline t]\overline T´.
 
 <!--
@@ -257,7 +257,7 @@ Another restriction applies to abstract type members:
 An abstract type member with a [volatile type](03-types.html#volatile-types) as its upper bound may not override an abstract type member which does not have a volatile upper bound.
 
 A special rule concerns parameterless methods.
-If a parameterless method defined as `def ´f´: ´T´ = ...` or `def ´f´ = ...` overrides a method of type ´()T'´ which has an empty parameter list, then ´f´ is also assumed to have an empty parameter list.
+If a parameterless method defined as `def ´f´: ´T´ = ...` or `def ´f´ = ...` overrides a method defined in Java of type ´()T'´ which has an empty parameter list, then ´f´ is also assumed to have an empty parameter list.
 
 An overriding method inherits all default arguments from the definition in the superclass.
 By specifying default arguments in the overriding method it is possible to add new defaults (if the corresponding parameter in the superclass does not have a default) or to override the defaults of the superclass (otherwise).
diff --git a/docs/_spec/TODOreference/dropped-features/auto-apply.md b/docs/_spec/APPLIEDreference/dropped-features/auto-apply.md
similarity index 98%
rename from docs/_spec/TODOreference/dropped-features/auto-apply.md
rename to docs/_spec/APPLIEDreference/dropped-features/auto-apply.md
index eadfe2f429ea..b9aedb9f046b 100644
--- a/docs/_spec/TODOreference/dropped-features/auto-apply.md
+++ b/docs/_spec/APPLIEDreference/dropped-features/auto-apply.md
@@ -16,8 +16,8 @@ In Scala 3, this idiom is an error.
 
 ```scala
 next
-^
-missing arguments for method next
+^^^^
+method next must be called with () argument
 ```
 
 In Scala 3, the application syntax has to follow exactly the parameter

From 6261c9e1d078758b9a3715a96f76e702866f1106 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Doeraene?= <sjrdoeraene@gmail.com>
Date: Fri, 28 Apr 2023 12:30:34 +0200
Subject: [PATCH 473/657] Integrate the spec of union and intersection types.

---
 docs/_spec/03-types.md                        | 111 ++++++++---
 docs/_spec/08-pattern-matching.md             |   2 +-
 docs/_spec/A2-scala-2-compatibility.md        |   5 +
 .../new-types/intersection-types.md           |   3 -
 .../APPLIEDreference/new-types/union-types.md |  77 ++++++++
 .../new-types/intersection-types-spec.md      | 108 -----------
 .../new-types/union-types-spec.md             | 172 ------------------
 .../TODOreference/new-types/union-types.md    |  46 -----
 8 files changed, 172 insertions(+), 352 deletions(-)
 rename docs/_spec/{TODOreference => APPLIEDreference}/new-types/intersection-types.md (97%)
 create mode 100644 docs/_spec/APPLIEDreference/new-types/union-types.md
 delete mode 100644 docs/_spec/TODOreference/new-types/intersection-types-spec.md
 delete mode 100644 docs/_spec/TODOreference/new-types/union-types-spec.md
 delete mode 100644 docs/_spec/TODOreference/new-types/union-types.md

diff --git a/docs/_spec/03-types.md b/docs/_spec/03-types.md
index 27b04308138c..c9cb932d8fc3 100644
--- a/docs/_spec/03-types.md
+++ b/docs/_spec/03-types.md
@@ -364,12 +364,64 @@ An _infix type_ ´T_1´ `op` ´T_2´ consists of an infix operator `op` which ge
 The type is equivalent to the type application `op`´[T_1, T_2]´.
 The infix operator `op` may be an arbitrary identifier.
 
-All type infix operators have the same precedence; parentheses have to be used for grouping.
-The [associativity](06-expressions.html#prefix,-infix,-and-postfix-operations) of a type operator is determined as for term operators: type operators ending in a colon ‘:’ are right-associative; all other operators are left-associative.
+Type operators follow the same [precedence and associativity as term operators](06-expressions.html#prefix-infix-and-postfix-operations).
+For example, `A + B * C` parses as `A + (B * C)` and `A | B & C` parses as `A | (B & C)`.
+Type operators ending in a colon ‘:’ are right-associative; all other operators are left-associative.
 
 In a sequence of consecutive type infix operations ´t_0 \, \mathit{op} \, t_1 \, \mathit{op_2} \, ... \, \mathit{op_n} \, t_n´, all operators ´\mathit{op}\_1, ..., \mathit{op}\_n´ must have the same associativity.
 If they are all left-associative, the sequence is interpreted as ´(... (t_0 \mathit{op_1} t_1) \mathit{op_2} ...) \mathit{op_n} t_n´, otherwise it is interpreted as ´t_0 \mathit{op_1} (t_1 \mathit{op_2} ( ... \mathit{op_n} t_n) ...)´.
 
+The type operators `|` and `&` are not really special.
+Nevertheless, unless shadowed, they resolve to `scala.|` and `scala.&`, which represent [union and intersection types](#union-and-intersection-types), respectively.
+
+### Union and Intersection Types
+
+Syntactically, the types `S | T` and `S & T` are infix types, where the infix operators are `|` and `&`, respectively (see above).
+
+However, in this specification, ´S ｜ T´ and ´S ＆ T´ refer to the underlying core concepts of *union and intersection types*, respectively.
+
+- The type ´S ｜ T´ represents the set of values that are represented by *either* ´S´ or ´T´.
+- The type ´S ＆ T´ represents the set of values that are represented by *both* ´S´ and ´T´.
+
+From the [conformance rules](#conformance) rules on union and intersection types, we can show that ´＆´ and ´｜´ are *commutative* and *associative*.
+Moreover, `＆` is distributive over `｜`.
+For any type ´A´, ´B´ and ´C´, all of the following relationships hold:
+
+- ´A ＆ B \equiv B ＆ A´,
+- ´A ｜ B \equiv B ｜ A´,
+- ´(A ＆ B) ＆ C \equiv A ＆ (B ＆ C)´,
+- ´(A ｜ B) ｜ C \equiv A ｜ (B ｜ C)´, and
+- ´A ＆ (B ｜ C) \equiv (A ＆ B) ｜ (A ＆ C)´.
+
+If ´C´ is a type constructor, then ´C[A] ＆ C[B]´ can be simplified using the following three rules:
+
+- If ´C´ is covariant, ´C[A] ＆ C[B] \equiv C[A ＆ B]´
+- If ´C´ is contravariant, ´C[A] ＆ C[B] \equiv C[A | B]´
+- If ´C´ is invariant, emit a compile error
+
+From the above rules, we can derive the following conformance relationships:
+
+- When ´C´ is covariant, ´C[A ＆ B] <: C[A] ＆ C[B]´.
+- When ´C´ is contravariant, ´C[A ｜ B] <: C[A] ＆ C[B]´.
+
+#### Join of a union type
+
+In some situations, a union type might need to be widened to a non-union type.
+For this purpose, we define the _join_ of a union type ´T_1 ｜ ... ｜ T_n´ as the smallest intersection type of base class instances of ´T_1, ..., T_n´.
+Note that union types might still appear as type arguments in the resulting type, this guarantees that the join is always finite.
+
+For example, given
+
+```scala
+trait C[+T]
+trait D
+trait E
+class A extends C[A] with D
+class B extends C[B] with D with E
+```
+
+The join of ´A ｜ B´ is ´C[A ｜ B] ＆ D´
+
 ### Function Types
 
 ```ebnf
@@ -589,6 +641,8 @@ If ´T´ is a possibly parameterized class type, where ´T´'s class is defined
 1. The _member bindings_ of a type ´T´ are
   1. all bindings ´d´ such that there exists a type instance of some class ´C´ among the base types of ´T´ and there exists a definition or declaration ´d'´ in ´C´ such that ´d´ results from ´d'´ by replacing every type ´T'´ in ´d'´ by ´T'´ in ´C´ seen from ´T´, and
   2. all bindings of the type's [refinement](#compound-types), if it has one.
+2. The member bindinds of ´S ＆ T´ are all the binds of ´S´ *and* all the bindins of ´T´.
+3. The member bindings of ´S ｜ T´ are the member bindings of its [join](#join-of-a-union-type).
 
 The _definition_ of a type projection `S#T` is the member binding ´d_T´ of the type `T` in `S`.
 In that case, we also say that `S#T` _is defined by_ ´d_T´.
@@ -647,6 +701,10 @@ The conformance relation ´(<:)´ is the smallest transitive relation that satis
      1. If ´U_i´ is a wildcard type argument of the form ´\\_ >: L_2 <: U_2´, then ´L_2 <: T_i´ and ´T_i <: U_2´.
 - A compound type `´T_1´ with ... with ´T_n´ {´R\,´}` conforms to each of its component types ´T_i´.
 - If ´T <: U_i´ for ´i \in \{ 1, ..., n \}´ and for every binding ´d´ of a type or value ´x´ in ´R´ there exists a member binding of ´x´ in ´T´ which subsumes ´d´, then ´T´ conforms to the compound type `´U_1´ with ... with ´U_n´ {´R\,´}`.
+- If ´T <: U´, then ´T <: U ｜ W´ and ´T <: W ｜ U´.
+- If ´T <: W´ and ´U <: W´, then ´T ｜ U <: W´.
+- If ´T <: U´ and ´T <: W´, then ´T <: U ＆ W´.
+- If ´T <: W´, then ´T ＆ U <: W´ and ´U ＆ T <: W´.
 - If ´T_i \equiv T_i'´ for ´i \in \{ 1, ..., n\}´ and ´U´ conforms to ´U'´ then the method type ´(p_1:T_1, ..., p_n:T_n) U´ conforms to ´(p_1':T_1', ..., p_n':T_n') U'´.
 - The polymorphic type ´[a_1 >: L_1 <: U_1, ..., a_n >: L_n <: U_n] T´ conforms to the polymorphic type ´[a_1 >: L_1' <: U_1', ..., a_n >: L_n' <: U_n'] T'´ if, assuming ´L_1' <: a_1 <: U_1', ..., L_n' <: a_n <: U_n'´ one has ´T <: T'´ and ´L_i <: L_i'´ and ´U_i' <: U_i´ for ´i \in \{ 1, ..., n \}´.
 - Type constructors ´T´ and ´T'´ follow a similar discipline.
@@ -667,28 +725,15 @@ A declaration or definition in some compound type of class type ´C´ _subsumes_
 - A type declaration `type ´t´[´T_1´, ..., ´T_n´] >: ´L´ <: ´U´` subsumes a type declaration `type ´t´[´T_1´, ..., ´T_n´] >: ´L'´ <: ´U'´` if ´L' <: L´ and ´U <: U'´.
 - A type or class definition that binds a type name ´t´ subsumes an abstract type declaration `type t[´T_1´, ..., ´T_n´] >: L <: U` if ´L <: t <: U´.
 
-
 #### Least upper bounds and greatest lower bounds
+
 The ´(<:)´ relation forms pre-order between types, i.e. it is transitive and reflexive.
 This allows us to define _least upper bounds_ and _greatest lower bounds_ of a set of types in terms of that order.
-The least upper bound or greatest lower bound of a set of types does not always exist.
-For instance, consider the class definitions:
-
-```scala
-class A[+T] {}
-class B extends A[B]
-class C extends A[C]
-```
-
-Then the types `A[Any], A[A[Any]], A[A[A[Any]]], ...` form a descending sequence of upper bounds for `B` and `C`.
-The least upper bound would be the infinite limit of that sequence, which does not exist as a Scala type.
-Since cases like this are in general impossible to detect, a Scala compiler is free to reject a term which has a type specified as a least upper or greatest lower bound, and that bound would be more complex than some compiler-set limit [^4].
 
-The least upper bound or greatest lower bound might also not be unique.
-For instance `A with B` and `B with A` are both greatest lower bounds of `A` and `B`.
-If there are several least upper bounds or greatest lower bounds, the Scala compiler is free to pick any one of them.
+- the _least upper bound_ of `A` and `B` is the smallest type `L` such that `A` <: `L` and `B` <: `L`.
+- the _greatest lower bound_ of `A` and `B` is the largest type `G` such that `G` <: `A` and `G` <: `B`.
 
-[^4]: The current Scala compiler limits the nesting level of parameterization in such bounds to be at most two deeper than the maximum nesting level of the operand types
+By construction, for all types `A` and `B`, the least upper bound of `A` and `B` is `A ｜ B`, and their greatest lower bound is `A ＆ B`.
 
 ### Weak Conformance
 
@@ -766,7 +811,29 @@ The erasure mapping is defined as follows.
 - The erasure of a singleton type `´p´.type` is the erasure of the type of ´p´.
 - The erasure of a type projection `´T´#´x´` is `|´T´|#´x´`.
 - The erasure of a compound type `´T_1´ with ... with ´T_n´ {´R\,´}` is the erasure of the intersection dominator of ´T_1, ..., T_n´.
+- The erasure of a union type ´S ｜ T´ is the _erased least upper bound_ (_elub_) of the erasures of ´S´ and ´T´.
+- The erasure of an intersection type ´S ＆ T´ is the _eglb_ (erased greatest lower bound) of the erasures of ´S´ and ´T´.
+
+The erased LUB 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`](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html)
+- if one argument is an array, [`Object`](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html)
+- 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, and
+  - S is last: in the linearization of the first argument type ´|A|´ 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.
 
-The _intersection dominator_ of a list of types ´T_1, ..., T_n´ is computed as follows.
-Let ´T_{i_1}, ..., T_{i_m}´ be the subsequence of types ´T_i´ which are not supertypes of some other type ´T_j´.
-If this subsequence contains a type designator ´T_c´ that refers to a class which is not a trait, the intersection dominator is ´T_c´. Otherwise, the intersection dominator is the first element of the subsequence, ´T_{i_1}´.
+The rules for ´eglb(A, B)´ are given below in pseudocode:
+
+```
+eglb(scala.Array[A], JArray[B]) = scala.Array[eglb(A, B)]
+eglb(scala.Array[T], _)         = scala.Array[T]
+eglb(_, scala.Array[T])         = scala.Array[T]
+eglb(A, B)                      = A                     if A extends B
+eglb(A, B)                      = B                     if B extends A
+eglb(A, _)                      = A                     if A is not a trait
+eglb(_, B)                      = B                     if B is not a trait
+eglb(A, _)                      = A                     // use first
+```
diff --git a/docs/_spec/08-pattern-matching.md b/docs/_spec/08-pattern-matching.md
index ee7b0d246aa7..1d50b814ee24 100644
--- a/docs/_spec/08-pattern-matching.md
+++ b/docs/_spec/08-pattern-matching.md
@@ -534,7 +534,7 @@ In the interest of efficiency the evaluation of a pattern matching expression ma
 This might affect evaluation through side effects in guards.
 However, it is guaranteed that a guard expression is evaluated only if the pattern it guards matches.
 
-If the selector of a pattern match is an instance of a [`sealed` class](05-classes-and-objects.html#modifiers), the compilation of pattern matching can emit warnings which diagnose that a given set of patterns is not exhaustive, i.e. that there is a possibility of a `MatchError` being raised at run-time.
+If the selector of a pattern match is an instance of a [`sealed` class](05-classes-and-objects.html#modifiers), a [union type](03-types#union-and-intersection-types), or a combination thereof, the compilation of pattern matching can emit warnings which diagnose that a given set of patterns is not exhaustive, i.e. that there is a possibility of a `MatchError` being raised at run-time.
 
 ###### Example
 
diff --git a/docs/_spec/A2-scala-2-compatibility.md b/docs/_spec/A2-scala-2-compatibility.md
index 461bd37592b0..30ac1ac32fc2 100644
--- a/docs/_spec/A2-scala-2-compatibility.md
+++ b/docs/_spec/A2-scala-2-compatibility.md
@@ -33,3 +33,8 @@ Scala 3 accepts the old syntax under the `-source:3.0-migration` option.
 If the `-migration` option is set, it can even rewrite old syntax to new.
 The [Scalafix](https://scalacenter.github.io/scalafix/) tool also
 can rewrite procedure syntax to make it Scala 3 compatible.
+
+## Compound Types (`with`)
+
+Intersection types `A & B` replace compound types `A with B` in Scala 2.
+For the moment, the syntax `A with B` is still allowed and interpreted as `A & B`, but its usage as a type (as opposed to in a `new` or `extends` clause) will be deprecated and removed in the future.
diff --git a/docs/_spec/TODOreference/new-types/intersection-types.md b/docs/_spec/APPLIEDreference/new-types/intersection-types.md
similarity index 97%
rename from docs/_spec/TODOreference/new-types/intersection-types.md
rename to docs/_spec/APPLIEDreference/new-types/intersection-types.md
index a4eedeb000f6..4720649e16a9 100644
--- a/docs/_spec/TODOreference/new-types/intersection-types.md
+++ b/docs/_spec/APPLIEDreference/new-types/intersection-types.md
@@ -63,6 +63,3 @@ to give at that point a definition of a `children` method with the required type
 class C extends A, B:
   def children: List[A & B] = ???
 ```
-
-
-[More details](./intersection-types-spec.md)
diff --git a/docs/_spec/APPLIEDreference/new-types/union-types.md b/docs/_spec/APPLIEDreference/new-types/union-types.md
new file mode 100644
index 000000000000..152505d7fc8d
--- /dev/null
+++ b/docs/_spec/APPLIEDreference/new-types/union-types.md
@@ -0,0 +1,77 @@
+---
+layout: doc-page
+title: "Union Types"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/new-types/union-types.html
+---
+
+A union type `A | B` has as values all values of type `A` and also all values of type `B`.
+
+
+```scala
+case class UserName(name: String)
+case class Password(hash: Hash)
+
+def help(id: UserName | Password) =
+  val user = id match
+    case UserName(name) => lookupName(name)
+    case Password(hash) => lookupPassword(hash)
+  ...
+```
+
+Union types are duals of intersection types. `|` is _commutative_:
+`A | B` is the same type as `B | A`.
+
+The compiler will assign a union type to an expression only if such a
+type is explicitly given. This can be seen in the following [REPL](https://docs.scala-lang.org/overviews/repl/overview.html) transcript:
+
+```scala
+scala> val password = Password(123)
+val password: Password = Password(123)
+
+scala> val name = UserName("Eve")
+val name: UserName = UserName(Eve)
+
+scala> if true then name else password
+val res2: Object = UserName(Eve)
+
+scala> val either: Password | UserName = if true then name else password
+val either: Password | UserName = UserName(Eve)
+```
+
+The type of `res2` is `Object & Product`, which is a supertype of
+`UserName` and `Password`, but not the least supertype `Password |
+UserName`.  If we want the least supertype, we have to give it
+explicitly, as is done for the type of `either`.
+
+## Type inference
+
+When inferring the result type of a definition (`val`, `var`, or `def`) and the
+type we are about to infer is a union type, then we replace it by its join.
+Similarly, when instantiating a type argument, if the corresponding type
+parameter is not upper-bounded by a union type and the type we are about to
+instantiate is a union type, we replace it by its join. This mirrors the
+treatment of singleton types which are also widened to their underlying type
+unless explicitly specified. The motivation is the same: inferring types
+which are "too precise" can lead to unintuitive typechecking issues later on.
+
+**Note:** Since this behavior limits the usability of union types, it might
+be changed in the future. For example by not widening unions that have been
+explicitly written down by the user and not inferred, or by not widening a type
+argument when the corresponding type parameter is covariant.
+
+See [PR #2330](https://github.com/lampepfl/dotty/pull/2330) and
+[Issue #4867](https://github.com/lampepfl/dotty/issues/4867) for further discussions.
+
+### Example
+
+```scala
+import scala.collection.mutable.ListBuffer
+val x = ListBuffer(Right("foo"), Left(0))
+val y: ListBuffer[Either[Int, String]] = x
+```
+
+This code typechecks because the inferred type argument to `ListBuffer` in the
+right-hand side of `x` was `Left[Int, Nothing] | Right[Nothing, String]` which
+was widened to `Either[Int, String]`. If the compiler hadn't done this widening,
+the last line wouldn't typecheck because `ListBuffer` is invariant in its
+argument.
diff --git a/docs/_spec/TODOreference/new-types/intersection-types-spec.md b/docs/_spec/TODOreference/new-types/intersection-types-spec.md
deleted file mode 100644
index 346c57c004f0..000000000000
--- a/docs/_spec/TODOreference/new-types/intersection-types-spec.md
+++ /dev/null
@@ -1,108 +0,0 @@
----
-layout: doc-page
-title: "Intersection Types - More Details"
-nightlyOf: https://docs.scala-lang.org/scala3/reference/new-types/intersection-types-spec.html
----
-
-## Syntax
-
-Syntactically, the type `S & T` is an infix type, where the infix operator is `&`.
-The operator `&` is a normal identifier
-with the usual precedence and subject to usual resolving rules.
-Unless shadowed by another definition, it resolves to the type `scala.&`,
-which acts as a type alias to an internal representation of intersection types.
-
-```
-Type              ::=  ...| InfixType
-InfixType         ::=  RefinedType {id [nl] RefinedType}
-```
-
-## Subtyping Rules
-
-```
-T <: A    T <: B
-----------------
-  T <: A & B
-
-    A <: T
-----------------
-    A & B <: T
-
-    B <: T
-----------------
-    A & B <: T
-```
-
-From the rules above, we can show that `&` is _commutative_: `A & B <: B & A` for any type `A` and `B`.
-
-```
-   B <: B           A <: A
-----------       -----------
-A & B <: B       A & B <: A
----------------------------
-       A & B  <:  B & A
-```
-
-In another word, `A & B` is the same type as `B & A`, in the sense that the two types
-have the same values and are subtypes of each other.
-
-If `C` is a type constructor, then `C[A] & C[B]` can be simplified using the following three rules:
-
-- If `C` is covariant, `C[A] & C[B] ~> C[A & B]`
-- If `C` is contravariant, `C[A] & C[B] ~> C[A | B]`
-- If `C` is non-variant, emit a compile error
-
-When `C` is covariant, `C[A & B] <: C[A] & C[B]` can be derived:
-
-```
-    A <: A                  B <: B
-  ----------               ---------
-  A & B <: A               A & B <: B
----------------         -----------------
-C[A & B] <: C[A]          C[A & B] <: C[B]
-------------------------------------------
-      C[A & B] <: C[A] & C[B]
-```
-
-When `C` is contravariant, `C[A | B] <: C[A] & C[B]` can be derived:
-
-```
-    A <: A                        B <: B
-  ----------                     ---------
-  A <: A | B                     B <: A | B
--------------------           ----------------
-C[A | B] <: C[A]              C[A | B] <: C[B]
---------------------------------------------------
-            C[A | B] <: C[A] & C[B]
-```
-
-## Erasure
-
-The erased type for `S & T` is the erased _glb_ (greatest lower bound) of the
-erased type of `S` and `T`. The rules for erasure of intersection types are given
-below in pseudocode:
-
-```
-|S & T| = glb(|S|, |T|)
-
-glb(JArray(A), JArray(B)) = JArray(glb(A, B))
-glb(JArray(T), _)         = JArray(T)
-glb(_, JArray(T))         = JArray(T)
-glb(A, B)                 = A                     if A extends B
-glb(A, B)                 = B                     if B extends A
-glb(A, _)                 = A                     if A is not a trait
-glb(_, B)                 = B                     if B is not a trait
-glb(A, _)                 = A                     // use first
-```
-
-In the above, `|T|` means the erased type of `T`, `JArray` refers to
-the type of Java Array.
-
-See also: [`TypeErasure#erasedGlb`](https://github.com/lampepfl/dotty/blob/main/compiler/src/dotty/tools/dotc/core/TypeErasure.scala#L289).
-
-## Relationship with Compound Type (`with`)
-
-Intersection types `A & B` replace compound types `A with B` in Scala 2. For the
-moment, the syntax `A with B` is still allowed and interpreted as `A & B`, but
-its usage as a type (as opposed to in a `new` or `extends` clause) will be
-deprecated and removed in the future.
diff --git a/docs/_spec/TODOreference/new-types/union-types-spec.md b/docs/_spec/TODOreference/new-types/union-types-spec.md
deleted file mode 100644
index d250d3f11713..000000000000
--- a/docs/_spec/TODOreference/new-types/union-types-spec.md
+++ /dev/null
@@ -1,172 +0,0 @@
----
-layout: doc-page
-title: "Union Types - More Details"
-nightlyOf: https://docs.scala-lang.org/scala3/reference/new-types/union-types-spec.html
----
-
-## Syntax
-
-Syntactically, unions follow the same rules as intersections, but have a lower precedence, see
-[Intersection Types - More Details](./intersection-types-spec.md).
-
-### Interaction with pattern matching syntax
-`|` is also used in pattern matching to separate pattern alternatives and has
-lower precedence than `:` as used in typed patterns, this means that:
-
-```scala
-case _: A | B => ...
-```
-
-is still equivalent to:
-
-```scala
-case (_: A) | B => ...
-```
-
-and not to:
-
-```scala
-case _: (A | B) => ...
-```
-
-## Subtyping Rules
-
-- `A` is always a subtype of `A | B` for all `A`, `B`.
-- If `A <: C` and `B <: C` then `A | B <: C`
-- Like `&`, `|` is commutative and associative:
-
-  ```scala
-  A | B =:= B | A
-  A | (B | C) =:= (A | B) | C
-  ```
-
-- `&` is distributive over `|`:
-
-  ```scala
-  A & (B | C) =:= A & B | A & C
-  ```
-
-From these rules it follows that the _least upper bound_ (LUB) of a set of types
-is the union of these types. This replaces the
-[definition of least upper bound in the Scala 2 specification](https://www.scala-lang.org/files/archive/spec/2.13/03-types.html#least-upper-bounds-and-greatest-lower-bounds).
-
-## Motivation
-
-The primary reason for introducing union types in Scala is that they allow us to
-guarantee that for every set of types, we can always form a finite LUB. This is
-both useful in practice (infinite LUBs in Scala 2 were approximated in an ad-hoc
-way, resulting in imprecise and sometimes incredibly long types) and in theory
-(the type system of Scala 3 is based on the
-[DOT calculus](https://infoscience.epfl.ch/record/227176/files/soundness_oopsla16.pdf),
-which has union types).
-
-Additionally, union types are a useful construct when trying to give types to existing
-dynamically typed APIs, this is why they're [an integral part of TypeScript](https://www.typescriptlang.org/docs/handbook/advanced-types.html#union-types)
-and have even been [partially implemented in Scala.js](https://github.com/scala-js/scala-js/blob/master/library/src/main/scala/scala/scalajs/js/Union.scala).
-
-## Join of a union type
-
-In some situation described below, a union type might need to be widened to
-a non-union type, for this purpose we define the _join_ of a union type `T1 |
-... | Tn` as the smallest intersection type of base class instances of
-`T1`,...,`Tn`. Note that union types might still appear as type arguments in the
-resulting type, this guarantees that the join is always finite.
-
-### Example
-
-Given
-
-```scala
-trait C[+T]
-trait D
-trait E
-class A extends C[A] with D
-class B extends C[B] with D with E
-```
-
-The join of `A | B` is `C[A | B] & D`
-
-## Type inference
-
-When inferring the result type of a definition (`val`, `var`, or `def`) and the
-type we are about to infer is a union type, then we replace it by its join.
-Similarly, when instantiating a type argument, if the corresponding type
-parameter is not upper-bounded by a union type and the type we are about to
-instantiate is a union type, we replace it by its join. This mirrors the
-treatment of singleton types which are also widened to their underlying type
-unless explicitly specified. The motivation is the same: inferring types
-which are "too precise" can lead to unintuitive typechecking issues later on.
-
-**Note:** Since this behavior limits the usability of union types, it might
-be changed in the future. For example by not widening unions that have been
-explicitly written down by the user and not inferred, or by not widening a type
-argument when the corresponding type parameter is covariant.
-
-See [PR #2330](https://github.com/lampepfl/dotty/pull/2330) and
-[Issue #4867](https://github.com/lampepfl/dotty/issues/4867) for further discussions.
-
-### Example
-
-```scala
-import scala.collection.mutable.ListBuffer
-val x = ListBuffer(Right("foo"), Left(0))
-val y: ListBuffer[Either[Int, String]] = x
-```
-
-This code typechecks because the inferred type argument to `ListBuffer` in the
-right-hand side of `x` was `Left[Int, Nothing] | Right[Nothing, String]` which
-was widened to `Either[Int, String]`. If the compiler hadn't done this widening,
-the last line wouldn't typecheck because `ListBuffer` is invariant in its
-argument.
-
-
-## Members
-
-The members of a union type are the members of its join.
-
-### Example
-
-The following code does not typecheck, because method `hello` is not a member of
-`AnyRef` which is the join of `A | B`.
-
-```scala
-trait A { def hello: String }
-trait B { def hello: String }
-
-def test(x: A | B) = x.hello // error: value `hello` is not a member of A | B
-```
-
-On the other hand, the following would be allowed
-
-```scala
-trait C { def hello: String }
-trait A extends C with D
-trait B extends C with E
-
-def test(x: A | B) = x.hello // ok as `hello` is a member of the join of A | B which is C
-```
-
-## Exhaustivity checking
-
-If the selector of a pattern match is a union type, the match is considered
-exhaustive if all parts of the union are covered.
-
-## Erasure
-
-The erased type for `A | B` is the _erased least upper bound_ of the erased
-types of `A` and `B`. Quoting from the documentation of `TypeErasure#erasedLub`,
-the erased LUB 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`](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html)
-- if one argument is an array, [`Object`](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html)
-- 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 `|A|`
-                  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.
diff --git a/docs/_spec/TODOreference/new-types/union-types.md b/docs/_spec/TODOreference/new-types/union-types.md
deleted file mode 100644
index ebc4565e36fb..000000000000
--- a/docs/_spec/TODOreference/new-types/union-types.md
+++ /dev/null
@@ -1,46 +0,0 @@
----
-layout: doc-page
-title: "Union Types"
-nightlyOf: https://docs.scala-lang.org/scala3/reference/new-types/union-types.html
----
-
-A union type `A | B` has as values all values of type `A` and also all values of type `B`.
-
-
-```scala
-case class UserName(name: String)
-case class Password(hash: Hash)
-
-def help(id: UserName | Password) =
-  val user = id match
-    case UserName(name) => lookupName(name)
-    case Password(hash) => lookupPassword(hash)
-  ...
-```
-
-Union types are duals of intersection types. `|` is _commutative_:
-`A | B` is the same type as `B | A`.
-
-The compiler will assign a union type to an expression only if such a
-type is explicitly given. This can be seen in the following [REPL](https://docs.scala-lang.org/overviews/repl/overview.html) transcript:
-
-```scala
-scala> val password = Password(123)
-val password: Password = Password(123)
-
-scala> val name = UserName("Eve")
-val name: UserName = UserName(Eve)
-
-scala> if true then name else password
-val res2: Object = UserName(Eve)
-
-scala> val either: Password | UserName = if true then name else password
-val either: Password | UserName = UserName(Eve)
-```
-
-The type of `res2` is `Object & Product`, which is a supertype of
-`UserName` and `Password`, but not the least supertype `Password |
-UserName`.  If we want the least supertype, we have to give it
-explicitly, as is done for the type of `either`.
-
-[More details](./union-types-spec.md)

From 5dd886c6af6bae3ae139b06a293a99ce9030796f Mon Sep 17 00:00:00 2001
From: Guillaume Martres <smarter@ubuntu.com>
Date: Fri, 28 Apr 2023 15:51:09 +0200
Subject: [PATCH 474/657] Specify type lambdas (including variance inference
 and subtyping)

---
 docs/_spec/03-types.md                        |  40 ++++--
 .../04-basic-declarations-and-definitions.md  |  48 ++++++++
 .../new-types/type-lambdas.md                 |   2 -
 .../new-types/type-lambdas-spec.md            | 116 ------------------
 4 files changed, 75 insertions(+), 131 deletions(-)
 rename docs/_spec/{TODOreference => APPLIEDreference}/new-types/type-lambdas.md (92%)
 delete mode 100644 docs/_spec/TODOreference/new-types/type-lambdas-spec.md

diff --git a/docs/_spec/03-types.md b/docs/_spec/03-types.md
index c9cb932d8fc3..bbaac5de03a0 100644
--- a/docs/_spec/03-types.md
+++ b/docs/_spec/03-types.md
@@ -8,9 +8,12 @@ chapter: 3
 
 ```ebnf
   Type              ::=  FunctionArgTypes ‘=>’ Type
+                      |  TypeLambdaParams ‘=>>’ Type
                       |  InfixType
   FunctionArgTypes  ::=  InfixType
                       |  ‘(’ [ ParamType {‘,’ ParamType } ] ‘)’
+  TypeLambdaParams  ::=  ‘[’ TypeLambdaParam {‘,’ TypeLambdaParam} ‘]’
+  TypeLambdaParam   ::=  {Annotation} (id | ‘_’) [TypeParamClause] [‘>:’ Type] [‘<:’ Type]
   InfixType         ::=  CompoundType {id [nl] CompoundType}
   CompoundType      ::=  AnnotType {‘with’ AnnotType} [Refinement]
                       |  Refinement
@@ -453,8 +456,7 @@ Their exact supertype and implementation can be consulted in the [function class
 
 ## Non-Value Types
 
-The types explained in the following do not denote sets of values, nor do they appear explicitly in programs.
-They are introduced in this report as the internal types of defined identifiers.
+The types explained in the following do not denote sets of values.
 
 ### Method Types
 
@@ -511,20 +513,30 @@ union : [A >: Nothing <: Comparable[A]] (x: Set[A], xs: Set[A]) Set[A]
 
 ### Type Constructors
 
-A _type constructor_ is represented internally much like a polymorphic method type.
-`[´\pm´ ´a_1´ >: ´L_1´ <: ´U_1, ..., \pm a_n´ >: ´L_n´ <: ´U_n´] ´T´` represents a type that is expected by a [type constructor parameter](04-basic-declarations-and-definitions.html#type-parameters) or an [abstract type constructor binding](04-basic-declarations-and-definitions.html#type-declarations-and-type-aliases) with the corresponding type parameter clause.
+```
+Type             ::=  ... |  TypeLambdaParams ‘=>>’ Type
+TypeParamClause  ::=  ‘[’ TypeParam {‘,’ TypeParam} ‘]’
+TypeLambdaParams ::=  ‘[’ TypeLambdaParam {‘,’ TypeLambdaParam} ‘]’
+TypeLambdaParam  ::=  {Annotation} (id | ‘_’) [TypeParamClause] [‘>:’ Type] [‘<:’ Type]
+```
 
-###### Example
+<!-- the definition of a parameterized type above uses the concept of a type constructor, so we can't define a type constructor as an unapplied parameterized type. -->
 
-Consider this fragment of the `Iterable[+X]` class:
+A _type constructor_ is either:
+- a _type lambda_, of the form `[´\mathit{tps}\,´] =>> ´T´` where `[´\mathit{tps}\,´]` is a type parameter clause `[´a_1´ >: ´L_1´ <: ´U_1, ..., a_n´ >: ´L_n´ <: ´U_n´]` for some ´n \gt 0´ and ´T´ is either a value type
+or another type lambda.
+- a reference to a [desugared type declaration](04-basic-declarations-and-definitions.html#type-declarations-and-type-aliases) upper-bounded by a type lambda.
+- a reference to a [polymorphic class](05-classes-and-objects.html##class-definitions).
 
-```scala
-trait Iterable[+X] {
-  def flatMap[newType[+X] <: Iterable[X], S](f: X => newType[S]): newType[S]
-}
-```
+Each type parameter ´a_i´ of a type lambda has a variance ´v_i´ which cannot be written down by the user but is inferred from the body of the type lambda to maximize the number of types that conform to the type lambda.
+<!-- TODO: write down the exact algorithm? -->
 
-Conceptually, the type constructor `Iterable` is a name for the anonymous type `[+X] Iterable[X]`, which may be passed to the `newType` type constructor parameter in `flatMap`.
+#### Inferred type parameter clause
+
+To each type constructor corresponds an _inferred type parameter clause_ which is computed as follow:
+- For a type lambda, its type parameter clause (including variance annotations).
+- For a type declaration upper-bounded by a type lambda ´T´, the inferred clause of ´T´.
+- For a polymorphic class, its type parameter clause.
 
 <!-- ### Overloaded Types
 
@@ -660,6 +672,8 @@ We define the following relations between types.
 
 ### Equivalence
 
+´\color{red}{\text{TODO SCALA3: Redefine equivalence as mutual conformance?}}´
+
 Equivalence ´(\equiv)´ between types is the smallest congruence [^congruence] such that the following holds:
 
 - If ´t´ is defined by a type alias `type ´t´ = ´T´`, then ´t´ is equivalent to ´T´.
@@ -708,7 +722,7 @@ The conformance relation ´(<:)´ is the smallest transitive relation that satis
 - If ´T_i \equiv T_i'´ for ´i \in \{ 1, ..., n\}´ and ´U´ conforms to ´U'´ then the method type ´(p_1:T_1, ..., p_n:T_n) U´ conforms to ´(p_1':T_1', ..., p_n':T_n') U'´.
 - The polymorphic type ´[a_1 >: L_1 <: U_1, ..., a_n >: L_n <: U_n] T´ conforms to the polymorphic type ´[a_1 >: L_1' <: U_1', ..., a_n >: L_n' <: U_n'] T'´ if, assuming ´L_1' <: a_1 <: U_1', ..., L_n' <: a_n <: U_n'´ one has ´T <: T'´ and ´L_i <: L_i'´ and ´U_i' <: U_i´ for ´i \in \{ 1, ..., n \}´.
 - Type constructors ´T´ and ´T'´ follow a similar discipline.
-We characterize ´T´ and ´T'´ by their type parameter clauses ´[a_1, ..., a_n]´ and ´[a_1', ..., a_n']´, where an ´a_i´ or ´a_i'´ may include a variance annotation, a higher-order type parameter clause, and bounds.
+We characterize ´T´ and ´T'´ by their [inferred type parameter clauses](#inferred-type-parameter-clause) ´[a_1, ..., a_n]´ and ´[a_1', ..., a_n']´.
 Then, ´T´ conforms to ´T'´ if any list ´[t_1, ..., t_n]´ -- with declared variances, bounds and higher-order type parameter clauses -- of valid type arguments for ´T'´ is also a valid list of type arguments for ´T´ and ´T[t_1, ..., t_n] <: T'[t_1, ..., t_n]´.
 Note that this entails that:
   - The bounds on ´a_i´ must be weaker than the corresponding bounds declared for ´a'_i´.
diff --git a/docs/_spec/04-basic-declarations-and-definitions.md b/docs/_spec/04-basic-declarations-and-definitions.md
index e0985c68dbc6..5c45cc5c7819 100644
--- a/docs/_spec/04-basic-declarations-and-definitions.md
+++ b/docs/_spec/04-basic-declarations-and-definitions.md
@@ -226,6 +226,54 @@ Def        ::=  ‘type’ {nl} TypeDef
 TypeDef    ::=  id [TypeParamClause] ‘=’ Type
 ```
 
+### Desugaring of parameterized type declarations
+A parameterized type declaration is desugared into an unparameterized type declaration
+whose bounds are type lambdas with explicit variance annotations.
+
+#### Abstract Type
+An abstract type
+```scala
+type ´t´[´\mathit{tps}\,´] >: ´L´ <: ´U´
+```
+is desugared into an unparameterized abstract type as follow:
+- If `L` conforms to `Nothing`, then,
+
+  ```scala
+type ´t´ >: Nothing
+       <: [´\mathit{tps'}\,´] =>> ´U´
+  ```
+- otherwise,
+
+  ```scala
+type ´t´ >: [´\mathit{tps'}\,´] =>> ´L´
+       <: [´\mathit{tps'}\,´] =>> ´U´
+  ```
+  
+If at least one of the ´\mathit{tps}´ contains an explicit variance annotation, then ´\mathit{tps'} = \mathit{tps}´, otherwise we infer the variance of each type parameter as with the user-written type lambda `[´\mathit{tps}\,´] =>> ´U´`.
+
+The same desugaring applies to type parameters. For instance,
+```scala
+[F[X] <: Coll[X]]
+```
+is treated as a shorthand for
+```scala
+[F >: Nothing <: [X] =>> Coll[X]]
+```
+
+#### Type Alias
+A parameterized type alias
+```scala
+type ´t´[´\mathit{tps}\,´] = ´T´
+```
+is desugared into an unparameterized type alias
+```scala
+type ´t´ = [´\mathit{tps'}\,´] =>> ´T´
+```
+where ´\mathit{tps'}´ is computed as in the previous case.
+
+´\color{red}{\text{TODO SCALA3: Everything else in this section (and the next one
+on type parameters) needs to be rewritten to take into account the desugaring described above.}}´
+
 A _type declaration_ `type ´t´[´\mathit{tps}\,´] >: ´L´ <: ´U´` declares ´t´ to be an abstract type with lower bound type ´L´ and upper bound type ´U´.
 If the type parameter clause `[´\mathit{tps}\,´]` is omitted, ´t´ abstracts over a proper type, otherwise ´t´ stands for a type constructor that accepts type arguments as described by the type parameter clause.
 
diff --git a/docs/_spec/TODOreference/new-types/type-lambdas.md b/docs/_spec/APPLIEDreference/new-types/type-lambdas.md
similarity index 92%
rename from docs/_spec/TODOreference/new-types/type-lambdas.md
rename to docs/_spec/APPLIEDreference/new-types/type-lambdas.md
index ba88e28f5d56..4de3b260c0a2 100644
--- a/docs/_spec/TODOreference/new-types/type-lambdas.md
+++ b/docs/_spec/APPLIEDreference/new-types/type-lambdas.md
@@ -13,5 +13,3 @@ a type definition.
 
 For instance, the type above defines a binary type constructor, which maps arguments `X` and `Y` to `Map[Y, X]`.
 Type parameters of type lambdas can have bounds, but they cannot carry `+` or `-` variance annotations.
-
-[More details](./type-lambdas-spec.md)
diff --git a/docs/_spec/TODOreference/new-types/type-lambdas-spec.md b/docs/_spec/TODOreference/new-types/type-lambdas-spec.md
deleted file mode 100644
index 52f88dab4217..000000000000
--- a/docs/_spec/TODOreference/new-types/type-lambdas-spec.md
+++ /dev/null
@@ -1,116 +0,0 @@
----
-layout: doc-page
-title: "Type Lambdas - More Details"
-nightlyOf: https://docs.scala-lang.org/scala3/reference/new-types/type-lambdas-spec.html
----
-
-## Syntax
-
-```
-Type            ::=  ... |  TypeParamClause ‘=>>’ Type
-TypeParamClause ::=  ‘[’ TypeParam {‘,’ TypeParam} ‘]’
-TypeParam       ::=  {Annotation} (id [HkTypeParamClause] | ‘_’) TypeBounds
-TypeBounds      ::=  [‘>:’ Type] [‘<:’ Type]
-```
-
-## Type Checking
-
-A type lambda such as `[X] =>> F[X]` defines a function from types to types. The parameter(s) may carry bounds.
-If a parameter is bounded, as in `[X >: L <: U] =>> F[X]` it is checked that arguments to the parameters conform to the bounds `L` and `U`.
-Only the upper bound `U` can be F-bounded, i.e. `X` can appear in it.
-
-## Subtyping Rules
-
-Assume two type lambdas
-```scala
-type TL1  =  [X >: L1 <: U1] =>> R1
-type TL2  =  [X >: L2 <: U2] =>> R2
-```
-Then `TL1 <: TL2`, if
-
- - the type interval `L2..U2` is contained in the type interval `L1..U1` (i.e.
-`L1 <: L2` and `U2 <: U1`),
- - `R1 <: R2`
-
-Here we have relied on [alpha renaming](https://en.wikipedia.org/wiki/Lambda_calculus#%CE%B1-conversion) to match the two bound types `X`.
-
-A partially applied type constructor such as `List` is assumed to be equivalent to
-its eta expansion. I.e, `List = [X] =>> List[X]`. This allows type constructors to be compared with type lambdas.
-
-## Relationship with Parameterized Type Definitions
-
-A parameterized type definition
-```scala
-type T[X] = R
-```
-is regarded as a shorthand for an unparameterized definition with a type lambda as right-hand side:
-```scala
-type T = [X] =>> R
-```
-If the type definition carries `+` or `-` variance annotations,
-it is checked that the variance annotations are satisfied by the type lambda.
-For instance,
-```scala
-type F2[A, +B] = A => B
-```
-expands to
-```scala
-type F2 = [A, B] =>> A => B
-```
-and at the same time it is checked that the parameter `B` appears covariantly in `A => B`.
-
-A parameterized abstract type
-```scala
-type T[X] >: L <: U
-```
-is regarded as shorthand for an unparameterized abstract type with type lambdas as bounds.
-```scala
-type T >: ([X] =>> L) <: ([X] =>> U)
-```
-However, if `L` is `Nothing` it is not parameterized, since `Nothing` is treated as a bottom type for all kinds. For instance,
-```scala
-type T[X] <: X => X
-```
-is expanded to
-```scala
-type T >: Nothing <: ([X] =>> X => X)
-```
-instead of
-```scala
-type T >: ([X] =>> Nothing) <: ([X] =>> X => X)
-```
-
-The same expansions apply to type parameters. For instance,
-```scala
-[F[X] <: Coll[X]]
-```
-is treated as a shorthand for
-```scala
-[F >: Nothing <: [X] =>> Coll[X]]
-```
-Abstract types and opaque type aliases remember the variances they were created with. So the type
-```scala
-type F2[-A, +B]
-```
-is known to be contravariant in `A` and covariant in `B` and can be instantiated only
-with types that satisfy these constraints. Likewise
-```scala
-opaque type O[X] = List[X]
-```
-`O` is known to be invariant (and not covariant, as its right-hand side would suggest). On the other hand, a transparent alias
-```scala
-type O2[X] = List[X]
-```
-would be treated as covariant, `X` is used covariantly on its right-hand side.
-
-**Note**: The decision to treat `Nothing` as universal bottom type is provisional, and might be changed after further discussion.
-
-**Note**: Scala 2 and 3 differ in that Scala 2 also treats `Any` as universal top-type. This is not done in Scala 3. See also the discussion on [kind polymorphism](../other-new-features/kind-polymorphism.md)
-
-## Curried Type Parameters
-
-The body of a type lambda can again be a type lambda. Example:
-```scala
-type TL = [X] =>> [Y] =>> (X, Y)
-```
-Currently, no special provision is made to infer type arguments to such curried type lambdas. This is left for future work.

From b8098cee7f435df38e58e22442e9456b4946b2ea Mon Sep 17 00:00:00 2001
From: Fengyun Liu <fengyun.liu.cs@gmail.com>
Date: Mon, 1 May 2023 15:07:30 +0200
Subject: [PATCH 475/657] Correctly handle abstract type in
 isCheckDefinitelyFalse

---
 .../dotty/tools/dotc/transform/TypeTestsCasts.scala   | 11 +++++++----
 tests/neg-custom-args/isInstanceOf/i5826.scala        |  9 +++++++--
 2 files changed, 14 insertions(+), 6 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala b/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
index 15503b475d65..6faf5be98e34 100644
--- a/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
@@ -153,11 +153,14 @@ object TypeTestsCasts {
             val xs = xSpace.decompose.map(_.tp)
             xs.forall(x => isCheckDefinitelyFalse(x, p))
           else
-            val xClass = effectiveClass(x.widen)
-            val pClass = effectiveClass(p.widen)
+            if x.typeSymbol.isClass && p.typeSymbol.isClass then
+              val xClass = effectiveClass(x.widen)
+              val pClass = effectiveClass(p.widen)
 
-            !xClass.derivesFrom(pClass)
-            && (xClass.is(Final) || pClass.is(Final) || !xClass.is(Trait) && !pClass.is(Trait))
+              !xClass.derivesFrom(pClass)
+              && (xClass.is(Final) || pClass.is(Final) || !xClass.is(Trait) && !pClass.is(Trait))
+            else
+              false
     }
 
     def recur(X: Type, P: Type): String = (X <:< P) ||| (P.dealias match {
diff --git a/tests/neg-custom-args/isInstanceOf/i5826.scala b/tests/neg-custom-args/isInstanceOf/i5826.scala
index 89af39958541..e14142e974a8 100644
--- a/tests/neg-custom-args/isInstanceOf/i5826.scala
+++ b/tests/neg-custom-args/isInstanceOf/i5826.scala
@@ -1,6 +1,6 @@
 class Foo {
-  def test[A]: List[Int] | A => Int = {
-    case ls: List[Int] => ls.head       // ok, List decomposes to Some and None
+  def test[A]: (List[Int] | A) => Int = {
+    case ls: List[Int] => ls.head       // error, A = List[String]
     case _ => 0
   }
 
@@ -17,4 +17,9 @@ class Foo {
     case ls: A[X] => 4                 // error
     case _ => 0
   }
+
+  def test4[A](x: List[Int] | (A => Int)) = x match {
+    case ls: List[Int] => ls.head       // ok, List decomposes to Some and None
+    case _ => 0
+  }
 }

From 5344b06e0ab4f38c12900ad96ef7b082fbb4c1c4 Mon Sep 17 00:00:00 2001
From: Fengyun Liu <fengyun.liu.cs@gmail.com>
Date: Mon, 1 May 2023 15:13:33 +0200
Subject: [PATCH 476/657] Refine error message

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

diff --git a/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala b/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
index 6faf5be98e34..6dc9287262c0 100644
--- a/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
@@ -186,12 +186,12 @@ object TypeTestsCasts {
             if res1.isEmpty && res2.isEmpty then res1
             else if res2.isEmpty then
               if isCheckDefinitelyFalse(tp1, P) then res2
-              else i"it cannot be checked against the type $tp1"
+              else res1
             else if res1.isEmpty then
               if isCheckDefinitelyFalse(tp2, P) then res1
-              else i"it cannot be checked against the type $tp2"
+              else res2
             else
-              i"it cannot be checked against the type $tp2"
+              res1
 
           case _ =>
             // always false test warnings are emitted elsewhere

From 4d321163d33e8ce4016220fe6598024e15c0dd7b Mon Sep 17 00:00:00 2001
From: Fengyun Liu <fengyun.liu.cs@gmail.com>
Date: Mon, 1 May 2023 18:13:14 +0200
Subject: [PATCH 477/657] Fix #11541: Specialize ClassTag[T] in exhaustivity
 check

---
 .../src/dotty/tools/dotc/core/Definitions.scala     |  1 +
 .../dotty/tools/dotc/transform/patmat/Space.scala   |  7 ++++++-
 tests/patmat/i11541.scala                           | 13 +++++++++++++
 3 files changed, 20 insertions(+), 1 deletion(-)
 create mode 100644 tests/patmat/i11541.scala

diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
index 85aac4ce601c..b7211b3ce5e3 100644
--- a/compiler/src/dotty/tools/dotc/core/Definitions.scala
+++ b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -798,6 +798,7 @@ class Definitions {
 
   @tu lazy val ReflectPackageClass: Symbol = requiredPackage("scala.reflect.package").moduleClass
   @tu lazy val ClassTagClass: ClassSymbol = requiredClass("scala.reflect.ClassTag")
+    @tu lazy val ClassTagClass_unapply: Symbol = ClassTagClass.requiredMethod("unapply")
   @tu lazy val ClassTagModule: Symbol = ClassTagClass.companionModule
     @tu lazy val ClassTagModule_apply: Symbol = ClassTagModule.requiredMethod(nme.apply)
 
diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index 3e05310d7249..de2fed48bc5d 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -602,10 +602,15 @@ object SpaceEngine {
 
   /** Whether the extractor covers the given type */
   def covers(unapp: TermRef, scrutineeTp: Type, argLen: Int)(using Context): Boolean =
-    SpaceEngine.isIrrefutable(unapp, argLen) || unapp.symbol == defn.TypeTest_unapply && {
+    SpaceEngine.isIrrefutable(unapp, argLen)
+    || unapp.symbol == defn.TypeTest_unapply && {
       val AppliedType(_, _ :: tp :: Nil) = unapp.prefix.widen.dealias: @unchecked
       scrutineeTp <:< tp
     }
+    || unapp.symbol == defn.ClassTagClass_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)(using Context): List[Type] = trace(i"decompose($tp)", debug) {
diff --git a/tests/patmat/i11541.scala b/tests/patmat/i11541.scala
new file mode 100644
index 000000000000..4ac1af08c80b
--- /dev/null
+++ b/tests/patmat/i11541.scala
@@ -0,0 +1,13 @@
+import scala.reflect.ClassTag
+
+class Test:
+  type A
+
+  given ClassTag[A] = ???
+
+  var a: A | Null = null
+
+  a match { //WARNING: match may not be exhaustive. It would fail on pattern case: _: A
+    case null =>
+    case a: A =>
+  }

From ded5d25eb13bbac90c955aa4d9ae99d343e51aaf Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Mon, 1 May 2023 18:46:20 +0200
Subject: [PATCH 478/657] Change logic to find members of recursive types

The previous logic used two boolean variables to selectively create defensive copies.
It was quite complicated. The new logic is simpler and copies less.

 - It copies only if the same recursive type is accessed with two different
   prefixes. As long as the prefix stays the same,no confusion in the
   `substRecThis` is possible.
 - It avoids the openedTwice logic that causes defensive copies at all points
   in the future. It seems that trick is no longer necessary.

Fixes #17380 by avoiding infinite recursion due to defensive copies.
---
 .../src/dotty/tools/dotc/core/Types.scala     | 36 +++++++------------
 tests/pos/i17380.scala                        |  3 ++
 2 files changed, 16 insertions(+), 23 deletions(-)
 create mode 100644 tests/pos/i17380.scala

diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index fe0fc8a6dc2d..f000fe53f239 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -735,33 +735,24 @@ object Types {
         // 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 {
+        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.
+          // twice during findMember with two different prefixes, 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 if the new prefix `pre` is neq the prefix with which the
+          // type was previously opened.
+
+          val openedPre = tp.openedWithPrefix
           val rt =
-            if (tp.opened) { // defensive copy
-              tp.openedTwice = true
+            if openedPre.exists && (openedPre ne pre) then // defensive copy
               RecType(rt => tp.parent.substRecThis(tp, rt.recThis))
-            }
             else tp
-          rt.opened = true
+          rt.openedWithPrefix = pre
           try go(rt.parent).mapInfo(_.substRecThis(rt, pre))
-          finally
-            if (!rt.openedTwice) rt.opened = false
-        }
+          finally rt.openedWithPrefix = NoType
+      end goRec
 
       def goRefined(tp: RefinedType) = {
         val pdenot = go(tp.parent)
@@ -3191,9 +3182,8 @@ object Types {
    */
   class RecType(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
+    // See discussion in findMember#goRec why this field is needed
+    private[Types] var openedWithPrefix: Type = NoType
 
     val parent: Type = parentExp(this: @unchecked)
 
diff --git a/tests/pos/i17380.scala b/tests/pos/i17380.scala
new file mode 100644
index 000000000000..8963db3058b3
--- /dev/null
+++ b/tests/pos/i17380.scala
@@ -0,0 +1,3 @@
+class C { type T; type U }
+
+type X = C { type U = T; def u: U } { type T = String }
\ No newline at end of file

From 879ebdeb07c70484abde7070afbcbcb17afc4828 Mon Sep 17 00:00:00 2001
From: Fengyun Liu <fengyun.liu.cs@gmail.com>
Date: Tue, 2 May 2023 07:25:49 +0200
Subject: [PATCH 479/657] Refine code

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

diff --git a/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala b/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
index 6dc9287262c0..ef0fefecd49e 100644
--- a/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
@@ -134,12 +134,12 @@ object TypeTestsCasts {
 
     /** Whether the check X.isInstanceOf[P] is definitely false? */
     def isCheckDefinitelyFalse(X: Type, P: Type)(using Context): Boolean = trace(s"isCheckDefinitelyFalse(${X.show}, ${P.show})") {
-      X.dealias match
+      X.widenDealias match
       case AndType(x1, x2) =>
         isCheckDefinitelyFalse(x1, P) || isCheckDefinitelyFalse(x2, P)
 
       case x =>
-        P.dealias match
+        P.widenDealias match
         case AndType(p1, p2) =>
           isCheckDefinitelyFalse(x, p1) || isCheckDefinitelyFalse(x, p2)
 
@@ -154,8 +154,8 @@ object TypeTestsCasts {
             xs.forall(x => isCheckDefinitelyFalse(x, p))
           else
             if x.typeSymbol.isClass && p.typeSymbol.isClass then
-              val xClass = effectiveClass(x.widen)
-              val pClass = effectiveClass(p.widen)
+              val xClass = effectiveClass(x)
+              val pClass = effectiveClass(p)
 
               !xClass.derivesFrom(pClass)
               && (xClass.is(Final) || pClass.is(Final) || !xClass.is(Trait) && !pClass.is(Trait))

From 95c39bcd8ec7ff07c009b5824d5f19ae2b5ca873 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 1 May 2023 12:55:08 +0200
Subject: [PATCH 480/657] Cleanup

---
 compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala | 2 +-
 tests/run-staging/quote-nested-2.check                       | 2 +-
 tests/run-staging/quote-nested-5.check                       | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
index 350f90216ba4..a7a74a2a3465 100644
--- a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
+++ b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
@@ -53,7 +53,7 @@ class CrossStageSafety extends TreeMapWithStages {
     else tree match
       case tree @ Quote(quotedTree) =>
         tree.cancelled match
-          case Some(tree1) => transform(tree1.asInstance(tree.tpe)) // TODO is this asInstance still needed?
+          case Some(tree1) => transform(tree1)
           case None => transformQuote(quotedTree, tree)
       case tree @ Splice(splicedTree) =>
         tree.cancelled match
diff --git a/tests/run-staging/quote-nested-2.check b/tests/run-staging/quote-nested-2.check
index b0af638da1a8..7db9edb0424e 100644
--- a/tests/run-staging/quote-nested-2.check
+++ b/tests/run-staging/quote-nested-2.check
@@ -1,4 +1,4 @@
 ((q: scala.quoted.Quotes) ?=> {
   val a: scala.quoted.Expr[scala.Int] = scala.quoted.runtime.Expr.quote[scala.Int](4).apply(using q)
-  ((evidence$2: scala.quoted.Quotes) ?=> a).asInstanceOf[scala.ContextFunction1[scala.quoted.Quotes, scala.quoted.Expr[scala.Int]]].apply(using q)
+  ((evidence$2: scala.quoted.Quotes) ?=> a).apply(using q)
 })
diff --git a/tests/run-staging/quote-nested-5.check b/tests/run-staging/quote-nested-5.check
index d5fee708c460..53600d16a8da 100644
--- a/tests/run-staging/quote-nested-5.check
+++ b/tests/run-staging/quote-nested-5.check
@@ -1,4 +1,4 @@
 ((q: scala.quoted.Quotes) ?=> {
   val a: scala.quoted.Expr[scala.Int] = scala.quoted.runtime.Expr.quote[scala.Int](4).apply(using q)
-  ((q2: scala.quoted.Quotes) ?=> ((evidence$2: scala.quoted.Quotes) ?=> a).asInstanceOf[scala.ContextFunction1[scala.quoted.Quotes, scala.quoted.Expr[scala.Int]]].apply(using q2))
+  ((q2: scala.quoted.Quotes) ?=> ((evidence$2: scala.quoted.Quotes) ?=> a).apply(using q2))
 }.apply(using q))

From 0ca606641d87ec249459f58434e4cdf55e0e79b2 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 1 May 2023 13:05:25 +0200
Subject: [PATCH 481/657] Remove redundant case

---
 .../dotty/tools/dotc/staging/CrossStageSafety.scala   | 11 -----------
 compiler/src/dotty/tools/dotc/staging/HealType.scala  |  2 +-
 2 files changed, 1 insertion(+), 12 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
index a7a74a2a3465..5711fb96cda2 100644
--- a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
+++ b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
@@ -102,8 +102,6 @@ class CrossStageSafety extends TreeMapWithStages {
       case tree: TypeDef if tree.symbol.is(Case) && level > 0 =>
         report.error(reporting.CaseClassInInlinedCode(tree), tree)
         super.transform(tree)
-      case tree @ SplicedType(splicedTree) =>
-        transformSpliceType(splicedTree, tree)
       case _ =>
         super.transform(tree)
   end transform
@@ -163,15 +161,6 @@ class CrossStageSafety extends TreeMapWithStages {
     untpd.cpy.Splice(splice)(body1).withType(tpe1)
   }
 
-  private 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)
-  }
-
   def transformTypeAnnotationSplices(tp: Type)(using Context) = new TypeMap {
     def apply(tp: Type): Type = tp match
       case tp: AnnotatedType =>
diff --git a/compiler/src/dotty/tools/dotc/staging/HealType.scala b/compiler/src/dotty/tools/dotc/staging/HealType.scala
index 337c7e8c9b3b..2facb64746b3 100644
--- a/compiler/src/dotty/tools/dotc/staging/HealType.scala
+++ b/compiler/src/dotty/tools/dotc/staging/HealType.scala
@@ -63,7 +63,7 @@ class HealType(pos: SrcPos)(using Context) extends TypeMap {
 
   private def checkNotWildcardSplice(splice: TypeRef): Unit =
     splice.prefix.termSymbol.info.argInfos match
-      case (tb: TypeBounds) :: _ => report.error(em"Cannot splice $splice because it is a wildcard type", pos)
+      case (tb: TypeBounds) :: _ => report.error(em"Cannot stage $splice because it is an alias to a wildcard type", pos)
       case _ =>
 
   /** Return the root of this path if it is a variable defined in a previous level.

From e3735faabe2824e173cb3eca5b9bd067d50db047 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 1 May 2023 13:19:26 +0200
Subject: [PATCH 482/657] Refactor

---
 .../tools/dotc/staging/CrossStageSafety.scala | 96 +++++++++----------
 1 file changed, 43 insertions(+), 53 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
index 5711fb96cda2..cceb60719289 100644
--- a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
+++ b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
@@ -51,19 +51,53 @@ class CrossStageSafety extends TreeMapWithStages {
     if (tree.source != ctx.source && tree.source.exists)
       transform(tree)(using ctx.withSource(tree.source))
     else tree match
-      case tree @ Quote(quotedTree) =>
+      case tree: Quote =>
         tree.cancelled match
-          case Some(tree1) => transform(tree1)
-          case None => transformQuote(quotedTree, tree)
-      case tree @ Splice(splicedTree) =>
+          case Some(tree1) =>
+            transform(tree1)
+          case None =>
+            if (ctx.property(InAnnotation).isDefined)
+              report.error("Cannot have a quote in an annotation", tree.srcPos)
+            val body1 = transformQuoteBody(tree.body, tree.span)
+            val stripAnnotationsDeep: TypeMap = new TypeMap:
+              def apply(tp: Type): Type = mapOver(tp.stripAnnots)
+            val bodyType1 = healType(tree.srcPos)(stripAnnotationsDeep(tree.bodyType))
+            cpy.Quote(tree)(body1).withBodyType(bodyType1)
+
+      case tree: Splice =>
         tree.cancelled match
-          case Some(tree1) => transform(tree1)
-          case None => transformSplice(splicedTree, tree)
-      case tree @ QuotedTypeOf(quotedTree) =>
-        transformQuotedType(quotedTree, tree)
+          case Some(tree1) =>
+            transform(tree1)
+          case None =>
+            val body1 = transform(tree.expr)(using spliceContext)
+            val tpe1 =
+              if level == 0 then tree.tpe
+              else healType(tree.srcPos)(tree.tpe.widenTermRefExpr)
+            untpd.cpy.Splice(tree)(body1).withType(tpe1)
+
+      case tree @ QuotedTypeOf(body) =>
+        if (ctx.property(InAnnotation).isDefined)
+          report.error("Cannot have a quote in an annotation", tree.srcPos)
+        body.tpe match
+          case DirectTypeOf(termRef) =>
+            // Optimization: `quoted.Type.of[x.Underlying](quotes)`  -->  `x`
+            ref(termRef).withSpan(tree.span)
+          case _ =>
+            transformQuoteBody(body, tree.span) match
+              case DirectTypeOf.Healed(termRef) =>
+                // Optimization: `quoted.Type.of[@SplicedType type T = x.Underlying; T](quotes)`  -->  `x`
+                ref(termRef).withSpan(tree.span)
+              case transformedBody =>
+                val quotes = transform(tree.args.head)
+                // `quoted.Type.of[<body>](quotes)`  --> `quoted.Type.of[<body2>](quotes)`
+                val TypeApply(fun, _) = tree.fun: @unchecked
+                if level != 0 then cpy.Apply(tree)(cpy.TypeApply(tree.fun)(fun, transformedBody :: Nil), quotes :: Nil)
+                else tpd.Quote(transformedBody).select(nme.apply).appliedTo(quotes).withSpan(tree.span)
+
       case _ if !inQuoteOrSpliceScope =>
-        checkAnnotations(tree)
+        checkAnnotations(tree) // Check quotes in annotations
         super.transform(tree)
+
       case _: TypeTree =>
         val tp1 = transformTypeAnnotationSplices(tree.tpe)
         val healedType = healType(tree.srcPos)(tp1)
@@ -106,37 +140,6 @@ class CrossStageSafety extends TreeMapWithStages {
         super.transform(tree)
   end transform
 
-  /** Transform quoted trees while maintaining level correctness */
-  private def transformQuote(body: Tree, quote: Quote)(using Context): Tree = {
-    if (ctx.property(InAnnotation).isDefined)
-      report.error("Cannot have a quote in an annotation", quote.srcPos)
-    val transformedBody = transformQuoteBody(body, quote.span)
-    val stripAnnotationsDeep: TypeMap = new TypeMap:
-      def apply(tp: Type): Type = mapOver(tp.stripAnnots)
-    val bodyType1 = healType(quote.srcPos)(stripAnnotationsDeep(quote.bodyType))
-    cpy.Quote(quote)(transformedBody).withBodyType(bodyType1)
-  }
-
-  private def transformQuotedType(body: Tree, quote: Apply)(using Context): Tree = {
-    if (ctx.property(InAnnotation).isDefined)
-      report.error("Cannot have a quote in an annotation", quote.srcPos)
-    body.tpe match
-      case DirectTypeOf(termRef) =>
-        // Optimization: `quoted.Type.of[x.Underlying](quotes)`  -->  `x`
-        ref(termRef).withSpan(quote.span)
-      case _ =>
-        transformQuoteBody(body, quote.span) match
-          case DirectTypeOf.Healed(termRef) =>
-            // Optimization: `quoted.Type.of[@SplicedType type T = x.Underlying; T](quotes)`  -->  `x`
-            ref(termRef).withSpan(quote.span)
-          case transformedBody =>
-            val quotes = transform(quote.args.head)
-            // `quoted.Type.of[<body>](quotes)`  --> `quoted.Type.of[<body2>](quotes)`
-            val TypeApply(fun, _) = quote.fun: @unchecked
-            if level != 0 then cpy.Apply(quote)(cpy.TypeApply(quote.fun)(fun, transformedBody :: Nil), quotes :: Nil)
-            else tpd.Quote(transformedBody).select(nme.apply).appliedTo(quotes).withSpan(quote.span)
-  }
-
   private def transformQuoteBody(body: Tree, span: Span)(using Context): Tree = {
     val taggedTypes = new QuoteTypeTags(span)
     val contextWithQuote =
@@ -148,19 +151,6 @@ class CrossStageSafety extends TreeMapWithStages {
       case tags => tpd.Block(tags, transformedBody).withSpan(body.span)
   }
 
-  /** 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.
-   */
-  private def transformSplice(body: Tree, splice: Splice)(using Context): Tree = {
-    val body1 = transform(body)(using spliceContext)
-    val tpe1 =
-      if level == 0 then splice.tpe
-      else healType(splice.srcPos)(splice.tpe.widenTermRefExpr)
-    untpd.cpy.Splice(splice)(body1).withType(tpe1)
-  }
-
   def transformTypeAnnotationSplices(tp: Type)(using Context) = new TypeMap {
     def apply(tp: Type): Type = tp match
       case tp: AnnotatedType =>

From 6956c43356010d6d6a144713ee0737bd0baac7c9 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 1 May 2023 13:27:00 +0200
Subject: [PATCH 483/657] Refactor quote cancellation logic

---
 compiler/src/dotty/tools/dotc/ast/Trees.scala | 21 --------
 .../tools/dotc/staging/CrossStageSafety.scala | 52 ++++++++++++-------
 2 files changed, 32 insertions(+), 41 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala
index fbc68ebe63d7..19c189047c6d 100644
--- a/compiler/src/dotty/tools/dotc/ast/Trees.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala
@@ -714,17 +714,6 @@ object Trees {
         defn.FunctionType(1, isContextual = true)
           .appliedTo(defn.QuotesClass.typeRef, exprType)
       withType(quoteType)
-
-    /** Cancel this Quote if it contains a Splice */
-    def cancelled(using Context): Option[Tree[T]] =
-      def rec(tree: Tree[T]): Option[Tree[T]] = tree match
-        case Block(Nil, expr) => rec(expr)
-        case Splice(inner) =>
-          // Optimization: `'{ $x }` --> `x`
-          // and adapt the refinement of `Quotes { type reflect: ... } ?=> Expr[T]`
-          Some(inner)
-        case _ => None
-      rec(body)
   }
 
   /** A tree representing a splice `${ expr }`
@@ -741,16 +730,6 @@ object Trees {
   case class Splice[+T <: Untyped] private[ast] (expr: Tree[T])(implicit @constructorOnly src: SourceFile)
     extends TermTree[T] {
     type ThisTree[+T <: Untyped] = Splice[T]
-
-    /** Cancel this Splice if it contains a Quote */
-    def cancelled(using Context): Option[Tree[T]] =
-      def rec(tree: Tree[T]): Option[Tree[T]] = tree match
-        case Block(Nil, expr1) => rec(expr1)
-        case Quote(body) =>
-          // Optimization: `${ 'x }` --> `x`
-          Some(body)
-        case _ => None
-      rec(expr)
   }
 
   /** A type tree that represents an existing or inferred type */
diff --git a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
index cceb60719289..032067eca482 100644
--- a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
+++ b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
@@ -51,29 +51,25 @@ class CrossStageSafety extends TreeMapWithStages {
     if (tree.source != ctx.source && tree.source.exists)
       transform(tree)(using ctx.withSource(tree.source))
     else tree match
+      case CancelledQuote(tree) =>
+        transform(tree) // Optimization: `'{ $x }` --> `x`
       case tree: Quote =>
-        tree.cancelled match
-          case Some(tree1) =>
-            transform(tree1)
-          case None =>
-            if (ctx.property(InAnnotation).isDefined)
-              report.error("Cannot have a quote in an annotation", tree.srcPos)
-            val body1 = transformQuoteBody(tree.body, tree.span)
-            val stripAnnotationsDeep: TypeMap = new TypeMap:
-              def apply(tp: Type): Type = mapOver(tp.stripAnnots)
-            val bodyType1 = healType(tree.srcPos)(stripAnnotationsDeep(tree.bodyType))
-            cpy.Quote(tree)(body1).withBodyType(bodyType1)
+        if (ctx.property(InAnnotation).isDefined)
+          report.error("Cannot have a quote in an annotation", tree.srcPos)
+        val body1 = transformQuoteBody(tree.body, tree.span)
+        val stripAnnotationsDeep: TypeMap = new TypeMap:
+          def apply(tp: Type): Type = mapOver(tp.stripAnnots)
+        val bodyType1 = healType(tree.srcPos)(stripAnnotationsDeep(tree.bodyType))
+        cpy.Quote(tree)(body1).withBodyType(bodyType1)
 
+      case CancelledSplice(tree) =>
+        transform(tree) // Optimization: `${ 'x }` --> `x`
       case tree: Splice =>
-        tree.cancelled match
-          case Some(tree1) =>
-            transform(tree1)
-          case None =>
-            val body1 = transform(tree.expr)(using spliceContext)
-            val tpe1 =
-              if level == 0 then tree.tpe
-              else healType(tree.srcPos)(tree.tpe.widenTermRefExpr)
-            untpd.cpy.Splice(tree)(body1).withType(tpe1)
+        val body1 = transform(tree.expr)(using spliceContext)
+        val tpe1 =
+          if level == 0 then tree.tpe
+          else healType(tree.srcPos)(tree.tpe.widenTermRefExpr)
+        untpd.cpy.Splice(tree)(body1).withType(tpe1)
 
       case tree @ QuotedTypeOf(body) =>
         if (ctx.property(InAnnotation).isDefined)
@@ -224,4 +220,20 @@ class CrossStageSafety extends TreeMapWithStages {
           | - but the access is at level $level.$hint""", pos)
     tp
   }
+
+  private object CancelledQuote:
+    def unapply(tree: Quote): Option[Tree] =
+      def rec(tree: Tree): Option[Tree] = tree match
+        case Block(Nil, expr) => rec(expr)
+        case Splice(inner) => Some(inner)
+        case _ => None
+      rec(tree.body)
+
+  private object CancelledSplice:
+    def unapply(tree: Splice): Option[Tree] =
+      def rec(tree: Tree): Option[Tree] = tree match
+        case Block(Nil, expr) => rec(expr)
+        case Quote(inner) => Some(inner)
+        case _ => None
+      rec(tree.expr)
 }

From 859f6e6bff9d0b113909507ec4c7acb2b75aee42 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 1 May 2023 14:18:47 +0200
Subject: [PATCH 484/657] Remove unnecessary quotation level change

---
 .../src/dotty/tools/dotc/inlines/PrepareInlineable.scala  | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala b/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
index ed8683bf210e..060c8d21f390 100644
--- a/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/PrepareInlineable.scala
@@ -86,13 +86,7 @@ object PrepareInlineable {
       }
 
       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 eq defn.QuotedTypeModule_of => StagingLevel.quoteContext
-        case _ => ctx
+        postTransform(super.transform(preTransform(tree)))
     }
 
     /** Direct approach: place the accessor with the accessed symbol. This has the

From e4ddc88ba974117e3c95466e40d3ba2414705967 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 1 May 2023 14:21:55 +0200
Subject: [PATCH 485/657] Add missing change of staging level

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

diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala
index 19c189047c6d..77583a9a77e2 100644
--- a/compiler/src/dotty/tools/dotc/ast/Trees.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala
@@ -1705,9 +1705,9 @@ object Trees {
             case Thicket(ts) =>
               this(x, ts)
             case Quote(body) =>
-              this(x, body)
+              this(x, body)(using quoteContext)
             case Splice(expr) =>
-              this(x, expr)
+              this(x, expr)(using spliceContext)
             case Hole(_, _, args, content, tpt) =>
               this(this(this(x, args), content), tpt)
             case _ =>

From 7e8d2b106f5f852c13b2fc8d1ffc89e10b0a426d Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 1 May 2023 14:42:14 +0200
Subject: [PATCH 486/657] Simplify macroDependencies using level from context

---
 .../dotty/tools/dotc/inlines/Inliner.scala    | 38 ++++---------------
 1 file changed, 8 insertions(+), 30 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
index 9179e92527e6..ccef777380e1 100644
--- a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
@@ -23,7 +23,7 @@ import util.Spans.Span
 import dotty.tools.dotc.transform.Splicer
 import dotty.tools.dotc.transform.BetaReduce
 import quoted.QuoteUtils
-import staging.StagingLevel
+import staging.StagingLevel.{level, spliceContext}
 import scala.annotation.constructorOnly
 
 /** General support for inlining */
@@ -834,9 +834,7 @@ class Inliner(val call: tpd.Tree)(using Context):
 
     override def typedSplice(tree: untpd.Splice, pt: Type)(using Context): Tree =
       super.typedSplice(tree, pt) match
-        case tree1 @ Splice(expr)
-            if StagingLevel.level == 0
-            && !hasInliningErrors =>
+        case tree1 @ Splice(expr) if level == 0 && !hasInliningErrors =>
           val expanded = expandMacro(expr, tree1.srcPos)
           transform.TreeChecker.checkMacroGeneratedTree(tree1, expanded)
           typedExpr(expanded) // Inline calls and constant fold code generated by the macro
@@ -1032,9 +1030,9 @@ class Inliner(val call: tpd.Tree)(using Context):
   }
 
   private def expandMacro(body: Tree, splicePos: SrcPos)(using Context) = {
-    assert(StagingLevel.level == 0)
+    assert(level == 0)
     val inlinedFrom = enclosingInlineds.last
-    val dependencies = macroDependencies(body)
+    val dependencies = macroDependencies(body)(using spliceContext)
     val suspendable = ctx.compilationUnit.isSuspendable
     if dependencies.nonEmpty && !ctx.reporter.errorsReported then
       for sym <- dependencies do
@@ -1064,32 +1062,12 @@ class Inliner(val call: tpd.Tree)(using Context):
    */
   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 =>
+        tree match {
+          case tree: RefTree if tree.isTerm && level == -1 && tree.symbol.isDefinedInCurrentRun && !tree.symbol.isLocal =>
             foldOver(tree.symbol :: syms, tree)
-          case Quote(body) =>
-            level += 1
-            try apply(syms, body)
-            finally level -= 1
-          case QuotedTypeOf(body) =>
-            level += 1
-            try apply(syms, body)
-            finally level -= 1
-          case Splice(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)
+          case _: TypTree => syms
+          case _ => foldOver(syms, tree)
         }
     }.apply(Nil, tree)
 end Inliner

From a3c657ba8c86960caf866020443a743f6410b032 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 1 May 2023 14:44:01 +0200
Subject: [PATCH 487/657] Fix typo

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

diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
index 87620db36482..924f2e9ffa92 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -669,7 +669,7 @@ class TreePickler(pickler: TastyPickler) {
           // Add QUOTE tag to TASTy
           assert(body.isTerm,
             """Quote with type should not be pickled.
-              |Quote with type should only exists after staging phase at level staging level 0.""".stripMargin)
+              |Quote with type should only exists after staging phase at staging level 0.""".stripMargin)
           pickleTree(
             // scala.quoted.runtime.Expr.quoted[<tree.bodyType>](<body>)
             ref(defn.QuotedRuntime_exprQuote)

From be3cd481c160336ebfaa9bc2b6e8ebd28a2e2142 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 1 May 2023 14:58:08 +0200
Subject: [PATCH 488/657] Refactor use of Quote

---
 .../tools/dotc/transform/PickleQuotes.scala   | 22 +++++++++++--------
 .../tools/dotc/typer/QuotesAndSplices.scala   |  2 +-
 2 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
index b1a707a70cb1..75af32af247e 100644
--- a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
@@ -104,9 +104,10 @@ class PickleQuotes extends MacroTransform {
           val (contents, codeWithHoles) = makeHoles(quote.body)
           val sourceRef = Inlines.inlineCallTrace(ctx.owner, tree.sourcePos)
           val bodyWithHoles2 =
-            if quote.body.isType then codeWithHoles
+            if quote.isTypeQuote then codeWithHoles
             else Inlined(sourceRef, Nil, codeWithHoles)
-          val pickled = PickleQuotes.pickle(quotes, bodyWithHoles2, contents, quote.bodyType)
+          val quote1 = cpy.Quote(quote)(body = bodyWithHoles2)
+          val pickled = PickleQuotes.pickle(quote1, quotes, contents)
           transform(pickled) // pickle quotes that are in the contents
         case tree: DefDef if !tree.rhs.isEmpty && tree.symbol.isInlineMethod =>
           // Shrink size of the tree. The methods have already been inlined.
@@ -202,7 +203,10 @@ object PickleQuotes {
   val name: String = "pickleQuotes"
   val description: String = "turn quoted trees into explicit run-time data structures"
 
-  def pickle(quotes: Tree, body: Tree, contents: List[Tree], originalTp: Type)(using Context) = {
+  def pickle(quote: Quote, quotes: Tree, contents: List[Tree])(using Context) = {
+    val body = quote.body
+    val bodyType = quote.bodyType
+
     /** Helper methods to construct trees calling methods in `Quotes.reflect` based on the current `quotes` tree */
     object reflect extends ReifiedReflect {
       val quotesTree = quotes
@@ -256,7 +260,7 @@ object PickleQuotes {
       */
     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)
+      ref(lifter).appliedToType(bodyType).select(nme.apply).appliedTo(lit).appliedTo(quotes)
 
     def pickleAsValue(lit: Literal) = {
       // TODO should all constants be pickled as Literals?
@@ -334,18 +338,18 @@ object PickleQuotes {
                 case _ => Match(args(0).annotated(New(ref(defn.UncheckedAnnot.typeRef))), cases)
           )
 
-      val quoteClass = if body.isType then defn.QuotedTypeClass else defn.QuotedExprClass
-      val quotedType = quoteClass.typeRef.appliedTo(originalTp)
+      val quoteClass = if quote.isTypeQuote then defn.QuotedTypeClass else defn.QuotedExprClass
+      val quotedType = quoteClass.typeRef.appliedTo(bodyType)
       val lambdaTpe = MethodType(defn.QuotesClass.typeRef :: Nil, quotedType)
       val unpickleMeth =
-        if body.isType then defn.QuoteUnpickler_unpickleTypeV2
+        if quote.isTypeQuote then defn.QuoteUnpickler_unpickleTypeV2
         else defn.QuoteUnpickler_unpickleExprV2
       val unpickleArgs =
-        if body.isType then List(pickledQuoteStrings, types)
+        if quote.isTypeQuote then List(pickledQuoteStrings, types)
         else List(pickledQuoteStrings, types, termHoles)
       quotes
         .asInstance(defn.QuoteUnpicklerClass.typeRef)
-        .select(unpickleMeth).appliedToType(originalTp)
+        .select(unpickleMeth).appliedToType(bodyType)
         .appliedToArgs(unpickleArgs).withSpan(body.span)
     }
 
diff --git a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
index 5372dc4d04b6..3a5ea05726a5 100644
--- a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
+++ b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
@@ -50,7 +50,7 @@ trait QuotesAndSplices {
 
     if ctx.mode.is(Mode.Pattern) then
       typedQuotePattern(tree, pt, quotes).withSpan(tree.span)
-    else if tree.body.isType then
+    else if tree.isTypeQuote 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.

From 7bd7c921eb480a21ad5533d2966ee8b7a5dd736b Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 1 May 2023 16:36:09 +0200
Subject: [PATCH 489/657] Do not traverse type trees to find inline method
 calls

---
 compiler/src/dotty/tools/dotc/transform/Inlining.scala | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/Inlining.scala b/compiler/src/dotty/tools/dotc/transform/Inlining.scala
index f5b72759b57e..10f73fa94e08 100644
--- a/compiler/src/dotty/tools/dotc/transform/Inlining.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Inlining.scala
@@ -45,8 +45,6 @@ class Inlining extends MacroTransform {
         new TreeTraverser {
           def traverse(tree: Tree)(using Context): Unit =
             tree match
-              case _: GenericApply if tree.symbol == defn.QuotedTypeModule_of =>
-                traverseChildren(tree)(using StagingLevel.quoteContext)
               case tree: RefTree if !Inlines.inInlineMethod && StagingLevel.level == 0 =>
                 assert(!tree.symbol.isInlineMethod, tree.show)
               case _ =>
@@ -95,8 +93,6 @@ class Inlining extends MacroTransform {
           val tree1 = super.transform(tree)
           if tree1.tpe.isError then tree1
           else Inlines.inlineCall(tree1)
-        case _: GenericApply if tree.symbol == defn.QuotedTypeModule_of =>
-          super.transform(tree)(using StagingLevel.quoteContext)
         case _: PackageDef =>
           super.transform(tree) match
             case tree1: PackageDef  =>
@@ -108,7 +104,8 @@ class Inlining extends MacroTransform {
                 case _ => tree1
             case tree1 => tree1
         case _ =>
-          super.transform(tree)
+          if tree.isType then tree
+          else super.transform(tree)
     }
   }
 }

From b991b4066b481d0515441731ea6c1e87b55a77f3 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 1 May 2023 16:38:12 +0200
Subject: [PATCH 490/657] Remove post-condition that is already checked by
 Staging

---
 compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala | 2 --
 1 file changed, 2 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
index 75af32af247e..190d0c983a1c 100644
--- a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
@@ -87,8 +87,6 @@ class PickleQuotes extends MacroTransform {
         assert(Inlines.inInlineMethod)
       case tree: Splice =>
         assert(Inlines.inInlineMethod)
-      case tree: RefTree if !Inlines.inInlineMethod =>
-        assert(tree.symbol != defn.QuotedTypeModule_of)
       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")

From e611139bf865ce11fd7aa35868a5bf930ca06a01 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 1 May 2023 16:52:46 +0200
Subject: [PATCH 491/657] Refactor quote pickling case

---
 .../tools/dotc/transform/PickleQuotes.scala   | 19 ++++++++-----------
 1 file changed, 8 insertions(+), 11 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
index 190d0c983a1c..0c3a94e7d9cd 100644
--- a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
@@ -99,12 +99,7 @@ class PickleQuotes extends MacroTransform {
     override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
       tree match
         case Apply(Select(quote: Quote, nme.apply), List(quotes)) =>
-          val (contents, codeWithHoles) = makeHoles(quote.body)
-          val sourceRef = Inlines.inlineCallTrace(ctx.owner, tree.sourcePos)
-          val bodyWithHoles2 =
-            if quote.isTypeQuote then codeWithHoles
-            else Inlined(sourceRef, Nil, codeWithHoles)
-          val quote1 = cpy.Quote(quote)(body = bodyWithHoles2)
+          val (contents, quote1) = makeHoles(quote)
           val pickled = PickleQuotes.pickle(quote1, quotes, contents)
           transform(pickled) // pickle quotes that are in the contents
         case tree: DefDef if !tree.rhs.isEmpty && tree.symbol.isInlineMethod =>
@@ -115,8 +110,7 @@ class PickleQuotes extends MacroTransform {
           super.transform(tree)
   }
 
-  private def makeHoles(tree: tpd.Tree)(using Context): (List[Tree], tpd.Tree) =
-
+  private def makeHoles(quote: tpd.Quote)(using Context): (List[Tree], tpd.Quote) =
     class HoleContentExtractor extends Transformer:
       private val contents = List.newBuilder[Tree]
       override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
@@ -187,10 +181,13 @@ class PickleQuotes extends MacroTransform {
     end HoleContentExtractor
 
     val holeMaker = new HoleContentExtractor
-    val newTree = holeMaker.transform(tree)
-    (holeMaker.getContents(), newTree)
-
+    val body1 = holeMaker.transform(quote.body)
+    val body2 =
+      if quote.isTypeQuote then body1
+      else Inlined(Inlines.inlineCallTrace(ctx.owner, quote.sourcePos), Nil, body1)
+    val quote1 = cpy.Quote(quote)(body2)
 
+    (holeMaker.getContents(), quote1)
   end makeHoles
 
 }

From 37200bef72c019ea9e23e169ea8a06664f777d56 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 1 May 2023 17:21:51 +0200
Subject: [PATCH 492/657] Cleanup

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

diff --git a/compiler/src/dotty/tools/dotc/transform/Splicing.scala b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
index c833a0800e87..5c333c8c22ea 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicing.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
@@ -228,7 +228,7 @@ class Splicing extends MacroTransform:
           else super.transform(tree)
         case CapturedApplication(fn, argss) =>
           transformCapturedApplication(tree, fn, argss)
-        case Apply(sel @ Select(app @ Quote(body), nme.apply), quotes :: Nil) if level == 0 && body.isTerm =>
+        case Apply(Select(Quote(body), nme.apply), quotes :: Nil) if level == 0 && body.isTerm =>
           body match
             case _: RefTree if isCaptured(body.symbol) => capturedTerm(body)
             case _ => withCurrentQuote(quotes) { super.transform(tree) }

From e75cafe8b297157ea3f36fe9ce3576999b1f20e9 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 1 May 2023 17:26:13 +0200
Subject: [PATCH 493/657] Remove unnecessary widening

---
 compiler/src/dotty/tools/dotc/transform/Splicing.scala | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/Splicing.scala b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
index 5c333c8c22ea..4b288349fc33 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicing.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
@@ -391,9 +391,7 @@ class Splicing extends MacroTransform:
       Splice(closure, tpe)
 
     private def quoted(expr: Tree)(using Context): Tree =
-      untpd.Quote(expr).withBodyType(expr.tpe.widenTermRefExpr) // TODO do we need widenTermRefExpr?
-        .select(nme.apply)
-        .appliedTo(quotes.nn)
+      tpd.Quote(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 {

From 9214daa630cd7450ee47a85b964beef1e893fb01 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 1 May 2023 21:04:46 +0200
Subject: [PATCH 494/657] Apply suggestions from code review

Co-authored-by: Guillaume Martres <smarter@ubuntu.com>
---
 compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
index 924f2e9ffa92..5662b17b6697 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -666,7 +666,7 @@ class TreePickler(pickler: TastyPickler) {
               pickleTree(alias)
           }
         case tree @ Quote(body) =>
-          // Add QUOTE tag to TASTy
+          // TODO: Add QUOTE tag to TASTy
           assert(body.isTerm,
             """Quote with type should not be pickled.
               |Quote with type should only exists after staging phase at staging level 0.""".stripMargin)
@@ -678,7 +678,7 @@ class TreePickler(pickler: TastyPickler) {
               .withSpan(tree.span)
           )
         case Splice(expr) =>
-          pickleTree( // Add SPLICE tag to TASTy
+          pickleTree( // TODO: Add SPLICE tag to TASTy
             // scala.quoted.runtime.Expr.splice[<tree.tpe>](<expr>)
             ref(defn.QuotedRuntime_exprSplice)
               .appliedToType(tree.tpe)

From fdfa1e4b9154d6984147873b54c101806ade439b Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 2 May 2023 09:14:43 +0200
Subject: [PATCH 495/657] Add regression tests

Closes #13376
---
 tests/neg-macros/i13376a.scala | 6 ++++++
 tests/neg-macros/i13376b.scala | 6 ++++++
 tests/pos-macros/i13376a.scala | 7 +++++++
 tests/pos-macros/i13376b.scala | 7 +++++++
 4 files changed, 26 insertions(+)
 create mode 100644 tests/neg-macros/i13376a.scala
 create mode 100644 tests/neg-macros/i13376b.scala
 create mode 100644 tests/pos-macros/i13376a.scala
 create mode 100644 tests/pos-macros/i13376b.scala

diff --git a/tests/neg-macros/i13376a.scala b/tests/neg-macros/i13376a.scala
new file mode 100644
index 000000000000..563513eed232
--- /dev/null
+++ b/tests/neg-macros/i13376a.scala
@@ -0,0 +1,6 @@
+import scala.quoted.*
+trait C:
+  type T
+  def foo: T
+inline def makro(inline x: C): x.T = ${ impl[x.type]('x) } // error // error
+def impl[CC <: C](xp: Expr[CC])(using Quotes): Expr[CC#T] = '{ $xp.foo }
diff --git a/tests/neg-macros/i13376b.scala b/tests/neg-macros/i13376b.scala
new file mode 100644
index 000000000000..8866c24102fd
--- /dev/null
+++ b/tests/neg-macros/i13376b.scala
@@ -0,0 +1,6 @@
+import scala.quoted.*
+trait C:
+  type T
+  def foo: T
+inline def makro(x: C): x.T = ${ impl[x.type]('x) }
+def impl[CC <: C](xp: Expr[CC])(using Quotes): Expr[CC#T] = '{ $xp.foo } // error
diff --git a/tests/pos-macros/i13376a.scala b/tests/pos-macros/i13376a.scala
new file mode 100644
index 000000000000..8e746d0e34a8
--- /dev/null
+++ b/tests/pos-macros/i13376a.scala
@@ -0,0 +1,7 @@
+import scala.quoted.*
+trait C:
+  type T
+  def foo: T
+inline def makro(x: C): x.T = ${ impl[x.T]('x) }
+def impl[U: Type](xp: Expr[C { def foo: U }])(using Quotes): Expr[U] =
+  '{ $xp.foo }
diff --git a/tests/pos-macros/i13376b.scala b/tests/pos-macros/i13376b.scala
new file mode 100644
index 000000000000..8aa171ff07dd
--- /dev/null
+++ b/tests/pos-macros/i13376b.scala
@@ -0,0 +1,7 @@
+import scala.quoted.*
+trait C:
+  type T
+  def foo: T
+inline def makro(inline x: C): C#T = ${ impl('x) }
+def impl[U: Type](xp: Expr[C { def foo: U }])(using Quotes): Expr[U] =
+  '{ $xp.foo }

From fb235681f5ff9b8fc96e3bc064d37b2ea61d94b1 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 2 May 2023 09:22:03 +0200
Subject: [PATCH 496/657] Add regression test

Fix #14123
---
 tests/neg-macros/i14123a.scala |  4 ++++
 tests/neg-macros/i14123b.scala | 23 +++++++++++++++++++++++
 2 files changed, 27 insertions(+)
 create mode 100644 tests/neg-macros/i14123a.scala
 create mode 100644 tests/neg-macros/i14123b.scala

diff --git a/tests/neg-macros/i14123a.scala b/tests/neg-macros/i14123a.scala
new file mode 100644
index 000000000000..29978f85102c
--- /dev/null
+++ b/tests/neg-macros/i14123a.scala
@@ -0,0 +1,4 @@
+import scala.quoted._
+
+def f(foo: Any => Any)(using Quotes): Expr[Any] =
+  '{ println(${ foo[Int]('{???}); ??? }) } // error
diff --git a/tests/neg-macros/i14123b.scala b/tests/neg-macros/i14123b.scala
new file mode 100644
index 000000000000..80cadf518766
--- /dev/null
+++ b/tests/neg-macros/i14123b.scala
@@ -0,0 +1,23 @@
+package x
+
+import scala.quoted._
+
+object Impl {
+
+      sealed trait UpdateOp[+T]
+      case class Assignment[T](value:Expr[T]) extends UpdateOp[T]
+      case class Update(operation:Expr[Unit]) extends UpdateOp[Nothing]
+
+      def genRead[B:Type](newBuilder: Expr[B],
+                          readVal: (Expr[B]) => UpdateOp[B]
+                          )(using Quotes): Expr[B] =
+          '{
+                var x = $newBuilder
+                  ${readVal[B]('x) match { // error: method apply in trait Function1 does not take type parameters
+                    case Assignment(value) => '{ x = $value } // error
+                    case Update(operation) => operation // error
+                  }}
+                x
+          }
+
+}

From 4baffce739f7f6674a58539a435575636b25b549 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 2 May 2023 10:23:11 +0200
Subject: [PATCH 497/657] Add regression test

Closes #9360
---
 tests/pos-macros/i9360.scala | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 tests/pos-macros/i9360.scala

diff --git a/tests/pos-macros/i9360.scala b/tests/pos-macros/i9360.scala
new file mode 100644
index 000000000000..699ef5f38bee
--- /dev/null
+++ b/tests/pos-macros/i9360.scala
@@ -0,0 +1,22 @@
+package a
+
+import scala.quoted._
+
+trait CPM[F[_]]
+
+def fun[M[_],T](t:T)(using m:CPM[M]):M[T] = ???
+
+object M {
+
+  inline def transform[F[_],T](t:T): F[T] =
+     ${ transformImpl[F,T]('t) }
+
+  def transformImpl[F[_]:Type,T:Type](t:Expr[T])(using Quotes):Expr[F[T]] = {
+     import quotes.reflect._
+     t match {
+       case '{ type mt[_]; a.fun[`mt`, tt]($t)(using $m) } => ???
+     }
+
+  }
+
+}

From 3a20cd48ea17ff6cf4a41ca1f7bf2eabb2fbaaed Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Wed, 21 Dec 2022 11:51:04 +0100
Subject: [PATCH 498/657] Add reflect Flags.AbsOverride

---
 .../src/scala/quoted/runtime/impl/QuotesImpl.scala   |  1 +
 library/src/scala/quoted/Quotes.scala                | 12 ++++++++++++
 .../stdlibExperimentalDefinitions.scala              |  1 +
 3 files changed, 14 insertions(+)

diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
index cf967242a715..30be3120bc2e 100644
--- a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
+++ b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
@@ -2800,6 +2800,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     object Flags extends FlagsModule:
       def Abstract: Flags = dotc.core.Flags.Abstract
+      def AbsOverride: Flags = dotc.core.Flags.AbsOverride
       def Artifact: Flags = dotc.core.Flags.Artifact
       def Case: Flags = dotc.core.Flags.Case
       def CaseAccessor: Flags = dotc.core.Flags.CaseAccessor
diff --git a/library/src/scala/quoted/Quotes.scala b/library/src/scala/quoted/Quotes.scala
index 2ead4a8607a3..7cb681f66c51 100644
--- a/library/src/scala/quoted/Quotes.scala
+++ b/library/src/scala/quoted/Quotes.scala
@@ -4373,6 +4373,18 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
       /** Is this symbol `abstract` */
       def Abstract: Flags
 
+      /** Is this symbol is labeled with of abstract & override
+       *
+       *  The override modifier has an additional significance when combined with the abstract modifier.
+       *  That modifier combination is only allowed for value members of traits.
+       *
+       *  We call a member MM of a template incomplete if it is either abstract (i.e. defined by a declaration), or it is labeled abstract and override and every member overridden by MM is again incomplete.
+       *
+       *  Note that the abstract override modifier combination does not influence the concept whether a member is concrete or abstract.
+       *  A member is abstract if only a declaration is given for it; it is concrete if a full definition is given.
+       */
+      @experimental def AbsOverride: Flags
+
       /** Is this generated by Scala compiler.
        *  Corresponds to ACC_SYNTHETIC in the JVM.
        */
diff --git a/tests/run-custom-args/tasty-inspector/stdlibExperimentalDefinitions.scala b/tests/run-custom-args/tasty-inspector/stdlibExperimentalDefinitions.scala
index c278a87bfcde..644efb54c32e 100644
--- a/tests/run-custom-args/tasty-inspector/stdlibExperimentalDefinitions.scala
+++ b/tests/run-custom-args/tasty-inspector/stdlibExperimentalDefinitions.scala
@@ -65,6 +65,7 @@ val experimentalDefinitionInLibrary = Set(
    //// New APIs: Quotes
   // Should be stabilized in 3.4.0
   "scala.quoted.Quotes.reflectModule.defnModule.FunctionClass",
+  "scala.quoted.Quotes.reflectModule.FlagsModule.AbsOverride",
   // Can be stabilized in 3.4.0 (unsure) or later
   "scala.quoted.Quotes.reflectModule.CompilationInfoModule.XmacroSettings",
   "scala.quoted.Quotes.reflectModule.FlagsModule.JavaAnnotation",

From 3c3c0fbb54f6dfd4141ba7be014d092ed2f293be Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Wed, 21 Dec 2022 11:42:58 +0100
Subject: [PATCH 499/657] Check flags for method, val and bind symbols

Co-authored-by: Guillaume Martres <smarter@ubuntu.com>
---
 .../quoted/runtime/impl/QuotesImpl.scala      | 45 ++++++++++++++-----
 library/src/scala/quoted/Quotes.scala         | 20 ++++-----
 2 files changed, 42 insertions(+), 23 deletions(-)

diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
index 30be3120bc2e..d334a1566d52 100644
--- a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
+++ b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
@@ -9,7 +9,6 @@ import dotty.tools.dotc.ast.untpd
 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
 import dotty.tools.dotc.core.NameOps._
 import dotty.tools.dotc.core.StdNames._
@@ -276,12 +275,13 @@ 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 =
-        assert(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 =>
-          xCheckMacroedOwners(xCheckMacroValidExpr(rhsFn(prefss)), symbol).getOrElse(tpd.EmptyTree)
+          xCheckedMacroOwners(xCheckMacroValidExpr(rhsFn(prefss)), symbol).getOrElse(tpd.EmptyTree)
         ))
       def copy(original: Tree)(name: String, paramss: List[ParamClause], tpt: TypeTree, rhs: Option[Term]): DefDef =
-        tpd.cpy.DefDef(original)(name.toTermName, paramss, tpt, xCheckMacroedOwners(rhs, original.symbol).getOrElse(tpd.EmptyTree))
+        tpd.cpy.DefDef(original)(name.toTermName, paramss, tpt, xCheckedMacroOwners(rhs, original.symbol).getOrElse(tpd.EmptyTree))
       def unapply(ddef: DefDef): (String, List[ParamClause], TypeTree, Option[Term]) =
         (ddef.name.toString, ddef.paramss, ddef.tpt, optional(ddef.rhs))
     end DefDef
@@ -307,9 +307,10 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     object ValDef extends ValDefModule:
       def apply(symbol: Symbol, rhs: Option[Term]): ValDef =
-        withDefaultPos(tpd.ValDef(symbol.asTerm, xCheckMacroedOwners(xCheckMacroValidExpr(rhs), symbol).getOrElse(tpd.EmptyTree)))
+        xCheckMacroAssert(!symbol.flags.is(Flags.Method), "expected a symbol without `Method` flag set")
+        withDefaultPos(tpd.ValDef(symbol.asTerm, xCheckedMacroOwners(xCheckMacroValidExpr(rhs), symbol).getOrElse(tpd.EmptyTree)))
       def copy(original: Tree)(name: String, tpt: TypeTree, rhs: Option[Term]): ValDef =
-        tpd.cpy.ValDef(original)(name.toTermName, tpt, xCheckMacroedOwners(xCheckMacroValidExpr(rhs), original.symbol).getOrElse(tpd.EmptyTree))
+        tpd.cpy.ValDef(original)(name.toTermName, tpt, xCheckedMacroOwners(xCheckMacroValidExpr(rhs), original.symbol).getOrElse(tpd.EmptyTree))
       def unapply(vdef: ValDef): (String, TypeTree, Option[Term]) =
         (vdef.name.toString, vdef.tpt, optional(vdef.rhs))
 
@@ -398,7 +399,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
         def etaExpand(owner: Symbol): Term = self.tpe.widen match {
           case mtpe: Types.MethodType if !mtpe.isParamDependent =>
             val closureResType = mtpe.resType match {
-              case t: Types.MethodType => t.toFunctionType(isJava = self.symbol.is(JavaDefined))
+              case t: Types.MethodType => t.toFunctionType(isJava = self.symbol.is(dotc.core.Flags.JavaDefined))
               case t => t
             }
             val closureTpe = Types.MethodType(mtpe.paramNames, mtpe.paramInfos, closureResType)
@@ -811,7 +812,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
     object Lambda extends LambdaModule:
       def apply(owner: Symbol, tpe: MethodType, rhsFn: (Symbol, List[Tree]) => Tree): Block =
         val meth = dotc.core.Symbols.newAnonFun(owner, tpe)
-        withDefaultPos(tpd.Closure(meth, tss => xCheckMacroedOwners(xCheckMacroValidExpr(rhsFn(meth, tss.head.map(withDefaultPos))), meth)))
+        withDefaultPos(tpd.Closure(meth, tss => xCheckedMacroOwners(xCheckMacroValidExpr(rhsFn(meth, tss.head.map(withDefaultPos))), meth)))
 
       def unapply(tree: Block): Option[(List[ValDef], Term)] = tree match {
         case Block((ddef @ DefDef(_, tpd.ValDefs(params) :: Nil, _, Some(body))) :: Nil, Closure(meth, _))
@@ -1482,6 +1483,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
 
     object Bind extends BindModule:
       def apply(sym: Symbol, pattern: Tree): Bind =
+        xCheckMacroAssert(sym.flags.is(Flags.Case), "expected a symbol with `Case` flag set")
         withDefaultPos(tpd.Bind(sym, pattern))
       def copy(original: Tree)(name: String, pattern: Tree): Bind =
         withDefaultPos(tpd.cpy.Bind(original)(name.toTermName, pattern))
@@ -2522,14 +2524,23 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
         newMethod(owner, name, tpe, Flags.EmptyFlags, noSymbol)
       def newMethod(owner: Symbol, name: String, tpe: TypeRepr, flags: Flags, privateWithin: Symbol): Symbol =
         assert(!privateWithin.exists || privateWithin.isType, "privateWithin must be a type symbol or `Symbol.noSymbol`")
+        checkValidFlags(flags.toTermFlags, Flags.validMethodFlags)
         dotc.core.Symbols.newSymbol(owner, name.toTermName, flags | dotc.core.Flags.Method, tpe, privateWithin)
       def newVal(owner: Symbol, name: String, tpe: TypeRepr, flags: Flags, privateWithin: Symbol): Symbol =
         assert(!privateWithin.exists || privateWithin.isType, "privateWithin must be a type symbol or `Symbol.noSymbol`")
+        checkValidFlags(flags.toTermFlags, Flags.validValFlags)
         dotc.core.Symbols.newSymbol(owner, name.toTermName, flags, tpe, privateWithin)
       def newBind(owner: Symbol, name: String, flags: Flags, tpe: TypeRepr): Symbol =
-        dotc.core.Symbols.newSymbol(owner, name.toTermName, flags | Case, tpe)
+        checkValidFlags(flags.toTermFlags, Flags.validBindFlags)
+        dotc.core.Symbols.newSymbol(owner, name.toTermName, flags | dotc.core.Flags.Case, tpe)
       def noSymbol: Symbol = dotc.core.Symbols.NoSymbol
 
+      private inline def checkValidFlags(inline flags: Flags, inline valid: Flags): Unit =
+        xCheckMacroAssert(
+          flags <= valid,
+          s"Received invalid flags. Expected flags ${flags.show} to only contain a subset of ${valid.show}."
+        )
+
       def freshName(prefix: String): String =
         NameKinds.MacroNames.fresh(prefix.toTermName).toString
     end Symbol
@@ -2602,7 +2613,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
           self.isTerm && !self.is(dotc.core.Flags.Method) && !self.is(dotc.core.Flags.Case/*, FIXME add this check and fix sourcecode butNot = Enum | Module*/)
         def isDefDef: Boolean = self.is(dotc.core.Flags.Method)
         def isBind: Boolean =
-          self.is(dotc.core.Flags.Case, butNot = Enum | Module) && !self.isClass
+          self.is(dotc.core.Flags.Case, butNot = dotc.core.Flags.Enum | dotc.core.Flags.Module) && !self.isClass
         def isNoSymbol: Boolean = self == Symbol.noSymbol
         def exists: Boolean = self != Symbol.noSymbol
 
@@ -2846,6 +2857,13 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
       def Synthetic: Flags = dotc.core.Flags.Synthetic
       def Trait: Flags = dotc.core.Flags.Trait
       def Transparent: Flags = dotc.core.Flags.Transparent
+
+      // Keep: aligned with Quotes's `newMethod` doc
+      private[QuotesImpl] def validMethodFlags: Flags = Private | Protected | Override | Deferred | Final | Method | Implicit | Given | Local | AbsOverride | JavaStatic // Flags that could be allowed: Synthetic | ExtensionMethod | Exported | Erased | Infix | Invisible
+      // Keep: aligned with Quotes's `newVal` doc
+      private[QuotesImpl] def validValFlags: Flags = Private | Protected | Override | Deferred | Final | Param | Implicit | Lazy | Mutable | Local | ParamAccessor | Module | Package | Case | CaseAccessor | Given | Enum | AbsOverride | JavaStatic // Flags that could be added: Synthetic | Erased | Invisible
+      // Keep: aligned with Quotes's `newBind` doc
+      private[QuotesImpl] def validBindFlags: Flags = Case // Flags that could be allowed: Implicit | Given | Erased
     end Flags
 
     given FlagsMethods: FlagsMethods with
@@ -2966,7 +2984,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
     /** Checks that all definitions in this tree have the expected owner.
      *  Nested definitions are ignored and assumed to be correct by construction.
      */
-    private def xCheckMacroedOwners(tree: Option[Tree], owner: Symbol): tree.type =
+    private def xCheckedMacroOwners(tree: Option[Tree], owner: Symbol): tree.type =
       if xCheckMacro then
         tree match
           case Some(tree) =>
@@ -2977,7 +2995,7 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
     /** Checks that all definitions in this tree have the expected owner.
      *  Nested definitions are ignored and assumed to be correct by construction.
      */
-    private def xCheckMacroedOwners(tree: Tree, owner: Symbol): tree.type =
+    private def xCheckedMacroOwners(tree: Tree, owner: Symbol): tree.type =
       if xCheckMacro then
         xCheckMacroOwners(tree, owner)
       tree
@@ -3048,6 +3066,9 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
           "Reference to a method must be eta-expanded before it is used as an expression: " + term.show)
       term
 
+    private inline def xCheckMacroAssert(inline cond: Boolean, inline msg: String): Unit =
+      assert(!xCheckMacro || cond, msg)
+
     object Printer extends PrinterModule:
 
       lazy val TreeCode: Printer[Tree] = new Printer[Tree]:
diff --git a/library/src/scala/quoted/Quotes.scala b/library/src/scala/quoted/Quotes.scala
index 7cb681f66c51..c7d5719b0e1f 100644
--- a/library/src/scala/quoted/Quotes.scala
+++ b/library/src/scala/quoted/Quotes.scala
@@ -3785,9 +3785,10 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
       *  @param parent The owner of the method
       *  @param name The name of the method
       *  @param tpe The type of the method (MethodType, PolyType, ByNameType)
-      *  @param flags extra flags to with which the symbol should be constructed
+      *  @param flags extra flags to with which the symbol should be constructed. `Method` flag will be added. Can be `Private | Protected | Override | Deferred | Final | Method | Implicit | Given | Local | JavaStatic`
       *  @param privateWithin the symbol within which this new method symbol should be private. May be noSymbol.
       */
+      // Keep: `flags` doc aligned with QuotesImpl's `validMethodFlags`
       def newMethod(parent: Symbol, name: String, tpe: TypeRepr, flags: Flags, privateWithin: Symbol): Symbol
 
       /** Generates a new val/var/lazy val symbol with the given parent, name and type.
@@ -3801,11 +3802,12 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
       *  @param parent The owner of the val/var/lazy val
       *  @param name The name of the val/var/lazy val
       *  @param tpe The type of the val/var/lazy val
-      *  @param flags extra flags to with which the symbol should be constructed
+      *  @param flags extra flags to with which the symbol should be constructed. Can be `Private | Protected | Override | Deferred | Final | Param | Implicit | Lazy | Mutable | Local | ParamAccessor | Module | Package | Case | CaseAccessor | Given | Enum | JavaStatic`
       *  @param privateWithin the symbol within which this new method symbol should be private. May be noSymbol.
       *  @note As a macro can only splice code into the point at which it is expanded, all generated symbols must be
       *        direct or indirect children of the reflection context's owner.
       */
+      // Keep: `flags` doc aligned with QuotesImpl's `validValFlags`
       def newVal(parent: Symbol, name: String, tpe: TypeRepr, flags: Flags, privateWithin: Symbol): Symbol
 
       /** Generates a pattern bind symbol with the given parent, name and type.
@@ -3816,11 +3818,12 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
       *
       *  @param parent The owner of the binding
       *  @param name The name of the binding
-      *  @param flags extra flags to with which the symbol should be constructed
+      *  @param flags extra flags to with which the symbol should be constructed. `Case` flag will be added. Can be `Case`
       *  @param tpe The type of the binding
       *  @note As a macro can only splice code into the point at which it is expanded, all generated symbols must be
       *        direct or indirect children of the reflection context's owner.
       */
+      // Keep: `flags` doc aligned with QuotesImpl's `validBindFlags`
       def newBind(parent: Symbol, name: String, flags: Flags, tpe: TypeRepr): Symbol
 
       /** Definition not available */
@@ -4373,15 +4376,10 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
       /** Is this symbol `abstract` */
       def Abstract: Flags
 
-      /** Is this symbol is labeled with of abstract & override
+      /** Is this an abstract override method?
        *
-       *  The override modifier has an additional significance when combined with the abstract modifier.
-       *  That modifier combination is only allowed for value members of traits.
-       *
-       *  We call a member MM of a template incomplete if it is either abstract (i.e. defined by a declaration), or it is labeled abstract and override and every member overridden by MM is again incomplete.
-       *
-       *  Note that the abstract override modifier combination does not influence the concept whether a member is concrete or abstract.
-       *  A member is abstract if only a declaration is given for it; it is concrete if a full definition is given.
+       *  This corresponds to a definition declared as "abstract override def" in the source.
+       * See https://stackoverflow.com/questions/23645172/why-is-abstract-override-required-not-override-alone-in-subtrait for examples.
        */
       @experimental def AbsOverride: Flags
 

From 0cf8b5182ddd9dba487d0e1430cec60710ec0d78 Mon Sep 17 00:00:00 2001
From: Jamie Thompson <bishbashboshjt@gmail.com>
Date: Fri, 28 Apr 2023 12:00:02 +0200
Subject: [PATCH 500/657] apply enums/adts.md

---
 docs/_spec/05-classes-and-objects.md      |  49 ++++++
 docs/_spec/APPLIEDreference/enums/adts.md |  90 +++++++++++
 docs/_spec/TODOreference/enums/adts.md    | 173 ----------------------
 3 files changed, 139 insertions(+), 173 deletions(-)
 create mode 100644 docs/_spec/APPLIEDreference/enums/adts.md
 delete mode 100644 docs/_spec/TODOreference/enums/adts.md

diff --git a/docs/_spec/05-classes-and-objects.md b/docs/_spec/05-classes-and-objects.md
index 5de7048ba00e..e3fa8fe3e613 100644
--- a/docs/_spec/05-classes-and-objects.md
+++ b/docs/_spec/05-classes-and-objects.md
@@ -801,3 +801,52 @@ Generally, a _companion module_ of a class is an object which has the same name
 Conversely, the class is called the _companion class_ of the module.
 
 Very much like a concrete class definition, an object definition may still contain declarations of abstract type members, but not of abstract term members.
+
+## Enum Definitions
+
+<!-- TODO: Agree with NTs of rest of spec -->
+```ebnf
+TmplDef   ::=  ‘enum’ EnumDef
+EnumDef   ::=  id ClassConstr [‘extends’ [ConstrApps]] EnumBody
+EnumBody  ::=  [nl] ‘{’ [SelfType] EnumStat {semi EnumStat} ‘}’
+EnumStat  ::=  TemplateStat
+            |  {Annotation [nl]} {Modifier} EnumCase
+```
+
+### Enum Cases
+<!-- TODO: Agree with NTs of rest of spec -->
+```ebnf
+EnumCase  ::=  ‘case’ (id ClassConstr [‘extends’ ConstrApps] | ids)
+```
+
+<!-- TODO: an enum case is defined in terms of other scala constructs... -->
+
+### Variance for Type Parameters
+
+A parameterized enum case ´C´  of enum ´E´ with _inferred_ type parameters will copy variance annotations.
+e.g. type parameter ´T_{i}´ from ´E´ will have the same variance as type parameter `´T'_{i}´` in ´C´.
+
+###### Example
+
+The following enum `View` has a contravariant type parameter ´T´ and a single case `Refl`, representing a function mapping a type `T` to itself:
+
+```scala
+enum View[-´T´]:
+  case Refl(f: ´T´ => ´T´)
+```
+
+`Refl` expands to the following enum:
+
+```scala
+enum View[-´T´]:
+  case Refl[-´T'´](f: ´T'´ => ´T'´) extends View[´T'´]
+```
+
+The definition of `Refl` is incorrectly typed, as it uses contravariant type `´T'´` in the covariant result position of a function type.
+
+A correctly typed version would use an _explicit_, _invariant_ type parameter `´R´` on case `Refl`:
+
+```scala
+enum View[-´T´]:
+  case Refl[´R´](f: ´R´ => ´R´) extends View[´R´]
+```
\ No newline at end of file
diff --git a/docs/_spec/APPLIEDreference/enums/adts.md b/docs/_spec/APPLIEDreference/enums/adts.md
new file mode 100644
index 000000000000..23599e49dc5b
--- /dev/null
+++ b/docs/_spec/APPLIEDreference/enums/adts.md
@@ -0,0 +1,90 @@
+---
+layout: doc-page
+title: "Algebraic Data Types"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/enums/adts.html
+---
+
+The [`enum` concept](./enums.md) is general enough to also support algebraic data types (ADTs) and their generalized version (GADTs).
+Here is an example how an `Option` type can be represented as an ADT:
+
+```scala
+enum Option[+T]:
+  case Some(x: T)
+  case None
+```
+
+This example introduces an `Option` enum with a covariant type parameter `T` consisting of two cases, `Some` and `None`.
+`Some` is parameterized with a value parameter `x`.
+It is a shorthand for writing a case class that extends `Option`.
+Since `None` is not parameterized, it is treated as a normal enum value.
+
+The `extends` clauses that were omitted in the example above can also be given explicitly:
+
+```scala
+enum Option[+T]:
+  case Some(x: T) extends Option[T]
+  case None       extends Option[Nothing]
+```
+
+Note that the parent type of the `None` value is inferred as `Option[Nothing]`.
+Generally, all covariant type parameters of the enum class are minimized in a compiler-generated `extends` clause whereas all contravariant type parameters are maximized.
+If `Option` was non-variant, you would need to give the extends clause of `None` explicitly.
+
+As for normal enum values, the cases of an `enum` are all defined in the `enum`'s companion object.
+So it's `Option.Some` and `Option.None` unless the definitions are "pulled out" with an import.
+
+
+## Widening of Constructor Application
+
+Observe here the inferred result types of the following expressions:
+```scala
+scala> Option.Some("hello")
+val res1: t2.Option[String] = Some(hello)
+
+scala> Option.None
+val res2: t2.Option[Nothing] = None
+```
+
+Note that the type of the expressions above is always `Option`.
+Generally, the type of a enum case constructor application will be widened to the underlying enum type, unless a more specific type is expected.
+This is a subtle difference with respect to normal case classes.
+The classes making up the cases do exist, and can be unveiled, either by constructing them directly with a `new`, or by explicitly providing an expected type.
+
+```scala
+scala> new Option.Some(2)
+val res3: Option.Some[Int] = Some(2)
+scala> val x: Option.Some[Int] = Option.Some(3)
+val res4: Option.Some[Int] = Some(3)
+```
+
+As all other enums, ADTs can define methods.
+For instance, here is `Option` again, with an `isDefined` method and an `Option(...)` constructor in its companion object.
+
+```scala
+enum Option[+T]:
+  case Some(x: T)
+  case None
+
+  def isDefined: Boolean = this match
+    case None => false
+    case _    => true
+
+object Option:
+
+  def apply[T >: Null](x: T): Option[T] =
+    if x == null then None else Some(x)
+
+end Option
+```
+
+Enumerations and ADTs have been presented as two different concepts.
+But since they share the same syntactic construct, they can be seen simply as two ends of a spectrum and it is perfectly possible to construct hybrids.
+For instance, the code below gives an implementation of `Color` either with three enum values or with a parameterized case that takes an RGB value.
+
+```scala
+enum Color(val rgb: Int):
+  case Red   extends Color(0xFF0000)
+  case Green extends Color(0x00FF00)
+  case Blue  extends Color(0x0000FF)
+  case Mix(mix: Int) extends Color(mix)
+```
diff --git a/docs/_spec/TODOreference/enums/adts.md b/docs/_spec/TODOreference/enums/adts.md
deleted file mode 100644
index 3ab8c9f3b45b..000000000000
--- a/docs/_spec/TODOreference/enums/adts.md
+++ /dev/null
@@ -1,173 +0,0 @@
----
-layout: doc-page
-title: "Algebraic Data Types"
-nightlyOf: https://docs.scala-lang.org/scala3/reference/enums/adts.html
----
-
-The [`enum` concept](./enums.md) is general enough to also support algebraic data
-types (ADTs) and their generalized version (GADTs). Here is an example
-how an `Option` type can be represented as an ADT:
-
-```scala
-enum Option[+T]:
-  case Some(x: T)
-  case None
-```
-
-This example introduces an `Option` enum with a covariant type
-parameter `T` consisting of two cases, `Some` and `None`. `Some` is
-parameterized with a value parameter `x`. It is a shorthand for writing a
-case class that extends `Option`. Since `None` is not parameterized, it
-is treated as a normal enum value.
-
-The `extends` clauses that were omitted in the example above can also
-be given explicitly:
-
-```scala
-enum Option[+T]:
-  case Some(x: T) extends Option[T]
-  case None       extends Option[Nothing]
-```
-
-Note that the parent type of the `None` value is inferred as
-`Option[Nothing]`. Generally, all covariant type parameters of the enum
-class are minimized in a compiler-generated `extends` clause whereas all
-contravariant type parameters are maximized. If `Option` was non-variant,
-you would need to give the extends clause of `None` explicitly.
-
-As for normal enum values, the cases of an `enum` are all defined in
-the `enum`s companion object. So it's `Option.Some` and `Option.None`
-unless the definitions are "pulled out" with an import:
-
-```scala
-scala> Option.Some("hello")
-val res1: t2.Option[String] = Some(hello)
-
-scala> Option.None
-val res2: t2.Option[Nothing] = None
-```
-
-Note that the type of the expressions above is always `Option`. Generally, the type of a enum case constructor application will be widened to the underlying enum type, unless a more specific type is expected. This is a subtle difference with respect to normal case classes. The classes making up the cases do exist, and can be unveiled, either by constructing them directly with a `new`, or by explicitly providing an expected type.
-
-```scala
-scala> new Option.Some(2)
-val res3: Option.Some[Int] = Some(2)
-scala> val x: Option.Some[Int] = Option.Some(3)
-val res4: Option.Some[Int] = Some(3)
-```
-
-As all other enums, ADTs can define methods. For instance, here is `Option` again, with an
-`isDefined` method and an `Option(...)` constructor in its companion object.
-
-```scala
-enum Option[+T]:
-  case Some(x: T)
-  case None
-
-  def isDefined: Boolean = this match
-    case None => false
-    case _    => true
-
-object Option:
-
-  def apply[T >: Null](x: T): Option[T] =
-    if x == null then None else Some(x)
-
-end Option
-```
-
-Enumerations and ADTs have been presented as two different
-concepts. But since they share the same syntactic construct, they can
-be seen simply as two ends of a spectrum and it is perfectly possible
-to construct hybrids. For instance, the code below gives an
-implementation of `Color` either with three enum values or with a
-parameterized case that takes an RGB value.
-
-```scala
-enum Color(val rgb: Int):
-  case Red   extends Color(0xFF0000)
-  case Green extends Color(0x00FF00)
-  case Blue  extends Color(0x0000FF)
-  case Mix(mix: Int) extends Color(mix)
-```
-
-## Parameter Variance of Enums
-
-By default, parameterized cases of enums with type parameters will copy the type parameters of their parent, along
-with any variance notations. As usual, it is important to use type parameters carefully when they are variant, as shown
-below:
-
-The following `View` enum has a contravariant type parameter `T` and a single case `Refl`, representing a function
-mapping a type `T` to itself:
-
-```scala
-enum View[-T]:
-  case Refl(f: T => T)
-```
-
-The definition of `Refl` is incorrect, as it uses contravariant type `T` in the covariant result position of a
-function type, leading to the following error:
-
-```scala
--- Error: View.scala:2:12 --------
-2 |   case Refl(f: T => T)
-  |             ^^^^^^^^^
-  |contravariant type T occurs in covariant position in type T => T of value f
-  |enum case Refl requires explicit declaration of type T to resolve this issue.
-```
-
-Because `Refl` does not declare explicit parameters, it looks to the compiler like the following:
-
-```scala
-enum View[-T]:
-  case Refl[/*synthetic*/-T1](f: T1 => T1) extends View[T1]
-```
-
-The compiler has inferred for `Refl` the contravariant type parameter `T1`, following `T` in `View`.
-We can now clearly see that `Refl` needs to declare its own non-variant type parameter to correctly type `f`,
-and can remedy the error by the following change to `Refl`:
-
-```diff
-enum View[-T]:
--  case Refl(f: T => T)
-+  case Refl[R](f: R => R) extends View[R]
-```
-
-Above, type `R` is chosen as the parameter for `Refl` to highlight that it has a different meaning to
-type `T` in `View`, but any name will do.
-
-After some further changes, a more complete implementation of `View` can be given as follows and be used
-as the function type `T => U`:
-
-```scala
-enum View[-T, +U] extends (T => U):
-  case Refl[R](f: R => R) extends View[R, R]
-
-  final def apply(t: T): U = this match
-    case refl: Refl[r] => refl.f(t)
-```
-
-## Syntax of Enums
-
-Changes to the syntax fall in two categories: enum definitions and cases inside enums.
-The changes are specified below as deltas with respect to the Scala syntax given [here](../syntax.md)
-
- 1. Enum definitions are defined as follows:
-
-    ```
-    TmplDef   ::=  `enum' EnumDef
-    EnumDef   ::=  id ClassConstr [`extends' [ConstrApps]] EnumBody
-    EnumBody  ::=  [nl] ‘{’ [SelfType] EnumStat {semi EnumStat} ‘}’
-    EnumStat  ::=  TemplateStat
-                |  {Annotation [nl]} {Modifier} EnumCase
-    ```
-
- 2. Cases of enums are defined as follows:
-
-    ```
-    EnumCase  ::=  `case' (id ClassConstr [`extends' ConstrApps]] | ids)
-    ```
-
-## Reference
-
-For more information, see [Issue #1970](https://github.com/lampepfl/dotty/issues/1970).

From 8be388a1b227f9525ac57212697a57879714f1a4 Mon Sep 17 00:00:00 2001
From: Jamie Thompson <bishbashboshjt@gmail.com>
Date: Fri, 28 Apr 2023 12:01:11 +0200
Subject: [PATCH 501/657] apply enums/enums-index.md

---
 .../{TODOreference => APPLIEDreference}/enums/enums-index.md      | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename docs/_spec/{TODOreference => APPLIEDreference}/enums/enums-index.md (100%)

diff --git a/docs/_spec/TODOreference/enums/enums-index.md b/docs/_spec/APPLIEDreference/enums/enums-index.md
similarity index 100%
rename from docs/_spec/TODOreference/enums/enums-index.md
rename to docs/_spec/APPLIEDreference/enums/enums-index.md

From 471755329dfe276a3413da2d329e0e62d6771170 Mon Sep 17 00:00:00 2001
From: Jamie Thompson <bishbashboshjt@gmail.com>
Date: Fri, 28 Apr 2023 12:32:10 +0200
Subject: [PATCH 502/657] apply enums/enums.md

---
 docs/_spec/05-classes-and-objects.md          | 52 +++++++++++
 docs/_spec/12-the-scala-standard-library.md   |  4 +
 .../enums/enums.md                            | 88 +++++--------------
 3 files changed, 80 insertions(+), 64 deletions(-)
 rename docs/_spec/{TODOreference => APPLIEDreference}/enums/enums.md (64%)

diff --git a/docs/_spec/05-classes-and-objects.md b/docs/_spec/05-classes-and-objects.md
index e3fa8fe3e613..ea8c7bbb43fd 100644
--- a/docs/_spec/05-classes-and-objects.md
+++ b/docs/_spec/05-classes-and-objects.md
@@ -821,6 +821,58 @@ EnumCase  ::=  ‘case’ (id ClassConstr [‘extends’ ConstrApps] | ids)
 
 <!-- TODO: an enum case is defined in terms of other scala constructs... -->
 
+### Lowering of Enum Definitions
+
+Enums are represented as `sealed` classes that extend the `scala.reflect.Enum` trait.
+This trait defines a single public method, `ordinal`:
+
+```scala
+package scala.reflect
+
+transparent trait Enum extends Any, Product, Serializable:
+
+  def ordinal: Int
+```
+
+Simple enum cases all share a single implementation class.
+
+Value enum cases will each be implemented by a unique class.
+
+###### Example
+Consider the enumeration `RGB`, consisting of simple enum cases:
+```scala
+enum RGB:
+  case Red, Green, Blue
+```
+
+Each simple case `Red`, `Green`, and `Blue` will be instantiated using a private method that takes a tag and a name as arguments.
+
+For instance, the first definition of value `Color.Red` above would expand to:
+
+```scala
+val Red: Color = $new(0, "Red")
+```
+
+
+###### Example
+
+Consider the more complex enumeration `Color`, consisting of value enum cases:
+```scala
+enum Color(val rgb: Int):
+  case Red   extends Color(0xFF0000)
+  case Green extends Color(0x00FF00)
+  case Blue  extends Color(0x0000FF)
+```
+
+Each value case will expand as follows, for instance `Green` expands to
+
+```scala
+val Green: Color = new Color(0x00FF00):
+  def ordinal: Int = 1
+  override def productPrefix: String = "Green"
+  override def toString: String = "Green"
+```
+
 ### Variance for Type Parameters
 
 A parameterized enum case ´C´  of enum ´E´ with _inferred_ type parameters will copy variance annotations.
diff --git a/docs/_spec/12-the-scala-standard-library.md b/docs/_spec/12-the-scala-standard-library.md
index 14d1fb82aea4..441955df9b4f 100644
--- a/docs/_spec/12-the-scala-standard-library.md
+++ b/docs/_spec/12-the-scala-standard-library.md
@@ -345,6 +345,10 @@ class PartialFunction[-A, +B] extends Function1[A, B] {
 <!-- TODO: Could not find more info on which non-Product methods case class automatically define  -->
 All case classes automatically extend the `Product` trait (and generate synthetic methods to conform to it) (but not `Product´n´`), and define a `_´n´` method for each of their arguments.
 
+### Trait `Enum`
+<!-- TODO: Move somewhere else ? -->
+All enum definitions automatically extend the `reflect.Enum` trait (and generate synthetic methods to conform to it).
+
 ### Class `Array`
 
 All operations on arrays desugar to the corresponding operations of the underlying platform.
diff --git a/docs/_spec/TODOreference/enums/enums.md b/docs/_spec/APPLIEDreference/enums/enums.md
similarity index 64%
rename from docs/_spec/TODOreference/enums/enums.md
rename to docs/_spec/APPLIEDreference/enums/enums.md
index 65051bdfb39f..bcab50d3a36d 100644
--- a/docs/_spec/TODOreference/enums/enums.md
+++ b/docs/_spec/APPLIEDreference/enums/enums.md
@@ -11,9 +11,8 @@ enum Color:
   case Red, Green, Blue
 ```
 
-This defines a new `sealed` class, `Color`, with three values, `Color.Red`,
-`Color.Green`, `Color.Blue`.  The color values are members of `Color`s
-companion object.
+This defines a new `sealed` class, `Color`, with three values, `Color.Red`, `Color.Green`, `Color.Blue`.
+The color values are members of `Color`s companion object.
 
 ## Parameterized enums
 
@@ -26,13 +25,12 @@ enum Color(val rgb: Int):
   case Blue  extends Color(0x0000FF)
 ```
 
-As the example shows, you can define the parameter value by using an
-explicit extends clause.
+As the example shows, you can define the parameter value by using an explicit extends clause.
 
 ## Methods defined for enums
 
-The values of an enum correspond to unique integers. The integer
-associated with an enum value is returned by its `ordinal` method:
+The values of an enum correspond to unique integers.
+The integer associated with an enum value is returned by its `ordinal` method:
 
 ```scala
 scala> val red = Color.Red
@@ -42,10 +40,9 @@ val res0: Int = 0
 ```
 
 The companion object of an enum also defines three utility methods.
-The `valueOf` method obtains an enum value
-by its name. The `values` method returns all enum values
-defined in an enumeration in an `Array`. The `fromOrdinal`
-method obtains an enum value from its ordinal (`Int`) value.
+The `valueOf` method obtains an enum value by its name.
+The `values` method returns all enum values defined in an enumeration in an `Array`.
+The `fromOrdinal` method obtains an enum value from its ordinal (`Int`) value.
 
 ```scala
 scala> Color.valueOf("Blue")
@@ -58,7 +55,8 @@ val res2: Color = Red
 
 ## User-defined members of enums
 
-It is possible to add your own definitions to an enum. Example:
+It is possible to add your own definitions to an enum.
+For example:
 
 ```scala
 enum Planet(mass: Double, radius: Double):
@@ -94,11 +92,10 @@ end Planet
 
 Enum case declarations are similar to secondary constructors:
 they are scoped outside of the enum template, despite being declared within it.
-This means that enum case declarations cannot access inner members of the
-enum class.
+This means that enum case declarations cannot access inner members of the enum class.
 
-Similarly, enum case declarations may not directly reference members of the enum's companion object,
-even if they are imported (directly, or by renaming). For example:
+Similarly, enum case declarations may not directly reference members of the enum's companion object, even if they are imported (directly, or by renaming).
+For example:
 
 ```scala
 import Planet.*
@@ -113,13 +110,13 @@ object Planet:
   private final val (earthMass, earthRadius) = (5.976e+24, 6.37814e6)
 end Planet
 ```
-The fields referenced by `Mercury` are not visible, and the fields referenced by `Venus` may not
-be referenced directly (using `import Planet.*`). You must use an indirect reference,
-such as demonstrated with `Earth`.
+The fields referenced by `Mercury` are not visible, and the fields referenced by `Venus` may not be referenced directly (using `import Planet.*`).
+You must use an indirect reference, such as demonstrated with `Earth`.
 
 ## Deprecation of Enum Cases
 
-As a library author, you may want to signal that an enum case is no longer intended for use. However you could still want to gracefully handle the removal of a case from your public API, such as special casing deprecated cases.
+As a library author, you may want to signal that an enum case is no longer intended for use.
+However you could still want to gracefully handle the removal of a case from your public API, such as special casing deprecated cases.
 
 To illustrate, say that the `Planet` enum originally had an additional case:
 
@@ -131,7 +128,8 @@ To illustrate, say that the `Planet` enum originally had an additional case:
  end Planet
 ```
 
-We now want to deprecate the `Pluto` case. First we add the `scala.deprecated` annotation to `Pluto`:
+We now want to deprecate the `Pluto` case.
+First we add the `scala.deprecated` annotation to `Pluto`:
 
 ```diff
  enum Planet(mass: Double, radius: Double):
@@ -144,7 +142,8 @@ We now want to deprecate the `Pluto` case. First we add the `scala.deprecated` a
  end Planet
 ```
 
-Outside the lexical scopes of `enum Planet` or `object Planet`, references to `Planet.Pluto` will produce a deprecation warning, but within those scopes we can still reference it to implement introspection over the deprecated cases:
+Outside the lexical scopes of `enum Planet` or `object Planet`, references to `Planet.Pluto` will produce a deprecation warning.
+Within those scopes however, we can still reference it to implement introspection over the deprecated cases:
 
 ```scala
 trait Deprecations[T <: reflect.Enum] {
@@ -163,8 +162,7 @@ We could imagine that a library may use [type class derivation](../contextual/de
 
 ## Compatibility with Java Enums
 
-If you want to use the Scala-defined enums as [Java enums](https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html), you can do so by extending
-the class `java.lang.Enum`, which is imported by default, as follows:
+If you want to use the Scala-defined enums as [Java enums](https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html), you can do so by extending the class `java.lang.Enum`, which is imported by default, as follows:
 
 ```scala
 enum Color extends Enum[Color] { case Red, Green, Blue }
@@ -180,43 +178,5 @@ scala> Color.Red.compareTo(Color.Green)
 val res15: Int = -1
 ```
 
-For a more in-depth example of using Scala 3 enums from Java, see [this test](https://github.com/lampepfl/dotty/tree/main/tests/run/enum-java). In the test, the enums are defined in the `MainScala.scala` file and used from a Java source, `Test.java`.
-
-## Implementation
-
-Enums are represented as `sealed` classes that extend the `scala.reflect.Enum` trait.
-This trait defines a single public method, `ordinal`:
-
-```scala
-package scala.reflect
-
-/** A base trait of all Scala enum definitions */
-transparent trait Enum extends Any, Product, Serializable:
-
-  /** A number uniquely identifying a case of an enum */
-  def ordinal: Int
-```
-
-Enum values with `extends` clauses get expanded to anonymous class instances.
-For instance, the `Venus` value above would be defined like this:
-
-```scala
-val Venus: Planet = new Planet(4.869E24, 6051800.0):
-  def ordinal: Int = 1
-  override def productPrefix: String = "Venus"
-  override def toString: String = "Venus"
-```
-
-Enum values without `extends` clauses all share a single implementation
-that can be instantiated using a private method that takes a tag and a name as arguments.
-For instance, the first
-definition of value `Color.Red` above would expand to:
-
-```scala
-val Red: Color = $new(0, "Red")
-```
-
-## Reference
-
-For more information, see [Issue #1970](https://github.com/lampepfl/dotty/issues/1970) and
-[PR #4003](https://github.com/lampepfl/dotty/pull/4003).
+For a more in-depth example of using Scala 3 enums from Java, see [this test](https://github.com/lampepfl/dotty/tree/main/tests/run/enum-java).
+In the test, the enums are defined in the `MainScala.scala` file and used from a Java source, `Test.java`.

From 94a0fcd1e6ebb75dc6dfa95147661abaf3c7503c Mon Sep 17 00:00:00 2001
From: Jamie Thompson <bishbashboshjt@gmail.com>
Date: Fri, 28 Apr 2023 16:03:13 +0200
Subject: [PATCH 503/657] apply enums/desugarEnums.md

---
 docs/_spec/05-classes-and-objects.md          | 270 +++++++++++++++++-
 .../_spec/TODOreference/enums/desugarEnums.md | 215 --------------
 2 files changed, 255 insertions(+), 230 deletions(-)
 delete mode 100644 docs/_spec/TODOreference/enums/desugarEnums.md

diff --git a/docs/_spec/05-classes-and-objects.md b/docs/_spec/05-classes-and-objects.md
index ea8c7bbb43fd..634df1fa4bf6 100644
--- a/docs/_spec/05-classes-and-objects.md
+++ b/docs/_spec/05-classes-and-objects.md
@@ -41,6 +41,8 @@ The list of parents of a template must be well-formed.
 This means that the class denoted by the superclass constructor ´sc´ must be a subclass of the superclasses of all the traits ´mt_1, ..., mt_n´.
 In other words, the non-trait classes inherited by a template form a chain in the inheritance hierarchy which starts with the template's superclass.
 
+It is forbidden for a template's superclass constructor ´sc´ to be an [enum class](#enum-definitions), unless the template is the implementation of an [enum case](#enum-definitions) of ´sc´.
+
 The _least proper supertype_ of a template is the class type or [compound type](03-types.html#compound-types) consisting of all its parent class types.
 
 The statement sequence ´\mathit{stats}´ contains member definitions that define new members or overwrite members in the parent classes.
@@ -811,21 +813,78 @@ EnumDef   ::=  id ClassConstr [‘extends’ [ConstrApps]] EnumBody
 EnumBody  ::=  [nl] ‘{’ [SelfType] EnumStat {semi EnumStat} ‘}’
 EnumStat  ::=  TemplateStat
             |  {Annotation [nl]} {Modifier} EnumCase
+EnumCase  ::=  ‘case’ (id ClassConstr [‘extends’ ConstrApps] | ids)
 ```
 
-### Enum Cases
-<!-- TODO: Agree with NTs of rest of spec -->
-```ebnf
-EnumCase  ::=  ‘case’ (id ClassConstr [‘extends’ ConstrApps] | ids)
+An _enum definition_ implies the definition of an _enum class_, a companion object, and one or more _enum cases_.
+
+Enum definitions are useful to encode both Generalised Algebraic Data Types and Enumerated Types.
+
+The compiler expands enum definitions to code that only uses Scala's other language features.
+As such, enum definitions in Scala are convenient _syntactic sugar_, but they are not essential to understand Scala's core.
+
+We now explain the expansion of enum definitions in detail.
+First, some terminology and notational conventions:
+
+- We use ´E´ as a name of an enum definition, and ´C´ as a name of an enum case that appears in ´E´.
+- We use `<...>` for syntactic constructs that in some circumstances might be empty.
+For instance, `<value-params>` represents one or more parameter lists `(´\mathit{ps}_1\,´)...(´\mathit{ps}_n´)` or nothing at all.
+- Enum classes fall into two categories:
+  - _parameterized_ enum classes have at least one of the following:
+     - a type parameter section, denoted as `[´\mathit{tps}\,´]`;
+     - one or more (possibly empty) parameter sections, denoted as `(´\mathit{ps}_1\,´)...(´\mathit{ps}_n´)`.
+  - _unparameterized_ enum classes have no type parameter sections and no parameter sections.
+- Enum cases fall into three categories:
+
+  - _Class cases_ are those cases that are parameterized, either with a type parameter section `[´\mathit{tps}\,´]` or with one or more (possibly empty) parameter sections `(´\mathit{ps}_1\,´)...(´\mathit{ps}_n´)`.
+  - _Simple cases_ are cases of an unparameterized enum that have neither parameters nor an extends clause or body.
+  That is, they consist of a name only.
+  - _Value cases_ are all cases that do not have a parameter section but that do have a (possibly generated) `extends` clause and/or a body.
+
+- Simple cases and value cases are collectively called _singleton cases_.
+
+###### Example
+
+An example enum for a `Planet` enumeration can be given as
+```scala
+enum Planet(mass: Double, radius: Double):
+  case Mercury extends Planet(3.303e+23, 2.4397e6)
+  case Venus   extends Planet(4.869e+24, 6.0518e6)
+  case Earth   extends Planet(5.976e+24, 6.37814e6)
+  case Mars    extends Planet(6.421e+23, 3.3972e6)
+  case Jupiter extends Planet(1.9e+27,   7.1492e7)
+  case Saturn  extends Planet(5.688e+26, 6.0268e7)
+  case Uranus  extends Planet(8.686e+25, 2.5559e7)
+  case Neptune extends Planet(1.024e+26, 2.4746e7)
+
+  private inline val G = 6.67300E-11
+  def surfaceGravity = G * mass / (radius * radius)
+  def surfaceWeight(otherMass: Double) = otherMass * surfaceGravity
+end Planet
 ```
 
-<!-- TODO: an enum case is defined in terms of other scala constructs... -->
+###### Example
+
+An example enum for the Option ADT can be given as
+```scala
+enum Option[+T]:
+  case Some(x: T)
+  case None
+```
 
 ### Lowering of Enum Definitions
 
-Enums are represented as `sealed` classes that extend the `scala.reflect.Enum` trait.
-This trait defines a single public method, `ordinal`:
+###### Summary
+An enum class is represented as a `sealed` class that extends the `scala.reflect.Enum` trait.
+
+Enum cases are represented as follows:
+- a class case is mapped to a `case class`,
+- a singleton case is mapped to a `val` definition, where
+  - Simple cases all share a single implementation class.
+  - Value cases will each be implemented by a unique class.
 
+###### Precise rules
+The `scala.reflect.Enum` trait defines a single public method, `ordinal`:
 ```scala
 package scala.reflect
 
@@ -833,10 +892,128 @@ transparent trait Enum extends Any, Product, Serializable:
 
   def ordinal: Int
 ```
+There are nine desugaring rules.
+Rule (1) desugars enum definitions.
+Rules (2) and (3) desugar simple cases.
+Rules (4) to (6) define `extends` clauses for cases that are missing them.
+Rules (7) to (9) define how such cases with `extends` clauses map into `case class`es or `val`s.
 
-Simple enum cases all share a single implementation class.
+1.  An `enum` definition
+    ```scala
+    enum ´E´ ... { <defs> <cases> }
+    ```
+    expands to a `sealed abstract` class that extends the `scala.reflect.Enum` trait and an associated companion object that contains the defined cases, expanded according to rules (2 - 8).
+    The enum class starts with a compiler-generated import that imports the names `<caseIds>` of all cases so that they can be used without prefix in the class.
+    ```scala
+    sealed abstract class ´E´ ... extends <parents> with scala.reflect.Enum {
+        import ´E´.{ <caseIds> }
+        <defs>
+    }
+    object ´E´ { <cases> }
+    ```
+
+2. A singleton case consisting of a comma-separated list of enum names
+   ```scala
+   case ´C_1´, ..., ´C_n´
+   ```
+   expands to
+   ```scala
+   case ´C_1´; ...; case ´C_n´
+   ```
+   Any modifiers or annotations on the original case extend to all expanded cases.
+   This result is then further rewritten by either (3 or 4).
+
+3. A singleton case without an extends clause
+   ```scala
+   case ´C´
+   ```
+   of an unparameterized enum `´E´` expands to the following simple enum case in `´E´`'s companion object:
+   ```scala
+   val ´C´ = $new(n, "C")
+   ```
+   Here, `$new` is a private method that creates an instance of ´E´ (see below).
+
+4. A singleton case without an extends clause
+   ```scala
+   case ´C´
+   ```
+   of an enum `´E´` with type parameters
+   ```scala
+   ´\mathit{v}_1´ ´T_1´ >: ´L_1´ <: ´U_1´ ,   ... ,   ´\mathit{v}_n´ ´T_n´ >: ´L_n´ <: ´U_n´      (n > 0)
+   ```
+   where each of the variances `´\mathit{v}_i´` is either `'+'` or `'-'`, expands to the following value enum case:
+   ```scala
+   case ´C´ extends ´E´[´B_1´, ..., ´B_n´]
+   ```
+   where `´B_i´` is `´L_i´` if `´\mathit{v}_i´ = '+'` and `´U_i´` if `´\mathit{v}_i´ = '-'`.
+   This result is then further rewritten with rule (8).
+   **NOTE:** It is not permitted for enums with non-variant type parameters to have singleton cases without an extends clause.
+
+5. A class case without an extends clause
+   ```scala
+   case ´C´ <type-params> <value-params>
+   ```
+   of an enum `´E´` that does not take type parameters expands to
+   ```scala
+   case ´C´ <type-params> <value-params> extends ´E´
+   ```
+   This result is then further rewritten with rule (9).
+
+6. If `´E´` is an enum with type parameters `´\mathit{tps}´`, a class case with neither type parameters nor an extends clause
+   ```scala
+   case ´C´ <value-params>
+   ```
+   expands to
+   ```scala
+   case ´C´[´\mathit{tps}´] <value-params> extends ´E´[´\mathit{tps}´]
+   ```
+   This result is then further rewritten with rule (9).
+   For class cases that have type parameters themselves, an extends clause needs to be given explicitly.
+
+
+7. If `´E´` is an enum with type parameters `´\mathit{tps}´`, a class case without type parameters but with an extends clause
+   ```scala
+   case ´C´ <value-params> extends <parents>
+   ```
+   expands to
+   ```scala
+   case ´C´[´\mathit{tps}´] <value-params> extends <parents>
+   ```
+   provided at least one of the parameters `´\mathit{tps}´` is mentioned in a parameter type in `<value-params>` or in a type argument in `<parents>`.
+
+8. A value case
+   ```scala
+   case ´C´ extends <parents>
+   ```
+   expands to the following `val` definition in `´E´`'s companion object:
+   ```scala
+   val ´C´ = new <parents> { <body>; def ordinal = ´\mathit{n}´ }
+   ```
+   where `´\mathit{n}´` is the ordinal number of the case in the companion object, starting from 0.
+   The anonymous class also implements the abstract `Product` methods that it inherits from `Enum`.
+   **NOTE:** It is an error if a value case refers to a type parameter of `´E´` in a type argument within `<parents>`.
+
+9. A class case
+   ```scala
+   case ´C´ <type-params> <value-params> extends <parents>
+   ```
+   expands analogous to a final case class in `´E´`'s companion object:
+   ```scala
+   final case class ´C´ <type-params> <value-params> extends <parents> {
+      def ordinal = ´\mathit{n}´
+   }
+   ```
+   where `´\mathit{n}´` is the ordinal number of the case in the companion object, starting from 0.
+   **NOTE:** It is an error if a class case refers to a type parameter of `´E´` in a parameter type in `<type-params>` or `<value-params>` or in a type argument of `<parents>`, unless that parameter is already a type parameter of the case, i.e. the parameter name is defined in `<type-params>`.
+
+###### Superclass of an enum case
+
+an enum case (singleton or class) with explicit extends clause
+```scala
+case ´C´ <type-params> <value-params> extends <parents>
+```
 
-Value enum cases will each be implemented by a unique class.
+must extend the parent enum `´E´` as the first parent of `<parents>`.
 
 ###### Example
 Consider the enumeration `RGB`, consisting of simple enum cases:
@@ -845,12 +1022,18 @@ enum RGB:
   case Red, Green, Blue
 ```
 
-Each simple case `Red`, `Green`, and `Blue` will be instantiated using a private method that takes a tag and a name as arguments.
-
-For instance, the first definition of value `Color.Red` above would expand to:
+The three simple cases will expand as follows in the companion of `RGB`:
 
 ```scala
-val Red: Color = $new(0, "Red")
+val Red = $new(0, "Red")
+val Green = $new(1, "Green")
+val Blue = $new(2, "Blue")
+
+private def $new(_$ordinal: Int, $name: String) =
+  new RGB with scala.runtime.EnumValue:
+    def ordinal = _$ordinal
+    override def productPrefix = $name
+    override def toString = $name
 ```
 
 
@@ -864,15 +1047,72 @@ enum Color(val rgb: Int):
   case Blue  extends Color(0x0000FF)
 ```
 
-Each value case will expand as follows, for instance `Green` expands to
+The three value cases will expand as follows in the companion of `Color`:
 
 ```scala
-val Green: Color = new Color(0x00FF00):
+val Red = new Color(0xFF0000):
+  def ordinal: Int = 0
+  override def productPrefix: String = "Red"
+  override def toString: String = "Red"
+val Green = new Color(0x00FF00):
   def ordinal: Int = 1
   override def productPrefix: String = "Green"
   override def toString: String = "Green"
+val Blue = new Color(0x0000FF):
+  def ordinal: Int = 2
+  override def productPrefix: String = "Blue"
+  override def toString: String = "Blue"
 ```
 
+### Widening of enum cases post-construction
+The compiler-generated `apply` and `copy` methods of an class enum case
+```scala
+case ´C´[´\mathit{tps}\,´](´\mathit{ps}_1\,´)...(´\mathit{ps}_n´) extends ´P_1´, ..., ´P_n´
+```
+are treated specially.
+A call `´C´[´\mathit{tps}\,´](´\mathit{ps}_1\,´)...(´\mathit{ps}_n´)` of the `apply` method is ascribed the underlying type `´P_1´ & ... & ´P_n´` (dropping any [transparent traits](../other-new-features/transparent-traits.md)) as long as that type is still compatible with the expected type at the point of application.
+A call `t.copy[´\mathit{tps}\,´](´\mathit{ps}_1\,´)...(´\mathit{ps}_n´)` of `´C´`'s `copy` method is treated in the same way.
+
+### Translation of enums with only singleton cases
+
+An enum `´E´` (possibly generic) that defines one or more singleton cases, and no class cases will define the following additional synthetic members in its companion object (where `´E'´` denotes `´E´` with any type parameters replaced by wildcards):
+
+   - A method `valueOf(name: String): ´E'´`.
+   It returns the singleton case value whose identifier is `name`.
+   - A method `values` which returns an `Array[´E'´]` of all singleton case values defined by `E`, in the order of their definitions.
+
+### Factory method for simple enum cases
+
+If an enum `´E´` contains at least one simple case, its companion object will define in addition:
+
+  - A private method `$new` which defines a new simple case value with given ordinal number and name.
+  This method can be thought as being defined as follows.
+
+  ```scala
+  private def $new(_$ordinal: Int, $name: String): ´E´ with runtime.EnumValue
+  ```
+  - `$new` returns a new instance of an anonymous class which implements the abstract `Product` methods that it inherits from `Enum`.
+  - if `´E´` inherits from `java.lang.Enum` the anonymous class does not override the `ordinal` or `toString` methods, as these are final in `java.lang.Enum`.
+  Additionally `productPrefix` will delegate to `this.name`.
+
+### Translation of Java-compatible enums
+
+A Java-compatible enum is an enum that extends `java.lang.Enum`.
+The translation rules are the same as above, with the reservations defined in this section.
+
+- It is a compile-time error for a Java-compatible enum to have class cases.
+
+- Cases such as `case C` expand to a `@static val` as opposed to a `val`.
+This allows them to be generated as static fields of the enum type, thus ensuring they are represented the same way as Java enums.
+
+### Scopes for Enum Cases
+
+A case in an `enum` is treated similarly to a secondary constructor.
+It can access neither the enclosing `enum` using `this`, nor its value parameters or instance members using simple identifiers.
+
+Even though translated enum cases are located in the enum's companion object, referencing this object or its members via `this` or a simple identifier is also illegal.
+The compiler typechecks enum cases in the scope of the enclosing companion object but flags any such illegal accesses as errors.
+
 ### Variance for Type Parameters
 
 A parameterized enum case ´C´  of enum ´E´ with _inferred_ type parameters will copy variance annotations.
diff --git a/docs/_spec/TODOreference/enums/desugarEnums.md b/docs/_spec/TODOreference/enums/desugarEnums.md
deleted file mode 100644
index 477653d670bb..000000000000
--- a/docs/_spec/TODOreference/enums/desugarEnums.md
+++ /dev/null
@@ -1,215 +0,0 @@
----
-layout: doc-page
-title: "Translation of Enums and ADTs"
-nightlyOf: https://docs.scala-lang.org/scala3/reference/enums/desugarEnums.html
----
-
-The compiler expands enums and their cases to code that only uses
-Scala's other language features. As such, enums in Scala are
-convenient _syntactic sugar_, but they are not essential to understand
-Scala's core.
-
-We now explain the expansion of enums in detail. First,
-some terminology and notational conventions:
-
- - We use `E` as a name of an enum, and `C` as a name of a case that appears in `E`.
- - We use `<...>` for syntactic constructs that in some circumstances might be empty. For instance,
-   `<value-params>` represents one or more parameter lists `(...)` or nothing at all.
-
- - Enum cases fall into three categories:
-
-   - _Class cases_ are those cases that are parameterized, either with a type parameter section `[...]` or with one or more (possibly empty) parameter sections `(...)`.
-   - _Simple cases_ are cases of a non-generic enum that have neither parameters nor an extends clause or body. That is, they consist of a name only.
-   - _Value cases_ are all cases that do not have a parameter section but that do have a (possibly generated) `extends` clause and/or a body.
-
-  Simple cases and value cases are collectively called _singleton cases_.
-
-The desugaring rules imply that class cases are mapped to case classes, and singleton cases are mapped to `val` definitions.
-
-There are nine desugaring rules. Rule (1) desugars enum definitions. Rules
-(2) and (3) desugar simple cases. Rules (4) to (6) define `extends` clauses for cases that
-are missing them. Rules (7) to (9) define how such cases with `extends` clauses
-map into `case class`es or `val`s.
-
-1. An `enum` definition
-   ```scala
-   enum E ... { <defs> <cases> }
-   ```
-   expands to a `sealed abstract` class that extends the `scala.reflect.Enum` trait and
-   an associated companion object that contains the defined cases, expanded according
-   to rules (2 - 8). The enum class starts with a compiler-generated import that imports
-   the names `<caseIds>` of all cases so that they can be used without prefix in the class.
-   ```scala
-   sealed abstract class E ... extends <parents> with scala.reflect.Enum {
-     import E.{ <caseIds> }
-     <defs>
-   }
-   object E { <cases> }
-   ```
-
-2. A simple case consisting of a comma-separated list of enum names
-   ```scala
-   case C_1, ..., C_n
-   ```
-   expands to
-   ```scala
-   case C_1; ...; case C_n
-   ```
-   Any modifiers or annotations on the original case extend to all expanded
-   cases.
-
-3. A simple case
-   ```scala
-   case C
-   ```
-   of an enum `E` that does not take type parameters expands to
-   ```scala
-   val C = $new(n, "C")
-   ```
-   Here, `$new` is a private method that creates an instance of `E` (see
-   below).
-
-4. If `E` is an enum with type parameters
-   ```scala
-   V1 T1 >: L1 <: U1 ,   ... ,    Vn Tn >: Ln <: Un      (n > 0)
-   ```
-   where each of the variances `Vi` is either `'+'` or `'-'`, then a simple case
-   ```scala
-   case C
-   ```
-   expands to
-   ```scala
-   case C extends E[B1, ..., Bn]
-   ```
-   where `Bi` is `Li` if `Vi = '+'` and `Ui` if `Vi = '-'`. This result is then further
-   rewritten with rule (8). Simple cases of enums with non-variant type
-   parameters are not permitted (however value cases with explicit `extends` clause are)
-
-5. A class case without an extends clause
-   ```scala
-   case C <type-params> <value-params>
-   ```
-   of an enum `E` that does not take type parameters expands to
-   ```scala
-   case C <type-params> <value-params> extends E
-   ```
-   This result is then further rewritten with rule (9).
-
-6. If `E` is an enum with type parameters `Ts`, a class case with neither type parameters nor an extends clause
-   ```scala
-   case C <value-params>
-   ```
-   expands to
-   ```scala
-   case C[Ts] <value-params> extends E[Ts]
-   ```
-   This result is then further rewritten with rule (9). For class cases that have type parameters themselves, an extends clause needs to be given explicitly.
-
-7. If `E` is an enum with type parameters `Ts`, a class case without type parameters but with an extends clause
-   ```scala
-   case C <value-params> extends <parents>
-   ```
-   expands to
-   ```scala
-   case C[Ts] <value-params> extends <parents>
-   ```
-   provided at least one of the parameters `Ts` is mentioned in a parameter type in
-   `<value-params>` or in a type argument in `<parents>`.
-
-8. A value case
-   ```scala
-   case C extends <parents>
-   ```
-   expands to a value definition in `E`'s companion object:
-   ```scala
-   val C = new <parents> { <body>; def ordinal = n }
-   ```
-   where `n` is the ordinal number of the case in the companion object,
-   starting from 0. The anonymous class also
-   implements the abstract `Product` methods that it inherits from `Enum`.
-
-   It is an error if a value case refers to a type parameter of the enclosing `enum`
-   in a type argument of `<parents>`.
-
-9. A class case
-   ```scala
-   case C <params> extends <parents>
-   ```
-   expands analogous to a final case class in `E`'s companion object:
-   ```scala
-   final case class C <params> extends <parents>
-   ```
-   The enum case defines an `ordinal` method of the form
-   ```scala
-   def ordinal = n
-   ```
-   where `n` is the ordinal number of the case in the companion object,
-   starting from 0.
-
-   It is an error if a value case refers to a type parameter of the enclosing `enum`
-   in a parameter type in `<params>` or in a type argument of `<parents>`, unless that parameter is already
-   a type parameter of the case, i.e. the parameter name is defined in `<params>`.
-
-   The compiler-generated `apply` and `copy` methods of an enum case
-   ```scala
-   case C(ps) extends P1, ..., Pn
-   ```
-   are treated specially. A call `C(ts)` of the apply method is ascribed the underlying type
-   `P1 & ... & Pn` (dropping any [transparent traits](../other-new-features/transparent-traits.md))
-   as long as that type is still compatible with the expected type at the point of application.
-   A call `t.copy(ts)` of `C`'s `copy` method is treated in the same way.
-
-## Translation of Enums with Singleton Cases
-
-An enum `E` (possibly generic) that defines one or more singleton cases
-will define the following additional synthetic members in its companion object (where `E'` denotes `E` with
-any type parameters replaced by wildcards):
-
-   - A method `valueOf(name: String): E'`. It returns the singleton case value whose identifier is `name`.
-   - A method `values` which returns an `Array[E']` of all singleton case
-     values defined by `E`, in the order of their definitions.
-
-If `E` contains at least one simple case, its companion object will define in addition:
-
-   - A private method `$new` which defines a new simple case value with given
-     ordinal number and name. This method can be thought as being defined as
-     follows.
-
-     ```scala
-     private def $new(_$ordinal: Int, $name: String) =
-       new E with runtime.EnumValue:
-         def ordinal = _$ordinal
-         override def productPrefix = $name // if not overridden in `E`
-         override def toString = $name      // if not overridden in `E`
-     ```
-
-The anonymous class also implements the abstract `Product` methods that it inherits from `Enum`.
-The `ordinal` method is only generated if the enum does not extend from `java.lang.Enum` (as Scala enums do not extend
-`java.lang.Enum`s unless explicitly specified). In case it does, there is no need to generate `ordinal` as
-`java.lang.Enum` defines it. Similarly there is no need to override `toString` as that is defined in terms of `name` in
-`java.lang.Enum`. Finally, `productPrefix` will call `this.name` when `E` extends `java.lang.Enum`.
-
-## Scopes for Enum Cases
-
-A case in an `enum` is treated similarly to a secondary constructor. It can access neither the enclosing `enum` using `this`, nor its value parameters or instance members using simple
-identifiers.
-
-Even though translated enum cases are located in the enum's companion object, referencing
-this object or its members via `this` or a simple identifier is also illegal. The compiler typechecks enum cases in the scope of the enclosing companion object but flags any such illegal accesses as errors.
-
-## Translation of Java-compatible enums
-
-A Java-compatible enum is an enum that extends `java.lang.Enum`. The translation rules are the same as above, with the reservations defined in this section.
-
-It is a compile-time error for a Java-compatible enum to have class cases.
-
-Cases such as `case C` expand to a `@static val` as opposed to a `val`. This allows them to be generated as static fields of the enum type, thus ensuring they are represented the same way as Java enums.
-
-## Other Rules
-
-- A normal case class which is not produced from an enum case is not allowed to extend
-  `scala.reflect.Enum`. This ensures that the only cases of an enum are the ones that are
-  explicitly declared in it.
-
-- If an enum case has an `extends` clause, the enum class must be one of the
-  classes that's extended.

From 0f031cdf2f6cefd7f3e3480c91b67dcb4ce287cf Mon Sep 17 00:00:00 2001
From: Lucas <leblanc.lucas29@gmail.com>
Date: Mon, 27 Feb 2023 13:03:43 +0100
Subject: [PATCH 504/657] Add the CSS import in the layout

Add import CSS

Correct import
---
 docs/_layouts/base.html | 1 +
 1 file changed, 1 insertion(+)

diff --git a/docs/_layouts/base.html b/docs/_layouts/base.html
index feb79d1590a0..bc8b3ab26bb0 100644
--- a/docs/_layouts/base.html
+++ b/docs/_layouts/base.html
@@ -1,5 +1,6 @@
 <link rel="dns-prefetch" href="//fonts.googleapis.com">
 <link rel="preconnect" href="https://cdnjs.cloudflare.com" crossorigin>
 <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+<link rel="stylesheet" href="{{site.baseurl}}/css/dottydoc.css">
 
 {{ content }}

From af6af313339d5b754e41c206d530be6de25e0a7b Mon Sep 17 00:00:00 2001
From: Lucas <leblanc.lucas29@gmail.com>
Date: Mon, 27 Mar 2023 12:07:11 +0200
Subject: [PATCH 505/657] Correct the CSS files for the anchors, the warning
 and the images - Anchors: Remove the color of the anchors, the file content
 css is enough - Warning: Remove the color, banners.css is enough - Images:
 Add a width 100% and height auto to not overlaps

---
 docs/_assets/css/dottydoc.css | 29 +++++------------------------
 1 file changed, 5 insertions(+), 24 deletions(-)

diff --git a/docs/_assets/css/dottydoc.css b/docs/_assets/css/dottydoc.css
index ca7613835ff0..38990ed82a09 100644
--- a/docs/_assets/css/dottydoc.css
+++ b/docs/_assets/css/dottydoc.css
@@ -14,6 +14,11 @@ main.container {
   height: auto;
 }
 
+.site-container img{
+  width: 100%;
+  height: auto;
+}
+
 /* headers */
 main header {
   border-bottom: 1px solid rgba(0,0,0,.1);
@@ -45,21 +50,6 @@ ul.post-list {
   margin-bottom: 0;
 }
 
-/* headings anchors */
-a.anchor {
-  color: transparent;
-  margin-left: -23px;
-  padding-right: 3px;
-  transition: color .4s ease-out;
-}
-
-a.anchor::before {
-	content: "\f0c1";
-	font-family: "Font Awesome 5 Free";
-	font-weight: 900;
-	font-size: 20px;
-}
-
 h1:hover a.anchor,
 h2:hover a.anchor,
 h3:hover a.anchor,
@@ -191,15 +181,6 @@ blockquote {
   border-left: 0.25em solid #ddd;
 }
 
-aside {
-  padding: 15px;
-  margin: 10px 0;
-}
-
-aside.warning {
-  border-left: 3px solid var(--red500);
-  background-color: var(--aside-warning-bg);
-}
 
 aside.notice {
   border-left: 3px solid #4c97e4;

From cc055745a3bff92194f2d6e282ec00bea131b2c6 Mon Sep 17 00:00:00 2001
From: Lucas <leblanc.lucas29@gmail.com>
Date: Mon, 17 Apr 2023 13:42:41 +0200
Subject: [PATCH 506/657] Remove obsolete CSS, Corrections and improvements - I
 removed the obsolete CSS in dottydoc.css - The compliant CSS codes have been
 moved to folder dotty_res/styles/theme/layout - I improved the UI for the
 author of a blog post

---
 docs/_assets/css/dottydoc.css                 | 221 +-----------------
 docs/_layouts/blog-page.html                  |  37 +--
 .../styles/theme/layout/container.css         |   5 +
 .../dotty_res/styles/theme/layout/content.css |  47 +++-
 4 files changed, 71 insertions(+), 239 deletions(-)

diff --git a/docs/_assets/css/dottydoc.css b/docs/_assets/css/dottydoc.css
index 38990ed82a09..6408fac3fab4 100644
--- a/docs/_assets/css/dottydoc.css
+++ b/docs/_assets/css/dottydoc.css
@@ -1,224 +1,23 @@
-html, body {
-  font-weight: 300;
-  height: 100%;
-}
-
-main.container {
-  min-height: 100vh;
-  padding: 15px 15px;
-  padding-bottom: 45px; /* prevents the content to be hidden by the gitter sidecar */
-}
-
-.container img {
-  width: 100%;
-  height: auto;
-}
-
-.site-container img{
-  width: 100%;
-  height: auto;
-}
-
-/* headers */
-main header {
-  border-bottom: 1px solid rgba(0,0,0,.1);
-  margin-bottom: 16px;
-  padding-bottom: 16px;
-}
-
-main > h1 {
-  margin-bottom: 20px;
-}
-
 .byline {
   font-size: 14px;
+  display: flex;
+  margin-top: 10px;
 }
 
-.byline, .byline a {
-  color: grey;
-}
-.byline .author {
-  display: block;
-}
-
-/* indexes */
-ul.post-list {
-  list-style: none;
-  padding-left: 0;
-}
-.post-list h2 {
-  margin-bottom: 0;
-}
-
-h1:hover a.anchor,
-h2:hover a.anchor,
-h3:hover a.anchor,
-h4:hover a.anchor,
-h5:hover a.anchor {
-  color: lightgrey;
-  text-decoration: none;
-}
-
-h1:hover a.anchor:hover,
-h2:hover a.anchor:hover,
-h3:hover a.anchor:hover,
-h4:hover a.anchor:hover,
-h5:hover a.anchor:hover {
-  color: var(--secondary);
-}
-
-/* blog footer */
-.blog-author {
-  color: gray;
-}
-
-.blog-author img#author-img {
+.byline img#author-img {
   width: auto;
   height: auto;
-  max-width:100px;
-  max-height:100px;
-  border-radius: 50%;
+  max-width: 50px;
+  border-radius: 10px;
 }
 
-/* api docs */
-.api span.letter-anchor {
-  float: left;
-  width: 50px;
-  height: 50px;
-  border-radius: 50px;
-  color: white;
-  margin-top: 6px;
-  margin-right: 8px;
-  line-height: 50px;
-  text-align: center;
-  text-decoration: none;
-  font-size: 43px;
-  font-family: var(--font-family-sans-serif);
-}
-.api span.letter-anchor.object {
-  line-height: 48px;
-}
-.api span.letter-anchor.class {
-  line-height: 48px;
-  padding-right: 3px;
-}
-.letter-anchor.object {
-  background: #2c6c8d;
-}
-.letter-anchor.class {
-  background: #44ad7d;
-}
-.letter-anchor.trait {
-  background: #19aacf;
-}
-.letter-anchor.enum {
-  background: #7803fc;
-}
-.letter-anchor.package {
-  background: #2c6c8d;
-}
-
-.api header {
-  font-family: var(--font-family-sans-serif);
+.byline, .byline a {
+  color: grey;
 }
-.api header .name-prefix {
+.byline .author {
   display: block;
 }
-.api header .name-suffix {
-  display: inline-block;
-}
-
-.api header h1 {
-  margin: -13px 8px 0 0;
-  display: inline-block;
-}
-.api h2 {
-  margin-top: 1rem;
-}
-.api h3 {
-  display: inline;
-  margin: 0;
-  font: inherit;
-  font-weight: bold;
-}
-
-/* improved display and wrapping of parameters */
-.api .params, .api .type-params {
-  display: inline-flex;
-  flex-flow: wrap;
-}
-
-/* api layout */
-.wide-table {
-  display: table;
-  width: 100%;
-}
-.api .member:hover {
-  background: var(--doc-bg);
-  cursor: pointer;
-}
-.api .left-column {
-  white-space: nowrap;
-  padding-left: 1em;
-  border-left: 3px solid transparent;/* table rows cannot have borders*/
-  font-family: var(--font-family-monospace);
-  text-align: right;
-  width: 1px;
-}
-.api .member:hover .left-column {
-  border-left: 3px solid var(--secondary);
-}
-.api .right-column {
-  display: inline;
-  text-align: right;
-  font-family: var(--font-family-monospace);
-}
-
-/* admonitions */
-blockquote {
-  padding: 0 1em;
-  color: #777;
-  border-left: 0.25em solid #ddd;
-}
-
-
-aside.notice {
-  border-left: 3px solid #4c97e4;
-  background-color: #e4ebff;
-}
-
-aside.success {
-  border-left: 3px solid #36bf1d;
-  background-color: #ebfddd;
-}
-
-/* media queries for bigger screens (dottydoc is mobile-first) */
-@media (min-width: 576px) {
-  .byline .author {
-    display: inline;
-    margin-left: 1em;
-  }
-  main.container {
-    padding: 15px 30px;
-  }
-}
-@media (min-width: 768px) {
-  .api .member {
-    display: table-row;
-  }
-  .api .left-column {
-    display: table-cell;
-  }
-  .api .right-column {
-    display: flex;
-    flex-flow: wrap;
-  }
-  main.container {
-    padding: 15px 45px;
-  }
-}
 
-header {
-  position: static !important;
-  width: 100% !important;
+.byline .secondary-infos{
+  margin-left: 10px;
 }
diff --git a/docs/_layouts/blog-page.html b/docs/_layouts/blog-page.html
index c5d0fe8875e7..7d1a7439f68a 100644
--- a/docs/_layouts/blog-page.html
+++ b/docs/_layouts/blog-page.html
@@ -5,14 +5,25 @@
     <header>
         <h1>{{ page.title }}</h1>
         <div class="byline">
-            <time class="date">
-                <i class="far fa-calendar-alt"></i>
-                {{ page.date | date: "%Y-%m-%d" }}
-            </time>
-            <span class="author">
-                <i class="fas fa-pen-nib"></i>
-                {{ page.author }}
-            </span>
+            {% if page.author and page.authorImg %}
+            <img id="author-img" src="{{ site.baseurl }}{{ page.authorImg }}">
+            {% endif %}
+            <div class="secondary-infos">
+                {% if page.author %}
+                <div>
+                    <span class="author">
+                        <i class="fas fa-pen-nib"></i>
+                        {{ page.author }}
+                    </span>
+                </div>
+                {% endif %}
+                <div>
+                    <time class="date">
+                        <i class="far fa-calendar-alt"></i>
+                        {{ page.date | date: "%Y-%m-%d" }}
+                    </time>
+                </div>
+            </div>
         </div>
         {% if page.subTitle %}
         <div class="subtitle">
@@ -22,14 +33,4 @@ <h1>{{ page.title }}</h1>
     </header>
 
     {{ content }}
-
-    {% if page.author and page.authorImg %}
-    <hr/>
-    <div class="blog-author">
-        <img id="author-img" src="{{ site.baseurl }}{{ page.authorImg }}">
-        <span id="author-signature">
-            {{ page.author }}
-        </span>
-    </div>
-    {% endif %}
 </main>
diff --git a/scaladoc/resources/dotty_res/styles/theme/layout/container.css b/scaladoc/resources/dotty_res/styles/theme/layout/container.css
index 849235e2fa82..53ede0e3dfff 100644
--- a/scaladoc/resources/dotty_res/styles/theme/layout/container.css
+++ b/scaladoc/resources/dotty_res/styles/theme/layout/container.css
@@ -19,6 +19,11 @@ p {
   --header-height: calc(8 * var(--base-spacing));
 }
 
+.site-container img{
+  max-width: 100%;
+  height: auto;
+}
+
 /* Scrollbar */
 
 ::-webkit-scrollbar {
diff --git a/scaladoc/resources/dotty_res/styles/theme/layout/content.css b/scaladoc/resources/dotty_res/styles/theme/layout/content.css
index e46e66cba9e5..8ebc3459c7ed 100644
--- a/scaladoc/resources/dotty_res/styles/theme/layout/content.css
+++ b/scaladoc/resources/dotty_res/styles/theme/layout/content.css
@@ -8,6 +8,19 @@
   scroll-behavior: smooth;
 }
 
+/* blog footer */
+.blog-author {
+  color: gray;
+}
+
+.blog-author img#author-img {
+  width: auto;
+  height: auto;
+  max-width:100px;
+  max-height:100px;
+  border-radius: 50%;
+}
+
 #content {
   display: flex;
   flex-flow: row;
@@ -144,9 +157,9 @@
 }
 
 #content h2 {
-   color: var(--text-primary);
-    margin-block-start: calc(6* var(--base-spacing));
-    margin-block-end: calc(3* var(--base-spacing));
+  color: var(--text-primary);
+  margin-block-start: calc(6* var(--base-spacing));
+  margin-block-end: calc(3* var(--base-spacing));
 }
 
 #content .cover > h2 {
@@ -167,7 +180,7 @@
 
 /* content first paragraph */
 .first-p {
-    margin-block-start: calc(2* var(--base-spacing));
+  margin-block-start: calc(2* var(--base-spacing));
 }
 
 #content .first-p {
@@ -218,18 +231,32 @@
 
 /* content link */
 #content a {
-    color: var(--text-primary);
-    text-decoration: underline solid 1px;
-    -webkit-text-decoration-line: underline; /* Safari */
-    text-decoration-line: underline;
-    text-underline-offset: 2px;
-    transition: text-decoration-color .2s ease-in-out;
+  color: var(--text-primary);
+  text-decoration: underline solid 1px;
+  -webkit-text-decoration-line: underline; /* Safari */
+  text-decoration-line: underline;
+  text-underline-offset: 2px;
+  transition: text-decoration-color .2s ease-in-out;
 }
 
 #content a:hover {
   text-decoration-color: transparent;
 }
 
+#content a.anchor {
+  color: transparent;
+  margin-left: -23px;
+  padding-right: 3px;
+  transition: color .4s ease-out;
+}
+
+#content a.anchor::before {
+  content: "\f0c1";
+  font-family: "Font Awesome 5 Free";
+  font-weight: 900;
+  font-size: 20px;
+}
+
 #content .cover-header {
   margin-block-end: calc(2 * var(--base-spacing));
 }

From 4d53eab1fb4a94dd8c8ab0fafc383a7b3339ead9 Mon Sep 17 00:00:00 2001
From: Lucas Leblanc <44496264+Dedelweiss@users.noreply.github.com>
Date: Tue, 2 May 2023 12:37:29 +0200
Subject: [PATCH 507/657] deps(scaladoc): update flexmark from 0.42.12 to
 0.62.2 (#17347)

This pr updates the flexmark dependencies used in Scaladoc from 0.42.12,
which is from 2019, up to 0.62.2. This is mainly done to tackle a bunch of CVEs that are attached to the old versions of flexmark.

fixes https://github.com/lampepfl/dotty/issues/16223

---------

Co-authored-by: Chris Kipp <ckipp@pm.me>
---
 dist/bin/scaladoc                             | 24 ++++++++++++++-----
 project/Dependencies.scala                    |  9 ++++---
 .../src/dotty/tools/scaladoc/DocContext.scala |  5 ----
 scaladoc/src/dotty/tools/scaladoc/Main.scala  | 12 +---------
 .../src/dotty/tools/scaladoc/Scaladoc.scala   |  9 ++-----
 .../tools/scaladoc/ScaladocCommand.scala      | 13 +---------
 .../tools/scaladoc/ScaladocSettings.scala     | 13 ----------
 .../dotty/tools/scaladoc/SocialLinks.scala    |  4 ----
 .../dotty/tools/scaladoc/SourceLinks.scala    |  1 -
 .../src/dotty/tools/scaladoc/compat.scala     |  3 +--
 .../parsers/WikiCodeBlockParser.scala         | 17 ++++++-------
 .../scaladoc/renderers/HtmlRenderer.scala     |  9 -------
 .../tools/scaladoc/renderers/Locations.scala  |  8 -------
 .../scaladoc/renderers/MarkdownRenderer.scala | 11 ---------
 .../scaladoc/renderers/MemberRenderer.scala   |  3 ---
 .../tools/scaladoc/renderers/Renderer.scala   |  7 ------
 .../tools/scaladoc/renderers/Resources.scala  |  7 ------
 .../site/FlexmarkSectionWrapper.scala         |  1 -
 .../dotty/tools/scaladoc/site/common.scala    |  3 ++-
 .../dotty/tools/scaladoc/site/templates.scala |  1 -
 .../snippets/FlexmarkSnippetProcessor.scala   |  1 -
 .../scaladoc/tasty/comments/Comments.scala    |  1 -
 .../tasty/comments/MarkdownParser.scala       |  7 +++---
 .../markdown/DocFlexmarkExtension.scala       |  7 ++++--
 .../markdown/SectionRenderingExtension.scala  | 17 +++++++++----
 .../markdown/SnippetRenderingExtension.scala  |  5 +++-
 .../scaladoc/site/TemplateFileTests.scala     |  7 +++---
 .../scaladoc/snippets/SnippetsE2eTest.scala   |  1 -
 28 files changed, 69 insertions(+), 137 deletions(-)

diff --git a/dist/bin/scaladoc b/dist/bin/scaladoc
index 67210f0d6b4f..8b9ec41a7f8c 100755
--- a/dist/bin/scaladoc
+++ b/dist/bin/scaladoc
@@ -61,15 +61,31 @@ classpathArgs () {
   CLASS_PATH+="$(find_lib "*tasty-core*")$PSEP"
   CLASS_PATH+="$(find_lib "*scala3-tasty-inspector*")$PSEP"
   CLASS_PATH+="$(find_lib "*flexmark-0*")$PSEP"
-  CLASS_PATH+="$(find_lib "*flexmark-html-parser*")$PSEP"
+  CLASS_PATH+="$(find_lib "*flexmark*")$PSEP"
   CLASS_PATH+="$(find_lib "*flexmark-ext-anchorlink*")$PSEP"
   CLASS_PATH+="$(find_lib "*flexmark-ext-autolink*")$PSEP"
   CLASS_PATH+="$(find_lib "*flexmark-ext-emoji*")$PSEP"
   CLASS_PATH+="$(find_lib "*flexmark-ext-gfm-strikethrough*")$PSEP"
-  CLASS_PATH+="$(find_lib "*flexmark-ext-gfm-tables*")$PSEP"
   CLASS_PATH+="$(find_lib "*flexmark-ext-gfm-tasklist*")$PSEP"
   CLASS_PATH+="$(find_lib "*flexmark-ext-wikilink*")$PSEP"
   CLASS_PATH+="$(find_lib "*flexmark-ext-yaml-front-matter*")$PSEP"
+  CLASS_PATH+="$(find_lib "*flexmark-ext-tables*")$PSEP"
+  CLASS_PATH+="$(find_lib "*flexmark-ext-ins*")$PSEP"
+  CLASS_PATH+="$(find_lib "*flexmark-ext-superscript*")$PSEP"
+  CLASS_PATH+="$(find_lib "*flexmark-util*")$PSEP"
+  CLASS_PATH+="$(find_lib "*flexmark-util-ast*")$PSEP"
+  CLASS_PATH+="$(find_lib "*flexmark-util-data*")$PSEP"
+  CLASS_PATH+="$(find_lib "*flexmark-util-dependency*")$PSEP"
+  CLASS_PATH+="$(find_lib "*flexmark-util-misc*")$PSEP"
+  CLASS_PATH+="$(find_lib "*flexmark-util-format*")$PSEP"
+  CLASS_PATH+="$(find_lib "*flexmark-util-sequence*")$PSEP"
+  CLASS_PATH+="$(find_lib "*flexmark-util-builder*")$PSEP"
+  CLASS_PATH+="$(find_lib "*flexmark-util-collection*")$PSEP"
+  CLASS_PATH+="$(find_lib "*flexmark-util-visitor*")$PSEP"
+  CLASS_PATH+="$(find_lib "*flexmark-util-options*")$PSEP"
+  CLASS_PATH+="$(find_lib "*flexmark-util-html*")$PSEP"
+  CLASS_PATH+="$(find_lib "*flexmark-formatter*")$PSEP"
+  CLASS_PATH+="$(find_lib "*flexmark-ast*")$PSEP"
   CLASS_PATH+="$(find_lib "*liqp*")$PSEP"
   CLASS_PATH+="$(find_lib "*jsoup*")$PSEP"
   CLASS_PATH+="$(find_lib "*jackson-dataformat-yaml*")$PSEP"
@@ -80,7 +96,6 @@ classpathArgs () {
   CLASS_PATH+="$(find_lib "*jline-reader*")$PSEP"
   CLASS_PATH+="$(find_lib "*jline-terminal-3*")$PSEP"
   CLASS_PATH+="$(find_lib "*jline-terminal-jna*")$PSEP"
-  CLASS_PATH+="$(find_lib "*flexmark-util*")$PSEP"
   CLASS_PATH+="$(find_lib "*flexmark-formatter*")$PSEP"
   CLASS_PATH+="$(find_lib "*autolink-0.6*")$PSEP"
   CLASS_PATH+="$(find_lib "*flexmark-jira-converter*")$PSEP"
@@ -93,9 +108,6 @@ classpathArgs () {
   CLASS_PATH+="$(find_lib "*protobuf-java*")$PSEP"
   CLASS_PATH+="$(find_lib "*util-interface*")$PSEP"
   CLASS_PATH+="$(find_lib "*jna-5*")$PSEP"
-  CLASS_PATH+="$(find_lib "*flexmark-ext-tables*")$PSEP"
-  CLASS_PATH+="$(find_lib "*flexmark-ext-ins*")$PSEP"
-  CLASS_PATH+="$(find_lib "*flexmark-ext-superscript*")$PSEP"
   CLASS_PATH+="$(find_lib "*antlr4-runtime*")$PSEP"
 
   jvm_cp_args="-classpath \"$CLASS_PATH\""
diff --git a/project/Dependencies.scala b/project/Dependencies.scala
index 1dbf732a5b6e..1ac5090b7a6e 100644
--- a/project/Dependencies.scala
+++ b/project/Dependencies.scala
@@ -10,18 +10,21 @@ object Dependencies {
   val `jackson-dataformat-yaml` =
     "com.fasterxml.jackson.dataformat" % "jackson-dataformat-yaml" % jacksonVersion
 
-  private val flexmarkVersion = "0.42.12"
+  // Freeze on 0.62.x as 0.64.0 requires Java 11
+  private val flexmarkVersion = "0.62.2"
 
   val flexmarkDeps = Seq(
     "com.vladsch.flexmark" % "flexmark" % flexmarkVersion,
-    "com.vladsch.flexmark" % "flexmark-html-parser" % flexmarkVersion,
+    "com.vladsch.flexmark" % "flexmark-util-ast" % flexmarkVersion,
+    "com.vladsch.flexmark" % "flexmark-util-data" % flexmarkVersion,
+    "com.vladsch.flexmark" % "flexmark-util-html" % flexmarkVersion,
     "com.vladsch.flexmark" % "flexmark-ext-anchorlink" % flexmarkVersion,
     "com.vladsch.flexmark" % "flexmark-ext-autolink" % flexmarkVersion,
     "com.vladsch.flexmark" % "flexmark-ext-emoji" % flexmarkVersion,
     "com.vladsch.flexmark" % "flexmark-ext-gfm-strikethrough" % flexmarkVersion,
-    "com.vladsch.flexmark" % "flexmark-ext-gfm-tables" % flexmarkVersion,
     "com.vladsch.flexmark" % "flexmark-ext-gfm-tasklist" % flexmarkVersion,
     "com.vladsch.flexmark" % "flexmark-ext-wikilink" % flexmarkVersion,
+    "com.vladsch.flexmark" % "flexmark-ext-tables" % flexmarkVersion,
     "com.vladsch.flexmark" % "flexmark-ext-yaml-front-matter" % flexmarkVersion,
   )
 
diff --git a/scaladoc/src/dotty/tools/scaladoc/DocContext.scala b/scaladoc/src/dotty/tools/scaladoc/DocContext.scala
index 7f208daff29a..acc93ccb332f 100644
--- a/scaladoc/src/dotty/tools/scaladoc/DocContext.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/DocContext.scala
@@ -1,11 +1,9 @@
 package dotty.tools.scaladoc
 
 import java.io.File
-import java.nio.file.Files
 import java.nio.file.Path
 import java.nio.file.Paths
 
-import scala.jdk.CollectionConverters._
 import dotty.tools.scaladoc.site.StaticSiteContext
 import dotty.tools.dotc.core.Contexts._
 import dotty.tools.dotc.util.SourceFile
@@ -13,9 +11,6 @@ import dotty.tools.dotc.util.SourcePosition
 import dotty.tools.dotc.util.Spans
 import java.io.ByteArrayOutputStream
 import java.io.PrintStream
-import scala.io.Codec
-import java.net.URL
-import scala.util.Try
 import scala.collection.mutable
 import dotty.tools.scaladoc.util.Check.checkJekyllIncompatPath
 
diff --git a/scaladoc/src/dotty/tools/scaladoc/Main.scala b/scaladoc/src/dotty/tools/scaladoc/Main.scala
index da35e63561fd..36b8b1daf4c4 100644
--- a/scaladoc/src/dotty/tools/scaladoc/Main.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/Main.scala
@@ -1,16 +1,6 @@
 package dotty.tools.scaladoc
 
-import java.util.ServiceLoader
-import java.io.File
-import java.util.jar._
-import scala.jdk.CollectionConverters._
-import collection.immutable.ArraySeq
-
-import java.nio.file.Files
-
-import dotty.tools.dotc.config.Settings._
-import dotty.tools.dotc.config.CommonScalaSettings
-import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Contexts.ContextBase
 
 /** Main class for the doctool when used from cli. */
 class Main:
diff --git a/scaladoc/src/dotty/tools/scaladoc/Scaladoc.scala b/scaladoc/src/dotty/tools/scaladoc/Scaladoc.scala
index da34e97efdf5..fa02e87548e6 100644
--- a/scaladoc/src/dotty/tools/scaladoc/Scaladoc.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/Scaladoc.scala
@@ -1,20 +1,15 @@
 package dotty.tools.scaladoc
 
-import java.util.ServiceLoader
 import java.io.File
 import java.io.FileWriter
-import java.util.jar._
-import scala.jdk.CollectionConverters._
-import collection.immutable.ArraySeq
+import java.nio.file.Paths
 
-import java.nio.file.{ Files, Paths }
+import collection.immutable.ArraySeq
 
 import dotty.tools.dotc.config.Settings._
 import dotty.tools.dotc.config.{ CommonScalaSettings, AllScalaSettings }
 import dotty.tools.dotc.reporting.Reporter
 import dotty.tools.dotc.core.Contexts._
-
-import dotty.tools.scaladoc.Inkuire
 import dotty.tools.scaladoc.Inkuire._
 
 object Scaladoc:
diff --git a/scaladoc/src/dotty/tools/scaladoc/ScaladocCommand.scala b/scaladoc/src/dotty/tools/scaladoc/ScaladocCommand.scala
index b91b8307208b..8b438a27f33e 100644
--- a/scaladoc/src/dotty/tools/scaladoc/ScaladocCommand.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/ScaladocCommand.scala
@@ -1,20 +1,9 @@
 package dotty.tools.scaladoc
 
-import java.util.ServiceLoader
-import java.io.File
-import java.util.jar._
-import scala.jdk.CollectionConverters._
-import collection.immutable.ArraySeq
-
-import java.nio.file.Files
-
 import dotty.tools.dotc.config.Settings._
-import dotty.tools.dotc.config.CommonScalaSettings
-import dotty.tools.scaladoc.Scaladoc._
-import dotty.tools.dotc.config.Settings.Setting.value
 import dotty.tools.dotc.config.Properties._
 import dotty.tools.dotc.config.CliCommand
-import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Contexts.Context
 
 object ScaladocCommand extends CliCommand:
   type ConcreteSettings = ScaladocSettings
diff --git a/scaladoc/src/dotty/tools/scaladoc/ScaladocSettings.scala b/scaladoc/src/dotty/tools/scaladoc/ScaladocSettings.scala
index ee7c6cd4980f..96e7854b45cf 100644
--- a/scaladoc/src/dotty/tools/scaladoc/ScaladocSettings.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/ScaladocSettings.scala
@@ -1,20 +1,7 @@
 package dotty.tools.scaladoc
 
-import java.util.ServiceLoader
-import java.io.File
-import java.util.jar._
-import scala.jdk.CollectionConverters._
-import collection.immutable.ArraySeq
-
-import java.nio.file.Files
-
 import dotty.tools.dotc.config.Settings._
 import dotty.tools.dotc.config.AllScalaSettings
-import dotty.tools.scaladoc.Scaladoc._
-import dotty.tools.dotc.config.Settings.Setting.value
-import dotty.tools.dotc.config.Properties._
-import dotty.tools.dotc.config.CliCommand
-import dotty.tools.dotc.core.Contexts._
 
 class ScaladocSettings extends SettingGroup with AllScalaSettings:
   val unsupportedSettings = Seq(
diff --git a/scaladoc/src/dotty/tools/scaladoc/SocialLinks.scala b/scaladoc/src/dotty/tools/scaladoc/SocialLinks.scala
index f4fe674dbcb4..a07029d06c50 100644
--- a/scaladoc/src/dotty/tools/scaladoc/SocialLinks.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/SocialLinks.scala
@@ -1,9 +1,5 @@
 package dotty.tools.scaladoc
 
-import java.nio.file.Path
-import java.nio.file.Paths
-import dotty.tools.dotc.core.Contexts.Context
-
 enum SocialLinks(val url: String, val className: String):
   case Github(ghUrl: String) extends SocialLinks(ghUrl, "gh")
   case Twitter(tUrl: String) extends SocialLinks(tUrl, "twitter")
diff --git a/scaladoc/src/dotty/tools/scaladoc/SourceLinks.scala b/scaladoc/src/dotty/tools/scaladoc/SourceLinks.scala
index a9e300040fb8..b3732bcbc946 100644
--- a/scaladoc/src/dotty/tools/scaladoc/SourceLinks.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/SourceLinks.scala
@@ -2,7 +2,6 @@ package dotty.tools.scaladoc
 
 import java.nio.file.Path
 import java.nio.file.Paths
-import dotty.tools.dotc.core.Contexts.Context
 import scala.util.matching.Regex
 
 def pathToString(p: Path) =
diff --git a/scaladoc/src/dotty/tools/scaladoc/compat.scala b/scaladoc/src/dotty/tools/scaladoc/compat.scala
index fc660d97cb5d..d2095b9cc98c 100644
--- a/scaladoc/src/dotty/tools/scaladoc/compat.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/compat.scala
@@ -3,7 +3,6 @@ package dotty.tools.scaladoc
 import java.util.stream.Stream // comment out - wrong error!
 import java.util.stream.Collectors
 import java.util.Collections
-import java.nio.file.Path
 import com.vladsch.flexmark.util.ast.{Node => MdNode}
 import dotty.tools.scaladoc.tasty.comments.wiki.WikiDocElement
 import scala.jdk.CollectionConverters._
@@ -37,4 +36,4 @@ extension [V](jlist: JList[V])
 
 extension [V](jset: JSet[V])
   def ++ (other: JSet[V]): JSet[V] =
-    Stream.of(jset, other).flatMap(_.stream).collect(Collectors.toSet())
\ No newline at end of file
+    Stream.of(jset, other).flatMap(_.stream).collect(Collectors.toSet())
diff --git a/scaladoc/src/dotty/tools/scaladoc/parsers/WikiCodeBlockParser.scala b/scaladoc/src/dotty/tools/scaladoc/parsers/WikiCodeBlockParser.scala
index 865d78193886..4201cae4e2e6 100644
--- a/scaladoc/src/dotty/tools/scaladoc/parsers/WikiCodeBlockParser.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/parsers/WikiCodeBlockParser.scala
@@ -6,13 +6,14 @@ import com.vladsch.flexmark.parser.core._
 import com.vladsch.flexmark.parser.block._
 import com.vladsch.flexmark.util.ast.Block
 import com.vladsch.flexmark.util.ast.BlockContent
-import com.vladsch.flexmark.util.options.DataHolder
+import com.vladsch.flexmark.util.data.DataHolder
 import com.vladsch.flexmark.util.sequence.BasedSequence
 import com.vladsch.flexmark.util.sequence.SegmentedSequence
 
 import java.{util => ju}
 import ju.regex.Matcher
 import ju.regex.Pattern
+import scala.jdk.CollectionConverters._
 
 
 /** Copied from FencedCodeBlockParser. */
@@ -21,8 +22,11 @@ object WikiCodeBlockParser {
   private val CLOSING_FENCE = Pattern.compile("^(\\}{3})(?=[ \t]*$)$")
 
   class Factory extends CustomBlockParserFactory {
+    override def apply(options: DataHolder): BlockParserFactory =
+      new WikiCodeBlockParser.BlockFactory(options)
+
     override def getAfterDependents =
-      new ju.HashSet[Class[_ <: CustomBlockParserFactory]](ju.Arrays.asList(
+      new ju.HashSet[Class[?]](ju.Arrays.asList(
         classOf[BlockQuoteParser.Factory],
         classOf[HeadingParser.Factory],
         //FencedCodeBlockParser.Factory.class,
@@ -33,7 +37,7 @@ object WikiCodeBlockParser {
       ))
 
     override def getBeforeDependents =
-      new ju.HashSet[Class[_ <: CustomBlockParserFactory]](ju.Arrays.asList(
+      new ju.HashSet[Class[?]](ju.Arrays.asList(
         //BlockQuoteParser.Factory.class,
         //HeadingParser.Factory.class,
         //FencedCodeBlockParser.Factory.class,
@@ -44,9 +48,6 @@ object WikiCodeBlockParser {
       ))
 
     override def affectsGlobalScope = false
-
-    override def create(options: DataHolder) =
-      new WikiCodeBlockParser.BlockFactory(options)
   }
 
   private[WikiCodeBlockParser] class BlockFactory (val options: DataHolder)
@@ -83,7 +84,7 @@ class WikiCodeBlockParser(
 
   final private val block = new FencedCodeBlock()
   private var content = new BlockContent
-  private val codeContentBlock = options.get(Parser.FENCED_CODE_CONTENT_BLOCK)
+  private val codeContentBlock = Parser.FENCED_CODE_CONTENT_BLOCK.get(options)
 
   def getBlock: Block = block
   def getFenceIndent: Int = fenceIndent
@@ -141,7 +142,7 @@ class WikiCodeBlockParser(
           codeBlock.setCharsFromContent
           block.appendChild(codeBlock)
         } else {
-          val codeBlock = new Text(SegmentedSequence.of(segments))
+          val codeBlock = new Text(SegmentedSequence.create(segments.asScala.toSeq:_*))
           block.appendChild(codeBlock)
         }
       }
diff --git a/scaladoc/src/dotty/tools/scaladoc/renderers/HtmlRenderer.scala b/scaladoc/src/dotty/tools/scaladoc/renderers/HtmlRenderer.scala
index cc0a0e197d26..93b86ce0bc51 100644
--- a/scaladoc/src/dotty/tools/scaladoc/renderers/HtmlRenderer.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/renderers/HtmlRenderer.scala
@@ -2,18 +2,9 @@ package dotty.tools.scaladoc
 package renderers
 
 import util.HTML._
-import scala.jdk.CollectionConverters._
-import java.net.URI
-import java.net.URL
 import dotty.tools.scaladoc.site._
-import scala.util.Try
 import org.jsoup.Jsoup
-import java.nio.file.Paths
-import java.nio.file.Path
 import java.nio.file.Files
-import java.nio.file.FileVisitOption
-import java.io.File
-import dotty.tools.scaladoc.staticFileSymbolUUID
 
 class HtmlRenderer(rootPackage: Member, members: Map[DRI, Member])(using ctx: DocContext)
   extends Renderer(rootPackage, members, extension = "html"):
diff --git a/scaladoc/src/dotty/tools/scaladoc/renderers/Locations.scala b/scaladoc/src/dotty/tools/scaladoc/renderers/Locations.scala
index deb676e812c8..689234cdd29c 100644
--- a/scaladoc/src/dotty/tools/scaladoc/renderers/Locations.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/renderers/Locations.scala
@@ -1,18 +1,10 @@
 package dotty.tools.scaladoc
 package renderers
 
-import util.HTML._
 import scala.jdk.CollectionConverters._
 import java.net.URI
-import java.net.URL
 import dotty.tools.scaladoc.site._
-import scala.util.Try
-import org.jsoup.Jsoup
 import java.nio.file.Paths
-import java.nio.file.Path
-import java.nio.file.Files
-import java.io.File
-import scala.util.matching._
 import dotty.tools.scaladoc.util.Escape._
 
 val UnresolvedLocationLink = "#"
diff --git a/scaladoc/src/dotty/tools/scaladoc/renderers/MarkdownRenderer.scala b/scaladoc/src/dotty/tools/scaladoc/renderers/MarkdownRenderer.scala
index 12d41ac86218..6f20276e907e 100644
--- a/scaladoc/src/dotty/tools/scaladoc/renderers/MarkdownRenderer.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/renderers/MarkdownRenderer.scala
@@ -2,17 +2,6 @@ package dotty.tools.scaladoc
 package renderers
 
 import util.HTML._
-import scala.jdk.CollectionConverters._
-import java.net.URI
-import java.net.URL
-import dotty.tools.scaladoc.site._
-import scala.util.Try
-import org.jsoup.Jsoup
-import java.nio.file.Paths
-import java.nio.file.Path
-import java.nio.file.Files
-import java.nio.file.FileVisitOption
-import java.io.File
 
 class MarkdownRenderer(rootPackage: Member, members: Map[DRI, Member])(using ctx: DocContext)
   extends Renderer(rootPackage, members, extension = "md"):
diff --git a/scaladoc/src/dotty/tools/scaladoc/renderers/MemberRenderer.scala b/scaladoc/src/dotty/tools/scaladoc/renderers/MemberRenderer.scala
index 47f6bb4b9728..996b422b44fd 100644
--- a/scaladoc/src/dotty/tools/scaladoc/renderers/MemberRenderer.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/renderers/MemberRenderer.scala
@@ -7,9 +7,6 @@ import util.HTML.{div, *}
 
 import scala.jdk.CollectionConverters.*
 import dotty.tools.scaladoc.translators.FilterAttributes
-import dotty.tools.scaladoc.tasty.comments.markdown.DocFlexmarkRenderer
-import com.vladsch.flexmark.util.ast.Node as MdNode
-import dotty.tools.scaladoc.tasty.comments.wiki.WikiDocElement
 import org.jsoup.Jsoup
 import translators.*
 
diff --git a/scaladoc/src/dotty/tools/scaladoc/renderers/Renderer.scala b/scaladoc/src/dotty/tools/scaladoc/renderers/Renderer.scala
index dc2157131e0b..1a43ea8648a8 100644
--- a/scaladoc/src/dotty/tools/scaladoc/renderers/Renderer.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/renderers/Renderer.scala
@@ -2,18 +2,11 @@ package dotty.tools.scaladoc
 package renderers
 
 import util.HTML._
-import scala.jdk.CollectionConverters._
 import collection.mutable.ListBuffer
-import java.net.URI
-import java.net.URL
 import dotty.tools.scaladoc.site._
-import scala.util.Try
-import org.jsoup.Jsoup
 import java.nio.file.Paths
 import java.nio.file.Path
 import java.nio.file.Files
-import java.nio.file.FileVisitOption
-import java.io.File
 
 case class Page(link: Link, content: Member | ResolvedTemplate | String, children: Seq[Page], hidden: Boolean = false):
   def withNewChildren(newChildren: Seq[Page]) = copy(children = children ++ newChildren)
diff --git a/scaladoc/src/dotty/tools/scaladoc/renderers/Resources.scala b/scaladoc/src/dotty/tools/scaladoc/renderers/Resources.scala
index 43b4440bce2c..27af3ac5dee6 100644
--- a/scaladoc/src/dotty/tools/scaladoc/renderers/Resources.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/renderers/Resources.scala
@@ -2,16 +2,10 @@ package dotty.tools.scaladoc
 package renderers
 
 import util.HTML._
-import scala.jdk.CollectionConverters._
-import java.net.URI
 import java.net.URL
-import dotty.tools.scaladoc.site._
-import scala.util.Try
-import org.jsoup.Jsoup
 import java.nio.file.Paths
 import java.nio.file.Path
 import java.nio.file.Files
-import java.io.File
 import dotty.tools.scaladoc.translators.FilterAttributes
 import util._
 import translators._
@@ -190,7 +184,6 @@ trait Resources(using ctx: DocContext) extends Locations, Writer:
 
     def docPartRenderPlain(d: DocPart): String =
       import dotty.tools.scaladoc.tasty.comments.wiki._
-      import com.vladsch.flexmark.util.ast.{Node => MdNode}
       def renderPlain(wd: WikiDocElement): String =
         wd match
           case Paragraph(text) => renderPlain(text)
diff --git a/scaladoc/src/dotty/tools/scaladoc/site/FlexmarkSectionWrapper.scala b/scaladoc/src/dotty/tools/scaladoc/site/FlexmarkSectionWrapper.scala
index 12e93505ab59..ec0bd241602a 100644
--- a/scaladoc/src/dotty/tools/scaladoc/site/FlexmarkSectionWrapper.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/site/FlexmarkSectionWrapper.scala
@@ -4,7 +4,6 @@ package site
 import com.vladsch.flexmark.util.{ast => mdu, sequence}
 import com.vladsch.flexmark.{ast => mda}
 import com.vladsch.flexmark.formatter.Formatter
-import com.vladsch.flexmark.util.options.MutableDataSet
 import scala.jdk.CollectionConverters._
 
 import dotty.tools.scaladoc.tasty.comments.markdown.Section
diff --git a/scaladoc/src/dotty/tools/scaladoc/site/common.scala b/scaladoc/src/dotty/tools/scaladoc/site/common.scala
index 6c4852961fec..c0c959cf205c 100644
--- a/scaladoc/src/dotty/tools/scaladoc/site/common.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/site/common.scala
@@ -12,12 +12,13 @@ import com.vladsch.flexmark.ext.gfm.tasklist.TaskListExtension
 import com.vladsch.flexmark.ext.tables.TablesExtension
 import com.vladsch.flexmark.ext.yaml.front.matter.{AbstractYamlFrontMatterVisitor, YamlFrontMatterExtension}
 import com.vladsch.flexmark.parser.{Parser, ParserEmulationProfile}
-import com.vladsch.flexmark.util.options.{DataHolder, MutableDataSet}
 import com.vladsch.flexmark.ext.wikilink.WikiLinkExtension
 import com.vladsch.flexmark.formatter.Formatter
 import com.vladsch.flexmark.html.HtmlRenderer
 
 import scala.jdk.CollectionConverters._
+import com.vladsch.flexmark.util.data.DataHolder
+import com.vladsch.flexmark.util.data.MutableDataSet
 
 val docsRootDRI: DRI = DRI(location = "_docs/index", symbolUUID = staticFileSymbolUUID)
 val apiPageDRI: DRI = DRI(location = "api/index")
diff --git a/scaladoc/src/dotty/tools/scaladoc/site/templates.scala b/scaladoc/src/dotty/tools/scaladoc/site/templates.scala
index fe51bbe0614d..92e0096e5af1 100644
--- a/scaladoc/src/dotty/tools/scaladoc/site/templates.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/site/templates.scala
@@ -11,7 +11,6 @@ import com.vladsch.flexmark.ext.gfm.tasklist.TaskListExtension
 import com.vladsch.flexmark.ext.tables.TablesExtension
 import com.vladsch.flexmark.ext.yaml.front.matter.{AbstractYamlFrontMatterVisitor, YamlFrontMatterExtension}
 import com.vladsch.flexmark.parser.{Parser, ParserEmulationProfile}
-import com.vladsch.flexmark.util.options.{DataHolder, MutableDataSet}
 import com.vladsch.flexmark.html.HtmlRenderer
 import com.vladsch.flexmark.formatter.Formatter
 import liqp.Template
diff --git a/scaladoc/src/dotty/tools/scaladoc/snippets/FlexmarkSnippetProcessor.scala b/scaladoc/src/dotty/tools/scaladoc/snippets/FlexmarkSnippetProcessor.scala
index 69e7c7764985..33f0e089053a 100644
--- a/scaladoc/src/dotty/tools/scaladoc/snippets/FlexmarkSnippetProcessor.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/snippets/FlexmarkSnippetProcessor.scala
@@ -4,7 +4,6 @@ package snippets
 import com.vladsch.flexmark.util.{ast => mdu, sequence}
 import com.vladsch.flexmark.{ast => mda}
 import com.vladsch.flexmark.formatter.Formatter
-import com.vladsch.flexmark.util.options.MutableDataSet
 import scala.jdk.CollectionConverters._
 
 import dotty.tools.scaladoc.tasty.comments.markdown.ExtendedFencedCodeBlock
diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/comments/Comments.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/comments/Comments.scala
index 66844f5049d3..ff4405d3ec71 100644
--- a/scaladoc/src/dotty/tools/scaladoc/tasty/comments/Comments.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/tasty/comments/Comments.scala
@@ -7,7 +7,6 @@ import scala.util.Try
 import com.vladsch.flexmark.util.{ast => mdu, sequence}
 import com.vladsch.flexmark.{ast => mda}
 import com.vladsch.flexmark.formatter.Formatter
-import com.vladsch.flexmark.util.options.MutableDataSet
 import com.vladsch.flexmark.util.sequence.BasedSequence
 
 import scala.quoted._
diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/comments/MarkdownParser.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/comments/MarkdownParser.scala
index f5dd0ea88528..edf9051c0ed7 100644
--- a/scaladoc/src/dotty/tools/scaladoc/tasty/comments/MarkdownParser.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/tasty/comments/MarkdownParser.scala
@@ -9,7 +9,6 @@ import com.vladsch.flexmark.formatter.Formatter
 import com.vladsch.flexmark.parser.Parser
 import com.vladsch.flexmark.util.sequence.CharSubSequence
 import com.vladsch.flexmark.parser.ParserEmulationProfile
-import com.vladsch.flexmark.ext.gfm.tables.TablesExtension
 import com.vladsch.flexmark.ext.gfm.strikethrough.StrikethroughExtension
 import com.vladsch.flexmark.ext.gfm.tasklist.TaskListExtension
 import com.vladsch.flexmark.ext.emoji.EmojiExtension
@@ -17,10 +16,12 @@ import com.vladsch.flexmark.ext.autolink.AutolinkExtension
 import com.vladsch.flexmark.ext.anchorlink.AnchorLinkExtension
 import com.vladsch.flexmark.ext.yaml.front.matter.YamlFrontMatterExtension
 import com.vladsch.flexmark.ext.wikilink.WikiLinkExtension
-import com.vladsch.flexmark.util.options.{ DataHolder, MutableDataSet }
-import com.vladsch.flexmark.util.builder.Extension
 
 import scala.jdk.CollectionConverters._
+import com.vladsch.flexmark.util.misc.Extension
+import com.vladsch.flexmark.ext.tables.TablesExtension
+import com.vladsch.flexmark.util.data.MutableDataSet
+import com.vladsch.flexmark.util.data.DataHolder
 
 object MarkdownParser {
 
diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/comments/markdown/DocFlexmarkExtension.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/comments/markdown/DocFlexmarkExtension.scala
index ad5533d634ad..d797eaed7fbf 100644
--- a/scaladoc/src/dotty/tools/scaladoc/tasty/comments/markdown/DocFlexmarkExtension.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/tasty/comments/markdown/DocFlexmarkExtension.scala
@@ -15,6 +15,9 @@ import com.vladsch.flexmark._
 
 import dotty.tools.scaladoc.snippets._
 import scala.jdk.CollectionConverters._
+import com.vladsch.flexmark.util.data.MutableDataHolder
+import com.vladsch.flexmark.util.data.DataHolder
+import com.vladsch.flexmark.html.renderer.NodeRenderingHandler.CustomNodeRenderer
 
 class DocLinkNode(
   val target: DocLink,
@@ -40,7 +43,7 @@ class DocFlexmarkParser(resolveLink: String => DocLink) extends Parser.ParserExt
   class Factory extends LinkRefProcessorFactory:
     override def getBracketNestingLevel(options: DataHolder) = 1
     override def getWantExclamationPrefix(options: DataHolder) = false
-    override def create(doc: Document): LinkRefProcessor =
+    override def apply(doc: Document): LinkRefProcessor =
       new WikiLinkLinkRefProcessor(doc):
         override def createNode(nodeChars: BasedSequence): Node =
           val chars = nodeChars.toString.substring(2, nodeChars.length - 2)
@@ -75,7 +78,7 @@ case class DocFlexmarkRenderer(renderLink: (DocLink, String) => String)
         )
 
     object Factory extends NodeRendererFactory:
-      override def create(options: DataHolder): NodeRenderer = Render
+      override def apply(options: DataHolder): NodeRenderer = Render
 
     def extend(htmlRendererBuilder: HtmlRenderer.Builder, tpe: String): Unit =
       htmlRendererBuilder.nodeRendererFactory(Factory)
diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/comments/markdown/SectionRenderingExtension.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/comments/markdown/SectionRenderingExtension.scala
index 1fa1a604c85a..421c7eaab76f 100644
--- a/scaladoc/src/dotty/tools/scaladoc/tasty/comments/markdown/SectionRenderingExtension.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/tasty/comments/markdown/SectionRenderingExtension.scala
@@ -3,17 +3,23 @@ package tasty.comments.markdown
 
 import com.vladsch.flexmark.html.*
 import com.vladsch.flexmark.html.renderer.*
+import com.vladsch.flexmark.html.renderer.NodeRenderingHandler.CustomNodeRenderer
 import com.vladsch.flexmark.parser.*
 import com.vladsch.flexmark.ext.wikilink.*
 import com.vladsch.flexmark.ext.wikilink.internal.WikiLinkLinkRefProcessor
 import com.vladsch.flexmark.util.ast.*
 import com.vladsch.flexmark.util.options.*
 import com.vladsch.flexmark.util.sequence.BasedSequence
-import com.vladsch.flexmark.util.html.{AttributeImpl, Attributes}
 import com.vladsch.flexmark.*
 import com.vladsch.flexmark.ast.FencedCodeBlock
 
 import scala.collection.mutable
+import com.vladsch.flexmark.util.data.MutableDataHolder
+import com.vladsch.flexmark.util.html.Attributes
+import com.vladsch.flexmark.util.html.AttributeImpl
+import com.vladsch.flexmark.util.data.DataHolder
+import com.vladsch.flexmark.util.html.Attribute
+import com.vladsch.flexmark.util.html.MutableAttributes
 
 
 object SectionRenderingExtension extends HtmlRenderer.HtmlRendererExtension:
@@ -30,18 +36,18 @@ object SectionRenderingExtension extends HtmlRenderer.HtmlRendererExtension:
       repeatedIds.update((c, header.getText), repeatedIds((c, header.getText)) + 1)
       val id = idGenerator.getId(header.getText.append(ifSuffixStr))
       val anchor = AnchorLink(s"#$id")
-      val attributes = Attributes()
       val headerClass: String = header.getLevel match
         case 1 => "h500"
         case 2 => "h500"
         case 3 => "h400"
         case 4 => "h300"
         case _ => "h50"
-      attributes.addValue(AttributeImpl.of("class", headerClass))
+      val attributes = MutableAttributes()
+      attributes.addValue("class", headerClass)
       val embeddedAttributes = EmbeddedAttributeProvider.EmbeddedNodeAttributes(header, attributes)
       header.prependChild(embeddedAttributes)
       header.prependChild(anchor)
-      html.attr(AttributeImpl.of("id", id)).withAttr.tag("section", false, false, () => {
+      html.attr("id", id).withAttr.tag("section", false, false, () => {
         c.render(header)
         body.foreach(c.render)
       })
@@ -59,7 +65,8 @@ object SectionRenderingExtension extends HtmlRenderer.HtmlRendererExtension:
       )
 
   object Factory extends NodeRendererFactory:
-    override def create(options: DataHolder): NodeRenderer = Render
+    override def apply(options: DataHolder): NodeRenderer = Render
+
 
   def extend(htmlRendererBuilder: HtmlRenderer.Builder, tpe: String): Unit =
     htmlRendererBuilder.nodeRendererFactory(Factory)
diff --git a/scaladoc/src/dotty/tools/scaladoc/tasty/comments/markdown/SnippetRenderingExtension.scala b/scaladoc/src/dotty/tools/scaladoc/tasty/comments/markdown/SnippetRenderingExtension.scala
index e70b0883a31e..e980c5fc44ef 100644
--- a/scaladoc/src/dotty/tools/scaladoc/tasty/comments/markdown/SnippetRenderingExtension.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/tasty/comments/markdown/SnippetRenderingExtension.scala
@@ -13,6 +13,9 @@ import com.vladsch.flexmark.util.options._
 import com.vladsch.flexmark.util.sequence.BasedSequence
 import com.vladsch.flexmark._
 import com.vladsch.flexmark.ast.FencedCodeBlock
+import com.vladsch.flexmark.util.data.MutableDataHolder
+import com.vladsch.flexmark.html.renderer.NodeRenderingHandler.CustomNodeRenderer
+import com.vladsch.flexmark.util.data.DataHolder
 
 /**
  * SnippetRenderingExtension is responsible for running an analysis for scala codeblocks in the static documentation/scaladoc comments.
@@ -39,7 +42,7 @@ object SnippetRenderingExtension extends HtmlRenderer.HtmlRendererExtension:
       )
 
   object Factory extends NodeRendererFactory:
-    override def create(options: DataHolder): NodeRenderer = Render
+    override def apply(options: DataHolder): NodeRenderer = Render
 
   def extend(htmlRendererBuilder: HtmlRenderer.Builder, tpe: String): Unit =
     htmlRendererBuilder.nodeRendererFactory(Factory)
diff --git a/scaladoc/test/dotty/tools/scaladoc/site/TemplateFileTests.scala b/scaladoc/test/dotty/tools/scaladoc/site/TemplateFileTests.scala
index 203ab9cf5ed1..f07868ad4f44 100644
--- a/scaladoc/test/dotty/tools/scaladoc/site/TemplateFileTests.scala
+++ b/scaladoc/test/dotty/tools/scaladoc/site/TemplateFileTests.scala
@@ -202,6 +202,7 @@ class TemplateFileTests:
         content -> "md"
       )
     )
+
   @Test
   def markdown(): Unit =
     testTemplate(
@@ -222,10 +223,10 @@ class TemplateFileTests:
       ext = "md"
     ) { t =>
       assertEquals(
-        """<section id="hello-there">
-        |<h1 class="h500"><a href="#hello-there" class="anchor"></a>Hello there!</h1>
+        """<section id="hello-there2">
+        |<h1 class="h500"><a href="#hello-there2" class="anchor"></a>Hello there2!</h1>
         |</section>""".stripMargin,
-      t.resolveInner(RenderingContext(Map("msg" -> "there"))).code.trim())
+      t.resolveInner(RenderingContext(Map("msg" -> "there2"))).code.trim())
     }
 
   @Test
diff --git a/scaladoc/test/dotty/tools/scaladoc/snippets/SnippetsE2eTest.scala b/scaladoc/test/dotty/tools/scaladoc/snippets/SnippetsE2eTest.scala
index 1f28c938033d..616f7ae7f35e 100644
--- a/scaladoc/test/dotty/tools/scaladoc/snippets/SnippetsE2eTest.scala
+++ b/scaladoc/test/dotty/tools/scaladoc/snippets/SnippetsE2eTest.scala
@@ -13,7 +13,6 @@ import dotty.tools.dotc.reporting.{ Diagnostic, StoreReporter }
 import com.vladsch.flexmark.util.{ast => mdu, sequence}
 import com.vladsch.flexmark.{ast => mda}
 import com.vladsch.flexmark.formatter.Formatter
-import com.vladsch.flexmark.util.options.MutableDataSet
 import scala.jdk.CollectionConverters._
 
 import dotty.tools.scaladoc.tasty.comments.markdown.ExtendedFencedCodeBlock

From d9fa877b02fede0447d0b3b94a9d369d2f3f6d93 Mon Sep 17 00:00:00 2001
From: Jamie Thompson <bishbashboshjt@gmail.com>
Date: Fri, 28 Apr 2023 18:21:43 +0200
Subject: [PATCH 508/657] apply other-new-features/trait-parameters.md

---
 docs/_spec/05-classes-and-objects.md          | 82 +++++++++++++++--
 .../other-new-features/trait-parameters.md    | 34 +++++++
 .../other-new-features/trait-parameters.md    | 88 -------------------
 3 files changed, 110 insertions(+), 94 deletions(-)
 create mode 100644 docs/_spec/APPLIEDreference/other-new-features/trait-parameters.md
 delete mode 100644 docs/_spec/TODOreference/other-new-features/trait-parameters.md

diff --git a/docs/_spec/05-classes-and-objects.md b/docs/_spec/05-classes-and-objects.md
index 5de7048ba00e..30e177e843ee 100644
--- a/docs/_spec/05-classes-and-objects.md
+++ b/docs/_spec/05-classes-and-objects.md
@@ -92,8 +92,10 @@ If this is not a template of a trait, then its _evaluation_ consists of the foll
 
 - First, the superclass constructor ´sc´ is
   [evaluated](#constructor-invocations).
-- Then, all base classes in the template's [linearization](#class-linearization) up to the template's superclass denoted by ´sc´ are mixin-evaluated.
-Mixin-evaluation happens in reverse order of occurrence in the linearization.
+- Then, all base classes in the template's [linearization](#class-linearization) up to the template's superclass denoted by ´sc´ are evaluated.
+evaluation happens in reverse order of occurrence in the linearization. Each evaluation occurs as follows:
+  - First, arguments to ´mt_i´ are evaluated from left to right, and set as parameters of ´mt_i´.
+  - ´mt_i´ is then mixin-evaluated.
 - Finally, the statement sequence ´\mathit{stats}\,´ is evaluated.
 
 ### Constructor Invocations
@@ -662,13 +664,10 @@ This form of extensibility can be excluded by declaring the base class `Expr` `s
 ## Traits
 
 ```ebnf
-TmplDef          ::=  ‘trait’ TraitDef
-TraitDef         ::=  id [TypeParamClause] TraitTemplateOpt
-TraitTemplateOpt ::=  ‘extends’ TraitTemplate | [[‘extends’] TemplateBody]
+TmplDef          ::=  ‘trait’ ClassDef
 ```
 
 A _trait_ is a class that is meant to be added to some other class as a mixin.
-Unlike normal classes, traits cannot have constructor parameters.
 Furthermore, no constructor arguments are passed to the superclass of the trait.
 This is not necessary as traits are initialized after the superclass is initialized.
 
@@ -743,9 +742,80 @@ object MyTable extends ListTable[String, Int](0) with SynchronizedTable[String,
 The object `MyTable` inherits its `get` and `set` method from `SynchronizedTable`.
 The `super` calls in these methods are re-bound to refer to the corresponding implementations in `ListTable`, which is the actual supertype of `SynchronizedTable` in `MyTable`.
 
+### Extending parameterized traits
+
+Extra rules apply for extending a trait with parameters:
+
+1. If a class `´C´` extends a parameterized trait `´T´`, and its superclass does not, `´C´` _must_ pass arguments to `´T´`.
+
+2. If a class `´C´` extends a parameterized trait `´T´`, and its superclass does as well, `´C´` _must not_  pass arguments to `´T´`.
+
+3. Traits must never pass arguments to parent traits.
+
+4. If a class `´C´` extends an unparameterized trait `´T_i´` and the base types of `´T_i´` include parameterized trait `´T_j´`, and the superclass of `´C´` does not extend `´T_j´`, then `´C´` _must_ also explicitly extend `´T_j´` and pass arguments.
+This rule is relaxed if the missing trait contains only context parameters. In that case the trait reference is implicitly inserted as an additional parent with inferred arguments.
+
+###### Example - Preventing ambiguities
+
+The following listing tries to extend `Greeting` twice, with different parameters.
+
+```scala
+trait Greeting(val name: String):
+  def msg = s"How are you, $name"
+
+class C extends Greeting("Bob")
+
+class D extends C, Greeting("Bill") // error
+
+@main def greet = println(D().msg)
+```
+
+Should this program print "Bob" or "Bill"? In fact this program is illegal, because it violates rule 2 above.
+Instead, `D` can extend `Greeting` without passing arguments.
+
+###### Example - Overriding
+
+Here's a variant of `Greeting` that overrides `msg`:
+```scala
+trait FormalGreeting extends Greeting:
+  override def msg = s"How do you do, $name"
+```
+
+Due to rule 4, the following class extending `FormalGreeting` is required to also extend `Greeting` with arguments:
+```scala
+class GreetBobFormally extends FormalGreeting, Greeting("Bob")
+```
+
+###### Example - Inferred context parameters
+
+Here's a variant of `Greeting` where the addressee is a context parameter of type `ImpliedName`:
+
+```scala
+trait ImpliedGreeting(using val iname: ImpliedName):
+  def msg = s"How are you, $iname"
+
+case class ImpliedName(name: String):
+  override def toString = name
+
+trait ImpliedFormalGreeting extends ImpliedGreeting:
+  override def msg = s"How do you do, $iname"
+
+class F(using iname: ImpliedName) extends ImpliedFormalGreeting
+```
+
+The definition of `F` in the last line is implicitly expanded to
+```scala
+class F(using iname: ImpliedName) extends
+  Object, // implicitly inserted
+  ImpliedGreeting(using iname), // implicitly inserted
+  ImpliedFormalGreeting
+```
+Due to rule 4, `F` is required to also extend `ImpliedGreeting` and pass arguments to it, however note that because `ImpliedGreeting` has only context parameters the extension was added implicitly.
+
 ## Object Definitions
 
 ```ebnf
+TmplDef         ::=  ‘object’ ObjectDef
 ObjectDef       ::=  id ClassTemplate
 ```
 
diff --git a/docs/_spec/APPLIEDreference/other-new-features/trait-parameters.md b/docs/_spec/APPLIEDreference/other-new-features/trait-parameters.md
new file mode 100644
index 000000000000..7924224ddc74
--- /dev/null
+++ b/docs/_spec/APPLIEDreference/other-new-features/trait-parameters.md
@@ -0,0 +1,34 @@
+---
+layout: doc-page
+title: "Trait Parameters"
+nightlyOf: https://docs.scala-lang.org/scala3/reference/other-new-features/trait-parameters.html
+---
+
+Scala 3 enables traits to have parameters, just like a class.
+
+For example, here is a trait `Greeting`:
+```scala
+trait Greeting(val name: String):
+  def msg = s"How are you, $name"
+```
+
+A class, enum, or object can extend `Greeting` as follows:
+
+```scala
+class Greet extends Greeting("Bob"):
+  println(msg)
+```
+
+However if another trait extends `Greeting` then it must not pass arguments:
+
+```scala
+trait FormalGreeting extends Greeting:
+  override def msg = s"How do you do, $name"
+```
+
+If you want a class to greet Bob formally, then you should extend both `FormalGreeting` and `Greeting`:
+
+```scala
+class GreetFormally extends FormalGreeting, Greeting("Bob"):
+  println(msg)
+```
diff --git a/docs/_spec/TODOreference/other-new-features/trait-parameters.md b/docs/_spec/TODOreference/other-new-features/trait-parameters.md
deleted file mode 100644
index c704e73ce9b8..000000000000
--- a/docs/_spec/TODOreference/other-new-features/trait-parameters.md
+++ /dev/null
@@ -1,88 +0,0 @@
----
-layout: doc-page
-title: "Trait Parameters"
-nightlyOf: https://docs.scala-lang.org/scala3/reference/other-new-features/trait-parameters.html
----
-
-Scala 3 allows traits to have parameters, just like classes have parameters.
-
-```scala
-trait Greeting(val name: String):
-  def msg = s"How are you, $name"
-
-class C extends Greeting("Bob"):
-  println(msg)
-```
-
-Arguments to a trait are evaluated immediately before the trait is initialized.
-
-One potential issue with trait parameters is how to prevent
-ambiguities. For instance, you might try to extend `Greeting` twice,
-with different parameters.
-
-```scala
-class D extends C, Greeting("Bill") // error: parameter passed twice
-```
-
-Should this print "Bob" or "Bill"? In fact this program is illegal,
-because it violates the second rule of the following for trait parameters:
-
- 1. If a class `C` extends a parameterized trait `T`, and its superclass does not, `C` _must_ pass arguments to `T`.
-
- 2. If a class `C` extends a parameterized trait `T`, and its superclass does as well, `C` _must not_  pass arguments to `T`.
-
- 3. Traits must never pass arguments to parent traits.
-
-Here's a trait extending the parameterized trait `Greeting`.
-
-```scala
-trait FormalGreeting extends Greeting:
-  override def msg = s"How do you do, $name"
-```
-As is required, no arguments are passed to `Greeting`. However, this poses an issue
-when defining a class that extends `FormalGreeting`:
-
-```scala
-class E extends FormalGreeting // error: missing arguments for `Greeting`.
-```
-
-The correct way to write `E` is to extend both `Greeting` and
-`FormalGreeting` (in either order):
-
-```scala
-class E extends Greeting("Bob"), FormalGreeting
-```
-
-## Traits With Context Parameters
-
-This "explicit extension required" rule is relaxed if the missing trait contains only
-[context parameters](../contextual/using-clauses.md). In that case the trait reference is
-implicitly inserted as an additional parent with inferred arguments. For instance,
-here's a variant of greetings where the addressee is a context parameter of type
-`ImpliedName`:
-
-```scala
-case class ImpliedName(name: String):
-  override def toString = name
-
-trait ImpliedGreeting(using val iname: ImpliedName):
-  def msg = s"How are you, $iname"
-
-trait ImpliedFormalGreeting extends ImpliedGreeting:
-  override def msg = s"How do you do, $iname"
-
-class F(using iname: ImpliedName) extends ImpliedFormalGreeting
-```
-
-The definition of `F` in the last line is implicitly expanded to
-```scala
-class F(using iname: ImpliedName) extends
-  Object,
-  ImpliedGreeting(using iname),
-  ImpliedFormalGreeting(using iname)
-```
-Note the inserted reference to the super trait `ImpliedGreeting`, which was not mentioned explicitly.
-
-## Reference
-
-For more information, see [Scala SIP 25](http://docs.scala-lang.org/sips/pending/trait-parameters.html).

From 1f12656e75819f549b40ee3a8306773b037cb355 Mon Sep 17 00:00:00 2001
From: Fengyun Liu <fengyun.liu.cs@gmail.com>
Date: Tue, 2 May 2023 21:08:46 +0200
Subject: [PATCH 509/657] Fix logic in isCheckDefinitelyFalse

---
 .../tools/dotc/transform/TypeTestsCasts.scala  | 11 ++++++++---
 tests/neg-custom-args/isInstanceOf/i5826.scala | 18 +++++++++++++++++-
 2 files changed, 25 insertions(+), 4 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala b/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
index ef0fefecd49e..979538b56fc5 100644
--- a/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
@@ -157,8 +157,12 @@ object TypeTestsCasts {
               val xClass = effectiveClass(x)
               val pClass = effectiveClass(p)
 
-              !xClass.derivesFrom(pClass)
-              && (xClass.is(Final) || pClass.is(Final) || !xClass.is(Trait) && !pClass.is(Trait))
+              val bothAreClasses = !xClass.is(Trait) && !pClass.is(Trait)
+              val notXsubP = !xClass.derivesFrom(pClass)
+              val notPsubX = !pClass.derivesFrom(xClass)
+              bothAreClasses && notXsubP && notPsubX
+              || xClass.is(Final) && notXsubP
+              || pClass.is(Final) && notPsubX
             else
               false
     }
@@ -183,7 +187,8 @@ object TypeTestsCasts {
             val res1 = recur(tp1, P)
             val res2 = recur(tp2, P)
 
-            if res1.isEmpty && res2.isEmpty then res1
+            if res1.isEmpty && res2.isEmpty then
+              res1
             else if res2.isEmpty then
               if isCheckDefinitelyFalse(tp1, P) then res2
               else res1
diff --git a/tests/neg-custom-args/isInstanceOf/i5826.scala b/tests/neg-custom-args/isInstanceOf/i5826.scala
index e14142e974a8..c63bf3ab4aef 100644
--- a/tests/neg-custom-args/isInstanceOf/i5826.scala
+++ b/tests/neg-custom-args/isInstanceOf/i5826.scala
@@ -19,7 +19,23 @@ class Foo {
   }
 
   def test4[A](x: List[Int] | (A => Int)) = x match {
-    case ls: List[Int] => ls.head       // ok, List decomposes to Some and None
+    case ls: List[Int] => ls.head       // error, List extends Int => T
+    case _ => 0
+  }
+
+  final class C[T] extends A[T]
+
+  def test5[T](x: A[T] | B[T] | Option[T]): Boolean = x.isInstanceOf[C[String]] // error
+
+  def test6[T](x: A[T] | B[T] | Option[T]): Boolean = x.isInstanceOf[C[T]]
+
+  def test7[A](x: Option[Int] | (A => Int)) = x match {
+    case ls: Option[Int] => ls.head       // OK, Option decomposes to Some and None
+    case _ => 0
+  }
+
+  def test8(x: List[Int] | A[String]) = x match {
+    case ls: List[Int] => ls.head        // OK, List decomposes to :: and Nil
     case _ => 0
   }
 }

From 3347eb4fd3c9e0c13131ff83166a0359fcd91ed1 Mon Sep 17 00:00:00 2001
From: Lucas <leblanc.lucas29@gmail.com>
Date: Wed, 29 Mar 2023 15:04:33 +0200
Subject: [PATCH 510/657] Feat: Add a blog configuration with yaml - Add input
 config, who allow to define the path import - Add output config, who allow to
 define the path destination - Add hidden, who allow to not generate the blog

---
 .../scaladoc/site/StaticSiteContext.scala     |  4 +++
 .../scaladoc/site/StaticSiteLoader.scala      | 32 +++++++++++++++++--
 2 files changed, 33 insertions(+), 3 deletions(-)

diff --git a/scaladoc/src/dotty/tools/scaladoc/site/StaticSiteContext.scala b/scaladoc/src/dotty/tools/scaladoc/site/StaticSiteContext.scala
index de3f511c8e67..7a90a462cba0 100644
--- a/scaladoc/src/dotty/tools/scaladoc/site/StaticSiteContext.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/site/StaticSiteContext.scala
@@ -23,6 +23,10 @@ class StaticSiteContext(
   val docsPath = root.toPath.resolve("_docs")
   val blogPath = root.toPath.resolve("_blog")
 
+  def resolveNewBlogPath(stringPath: String): Path =
+    if stringPath.nonEmpty then root.toPath.resolve(stringPath)
+    else blogPath
+
   def relativize(path: Path): Path =
     if args.apiSubdirectory then
       docsPath.relativize(path)
diff --git a/scaladoc/src/dotty/tools/scaladoc/site/StaticSiteLoader.scala b/scaladoc/src/dotty/tools/scaladoc/site/StaticSiteLoader.scala
index c9ace108c9b2..8277cd2a5d01 100644
--- a/scaladoc/src/dotty/tools/scaladoc/site/StaticSiteLoader.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/site/StaticSiteLoader.scala
@@ -113,11 +113,37 @@ class StaticSiteLoader(val root: File, val args: Scaladoc.Args)(using StaticSite
     StaticSiteRoot(withBlog, mappings)
   }
 
+  var hiddenBlog = false
+
+  def readYml: (Option[Boolean], Option[Boolean], Option[Boolean], String) =
+    val ymlPath = root.toPath.resolve("blog.yml")
+    if (Files.exists(ymlPath)) then
+      val yamlContent = Source.fromFile(ymlPath.toString).getLines().mkString("\n")
+      val hidden = if (yamlContent.contains("hidden: true")) Some(true) else None
+      val input = if (yamlContent.contains("input:")) Some(true) else None
+      val output = if (yamlContent.contains("output:")) Some(true) else None
+      (hidden, input, output, yamlContent)
+    else
+      (None, None, None, "")
+
   def loadBlog(): Option[LoadedTemplate] = {
+    val (hidden, input, output, yamlContent) = readYml
+    val lines = yamlContent.split("\n")
+    val rootPath = input.collect {
+      case true =>
+        lines.collectFirst { case line if line.contains("input:") => line.replaceFirst("input:", "").trim }
+          .map(ctx.resolveNewBlogPath)
+          .getOrElse(ctx.blogPath)
+    }.getOrElse(ctx.blogPath)
+    val defaultDirectory = output.collect {
+    case true =>
+      lines
+        .collectFirst { case line if line.contains("output:") => line.replaceFirst("output:", "").trim }
+        .getOrElse("blog")
+    }.getOrElse("blog")
+    hidden.collect { case true => hiddenBlog = true }
     type Date = (String, String, String)
-    val rootPath = ctx.blogPath
-    val defaultDirectory = "blog"
-    if (!Files.exists(rootPath)) None
+    if (!Files.exists(rootPath) || hiddenBlog) None
     else {
       val indexPageOpt = Seq(
           rootPath.resolve("index.md"),

From e243b322475c5d0f9bd682c0bfbb8eb6b6dec13b Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Tue, 25 Apr 2023 16:00:05 +0200
Subject: [PATCH 511/657] deps: update sbt version to 1.8.2

---
 community-build/src/scala/dotty/communitybuild/projects.scala   | 2 +-
 project/build.properties                                        | 2 +-
 sbt-test/sbt-dotty/dotty-knowledge.i17/project/build.properties | 2 +-
 semanticdb/project/build.properties                             | 2 +-
 .../sourcepath-with-inline-api-hash/project/build.properties    | 2 +-
 .../sourcepath-with-inline/project/build.properties             | 2 +-
 6 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/community-build/src/scala/dotty/communitybuild/projects.scala b/community-build/src/scala/dotty/communitybuild/projects.scala
index fe3f5cfed5a2..1349c3adc3b9 100644
--- a/community-build/src/scala/dotty/communitybuild/projects.scala
+++ b/community-build/src/scala/dotty/communitybuild/projects.scala
@@ -140,7 +140,7 @@ final case class SbtCommunityProject(
       case Some(ivyHome) => List(s"-Dsbt.ivy.home=$ivyHome")
       case _ => Nil
     extraSbtArgs ++ sbtProps ++ List(
-      "-sbt-version", "1.8.0",
+      "-sbt-version", "1.8.2",
       "-Dsbt.supershell=false",
       s"-Ddotty.communitybuild.dir=$communitybuildDir",
       s"--addPluginSbtFile=$sbtPluginFilePath"
diff --git a/project/build.properties b/project/build.properties
index 8b9a0b0ab037..46e43a97ed86 100644
--- a/project/build.properties
+++ b/project/build.properties
@@ -1 +1 @@
-sbt.version=1.8.0
+sbt.version=1.8.2
diff --git a/sbt-test/sbt-dotty/dotty-knowledge.i17/project/build.properties b/sbt-test/sbt-dotty/dotty-knowledge.i17/project/build.properties
index 8b9a0b0ab037..46e43a97ed86 100644
--- a/sbt-test/sbt-dotty/dotty-knowledge.i17/project/build.properties
+++ b/sbt-test/sbt-dotty/dotty-knowledge.i17/project/build.properties
@@ -1 +1 @@
-sbt.version=1.8.0
+sbt.version=1.8.2
diff --git a/semanticdb/project/build.properties b/semanticdb/project/build.properties
index 8b9a0b0ab037..46e43a97ed86 100644
--- a/semanticdb/project/build.properties
+++ b/semanticdb/project/build.properties
@@ -1 +1 @@
-sbt.version=1.8.0
+sbt.version=1.8.2
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 8b9a0b0ab037..46e43a97ed86 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.8.0
+sbt.version=1.8.2
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 8b9a0b0ab037..46e43a97ed86 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.8.0
+sbt.version=1.8.2

From 0daeabed7c204bd883b7846ba3d98ca7375e39a6 Mon Sep 17 00:00:00 2001
From: Lucas <leblanc.lucas29@gmail.com>
Date: Wed, 3 May 2023 13:56:56 +0200
Subject: [PATCH 512/657] Fix: Refactor the function using jackson

---
 .../tools/scaladoc/site/BlogParser.scala      | 29 +++++++++++++++
 .../scaladoc/site/StaticSiteLoader.scala      | 35 ++++---------------
 2 files changed, 35 insertions(+), 29 deletions(-)
 create mode 100644 scaladoc/src/dotty/tools/scaladoc/site/BlogParser.scala

diff --git a/scaladoc/src/dotty/tools/scaladoc/site/BlogParser.scala b/scaladoc/src/dotty/tools/scaladoc/site/BlogParser.scala
new file mode 100644
index 000000000000..6fd3d3db0c8d
--- /dev/null
+++ b/scaladoc/src/dotty/tools/scaladoc/site/BlogParser.scala
@@ -0,0 +1,29 @@
+package dotty.tools.scaladoc
+package site
+
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.dataformat.yaml.YAMLFactory
+import com.fasterxml.jackson.databind.DeserializationFeature
+import java.io.File
+import scala.beans._
+
+case class BlogConfig(
+  @BeanProperty var input: String,
+  @BeanProperty var output: String,
+  @BooleanBeanProperty var hidden: Boolean
+):
+    def this() = this(null, null, false)
+
+object BlogParser:
+  def readYml(root: File): BlogConfig =
+    val ymlFile = root.toPath
+    .resolve("blog.yml")
+    .toFile
+
+    if ymlFile.exists then
+      val mapper = new ObjectMapper(new YAMLFactory())
+      mapper.findAndRegisterModules();
+
+      val blogConfig: BlogConfig = mapper.readValue(ymlFile, classOf[BlogConfig])
+      blogConfig
+    else new BlogConfig
diff --git a/scaladoc/src/dotty/tools/scaladoc/site/StaticSiteLoader.scala b/scaladoc/src/dotty/tools/scaladoc/site/StaticSiteLoader.scala
index 8277cd2a5d01..489720cc5936 100644
--- a/scaladoc/src/dotty/tools/scaladoc/site/StaticSiteLoader.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/site/StaticSiteLoader.scala
@@ -5,6 +5,7 @@ import java.io.File
 import java.nio.file.Files
 import java.nio.file.{ Paths, Path }
 import scala.io._
+import dotty.tools.scaladoc.site.BlogParser
 
 class StaticSiteLoader(val root: File, val args: Scaladoc.Args)(using StaticSiteContext, CompilerContext):
   val ctx: StaticSiteContext = summon[StaticSiteContext]
@@ -113,37 +114,13 @@ class StaticSiteLoader(val root: File, val args: Scaladoc.Args)(using StaticSite
     StaticSiteRoot(withBlog, mappings)
   }
 
-  var hiddenBlog = false
-
-  def readYml: (Option[Boolean], Option[Boolean], Option[Boolean], String) =
-    val ymlPath = root.toPath.resolve("blog.yml")
-    if (Files.exists(ymlPath)) then
-      val yamlContent = Source.fromFile(ymlPath.toString).getLines().mkString("\n")
-      val hidden = if (yamlContent.contains("hidden: true")) Some(true) else None
-      val input = if (yamlContent.contains("input:")) Some(true) else None
-      val output = if (yamlContent.contains("output:")) Some(true) else None
-      (hidden, input, output, yamlContent)
-    else
-      (None, None, None, "")
-
   def loadBlog(): Option[LoadedTemplate] = {
-    val (hidden, input, output, yamlContent) = readYml
-    val lines = yamlContent.split("\n")
-    val rootPath = input.collect {
-      case true =>
-        lines.collectFirst { case line if line.contains("input:") => line.replaceFirst("input:", "").trim }
-          .map(ctx.resolveNewBlogPath)
-          .getOrElse(ctx.blogPath)
-    }.getOrElse(ctx.blogPath)
-    val defaultDirectory = output.collect {
-    case true =>
-      lines
-        .collectFirst { case line if line.contains("output:") => line.replaceFirst("output:", "").trim }
-        .getOrElse("blog")
-    }.getOrElse("blog")
-    hidden.collect { case true => hiddenBlog = true }
+    val blogConfig = BlogParser.readYml(root)
+    val rootPath = Option(blogConfig.input).map(input => ctx.resolveNewBlogPath(input)).getOrElse(ctx.blogPath)
+    val defaultDirectory = Option(blogConfig.output).getOrElse("blog")
+
     type Date = (String, String, String)
-    if (!Files.exists(rootPath) || hiddenBlog) None
+    if (!Files.exists(rootPath) || blogConfig.hidden) None
     else {
       val indexPageOpt = Seq(
           rootPath.resolve("index.md"),

From afbc53b3fc75a7494a00f4d392b776b5f7414ed7 Mon Sep 17 00:00:00 2001
From: Som Snytt <som.snytt@gmail.com>
Date: Wed, 3 May 2023 09:32:23 -0700
Subject: [PATCH 513/657] Avoid URL constructor deprecated on JDK20

---
 .../dotty/tools/dotc/classpath/DirectoryClassPath.scala   | 4 ++--
 .../tools/dotc/classpath/VirtualDirectoryClassPath.scala  | 8 +++-----
 compiler/src/dotty/tools/io/ClassPath.scala               | 7 +++----
 .../src/dotty/tools/repl/AbstractFileClassLoader.scala    | 3 +++
 project/DocumentationWebsite.scala                        | 3 ++-
 5 files changed, 13 insertions(+), 12 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/classpath/DirectoryClassPath.scala b/compiler/src/dotty/tools/dotc/classpath/DirectoryClassPath.scala
index 7f20d7c7d9ea..1411493bcbfd 100644
--- a/compiler/src/dotty/tools/dotc/classpath/DirectoryClassPath.scala
+++ b/compiler/src/dotty/tools/dotc/classpath/DirectoryClassPath.scala
@@ -6,7 +6,7 @@ package dotty.tools.dotc.classpath
 import scala.language.unsafeNulls
 
 import java.io.{File => JFile}
-import java.net.URL
+import java.net.{URI, URL}
 import java.nio.file.{FileSystems, Files}
 
 import dotty.tools.dotc.classpath.PackageNameUtils.{packageContains, separatePkgAndClassNames}
@@ -194,7 +194,7 @@ final class JrtClassPath(fs: java.nio.file.FileSystem) extends ClassPath with No
     if (inPackage.isRoot) ClassPathEntries(packages(inPackage), Nil)
     else ClassPathEntries(packages(inPackage), classes(inPackage))
 
-  def asURLs: Seq[URL] = Seq(new URL("jrt:/"))
+  def asURLs: Seq[URL] = Seq(new URI("jrt:/").toURL)
   // 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
diff --git a/compiler/src/dotty/tools/dotc/classpath/VirtualDirectoryClassPath.scala b/compiler/src/dotty/tools/dotc/classpath/VirtualDirectoryClassPath.scala
index 0cb0ba59c52e..e750d9ccacc0 100644
--- a/compiler/src/dotty/tools/dotc/classpath/VirtualDirectoryClassPath.scala
+++ b/compiler/src/dotty/tools/dotc/classpath/VirtualDirectoryClassPath.scala
@@ -2,12 +2,10 @@ package dotty.tools.dotc.classpath
 
 import scala.language.unsafeNulls
 
-import dotty.tools.io.ClassRepresentation
+import dotty.tools.io.{ClassPath, ClassRepresentation}
 import dotty.tools.io.{AbstractFile, VirtualDirectory}
 import FileUtils._
-import java.net.URL
-
-import dotty.tools.io.ClassPath
+import java.net.{URI, URL}
 
 case class VirtualDirectoryClassPath(dir: VirtualDirectory) extends ClassPath with DirectoryLookup[ClassFileEntryImpl] with NoSourcePaths {
   type F = AbstractFile
@@ -37,7 +35,7 @@ case class VirtualDirectoryClassPath(dir: VirtualDirectory) extends ClassPath wi
   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 asURLs: Seq[URL] = Seq(new URI(dir.name).toURL)
   def asClassPathStrings: Seq[String] = Seq(dir.path)
 
   override def findClass(className: String): Option[ClassRepresentation] = findClassFile(className) map ClassFileEntryImpl.apply
diff --git a/compiler/src/dotty/tools/io/ClassPath.scala b/compiler/src/dotty/tools/io/ClassPath.scala
index 754c2bae3597..b45de57f9850 100644
--- a/compiler/src/dotty/tools/io/ClassPath.scala
+++ b/compiler/src/dotty/tools/io/ClassPath.scala
@@ -9,8 +9,7 @@ package io
 
 import scala.language.unsafeNulls
 
-import java.net.MalformedURLException
-import java.net.URL
+import java.net.{MalformedURLException, URI, URISyntaxException, URL}
 import java.util.regex.PatternSyntaxException
 
 import File.pathSeparator
@@ -182,8 +181,8 @@ object ClassPath {
   }
 
   def specToURL(spec: String): Option[URL] =
-    try Some(new URL(spec))
-    catch { case _: MalformedURLException => None }
+    try Some(new URI(spec).toURL)
+    catch case _: MalformedURLException | _: URISyntaxException => None
 
   def manifests: List[java.net.URL] = {
     import scala.jdk.CollectionConverters.EnumerationHasAsScala
diff --git a/compiler/src/dotty/tools/repl/AbstractFileClassLoader.scala b/compiler/src/dotty/tools/repl/AbstractFileClassLoader.scala
index 89fd290f7286..7a457a1d7546 100644
--- a/compiler/src/dotty/tools/repl/AbstractFileClassLoader.scala
+++ b/compiler/src/dotty/tools/repl/AbstractFileClassLoader.scala
@@ -23,6 +23,9 @@ import java.util.Collections
 class AbstractFileClassLoader(val root: AbstractFile, parent: ClassLoader) extends ClassLoader(parent):
   private def findAbstractFile(name: String) = root.lookupPath(name.split('/').toIndexedSeq, directory = false)
 
+  // on JDK 20 the URL constructor we're using is deprecated,
+  // but the recommended replacement, URL.of, doesn't exist on JDK 8
+  @annotation.nowarn("cat=deprecation")
   override protected def findResource(name: String) =
     findAbstractFile(name) match
       case null => null
diff --git a/project/DocumentationWebsite.scala b/project/DocumentationWebsite.scala
index e24917a60803..5f8e499af62f 100644
--- a/project/DocumentationWebsite.scala
+++ b/project/DocumentationWebsite.scala
@@ -1,4 +1,5 @@
 import java.io.File
+import java.net.URI
 import java.nio.file.Paths
 import sbt._
 import Build._
@@ -48,7 +49,7 @@ object DocumentationWebsite {
     sbt.IO.touch(inkuireDestinationFile)
 
     def tryFetch(retries: Int, timeout: Duration): Unit = {
-      val downloadProcess = (new java.net.URL(inkuireLink) #> inkuireDestinationFile).run()
+      val downloadProcess = (new URI(inkuireLink).toURL #> inkuireDestinationFile).run()
       val result: Future[Int] = Future(blocking(downloadProcess.exitValue()))
       try {
         Await.result(result, timeout) match {

From 0975d29fed6cef938513c332ea2d4ec054ee2d7a Mon Sep 17 00:00:00 2001
From: Som Snytt <som.snytt@gmail.com>
Date: Sat, 29 Apr 2023 09:33:56 -0700
Subject: [PATCH 514/657] Retry waiting for javac

If running a single test, the pool shutdown
is likely to subvert `waitFor` the javac process.
Catch the `InterruptedException` and try again
with a timed wait of generous but finite duration,
to accommodate testing by developers. This quick
fix does not correct the race, which presumably
does not matter because of the order in which tests
are ordinarily submitted.
---
 .../dotty/tools/vulpix/ParallelTesting.scala     | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/compiler/test/dotty/tools/vulpix/ParallelTesting.scala b/compiler/test/dotty/tools/vulpix/ParallelTesting.scala
index 3799a2335a78..bccbcbee29e1 100644
--- a/compiler/test/dotty/tools/vulpix/ParallelTesting.scala
+++ b/compiler/test/dotty/tools/vulpix/ParallelTesting.scala
@@ -12,7 +12,7 @@ import java.nio.file.{Files, NoSuchFileException, Path, Paths}
 import java.nio.charset.{Charset, StandardCharsets}
 import java.text.SimpleDateFormat
 import java.util.{HashMap, Timer, TimerTask}
-import java.util.concurrent.{TimeUnit, TimeoutException, Executors => JExecutors}
+import java.util.concurrent.{ExecutionException, TimeUnit, TimeoutException, Executors => JExecutors}
 
 import scala.collection.mutable
 import scala.io.{Codec, Source}
@@ -494,6 +494,12 @@ trait ParallelTesting extends RunnerOrchestration { self =>
         .and("-d", targetDir.getPath)
         .withClasspath(targetDir.getPath)
 
+      def waitForJudiciously(process: Process): Int =
+        try process.waitFor()
+        catch case _: InterruptedException =>
+          try if process.waitFor(5L, TimeUnit.MINUTES) then process.exitValue() else -2
+          finally Thread.currentThread.interrupt()
+
       def compileWithJavac(fs: Array[String]) = if (fs.nonEmpty) {
         val fullArgs = Array(
           "javac",
@@ -503,7 +509,7 @@ trait ParallelTesting extends RunnerOrchestration { self =>
         val process = Runtime.getRuntime.exec(fullArgs)
         val output = Source.fromInputStream(process.getErrorStream).mkString
 
-        if (process.waitFor() != 0) Some(output)
+        if waitForJudiciously(process) != 0 then Some(output)
         else None
       } else None
 
@@ -676,7 +682,11 @@ trait ParallelTesting extends RunnerOrchestration { self =>
 
         for fut <- eventualResults do
           try fut.get()
-          catch case ex: Exception =>
+          catch
+          case ee: ExecutionException if ee.getCause.isInstanceOf[InterruptedException] =>
+            System.err.println("Interrupted (probably running after shutdown)")
+            ee.printStackTrace()
+          case ex: Exception =>
             System.err.println(ex.getMessage)
             ex.printStackTrace()
 

From f4c49017d7d1a663ba4da6e016793c67d1e0bf36 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Thu, 4 May 2023 08:20:40 +0200
Subject: [PATCH 515/657] Make arguments order in quote hole deterministic

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

diff --git a/compiler/src/dotty/tools/dotc/transform/Splicing.scala b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
index 4b288349fc33..71bcaa4fcec0 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicing.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
@@ -177,7 +177,7 @@ class Splicing extends MacroTransform:
    *  ```
    */
   private class SpliceTransformer(spliceOwner: Symbol, isCaptured: Symbol => Boolean) extends Transformer:
-    private var refBindingMap = mutable.Map.empty[Symbol, (Tree, Symbol)]
+    private var refBindingMap = mutable.LinkedHashMap.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: QuoteTypeTags | Null = null // TODO: add to the context

From 82236ae16ef774dde7d87ced576cdb4335541b0e Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Thu, 4 May 2023 10:09:14 +0200
Subject: [PATCH 516/657] Do not remove inline method implementations until
 PruneErasedDefs

---
 .../src/dotty/tools/dotc/staging/CrossStageSafety.scala     | 5 +++--
 .../src/dotty/tools/dotc/transform/FirstTransform.scala     | 1 +
 compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala  | 4 +---
 compiler/src/dotty/tools/dotc/transform/Staging.scala       | 6 ++++--
 .../dotty/tools/dotc/BootstrappedOnlyCompilationTests.scala | 2 ++
 tests/pos-macros/macro-deprecation.scala                    | 4 ++++
 tests/pos-macros/macro-experimental.scala                   | 5 +++++
 7 files changed, 20 insertions(+), 7 deletions(-)
 create mode 100644 tests/pos-macros/macro-deprecation.scala
 create mode 100644 tests/pos-macros/macro-experimental.scala

diff --git a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
index 032067eca482..feb93c3c6319 100644
--- a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
+++ b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
@@ -90,6 +90,9 @@ class CrossStageSafety extends TreeMapWithStages {
                 if level != 0 then cpy.Apply(tree)(cpy.TypeApply(tree.fun)(fun, transformedBody :: Nil), quotes :: Nil)
                 else tpd.Quote(transformedBody).select(nme.apply).appliedTo(quotes).withSpan(tree.span)
 
+      case _: DefDef if tree.symbol.isInlineMethod =>
+        tree
+
       case _ if !inQuoteOrSpliceScope =>
         checkAnnotations(tree) // Check quotes in annotations
         super.transform(tree)
@@ -117,8 +120,6 @@ class CrossStageSafety extends TreeMapWithStages {
             // propagate healed types
             tree1.withType(tree1.tpt.tpe.appliedTo(tree1.args.map(_.tpe)))
           case tree1 => tree1
-      case tree: DefDef if tree.symbol.is(Inline) && level > 0 =>
-        EmptyTree // Remove inline defs in quoted code. Already fully inlined.
       case tree: ValOrDefDef =>
         checkAnnotations(tree)
         healInfo(tree, tree.tpt.srcPos)
diff --git a/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala b/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala
index a7e0795ce195..03639c8af689 100644
--- a/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala
+++ b/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala
@@ -18,6 +18,7 @@ import NameKinds.OuterSelectName
 import StdNames._
 import TypeUtils.isErasedValueType
 import config.Feature
+import inlines.Inlines.inInlineMethod
 
 object FirstTransform {
   val name: String = "firstTransform"
diff --git a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
index 0c3a94e7d9cd..581b320ed9df 100644
--- a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
@@ -103,9 +103,7 @@ class PickleQuotes extends MacroTransform {
           val pickled = PickleQuotes.pickle(quote1, quotes, contents)
           transform(pickled) // pickle quotes that are in the contents
         case tree: DefDef if !tree.rhs.isEmpty && tree.symbol.isInlineMethod =>
-          // 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))
+          tree
         case _ =>
           super.transform(tree)
   }
diff --git a/compiler/src/dotty/tools/dotc/transform/Staging.scala b/compiler/src/dotty/tools/dotc/transform/Staging.scala
index 581fd2753504..35a67e670457 100644
--- a/compiler/src/dotty/tools/dotc/transform/Staging.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Staging.scala
@@ -8,6 +8,7 @@ import dotty.tools.dotc.core.Decorators._
 import dotty.tools.dotc.core.Flags._
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.Types._
+import dotty.tools.dotc.inlines.Inlines
 import dotty.tools.dotc.util.SrcPos
 import dotty.tools.dotc.transform.SymUtils._
 import dotty.tools.dotc.staging.StagingLevel.*
@@ -56,7 +57,8 @@ class Staging extends MacroTransform {
           checker.transform(tree)
         case _ =>
       }
-
+    }
+    if !Inlines.inInlineMethod then
       tree match {
         case tree: RefTree =>
           assert(level != 0 || tree.symbol != defn.QuotedTypeModule_of,
@@ -72,7 +74,7 @@ class Staging extends MacroTransform {
         case _ =>
           // OK
       }
-    }
+  end checkPostCondition
 
   override def run(using Context): Unit =
     if (ctx.compilationUnit.needsStaging) super.run
diff --git a/compiler/test/dotty/tools/dotc/BootstrappedOnlyCompilationTests.scala b/compiler/test/dotty/tools/dotc/BootstrappedOnlyCompilationTests.scala
index 8c8f0079e868..2a665c478932 100644
--- a/compiler/test/dotty/tools/dotc/BootstrappedOnlyCompilationTests.scala
+++ b/compiler/test/dotty/tools/dotc/BootstrappedOnlyCompilationTests.scala
@@ -110,6 +110,8 @@ class BootstrappedOnlyCompilationTests {
     aggregateTests(
       compileFilesInDir("tests/neg-macros", defaultOptions.and("-Xcheck-macros")),
       compileFile("tests/pos-macros/i9570.scala", defaultOptions.and("-Xfatal-warnings")),
+      compileFile("tests/pos-macros/macro-deprecation.scala", defaultOptions.and("-Xfatal-warnings", "-deprecation")),
+      compileFile("tests/pos-macros/macro-experimental.scala", defaultOptions.and("-Yno-experimental")),
     ).checkExpectedErrors()
   }
 
diff --git a/tests/pos-macros/macro-deprecation.scala b/tests/pos-macros/macro-deprecation.scala
new file mode 100644
index 000000000000..ff14f96ac7fa
--- /dev/null
+++ b/tests/pos-macros/macro-deprecation.scala
@@ -0,0 +1,4 @@
+import scala.quoted.*
+
+inline def f = ${ impl } // error
+@deprecated def impl(using Quotes) = '{1}
diff --git a/tests/pos-macros/macro-experimental.scala b/tests/pos-macros/macro-experimental.scala
new file mode 100644
index 000000000000..dc011f4e45b9
--- /dev/null
+++ b/tests/pos-macros/macro-experimental.scala
@@ -0,0 +1,5 @@
+import scala.quoted.*
+import scala.annotation.experimental
+
+inline def f = ${ impl } // error
+@experimental def impl(using Quotes) = '{1}

From d02ecd02b7acde957600649ad41a1a1b33572f4d Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Thu, 4 May 2023 13:42:32 +0200
Subject: [PATCH 517/657] test: add in a check file for rewrite issue (#17410)

This adds in a test to ensure that the issue reported in #17399 is
indeed fixed with #12954. This case is a bit different, so best to also
just have it covered with a test.

Closes #17399
---
 compiler/test/dotty/tools/dotc/CompilationTests.scala | 1 +
 tests/rewrites/i17399.check                           | 7 +++++++
 tests/rewrites/i17399.scala                           | 5 +++++
 3 files changed, 13 insertions(+)
 create mode 100644 tests/rewrites/i17399.check
 create mode 100644 tests/rewrites/i17399.scala

diff --git a/compiler/test/dotty/tools/dotc/CompilationTests.scala b/compiler/test/dotty/tools/dotc/CompilationTests.scala
index d75afc330f5f..c782c78f8eb7 100644
--- a/compiler/test/dotty/tools/dotc/CompilationTests.scala
+++ b/compiler/test/dotty/tools/dotc/CompilationTests.scala
@@ -82,6 +82,7 @@ class CompilationTests {
       compileFile("tests/rewrites/i11895.scala", defaultOptions.and("-indent", "-rewrite")),
       compileFile("tests/rewrites/i12340.scala", unindentOptions.and("-rewrite")),
       compileFile("tests/rewrites/i17187.scala", unindentOptions.and("-rewrite")),
+      compileFile("tests/rewrites/i17399.scala", unindentOptions.and("-rewrite")),
     ).checkRewrites()
   }
 
diff --git a/tests/rewrites/i17399.check b/tests/rewrites/i17399.check
new file mode 100644
index 000000000000..0b7eef78db4f
--- /dev/null
+++ b/tests/rewrites/i17399.check
@@ -0,0 +1,7 @@
+def test[T](body:T):T = body
+
+object Test {
+  test {
+    println("test 1")
+  }
+}
diff --git a/tests/rewrites/i17399.scala b/tests/rewrites/i17399.scala
new file mode 100644
index 000000000000..965d17c4f718
--- /dev/null
+++ b/tests/rewrites/i17399.scala
@@ -0,0 +1,5 @@
+def test[T](body:T):T = body
+
+object Test:
+  test:
+    println("test 1")

From 23409794d310a41be7eba4fa5060afa5f9c65f87 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Thu, 4 May 2023 17:28:26 +0200
Subject: [PATCH 518/657] Add regression test

Closes #17409
---
 tests/pos-macros/i17409.scala | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 tests/pos-macros/i17409.scala

diff --git a/tests/pos-macros/i17409.scala b/tests/pos-macros/i17409.scala
new file mode 100644
index 000000000000..449e0576d84b
--- /dev/null
+++ b/tests/pos-macros/i17409.scala
@@ -0,0 +1,10 @@
+import scala.quoted.*
+
+transparent inline def thing =
+  ${ thingImpl }
+
+def thingImpl(using Quotes): Expr[Any] =
+  '{
+    def makeThing: { def me: this.type } = ???
+    makeThing
+  }

From e434e5f4d94816028581d0262edb0d169e9d3c9d Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sun, 30 Apr 2023 11:11:02 +0200
Subject: [PATCH 519/657] Allow new capture set syntax

 - `^{xs}`  in postfix
 - `->{xs}` after arrow
 - `any` instead of `*`
---
 .../src/dotty/tools/dotc/ast/Desugar.scala    |   8 +-
 compiler/src/dotty/tools/dotc/ast/untpd.scala |  14 ++
 .../src/dotty/tools/dotc/core/StdNames.scala  |   2 +
 .../dotty/tools/dotc/parsing/Parsers.scala    |  24 ++-
 .../tools/dotc/printing/RefinedPrinter.scala  |   2 +
 .../src/dotty/tools/dotc/typer/Typer.scala    |  16 +-
 tests/pos-custom-args/captures/byname.scala   |   4 +-
 .../pos-custom-args/captures/capt-test.scala  |   8 +-
 tests/pos-custom-args/captures/capt1.scala    |  16 +-
 tests/pos-custom-args/captures/classes.scala  |  18 +-
 .../colltest5/CollectionStrawManCC5_1.scala   | 170 +++++++++---------
 .../captures/colltest5/Test_2.scala           |  26 +--
 12 files changed, 174 insertions(+), 134 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index d6f9e0d24c91..e0cba60950fa 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -1827,13 +1827,11 @@ object desugar {
       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))
+            cpy.ByNameTypeTree(parent)(makeRetaining(restpt, refs, tpnme.retainsByName))
           case _ =>
-            annotate(tpnme.retains, parent)
+            makeRetaining(parent, refs, tpnme.retains)
       case f: FunctionWithMods if f.hasErasedParams => makeFunctionWithValDefs(f, pt)
     }
     desugared.withSpan(tree.span)
@@ -1927,7 +1925,7 @@ object desugar {
         }
         tree match
           case tree: FunctionWithMods =>
-            untpd.FunctionWithMods(applyVParams, tree.body, tree.mods, tree.erasedParams)
+            untpd.FunctionWithMods(applyVParams, result, tree.mods, tree.erasedParams)
           case _ => untpd.Function(applyVParams, result)
     }
   }
diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
index 30f58fba44ec..910b0f84758a 100644
--- a/compiler/src/dotty/tools/dotc/ast/untpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -150,6 +150,9 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   /** {x1, ..., xN} T   (only relevant under captureChecking) */
   case class CapturingTypeTree(refs: List[Tree], parent: Tree)(implicit @constructorOnly src: SourceFile) extends TypTree
 
+  /** {x1, ..., xN} T   (only relevant under captureChecking) */
+  case class CapturesAndResult(refs: List[Tree], parent: Tree)(implicit @constructorOnly src: SourceFile) extends TypTree
+
   /** Short-lived usage in typer, does not need copy/transform/fold infrastructure */
   case class DependentTypeTree(tp: List[Symbol] => Type)(implicit @constructorOnly src: SourceFile) extends Tree
 
@@ -501,6 +504,9 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def captureRoot(using Context): Select =
     Select(scalaDot(nme.caps), nme.CAPTURE_ROOT)
 
+  def makeRetaining(parent: Tree, refs: List[Tree], annotName: TypeName)(using Context): Annotated =
+    Annotated(parent, New(scalaAnnotationDot(annotName), List(refs)))
+
   def makeConstructor(tparams: List[TypeDef], vparamss: List[List[ValDef]], rhs: Tree = EmptyTree)(using Context): DefDef =
     DefDef(nme.CONSTRUCTOR, joinParams(tparams, vparamss), TypeTree(), rhs)
 
@@ -658,6 +664,10 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
       case tree: Number if (digits == tree.digits) && (kind == tree.kind) => tree
       case _ => finalize(tree, untpd.Number(digits, kind))
     }
+    def CapturesAndResult(tree: Tree)(refs: List[Tree], parent: Tree)(using Context): Tree = tree match
+      case tree: CapturesAndResult if (refs eq tree.refs) && (parent eq tree.parent) => tree
+      case _ => finalize(tree, untpd.CapturesAndResult(refs, parent))
+
     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))
@@ -723,6 +733,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         tree
       case MacroTree(expr) =>
         cpy.MacroTree(tree)(transform(expr))
+      case CapturesAndResult(refs, parent) =>
+        cpy.CapturesAndResult(tree)(transform(refs), transform(parent))
       case CapturingTypeTree(refs, parent) =>
         cpy.CapturingTypeTree(tree)(transform(refs), transform(parent))
       case _ =>
@@ -782,6 +794,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         this(x, splice)
       case MacroTree(expr) =>
         this(x, expr)
+      case CapturesAndResult(refs, parent) =>
+        this(this(x, refs), parent)
       case CapturingTypeTree(refs, parent) =>
         this(this(x, refs), parent)
       case _ =>
diff --git a/compiler/src/dotty/tools/dotc/core/StdNames.scala b/compiler/src/dotty/tools/dotc/core/StdNames.scala
index 27e97a92b48e..e5ca0710447d 100644
--- a/compiler/src/dotty/tools/dotc/core/StdNames.scala
+++ b/compiler/src/dotty/tools/dotc/core/StdNames.scala
@@ -287,6 +287,7 @@ object StdNames {
 
     // Compiler-internal
     val CAPTURE_ROOT: N             = "*"
+    val CAPTURE_ROOT_ALT: N         = "any"
     val CONSTRUCTOR: N              = "<init>"
     val STATIC_CONSTRUCTOR: N       = "<clinit>"
     val EVT2U: N                    = "evt2u$"
@@ -301,6 +302,7 @@ object StdNames {
     val THROWS: N                   = "$throws"
     val U2EVT: N                    = "u2evt$"
     val ALLARGS: N                  = "$allArgs"
+    val UPARROW: N                  = "^"
 
     final val Nil: N                = "Nil"
     final val Predef: N             = "Predef"
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 7fecdd2c5eae..c36e2238662f 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -1467,6 +1467,7 @@ object Parsers {
       if in.token == THIS then simpleRef()
       else termIdent() match
         case Ident(nme.CAPTURE_ROOT) => captureRoot
+        case Ident(nme.CAPTURE_ROOT_ALT) => captureRoot
         case id => id
 
     /**  CaptureSet ::=  `{` CaptureRef {`,` CaptureRef} `}`    -- under captureChecking
@@ -1475,6 +1476,11 @@ object Parsers {
       if in.token == RBRACE then Nil else commaSeparated(captureRef)
     }
 
+    def capturesAndResult(core: () => Tree): Tree =
+      if in.token == LBRACE && in.offset == in.lastOffset
+      then CapturesAndResult(captureSet(), core())
+      else core()
+
     /** Type           ::=  FunType
      *                   |  HkTypeParamClause ‘=>>’ Type
      *                   |  FunParamClause ‘=>>’ Type
@@ -1519,7 +1525,7 @@ object Parsers {
           else
             accept(ARROW)
 
-          val resultType = typ()
+          val resultType = capturesAndResult(typ)
           if token == TLARROW then
             for case ValDef(_, tpt, _) <- params do
               if isByNameType(tpt) then
@@ -1690,7 +1696,7 @@ object Parsers {
       infixOps(t, canStartInfixTypeTokens, refinedTypeFn, Location.ElseWhere, ParseKind.Type,
         isOperator = !followingIsVararg() && !isPureArrow)
 
-    /** RefinedType   ::=  WithType {[nl] Refinement}
+    /** RefinedType   ::=  WithType {[nl] (Refinement} [`^` CaptureSet]
      */
     val refinedTypeFn: Location => Tree = _ => refinedType()
 
@@ -1698,11 +1704,19 @@ object Parsers {
 
     def refinedTypeRest(t: Tree): Tree = {
       argumentStart()
-      if (in.isNestedStart)
+      if in.isNestedStart then
         refinedTypeRest(atSpan(startOffset(t)) {
           RefinedTypeTree(rejectWildcardType(t), refinement(indentOK = true))
         })
-      else t
+      else if in.isIdent(nme.UPARROW) then
+        val upArrowStart = in.offset
+        in.nextToken()
+        def cs =
+          if in.token == LBRACE then captureSet()
+          else atSpan(upArrowStart)(captureRoot) :: Nil
+        makeRetaining(t, cs, tpnme.retains)
+      else
+        t
     }
 
     /** WithType ::= AnnotType {`with' AnnotType}    (deprecated)
@@ -1929,7 +1943,7 @@ object Parsers {
     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()) }
+        val tp = atSpan(in.skipToken()) { ByNameTypeTree(capturesAndResult(core)) }
         if isImpure && Feature.pureFunsEnabled then ImpureByNameTypeTree(tp) else tp
       else if in.token == LBRACE && followingIsCaptureSet() then
         val start = in.offset
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index 93de33778750..34374fe24998 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -730,6 +730,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         val contentText = toTextGlobal(content)
         val tptText = toTextGlobal(tpt)
         prefix ~~ idx.toString ~~ "|" ~~ tptText ~~ "|" ~~ argsText ~~ "|" ~~ contentText ~~ postfix
+      case CapturesAndResult(refs, parent) =>
+        changePrec(GlobalPrec)("^{" ~ Text(refs.map(toText), ", ") ~ "} " ~ toText(parent))
       case CapturingTypeTree(refs, parent) =>
         parent match
           case ImpureByNameTypeTree(bntpt) =>
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 7eb8519739c6..9f13071ae4b7 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -1389,6 +1389,11 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
 
   def typedFunctionType(tree: untpd.Function, pt: Type)(using Context): Tree = {
     val untpd.Function(args, body) = tree
+    body match
+      case untpd.CapturesAndResult(refs, result) =>
+        return typedUnadapted(untpd.makeRetaining(
+          cpy.Function(tree)(args, result), refs, tpnme.retains), pt)
+      case _ =>
     var (funFlags, erasedParams) = tree match {
       case tree: untpd.FunctionWithMods => (tree.mods.flags, tree.erasedParams)
       case _ => (EmptyFlags, args.map(_ => false))
@@ -2274,10 +2279,13 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     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 typedByNameTypeTree(tree: untpd.ByNameTypeTree)(using Context): ByNameTypeTree = tree.result match
+    case untpd.CapturesAndResult(refs, tpe) =>
+      typedByNameTypeTree(
+        cpy.ByNameTypeTree(tree)(untpd.makeRetaining(tpe, refs, tpnme.retainsByName)))
+    case _ =>
+      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
diff --git a/tests/pos-custom-args/captures/byname.scala b/tests/pos-custom-args/captures/byname.scala
index 35b8876d0058..e54a67660172 100644
--- a/tests/pos-custom-args/captures/byname.scala
+++ b/tests/pos-custom-args/captures/byname.scala
@@ -4,9 +4,9 @@ type Cap = {*} CC
 
 class I
 
-def test(cap1: Cap, cap2: Cap): {cap1} I =
+def test(cap1: Cap, cap2: Cap): I{ref cap1} =
   def f() = if cap1 == cap1 then I() else I()
-  def h(x: {cap1}-> I) = x
+  def h(x: ->{ref any} I) = x
   h(f()) // OK
   def hh(x: -> I @retainsByName(cap1)) = x
   h(f())
diff --git a/tests/pos-custom-args/captures/capt-test.scala b/tests/pos-custom-args/captures/capt-test.scala
index c61577e96eb1..081dbd8a3aa1 100644
--- a/tests/pos-custom-args/captures/capt-test.scala
+++ b/tests/pos-custom-args/captures/capt-test.scala
@@ -19,10 +19,10 @@ def map[A, B](f: A => B)(xs: LIST[A]): LIST[B] =
   xs.map(f)
 
 class C
-type Cap = {*} C
+type Cap = C{ref any}
 
 class Foo(x: Cap):
-  this: {x} Foo =>
+  this: Foo{ref x} =>
 
 def test(c: Cap, d: Cap) =
   def f(x: Cap): Unit = if c == x then ()
@@ -32,7 +32,7 @@ def test(c: Cap, d: Cap) =
   val zs =
     val z = g
     CONS(z, ys)
-  val zsc: LIST[{d, y} Cap -> Unit] = zs
+  val zsc: LIST[Cap ->{ref d, y} Unit] = zs
 
   val a4 = zs.map(identity)
-  val a4c: LIST[{d, y} Cap -> Unit] = a4
+  val a4c: LIST[Cap ->{ref d, y} Unit] = a4
diff --git a/tests/pos-custom-args/captures/capt1.scala b/tests/pos-custom-args/captures/capt1.scala
index cc39790623d4..865b382f4e9f 100644
--- a/tests/pos-custom-args/captures/capt1.scala
+++ b/tests/pos-custom-args/captures/capt1.scala
@@ -1,9 +1,9 @@
 class C
-type Cap = {*} C
-def f1(c: Cap): {c} () -> c.type = () => c // ok
+type Cap = C^
+def f1(c: Cap): () ->{c} c.type = () => c // ok
 
 def f2: Int =
-  val g: {*} Boolean -> Int = ???
+  val g: Boolean ->{any} Int = ???
   val x = g(true)
   x
 
@@ -13,11 +13,11 @@ def f3: Int =
   val x = g.apply(true)
   x
 
-def foo(): {*} C =
-  val x: {*} C = ???
-  val y: {x} C = x
-  val x2: {x} () -> C = ???
-  val y2: {x} () -> {x} C = x2
+def foo(): C^ =
+  val x: C^ = ???
+  val y: C^{x} = x
+  val x2: () ->{x} C = ???
+  val y2: () ->{x} C^{x} = x2
 
   val z1: () => Cap = f1(x)
   def h[X](a: X)(b: X) = a
diff --git a/tests/pos-custom-args/captures/classes.scala b/tests/pos-custom-args/captures/classes.scala
index f14a7e6dd84e..80971512e25e 100644
--- a/tests/pos-custom-args/captures/classes.scala
+++ b/tests/pos-custom-args/captures/classes.scala
@@ -1,22 +1,22 @@
 import annotation.retains
 class B
-type Cap = {*} B
+type Cap = B{ref any}
 class C(val n: Cap):
-  this: {n} C =>
-  def foo(): {n} B = n
+  this: C{ref n} =>
+  def foo(): B{ref n} = n
 
 
 def test(x: Cap, y: Cap, z: Cap) =
   val c0 = C(x)
-  val c1: {x} C {val n: {x} B} = c0
+  val c1: C{ref x}{val n: B{ref x}} = c0
   val d = c1.foo()
-  d: {x} B
+  d: B{ref x}
 
   val c2 = if ??? then C(x) else C(y)
   val c2a = identity(c2)
-  val c3: {x, y} C { val n: {x, y} B } = c2
+  val c3: C{ref x, y}{ val n: B{ref x, y} } = c2
   val d1 = c3.foo()
-  d1: B @retains(x, y)
+  d1: B{ref x, y}
 
   class Local:
 
@@ -29,7 +29,7 @@ def test(x: Cap, y: Cap, z: Cap) =
   end Local
 
   val l = Local()
-  val l1: {x, y} Local = l
+  val l1: Local{ref x, y} = l
   val l2 = Local(x)
-  val l3: {x, y, z} Local = l2
+  val l3: Local{ref x, y, z} = l2
 
diff --git a/tests/run-custom-args/captures/colltest5/CollectionStrawManCC5_1.scala b/tests/run-custom-args/captures/colltest5/CollectionStrawManCC5_1.scala
index 796dc62bdf22..63aee49f8454 100644
--- a/tests/run-custom-args/captures/colltest5/CollectionStrawManCC5_1.scala
+++ b/tests/run-custom-args/captures/colltest5/CollectionStrawManCC5_1.scala
@@ -18,19 +18,21 @@ object CollectionStrawMan5 {
 
   /* ------------ Base Traits -------------------------------- */
 
+  type AnyIterableOnce[A] = IterableOnce[A]^
+
   /** Iterator can be used only once */
   trait IterableOnce[+A] {
-    this: {*} IterableOnce[A] =>
-    def iterator: {this} Iterator[A]
+    this: AnyIterableOnce[A] =>
+    def iterator: Iterator[A]^{this}
   }
 
   /** Base trait for instances that can construct a collection from an iterable */
   trait FromIterable {
-    type C[X] <: {*} Iterable[X]
-    def fromIterable[B](it: {*} Iterable[B]): {it} C[B]
+    type C[X] <: Iterable[X]^
+    def fromIterable[B](it: Iterable[B]^): C[B]^{it}
   }
 
-  type FromIterableOf[+CC[X] <: {*} Iterable[X]] = FromIterable {
+  type FromIterableOf[+CC[X] <: Iterable[X]^] = FromIterable {
     type C[X] <: CC[X]
   }
 
@@ -42,9 +44,9 @@ object CollectionStrawMan5 {
 
   /** Base trait for generic collections */
   trait Iterable[+A] extends IterableOnce[A] with IterableLike[A] {
-    this: {*} Iterable[A] =>
-    type C[X] <: {*} Iterable[X]
-    protected def coll: {this} Iterable[A] = this
+    this: Iterable[A]^ =>
+    type C[X] <: Iterable[X]^
+    protected def coll: Iterable[A]^{this} = this
     def knownLength: Int = -1
   }
 
@@ -58,7 +60,7 @@ object CollectionStrawMan5 {
 
   trait SeqFactory extends IterableFactory {
     type C[X] <: Seq[X]
-    def fromIterable[B](it: {*} Iterable[B]): C[B]
+    def fromIterable[B](it: Iterable[B]^): C[B]
   }
 
   /** Base trait for strict collections */
@@ -78,7 +80,7 @@ object CollectionStrawMan5 {
     def +=(x: A): this.type
     def result: To
 
-    def ++=(xs: {*} IterableOnce[A]): this.type = {
+    def ++=(xs: IterableOnce[A]^): this.type = {
       xs.iterator.foreach(+=)
       this
     }
@@ -103,7 +105,7 @@ object CollectionStrawMan5 {
        with IterablePolyTransforms[A]
        with IterableMonoTransforms[A] { // sound bcs of VarianceNote
     type Repr = C[A] @uncheckedVariance
-    protected[this] def fromLikeIterable(coll: {*} Iterable[A] @uncheckedVariance): {coll} Repr @uncheckedVariance =
+    protected[this] def fromLikeIterable(coll: Iterable[A] @uncheckedVariance ^): Repr @uncheckedVariance ^{coll} =
       fromIterable(coll)
   }
 
@@ -112,50 +114,50 @@ object CollectionStrawMan5 {
   extends IterableLike[A], SeqMonoTransforms[A], SeqPolyTransforms[A]: // sound bcs of VarianceNote
     this: SeqLike[A] =>
     type C[X] <: Seq[X]
-    def fromIterable[B](coll: {*} Iterable[B]): C[B]
-    override protected[this] def fromLikeIterable(coll: {*} Iterable[A] @uncheckedVariance): Repr =
+    def fromIterable[B](coll: Iterable[B]^): C[B]
+    override protected[this] def fromLikeIterable(coll: Iterable[A] @uncheckedVariance ^): Repr =
       fromIterable(coll)
 
   trait IterableOps[+A] extends Any {
-    this: {*} IterableOps[A] =>
-    def iterator: {this} Iterator[A]
+    this: IterableOps[A]^ =>
+    def iterator: Iterator[A]^{this}
     def foreach(f: A => Unit): Unit = iterator.foreach(f)
     def foldLeft[B](z: B)(op: (B, A) => B): B = iterator.foldLeft(z)(op)
     def foldRight[B](z: B)(op: (A, B) => B): B = iterator.foldRight(z)(op)
     def indexWhere(p: A => Boolean): Int = iterator.indexWhere(p)
     def isEmpty: Boolean = !iterator.hasNext
     def head: A = iterator.next()
-    def view: {this} View[A] = View.fromIterator(iterator)
+    def view: View[A]^{this} = View.fromIterator(iterator)
   }
 
   trait IterableMonoTransforms[+A] extends Any {
-    this: {*} IterableMonoTransforms[A] =>
+    this: IterableMonoTransforms[A]^ =>
     type Repr
-    protected def coll: {this} Iterable[A]
-    protected[this] def fromLikeIterable(coll: {*} Iterable[A] @uncheckedVariance): {coll} Repr
-    def filter(p: A => Boolean): {this, p} Repr = fromLikeIterable(View.Filter(coll, p))
+    protected def coll: Iterable[A]^{this}
+    protected[this] def fromLikeIterable(coll: Iterable[A] @uncheckedVariance ^): Repr^{coll}
+    def filter(p: A => Boolean): Repr^{this, p} = fromLikeIterable(View.Filter(coll, p))
 
-    def partition(p: A => Boolean): ({this, p} Repr, {this, p} Repr) = {
+    def partition(p: A => Boolean): (Repr^{this, p}, Repr^{this, p}) = {
       val pn = View.Partition(coll, p)
       (fromLikeIterable(pn.left), fromLikeIterable(pn.right))
     }
-    def drop(n: Int): {this} Repr = fromLikeIterable(View.Drop(coll, n))
+    def drop(n: Int): Repr^{this} = fromLikeIterable(View.Drop(coll, n))
 
-    def to[C[X] <: Iterable[X]](fi: FromIterableOf[C]): {this} C[A @uncheckedVariance] =
+    def to[C[X] <: Iterable[X]](fi: FromIterableOf[C]): C[A @uncheckedVariance]^{this} =
       // variance seems sound because `to` could just as well have been added
       // as a decorator. We should investigate this further to be sure.
       fi.fromIterable(coll)
   }
 
   trait IterablePolyTransforms[+A] extends Any {
-    this: {*} IterablePolyTransforms[A] =>
+    this: IterablePolyTransforms[A]^ =>
     type C[A]
-    protected def coll: {this} Iterable[A]
-    def fromIterable[B](coll: {*} Iterable[B]): {coll} C[B]
-    def map[B](f: A => B): {this, f} C[B] = fromIterable(View.Map(coll, f))
-    def flatMap[B](f: A => {*} IterableOnce[B]): {this, f} C[B] = fromIterable(View.FlatMap(coll, f))
-    def ++[B >: A](xs: {*} IterableOnce[B]): {this, xs} C[B] = fromIterable(View.Concat(coll, xs))
-    def zip[B](xs: {*} IterableOnce[B]): {this, xs} C[(A @uncheckedVariance, B)] = fromIterable(View.Zip(coll, xs))
+    protected def coll: Iterable[A]^{this}
+    def fromIterable[B](coll: Iterable[B]^): C[B]^{coll}
+    def map[B](f: A => B): C[B]^{this, f} = fromIterable(View.Map(coll, f))
+    def flatMap[B](f: A => IterableOnce[B]^): C[B]^{this, f} = fromIterable(View.FlatMap(coll, f))
+    def ++[B >: A](xs: IterableOnce[B]^): C[B]^{this, xs} = fromIterable(View.Concat(coll, xs))
+    def zip[B](xs: IterableOnce[B]^): C[(A @uncheckedVariance, B)]^{this, xs} = fromIterable(View.Zip(coll, xs))
        // sound bcs of VarianceNote
   }
 
@@ -167,7 +169,7 @@ object CollectionStrawMan5 {
       while (it.hasNext) xs = new Cons(it.next(), xs)
       fromLikeIterable(xs)
 
-    override protected[this] def fromLikeIterable(coll: {*} Iterable[A] @uncheckedVariance): Repr
+    override protected[this] def fromLikeIterable(coll: Iterable[A] @uncheckedVariance ^): Repr
 
     override def filter(p: A => Boolean): Repr = fromLikeIterable(View.Filter(coll, p))
 
@@ -186,11 +188,11 @@ object CollectionStrawMan5 {
   trait SeqPolyTransforms[+A] extends Any, IterablePolyTransforms[A]:
     this: SeqPolyTransforms[A] =>
     type C[A]
-    override def fromIterable[B](coll: {*} Iterable[B]): C[B]
+    override def fromIterable[B](coll: Iterable[B]^): C[B]
     override def map[B](f: A => B): C[B] = fromIterable(View.Map(coll, f))
-    override def flatMap[B](f: A => {*} IterableOnce[B]): C[B] = fromIterable(View.FlatMap(coll, f))
-    override def ++[B >: A](xs: {*} IterableOnce[B]): C[B] = fromIterable(View.Concat(coll, xs))
-    override def zip[B](xs: {*} IterableOnce[B]): C[(A @uncheckedVariance, B)] = fromIterable(View.Zip(coll, xs))
+    override def flatMap[B](f: A => IterableOnce[B]^): C[B] = fromIterable(View.FlatMap(coll, f))
+    override def ++[B >: A](xs: IterableOnce[B]^): C[B] = fromIterable(View.Concat(coll, xs))
+    override def zip[B](xs: IterableOnce[B]^): C[(A @uncheckedVariance, B)] = fromIterable(View.Zip(coll, xs))
 
 
   /* --------- Concrete collection types ------------------------------- */
@@ -206,7 +208,7 @@ object CollectionStrawMan5 {
       def hasNext = !current.isEmpty
       def next() = { val r = current.head; current = current.tail; r }
     }
-    def fromIterable[B](c: {*} Iterable[B]): List[B] = List.fromIterable(c)
+    def fromIterable[B](c: Iterable[B]^): List[B] = List.fromIterable(c)
     def apply(i: Int): A = {
       require(!isEmpty)
       if (i == 0) head else tail.apply(i - 1)
@@ -217,7 +219,7 @@ object CollectionStrawMan5 {
     def ++:[B >: A](prefix: List[B]): List[B] =
       if (prefix.isEmpty) this
       else Cons(prefix.head, prefix.tail ++: this)
-    override def ++[B >: A](xs: {*} IterableOnce[B]): List[B] = xs match {
+    override def ++[B >: A](xs: IterableOnce[B]^): List[B] = xs match {
       case xs: List[B] => this ++: xs
       case _ => fromIterable(View.Concat(this, xs))
     }
@@ -240,7 +242,7 @@ object CollectionStrawMan5 {
 
   object List extends SeqFactory {
     type C[X] = List[X]
-    def fromIterable[B](coll: {*} Iterable[B]): List[B] = coll match {
+    def fromIterable[B](coll: Iterable[B]^): List[B] = coll match {
       case coll: List[B] => coll
       case _ => ListBuffer.fromIterable(coll).result
     }
@@ -252,7 +254,7 @@ object CollectionStrawMan5 {
     private var first, last: List[A] = Nil
     private var aliased = false
     def iterator = first.iterator
-    def fromIterable[B](coll: {*} Iterable[B]): ListBuffer[B] = ListBuffer.fromIterable(coll)
+    def fromIterable[B](coll: Iterable[B]^): ListBuffer[B] = ListBuffer.fromIterable(coll)
     def apply(i: Int) = first.apply(i)
     def length = first.length
 
@@ -286,7 +288,7 @@ object CollectionStrawMan5 {
 
   object ListBuffer extends SeqFactory {
     type C[X] = ListBuffer[X]
-    def fromIterable[B](coll: {*} Iterable[B]): ListBuffer[B] = new ListBuffer[B] ++= coll
+    def fromIterable[B](coll: Iterable[B]^): ListBuffer[B] = new ListBuffer[B] ++= coll
   }
 
   /** Concrete collection type: ArrayBuffer */
@@ -303,7 +305,7 @@ object CollectionStrawMan5 {
     override def knownLength = length
     override def view = new ArrayBufferView(elems, start, end)
     def iterator = view.iterator
-    def fromIterable[B](it: {*} Iterable[B]): ArrayBuffer[B] =
+    def fromIterable[B](it: Iterable[B]^): ArrayBuffer[B] =
       ArrayBuffer.fromIterable(it)
     def +=(elem: A): this.type = {
       if (end == elems.length) {
@@ -324,7 +326,7 @@ object CollectionStrawMan5 {
     }
     def result = this
     def trimStart(n: Int): Unit = start += (n max 0)
-    override def ++[B >: A](xs: {*} IterableOnce[B]): ArrayBuffer[B] = xs match {
+    override def ++[B >: A](xs: IterableOnce[B]^): ArrayBuffer[B] = xs match {
       case xs: ArrayBuffer[B] @unchecked =>
         val elems = new Array[AnyRef](length + xs.length)
         Array.copy(this.elems, this.start, elems, 0, this.length)
@@ -338,7 +340,7 @@ object CollectionStrawMan5 {
 
   object ArrayBuffer extends SeqFactory {
     type C[X] = ArrayBuffer[X]
-    def fromIterable[B](coll: {*} Iterable[B]): ArrayBuffer[B] =
+    def fromIterable[B](coll: Iterable[B]^): ArrayBuffer[B] =
       if (coll.knownLength >= 0) {
         val elems = new Array[AnyRef](coll.knownLength)
         val it = coll.iterator
@@ -368,12 +370,12 @@ object CollectionStrawMan5 {
     type C[X] = List[X]
     protected def coll = new StringView(s)
     def iterator = coll.iterator
-    protected def fromLikeIterable(coll: {*} Iterable[Char]): String = {
+    protected def fromLikeIterable(coll: Iterable[Char]^): String = {
       val sb = new StringBuilder
       for (ch <- coll) sb.append(ch)
       sb.toString
     }
-    def fromIterable[B](coll: {*} Iterable[B]): List[B] = List.fromIterable(coll)
+    def fromIterable[B](coll: Iterable[B]^): List[B] = List.fromIterable(coll)
     def map(f: Char => Char): String = {
       val sb = new StringBuilder
       for (ch <- s) sb.append(f(ch))
@@ -384,7 +386,7 @@ object CollectionStrawMan5 {
       for (ch <- s) sb.append(f(ch))
       sb.toString
     }
-    def ++(xs: {*} IterableOnce[Char]): String = {
+    def ++(xs: IterableOnce[Char]^): String = {
       val sb = new StringBuilder(s)
       for (ch <- xs.iterator) sb.append(ch)
       sb.toString
@@ -402,10 +404,10 @@ object CollectionStrawMan5 {
 
   /** Concrete collection type: View */
   trait View[+A] extends Iterable[A] with IterableLike[A] {
-    this: {*} View[A] =>
-    type C[X] = {this} View[X]
+    this: View[A]^ =>
+    type C[X] = View[X]^{this}
     override def view: this.type = this
-    override def fromIterable[B](c: {*} Iterable[B]): {this, c} View[B] = {
+    override def fromIterable[B](c: Iterable[B]^): View[B]^{this, c} = {
       c match {
         case c: View[B] => c
         case _ => View.fromIterator(c.iterator)
@@ -431,8 +433,8 @@ object CollectionStrawMan5 {
   }
 
   object View {
-    def fromIterator[A](it: => {*} Iterator[A]): {it} View[A] = new View[A]:
-        def iterator: {this} Iterator[A] = it
+    def fromIterator[A](it: => Iterator[A]^): View[A]^{it} = new View[A]:
+        def iterator: Iterator[A]^{this} = it
 
     case object Empty extends View[Nothing] {
       def iterator: Iterator[Nothing] = Iterator.empty
@@ -444,43 +446,43 @@ object CollectionStrawMan5 {
       override def knownLength = xs.length
     }
 
-    case class Filter[A](val underlying: {*} Iterable[A], p: A => Boolean) extends View[A] {
-      this: {underlying, p} Filter[A] =>
-      def iterator: {this} Iterator[A] = underlying.iterator.filter(p)
+    case class Filter[A](val underlying: Iterable[A]^, p: A => Boolean) extends View[A] {
+      this: Filter[A]^{underlying, p} =>
+      def iterator: Iterator[A]^{this} = underlying.iterator.filter(p)
     }
-    case class Partition[A](val underlying: {*} Iterable[A], p: A => Boolean) {
-      self: {underlying, p} Partition[A] =>
+    case class Partition[A](val underlying: Iterable[A]^, p: A => Boolean) {
+      self: Partition[A]^{underlying, p} =>
 
       class Partitioned(expected: Boolean) extends View[A]:
-        this: {self} Partitioned =>
-        def iterator: {this} Iterator[A] =
+        this: Partitioned^{self} =>
+        def iterator: Iterator[A]^{this} =
           underlying.iterator.filter((x: A) => p(x) == expected)
 
-      val left: {self} Partitioned = Partitioned(true)
-      val right: {self} Partitioned = Partitioned(false)
+      val left: Partitioned^{self} = Partitioned(true)
+      val right: Partitioned^{self} = Partitioned(false)
     }
 
-    case class Drop[A](underlying: {*} Iterable[A], n: Int) extends View[A] {
-      this: {underlying} Drop[A] =>
-      def iterator: {this} Iterator[A] = underlying.iterator.drop(n)
+    case class Drop[A](underlying: Iterable[A]^, n: Int) extends View[A] {
+      this: Drop[A]^{underlying} =>
+      def iterator: Iterator[A]^{this} = underlying.iterator.drop(n)
       override def knownLength =
         if (underlying.knownLength >= 0) underlying.knownLength - n max 0 else -1
     }
 
-    case class Map[A, B](underlying: {*} Iterable[A], f: A => B) extends View[B] {
-      this: {underlying, f} Map[A, B] =>
-      def iterator: {this} Iterator[B] = underlying.iterator.map(f)
+    case class Map[A, B](underlying: Iterable[A]^, f: A => B) extends View[B] {
+      this: Map[A, B]^{underlying, f} =>
+      def iterator: Iterator[B]^{this} = underlying.iterator.map(f)
       override def knownLength = underlying.knownLength
     }
 
-    case class FlatMap[A, B](underlying: {*} Iterable[A], f: A => {*} IterableOnce[B]) extends View[B] {
-      this: {underlying, f} FlatMap[A, B] =>
-      def iterator: {this} Iterator[B] = underlying.iterator.flatMap(f)
+    case class FlatMap[A, B](underlying: Iterable[A]^, f: A => IterableOnce[B]^) extends View[B] {
+      this: FlatMap[A, B]^{underlying, f} =>
+      def iterator: Iterator[B]^{this} = underlying.iterator.flatMap(f)
     }
 
-    case class Concat[A](underlying: {*} Iterable[A], other: {*} IterableOnce[A]) extends View[A] {
-      this: {underlying, other} Concat[A] =>
-      def iterator: {this} Iterator[A] = underlying.iterator ++ other
+    case class Concat[A](underlying: Iterable[A]^, other: IterableOnce[A]^) extends View[A] {
+      this: Concat[A]^{underlying, other} =>
+      def iterator: Iterator[A]^{this} = underlying.iterator ++ other
       override def knownLength = other match {
         case other: Iterable[_] if underlying.knownLength >= 0 && other.knownLength >= 0 =>
           underlying.knownLength + other.knownLength
@@ -489,9 +491,9 @@ object CollectionStrawMan5 {
       }
     }
 
-    case class Zip[A, B](underlying: {*} Iterable[A], other: {*} IterableOnce[B]) extends View[(A, B)] {
-      this: {underlying, other} Zip[A, B] =>
-      def iterator: {this} Iterator[(A, B)] = underlying.iterator.zip(other)
+    case class Zip[A, B](underlying: Iterable[A]^, other: IterableOnce[B]^) extends View[(A, B)] {
+      this: Zip[A, B]^{underlying, other} =>
+      def iterator: Iterator[(A, B)]^{this} = underlying.iterator.zip(other)
       override def knownLength = other match {
         case other: Iterable[_] if underlying.knownLength >= 0 && other.knownLength >= 0 =>
           underlying.knownLength min other.knownLength
@@ -504,7 +506,7 @@ object CollectionStrawMan5 {
 /* ---------- Iterators ---------------------------------------------------*/
 
   /** A core Iterator class */
-  trait Iterator[+A] extends IterableOnce[A] { self: {*} Iterator[A] =>
+  trait Iterator[+A] extends IterableOnce[A] { self: Iterator[A]^ =>
     def hasNext: Boolean
     def next(): A
     def iterator: this.type = this
@@ -522,7 +524,7 @@ object CollectionStrawMan5 {
       }
       -1
     }
-    def filter(p: A => Boolean): {this, p} Iterator[A] = new Iterator[A] {
+    def filter(p: A => Boolean): Iterator[A]^{this, p} = new Iterator[A] {
       private var hd: A = compiletime.uninitialized
       private var hdDefined: Boolean = false
 
@@ -544,13 +546,13 @@ object CollectionStrawMan5 {
         else Iterator.empty.next()
     }
 
-    def map[B](f: A => B): {this, f} Iterator[B] = new Iterator[B] {
+    def map[B](f: A => B): Iterator[B]^{this, f} = new Iterator[B] {
       def hasNext = self.hasNext
       def next() = f(self.next())
     }
 
-    def flatMap[B](f: A => {*} IterableOnce[B]): {this, f} Iterator[B] = new Iterator[B] {
-      private var myCurrent: {this} Iterator[B] = Iterator.empty
+    def flatMap[B](f: A => IterableOnce[B]^): Iterator[B]^{this, f} = new Iterator[B] {
+      private var myCurrent: Iterator[B]^{this} = Iterator.empty
       private def current = {
         while (!myCurrent.hasNext && self.hasNext)
           myCurrent = f(self.next()).iterator
@@ -559,8 +561,8 @@ object CollectionStrawMan5 {
       def hasNext = current.hasNext
       def next() = current.next()
     }
-    def ++[B >: A](xs: {*} IterableOnce[B]): {this, xs} Iterator[B] = new Iterator[B] {
-      private var myCurrent: {self, xs} Iterator[B] = self
+    def ++[B >: A](xs: IterableOnce[B]^): Iterator[B]^{this, xs} = new Iterator[B] {
+      private var myCurrent: Iterator[B]^{self, xs} = self
       private var first = true
       private def current = {
         if (!myCurrent.hasNext && first) {
@@ -572,7 +574,7 @@ object CollectionStrawMan5 {
       def hasNext = current.hasNext
       def next() = current.next()
     }
-    def drop(n: Int): {this} Iterator[A] = {
+    def drop(n: Int): Iterator[A]^{this} = {
       var i = 0
       while (i < n && hasNext) {
         next()
@@ -580,7 +582,7 @@ object CollectionStrawMan5 {
       }
       this
     }
-    def zip[B](that: {*} IterableOnce[B]): {this, that} Iterator[(A, B)] = new Iterator[(A, B)] {
+    def zip[B](that: IterableOnce[B]^): Iterator[(A, B)]^{this, that} = new Iterator[(A, B)] {
       val thatIterator = that.iterator
       def hasNext = self.hasNext && thatIterator.hasNext
       def next() = (self.next(), thatIterator.next())
diff --git a/tests/run-custom-args/captures/colltest5/Test_2.scala b/tests/run-custom-args/captures/colltest5/Test_2.scala
index 8c070439db80..4a941afc124b 100644
--- a/tests/run-custom-args/captures/colltest5/Test_2.scala
+++ b/tests/run-custom-args/captures/colltest5/Test_2.scala
@@ -5,7 +5,7 @@ object Test {
   import colltest5.strawman.collections.*
   import CollectionStrawMan5.*
 
-  def seqOps(xs: Seq[Int]) = { // try with {*} Seq[Int]
+  def seqOps(xs: Seq[Int]) = { // try with Seq[Int]{ref any}
     val strPlusInt: (String, Int) => String = _ + _
     val intPlusStr: (Int, String) => String = _ + _
     val isEven: Int => Boolean = _ % 2 == 0
@@ -61,7 +61,7 @@ object Test {
     println(xs16)
   }
 
-  def viewOps(xs: {*} View[Int]) = {
+  def viewOps(xs: View[Int]{ref any}) = {
     val strPlusInt: (String, Int) => String = _ + _
     val intPlusStr: (Int, String) => String = _ + _
     val isEven: Int => Boolean = _ % 2 == 0
@@ -78,27 +78,27 @@ object Test {
     val x5 = xs.to(List)
     val y5: List[Int] = x5
     val (xs6, xs7) = xs.partition(isEven)
-    val ys6: {xs6, isEven} View[Int] = xs6
-    val ys7: {xs7, isEven} View[Int] = xs7
+    val ys6: View[Int]{ref xs6, isEven} = xs6
+    val ys7: View[Int]{ref xs7, isEven} = xs7
     val (xs6a, xs7a) = xs.partition(_ % 2 == 0)
-    val ys6a: {xs6} View[Int] = xs6
-    val ys7a: {xs7} View[Int] = xs7
+    val ys6a: View[Int]{ref xs6} = xs6
+    val ys7a: View[Int]{ref xs7} = xs7
     val xs8 = xs.drop(2)
-    val ys8: {xs8} View[Int] = xs8
+    val ys8: View[Int]{ref xs8} = xs8
     val xs9 = xs.map(isNonNeg)
-    val ys9: {xs9} View[Boolean] = xs9
+    val ys9: View[Boolean]{ref xs9} = xs9
     val xs10 = xs.flatMap(flips)
-    val ys10: {xs10} View[Int] = xs10
+    val ys10: View[Int]{ref xs10} = xs10
     val xs11 = xs ++ xs
-    val ys11: {xs11} View[Int] = xs11
+    val ys11: View[Int]{ref xs11} = xs11
     val xs12 = xs ++ Nil
-    val ys12: {xs12} View[Int] = xs12
+    val ys12: View[Int]{ref xs12} = xs12
     val xs13 = Nil ++ xs
     val ys13: List[Int] = xs13
     val xs14 = xs ++ Cons("a", Nil)
-    val ys14: {xs14} View[Any] = xs14
+    val ys14: View[Any]{ref xs14} = xs14
     val xs15 = xs.zip(xs9)
-    val ys15: {xs15} View[(Int, Boolean)] = xs15
+    val ys15: View[(Int, Boolean)]{ref xs15} = xs15
     println("-------")
     println(x1)
     println(x2)

From a307ebd6232c0a4830d1964518f42893ca5c73c5 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sun, 30 Apr 2023 11:55:12 +0200
Subject: [PATCH 520/657] Handle self types that are aliases of capturing types

---
 compiler/src/dotty/tools/dotc/core/Types.scala      | 6 +++---
 tests/pos-custom-args/captures/selftype-alias.scala | 9 +++++++++
 2 files changed, 12 insertions(+), 3 deletions(-)
 create mode 100644 tests/pos-custom-args/captures/selftype-alias.scala

diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index fe0fc8a6dc2d..165037d65979 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -4999,9 +4999,9 @@ object Types {
           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)
+          else givenSelf.dealiasKeepAnnots match
+            case givenSelf1 @ EventuallyCapturingType(tp, _) =>
+              givenSelf1.derivedAnnotatedType(tp & appliedRef, givenSelf1.annot)
             case _ =>
               AndType(givenSelf, appliedRef)
         }
diff --git a/tests/pos-custom-args/captures/selftype-alias.scala b/tests/pos-custom-args/captures/selftype-alias.scala
new file mode 100644
index 000000000000..284691131c7b
--- /dev/null
+++ b/tests/pos-custom-args/captures/selftype-alias.scala
@@ -0,0 +1,9 @@
+import language.experimental.captureChecking
+
+type AnyIterableOnce[A] = IterableOnce[A]^
+
+/** Iterator can be used only once */
+trait IterableOnce[+A]:
+  //this: IterableOnce[A]{ref any} =>
+  this: AnyIterableOnce[A] =>
+  def iterator: Iterator[A]^{this}

From d7b3f0908c22e4bafd2cbf28d88043e9c48b5222 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sun, 30 Apr 2023 12:53:31 +0200
Subject: [PATCH 521/657] Update tests and restore parsing for infix `^` in
 types

---
 .../dotty/tools/dotc/parsing/Parsers.scala    |  9 ++++++-
 tests/pos-custom-args/captures/byname.scala   |  6 ++---
 .../pos-custom-args/captures/capt-test.scala  |  8 +++---
 tests/pos-custom-args/captures/classes.scala  | 18 ++++++-------
 .../captures/colltest5/Test_2.scala           | 26 +++++++++----------
 5 files changed, 37 insertions(+), 30 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index c36e2238662f..06a8d99bbd1c 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -1689,6 +1689,7 @@ object Parsers {
       if in.token == LPAREN then funParamClause() :: funParamClauses() else Nil
 
     /** InfixType ::= RefinedType {id [nl] RefinedType}
+     *             |  RefinedType `^`
      */
     def infixType(): Tree = infixTypeRest(refinedType())
 
@@ -1708,7 +1709,13 @@ object Parsers {
         refinedTypeRest(atSpan(startOffset(t)) {
           RefinedTypeTree(rejectWildcardType(t), refinement(indentOK = true))
         })
-      else if in.isIdent(nme.UPARROW) then
+      else if in.isIdent(nme.UPARROW)
+          && (in.lookahead.token == LBRACE
+              || !canStartInfixTypeTokens.contains(in.lookahead.token))
+        // Disambiguation: a `^` is treated as a postfix operator meaning `^{any}`
+        // if followed by `{` or newline, or any other token that cannot start
+        // an infix type. Otherwise it is treated as an infix operator.
+      then
         val upArrowStart = in.offset
         in.nextToken()
         def cs =
diff --git a/tests/pos-custom-args/captures/byname.scala b/tests/pos-custom-args/captures/byname.scala
index e54a67660172..780214ebdffd 100644
--- a/tests/pos-custom-args/captures/byname.scala
+++ b/tests/pos-custom-args/captures/byname.scala
@@ -1,12 +1,12 @@
 import annotation.retainsByName
 class CC
-type Cap = {*} CC
+type Cap = CC^
 
 class I
 
-def test(cap1: Cap, cap2: Cap): I{ref cap1} =
+def test(cap1: Cap, cap2: Cap): I^{cap1} =
   def f() = if cap1 == cap1 then I() else I()
-  def h(x: ->{ref any} I) = x
+  def h(x: ->{any} I) = x
   h(f()) // OK
   def hh(x: -> I @retainsByName(cap1)) = x
   h(f())
diff --git a/tests/pos-custom-args/captures/capt-test.scala b/tests/pos-custom-args/captures/capt-test.scala
index 081dbd8a3aa1..e229c685d846 100644
--- a/tests/pos-custom-args/captures/capt-test.scala
+++ b/tests/pos-custom-args/captures/capt-test.scala
@@ -19,10 +19,10 @@ def map[A, B](f: A => B)(xs: LIST[A]): LIST[B] =
   xs.map(f)
 
 class C
-type Cap = C{ref any}
+type Cap = C^
 
 class Foo(x: Cap):
-  this: Foo{ref x} =>
+  this: Foo^{x} =>
 
 def test(c: Cap, d: Cap) =
   def f(x: Cap): Unit = if c == x then ()
@@ -32,7 +32,7 @@ def test(c: Cap, d: Cap) =
   val zs =
     val z = g
     CONS(z, ys)
-  val zsc: LIST[Cap ->{ref d, y} Unit] = zs
+  val zsc: LIST[Cap ->{d, y} Unit] = zs
 
   val a4 = zs.map(identity)
-  val a4c: LIST[Cap ->{ref d, y} Unit] = a4
+  val a4c: LIST[Cap ->{d, y} Unit] = a4
diff --git a/tests/pos-custom-args/captures/classes.scala b/tests/pos-custom-args/captures/classes.scala
index 80971512e25e..bc827dcfc67d 100644
--- a/tests/pos-custom-args/captures/classes.scala
+++ b/tests/pos-custom-args/captures/classes.scala
@@ -1,22 +1,22 @@
 import annotation.retains
 class B
-type Cap = B{ref any}
+type Cap = B^
 class C(val n: Cap):
-  this: C{ref n} =>
-  def foo(): B{ref n} = n
+  this: C^{n} =>
+  def foo(): B^{n} = n
 
 
 def test(x: Cap, y: Cap, z: Cap) =
   val c0 = C(x)
-  val c1: C{ref x}{val n: B{ref x}} = c0
+  val c1: C{val n: B^{x}}^{x} = c0
   val d = c1.foo()
-  d: B{ref x}
+  d: B^{x}
 
   val c2 = if ??? then C(x) else C(y)
   val c2a = identity(c2)
-  val c3: C{ref x, y}{ val n: B{ref x, y} } = c2
+  val c3: C{ val n: B^{x, y} }^{x, y} = c2
   val d1 = c3.foo()
-  d1: B{ref x, y}
+  d1: B^{x, y}
 
   class Local:
 
@@ -29,7 +29,7 @@ def test(x: Cap, y: Cap, z: Cap) =
   end Local
 
   val l = Local()
-  val l1: Local{ref x, y} = l
+  val l1: Local^{x, y} = l
   val l2 = Local(x)
-  val l3: Local{ref x, y, z} = l2
+  val l3: Local^{x, y, z} = l2
 
diff --git a/tests/run-custom-args/captures/colltest5/Test_2.scala b/tests/run-custom-args/captures/colltest5/Test_2.scala
index 4a941afc124b..d6b4e43483e6 100644
--- a/tests/run-custom-args/captures/colltest5/Test_2.scala
+++ b/tests/run-custom-args/captures/colltest5/Test_2.scala
@@ -5,7 +5,7 @@ object Test {
   import colltest5.strawman.collections.*
   import CollectionStrawMan5.*
 
-  def seqOps(xs: Seq[Int]) = { // try with Seq[Int]{ref any}
+  def seqOps(xs: Seq[Int]) = { // try with Seq[Int]^{any}
     val strPlusInt: (String, Int) => String = _ + _
     val intPlusStr: (Int, String) => String = _ + _
     val isEven: Int => Boolean = _ % 2 == 0
@@ -61,7 +61,7 @@ object Test {
     println(xs16)
   }
 
-  def viewOps(xs: View[Int]{ref any}) = {
+  def viewOps(xs: View[Int]^{any}) = {
     val strPlusInt: (String, Int) => String = _ + _
     val intPlusStr: (Int, String) => String = _ + _
     val isEven: Int => Boolean = _ % 2 == 0
@@ -78,27 +78,27 @@ object Test {
     val x5 = xs.to(List)
     val y5: List[Int] = x5
     val (xs6, xs7) = xs.partition(isEven)
-    val ys6: View[Int]{ref xs6, isEven} = xs6
-    val ys7: View[Int]{ref xs7, isEven} = xs7
+    val ys6: View[Int]^{xs6, isEven} = xs6
+    val ys7: View[Int]^{xs7, isEven} = xs7
     val (xs6a, xs7a) = xs.partition(_ % 2 == 0)
-    val ys6a: View[Int]{ref xs6} = xs6
-    val ys7a: View[Int]{ref xs7} = xs7
+    val ys6a: View[Int]^{xs6} = xs6
+    val ys7a: View[Int]^{xs7} = xs7
     val xs8 = xs.drop(2)
-    val ys8: View[Int]{ref xs8} = xs8
+    val ys8: View[Int]^{xs8} = xs8
     val xs9 = xs.map(isNonNeg)
-    val ys9: View[Boolean]{ref xs9} = xs9
+    val ys9: View[Boolean]^{xs9} = xs9
     val xs10 = xs.flatMap(flips)
-    val ys10: View[Int]{ref xs10} = xs10
+    val ys10: View[Int]^{xs10} = xs10
     val xs11 = xs ++ xs
-    val ys11: View[Int]{ref xs11} = xs11
+    val ys11: View[Int]^{xs11} = xs11
     val xs12 = xs ++ Nil
-    val ys12: View[Int]{ref xs12} = xs12
+    val ys12: View[Int]^{xs12} = xs12
     val xs13 = Nil ++ xs
     val ys13: List[Int] = xs13
     val xs14 = xs ++ Cons("a", Nil)
-    val ys14: View[Any]{ref xs14} = xs14
+    val ys14: View[Any]^{xs14} = xs14
     val xs15 = xs.zip(xs9)
-    val ys15: View[(Int, Boolean)]{ref xs15} = xs15
+    val ys15: View[(Int, Boolean)]^{xs15} = xs15
     println("-------")
     println(x1)
     println(x2)

From d16c0f8efd44f0e1b80b418cc716f2b11a000325 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sun, 30 Apr 2023 16:50:38 +0200
Subject: [PATCH 522/657] Change printing to new syntax

---
 .../tools/dotc/printing/PlainPrinter.scala    | 39 ++++----
 .../tools/dotc/printing/RefinedPrinter.scala  | 90 +++++++++++--------
 tests/neg-custom-args/captures/byname.check   | 14 +--
 tests/neg-custom-args/captures/byname.scala   |  6 +-
 tests/neg-custom-args/captures/capt1.check    | 18 ++--
 tests/neg-custom-args/captures/cc-this.check  |  2 +-
 tests/neg-custom-args/captures/cc-this3.check |  4 +-
 tests/neg-custom-args/captures/cc-this3.scala |  4 +-
 tests/neg-custom-args/captures/cc-this4.check |  2 +-
 tests/neg-custom-args/captures/cc-this5.check |  4 +-
 .../captures/class-contra.check               |  4 +-
 .../captures/class-contra.scala               | 10 +--
 .../captures/curried-simplified.check         | 36 ++++----
 .../captures/curried-simplified.scala         | 14 +--
 tests/neg-custom-args/captures/eta.check      |  8 +-
 tests/neg-custom-args/captures/eta.scala      |  8 +-
 .../captures/exception-definitions.check      | 12 +--
 .../captures/exception-definitions.scala      |  8 +-
 tests/neg-custom-args/captures/i15116.check   |  8 +-
 tests/neg-custom-args/captures/i15116.scala   | 10 +--
 tests/neg-custom-args/captures/i15772.check   | 20 ++---
 tests/neg-custom-args/captures/i15772.scala   | 34 +++----
 tests/neg-custom-args/captures/lazylist.check | 28 +++---
 tests/neg-custom-args/captures/lazylist.scala | 18 ++--
 .../captures/lazylists-exceptions.check       |  2 +-
 .../captures/lazylists-exceptions.scala       | 16 ++--
 .../neg-custom-args/captures/lazylists1.check |  6 +-
 .../neg-custom-args/captures/lazylists1.scala | 18 ++--
 .../neg-custom-args/captures/lazylists2.check | 30 +++----
 .../neg-custom-args/captures/lazylists2.scala | 36 ++++----
 tests/neg-custom-args/captures/lazyref.check  | 20 ++---
 tests/neg-custom-args/captures/lazyref.scala  | 12 +--
 .../captures/nestedclass.check                |  2 +-
 .../captures/nestedclass.scala                |  2 +-
 tests/neg-custom-args/captures/real-try.check |  6 +-
 tests/neg-custom-args/captures/try.check      | 12 +--
 .../captures/usingLogFile.check               | 16 ++--
 .../captures/usingLogFile.scala               | 10 +--
 tests/neg-custom-args/captures/vars.check     | 12 +--
 tests/neg-custom-args/captures/vars.scala     |  6 +-
 .../captures/nested-classes.scala             |  4 +-
 41 files changed, 305 insertions(+), 306 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala b/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
index ee0062f77dcd..bd027ed79431 100644
--- a/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
@@ -149,8 +149,14 @@ class PlainPrinter(_ctx: Context) extends Printer {
     + defn.ObjectClass
     + defn.FromJavaObjectSymbol
 
-  def toText(cs: CaptureSet): Text =
-    "{" ~ Text(cs.elems.toList.map(toTextCaptureRef), ", ") ~ "}"
+  def toTextCaptureSet(cs: CaptureSet): Text =
+    if printDebug && !cs.isConst then cs.toString
+    else if ctx.settings.YccDebug.value then cs.show
+    else if !cs.isConst && cs.elems.isEmpty then "?"
+    else "{" ~ Text(cs.elems.toList.map(toTextCaptureRef), ", ") ~ "}"
+
+  protected def toTextCapturing(parent: Type, refsText: Text, boxText: Text): Text =
+    changePrec(InfixPrec)(boxText ~ toTextLocal(parent) ~ "^" ~ refsText)
 
   def toText(tp: Type): Text = controlled {
     homogenize(tp) match {
@@ -207,20 +213,8 @@ class PlainPrinter(_ctx: Context) extends Printer {
           (" <: " ~ 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, ",") ~ ")")
+        val boxText: Text = Str("box ") provided tp.isBoxed //&& ctx.settings.YccDebug.value
+        toTextCapturing(parent, toTextCaptureSet(refs), boxText)
       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 =>
@@ -241,14 +235,13 @@ class PlainPrinter(_ctx: Context) extends Printer {
           ~ (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)
-        }
+        def arrowText: Text = restp match
+          case ct @ EventuallyCapturingType(parent, refs) if ct.annot.symbol == defn.RetainsByNameAnnot =>
+            if refs.isUniversal then Str("=>") else Str("->") ~ toTextCaptureSet(refs)
+          case _ =>
+            if Feature.pureFunsEnabled then "->" else "=>"
+        changePrec(GlobalPrec)(arrowText ~ " " ~ toText(restp))
       case tp: HKTypeLambda =>
         changePrec(GlobalPrec) {
           "[" ~ paramsText(tp) ~ "]" ~ lambdaHash(tp) ~ Str(" =>> ") ~ toTextGlobal(tp.resultType)
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index 34374fe24998..338b03c5adb7 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -144,44 +144,49 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   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) ~ ")"
+  private def toTextFunction(tp: AppliedType, refs: Text = Str("")): Text =
+    val AppliedType(tycon, args) = (tp: @unchecked)
+    val tsym = tycon.typeSymbol
+    val isGiven = tsym.name.isContextFunction
+    val isPure = Feature.pureFunsEnabled && !tsym.name.isImpureFunction
+    changePrec(GlobalPrec) {
+      val argStr: Text =
+        if args.length == 2
+            && !defn.isTupleNType(args.head)
+            && !isGiven
+        then
+          atPrec(InfixPrec) { argText(args.head) }
+        else
+          "("
+          ~ argsText(args.init)
+          ~ ")"
+      argStr ~ " " ~ arrow(isGiven, isPure) ~ refs  ~ " " ~ argText(args.last)
+    }
 
-    def toTextFunction(args: List[Type], isGiven: Boolean, isPure: Boolean): Text =
+  private def toTextMethodAsFunction(info: Type, isPure: Boolean, refs: Text = Str("")): Text = info match
+    case info: MethodType =>
       changePrec(GlobalPrec) {
-        val argStr: Text =
-          if args.length == 2
-             && !defn.isTupleNType(args.head)
-             && !isGiven
-          then
-            atPrec(InfixPrec) { argText(args.head) }
-          else
-            "("
-            ~ argsText(args.init)
-            ~ ")"
-        argStr ~ " " ~ arrow(isGiven, isPure) ~ " " ~ argText(args.last)
+        "("
+        ~ paramsText(info)
+        ~ ") "
+        ~ arrow(info.isImplicitMethod, isPure)
+        ~ refs
+        ~ " "
+        ~ toTextMethodAsFunction(info.resultType, isPure)
+      }
+    case info: PolyType =>
+      changePrec(GlobalPrec) {
+        "["
+        ~ paramsText(info)
+        ~ "] => "
+        ~ toTextMethodAsFunction(info.resultType, isPure)
       }
+    case _ =>
+      toText(info)
 
-    def toTextMethodAsFunction(info: Type, isPure: Boolean): Text = info match
-      case info: MethodType =>
-        changePrec(GlobalPrec) {
-          "("
-          ~ paramsText(info)
-          ~ ") "
-          ~ arrow(info.isImplicitMethod, isPure)
-          ~ " "
-          ~ toTextMethodAsFunction(info.resultType, isPure)
-        }
-      case info: PolyType =>
-        changePrec(GlobalPrec) {
-          "["
-          ~ paramsText(info)
-          ~ "] => "
-          ~ toTextMethodAsFunction(info.resultType, isPure)
-        }
-      case _ =>
-        toText(info)
+  override def toText(tp: Type): Text = controlled {
+    def toTextTuple(args: List[Type]): Text =
+      "(" ~ argsText(args) ~ ")"
 
     def isInfixType(tp: Type): Boolean = tp match
       case AppliedType(tycon, args) =>
@@ -223,9 +228,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
             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,
-                isPure = Feature.pureFunsEnabled && !tsym.name.isImpureFunction)
+            else if defn.isFunctionSymbol(tsym) then toTextFunction(tp)
             else if isInfixType(tp) then
               val l :: r :: Nil = args: @unchecked
               val opName = tyconName(tycon)
@@ -618,7 +621,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         def toTextAnnot =
           toTextLocal(arg) ~~ annotText(annot.symbol.enclosingClass, annot)
         def toTextRetainsAnnot =
-          try changePrec(GlobalPrec)(toText(captureSet) ~ " " ~ toText(arg))
+          try changePrec(GlobalPrec)(toTextCaptureSet(captureSet) ~ " " ~ toText(arg))
           catch case ex: IllegalCaptureRef => toTextAnnot
         if annot.symbol.maybeOwner == defn.RetainsAnnot
             && Feature.ccEnabled && Config.printCaptureSetsAsPrefix && !printDebug
@@ -737,12 +740,21 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           case ImpureByNameTypeTree(bntpt) =>
             "=> " ~ toTextLocal(bntpt)
           case _ =>
-            changePrec(GlobalPrec)("{" ~ Text(refs.map(toText), ", ") ~ "} " ~ toText(parent))
+            toText(parent) ~ "^"
+            ~ changePrec(GlobalPrec)("{" ~ Text(refs.map(toText), ", ") ~ "}")
       case _ =>
         tree.fallbackToText(this)
     }
   }
 
+  override protected def toTextCapturing(tp: Type, refsText: Text, boxText: Text): Text = tp match
+    case tp: AppliedType if defn.isFunctionSymbol(tp.typeSymbol) && !printDebug =>
+      boxText ~ toTextFunction(tp, refsText)
+    case tp: RefinedType if defn.isFunctionOrPolyType(tp) && !printDebug =>
+      boxText ~ toTextMethodAsFunction(tp.refinedInfo, isPure = !tp.typeSymbol.name.isImpureFunction, refsText)
+    case _ =>
+      super.toTextCapturing(tp, refsText, boxText)
+
   override def toText[T <: Untyped](tree: Tree[T]): Text = controlled {
     import untpd._
 
diff --git a/tests/neg-custom-args/captures/byname.check b/tests/neg-custom-args/captures/byname.check
index 90cf6c145c33..b1d8fb3b5404 100644
--- a/tests/neg-custom-args/captures/byname.check
+++ b/tests/neg-custom-args/captures/byname.check
@@ -1,20 +1,14 @@
--- Warning: tests/neg-custom-args/captures/byname.scala:17:18 ----------------------------------------------------------
-17 |  def h(x: {cap1} -> I) = x // warning
-   |                  ^
-   |                  Style: by-name `->` should immediately follow closing `}` of capture set
-   |                  to avoid confusion with function type.
-   |                  That is, `{c}-> T` instead of `{c} -> T`.
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/byname.scala:10:6 ----------------------------------------
 10 |  h(f2()) // error
    |    ^^^^
-   |    Found:    {cap1} (x$0: Int) -> Int
-   |    Required: {cap2} (x$0: Int) -> Int
+   |    Found:    (x$0: Int) ->{cap1} Int
+   |    Required: (x$0: Int) ->{cap2} Int
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/byname.scala:19:5 ----------------------------------------
 19 |  h(g()) // error
    |    ^^^
-   |    Found:    {cap2} () ?-> I
-   |    Required: {cap1} () ?-> I
+   |    Found:    () ?->{cap2} I
+   |    Required: () ?->{cap1} I
    |
    | 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 1838647f2899..ac13174eb4f4 100644
--- a/tests/neg-custom-args/captures/byname.scala
+++ b/tests/neg-custom-args/captures/byname.scala
@@ -5,16 +5,16 @@ def test(cap1: Cap, cap2: Cap) =
   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: => {cap2} Int -> Int) = ff
+  def h(ff: => Int ->{cap2} Int) = ff
   h(f())  // ok
   h(f2()) // error
 
 class I
 
-def test2(cap1: Cap, cap2: Cap): {cap1} I =
+def test2(cap1: Cap, cap2: Cap): I^{cap1} =
   def f() = if cap1 == cap1 then I() else I()
   def g() = if cap2 == cap2 then I() else I()
-  def h(x: {cap1} -> I) = x // warning
+  def h(x: ->{cap1} I) = x // ok
   h(f()) // OK
   h(g()) // error
 
diff --git a/tests/neg-custom-args/captures/capt1.check b/tests/neg-custom-args/captures/capt1.check
index 51ed3e6736cf..1e9e8626bdc5 100644
--- a/tests/neg-custom-args/captures/capt1.check
+++ b/tests/neg-custom-args/captures/capt1.check
@@ -1,21 +1,21 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/capt1.scala:4:2 ------------------------------------------
 4 |  () => if x == null then y else y  // error
   |  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  |  Found:    {x} () -> ? C
+  |  Found:    () ->{x} C^?
   |  Required: () -> C
   |
   | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/capt1.scala:7:2 ------------------------------------------
 7 |  () => if x == null then y else y  // error
   |  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  |  Found:    {x} () -> ? C
+  |  Found:    () ->{x} C^?
   |  Required: Matchable
   |
   | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/capt1.scala:14:2 -----------------------------------------
 14 |  def f(y: Int) = if x == null then y else y  // error
    |  ^
-   |  Found:    {x} Int -> Int
+   |  Found:    Int ->{x} Int
    |  Required: Matchable
 15 |  f
    |
@@ -23,7 +23,7 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/capt1.scala:21:2 -----------------------------------------
 21 |  class F(y: Int) extends A:   // error
    |  ^
-   |  Found:    {x} A
+   |  Found:    A^{x}
    |  Required: A
 22 |    def m() = if x == null then y else y
 23 |  F(22)
@@ -32,7 +32,7 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/capt1.scala:26:2 -----------------------------------------
 26 |  new A: // error
    |  ^
-   |  Found:    {x} A
+   |  Found:    A^{x}
    |  Required: A
 27 |    def m() = if x == null then y else y
    |
@@ -40,14 +40,14 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/capt1.scala:32:24 ----------------------------------------
 32 |  val z2 = h[() -> Cap](() => x) // error
    |                        ^^^^^^^
-   |                        Found:    {x} () -> Cap
-   |                        Required: () -> box {*} C
+   |                        Found:    () ->{x} Cap
+   |                        Required: () -> box C^{*}
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/capt1.scala:33:5 -----------------------------------------
 33 |    (() => C())  // error
    |     ^^^^^^^^^
-   |     Found:    ? () -> Cap
-   |     Required: () -> box {*} C
+   |     Found:    () ->? Cap
+   |     Required: () -> box C^{*}
    |
    | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/cc-this.check b/tests/neg-custom-args/captures/cc-this.check
index 0049f42a5db5..47207f913f1d 100644
--- a/tests/neg-custom-args/captures/cc-this.check
+++ b/tests/neg-custom-args/captures/cc-this.check
@@ -1,7 +1,7 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/cc-this.scala:8:15 ---------------------------------------
 8 |    val y: C = this // error
   |               ^^^^
-  |               Found:    (C.this : {C.this.x} C)
+  |               Found:    (C.this : C^{C.this.x})
   |               Required: C
   |
   | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/cc-this3.check b/tests/neg-custom-args/captures/cc-this3.check
index 705cdfbc00d7..ceb2694e8f15 100644
--- a/tests/neg-custom-args/captures/cc-this3.check
+++ b/tests/neg-custom-args/captures/cc-this3.check
@@ -1,14 +1,14 @@
 -- [E058] Type Mismatch Error: tests/neg-custom-args/captures/cc-this3.scala:8:6 ---------------------------------------
 8 |class B extends A: // error
   |      ^
-  |      illegal inheritance: self type {*} B of class B does not conform to self type {} A
+  |      illegal inheritance: self type B^{*} of class B does not conform to self type A^{}
   |      of parent class A
   |
   | longer explanation available when compiling with `-explain`
 -- [E058] Type Mismatch Error: tests/neg-custom-args/captures/cc-this3.scala:11:6 --------------------------------------
 11 |class C(val f: () => Int) extends A // error
    |      ^
-   |      illegal inheritance: self type {C.this.f} C of class C does not conform to self type {} A
+   |      illegal inheritance: self type C^{C.this.f} of class C does not conform to self type A^{}
    |      of parent class A
    |
    | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/cc-this3.scala b/tests/neg-custom-args/captures/cc-this3.scala
index eeb9606f0c81..61ccdb214b30 100644
--- a/tests/neg-custom-args/captures/cc-this3.scala
+++ b/tests/neg-custom-args/captures/cc-this3.scala
@@ -6,13 +6,13 @@ class A:
   val x: A = this
 
 class B extends A: // error
-  this: {*} B =>
+  this: B^{*} =>
 
 class C(val f: () => Int) extends A // error
 
 class A2
 
 class B2 extends A2:  // ok
-  this: {*} B2 =>
+  this: B2^{*} =>
 
 class C2(val f: () => Int) extends A2 // ok
diff --git a/tests/neg-custom-args/captures/cc-this4.check b/tests/neg-custom-args/captures/cc-this4.check
index a54ca8d57f4e..52c06f5bbc30 100644
--- a/tests/neg-custom-args/captures/cc-this4.check
+++ b/tests/neg-custom-args/captures/cc-this4.check
@@ -2,5 +2,5 @@
 1 |open class C: // error
   |           ^
   |           class C needs an explicitly declared self type since its
-  |           inferred self type {} C
+  |           inferred self type C^{}
   |           is not visible in other compilation units that define subclasses.
diff --git a/tests/neg-custom-args/captures/cc-this5.check b/tests/neg-custom-args/captures/cc-this5.check
index 8cc1ac9ccc5d..84ac97474b80 100644
--- a/tests/neg-custom-args/captures/cc-this5.check
+++ b/tests/neg-custom-args/captures/cc-this5.check
@@ -5,14 +5,14 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/cc-this5.scala:21:15 -------------------------------------
 21 |    val x: A = this // error
    |               ^^^^
-   |               Found:    (A.this : {c} A)
+   |               Found:    (A.this : A^{c})
    |               Required: A
    |
    | longer explanation available when compiling with `-explain`
 -- [E058] Type Mismatch Error: tests/neg-custom-args/captures/cc-this5.scala:7:9 ---------------------------------------
 7 |  object D extends C:   // error
   |         ^
-  |         illegal inheritance: self type {c} D.type of object D does not conform to self type {} C
+  |         illegal inheritance: self type D.type^{c} of object D does not conform to self type C^{}
   |         of parent class C
   |
   | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/class-contra.check b/tests/neg-custom-args/captures/class-contra.check
index 69a5f0097de8..6d4c89f872ad 100644
--- a/tests/neg-custom-args/captures/class-contra.check
+++ b/tests/neg-custom-args/captures/class-contra.check
@@ -1,7 +1,7 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/class-contra.scala:12:39 ---------------------------------
-12 |  def fun(x: K{val f: {a} T}) = x.setf(a) // error
+12 |  def fun(x: K{val f: T^{a}}) = x.setf(a) // error
    |                                       ^
-   |                                       Found:    (a : {x, y} T)
+   |                                       Found:    (a : T^{x, y})
    |                                       Required: T
    |
    | 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 270aaf9309a9..210fd4e331f1 100644
--- a/tests/neg-custom-args/captures/class-contra.scala
+++ b/tests/neg-custom-args/captures/class-contra.scala
@@ -1,13 +1,13 @@
 
 class C
-type Cap = {*} C
+type Cap = C^
 
-class K(val f: {*} T):
-  def setf(x: {f} T) = ???
+class K(val f: T^):
+  def setf(x: T^{f}) = ???
 
 class T
 
 def test(x: Cap, y: Cap) =
-  val a: {x, y} T = ???
-  def fun(x: K{val f: {a} T}) = x.setf(a) // error
+  val a: T^{x, y} = ???
+  def fun(x: K{val f: T^{a}}) = x.setf(a) // error
   ()
\ No newline at end of file
diff --git a/tests/neg-custom-args/captures/curried-simplified.check b/tests/neg-custom-args/captures/curried-simplified.check
index 5d23a7a4955e..a8e187b1449f 100644
--- a/tests/neg-custom-args/captures/curried-simplified.check
+++ b/tests/neg-custom-args/captures/curried-simplified.check
@@ -1,42 +1,42 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/curried-simplified.scala:7:28 ----------------------------
 7 |  def y1: () -> () -> Int = x1  // error
   |                            ^^
-  |                            Found:    {x} () -> {x} () -> Int
+  |                            Found:    () ->? () ->{x} Int
   |                            Required: () -> () -> Int
   |
   | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/curried-simplified.scala:9:28 ----------------------------
 9 |  def y2: () -> () => Int = x2 // error
   |                            ^^
-  |                            Found:    {x} () -> {*} () -> Int
+  |                            Found:    () ->{x} () ->{*} Int
   |                            Required: () -> () => Int
   |
   | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/curried-simplified.scala:11:39 ---------------------------
 11 |  def y3: Cap -> Protect[Int -> Int] = x3 // error
    |                                       ^^
-   |                                       Found:    ? (x$0: Cap) -> {x$0} Int -> Int
+   |                                       Found:    (x$0: Cap) ->? Int ->{x$0} Int
    |                                       Required: Cap -> Protect[Int -> Int]
    |
    | longer explanation available when compiling with `-explain`
--- [E007] Type Mismatch Error: tests/neg-custom-args/captures/curried-simplified.scala:15:33 ---------------------------
-15 |  def y5: Cap -> {} Int -> Int = x5 // error
-   |                                 ^^
-   |                                 Found:    ? Cap -> {x} Int -> Int
-   |                                 Required: Cap -> {} Int -> Int
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/curried-simplified.scala:15:32 ---------------------------
+15 |  def y5: Cap -> Int ->{} Int = x5 // error
+   |                                ^^
+   |                                Found:    Cap ->? Int ->{x} Int
+   |                                Required: Cap -> Int ->{} Int
    |
    | longer explanation available when compiling with `-explain`
--- [E007] Type Mismatch Error: tests/neg-custom-args/captures/curried-simplified.scala:17:49 ---------------------------
-17 |  def y6: Cap -> {} Cap -> Protect[Int -> Int] = x6 // error
-   |                                                 ^^
-   |                                             Found:    ? (x$0: Cap) -> {x$0} (x$0: Cap) -> {x$0, x$0} Int -> Int
-   |                                             Required: Cap -> {} Cap -> Protect[Int -> Int]
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/curried-simplified.scala:17:48 ---------------------------
+17 |  def y6: Cap -> Cap ->{} Protect[Int -> Int] = x6 // error
+   |                                                ^^
+   |                                                Found:    (x$0: Cap) ->? (x$0: Cap) ->{x$0} Int ->{x$0, x$0} Int
+   |                                                Required: Cap -> Cap ->{} Protect[Int -> Int]
    |
    | longer explanation available when compiling with `-explain`
--- [E007] Type Mismatch Error: tests/neg-custom-args/captures/curried-simplified.scala:19:49 ---------------------------
-19 |  def y7: Cap -> Protect[Cap -> {} Int -> Int] = x7 // error
-   |                                                 ^^
-   |                                                 Found:    ? (x$0: Cap) -> {x$0} (x: Cap) -> {x$0, x} Int -> Int
-   |                                                 Required: Cap -> Protect[Cap -> {} Int -> Int]
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/curried-simplified.scala:19:48 ---------------------------
+19 |  def y7: Cap -> Protect[Cap -> Int ->{} Int] = x7 // error
+   |                                                ^^
+   |                                                Found:    (x$0: Cap) ->? (x: Cap) ->{x$0} Int ->{x$0, x} Int
+   |                                                Required: Cap -> Protect[Cap -> Int ->{} Int]
    |
    | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/curried-simplified.scala b/tests/neg-custom-args/captures/curried-simplified.scala
index 25b23370d154..988cf7c11c45 100644
--- a/tests/neg-custom-args/captures/curried-simplified.scala
+++ b/tests/neg-custom-args/captures/curried-simplified.scala
@@ -3,19 +3,19 @@
 type Protect[T] = T
 
 def test(x: Cap, y: Cap) =
-  def x1: {x} () -> () -> Int = ???
+  def x1: () -> () ->{x} Int = ???
   def y1: () -> () -> Int = x1  // error
-  def x2: {x} () -> () => Int = ???
+  def x2: () ->{x} () => Int = ???
   def y2: () -> () => Int = x2 // error
   def x3: Cap -> Int -> Int = ???
   def y3: Cap -> Protect[Int -> Int] = x3 // error
   def x4: Cap -> Protect[Int -> Int] = ???
-  def y4: Cap -> {} Int -> Int = x4 // ok
-  def x5: Cap -> {x} Int -> Int = ???
-  def y5: Cap -> {} Int -> Int = x5 // error
+  def y4: Cap -> Int ->{} Int = x4 // ok
+  def x5: Cap -> Int ->{x} Int = ???
+  def y5: Cap -> Int ->{} Int = x5 // error
   def x6: Cap -> Cap -> Int -> Int = ???
-  def y6: Cap -> {} Cap -> Protect[Int -> Int] = x6 // error
+  def y6: Cap -> Cap ->{} Protect[Int -> Int] = x6 // error
   def x7: Cap -> (x: Cap) -> Int -> Int = ???
-  def y7: Cap -> Protect[Cap -> {} Int -> Int] = x7 // error
+  def y7: Cap -> Protect[Cap -> Int ->{} Int] = x7 // error
 
 
diff --git a/tests/neg-custom-args/captures/eta.check b/tests/neg-custom-args/captures/eta.check
index ebd63855181b..a77d66382095 100644
--- a/tests/neg-custom-args/captures/eta.check
+++ b/tests/neg-custom-args/captures/eta.check
@@ -1,14 +1,14 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/eta.scala:4:9 --------------------------------------------
 4 |         g  // error
   |         ^
-  |         Found:    ? () -> A
-  |         Required: () -> {f} Proc
+  |         Found:    () ->? A
+  |         Required: () -> Proc^{f}
   |
   | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/eta.scala:6:14 -------------------------------------------
 6 |         bar( () => f )  // error
   |              ^^^^^^^
-  |              Found:    {f} () -> box {f} () -> Unit
-  |              Required: () -> box ? () -> Unit
+  |              Found:    () ->{f} box () ->{f} Unit
+  |              Required: () -> box () ->? Unit
   |
   | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/eta.scala b/tests/neg-custom-args/captures/eta.scala
index 3d9d759d2203..5cc0196a04c6 100644
--- a/tests/neg-custom-args/captures/eta.scala
+++ b/tests/neg-custom-args/captures/eta.scala
@@ -1,7 +1,7 @@
-    type Proc = (() -> Unit)
-     def foo(f: {*} Proc): {} Proc =
-       def bar[A <: {f} Proc](g: () -> A): () -> {f} Proc =
+    type Proc = () -> Unit
+     def foo(f: Proc^): Proc^{} =
+       def bar[A <: Proc^{f}](g: () -> A): () -> Proc^{f} =
          g  // error
-       val stowaway: () -> {f} Proc =
+       val stowaway: () -> Proc^{f} =
          bar( () => f )  // error
        () => { stowaway.apply().apply() }
\ No newline at end of file
diff --git a/tests/neg-custom-args/captures/exception-definitions.check b/tests/neg-custom-args/captures/exception-definitions.check
index aca5d9217d64..29bdbefcb843 100644
--- a/tests/neg-custom-args/captures/exception-definitions.check
+++ b/tests/neg-custom-args/captures/exception-definitions.check
@@ -2,16 +2,16 @@
 2 |class Err extends Exception: // error
   |^
   |reference (scala.caps.* : Any) is not included in allowed capture set {} of pure base class class Throwable
-3 |  self: {*} Err =>
+3 |  self: Err^{*} =>
 -- Error: tests/neg-custom-args/captures/exception-definitions.scala:10:6 ----------------------------------------------
-10 |class Err4(c: {*} Any) extends AnyVal // error
+10 |class Err4(c: Any^{*}) extends AnyVal // error
    |^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |reference (Err4.this.c : {*} Any) is not included in allowed capture set {} of pure base class class AnyVal
+   |reference (Err4.this.c : Any^{*}) is not included in allowed capture set {} of pure base class class AnyVal
 -- Error: tests/neg-custom-args/captures/exception-definitions.scala:7:12 ----------------------------------------------
 7 |    val x = c  // error
   |            ^
-  |(c : {*} Any) cannot be referenced here; it is not included in the allowed capture set {} of pure base class class Throwable
+  |(c : Any^{*}) cannot be referenced here; it is not included in the allowed capture set {} of pure base class class Throwable
 -- Error: tests/neg-custom-args/captures/exception-definitions.scala:8:8 -----------------------------------------------
-8 |  class Err3(c: {*} Any) extends Exception // error
+8 |  class Err3(c: Any^{*}) extends Exception // error
   |  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  |  reference (Err3.this.c : {*} Any) is not included in allowed capture set {} of pure base class class Throwable
+  |  reference (Err3.this.c : Any^{*}) is not included in allowed capture set {} of pure base class class Throwable
diff --git a/tests/neg-custom-args/captures/exception-definitions.scala b/tests/neg-custom-args/captures/exception-definitions.scala
index 9f3539b7febf..5ecd5eb85cf7 100644
--- a/tests/neg-custom-args/captures/exception-definitions.scala
+++ b/tests/neg-custom-args/captures/exception-definitions.scala
@@ -1,12 +1,12 @@
 
 class Err extends Exception: // error
-  self: {*} Err =>
+  self: Err^{*} =>
 
-def test(c: {*} Any) =
+def test(c: Any^{*}) =
   class Err2 extends Exception:
     val x = c  // error
-  class Err3(c: {*} Any) extends Exception // error
+  class Err3(c: Any^{*}) extends Exception // error
 
-class Err4(c: {*} Any) extends AnyVal // error
+class Err4(c: Any^{*}) extends AnyVal // error
 
 
diff --git a/tests/neg-custom-args/captures/i15116.check b/tests/neg-custom-args/captures/i15116.check
index 7c73a7ff52ff..844ce71d0fff 100644
--- a/tests/neg-custom-args/captures/i15116.check
+++ b/tests/neg-custom-args/captures/i15116.check
@@ -2,27 +2,27 @@
 3 |  val x = Foo(m)   // error
   |  ^^^^^^^^^^^^^^
   |  Non-local value x cannot have an inferred type
-  |  {Bar.this.m} Foo{val m: {Bar.this.m} String}
+  |  Foo{val m: String^{Bar.this.m}}^{Bar.this.m}
   |  with non-empty capture set {Bar.this.m}.
   |  The type needs to be declared explicitly.
 -- Error: tests/neg-custom-args/captures/i15116.scala:5:6 --------------------------------------------------------------
 5 |  val x = Foo(m)   // error
   |  ^^^^^^^^^^^^^^
   |  Non-local value x cannot have an inferred type
-  |  {Baz.this} Foo{val m: {*} String}
+  |  Foo{val m: String^{*}}^{Baz.this}
   |  with non-empty capture set {Baz.this}.
   |  The type needs to be declared explicitly.
 -- Error: tests/neg-custom-args/captures/i15116.scala:7:6 --------------------------------------------------------------
 7 |  val x = Foo(m)   // error
   |  ^^^^^^^^^^^^^^
   |  Non-local value x cannot have an inferred type
-  |  {Bar1.this.m} Foo{val m: {Bar1.this.m} String}
+  |  Foo{val m: String^{Bar1.this.m}}^{Bar1.this.m}
   |  with non-empty capture set {Bar1.this.m}.
   |  The type needs to be declared explicitly.
 -- Error: tests/neg-custom-args/captures/i15116.scala:9:6 --------------------------------------------------------------
 9 |  val x = Foo(m)   // error
   |  ^^^^^^^^^^^^^^
   |  Non-local value x cannot have an inferred type
-  |  {Baz2.this} Foo{val m: {*} String}
+  |  Foo{val m: String^{*}}^{Baz2.this}
   |  with non-empty capture set {Baz2.this}.
   |  The type needs to be declared explicitly.
diff --git a/tests/neg-custom-args/captures/i15116.scala b/tests/neg-custom-args/captures/i15116.scala
index 1659f251df3e..e1c23e4c6aef 100644
--- a/tests/neg-custom-args/captures/i15116.scala
+++ b/tests/neg-custom-args/captures/i15116.scala
@@ -1,9 +1,9 @@
-class Foo(m: {*} String)
-class Bar(val m: {*} String):
+class Foo(m: String^{*})
+class Bar(val m: String^{*}):
   val x = Foo(m)   // error
-trait Baz(val m: {*} String):
+trait Baz(val m: String^{*}):
   val x = Foo(m)   // error
-class Bar1(m: {*} String):
+class Bar1(m: String^{*}):
   val x = Foo(m)   // error
-trait Baz2(m: {*} String):
+trait Baz2(m: String^{*}):
   val x = Foo(m)   // error
diff --git a/tests/neg-custom-args/captures/i15772.check b/tests/neg-custom-args/captures/i15772.check
index a587f2d262ed..f26d929bbdcd 100644
--- a/tests/neg-custom-args/captures/i15772.check
+++ b/tests/neg-custom-args/captures/i15772.check
@@ -1,28 +1,28 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i15772.scala:20:49 ---------------------------------------
-20 |    val boxed1 : (({*} C) => Unit) -> Unit = box1(c)  // error
+20 |    val boxed1 : ((C^{*}) => Unit) -> Unit = box1(c)  // error
    |                                             ^^^^^^^
-   |                                             Found:    {c} ({*} ({c} C{val arg: {*} C}) -> Unit) -> Unit
-   |                                             Required: (({*} C) => Unit) -> Unit
+   |                                             Found:    (C{val arg: C^{*}}^{c} ->{*} Unit) ->{c} Unit
+   |                                             Required: (C^{*} => Unit) -> Unit
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i15772.scala:27:38 ---------------------------------------
-27 |    val boxed2 : Observe[{*} C] = box2(c)  // error
+27 |    val boxed2 : Observe[C^{*}] = box2(c)  // error
    |                                  ^^^^^^^
-   |                                  Found:    {c} ({*} ({c} C{val arg: {*} C}) -> Unit) -> Unit
-   |                                  Required: Observe[{*} C]
+   |                                  Found:    (C{val arg: C^{*}}^{c} ->{*} Unit) ->{c} Unit
+   |                                  Required: Observe[C^{*}]
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i15772.scala:33:37 ---------------------------------------
-33 |  val boxed2 : Observe[{*} C] = box2(c) // error
+33 |  val boxed2 : Observe[C]^{*} = box2(c) // error
    |                                     ^
-   |                                     Found:    {*} C
-   |                                     Required: box {*} C{val arg: ? C}
+   |                                     Found:    C^{*}
+   |                                     Required: box C{val arg: C^?}^{*}
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i15772.scala:44:2 ----------------------------------------
 44 |  x: (() -> Unit) // error
    |  ^
-   |  Found:    {x} () -> Unit
+   |  Found:    () ->{x} Unit
    |  Required: () -> Unit
    |
    | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/i15772.scala b/tests/neg-custom-args/captures/i15772.scala
index d3afdb6c63f1..a22bbea742be 100644
--- a/tests/neg-custom-args/captures/i15772.scala
+++ b/tests/neg-custom-args/captures/i15772.scala
@@ -1,6 +1,6 @@
 type Observe[T] = (T => Unit) -> Unit
 
-def unsafe(cap: {*} C) = cap.bad()
+def unsafe(cap: C^{*}) = cap.bad()
 
 def box1[T](v: T) : (T => Unit) -> Unit = {
   (fn: T => Unit) => fn(v)
@@ -10,35 +10,35 @@ def box2[T](v: T) : Observe[T] = {
   (fn: T => Unit) => fn(v)
 }
 
-class C(val arg: {*} C) {
+class C(val arg: C^{*}) {
   def bad() = println("I've gone bad!")
 }
 
-def main1(x: {*} C) : () -> Int =
+def main1(x: C^{*}) : () -> Int =
   () =>
-    val c : {x} C = new C(x)
-    val boxed1 : (({*} C) => Unit) -> Unit = box1(c)  // error
-    boxed1((cap: {*} C) => unsafe(c))
+    val c : C^{x} = new C(x)
+    val boxed1 : ((C^{*}) => Unit) -> Unit = box1(c)  // error
+    boxed1((cap: C^{*}) => unsafe(c))
     0
 
-def main2(x: {*} C) : () -> Int =
+def main2(x: C^{*}) : () -> Int =
   () =>
-    val c : {x} C = new C(x)
-    val boxed2 : Observe[{*} C] = box2(c)  // error
-    boxed2((cap: {*} C) => unsafe(c))
+    val c : C^{x} = new C(x)
+    val boxed2 : Observe[C^{*}] = box2(c)  // error
+    boxed2((cap: C^{*}) => unsafe(c))
     0
 
-def main3(x: {*} C) =
-  def c : {*} C = new C(x)
-  val boxed2 : Observe[{*} C] = box2(c) // error
-  boxed2((cap: {*} C) => unsafe(c))
+def main3(x: C^{*}) =
+  def c : C^{*} = new C(x)
+  val boxed2 : Observe[C]^{*} = box2(c) // error
+  boxed2((cap: C^{*}) => unsafe(c))
   0
 
 trait File:
   def write(s: String): Unit
 
-def main(io: {*} Any) =
-  val sayHello: (({io} File) => Unit) = (file: {io} File) => file.write("Hello World!\r\n")
-  val filesList : List[{io} File] = ???
+def main(io: Any^{*}) =
+  val sayHello: ((File^{io}) => Unit) = (file: File^{io}) => file.write("Hello World!\r\n")
+  val filesList : List[File]^{io} = ???
   val x = () => filesList.foreach(sayHello)
   x: (() -> Unit) // error
diff --git a/tests/neg-custom-args/captures/lazylist.check b/tests/neg-custom-args/captures/lazylist.check
index 471e2a038450..78c51e5ee42b 100644
--- a/tests/neg-custom-args/captures/lazylist.check
+++ b/tests/neg-custom-args/captures/lazylist.check
@@ -1,42 +1,42 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazylist.scala:17:15 -------------------------------------
 17 |  def tail = xs() // error
    |             ^^^^
-   |             Found:    {LazyCons.this.xs} lazylists.LazyList[T]
+   |             Found:    lazylists.LazyList[T]^{LazyCons.this.xs}
    |             Required: lazylists.LazyList[T]
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazylist.scala:35:29 -------------------------------------
 35 |  val ref1c: LazyList[Int] = ref1 // error
    |                             ^^^^
-   |             Found:    (ref1 : {cap1} lazylists.LazyCons[Int]{val xs: {cap1} () -> {*} lazylists.LazyList[Int]})
-   |             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 -------------------------------------
-37 |  val ref2c: {ref1} LazyList[Int] = ref2 // error
+37 |  val ref2c: LazyList[Int]^{ref1} = ref2 // error
    |                                    ^^^^
-   |                                    Found:    (ref2 : {cap2, ref1} lazylists.LazyList[Int])
-   |                                    Required: {ref1} lazylists.LazyList[Int]
+   |                                    Found:    (ref2 : lazylists.LazyList[Int]^{cap2, ref1})
+   |                                    Required: lazylists.LazyList[Int]^{ref1}
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazylist.scala:39:36 -------------------------------------
-39 |  val ref3c: {cap2} LazyList[Int] = ref3 // error
+39 |  val ref3c: LazyList[Int]^{cap2} = ref3 // error
    |                                    ^^^^
-   |                                    Found:    (ref3 : {cap2, ref1} lazylists.LazyList[Int])
-   |                                    Required: {cap2} lazylists.LazyList[Int]
+   |                                    Found:    (ref3 : lazylists.LazyList[Int]^{cap2, ref1})
+   |                                    Required: lazylists.LazyList[Int]^{cap2}
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazylist.scala:41:48 -------------------------------------
-41 |  val ref4c: {cap1, ref3, cap3} LazyList[Int] = ref4 // error
+41 |  val ref4c: LazyList[Int]^{cap1, ref3, cap3} = ref4 // error
    |                                                ^^^^
-   |                                             Found:    (ref4 : {cap3, cap2, ref1, cap1} lazylists.LazyList[Int])
-   |                                             Required: {cap1, ref3, cap3} lazylists.LazyList[Int]
+   |                                             Found:    (ref4 : lazylists.LazyList[Int]^{cap3, cap2, ref1, cap1})
+   |                                             Required: lazylists.LazyList[Int]^{cap1, ref3, cap3}
    |
    | longer explanation available when compiling with `-explain`
 -- [E164] Declaration Error: tests/neg-custom-args/captures/lazylist.scala:22:6 ----------------------------------------
-22 |  def tail: {*} LazyList[Nothing] = ???  // error overriding
+22 |  def tail: LazyList[Nothing]^{*} = ???  // error overriding
    |      ^
    |      error overriding method tail in class LazyList of type -> lazylists.LazyList[Nothing];
-   |        method tail of type -> {*} lazylists.LazyList[Nothing] has incompatible type
+   |        method tail of type -> lazylists.LazyList[Nothing]^{*} has incompatible type
    |
    | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/lazylist.scala b/tests/neg-custom-args/captures/lazylist.scala
index 2674f15a0ee3..6b4cf00e5566 100644
--- a/tests/neg-custom-args/captures/lazylist.scala
+++ b/tests/neg-custom-args/captures/lazylist.scala
@@ -1,17 +1,17 @@
 package lazylists
 
 abstract class LazyList[+T]:
-  this: ({*} LazyList[T]) =>
+  this: LazyList[T]^{*} =>
 
   def isEmpty: Boolean
   def head: T
   def tail: LazyList[T]
 
-  def map[U](f: T => U): {f, this} LazyList[U] =
+  def map[U](f: T => U): LazyList[U]^{f, this} =
     if isEmpty then LazyNil
     else LazyCons(f(head), () => tail.map(f))
 
-class LazyCons[+T](val x: T, val xs: () => {*} LazyList[T]) extends LazyList[T]:
+class LazyCons[+T](val x: T, val xs: () => LazyList[T]^{*}) extends LazyList[T]:
   def isEmpty = false
   def head = x
   def tail = xs() // error
@@ -19,13 +19,13 @@ class LazyCons[+T](val x: T, val xs: () => {*} LazyList[T]) extends LazyList[T]:
 object LazyNil extends LazyList[Nothing]:
   def isEmpty = true
   def head = ???
-  def tail: {*} LazyList[Nothing] = ???  // error overriding
+  def tail: LazyList[Nothing]^{*} = ???  // error overriding
 
-def map[A, B](xs: {*} LazyList[A], f: A => B): {f, xs} LazyList[B] =
+def map[A, B](xs: LazyList[A]^{*}, f: A => B): LazyList[B]^{f, xs} =
   xs.map(f)
 
 class CC
-type Cap = {*} CC
+type Cap = CC^{*}
 
 def test(cap1: Cap, cap2: Cap, cap3: Cap) =
   def f[T](x: LazyList[T]): LazyList[T] = if cap1 == cap1 then x else LazyNil
@@ -34,8 +34,8 @@ def test(cap1: Cap, cap2: Cap, cap3: Cap) =
   val ref1 = LazyCons(1, () => f(LazyNil))
   val ref1c: LazyList[Int] = ref1 // error
   val ref2 = map(ref1, g)
-  val ref2c: {ref1} LazyList[Int] = ref2 // error
+  val ref2c: LazyList[Int]^{ref1} = ref2 // error
   val ref3 = ref1.map(g)
-  val ref3c: {cap2} LazyList[Int] = ref3 // error
+  val ref3c: LazyList[Int]^{cap2} = ref3 // error
   val ref4 = (if cap1 == cap2 then ref1 else ref2).map(h)
-  val ref4c: {cap1, ref3, cap3} LazyList[Int] = ref4 // error
+  val ref4c: LazyList[Int]^{cap1, ref3, cap3} = ref4 // error
diff --git a/tests/neg-custom-args/captures/lazylists-exceptions.check b/tests/neg-custom-args/captures/lazylists-exceptions.check
index bd6fad047fe9..c8f835f4fdfa 100644
--- a/tests/neg-custom-args/captures/lazylists-exceptions.check
+++ b/tests/neg-custom-args/captures/lazylists-exceptions.check
@@ -1,7 +1,7 @@
 -- 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 `*`.
+   |  The expression's type LazyList[Int]^{*} is not allowed to capture the root capability `*`.
    |  This usually means that a capability persists longer than its allowed lifetime.
 37 |    tabulate(10) { i =>
 38 |      if i > 9 then throw Ex1()
diff --git a/tests/neg-custom-args/captures/lazylists-exceptions.scala b/tests/neg-custom-args/captures/lazylists-exceptions.scala
index 6cba934d61e8..a2b902e83cb9 100644
--- a/tests/neg-custom-args/captures/lazylists-exceptions.scala
+++ b/tests/neg-custom-args/captures/lazylists-exceptions.scala
@@ -1,31 +1,31 @@
 import language.experimental.saferExceptions
 
 trait LazyList[+A]:
-  this: {*} LazyList[A] =>
+  this: LazyList[A]^ =>
 
   def isEmpty: Boolean
   def head: A
-  def tail: {this} LazyList[A]
+  def tail: LazyList[A]^{this}
 
 object LazyNil extends LazyList[Nothing]:
   def isEmpty: Boolean = true
   def head = ???
   def tail = ???
 
-final class LazyCons[+T](val x: T, val xs: () => {*} LazyList[T]) extends LazyList[T]:
-  this: {*} LazyList[T] =>
+final class LazyCons[+T](val x: T, val xs: () => LazyList[T]^{*}) extends LazyList[T]:
+  this: LazyList[T]^{*} =>
 
   def isEmpty = false
   def head = x
-  def tail: {this} LazyList[T] = xs()
+  def tail: LazyList[T]^{this} = xs()
 end LazyCons
 
 extension [A](x: A)
-  def #:(xs1: => {*} LazyList[A]): {xs1} LazyList[A] =
+  def #:(xs1: => LazyList[A]^{*}): LazyList[A]^{xs1} =
     LazyCons(x, () => xs1)
 
-def tabulate[A](n: Int)(gen: Int => A): {gen} LazyList[A] =
-  def recur(i: Int): {gen} LazyList[A] =
+def tabulate[A](n: Int)(gen: Int => A): LazyList[A]^{gen} =
+  def recur(i: Int): LazyList[A]^{gen} =
     if i == n then LazyNil
     else gen(i) #: recur(i + 1)
   recur(0)
diff --git a/tests/neg-custom-args/captures/lazylists1.check b/tests/neg-custom-args/captures/lazylists1.check
index f91e2500dc15..127a0563c3c9 100644
--- a/tests/neg-custom-args/captures/lazylists1.check
+++ b/tests/neg-custom-args/captures/lazylists1.check
@@ -1,7 +1,7 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazylists1.scala:25:66 -----------------------------------
-25 |      def concat(other: {f} LazyList[A]): {this, f} LazyList[A] = ??? : ({xs, f} LazyList[A]) // error
+25 |      def concat(other: LazyList[A]^{f}): LazyList[A]^{this, f} = ??? : (LazyList[A]^{xs, f}) // error
    |                                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |                                                                  Found:    {xs, f} LazyList[A]
-   |                                                                  Required: {Mapped.this, f} LazyList[A]
+   |                                                                  Found:    LazyList[A]^{xs, f}
+   |                                                                  Required: LazyList[A]^{Mapped.this, f}
    |
    | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/lazylists1.scala b/tests/neg-custom-args/captures/lazylists1.scala
index c6475223b783..88d9e5672b5d 100644
--- a/tests/neg-custom-args/captures/lazylists1.scala
+++ b/tests/neg-custom-args/captures/lazylists1.scala
@@ -1,27 +1,27 @@
 class CC
-type Cap = {*} CC
+type Cap = CC^{*}
 
 trait LazyList[+A]:
-  this: ({*} LazyList[A]) =>
+  this: LazyList[A]^{*} =>
 
   def isEmpty: Boolean
   def head: A
-  def tail: {this} LazyList[A]
+  def tail: LazyList[A]^{this}
 
 object LazyNil extends LazyList[Nothing]:
   def isEmpty: Boolean = true
   def head = ???
   def tail = ???
 
-extension [A](xs: {*} LazyList[A])
-  def map[B](f: A => B): {xs, f} LazyList[B] =
+extension [A](xs: LazyList[A]^{*})
+  def map[B](f: A => B): LazyList[B]^{xs, f} =
     final class Mapped extends LazyList[B]:
-      this: ({xs, f} Mapped) =>
+      this: (Mapped^{xs, f}) =>
 
       def isEmpty = false
       def head: B = f(xs.head)
-      def tail: {this} LazyList[B] = xs.tail.map(f)  // OK
-      def drop(n: Int): {this} LazyList[B] = ??? : ({xs, f} LazyList[B]) // OK
-      def concat(other: {f} LazyList[A]): {this, f} LazyList[A] = ??? : ({xs, f} LazyList[A]) // error
+      def tail: LazyList[B]^{this} = xs.tail.map(f)  // OK
+      def drop(n: Int): LazyList[B]^{this} = ??? : (LazyList[B]^{xs, f}) // OK
+      def concat(other: LazyList[A]^{f}): LazyList[A]^{this, f} = ??? : (LazyList[A]^{xs, f}) // error
     new Mapped
 
diff --git a/tests/neg-custom-args/captures/lazylists2.check b/tests/neg-custom-args/captures/lazylists2.check
index 812170aabdfe..72efbc08f8e2 100644
--- a/tests/neg-custom-args/captures/lazylists2.check
+++ b/tests/neg-custom-args/captures/lazylists2.check
@@ -1,24 +1,24 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazylists2.scala:18:4 ------------------------------------
 18 |    final class Mapped extends LazyList[B]:  // error
    |    ^
-   |    Found:    {f, xs} LazyList[? B]
-   |    Required: {f} LazyList[B]
-19 |      this: ({xs, f} Mapped) =>
+   |    Found:    LazyList[B^?]^{f, xs}
+   |    Required: LazyList[B]^{f}
+19 |      this: (Mapped^{xs, f}) =>
 20 |      def isEmpty = false
 21 |      def head: B = f(xs.head)
-22 |      def tail: {this} LazyList[B] = xs.tail.map(f)
+22 |      def tail: LazyList[B]^{this} = xs.tail.map(f)
 23 |    new Mapped
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazylists2.scala:27:4 ------------------------------------
 27 |    final class Mapped extends LazyList[B]:  // error
    |    ^
-   |    Found:    {f, xs} LazyList[? B]
-   |    Required: {xs} LazyList[B]
-28 |      this: ({xs, f} Mapped) =>
+   |    Found:    LazyList[B^?]^{f, xs}
+   |    Required: LazyList[B]^{xs}
+28 |      this: Mapped^{xs, f} =>
 29 |      def isEmpty = false
 30 |      def head: B = f(xs.head)
-31 |      def tail: {this} LazyList[B] = xs.tail.map(f)
+31 |      def tail: LazyList[B]^{this} = xs.tail.map(f)
 32 |    new Mapped
    |
    | longer explanation available when compiling with `-explain`
@@ -26,19 +26,19 @@
 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
--- Error: tests/neg-custom-args/captures/lazylists2.scala:41:49 --------------------------------------------------------
-41 |      def tail: {this} LazyList[B] = xs.tail.map(f) // error
-   |                                                 ^
+-- 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
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazylists2.scala:45:4 ------------------------------------
 45 |    final class Mapped extends LazyList[B]:  // error
    |    ^
-   |    Found:    {f, xs} LazyList[? B]
-   |    Required: {xs} LazyList[B]
-46 |      this: ({xs, f} Mapped) =>
+   |    Found:    LazyList[B^?]^{f, xs}
+   |    Required: LazyList[B]^{xs}
+46 |      this: (Mapped^{xs, f}) =>
 47 |      def isEmpty = false
 48 |      def head: B = f(xs.head)
-49 |      def tail: {xs, f} LazyList[B] = xs.tail.map(f)
+49 |      def tail: LazyList[B]^{xs, f} = xs.tail.map(f)
 50 |    new Mapped
    |
    | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/lazylists2.scala b/tests/neg-custom-args/captures/lazylists2.scala
index 574fb5a1a488..f6c1cf95a8ed 100644
--- a/tests/neg-custom-args/captures/lazylists2.scala
+++ b/tests/neg-custom-args/captures/lazylists2.scala
@@ -1,62 +1,62 @@
 class CC
-type Cap = {*} CC
+type Cap = CC^
 
 trait LazyList[+A]:
-  this: ({*} LazyList[A]) =>
+  this: LazyList[A]^ =>
 
   def isEmpty: Boolean
   def head: A
-  def tail: {this} LazyList[A]
+  def tail: LazyList[A]^{this}
 
 object LazyNil extends LazyList[Nothing]:
   def isEmpty: Boolean = true
   def head = ???
   def tail = ???
 
-extension [A](xs: {*} LazyList[A])
-  def map[B](f: A => B): {f} LazyList[B] =
+extension [A](xs: LazyList[A]^)
+  def map[B](f: A => B): LazyList[B]^{f} =
     final class Mapped extends LazyList[B]:  // error
-      this: ({xs, f} Mapped) =>
+      this: (Mapped^{xs, f}) =>
 
       def isEmpty = false
       def head: B = f(xs.head)
-      def tail: {this} LazyList[B] = xs.tail.map(f)
+      def tail: LazyList[B]^{this} = xs.tail.map(f)
     new Mapped
 
-  def map2[B](f: A => B): {xs} LazyList[B] =
+  def map2[B](f: A => B): LazyList[B]^{xs} =
     final class Mapped extends LazyList[B]:  // error
-      this: ({xs, f} Mapped) =>
+      this: Mapped^{xs, f} =>
 
       def isEmpty = false
       def head: B = f(xs.head)
-      def tail: {this} LazyList[B] = xs.tail.map(f)
+      def tail: LazyList[B]^{this} = xs.tail.map(f)
     new Mapped
 
-  def map3[B](f: A => B): {xs} LazyList[B] =
+  def map3[B](f: A => B): LazyList[B]^{xs} =
     final class Mapped extends LazyList[B]:
-      this: ({xs} Mapped) =>
+      this: Mapped^{xs} =>
 
       def isEmpty = false
       def head: B = f(xs.head)  // error
-      def tail: {this} LazyList[B] = xs.tail.map(f) // error
+      def tail: LazyList[B]^{this}= xs.tail.map(f) // error
     new Mapped
 
-  def map4[B](f: A => B): {xs} LazyList[B] =
+  def map4[B](f: A => B): LazyList[B]^{xs} =
     final class Mapped extends LazyList[B]:  // error
-      this: ({xs, f} Mapped) =>
+      this: (Mapped^{xs, f}) =>
 
       def isEmpty = false
       def head: B = f(xs.head)
-      def tail: {xs, f} LazyList[B] = xs.tail.map(f)
+      def tail: LazyList[B]^{xs, f} = xs.tail.map(f)
     new Mapped
 
   def map5[B](f: A => B): LazyList[B] =
     class Mapped extends LazyList[B]:
-      this: ({xs, f} Mapped) =>
+      this: (Mapped^{xs, f}) =>
 
       def isEmpty = false
       def head: B = f(xs.head)
-      def tail: {this} LazyList[B] = xs.tail.map(f)
+      def tail: LazyList[B]^{this} = xs.tail.map(f)
     class Mapped2 extends Mapped:  // error
       this: Mapped =>
     new Mapped2
diff --git a/tests/neg-custom-args/captures/lazyref.check b/tests/neg-custom-args/captures/lazyref.check
index 7471f8f4f686..9c9e2b757fb7 100644
--- a/tests/neg-custom-args/captures/lazyref.check
+++ b/tests/neg-custom-args/captures/lazyref.check
@@ -1,28 +1,28 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazyref.scala:19:28 --------------------------------------
 19 |  val ref1c: LazyRef[Int] = ref1 // error
    |                            ^^^^
-   |                            Found:    (ref1 : {cap1} LazyRef[Int]{val elem: {cap1} () -> Int})
+   |                            Found:    (ref1 : LazyRef[Int]{val elem: () ->{cap1} Int}^{cap1})
    |                            Required: LazyRef[Int]
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazyref.scala:21:35 --------------------------------------
-21 |  val ref2c: {cap2} LazyRef[Int] = ref2 // error
+21 |  val ref2c: LazyRef[Int]^{cap2} = ref2 // error
    |                                   ^^^^
-   |                                   Found:    (ref2 : {cap2, ref1} LazyRef[Int]{val elem: {*} () -> Int})
-   |                                   Required: {cap2} LazyRef[Int]
+   |                                   Found:    (ref2 : LazyRef[Int]{val elem: () ->{*} Int}^{cap2, ref1})
+   |                                   Required: LazyRef[Int]^{cap2}
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazyref.scala:23:35 --------------------------------------
-23 |  val ref3c: {ref1} LazyRef[Int] = ref3 // error
+23 |  val ref3c: LazyRef[Int]^{ref1} = ref3 // error
    |                                   ^^^^
-   |                                   Found:    (ref3 : {cap2, ref1} LazyRef[Int]{val elem: {*} () -> Int})
-   |                                   Required: {ref1} LazyRef[Int]
+   |                                   Found:    (ref3 : LazyRef[Int]{val elem: () ->{*} Int}^{cap2, ref1})
+   |                                   Required: LazyRef[Int]^{ref1}
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazyref.scala:25:35 --------------------------------------
-25 |  val ref4c: {cap1} LazyRef[Int] = ref4 // error
+25 |  val ref4c: LazyRef[Int]^{cap1} = ref4 // error
    |                                   ^^^^
-   |                                   Found:    (ref4 : {cap2, cap1} LazyRef[Int]{val elem: {*} () -> Int})
-   |                                   Required: {cap1} LazyRef[Int]
+   |                                   Found:    (ref4 : LazyRef[Int]{val elem: () ->{*} Int}^{cap2, cap1})
+   |                                   Required: LazyRef[Int]^{cap1}
    |
    | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/lazyref.scala b/tests/neg-custom-args/captures/lazyref.scala
index 8395e5cb42cd..54e64b4b4b4b 100644
--- a/tests/neg-custom-args/captures/lazyref.scala
+++ b/tests/neg-custom-args/captures/lazyref.scala
@@ -3,13 +3,13 @@ type Cap = {*} CC
 
 class LazyRef[T](val elem: () => T):
   val get: () => T = elem
-  def map[U](f: T => U): {f, this} LazyRef[U] =
+  def map[U](f: T => U): LazyRef[U]^{f, this} =
     new LazyRef(() => f(elem()))
 
-def map[A, B](ref: {*} LazyRef[A], f: A => B): {f, ref} LazyRef[B] =
+def map[A, B](ref: LazyRef[A]^{*}, f: A => B): LazyRef[B]^{f, ref} =
   new LazyRef(() => f(ref.elem()))
 
-def mapc[A, B]: (ref: {*} LazyRef[A], f: A => B) -> {f, ref} LazyRef[B] =
+def mapc[A, B]: (ref: LazyRef[A]^{*}, f: A => B) -> LazyRef[B]^{f, ref} =
   (ref1, f1) => map[A, B](ref1, f1)
 
 def test(cap1: Cap, cap2: Cap) =
@@ -18,8 +18,8 @@ def test(cap1: Cap, cap2: Cap) =
   val ref1 = LazyRef(() => f(0))
   val ref1c: LazyRef[Int] = ref1 // error
   val ref2 = map(ref1, g)
-  val ref2c: {cap2} LazyRef[Int] = ref2 // error
+  val ref2c: LazyRef[Int]^{cap2} = ref2 // error
   val ref3 = ref1.map(g)
-  val ref3c: {ref1} LazyRef[Int] = ref3 // error
+  val ref3c: LazyRef[Int]^{ref1} = ref3 // error
   val ref4 = (if cap1 == cap2 then ref1 else ref2).map(g)
-  val ref4c: {cap1} LazyRef[Int] = ref4 // error
+  val ref4c: LazyRef[Int]^{cap1} = ref4 // error
diff --git a/tests/neg-custom-args/captures/nestedclass.check b/tests/neg-custom-args/captures/nestedclass.check
index cb4421ece0ec..2987318caf4f 100644
--- a/tests/neg-custom-args/captures/nestedclass.check
+++ b/tests/neg-custom-args/captures/nestedclass.check
@@ -1,7 +1,7 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/nestedclass.scala:15:15 ----------------------------------
 15 |  val xsc: C = xs  // error
    |               ^^
-   |               Found:    (xs : {cap1} C)
+   |               Found:    (xs : C^{cap1})
    |               Required: C
    |
    | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/nestedclass.scala b/tests/neg-custom-args/captures/nestedclass.scala
index 38adf7998868..5e5900694228 100644
--- a/tests/neg-custom-args/captures/nestedclass.scala
+++ b/tests/neg-custom-args/captures/nestedclass.scala
@@ -1,5 +1,5 @@
 class CC
-type Cap = {*} CC
+type Cap = CC^{*}
 
 abstract class C:
   def head: String
diff --git a/tests/neg-custom-args/captures/real-try.check b/tests/neg-custom-args/captures/real-try.check
index 9745470f219c..b991e3fe09c1 100644
--- a/tests/neg-custom-args/captures/real-try.check
+++ b/tests/neg-custom-args/captures/real-try.check
@@ -1,7 +1,7 @@
 -- Error: tests/neg-custom-args/captures/real-try.scala:12:2 -----------------------------------------------------------
 12 |  try  // error
    |  ^
-   |  The expression's type {*} () -> Unit is not allowed to capture the root capability `*`.
+   |  The expression's type () ->{*} Unit is not allowed to capture the root capability `*`.
    |  This usually means that a capability persists longer than its allowed lifetime.
 13 |    () => foo(1)
 14 |  catch
@@ -10,7 +10,7 @@
 -- Error: tests/neg-custom-args/captures/real-try.scala:18:2 -----------------------------------------------------------
 18 |  try  // error
    |  ^
-   |  The expression's type {*} () -> ? Cell[Unit] is not allowed to capture the root capability `*`.
+   |  The expression's type () ->{*} Cell[Unit]^? is not allowed to capture the root capability `*`.
    |  This usually means that a capability persists longer than its allowed lifetime.
 19 |    () => Cell(foo(1))
 20 |  catch
@@ -19,5 +19,5 @@
 -- Error: tests/neg-custom-args/captures/real-try.scala:30:4 -----------------------------------------------------------
 30 |  b.x // error
    |  ^^^
-   |  The expression's type box {*} () -> Unit is not allowed to capture the root capability `*`.
+   |  The expression's type box () ->{*} Unit is not allowed to capture the root capability `*`.
    |  This usually means that a capability persists longer than its allowed lifetime.
diff --git a/tests/neg-custom-args/captures/try.check b/tests/neg-custom-args/captures/try.check
index d4bcc859d256..efe71386a183 100644
--- a/tests/neg-custom-args/captures/try.check
+++ b/tests/neg-custom-args/captures/try.check
@@ -1,8 +1,8 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/try.scala:23:49 ------------------------------------------
 23 |  val a = handle[Exception, CanThrow[Exception]] { // error
    |                                                 ^
-   |                                                 Found:    ? ({*} CT[Exception]) -> CanThrow[Exception]
-   |                                                 Required: {*} CanThrow[Exception] -> box {*} CT[Exception]
+   |                                                 Found:    CT[Exception]^{*} ->? CanThrow[Exception]
+   |                                                 Required: CanThrow[Exception] ->{*} box CT[Exception]^{*}
 24 |    (x: CanThrow[Exception]) => x
 25 |  }{
    |
@@ -10,8 +10,8 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/try.scala:29:43 ------------------------------------------
 29 |  val b = handle[Exception, () -> Nothing] {  // error
    |                                           ^
-   |                                           Found:    ? (x: {*} CT[Exception]) -> {x} () -> Nothing
-   |                                           Required: {*} (x$0: CanThrow[Exception]) -> () -> Nothing
+   |                                           Found:    (x: CT[Exception]^{*}) ->? () ->{x} Nothing
+   |                                           Required: (x$0: CanThrow[Exception]) ->{*} () -> Nothing
 30 |    (x: CanThrow[Exception]) => () => raise(new Exception)(using x)
 31 |  } {
    |
@@ -24,7 +24,7 @@
 51 |      22
 52 |} {  // error
    |                        ^
-   |                        Found:    {x$0} () -> Int
+   |                        Found:    () ->{x$0} Int
    |                        Required: () -> Int
 53 |  (ex: Exception) => () => 22
 54 |}
@@ -38,7 +38,7 @@
 39 |        22
 40 |  } {  // error
    |           ^
-   |           The expression's type box {x$0, *} () -> Int is not allowed to capture the root capability `*`.
+   |           The expression's type box () ->{x$0, *} Int is not allowed to capture the root capability `*`.
    |           This usually means that a capability persists longer than its allowed lifetime.
 41 |    (ex: Exception) => () => 22
 42 |  }
diff --git a/tests/neg-custom-args/captures/usingLogFile.check b/tests/neg-custom-args/captures/usingLogFile.check
index 05fb385a64f7..68d8a4a43508 100644
--- a/tests/neg-custom-args/captures/usingLogFile.check
+++ b/tests/neg-custom-args/captures/usingLogFile.check
@@ -1,39 +1,39 @@
 -- Error: tests/neg-custom-args/captures/usingLogFile.scala:33:2 -------------------------------------------------------
 33 |  later3() // error
    |  ^^^^^^
-   |  box {*} () -> Unit cannot be box-converted to a type that can be selected or applied
+   |  box () ->{*} Unit cannot be box-converted to a type that can be selected or applied
    |  since one of their capture sets contains the root capability `*`
 -- Error: tests/neg-custom-args/captures/usingLogFile.scala:37:9 -------------------------------------------------------
 37 |  later4.x() // error
    |  ^^^^^^^^
-   |  The expression's type box {*} () -> Unit is not allowed to capture the root capability `*`.
+   |  The expression's type box () ->{*} Unit is not allowed to capture the root capability `*`.
    |  This usually means that a capability persists longer than its allowed lifetime.
 -- Error: tests/neg-custom-args/captures/usingLogFile.scala:23:6 -------------------------------------------------------
 23 |  val later = usingLogFile { f => () => f.write(0) } // error
    |  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |  Non-local value later cannot have an inferred type
-   |  {x$0} () -> Unit
+   |  () ->{x$0} Unit
    |  with non-empty capture set {x$0}.
    |  The type needs to be declared explicitly.
 -- Error: tests/neg-custom-args/captures/usingLogFile.scala:29:9 -------------------------------------------------------
 29 |  later2.x()  // error
    |  ^^^^^^^^
-   |  The expression's type box {x$0, *} () -> Unit is not allowed to capture the root capability `*`.
+   |  The expression's type box () ->{x$0, *} Unit is not allowed to capture the root capability `*`.
    |  This usually means that a capability persists longer than its allowed lifetime.
 -- Error: tests/neg-custom-args/captures/usingLogFile.scala:47:6 -------------------------------------------------------
 47 |  val later = usingLogFile { f => () => f.write(0) } // error
    |  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |  Non-local value later cannot have an inferred type
-   |  {x$0} () -> Unit
+   |  () ->{x$0} Unit
    |  with non-empty capture set {x$0}.
    |  The type needs to be declared explicitly.
 -- Error: tests/neg-custom-args/captures/usingLogFile.scala:62:25 ------------------------------------------------------
 62 |    val later = usingFile("out", f => (y: Int) => xs.foreach(x => f.write(x + y))) // error
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |        The expression's type box {x$0, *} (x$0: Int) -> Unit is not allowed to capture the root capability `*`.
-   |        This usually means that a capability persists longer than its allowed lifetime.
+   |         The expression's type box (x$0: Int) ->{x$0, *} Unit is not allowed to capture the root capability `*`.
+   |         This usually means that a capability persists longer than its allowed lifetime.
 -- Error: tests/neg-custom-args/captures/usingLogFile.scala:71:25 ------------------------------------------------------
 71 |    val later = usingFile("logfile", usingLogger(_, l => () => l.log("test"))) // error
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |                The expression's type box {x$0, *} () -> Unit is not allowed to capture the root capability `*`.
+   |                The expression's type box () ->{x$0, *} Unit is not allowed to capture the root capability `*`.
    |                This usually means that a capability persists longer than its allowed lifetime.
diff --git a/tests/neg-custom-args/captures/usingLogFile.scala b/tests/neg-custom-args/captures/usingLogFile.scala
index 8b367239050d..b4c40d503e08 100644
--- a/tests/neg-custom-args/captures/usingLogFile.scala
+++ b/tests/neg-custom-args/captures/usingLogFile.scala
@@ -14,7 +14,7 @@ object Test1:
 
 object Test2:
 
-  def usingLogFile[T](op: ({*} FileOutputStream) => T): T =
+  def usingLogFile[T](op: FileOutputStream^{*} => T): T =
     val logFile = FileOutputStream("log")
     val result = op(logFile)
     logFile.close()
@@ -38,7 +38,7 @@ object Test2:
 
 object Test3:
 
-  def usingLogFile[T](op: ({*} FileOutputStream) => T) =
+  def usingLogFile[T](op: FileOutputStream^{*} => T) =
     val logFile = FileOutputStream("log")
     val result = op(logFile)
     logFile.close()
@@ -47,10 +47,10 @@ object Test3:
   val later = usingLogFile { f => () => f.write(0) } // error
 
 object Test4:
-  class Logger(f: {*} OutputStream):
+  class Logger(f: OutputStream^{*}):
     def log(msg: String): Unit = ???
 
-  def usingFile[T](name: String, op: ({*} OutputStream) => T): T =
+  def usingFile[T](name: String, op: OutputStream^{*} => T): T =
     val f = new FileOutputStream(name)
     val result = op(f)
     f.close()
@@ -63,7 +63,7 @@ object Test4:
     later(1)
 
 
-  def usingLogger[T](f: {*} OutputStream, op: ({f} Logger) => T): T =
+  def usingLogger[T](f: OutputStream^{*}, op: Logger^{f} => T): T =
     val logger = Logger(f)
     op(logger)
 
diff --git a/tests/neg-custom-args/captures/vars.check b/tests/neg-custom-args/captures/vars.check
index 4b9ab5723ce6..285a15262bb1 100644
--- a/tests/neg-custom-args/captures/vars.check
+++ b/tests/neg-custom-args/captures/vars.check
@@ -1,31 +1,31 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/vars.scala:11:24 -----------------------------------------
 11 |  val z2c: () -> Unit = z2  // error
    |                        ^^
-   |                        Found:    {z2} () -> Unit
+   |                        Found:    () ->{z2} Unit
    |                        Required: () -> Unit
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/vars.scala:15:10 -----------------------------------------
 15 |  val u = a  // error
    |          ^
-   |          Found:    (a : box {*} String -> String)
-   |          Required: {*} (x$0: String) -> String
+   |          Found:    (a : box String ->{*} String)
+   |          Required: (x$0: String) ->{*} String
    |
    | longer explanation available when compiling with `-explain`
 -- Error: tests/neg-custom-args/captures/vars.scala:16:2 ---------------------------------------------------------------
 16 |  a("")  // error
    |  ^
-   |  box {*} String -> String cannot be box-converted to a type that can be selected or applied
+   |  box String ->{*} String cannot be box-converted to a type that can be selected or applied
    |  since one of their capture sets contains the root capability `*`
 -- Error: tests/neg-custom-args/captures/vars.scala:17:4 ---------------------------------------------------------------
 17 |  b.head // error
    |  ^^^^^^
-   |  The expression's type box {*} String -> String is not allowed to capture the root capability `*`.
+   |  The expression's type box String ->{*} String is not allowed to capture the root capability `*`.
    |  This usually means that a capability persists longer than its allowed lifetime.
 -- Error: tests/neg-custom-args/captures/vars.scala:32:8 ---------------------------------------------------------------
 32 |  local { cap3 => // error
    |  ^
-   |  The expression's type box {x$0, *} (x$0: String) -> String is not allowed to capture the root capability `*`.
+   |  The expression's type box (x$0: String) ->{x$0, *} String is not allowed to capture the root capability `*`.
    |  This usually means that a capability persists longer than its allowed lifetime.
 33 |    def g(x: String): String = if cap3 == cap3 then "" else "a"
 34 |    g
diff --git a/tests/neg-custom-args/captures/vars.scala b/tests/neg-custom-args/captures/vars.scala
index 2ad8fec53619..e437d087d5a2 100644
--- a/tests/neg-custom-args/captures/vars.scala
+++ b/tests/neg-custom-args/captures/vars.scala
@@ -1,12 +1,12 @@
 class CC
-type Cap = {*} CC
+type Cap = CC^
 
 def test(cap1: Cap, cap2: Cap) =
   def f(x: String): String = if cap1 == cap1 then "" else "a"
   var x = f
   val y = x
   val z = () => if x("") == "" then "a" else "b"
-  val zc: {cap1} () -> String = z
+  val zc: () ->{cap1} String = z
   val z2 = () => { x = identity }
   val z2c: () -> Unit = z2  // error
 
@@ -35,7 +35,7 @@ def test(cap1: Cap, cap2: Cap) =
   }
 
   class Ref:
-    var elem: {cap1} String -> String = null
+    var elem: String ->{cap1} String = null
 
   val r = Ref()
   r.elem = f
diff --git a/tests/pos-custom-args/captures/nested-classes.scala b/tests/pos-custom-args/captures/nested-classes.scala
index 2e893b7413a5..b16fc4365183 100644
--- a/tests/pos-custom-args/captures/nested-classes.scala
+++ b/tests/pos-custom-args/captures/nested-classes.scala
@@ -5,10 +5,10 @@ import annotation.{capability, constructorOnly}
 class Blah
 class Pkg(using @constructorOnly io: IO):
   class Foo:
-    def m(foo: {io} Blah) = ???
+    def m(foo: Blah^{io}) = ???
 class Pkg2(using io: IO):
   class Foo:
-    def m(foo: {io} Blah): Any = io; ???
+    def m(foo: Blah^{io}): Any = io; ???
 
 def main(using io: IO) =
   val pkg = Pkg()

From 8aa41030067d94a9cac7c29bf42f713f429c069a Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sun, 30 Apr 2023 17:21:13 +0200
Subject: [PATCH 523/657] Avoid printing root capture set

Use ^ and => shorthands instead.
---
 .../tools/dotc/printing/PlainPrinter.scala    | 12 ++++++--
 .../tools/dotc/printing/RefinedPrinter.scala  | 14 ++++++---
 tests/neg-custom-args/captures/capt1.check    |  4 +--
 tests/neg-custom-args/captures/cc-this3.check |  2 +-
 tests/neg-custom-args/captures/cc-this3.scala |  4 +--
 .../captures/curried-simplified.check         |  2 +-
 .../captures/exception-definitions.check      | 16 +++++-----
 .../captures/exception-definitions.scala      |  8 ++---
 tests/neg-custom-args/captures/i15116.check   |  4 +--
 tests/neg-custom-args/captures/i15116.scala   | 10 +++----
 tests/neg-custom-args/captures/i15772.check   | 30 +++++++++----------
 tests/neg-custom-args/captures/i15772.scala   | 26 ++++++++--------
 tests/neg-custom-args/captures/lazylist.check |  8 ++---
 tests/neg-custom-args/captures/lazylist.scala | 10 +++----
 .../captures/lazylists-exceptions.check       |  2 +-
 .../captures/lazylists-exceptions.scala       |  6 ++--
 tests/neg-custom-args/captures/lazyref.check  |  6 ++--
 tests/neg-custom-args/captures/lazyref.scala  |  4 +--
 .../captures/nestedclass.scala                |  2 +-
 tests/neg-custom-args/captures/real-try.check |  6 ++--
 tests/neg-custom-args/captures/try.check      | 10 +++----
 .../captures/usingLogFile.check               | 12 ++++----
 .../captures/usingLogFile.scala               | 10 +++----
 tests/neg-custom-args/captures/vars.check     | 10 +++----
 24 files changed, 116 insertions(+), 102 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala b/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
index bd027ed79431..91e152c57048 100644
--- a/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
@@ -155,8 +155,15 @@ class PlainPrinter(_ctx: Context) extends Printer {
     else if !cs.isConst && cs.elems.isEmpty then "?"
     else "{" ~ Text(cs.elems.toList.map(toTextCaptureRef), ", ") ~ "}"
 
+  /** Print capturing type, overridden in RefinedPrinter to account for
+   *  capturing function types.
+   */
   protected def toTextCapturing(parent: Type, refsText: Text, boxText: Text): Text =
-    changePrec(InfixPrec)(boxText ~ toTextLocal(parent) ~ "^" ~ refsText)
+    changePrec(InfixPrec):
+      boxText ~ toTextLocal(parent) ~ "^"
+      ~ (refsText provided refsText != rootSetText)
+
+  final protected def rootSetText = Str("{*}")
 
   def toText(tp: Type): Text = controlled {
     homogenize(tp) match {
@@ -214,7 +221,8 @@ class PlainPrinter(_ctx: Context) extends Printer {
         }.close
       case tp @ EventuallyCapturingType(parent, refs) =>
         val boxText: Text = Str("box ") provided tp.isBoxed //&& ctx.settings.YccDebug.value
-        toTextCapturing(parent, toTextCaptureSet(refs), boxText)
+        val refsText = if refs.isUniversal then rootSetText else toTextCaptureSet(refs)
+        toTextCapturing(parent, refsText, boxText)
       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 =>
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index 338b03c5adb7..2e2ef69ace3f 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -148,7 +148,9 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     val AppliedType(tycon, args) = (tp: @unchecked)
     val tsym = tycon.typeSymbol
     val isGiven = tsym.name.isContextFunction
-    val isPure = Feature.pureFunsEnabled && !tsym.name.isImpureFunction
+    val capturesRoot = refs == rootSetText
+    val isPure =
+      Feature.pureFunsEnabled && !tsym.name.isImpureFunction && !capturesRoot
     changePrec(GlobalPrec) {
       val argStr: Text =
         if args.length == 2
@@ -160,17 +162,21 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           "("
           ~ argsText(args.init)
           ~ ")"
-      argStr ~ " " ~ arrow(isGiven, isPure) ~ refs  ~ " " ~ argText(args.last)
+      argStr
+      ~ " " ~ arrow(isGiven, isPure)
+      ~ (refs provided !capturesRoot)
+      ~ " " ~ argText(args.last)
     }
 
   private def toTextMethodAsFunction(info: Type, isPure: Boolean, refs: Text = Str("")): Text = info match
     case info: MethodType =>
+      val capturesRoot = refs == rootSetText
       changePrec(GlobalPrec) {
         "("
         ~ paramsText(info)
         ~ ") "
-        ~ arrow(info.isImplicitMethod, isPure)
-        ~ refs
+        ~ arrow(info.isImplicitMethod, isPure && !capturesRoot)
+        ~ (refs provided !capturesRoot)
         ~ " "
         ~ toTextMethodAsFunction(info.resultType, isPure)
       }
diff --git a/tests/neg-custom-args/captures/capt1.check b/tests/neg-custom-args/captures/capt1.check
index 1e9e8626bdc5..f51d4631782d 100644
--- a/tests/neg-custom-args/captures/capt1.check
+++ b/tests/neg-custom-args/captures/capt1.check
@@ -41,13 +41,13 @@
 32 |  val z2 = h[() -> Cap](() => x) // error
    |                        ^^^^^^^
    |                        Found:    () ->{x} Cap
-   |                        Required: () -> box C^{*}
+   |                        Required: () -> box C^
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/capt1.scala:33:5 -----------------------------------------
 33 |    (() => C())  // error
    |     ^^^^^^^^^
    |     Found:    () ->? Cap
-   |     Required: () -> box C^{*}
+   |     Required: () -> box C^
    |
    | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/cc-this3.check b/tests/neg-custom-args/captures/cc-this3.check
index ceb2694e8f15..d57471c6872e 100644
--- a/tests/neg-custom-args/captures/cc-this3.check
+++ b/tests/neg-custom-args/captures/cc-this3.check
@@ -1,7 +1,7 @@
 -- [E058] Type Mismatch Error: tests/neg-custom-args/captures/cc-this3.scala:8:6 ---------------------------------------
 8 |class B extends A: // error
   |      ^
-  |      illegal inheritance: self type B^{*} of class B does not conform to self type A^{}
+  |      illegal inheritance: self type B^ of class B does not conform to self type A^{}
   |      of parent class A
   |
   | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/cc-this3.scala b/tests/neg-custom-args/captures/cc-this3.scala
index 61ccdb214b30..25af19dd6c4a 100644
--- a/tests/neg-custom-args/captures/cc-this3.scala
+++ b/tests/neg-custom-args/captures/cc-this3.scala
@@ -6,13 +6,13 @@ class A:
   val x: A = this
 
 class B extends A: // error
-  this: B^{*} =>
+  this: B^ =>
 
 class C(val f: () => Int) extends A // error
 
 class A2
 
 class B2 extends A2:  // ok
-  this: B2^{*} =>
+  this: B2^ =>
 
 class C2(val f: () => Int) extends A2 // ok
diff --git a/tests/neg-custom-args/captures/curried-simplified.check b/tests/neg-custom-args/captures/curried-simplified.check
index a8e187b1449f..6a792314e4e3 100644
--- a/tests/neg-custom-args/captures/curried-simplified.check
+++ b/tests/neg-custom-args/captures/curried-simplified.check
@@ -8,7 +8,7 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/curried-simplified.scala:9:28 ----------------------------
 9 |  def y2: () -> () => Int = x2 // error
   |                            ^^
-  |                            Found:    () ->{x} () ->{*} Int
+  |                            Found:    () ->{x} () => Int
   |                            Required: () -> () => Int
   |
   | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/exception-definitions.check b/tests/neg-custom-args/captures/exception-definitions.check
index 29bdbefcb843..23dbe0fb6529 100644
--- a/tests/neg-custom-args/captures/exception-definitions.check
+++ b/tests/neg-custom-args/captures/exception-definitions.check
@@ -2,16 +2,16 @@
 2 |class Err extends Exception: // error
   |^
   |reference (scala.caps.* : Any) is not included in allowed capture set {} of pure base class class Throwable
-3 |  self: Err^{*} =>
+3 |  self: Err^ =>
 -- Error: tests/neg-custom-args/captures/exception-definitions.scala:10:6 ----------------------------------------------
-10 |class Err4(c: Any^{*}) extends AnyVal // error
-   |^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |reference (Err4.this.c : Any^{*}) is not included in allowed capture set {} of pure base class class AnyVal
+10 |class Err4(c: Any^) extends AnyVal // error
+   |^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |reference (Err4.this.c : Any^) is not included in allowed capture set {} of pure base class class AnyVal
 -- Error: tests/neg-custom-args/captures/exception-definitions.scala:7:12 ----------------------------------------------
 7 |    val x = c  // error
   |            ^
-  |(c : Any^{*}) cannot be referenced here; it is not included in the allowed capture set {} of pure base class class Throwable
+  |(c : Any^) cannot be referenced here; it is not included in the allowed capture set {} of pure base class class Throwable
 -- Error: tests/neg-custom-args/captures/exception-definitions.scala:8:8 -----------------------------------------------
-8 |  class Err3(c: Any^{*}) extends Exception // error
-  |  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-  |  reference (Err3.this.c : Any^{*}) is not included in allowed capture set {} of pure base class class Throwable
+8 |  class Err3(c: Any^) extends Exception // error
+  |  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  |  reference (Err3.this.c : Any^) is not included in allowed capture set {} of pure base class class Throwable
diff --git a/tests/neg-custom-args/captures/exception-definitions.scala b/tests/neg-custom-args/captures/exception-definitions.scala
index 5ecd5eb85cf7..996f64ae4bd1 100644
--- a/tests/neg-custom-args/captures/exception-definitions.scala
+++ b/tests/neg-custom-args/captures/exception-definitions.scala
@@ -1,12 +1,12 @@
 
 class Err extends Exception: // error
-  self: Err^{*} =>
+  self: Err^ =>
 
-def test(c: Any^{*}) =
+def test(c: Any^) =
   class Err2 extends Exception:
     val x = c  // error
-  class Err3(c: Any^{*}) extends Exception // error
+  class Err3(c: Any^) extends Exception // error
 
-class Err4(c: Any^{*}) extends AnyVal // error
+class Err4(c: Any^) extends AnyVal // error
 
 
diff --git a/tests/neg-custom-args/captures/i15116.check b/tests/neg-custom-args/captures/i15116.check
index 844ce71d0fff..4b637a7c2e40 100644
--- a/tests/neg-custom-args/captures/i15116.check
+++ b/tests/neg-custom-args/captures/i15116.check
@@ -9,7 +9,7 @@
 5 |  val x = Foo(m)   // error
   |  ^^^^^^^^^^^^^^
   |  Non-local value x cannot have an inferred type
-  |  Foo{val m: String^{*}}^{Baz.this}
+  |  Foo{val m: String^}^{Baz.this}
   |  with non-empty capture set {Baz.this}.
   |  The type needs to be declared explicitly.
 -- Error: tests/neg-custom-args/captures/i15116.scala:7:6 --------------------------------------------------------------
@@ -23,6 +23,6 @@
 9 |  val x = Foo(m)   // error
   |  ^^^^^^^^^^^^^^
   |  Non-local value x cannot have an inferred type
-  |  Foo{val m: String^{*}}^{Baz2.this}
+  |  Foo{val m: String^}^{Baz2.this}
   |  with non-empty capture set {Baz2.this}.
   |  The type needs to be declared explicitly.
diff --git a/tests/neg-custom-args/captures/i15116.scala b/tests/neg-custom-args/captures/i15116.scala
index e1c23e4c6aef..c4dc6c88d56c 100644
--- a/tests/neg-custom-args/captures/i15116.scala
+++ b/tests/neg-custom-args/captures/i15116.scala
@@ -1,9 +1,9 @@
-class Foo(m: String^{*})
-class Bar(val m: String^{*}):
+class Foo(m: String^)
+class Bar(val m: String^):
   val x = Foo(m)   // error
-trait Baz(val m: String^{*}):
+trait Baz(val m: String^):
   val x = Foo(m)   // error
-class Bar1(m: String^{*}):
+class Bar1(m: String^):
   val x = Foo(m)   // error
-trait Baz2(m: String^{*}):
+trait Baz2(m: String^):
   val x = Foo(m)   // error
diff --git a/tests/neg-custom-args/captures/i15772.check b/tests/neg-custom-args/captures/i15772.check
index f26d929bbdcd..e77d4022451d 100644
--- a/tests/neg-custom-args/captures/i15772.check
+++ b/tests/neg-custom-args/captures/i15772.check
@@ -1,22 +1,22 @@
--- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i15772.scala:20:49 ---------------------------------------
-20 |    val boxed1 : ((C^{*}) => Unit) -> Unit = box1(c)  // error
-   |                                             ^^^^^^^
-   |                                             Found:    (C{val arg: C^{*}}^{c} ->{*} Unit) ->{c} Unit
-   |                                             Required: (C^{*} => Unit) -> Unit
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i15772.scala:20:46 ---------------------------------------
+20 |    val boxed1 : ((C^) => Unit) -> Unit = box1(c)  // error
+   |                                          ^^^^^^^
+   |                                          Found:    (C{val arg: C^}^{c} => Unit) ->{c} Unit
+   |                                          Required: (C^ => Unit) -> Unit
    |
    | longer explanation available when compiling with `-explain`
--- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i15772.scala:27:38 ---------------------------------------
-27 |    val boxed2 : Observe[C^{*}] = box2(c)  // error
-   |                                  ^^^^^^^
-   |                                  Found:    (C{val arg: C^{*}}^{c} ->{*} Unit) ->{c} Unit
-   |                                  Required: Observe[C^{*}]
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i15772.scala:27:35 ---------------------------------------
+27 |    val boxed2 : Observe[C^] = box2(c)  // error
+   |                               ^^^^^^^
+   |                               Found:    (C{val arg: C^}^{c} => Unit) ->{c} Unit
+   |                               Required: Observe[C^]
    |
    | longer explanation available when compiling with `-explain`
--- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i15772.scala:33:37 ---------------------------------------
-33 |  val boxed2 : Observe[C]^{*} = box2(c) // error
-   |                                     ^
-   |                                     Found:    C^{*}
-   |                                     Required: box C{val arg: C^?}^{*}
+-- [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^?}^
    |
    | 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/i15772.scala b/tests/neg-custom-args/captures/i15772.scala
index a22bbea742be..e4efb6b9ccab 100644
--- a/tests/neg-custom-args/captures/i15772.scala
+++ b/tests/neg-custom-args/captures/i15772.scala
@@ -1,6 +1,6 @@
 type Observe[T] = (T => Unit) -> Unit
 
-def unsafe(cap: C^{*}) = cap.bad()
+def unsafe(cap: C^) = cap.bad()
 
 def box1[T](v: T) : (T => Unit) -> Unit = {
   (fn: T => Unit) => fn(v)
@@ -10,34 +10,34 @@ def box2[T](v: T) : Observe[T] = {
   (fn: T => Unit) => fn(v)
 }
 
-class C(val arg: C^{*}) {
+class C(val arg: C^) {
   def bad() = println("I've gone bad!")
 }
 
-def main1(x: C^{*}) : () -> Int =
+def main1(x: C^) : () -> Int =
   () =>
     val c : C^{x} = new C(x)
-    val boxed1 : ((C^{*}) => Unit) -> Unit = box1(c)  // error
-    boxed1((cap: C^{*}) => unsafe(c))
+    val boxed1 : ((C^) => Unit) -> Unit = box1(c)  // error
+    boxed1((cap: C^) => unsafe(c))
     0
 
-def main2(x: C^{*}) : () -> Int =
+def main2(x: C^) : () -> Int =
   () =>
     val c : C^{x} = new C(x)
-    val boxed2 : Observe[C^{*}] = box2(c)  // error
-    boxed2((cap: C^{*}) => unsafe(c))
+    val boxed2 : Observe[C^] = box2(c)  // error
+    boxed2((cap: C^) => unsafe(c))
     0
 
-def main3(x: C^{*}) =
-  def c : C^{*} = new C(x)
-  val boxed2 : Observe[C]^{*} = box2(c) // error
-  boxed2((cap: C^{*}) => unsafe(c))
+def main3(x: C^) =
+  def c : C^ = new C(x)
+  val boxed2 : Observe[C]^ = box2(c) // error
+  boxed2((cap: C^) => unsafe(c))
   0
 
 trait File:
   def write(s: String): Unit
 
-def main(io: Any^{*}) =
+def main(io: Any^) =
   val sayHello: ((File^{io}) => Unit) = (file: File^{io}) => file.write("Hello World!\r\n")
   val filesList : List[File]^{io} = ???
   val x = () => filesList.foreach(sayHello)
diff --git a/tests/neg-custom-args/captures/lazylist.check b/tests/neg-custom-args/captures/lazylist.check
index 78c51e5ee42b..4b7611fc3fb7 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:    (ref1 : lazylists.LazyCons[Int]{val xs: () ->{cap1} lazylists.LazyList[Int]^{*}}^{cap1})
-   |              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 -------------------------------------
@@ -34,9 +34,9 @@
    |
    | longer explanation available when compiling with `-explain`
 -- [E164] Declaration Error: tests/neg-custom-args/captures/lazylist.scala:22:6 ----------------------------------------
-22 |  def tail: LazyList[Nothing]^{*} = ???  // error overriding
+22 |  def tail: LazyList[Nothing]^ = ???  // error overriding
    |      ^
    |      error overriding method tail in class LazyList of type -> lazylists.LazyList[Nothing];
-   |        method tail of type -> lazylists.LazyList[Nothing]^{*} has incompatible type
+   |        method tail of type -> lazylists.LazyList[Nothing]^ has incompatible type
    |
    | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/lazylist.scala b/tests/neg-custom-args/captures/lazylist.scala
index 6b4cf00e5566..e6e4d003f7ae 100644
--- a/tests/neg-custom-args/captures/lazylist.scala
+++ b/tests/neg-custom-args/captures/lazylist.scala
@@ -1,7 +1,7 @@
 package lazylists
 
 abstract class LazyList[+T]:
-  this: LazyList[T]^{*} =>
+  this: LazyList[T]^ =>
 
   def isEmpty: Boolean
   def head: T
@@ -11,7 +11,7 @@ abstract class LazyList[+T]:
     if isEmpty then LazyNil
     else LazyCons(f(head), () => tail.map(f))
 
-class LazyCons[+T](val x: T, val xs: () => LazyList[T]^{*}) extends LazyList[T]:
+class LazyCons[+T](val x: T, val xs: () => LazyList[T]^) extends LazyList[T]:
   def isEmpty = false
   def head = x
   def tail = xs() // error
@@ -19,13 +19,13 @@ class LazyCons[+T](val x: T, val xs: () => LazyList[T]^{*}) extends LazyList[T]:
 object LazyNil extends LazyList[Nothing]:
   def isEmpty = true
   def head = ???
-  def tail: LazyList[Nothing]^{*} = ???  // error overriding
+  def tail: LazyList[Nothing]^ = ???  // error overriding
 
-def map[A, B](xs: LazyList[A]^{*}, f: A => B): LazyList[B]^{f, xs} =
+def map[A, B](xs: LazyList[A]^, f: A => B): LazyList[B]^{f, xs} =
   xs.map(f)
 
 class CC
-type Cap = CC^{*}
+type Cap = CC^
 
 def test(cap1: Cap, cap2: Cap, cap3: Cap) =
   def f[T](x: LazyList[T]): LazyList[T] = if cap1 == cap1 then x else LazyNil
diff --git a/tests/neg-custom-args/captures/lazylists-exceptions.check b/tests/neg-custom-args/captures/lazylists-exceptions.check
index c8f835f4fdfa..4c451b1fea8a 100644
--- a/tests/neg-custom-args/captures/lazylists-exceptions.check
+++ b/tests/neg-custom-args/captures/lazylists-exceptions.check
@@ -1,7 +1,7 @@
 -- 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 `*`.
+   |  The expression's type LazyList[Int]^ is not allowed to capture the root capability `*`.
    |  This usually means that a capability persists longer than its allowed lifetime.
 37 |    tabulate(10) { i =>
 38 |      if i > 9 then throw Ex1()
diff --git a/tests/neg-custom-args/captures/lazylists-exceptions.scala b/tests/neg-custom-args/captures/lazylists-exceptions.scala
index a2b902e83cb9..6a72facf7285 100644
--- a/tests/neg-custom-args/captures/lazylists-exceptions.scala
+++ b/tests/neg-custom-args/captures/lazylists-exceptions.scala
@@ -12,8 +12,8 @@ object LazyNil extends LazyList[Nothing]:
   def head = ???
   def tail = ???
 
-final class LazyCons[+T](val x: T, val xs: () => LazyList[T]^{*}) extends LazyList[T]:
-  this: LazyList[T]^{*} =>
+final class LazyCons[+T](val x: T, val xs: () => LazyList[T]^) extends LazyList[T]:
+  this: LazyList[T]^ =>
 
   def isEmpty = false
   def head = x
@@ -21,7 +21,7 @@ final class LazyCons[+T](val x: T, val xs: () => LazyList[T]^{*}) extends LazyLi
 end LazyCons
 
 extension [A](x: A)
-  def #:(xs1: => LazyList[A]^{*}): LazyList[A]^{xs1} =
+  def #:(xs1: => LazyList[A]^): LazyList[A]^{xs1} =
     LazyCons(x, () => xs1)
 
 def tabulate[A](n: Int)(gen: Int => A): LazyList[A]^{gen} =
diff --git a/tests/neg-custom-args/captures/lazyref.check b/tests/neg-custom-args/captures/lazyref.check
index 9c9e2b757fb7..8c91ec13b5d8 100644
--- a/tests/neg-custom-args/captures/lazyref.check
+++ b/tests/neg-custom-args/captures/lazyref.check
@@ -8,21 +8,21 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazyref.scala:21:35 --------------------------------------
 21 |  val ref2c: LazyRef[Int]^{cap2} = ref2 // error
    |                                   ^^^^
-   |                                   Found:    (ref2 : LazyRef[Int]{val elem: () ->{*} Int}^{cap2, ref1})
+   |                                   Found:    (ref2 : LazyRef[Int]{val elem: () => Int}^{cap2, ref1})
    |                                   Required: LazyRef[Int]^{cap2}
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazyref.scala:23:35 --------------------------------------
 23 |  val ref3c: LazyRef[Int]^{ref1} = ref3 // error
    |                                   ^^^^
-   |                                   Found:    (ref3 : LazyRef[Int]{val elem: () ->{*} Int}^{cap2, ref1})
+   |                                   Found:    (ref3 : LazyRef[Int]{val elem: () => Int}^{cap2, ref1})
    |                                   Required: LazyRef[Int]^{ref1}
    |
    | longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/lazyref.scala:25:35 --------------------------------------
 25 |  val ref4c: LazyRef[Int]^{cap1} = ref4 // error
    |                                   ^^^^
-   |                                   Found:    (ref4 : LazyRef[Int]{val elem: () ->{*} Int}^{cap2, cap1})
+   |                                   Found:    (ref4 : LazyRef[Int]{val elem: () => Int}^{cap2, cap1})
    |                                   Required: LazyRef[Int]^{cap1}
    |
    | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/lazyref.scala b/tests/neg-custom-args/captures/lazyref.scala
index 54e64b4b4b4b..797781ac5360 100644
--- a/tests/neg-custom-args/captures/lazyref.scala
+++ b/tests/neg-custom-args/captures/lazyref.scala
@@ -6,10 +6,10 @@ class LazyRef[T](val elem: () => T):
   def map[U](f: T => U): LazyRef[U]^{f, this} =
     new LazyRef(() => f(elem()))
 
-def map[A, B](ref: LazyRef[A]^{*}, f: A => B): LazyRef[B]^{f, ref} =
+def map[A, B](ref: LazyRef[A]^, f: A => B): LazyRef[B]^{f, ref} =
   new LazyRef(() => f(ref.elem()))
 
-def mapc[A, B]: (ref: LazyRef[A]^{*}, f: A => B) -> LazyRef[B]^{f, ref} =
+def mapc[A, B]: (ref: LazyRef[A]^, f: A => B) -> LazyRef[B]^{f, ref} =
   (ref1, f1) => map[A, B](ref1, f1)
 
 def test(cap1: Cap, cap2: Cap) =
diff --git a/tests/neg-custom-args/captures/nestedclass.scala b/tests/neg-custom-args/captures/nestedclass.scala
index 5e5900694228..0581f9ce9b2d 100644
--- a/tests/neg-custom-args/captures/nestedclass.scala
+++ b/tests/neg-custom-args/captures/nestedclass.scala
@@ -1,5 +1,5 @@
 class CC
-type Cap = CC^{*}
+type Cap = CC^
 
 abstract class C:
   def head: String
diff --git a/tests/neg-custom-args/captures/real-try.check b/tests/neg-custom-args/captures/real-try.check
index b991e3fe09c1..c46d1e075075 100644
--- a/tests/neg-custom-args/captures/real-try.check
+++ b/tests/neg-custom-args/captures/real-try.check
@@ -1,7 +1,7 @@
 -- Error: tests/neg-custom-args/captures/real-try.scala:12:2 -----------------------------------------------------------
 12 |  try  // error
    |  ^
-   |  The expression's type () ->{*} Unit is not allowed to capture the root capability `*`.
+   |  The expression's type () => Unit is not allowed to capture the root capability `*`.
    |  This usually means that a capability persists longer than its allowed lifetime.
 13 |    () => foo(1)
 14 |  catch
@@ -10,7 +10,7 @@
 -- Error: tests/neg-custom-args/captures/real-try.scala:18:2 -----------------------------------------------------------
 18 |  try  // error
    |  ^
-   |  The expression's type () ->{*} Cell[Unit]^? is not allowed to capture the root capability `*`.
+   |  The expression's type () => Cell[Unit]^? is not allowed to capture the root capability `*`.
    |  This usually means that a capability persists longer than its allowed lifetime.
 19 |    () => Cell(foo(1))
 20 |  catch
@@ -19,5 +19,5 @@
 -- Error: tests/neg-custom-args/captures/real-try.scala:30:4 -----------------------------------------------------------
 30 |  b.x // error
    |  ^^^
-   |  The expression's type box () ->{*} Unit is not allowed to capture the root capability `*`.
+   |  The expression's type box () => Unit is not allowed to capture the root capability `*`.
    |  This usually means that a capability persists longer than its allowed lifetime.
diff --git a/tests/neg-custom-args/captures/try.check b/tests/neg-custom-args/captures/try.check
index efe71386a183..604f7bb1efb4 100644
--- a/tests/neg-custom-args/captures/try.check
+++ b/tests/neg-custom-args/captures/try.check
@@ -1,8 +1,8 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/try.scala:23:49 ------------------------------------------
 23 |  val a = handle[Exception, CanThrow[Exception]] { // error
    |                                                 ^
-   |                                                 Found:    CT[Exception]^{*} ->? CanThrow[Exception]
-   |                                                 Required: CanThrow[Exception] ->{*} box CT[Exception]^{*}
+   |                                                 Found:    CT[Exception]^ ->? CanThrow[Exception]
+   |                                                 Required: CanThrow[Exception] => box CT[Exception]^
 24 |    (x: CanThrow[Exception]) => x
 25 |  }{
    |
@@ -10,8 +10,8 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/try.scala:29:43 ------------------------------------------
 29 |  val b = handle[Exception, () -> Nothing] {  // error
    |                                           ^
-   |                                           Found:    (x: CT[Exception]^{*}) ->? () ->{x} Nothing
-   |                                           Required: (x$0: CanThrow[Exception]) ->{*} () -> Nothing
+   |                                           Found:    (x: CT[Exception]^) ->? () ->{x} Nothing
+   |                                           Required: (x$0: CanThrow[Exception]) => () -> Nothing
 30 |    (x: CanThrow[Exception]) => () => raise(new Exception)(using x)
 31 |  } {
    |
@@ -38,7 +38,7 @@
 39 |        22
 40 |  } {  // error
    |           ^
-   |           The expression's type box () ->{x$0, *} Int is not allowed to capture the root capability `*`.
+   |           The expression's type box () => Int is not allowed to capture the root capability `*`.
    |           This usually means that a capability persists longer than its allowed lifetime.
 41 |    (ex: Exception) => () => 22
 42 |  }
diff --git a/tests/neg-custom-args/captures/usingLogFile.check b/tests/neg-custom-args/captures/usingLogFile.check
index 68d8a4a43508..99e895c74ee7 100644
--- a/tests/neg-custom-args/captures/usingLogFile.check
+++ b/tests/neg-custom-args/captures/usingLogFile.check
@@ -1,12 +1,12 @@
 -- Error: tests/neg-custom-args/captures/usingLogFile.scala:33:2 -------------------------------------------------------
 33 |  later3() // error
    |  ^^^^^^
-   |  box () ->{*} Unit cannot be box-converted to a type that can be selected or applied
+   |  box () => Unit cannot be box-converted to a type that can be selected or applied
    |  since one of their capture sets contains the root capability `*`
 -- Error: tests/neg-custom-args/captures/usingLogFile.scala:37:9 -------------------------------------------------------
 37 |  later4.x() // error
    |  ^^^^^^^^
-   |  The expression's type box () ->{*} Unit is not allowed to capture the root capability `*`.
+   |  The expression's type box () => Unit is not allowed to capture the root capability `*`.
    |  This usually means that a capability persists longer than its allowed lifetime.
 -- Error: tests/neg-custom-args/captures/usingLogFile.scala:23:6 -------------------------------------------------------
 23 |  val later = usingLogFile { f => () => f.write(0) } // error
@@ -18,7 +18,7 @@
 -- Error: tests/neg-custom-args/captures/usingLogFile.scala:29:9 -------------------------------------------------------
 29 |  later2.x()  // error
    |  ^^^^^^^^
-   |  The expression's type box () ->{x$0, *} Unit is not allowed to capture the root capability `*`.
+   |  The expression's type box () => Unit is not allowed to capture the root capability `*`.
    |  This usually means that a capability persists longer than its allowed lifetime.
 -- Error: tests/neg-custom-args/captures/usingLogFile.scala:47:6 -------------------------------------------------------
 47 |  val later = usingLogFile { f => () => f.write(0) } // error
@@ -30,10 +30,10 @@
 -- Error: tests/neg-custom-args/captures/usingLogFile.scala:62:25 ------------------------------------------------------
 62 |    val later = usingFile("out", f => (y: Int) => xs.foreach(x => f.write(x + y))) // error
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |         The expression's type box (x$0: Int) ->{x$0, *} Unit is not allowed to capture the root capability `*`.
-   |         This usually means that a capability persists longer than its allowed lifetime.
+   |                The expression's type box (x$0: Int) => Unit is not allowed to capture the root capability `*`.
+   |                This usually means that a capability persists longer than its allowed lifetime.
 -- Error: tests/neg-custom-args/captures/usingLogFile.scala:71:25 ------------------------------------------------------
 71 |    val later = usingFile("logfile", usingLogger(_, l => () => l.log("test"))) // error
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |                The expression's type box () ->{x$0, *} Unit is not allowed to capture the root capability `*`.
+   |                The expression's type box () => Unit is not allowed to capture the root capability `*`.
    |                This usually means that a capability persists longer than its allowed lifetime.
diff --git a/tests/neg-custom-args/captures/usingLogFile.scala b/tests/neg-custom-args/captures/usingLogFile.scala
index b4c40d503e08..1e281f130b8a 100644
--- a/tests/neg-custom-args/captures/usingLogFile.scala
+++ b/tests/neg-custom-args/captures/usingLogFile.scala
@@ -14,7 +14,7 @@ object Test1:
 
 object Test2:
 
-  def usingLogFile[T](op: FileOutputStream^{*} => T): T =
+  def usingLogFile[T](op: FileOutputStream^ => T): T =
     val logFile = FileOutputStream("log")
     val result = op(logFile)
     logFile.close()
@@ -38,7 +38,7 @@ object Test2:
 
 object Test3:
 
-  def usingLogFile[T](op: FileOutputStream^{*} => T) =
+  def usingLogFile[T](op: FileOutputStream^ => T) =
     val logFile = FileOutputStream("log")
     val result = op(logFile)
     logFile.close()
@@ -47,10 +47,10 @@ object Test3:
   val later = usingLogFile { f => () => f.write(0) } // error
 
 object Test4:
-  class Logger(f: OutputStream^{*}):
+  class Logger(f: OutputStream^):
     def log(msg: String): Unit = ???
 
-  def usingFile[T](name: String, op: OutputStream^{*} => T): T =
+  def usingFile[T](name: String, op: OutputStream^ => T): T =
     val f = new FileOutputStream(name)
     val result = op(f)
     f.close()
@@ -63,7 +63,7 @@ object Test4:
     later(1)
 
 
-  def usingLogger[T](f: OutputStream^{*}, op: Logger^{f} => T): T =
+  def usingLogger[T](f: OutputStream^, op: Logger^{f} => T): T =
     val logger = Logger(f)
     op(logger)
 
diff --git a/tests/neg-custom-args/captures/vars.check b/tests/neg-custom-args/captures/vars.check
index 285a15262bb1..b0420c7e5179 100644
--- a/tests/neg-custom-args/captures/vars.check
+++ b/tests/neg-custom-args/captures/vars.check
@@ -8,24 +8,24 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/vars.scala:15:10 -----------------------------------------
 15 |  val u = a  // error
    |          ^
-   |          Found:    (a : box String ->{*} String)
-   |          Required: (x$0: String) ->{*} String
+   |          Found:    (a : box String => String)
+   |          Required: (x$0: String) => String
    |
    | longer explanation available when compiling with `-explain`
 -- Error: tests/neg-custom-args/captures/vars.scala:16:2 ---------------------------------------------------------------
 16 |  a("")  // error
    |  ^
-   |  box String ->{*} String cannot be box-converted to a type that can be selected or applied
+   |  box String => String cannot be box-converted to a type that can be selected or applied
    |  since one of their capture sets contains the root capability `*`
 -- Error: tests/neg-custom-args/captures/vars.scala:17:4 ---------------------------------------------------------------
 17 |  b.head // error
    |  ^^^^^^
-   |  The expression's type box String ->{*} String is not allowed to capture the root capability `*`.
+   |  The expression's type box String => String is not allowed to capture the root capability `*`.
    |  This usually means that a capability persists longer than its allowed lifetime.
 -- Error: tests/neg-custom-args/captures/vars.scala:32:8 ---------------------------------------------------------------
 32 |  local { cap3 => // error
    |  ^
-   |  The expression's type box (x$0: String) ->{x$0, *} String is not allowed to capture the root capability `*`.
+   |  The expression's type box (x$0: String) => String is not allowed to capture the root capability `*`.
    |  This usually means that a capability persists longer than its allowed lifetime.
 33 |    def g(x: String): String = if cap3 == cap3 then "" else "a"
 34 |    g

From d5cee7ce13c374b6888af7747f81ca7601cfdfee Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sun, 30 Apr 2023 17:52:28 +0200
Subject: [PATCH 524/657] Change to new syntax in pos-custom-args

---
 tests/pos-custom-args/bounded1.scala          | 14 ++--
 tests/pos-custom-args/captures/bounded.scala  |  8 +--
 tests/pos-custom-args/captures/boxed1.scala   |  4 +-
 .../captures/boxmap-paper.scala               | 16 ++---
 .../captures/caps-universal.scala             |  2 +-
 .../captures/capt-capability.scala            |  6 +-
 .../captures/capt-depfun.scala                |  4 +-
 .../captures/capt-depfun2.scala               |  2 +-
 tests/pos-custom-args/captures/capt0.scala    |  2 +-
 tests/pos-custom-args/captures/capt2.scala    |  8 +--
 .../pos-custom-args/captures/caseclass.scala  | 10 +--
 .../pos-custom-args/captures/cc-expand.scala  |  2 +-
 tests/pos-custom-args/captures/cc-this.scala  |  4 +-
 .../captures/compare-refined.scala            | 10 +--
 .../captures/curried-shorthands.scala         |  8 +--
 tests/pos-custom-args/captures/filevar.scala  |  8 +--
 tests/pos-custom-args/captures/hk-param.scala | 14 ++--
 tests/pos-custom-args/captures/i15922.scala   |  6 +-
 tests/pos-custom-args/captures/i16116.scala   |  4 +-
 tests/pos-custom-args/captures/i16226.scala   |  8 +--
 .../pos-custom-args/captures/iterators.scala  |  8 +--
 .../captures/lazylists-exceptions.scala       | 32 ++++-----
 .../captures/lazylists-mono.scala             | 12 ++--
 .../pos-custom-args/captures/lazylists.scala  | 20 +++---
 .../pos-custom-args/captures/lazylists1.scala | 24 +++----
 tests/pos-custom-args/captures/lazyref.scala  | 16 ++---
 .../captures/list-encoding.scala              |  4 +-
 tests/pos-custom-args/captures/lists.scala    | 72 +++++++++----------
 tests/pos-custom-args/captures/logger.scala   | 26 +++----
 .../captures/nonvariant-inf.scala             |  4 +-
 .../captures/override-adapt-box-pos-alt.scala |  8 +--
 .../captures/override-adapt-box-pos.scala     | 12 ++--
 tests/pos-custom-args/captures/pairs.scala    | 14 ++--
 .../captures/selftype-alias.scala             |  1 -
 .../captures/stack-alloc.scala                |  2 +-
 tests/pos-custom-args/captures/vars.scala     |  8 +--
 36 files changed, 201 insertions(+), 202 deletions(-)

diff --git a/tests/pos-custom-args/bounded1.scala b/tests/pos-custom-args/bounded1.scala
index 5fb7f0da904b..e16da4935a14 100644
--- a/tests/pos-custom-args/bounded1.scala
+++ b/tests/pos-custom-args/bounded1.scala
@@ -1,27 +1,27 @@
 // To be revisited
 class CC
-type Cap = {*} CC
+type Cap = CC^
 
 def test(c: Cap) =
-  class B[X <: {c} Object](x: X):
+  class B[X <: Object^{c}](x: X):
     def elem = x
     def lateElem = () => x
 
   def f(x: Int): Int = if c == c then x else 0
   val b = new B(f)
   val r1 = b.elem
-  val r1c: {c} Int -> Int = r1
+  val r1c: Int^{c} -> Int = r1
   val r2 = b.lateElem
-  val r2c: () -> {c} Int -> Int = r2 // was error now OK
+  val r2c: () -> Int^{c} -> Int = r2 // was error now OK
 
 def test2(c: Cap) =
-  class B[X <: {*} Any](x: X):
+  class B[X <: Any^](x: X):
     def elem = x
     def lateElem = () => x
 
   def f(x: Int): Int = if c == c then x else 0
   val b = new B(f)
   val r1 = b.elem
-  val r1c: {c} Int -> Int = r1
+  val r1c: Int ->{c} Int = r1
   val r2 = b.lateElem
-  val r2c: () -> {c} Int -> Int = r2 // was error now OK
\ No newline at end of file
+  val r2c: () -> Int ->{c} Int = r2 // was error now OK
\ No newline at end of file
diff --git a/tests/pos-custom-args/captures/bounded.scala b/tests/pos-custom-args/captures/bounded.scala
index 85c1a67387b5..7959df7d50cf 100644
--- a/tests/pos-custom-args/captures/bounded.scala
+++ b/tests/pos-custom-args/captures/bounded.scala
@@ -1,14 +1,14 @@
 class CC
-type Cap = {*} CC
+type Cap = CC^
 
 def test(c: Cap) =
-  class B[X <: {c} Object](x: X):
+  class B[X <: Object^{c}](x: X):
     def elem = x
     def lateElem = () => x
 
   def f(x: Int): Int = if c == c then x else 0
   val b = new B(f)
   val r1 = b.elem
-  val r1c: {c} Int -> Int = r1
+  val r1c: Int ->{c} Int = r1
   val r2 = b.lateElem
-  val r2c: {c} () -> {c} Int -> Int = r2
\ No newline at end of file
+  val r2c: () ->{c} Int ->{c} Int = r2
\ No newline at end of file
diff --git a/tests/pos-custom-args/captures/boxed1.scala b/tests/pos-custom-args/captures/boxed1.scala
index ba198335f51d..8c6b63ef0134 100644
--- a/tests/pos-custom-args/captures/boxed1.scala
+++ b/tests/pos-custom-args/captures/boxed1.scala
@@ -6,6 +6,6 @@ def foo(x: => Int): Unit = ()
 
 def test(c: Cap) =
   val f = () => { c; 1 }
-  val _: {c} () -> Int = f
+  val _: () ->{c} Int = f
   val g = () => Box(f)
-  val _: () -> Box[{f} () -> Int] = g
+  val _: () -> Box[() ->{f} Int] = g
diff --git a/tests/pos-custom-args/captures/boxmap-paper.scala b/tests/pos-custom-args/captures/boxmap-paper.scala
index aff4c38e1b9d..9d5bb49af25d 100644
--- a/tests/pos-custom-args/captures/boxmap-paper.scala
+++ b/tests/pos-custom-args/captures/boxmap-paper.scala
@@ -12,25 +12,25 @@ def map[A, B](c: Cell[A])(f: A => B): Cell[B]
 def pureMap[A, B](c: Cell[A])(f: A -> B): Cell[B]
   = c[Cell[B]]((x: A) => cell(f(x)))
 
-def lazyMap[A, B](c: Cell[A])(f: A => B): {f} () -> Cell[B]
+def lazyMap[A, B](c: Cell[A])(f: A => B): () ->{f} Cell[B]
   = () => c[Cell[B]]((x: A) => cell(f(x)))
 
 trait IO:
   def print(s: String): Unit
 
-def test(io: {*} IO) =
+def test(io: IO^) =
 
-  val loggedOne: {io} () -> Int = () => { io.print("1"); 1 }
+  val loggedOne: () ->{io} Int = () => { io.print("1"); 1 }
 
-  val c: Cell[{io} () -> Int]
-      = cell[{io} () -> Int](loggedOne)
+  val c: Cell[() ->{io} Int]
+      = cell[() ->{io} Int](loggedOne)
 
-  val g = (f: {io} () -> Int) =>
+  val g = (f: () ->{io} Int) =>
     val x = f(); io.print(" + ")
     val y = f(); io.print(s" = ${x + y}")
 
-  val r = lazyMap[{io} () -> Int, Unit](c)(f => g(f))
-  val r2 = lazyMap[{io} () -> Int, Unit](c)(g)
+  val r = lazyMap[() ->{io} Int, Unit](c)(f => g(f))
+  val r2 = lazyMap[() ->{io} Int, Unit](c)(g)
   val r3 = lazyMap(c)(g)
   val _ = r()
   val _ = r2()
diff --git a/tests/pos-custom-args/captures/caps-universal.scala b/tests/pos-custom-args/captures/caps-universal.scala
index d84f2b7b2584..77ce10c4e42e 100644
--- a/tests/pos-custom-args/captures/caps-universal.scala
+++ b/tests/pos-custom-args/captures/caps-universal.scala
@@ -2,6 +2,6 @@ import annotation.retains
 
 val foo: Int => Int = x => x
 val bar: (Int -> Int) @retains(caps.*) = foo
-val baz: {*} Int -> Int = bar
+val baz: Int => Int = bar
 
 
diff --git a/tests/pos-custom-args/captures/capt-capability.scala b/tests/pos-custom-args/captures/capt-capability.scala
index 4dbd6e32f2a4..830d341c7bca 100644
--- a/tests/pos-custom-args/captures/capt-capability.scala
+++ b/tests/pos-custom-args/captures/capt-capability.scala
@@ -1,7 +1,7 @@
 import annotation.capability
 
 @capability class Cap
-def f1(c: Cap): {c} () -> c.type = () => c // ok
+def f1(c: Cap): () ->{c} c.type = () => c // ok
 
 def f2: Int =
   val g: Boolean => Int = ???
@@ -17,8 +17,8 @@ def f3: Int =
 def foo() =
   val x: Cap = ???
   val y: Cap = x
-  val x2: {x} () -> Cap = ???
-  val y2: {x} () -> Cap = x2
+  val x2: () ->{x} Cap = ???
+  val y2: () ->{x} Cap = x2
 
   val z1: () => Cap = f1(x)
   def h[X](a: X)(b: X) = a
diff --git a/tests/pos-custom-args/captures/capt-depfun.scala b/tests/pos-custom-args/captures/capt-depfun.scala
index 0e9786b2ee34..3a896b8acb8e 100644
--- a/tests/pos-custom-args/captures/capt-depfun.scala
+++ b/tests/pos-custom-args/captures/capt-depfun.scala
@@ -16,6 +16,6 @@ def f(y: Cap, z: Cap): String @retains(caps.*) =
   val d = a(g())
 
   val ac: ((x: Cap) -> ID[String @retains(x) -> String @retains(x)]) = ???
-  val bc: (({y} String) -> {y} String) = ac(y)
-  val dc: (String -> {y, z} String) = ac(g())
+  val bc: String^{y} -> String^{y} = ac(y)
+  val dc: String -> String^{y, z} = ac(g())
   c
diff --git a/tests/pos-custom-args/captures/capt-depfun2.scala b/tests/pos-custom-args/captures/capt-depfun2.scala
index 1c747d5885e6..96e97de95d72 100644
--- a/tests/pos-custom-args/captures/capt-depfun2.scala
+++ b/tests/pos-custom-args/captures/capt-depfun2.scala
@@ -5,5 +5,5 @@ type Cap = C @retains(caps.*)
 def f(y: Cap, z: Cap) =
   def g(): C @retains(y, z) = ???
   val ac: ((x: Cap) -> Array[String @retains(x)]) = ???
-  val dc: Array[? >: String <: {y, z} String] = ac(g()) // needs to be inferred
+  val dc: Array[? >: String <: String]^{y, z} = ac(g()) // needs to be inferred
   val ec = ac(y)
diff --git a/tests/pos-custom-args/captures/capt0.scala b/tests/pos-custom-args/captures/capt0.scala
index 52d6253af46b..fca48170b6f5 100644
--- a/tests/pos-custom-args/captures/capt0.scala
+++ b/tests/pos-custom-args/captures/capt0.scala
@@ -1,7 +1,7 @@
 object Test:
 
   def test() =
-    val x: {*} Any = "abc"
+    val x: Any^ = "abc"
     val y: Object @scala.annotation.retains(x) = ???
     val z: Object @scala.annotation.retains(x, caps.*) = y: Object @annotation.retains(x)
 
diff --git a/tests/pos-custom-args/captures/capt2.scala b/tests/pos-custom-args/captures/capt2.scala
index 77c0caaf0f1d..498dbd371ca0 100644
--- a/tests/pos-custom-args/captures/capt2.scala
+++ b/tests/pos-custom-args/captures/capt2.scala
@@ -3,7 +3,7 @@ class C
 type Cap = C @retains(caps.*)
 
 def test1() =
-  val y: {*} String = ""
+  val y: String^ = ""
   def x: Object @retains(y) = y
 
 def test2() =
@@ -13,8 +13,8 @@ def test2() =
   z: (() -> Unit) @retains(x)
   def z2: (() -> Unit) @retains(y) = y
   z2: (() -> Unit) @retains(y)
-  val p: {*} () -> String = () => "abc"
-  val q: {p} C = ???
-  val _ = p: ({p} () -> String)
+  val p: () => String = () => "abc"
+  val q: C^{p} = ???
+  val _ = p: (() ->{p} String)
 
 
diff --git a/tests/pos-custom-args/captures/caseclass.scala b/tests/pos-custom-args/captures/caseclass.scala
index a845da181e9f..ffbf878dca49 100644
--- a/tests/pos-custom-args/captures/caseclass.scala
+++ b/tests/pos-custom-args/captures/caseclass.scala
@@ -1,6 +1,6 @@
 @annotation.capability class C
 object test1:
-  case class Ref(x: {*} String)
+  case class Ref(x: String^)
 
   def test(c: C) =
     val x1 = Ref("hello")
@@ -14,7 +14,7 @@ object test2:
 
     val pure: () -> Unit = () => ()
     val impure: () => Unit = pure
-    val mixed: {c} () -> Unit = pure
+    val mixed: () ->{c} Unit = pure
     val x = Ref(impure)
     val y0 = x.copy(pure)
     val yc0: Ref = y0
@@ -25,10 +25,10 @@ object test2:
     val yc2: Ref = y2
 
     val x3 = Ref(mixed)
-    val _: {c} Ref = x3
+    val _: Ref^{c} = x3
     val y3 = x3.copy()
-    val yc3: {c} Ref = y3
+    val yc3: Ref^{c} = y3
 
     val y4 = y3 match
       case Ref(xx) => xx
-    val y4c: {x3} () -> Unit = y4
+    val y4c: () ->{x3} Unit = y4
diff --git a/tests/pos-custom-args/captures/cc-expand.scala b/tests/pos-custom-args/captures/cc-expand.scala
index 87b2c34caf5f..1d398353a5ec 100644
--- a/tests/pos-custom-args/captures/cc-expand.scala
+++ b/tests/pos-custom-args/captures/cc-expand.scala
@@ -9,7 +9,7 @@ object Test:
 
   def test(ct: CT, dt: CT) =
 
-    def x0: A -> {ct} B = ???
+    def x0: A -> B^{ct} = ???
 
     def x1: A -> B @retains(ct) = ???
     def x2: A -> B -> C @retains(ct) = ???
diff --git a/tests/pos-custom-args/captures/cc-this.scala b/tests/pos-custom-args/captures/cc-this.scala
index 77414fa9b8c0..2124ee494041 100644
--- a/tests/pos-custom-args/captures/cc-this.scala
+++ b/tests/pos-custom-args/captures/cc-this.scala
@@ -5,7 +5,7 @@ def eff(using Cap): Unit = ()
 def test(using Cap) =
 
   class C(val x: () => Int):
-    val y: {*} C = this
+    val y: C^ = this
 
   def f = () =>
     eff
@@ -14,4 +14,4 @@ def test(using Cap) =
   def c1 = new C(f)
   def c2 = c1
   def c3 = c2.y
-  val _ = c3: {*} C
+  val _ = c3: C^
diff --git a/tests/pos-custom-args/captures/compare-refined.scala b/tests/pos-custom-args/captures/compare-refined.scala
index c60bfee602b3..306f2216ab82 100644
--- a/tests/pos-custom-args/captures/compare-refined.scala
+++ b/tests/pos-custom-args/captures/compare-refined.scala
@@ -2,11 +2,11 @@ abstract class LIST[+T]:
   def map[U](f: T => U): LIST[U] = ???
 
 class C
-type Cap = {*} C
+type Cap = C^
 
 def test(d: Cap) =
-  val zsc: LIST[{d} Cap -> Unit] = ???
-  val a4 = zsc.map[{d} Cap -> Unit]((x: {d} Cap -> Unit) => x)
-  val a5 = zsc.map[{d} Cap -> Unit](identity[{d} Cap -> Unit])
-  val a6 = zsc.map(identity[{d} Cap -> Unit])
+  val zsc: LIST[Cap ->{d} Unit] = ???
+  val a4 = zsc.map[Cap ->{d} Unit]((x: Cap ->{d} Unit) => x)
+  val a5 = zsc.map[Cap ->{d} Unit](identity[Cap ->{d} Unit])
+  val a6 = zsc.map(identity[Cap ->{d} Unit])
   val a7 = zsc.map(identity)
diff --git a/tests/pos-custom-args/captures/curried-shorthands.scala b/tests/pos-custom-args/captures/curried-shorthands.scala
index 7c58729a3041..c68dc4b5cdbf 100644
--- a/tests/pos-custom-args/captures/curried-shorthands.scala
+++ b/tests/pos-custom-args/captures/curried-shorthands.scala
@@ -10,15 +10,15 @@ object Test:
   val f3 = (f: Int => Int) =>
     println(f(3))
     (xs: List[Int]) => xs.map(_ + 1)
-  val f3c: (Int => Int) -> {} List[Int] -> List[Int] = f3
+  val f3c: (Int => Int) -> List[Int] ->{} List[Int] = f3
 
   class LL[A]:
-    def drop(n: Int): {this} LL[A] = ???
+    def drop(n: Int): LL[A]^{this} = ???
 
   def test(ct: CanThrow[Exception]) =
-    def xs: {ct} LL[Int] = ???
+    def xs: LL[Int]^{ct} = ???
     val ys = xs.drop(_)
-    val ysc: Int -> {ct} LL[Int] = ys
+    val ysc: Int -> LL[Int]^{ct} = ys
 
 
 
diff --git a/tests/pos-custom-args/captures/filevar.scala b/tests/pos-custom-args/captures/filevar.scala
index 17a8281c4d29..a6cc7ca9ff47 100644
--- a/tests/pos-custom-args/captures/filevar.scala
+++ b/tests/pos-custom-args/captures/filevar.scala
@@ -6,10 +6,10 @@ object test1:
   class File:
     def write(x: String): Unit = ???
 
-  class Service(f: {*} File):
+  class Service(f: File^):
     def log = f.write("log")
 
-  def withFile[T](op: (f: {*} File) => T): T =
+  def withFile[T](op: (f: File^) => T): T =
     op(new File)
 
   def test =
@@ -24,10 +24,10 @@ object test2:
     def write(x: String): Unit = ???
 
   class Service(io: IO):
-    var file: {io} File = uninitialized
+    var file: File^{io} = uninitialized
     def log = file.write("log")
 
-  def withFile[T](io: IO)(op: (f: {io} File) => T): T =
+  def withFile[T](io: IO)(op: (f: File^{io}) => T): T =
     op(new File)
 
   def test(io: IO) =
diff --git a/tests/pos-custom-args/captures/hk-param.scala b/tests/pos-custom-args/captures/hk-param.scala
index b0e894d865e9..bf2f75f29e7f 100644
--- a/tests/pos-custom-args/captures/hk-param.scala
+++ b/tests/pos-custom-args/captures/hk-param.scala
@@ -1,17 +1,17 @@
 /** Concrete collection type: View */
-trait View[+A] extends Itable[A], ILike[A, [X] =>> {*} View[X]]:
-  override def fromIterable[B](c: {*} Itable[B]): {c} View[B] = ???
+trait View[+A] extends Itable[A], ILike[A, [X] =>> View[X]^]:
+  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]
+  def fromIterable[B](coll: Itable[B]^): C[B]
 
-trait ILike[+A, +C[X] <: {*} Itable[X]] extends IPolyTransforms[A, C]
+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]
+trait Itable[+A] extends ItableOnce[A] with ILike[A, Itable^]
 
 /** Iterator can be used only once */
 trait ItableOnce[+A] {
-  this: {*} ItableOnce[A] =>
-  def iterator: {this} Iterator[A]
+  this: ItableOnce[A]^ =>
+  def iterator: Iterator[A]^{this}
 }
diff --git a/tests/pos-custom-args/captures/i15922.scala b/tests/pos-custom-args/captures/i15922.scala
index 8547f7598eef..23109a3ba8f4 100644
--- a/tests/pos-custom-args/captures/i15922.scala
+++ b/tests/pos-custom-args/captures/i15922.scala
@@ -2,13 +2,13 @@ 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 withCap[X](op: ({*} Cap) => X): X = {
-  val cap: {*} Cap = new Cap { def use() = { println("cap is used"); 0 } }
+def withCap[X](op: (Cap^) => X): X = {
+  val cap: Cap^ = new Cap { def use() = { println("cap is used"); 0 } }
   val result = op(cap)
   result
 }
 
-def leaking(c: {*} Cap): Id[{c} Cap] = mkId(c)
+def leaking(c: Cap^): Id[Cap^{c}] = mkId(c)
 
 def test =
   val bad = withCap(leaking)
diff --git a/tests/pos-custom-args/captures/i16116.scala b/tests/pos-custom-args/captures/i16116.scala
index 2f5d5304dca5..0311e744f146 100644
--- a/tests/pos-custom-args/captures/i16116.scala
+++ b/tests/pos-custom-args/captures/i16116.scala
@@ -17,7 +17,7 @@ object Test {
 
   @capability
   class CpsTransform[F[_]] {
-     def await[T](ft: F[T]): { this } T = ???
+     def await[T](ft: F[T]): T^{ this } = ???
   }
 
   transparent inline def cpsAsync[F[_]](using m:CpsMonad[F]) =
@@ -27,7 +27,7 @@ object Test {
       def apply[A](expr: (CpsTransform[F], C) ?=> A): F[A] = ???
   }
 
-  def asyncPlus[F[_]](a:Int, b:F[Int])(using cps: CpsTransform[F]): { cps } Int =
+  def asyncPlus[F[_]](a:Int, b:F[Int])(using cps: CpsTransform[F]): Int^{ cps } =
     a + (cps.await(b).asInstanceOf[Int])
 
   def testExample1Future(): Unit =
diff --git a/tests/pos-custom-args/captures/i16226.scala b/tests/pos-custom-args/captures/i16226.scala
index 8edf3f54d739..4cd7f0ceea81 100644
--- a/tests/pos-custom-args/captures/i16226.scala
+++ b/tests/pos-custom-args/captures/i16226.scala
@@ -1,14 +1,14 @@
 @annotation.capability class Cap
 
 class LazyRef[T](val elem: () => T):
-  val get: {elem} () -> T = elem
-  def map[U](f: T => U): {f, this} LazyRef[U] =
+  val get: () ->{elem} T = elem
+  def map[U](f: T => U): LazyRef[U]^{f, this} =
     new LazyRef(() => f(elem()))
 
-def map[A, B](ref: {*} LazyRef[A], f: A => B): {f, ref} LazyRef[B] =
+def map[A, B](ref: LazyRef[A]^, f: A => B): LazyRef[B]^{f, ref} =
   new LazyRef(() => f(ref.elem()))
 
 def main(io: Cap) = {
-  def mapd[A, B]: ({io} LazyRef[A], A => B) => {*} LazyRef[B] =
+  def mapd[A, B]: (LazyRef[A]^{io}, A => B) => LazyRef[B]^ =
     (ref1, f1) => map[A, B](ref1, f1)
 }
diff --git a/tests/pos-custom-args/captures/iterators.scala b/tests/pos-custom-args/captures/iterators.scala
index 50be2012e25c..10a7f57cd68f 100644
--- a/tests/pos-custom-args/captures/iterators.scala
+++ b/tests/pos-custom-args/captures/iterators.scala
@@ -1,19 +1,19 @@
 package cctest
 
 abstract class Iterator[T]:
-  thisIterator: {*} Iterator[T] =>
+  thisIterator: Iterator[T]^ =>
 
   def hasNext: Boolean
   def next: T
-  def map(f: {*} T => T): {f, this} Iterator[T] = new Iterator:
+  def map(f: T => T): Iterator[T]^{f, this} = new Iterator:
     def hasNext = thisIterator.hasNext
     def next = f(thisIterator.next)
 end Iterator
 
 class C
-type Cap = {*} C
+type Cap = C^
 
-def map[T, U](it: {*} Iterator[T], f: {*} T => U): {it, f} Iterator[U] = new Iterator:
+def map[T, U](it: Iterator[T]^, f: T^ => U): Iterator[U]^{it, f} = new Iterator:
   def hasNext = it.hasNext
   def next = f(it.next)
 
diff --git a/tests/pos-custom-args/captures/lazylists-exceptions.scala b/tests/pos-custom-args/captures/lazylists-exceptions.scala
index 2d4ebb245dca..8f1fba2bf2dc 100644
--- a/tests/pos-custom-args/captures/lazylists-exceptions.scala
+++ b/tests/pos-custom-args/captures/lazylists-exceptions.scala
@@ -4,52 +4,52 @@ import scala.compiletime.uninitialized
 trait LzyList[+A]:
   def isEmpty: Boolean
   def head: A
-  def tail: {this} LzyList[A]
+  def tail: LzyList[A]^{this}
 
 object LzyNil extends LzyList[Nothing]:
   def isEmpty = true
   def head = ???
   def tail = ???
 
-final class LzyCons[+A](hd: A, tl: () => {*} LzyList[A]) extends LzyList[A]:
+final class LzyCons[+A](hd: A, tl: () => LzyList[A]^) extends LzyList[A]:
   private var forced = false
-  private var cache: {this} LzyList[A] = uninitialized
+  private var cache: LzyList[A]^{this} = uninitialized
   private def force =
     if !forced then { cache = tl(); forced = true }
     cache
 
   def isEmpty = false
   def head = hd
-  def tail: {this} LzyList[A] = force
+  def tail: LzyList[A]^{this} = force
 end LzyCons
 
-extension [A](xs: {*} LzyList[A])
-  def map[B](f: A => B): {xs, f} LzyList[B] =
+extension [A](xs: LzyList[A]^)
+  def map[B](f: A => B): LzyList[B]^{xs, f} =
     if xs.isEmpty then LzyNil
     else LzyCons(f(xs.head), () => xs.tail.map(f))
 
-  def filter(p: A => Boolean): {xs, p} LzyList[A] =
+  def filter(p: A => Boolean): LzyList[A]^{xs, p} =
     if xs.isEmpty then LzyNil
     else if p(xs.head) then lazyCons(xs.head, xs.tail.filter(p))
     else xs.tail.filter(p)
 
-  def concat(ys: {*} LzyList[A]): {xs, ys} LzyList[A] =
+  def concat(ys: LzyList[A]^): LzyList[A]^{xs, ys} =
     if xs.isEmpty then ys
     else xs.head #: xs.tail.concat(ys)
 
-  def drop(n: Int): {xs} LzyList[A] =
+  def drop(n: Int): LzyList[A]^{xs} =
     if n == 0 then xs else xs.tail.drop(n - 1)
 end extension
 
 extension [A](x: A)
-  def #:(xs1: => {*} LzyList[A]): {xs1} LzyList[A] =
+  def #:(xs1: => LzyList[A]^): LzyList[A]^{xs1} =
     LzyCons(x, () => xs1)
 
-def lazyCons[A](x: A, xs1: => {*} LzyList[A]): {xs1} LzyList[A] =
+def lazyCons[A](x: A, xs1: => LzyList[A]^): LzyList[A]^{xs1} =
   LzyCons(x, () => xs1)
 
-def tabulate[A](n: Int)(gen: Int => A): {gen} LzyList[A] =
-  def recur(i: Int): {gen} LzyList[A] =
+def tabulate[A](n: Int)(gen: Int => A): LzyList[A]^{gen} =
+  def recur(i: Int): LzyList[A]^{gen} =
     if i == n then LzyNil
     else gen(i) #: recur(i + 1)
   recur(0)
@@ -69,16 +69,16 @@ def test(using cap1: CanThrow[Ex1], cap2: CanThrow[Ex2]) =
     x * x
 
   def x1 = xs.map(f)
-  def x1c: {cap1} LzyList[Int] = x1
+  def x1c: LzyList[Int]^{cap1} = x1
 
   def x2 = x1.concat(xs.map(g).filter(_ > 0))
-  def x2c: {cap1, cap2} LzyList[Int] = x2
+  def x2c: LzyList[Int]^{cap1, cap2} = x2
 
   val x3 = tabulate(10) { i =>
       if i > 9 then throw Ex1()
       i * i
     }
-  val x3c: {cap1} LzyList[Int] = x3
+  val x3c: LzyList[Int]^{cap1} = x3
 
 class LimitExceeded extends Exception
 
diff --git a/tests/pos-custom-args/captures/lazylists-mono.scala b/tests/pos-custom-args/captures/lazylists-mono.scala
index 44ab36ded6a2..d0f88d0de6a3 100644
--- a/tests/pos-custom-args/captures/lazylists-mono.scala
+++ b/tests/pos-custom-args/captures/lazylists-mono.scala
@@ -1,26 +1,26 @@
 class CC
-type Cap = {*} CC
+type Cap = CC^
 
 //-------------------------------------------------
 
 def test(E: Cap) =
 
   trait LazyList[+A]:
-    protected def contents: {E} () -> (A, {E} LazyList[A])
+    protected def contents: () ->{E} (A, {E} LazyList[A])
     def isEmpty: Boolean
     def head: A = contents()._1
     def tail: {E} LazyList[A] = contents()._2
 
-  class LazyCons[+A](override val contents: {E} () -> (A, {E} LazyList[A]))
+  class LazyCons[+A](override val contents: () ->{E} (A, {E} LazyList[A]))
   extends LazyList[A]:
     def isEmpty: Boolean = false
 
   object LazyNil extends LazyList[Nothing]:
-    def contents: {E} () -> (Nothing, LazyList[Nothing]) = ???
+    def contents: () ->{E} (Nothing, LazyList[Nothing]) = ???
     def isEmpty: Boolean = true
 
-  extension [A](xs: {E} LazyList[A])
-    def map[B](f: {E} A -> B): {E} LazyList[B] =
+  extension [A](xs: LazyList[A]^{E})
+    def map[B](f: A ->{E} B): LazyList[B]^{E} =
       if xs.isEmpty then LazyNil
       else
         val cons = () => (f(xs.head), xs.tail.map(f))
diff --git a/tests/pos-custom-args/captures/lazylists.scala b/tests/pos-custom-args/captures/lazylists.scala
index fd130c87cdea..273f21c1fcf3 100644
--- a/tests/pos-custom-args/captures/lazylists.scala
+++ b/tests/pos-custom-args/captures/lazylists.scala
@@ -1,26 +1,26 @@
 class CC
-type Cap = {*} CC
+type Cap = CC^
 
 trait LazyList[+A]:
-  this: {*} LazyList[A] =>
+  this: LazyList[A]^ =>
 
   def isEmpty: Boolean
   def head: A
-  def tail: {this} LazyList[A]
+  def tail: LazyList[A]^{this}
 
 object LazyNil extends LazyList[Nothing]:
   def isEmpty: Boolean = true
   def head = ???
   def tail = ???
 
-extension [A](xs: {*} LazyList[A])
-  def map[B](f: A => B): {xs, f} LazyList[B] =
+extension [A](xs: LazyList[A]^)
+  def map[B](f: A => B): LazyList[B]^{xs, f} =
     final class Mapped extends LazyList[B]:
-      this: {xs, f} Mapped =>
+      this: Mapped^{xs, f} =>
 
       def isEmpty = false
       def head: B = f(xs.head)
-      def tail: {this} LazyList[B] = xs.tail.map(f)  // OK
+      def tail: LazyList[B]^{this} = xs.tail.map(f)  // OK
     if xs.isEmpty then LazyNil
     else new Mapped
 
@@ -30,12 +30,12 @@ def test(cap1: Cap, cap2: Cap) =
 
   val xs =
     class Initial extends LazyList[String]:
-      this: {cap1} Initial =>
+      this: Initial^{cap1} =>
 
       def isEmpty = false
       def head = f("")
       def tail = LazyNil
     new Initial
-  val xsc: {cap1} LazyList[String] = xs
+  val xsc: LazyList[String]^{cap1} = xs
   val ys = xs.map(g)
-  val ysc: {cap1, cap2} LazyList[String] = ys
+  val ysc: LazyList[String]^{cap1, cap2} = ys
diff --git a/tests/pos-custom-args/captures/lazylists1.scala b/tests/pos-custom-args/captures/lazylists1.scala
index a59e7c0da12f..62b34f442221 100644
--- a/tests/pos-custom-args/captures/lazylists1.scala
+++ b/tests/pos-custom-args/captures/lazylists1.scala
@@ -1,28 +1,28 @@
 class CC
-type Cap = {*} CC
+type Cap = CC^
 
 trait LazyList[+A]:
 
   def isEmpty: Boolean
   def head: A
-  def tail: {this} LazyList[A]
-  def concat[B >: A](other: {*} LazyList[B]): {this, other} LazyList[B]
+  def tail: LazyList[A]^{this}
+  def concat[B >: A](other: LazyList[B]^): LazyList[B]^{this, other}
 
 object LazyNil extends LazyList[Nothing]:
   def isEmpty: Boolean = true
   def head = ???
   def tail = ???
-  def concat[B](other: {*} LazyList[B]): {other} LazyList[B] = other
+  def concat[B](other: LazyList[B]^): LazyList[B]^{other} = other
 
-final class LazyCons[+A](x: A)(xs: () => {*} LazyList[A]) extends LazyList[A]:
+final class LazyCons[+A](x: A)(xs: () => LazyList[A]^) extends LazyList[A]:
   def isEmpty = false
   def head = x
-  def tail: {this} LazyList[A] = xs()
-  def concat[B >: A](other: {*} LazyList[B]): {this, other} LazyList[B] =
+  def tail: LazyList[A]^{this} = xs()
+  def concat[B >: A](other: LazyList[B]^): LazyList[B]^{this, other} =
     LazyCons(head)(() => tail.concat(other))
 
-extension [A](xs: {*} LazyList[A])
-  def map[B](f: A => B): {xs, f} LazyList[B] =
+extension [A](xs: LazyList[A]^)
+  def map[B](f: A => B): LazyList[B]^{xs, f} =
     if xs.isEmpty then LazyNil
     else LazyCons(f(xs.head))(() => xs.tail.map(f))
 
@@ -31,9 +31,9 @@ def test(cap1: Cap, cap2: Cap) =
   def g(x: String): String = if cap2 == cap2 then "" else "a"
 
   val xs = new LazyCons("")(() => if f("") == f("") then LazyNil else LazyNil)
-  val xsc: {cap1} LazyList[String] = xs
+  val xsc: LazyList[String]^{cap1} = xs
   val ys = xs.map(g)
-  val ysc: {cap1, cap2} LazyList[String] = ys
+  val ysc: LazyList[String]^{cap1, cap2} = ys
   val zs = new LazyCons("")(() => if g("") == g("") then LazyNil else LazyNil)
   val as = xs.concat(zs)
-  val asc: {xs, zs} LazyList[String] = as
+  val asc: LazyList[String]^{xs, zs} = as
diff --git a/tests/pos-custom-args/captures/lazyref.scala b/tests/pos-custom-args/captures/lazyref.scala
index 0d988dc3e17b..3dae51b491b4 100644
--- a/tests/pos-custom-args/captures/lazyref.scala
+++ b/tests/pos-custom-args/captures/lazyref.scala
@@ -1,24 +1,24 @@
 @annotation.capability class Cap
 
 class LazyRef[T](val elem: () => T):
-  val get: {elem} () -> T = elem
-  def map[U](f: T => U): {f, this} LazyRef[U] =
+  val get: () ->{elem} T = elem
+  def map[U](f: T => U): LazyRef[U]^{f, this} =
     new LazyRef(() => f(elem()))
 
-def map[A, B](ref: {*} LazyRef[A], f: A => B): {f, ref} LazyRef[B] =
+def map[A, B](ref: LazyRef[A]^, f: A => B): LazyRef[B]^{f, ref} =
   new LazyRef(() => f(ref.elem()))
 
-def mapc[A, B]: (ref: {*} LazyRef[A], f: A => B) => {f, ref} LazyRef[B] =
+def mapc[A, B]: (ref: LazyRef[A]^, f: A => B) => LazyRef[B]^{f, ref} =
   (ref1, f1) => map[A, B](ref1, f1)
 
 def test(cap1: Cap, cap2: Cap) =
   def f(x: Int) = if cap1 == cap1 then x else 0
   def g(x: Int) = if cap2 == cap2 then x else 0
   val ref1 = LazyRef(() => f(0))
-  val ref1c: {cap1} LazyRef[Int] = ref1
+  val ref1c: LazyRef[Int]^{cap1} = ref1
   val ref2 = map(ref1, g)
-  val ref2c: {cap2, ref1} LazyRef[Int] = ref2
+  val ref2c: LazyRef[Int]^{cap2, ref1} = ref2
   val ref3 = ref1.map(g)
-  val ref3c: {cap2, ref1} LazyRef[Int] = ref3
+  val ref3c: LazyRef[Int]^{cap2, ref1} = ref3
   val ref4 = (if cap1 == cap2 then ref1 else ref2).map(g)
-  val ref4c: {cap1, cap2} LazyRef[Int] = ref4
+  val ref4c: LazyRef[Int]^{cap1, cap2} = ref4
diff --git a/tests/pos-custom-args/captures/list-encoding.scala b/tests/pos-custom-args/captures/list-encoding.scala
index 87630467023e..d959b523404b 100644
--- a/tests/pos-custom-args/captures/list-encoding.scala
+++ b/tests/pos-custom-args/captures/list-encoding.scala
@@ -7,7 +7,7 @@ type Op[T, C] =
   (v: T) => (s: C) => C
 
 type List[T] =
-  [C] -> (op: Op[T, C]) -> {op} (s: C) -> C
+  [C] -> (op: Op[T, C]) -> (s: C) ->{op} C
 
 def nil[T]: List[T] =
   [C] => (op: Op[T, C]) => (s: C) => s
@@ -15,7 +15,7 @@ def nil[T]: List[T] =
 def cons[T](hd: T, tl: List[T]): List[T] =
   [C] => (op: Op[T, C]) => (s: C) => op(hd)(tl(op)(s))
 
-def foo(c: {*} Cap) =
+def foo(c: Cap^) =
   def f(x: String @retains(c), y: String @retains(c)) =
     cons(x, cons(y, nil))
   def g(x: String @retains(c), y: Any) =
diff --git a/tests/pos-custom-args/captures/lists.scala b/tests/pos-custom-args/captures/lists.scala
index 6389ec933b32..4e76ed3d5e1d 100644
--- a/tests/pos-custom-args/captures/lists.scala
+++ b/tests/pos-custom-args/captures/lists.scala
@@ -2,7 +2,7 @@ abstract class LIST[+T]:
   def isEmpty: Boolean
   def head: T
   def tail: LIST[T]
-  def map[U](f: {*} T -> U): LIST[U] =
+  def map[U](f: T => U): LIST[U] =
     if isEmpty then NIL
     else CONS(f(head), tail.map(f))
 
@@ -28,9 +28,9 @@ def test(c: Cap, d: Cap, e: Cap) =
   val zs =
     val z = g
     CONS(z, ys)
-  val zsc: LIST[{d, y} Cap -> Unit] = zs
+  val zsc: LIST[Cap ->{d, y} Unit] = zs
   val z1 = zs.head
-  val z1c: {y, d} Cap -> Unit = z1
+  val z1c: Cap ->{y, d} Unit = z1
   val ys1 = zs.tail
   val y1 = ys1.head
 
@@ -38,53 +38,53 @@ def test(c: Cap, d: Cap, e: Cap) =
   def m1[A, B] =
     (f: A => B) => (xs: LIST[A]) => xs.map(f)
 
-  def m1c: (f: String => Int) -> {f} LIST[String] -> LIST[Int] = m1[String, Int]
+  def m1c: (f: String => Int) -> LIST[String] ->{f} LIST[Int] = m1[String, Int]
 
   def m2 = [A, B] =>
       (f: A => B) => (xs: LIST[A]) => xs.map(f)
 
-  def m2c: [A, B] -> (f: A => B) -> {f} LIST[A] -> LIST[B] = m2
+  def m2c: [A, B] -> (f: A => B) -> LIST[A] ->{f} LIST[B] = m2
 
   def eff[A](x: A) = if x == e then x else x
 
   val eff2 = [A] => (x: A) => if x == e then x else x
 
-  val a0 = identity[{d, y} Cap -> Unit]
-  val a0c: {d, y} ({d, y} Cap -> Unit) -> {d, y} Cap -> Unit = a0
-  val a1 = zs.map[{d, y} Cap -> Unit](a0)
-  val a1c: LIST[{d, y} Cap -> Unit] = a1
-  val a2 = zs.map[{d, y} Cap -> Unit](identity[{d, y} Cap -> Unit])
-  val a2c: LIST[{d, y} Cap -> Unit] = a2
-  val a3 = zs.map(identity[{d, y} Cap -> Unit])
-  val a3c: LIST[{d, y} Cap -> Unit] = a3
+  val a0 = identity[Cap ->{d, y} Unit]
+  val a0c: (Cap ->{d, y} Unit) ->{d, y} Cap ->{d, y} Unit = a0
+  val a1 = zs.map[Cap ->{d, y} Unit](a0)
+  val a1c: LIST[Cap ->{d, y} Unit] = a1
+  val a2 = zs.map[Cap ->{d, y} Unit](identity[Cap ->{d, y} Unit])
+  val a2c: LIST[Cap ->{d, y} Unit] = a2
+  val a3 = zs.map(identity[Cap ->{d, y} Unit])
+  val a3c: LIST[Cap ->{d, y} Unit] = a3
   val a4 = zs.map(identity)
-  val a4c: LIST[{d, c} Cap -> Unit] = a4
-  val a5 = map[{d, y} Cap -> Unit, {d, y} Cap -> Unit](identity)(zs)
-  val a5c: LIST[{d, c} Cap -> Unit] = a5
-  val a6 = m1[{d, y} Cap -> Unit, {d, y} Cap -> Unit](identity)(zs)
-  val a6c: LIST[{d, c} Cap -> Unit] = a6
+  val a4c: LIST[Cap ->{d, c} Unit] = a4
+  val a5 = map[Cap ->{d, y} Unit, Cap ->{d, y} Unit](identity)(zs)
+  val a5c: LIST[Cap ->{d, c} Unit] = a5
+  val a6 = m1[Cap ->{d, y} Unit, Cap ->{d, y} Unit](identity)(zs)
+  val a6c: LIST[Cap ->{d, c} Unit] = a6
 
-  val b0 = eff[{d, y} Cap -> Unit]
-  val b0c: {e, d, y} ({d, y} Cap -> Unit) -> {d, y} Cap -> Unit = b0
-  val b1 = zs.map[{d, y} Cap -> Unit](a0)
-  val b1c: {e} LIST[{d, y} Cap -> Unit] = b1
-  val b2 = zs.map[{d, y} Cap -> Unit](eff[{d, y} Cap -> Unit])
-  val b2c: {e} LIST[{d, y} Cap -> Unit] = b2
-  val b3 = zs.map(eff[{d, y} Cap -> Unit])
-  val b3c: {e} LIST[{d, y} Cap -> Unit] = b3
+  val b0 = eff[Cap ->{d, y} Unit]
+  val b0c: (Cap ->{d, y} Unit) ->{e, d, y} Cap ->{d, y} Unit = b0
+  val b1 = zs.map[Cap ->{d, y} Unit](a0)
+  val b1c: LIST[Cap ->{d, y} Unit]^{e} = b1
+  val b2 = zs.map[Cap ->{d, y} Unit](eff[Cap ->{d, y} Unit])
+  val b2c: LIST[Cap ->{d, y} Unit]^{e} = b2
+  val b3 = zs.map(eff[Cap ->{d, y} Unit])
+  val b3c: LIST[Cap ->{d, y} Unit]^{e} = b3
   val b4 = zs.map(eff)
-  val b4c: {e} LIST[{d, c} Cap -> Unit] = b4
+  val b4c: LIST[{d, c} Cap -> Unit]^{e} = b4
   val b5 = map[{d, y} Cap -> Unit, {d, y} Cap -> Unit](eff)(zs)
-  val b5c: {e} LIST[{d, c} Cap -> Unit] = b5
+  val b5c: LIST[{d, c} Cap -> Unit]^{e} = b5
   val b6 = m1[{d, y} Cap -> Unit, {d, y} Cap -> Unit](eff)(zs)
-  val b6c: {e} LIST[{d, c} Cap -> Unit] = b6
+  val b6c: LIST[{d, c} Cap -> Unit]^{e} = b6
 
   val c0 = eff2[{d, y} Cap -> Unit]
-  val c0c: {e, d, y} ({d, y} Cap -> Unit) -> {d, y} Cap -> Unit = c0
-  val c1 = zs.map[{d, y} Cap -> Unit](a0)
-  val c1c: {e} LIST[{d, y} Cap -> Unit] = c1
-  val c2 = zs.map[{d, y} Cap -> Unit](eff2[{d, y} Cap -> Unit])
-  val c2c: {e} LIST[{d, y} Cap -> Unit] = c2
-  val c3 = zs.map(eff2[{d, y} Cap -> Unit])
-  val c3c: {e} LIST[{d, y} Cap -> Unit] = c3
+  val c0c: ({d, y} Cap -> Unit) ->{e, d, y}  Cap ->{d, y} Unit = c0
+  val c1 = zs.map[Cap ->{d, y} Unit](a0)
+  val c1c: LIST[{d, y} Cap -> Unit]^{e} = c1
+  val c2 = zs.map[Cap ->{d, y} Unit](eff2[Cap ->{d, y} Unit])
+  val c2c: LIST[{d, y} Cap -> Unit]^{e} = c2
+  val c3 = zs.map(eff2[Cap ->{d, y} Unit])
+  val c3c: LIST[Cap ->{d, y} Unit]^{e} = c3
 
diff --git a/tests/pos-custom-args/captures/logger.scala b/tests/pos-custom-args/captures/logger.scala
index e5b6c834ffe0..3f417da8c1be 100644
--- a/tests/pos-custom-args/captures/logger.scala
+++ b/tests/pos-custom-args/captures/logger.scala
@@ -7,9 +7,9 @@ class Logger(using fs: FileSystem):
   def log(s: String): Unit = ???
 
 def test(using fs: FileSystem) =
-  val l: {fs} Logger = Logger(using fs)
+  val l: Logger^{fs} = Logger(using fs)
   l.log("hello world!")
-  val xs: {l} LazyList[Int] =
+  val xs: LazyList[Int]^{l} =
     LazyList.from(1)
       .map { i =>
         l.log(s"computing elem # $i")
@@ -19,25 +19,25 @@ def test(using fs: FileSystem) =
 trait LazyList[+A]:
   def isEmpty: Boolean
   def head: A
-  def tail: {this} LazyList[A]
+  def tail: LazyList[A]^{this}
 
 object LazyNil extends LazyList[Nothing]:
   def isEmpty: Boolean = true
   def head = ???
   def tail = ???
 
-final class LazyCons[+T](val x: T, val xs: () => {*} LazyList[T]) extends LazyList[T]:
+final class LazyCons[+T](val x: T, val xs: () => LazyList[T]^) extends LazyList[T]:
   def isEmpty = false
   def head = x
-  def tail: {this} LazyList[T] = xs()
+  def tail: LazyList[T]^{this} = xs()
 end LazyCons
 
 extension [A](x: A)
-  def #::(xs1: => {*} LazyList[A]): {xs1} LazyList[A] =
+  def #::(xs1: => LazyList[A]^): LazyList[A]^{xs1} =
     LazyCons(x, () => xs1)
 
-extension [A](xs: {*} LazyList[A])
-  def map[B](f: A => B): {xs, f} LazyList[B] =
+extension [A](xs: LazyList[A]^)
+  def map[B](f: A => B): LazyList[B]^{xs, f} =
     if xs.isEmpty then LazyNil
     else f(xs.head) #:: xs.tail.map(f)
 
@@ -50,17 +50,17 @@ class Pair[+A, +B](x: A, y: B):
   def snd: B = y
 
 def test2(ct: CanThrow[Exception], fs: FileSystem) =
-  def x: {ct} Int -> String = ???
-  def y: {fs} Logger = ???
+  def x: Int ->{ct} String = ???
+  def y: Logger^{fs} = ???
   def p = Pair(x, y)
   def f = () => p.fst
 
 
 /*
-  val l1: {*} Int -> String = ???
-  val l2: {c} Object = ???
+  val l1: Int => String = ???
+  val l2: Object^{c} = ???
   val pd = () => Pair(l1, l2)
-  val p2: Pair[{*} Int -> String, {c} Object] = pd()
+  val p2: Pair[Int => String, Object]^{c} = pd()
   val hd = () => p2.fst
 
 */
\ No newline at end of file
diff --git a/tests/pos-custom-args/captures/nonvariant-inf.scala b/tests/pos-custom-args/captures/nonvariant-inf.scala
index 6569f35042e8..4798f98c9fce 100644
--- a/tests/pos-custom-args/captures/nonvariant-inf.scala
+++ b/tests/pos-custom-args/captures/nonvariant-inf.scala
@@ -3,7 +3,7 @@ trait Iterable[+A]
 
 /** Base trait for instances that can construct a collection from an iterable */
 trait FromIterable {
-  type C[X] <: {*} Iterable[X]
-  def fromIterable[B](it: {*} Iterable[B]): {it} C[B]
+  type C[X] <: Iterable[X]^
+  def fromIterable[B](it: Iterable[B]^): C[B]^{it}
   def empty[A]: C[A] = fromIterable(??? : Iterable[A])
 }
diff --git a/tests/pos-custom-args/captures/override-adapt-box-pos-alt.scala b/tests/pos-custom-args/captures/override-adapt-box-pos-alt.scala
index c7e4d38723d7..bb6b4030dbff 100644
--- a/tests/pos-custom-args/captures/override-adapt-box-pos-alt.scala
+++ b/tests/pos-custom-args/captures/override-adapt-box-pos-alt.scala
@@ -9,9 +9,9 @@ abstract class A[X] {
 
 class C
 
-def test(io: {*} IO) = {
-  class B extends A[{io} C] {  // X =:= {io} C
-    def foo(x: Unit): {io} C = ???
-    def bar(op: ({io} C) => Int): Int = 0
+def test(io: IO^) = {
+  class B extends A[C^{io}] {  // X =:= {io} C
+    def foo(x: Unit): C^{io} = ???
+    def bar(op: (C^{io}) => Int): Int = 0
   }
 }
diff --git a/tests/pos-custom-args/captures/override-adapt-box-pos.scala b/tests/pos-custom-args/captures/override-adapt-box-pos.scala
index 7496a138070d..9adaec6896cf 100644
--- a/tests/pos-custom-args/captures/override-adapt-box-pos.scala
+++ b/tests/pos-custom-args/captures/override-adapt-box-pos.scala
@@ -4,16 +4,16 @@ class IO
 
 abstract class A[X, Y] {
   def foo(x: Unit): X
-  def bar(x: Int, y: {} IO): X
+  def bar(x: Int, y: IO^{}): X
   def baz(x: Y): X
 }
 
 class C
 
-def test(io: {*} IO) = {
-  class B extends A[{io} C, {} C] {  // X =:= {io} C
-    override def foo(x: Unit): {io} C = ???
-    override def bar(x: Int, y: {} IO): {io} C = ???
-    override def baz(x: {} C): {io} C = ???
+def test(io: IO^) = {
+  class B extends A[C^{io}, C^{}] {  // X =:= {io} C
+    override def foo(x: Unit): C^{io} = ???
+    override def bar(x: Int, y: IO^{}): C^{io} = ???
+    override def baz(x: C^{}): C^{io} = ???
   }
 }
diff --git a/tests/pos-custom-args/captures/pairs.scala b/tests/pos-custom-args/captures/pairs.scala
index 9c8ec003d28d..bc20d20ffd92 100644
--- a/tests/pos-custom-args/captures/pairs.scala
+++ b/tests/pos-custom-args/captures/pairs.scala
@@ -12,21 +12,21 @@ object Generic:
     def g(x: Cap): Unit = if d == x then ()
     val p = Pair(f, g)
     val x1 = p.fst
-    val x1c: {c} Cap -> Unit = x1
+    val x1c: Cap ->{c} Unit = x1
     val y1 = p.snd
-    val y1c: {d} Cap -> Unit = y1
+    val y1c: Cap ->{d} Unit = y1
 
 object Monomorphic:
 
-  class Pair(x: Cap => Unit, y: {*} Cap -> Unit):
-    def fst: {x} Cap -> Unit = x
-    def snd: {y} Cap -> Unit = y
+  class Pair(x: Cap => Unit, y: Cap => Unit):
+    def fst: Cap ->{x} Unit = x
+    def snd: Cap ->{y} Unit = y
 
   def test(c: Cap, d: Cap) =
     def f(x: Cap): Unit = if c == x then ()
     def g(x: Cap): Unit = if d == x then ()
     val p = Pair(f, g)
     val x1 = p.fst
-    val x1c: {c} Cap -> Unit = x1
+    val x1c: Cap ->{c} Unit = x1
     val y1 = p.snd
-    val y1c: {d} Cap -> Unit = y1
+    val y1c: Cap ->{d} Unit = y1
diff --git a/tests/pos-custom-args/captures/selftype-alias.scala b/tests/pos-custom-args/captures/selftype-alias.scala
index 284691131c7b..180c7b27b146 100644
--- a/tests/pos-custom-args/captures/selftype-alias.scala
+++ b/tests/pos-custom-args/captures/selftype-alias.scala
@@ -4,6 +4,5 @@ type AnyIterableOnce[A] = IterableOnce[A]^
 
 /** Iterator can be used only once */
 trait IterableOnce[+A]:
-  //this: IterableOnce[A]{ref any} =>
   this: AnyIterableOnce[A] =>
   def iterator: Iterator[A]^{this}
diff --git a/tests/pos-custom-args/captures/stack-alloc.scala b/tests/pos-custom-args/captures/stack-alloc.scala
index 03b6708a3119..7013f978c281 100644
--- a/tests/pos-custom-args/captures/stack-alloc.scala
+++ b/tests/pos-custom-args/captures/stack-alloc.scala
@@ -5,7 +5,7 @@ class Pooled
 val stack = mutable.ArrayBuffer[Pooled]()
 var nextFree = 0
 
-def withFreshPooled[T](op: ({*} Pooled) => T): T =
+def withFreshPooled[T](op: Pooled^ => T): T =
   if nextFree >= stack.size then stack.append(new Pooled)
   val pooled = stack(nextFree)
   nextFree = nextFree + 1
diff --git a/tests/pos-custom-args/captures/vars.scala b/tests/pos-custom-args/captures/vars.scala
index 12721158a2bb..ccf2cd587eb1 100644
--- a/tests/pos-custom-args/captures/vars.scala
+++ b/tests/pos-custom-args/captures/vars.scala
@@ -5,13 +5,13 @@ def test(cap1: Cap, cap2: Cap) =
   var x = f
   val y = x
   val z = () => if x("") == "" then "a" else "b"
-  val zc: {cap1} () -> String = z
+  val zc: () ->{cap1} String = z
   val z2 = () => { x = identity }
-  val z2c: {cap1} () -> Unit = z2
+  val z2c: () ->{cap1} Unit = z2
 
   class Ref:
-    var elem: {cap1} String -> String = null
+    var elem: String ->{cap1} String = null
 
   val r = Ref()
   r.elem = f
-  val fc: {cap1} String -> String = r.elem
+  val fc: String ->{cap1} String = r.elem

From 057bd73c79b2b1a6d5899f2cd013e0ce78c67b2c Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sun, 30 Apr 2023 19:46:54 +0200
Subject: [PATCH 525/657] Change to new syntax in run-custom-args

And fine tune distinction of ^ as postfix or infix operator
---
 compiler/src/dotty/tools/dotc/parsing/Parsers.scala        | 7 ++++---
 tests/pos-custom-args/captures/trickyTrailingUpArrow.scala | 6 ++++++
 tests/run-custom-args/captures/minicheck.scala             | 6 +++---
 3 files changed, 13 insertions(+), 6 deletions(-)
 create mode 100644 tests/pos-custom-args/captures/trickyTrailingUpArrow.scala

diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 06a8d99bbd1c..c8d2ed0e6457 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -1711,10 +1711,11 @@ object Parsers {
         })
       else if in.isIdent(nme.UPARROW)
           && (in.lookahead.token == LBRACE
-              || !canStartInfixTypeTokens.contains(in.lookahead.token))
+              || !canStartInfixTypeTokens.contains(in.lookahead.token)
+              || in.lookahead.lineOffset > 0)
         // Disambiguation: a `^` is treated as a postfix operator meaning `^{any}`
-        // if followed by `{` or newline, or any other token that cannot start
-        // an infix type. Otherwise it is treated as an infix operator.
+        // if followed by `{` or a new line (significant or not), or a token that
+        // cannot start an infix type. Otherwise it is treated as an infix operator.
       then
         val upArrowStart = in.offset
         in.nextToken()
diff --git a/tests/pos-custom-args/captures/trickyTrailingUpArrow.scala b/tests/pos-custom-args/captures/trickyTrailingUpArrow.scala
new file mode 100644
index 000000000000..e9d1f50848c0
--- /dev/null
+++ b/tests/pos-custom-args/captures/trickyTrailingUpArrow.scala
@@ -0,0 +1,6 @@
+object Test:
+  var x = 0
+  type FreshContext = String^
+  x += 1
+
+  inline def ctx(using c: String) = c
diff --git a/tests/run-custom-args/captures/minicheck.scala b/tests/run-custom-args/captures/minicheck.scala
index 344e021493e5..bdc591580482 100644
--- a/tests/run-custom-args/captures/minicheck.scala
+++ b/tests/run-custom-args/captures/minicheck.scala
@@ -83,7 +83,7 @@ abstract class Ctx:
   def run: Run
   def detached: DetachedContext
 
-type Context = {*} Ctx
+type Context = Ctx^
 
 abstract class DetachedContext extends Ctx:
   def outer: DetachedContext
@@ -110,9 +110,9 @@ object NoContext extends FreshCtx(-1):
   owner = NoSymbol
   scope = EmptyScope
 
-type FreshContext = {*} FreshCtx
+type FreshContext = FreshCtx^
 
-inline def ctx(using c: Context): {c} Ctx = c
+inline def ctx(using c: Context): Ctx^{c} = c
 
 // !cc! it does not work if ctxStack is an Array[FreshContext] instead.
 var ctxStack = Array.tabulate(16)(new FreshCtx(_))

From 14155320891da1cac09b31382294bbb56a393941 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Mon, 1 May 2023 10:08:46 +0200
Subject: [PATCH 526/657] Futher fix in trailing uparrow detection

Recognize as trailing in front of `->` or `?->`
---
 .../dotty/tools/dotc/parsing/Parsers.scala    | 23 ++++++++++++-------
 1 file changed, 15 insertions(+), 8 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index c8d2ed0e6457..13fa1d1beba8 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -1703,20 +1703,27 @@ object Parsers {
 
     def refinedType() = refinedTypeRest(withType())
 
+    /** Disambiguation: a `^` is treated as a postfix operator meaning `^{any}`
+     *  if followed by `{`, `->`, or `?->`,
+     *  or followed by a new line (significant or not),
+     *  or followed by a token that cannot start an infix type.
+     *  Otherwise it is treated as an infix operator.
+     */
+    private def isTrailingUpArrow =
+      val ahead = in.lookahead
+      ahead.token == LBRACE
+      || ahead.isIdent(nme.PUREARROW)
+      || ahead.isIdent(nme.PURECTXARROW)
+      || !canStartInfixTypeTokens.contains(ahead.token)
+      || ahead.lineOffset > 0
+
     def refinedTypeRest(t: Tree): Tree = {
       argumentStart()
       if in.isNestedStart then
         refinedTypeRest(atSpan(startOffset(t)) {
           RefinedTypeTree(rejectWildcardType(t), refinement(indentOK = true))
         })
-      else if in.isIdent(nme.UPARROW)
-          && (in.lookahead.token == LBRACE
-              || !canStartInfixTypeTokens.contains(in.lookahead.token)
-              || in.lookahead.lineOffset > 0)
-        // Disambiguation: a `^` is treated as a postfix operator meaning `^{any}`
-        // if followed by `{` or a new line (significant or not), or a token that
-        // cannot start an infix type. Otherwise it is treated as an infix operator.
-      then
+      else if in.isIdent(nme.UPARROW) && isTrailingUpArrow then
         val upArrowStart = in.offset
         in.nextToken()
         def cs =

From 9127445c8885b3acbf759c37c15e159a239da75b Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Mon, 1 May 2023 10:09:13 +0200
Subject: [PATCH 527/657] Disallow old syntax for captures

---
 .../dotty/tools/dotc/parsing/Parsers.scala    | 63 +++----------------
 tests/neg-custom-args/capt-wf.scala           | 28 ++++-----
 .../captures/boundschecks.scala               |  8 +--
 .../captures/boundschecks2.scala              |  6 +-
 .../captures/box-adapt-boxing.scala           | 22 +++----
 .../captures/box-adapt-cases.scala            | 18 +++---
 .../captures/box-adapt-cov.scala              | 16 ++---
 .../captures/box-adapt-cs.scala               | 18 +++---
 .../captures/box-adapt-depfun.scala           | 18 +++---
 .../captures/box-adapt-typefun.scala          | 12 ++--
 .../captures/capt-depfun.scala                |  2 +-
 tests/neg-custom-args/captures/capt-env.scala |  2 +-
 .../captures/capt-wf-typer.scala              |  4 +-
 tests/neg-custom-args/captures/capt-wf2.scala |  4 +-
 tests/neg-custom-args/captures/capt2.scala    |  6 +-
 .../captures/caseclass/Test_2.scala           |  8 +--
 .../neg-custom-args/captures/cc-depfun.scala  |  4 +-
 tests/neg-custom-args/captures/cc-this2.check |  2 +-
 .../captures/cc-this2/D_2.scala               |  2 +-
 .../captures/class-constr.scala               | 14 ++---
 tests/neg-custom-args/captures/classes.scala  |  6 +-
 tests/neg-custom-args/captures/ctest.scala    |  2 +-
 .../captures/emptyref-in-self.scala           |  4 +-
 tests/neg-custom-args/captures/filevar.scala  |  4 +-
 .../captures/heal-tparam-cs.scala             | 20 +++---
 tests/neg-custom-args/captures/i15049.scala   |  6 +-
 tests/neg-custom-args/captures/i15749.scala   |  6 +-
 tests/neg-custom-args/captures/i15749a.scala  | 14 ++---
 tests/neg-custom-args/captures/i15921.scala   |  2 +-
 .../captures/i15923-cases.scala               |  6 +-
 tests/neg-custom-args/captures/i15923.scala   |  4 +-
 tests/neg-custom-args/captures/i16114.scala   | 32 +++++-----
 .../neg-custom-args/captures/impurefuns.scala |  3 +
 .../captures/inner-classes.scala              |  8 +--
 tests/neg-custom-args/captures/lazyref.scala  |  2 +-
 .../override-adapt-box-selftype.scala         | 36 +++++------
 .../captures/override-adapt-box.scala         |  8 +--
 .../captures/override-boxed.scala             |  7 ++-
 .../captures/stack-alloc.scala                |  2 +-
 tests/neg-custom-args/captures/try3.scala     |  4 +-
 tests/neg-custom-args/captures/unbox.scala    |  2 +-
 tests/pending/neg/cc-depfun.scala             | 14 +++++
 .../captures/lazylists-mono.scala             |  6 +-
 tests/pos-custom-args/captures/lists.scala    | 18 +++---
 .../captures/trickyTrailingUpArrow.scala      |  3 +
 .../dotc/transform/TreeMapWithStages.scala    |  2 +-
 tests/pos/boxmap-paper.scala                  | 16 ++---
 47 files changed, 232 insertions(+), 262 deletions(-)
 create mode 100644 tests/neg-custom-args/captures/impurefuns.scala
 create mode 100644 tests/pending/neg/cc-depfun.scala

diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 13fa1d1beba8..5c306302361b 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -970,29 +970,6 @@ object Parsers {
         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
@@ -1504,9 +1481,12 @@ object Parsers {
         val paramSpan = Span(start, in.lastOffset)
         atSpan(start, in.offset) {
           var token = in.token
+          var isPure = false
           if isPureArrow(nme.PUREARROW) then
+            isPure = true
             token = ARROW
           else if isPureArrow(nme.PURECTXARROW) then
+            isPure = true
             token = CTXARROW
           else if token == TLARROW then
             if !imods.flags.isEmpty || params.isEmpty then
@@ -1525,7 +1505,7 @@ object Parsers {
           else
             accept(ARROW)
 
-          val resultType = capturesAndResult(typ)
+          val resultType = if isPure then capturesAndResult(typ) else typ()
           if token == TLARROW then
             for case ValDef(_, tpt, _) <- params do
               if isByNameType(tpt) then
@@ -1618,8 +1598,6 @@ object Parsers {
           }
           else { accept(TLARROW); typ() }
         }
-        else if in.token == LBRACE && followingIsCaptureSet() then
-          CapturingTypeTree(captureSet(), typ())
         else if (in.token == INDENT) enclosed(INDENT, typ())
         else infixType()
 
@@ -1958,31 +1936,9 @@ object Parsers {
     def paramTypeOf(core: () => Tree): Tree =
       if in.token == ARROW || isPureArrow(nme.PUREARROW) then
         val isImpure = in.token == ARROW
-        val tp = atSpan(in.skipToken()) { ByNameTypeTree(capturesAndResult(core)) }
+        val tp = atSpan(in.skipToken()):
+          ByNameTypeTree(if isImpure then core() else capturesAndResult(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()
 
@@ -2069,8 +2025,6 @@ object Parsers {
     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 ------------------------------------------------ */
@@ -4218,10 +4172,7 @@ object Parsers {
           val selfTpt =
             if in.isColon then
               in.nextToken()
-              if in.token == LBRACE && followingIsCaptureSet() then
-                CapturingTypeTree(captureSet(), infixType())
-              else
-                infixType()
+              infixType()
             else
               if selfName == nme.WILDCARD then accept(COLONfollow)
               TypeTree()
diff --git a/tests/neg-custom-args/capt-wf.scala b/tests/neg-custom-args/capt-wf.scala
index 3bd80e0d0f68..fe883af0ba8e 100644
--- a/tests/neg-custom-args/capt-wf.scala
+++ b/tests/neg-custom-args/capt-wf.scala
@@ -1,35 +1,35 @@
 class C
-type Cap = {*} C
+type Cap = C^
 
 object foo
 
 def test(c: Cap, other: String): Unit =
-  val x1: {*} C = ??? // OK
-  val x2: {other} C = ??? // error: cs is empty
+  val x1: C^ = ??? // OK
+  val x2: C^{other} = ??? // error: cs is empty
   val s1 = () => "abc"
-  val x3: {s1} C = ??? // error: cs is empty
+  val x3: C^{s1} = ??? // error: cs is empty
   val x3a: () -> String = s1
   val s2 = () => if x1 == null then "" else "abc"
-  val x4: {s2} C = ??? // OK
-  val x5: {c, c} C = ??? // error: redundant
-  val x6: {c} {c} C = ??? // error: redundant
-  val x7: {c} Cap = ??? // error: redundant
-  val x8: {*} {c} C = ??? // OK
-  val x9: {c, *} C = ??? // error: redundant
-  val x10: {*, c} C = ??? // error: redundant
+  val x4: C^{s2} = ??? // OK
+  val x5: C^{c, c} = ??? // error: redundant
+  // val x6: C^{c}^{c} = ??? // would be syntax error
+  val x7: Cap^{c} = ??? // error: redundant
+  // val x8: C^{c}^{*} = ??? // would be syntax error
+  val x9: C^{c, *}  = ??? // error: redundant
+  val x10: C^{*, c} = ??? // error: redundant
 
   def even(n: Int): Boolean = if n == 0 then true else odd(n - 1)
   def odd(n: Int): Boolean = if n == 1 then true else even(n - 1)
   val e1 = even
   val o1 = odd
 
-  val y1: {e1} String = ??? // error cs is empty
-  val y2: {o1} String = ??? // error cs is empty
+  val y1: String^{e1} = ??? // error cs is empty
+  val y2: String^{o1} = ??? // error cs is empty
 
   lazy val ev: (Int -> Boolean) = (n: Int) =>
     lazy val od: (Int -> Boolean) = (n: Int) =>
       if n == 1 then true else ev(n - 1)
     if n == 0 then true else od(n - 1)
-  val y3: {ev} String = ??? // error cs is empty
+  val y3: String^{ev} = ??? // error cs is empty
 
   ()
\ No newline at end of file
diff --git a/tests/neg-custom-args/captures/boundschecks.scala b/tests/neg-custom-args/captures/boundschecks.scala
index cf4eab28f19d..766d89d2f37b 100644
--- a/tests/neg-custom-args/captures/boundschecks.scala
+++ b/tests/neg-custom-args/captures/boundschecks.scala
@@ -6,13 +6,13 @@ object test {
 
   class C[X <: Tree](x: X)
 
-  def foo(t: {*} Tree) =
+  def foo(t: Tree^) =
     f(t) // error
-    f[{*} Tree](t) // error
+    f[Tree^](t) // error
     f[Tree](t)  // error
     val c1 = C(t) // error
-    val c2 = C[{*} Tree](t) // error
+    val c2 = C[Tree^](t) // error
     val c3 = C[Tree](t)  // error
 
-    val foo: C[{*} Tree] = ???
+    val foo: C[Tree^] = ???
 }
diff --git a/tests/neg-custom-args/captures/boundschecks2.scala b/tests/neg-custom-args/captures/boundschecks2.scala
index f6927b04931b..923758d722f9 100644
--- a/tests/neg-custom-args/captures/boundschecks2.scala
+++ b/tests/neg-custom-args/captures/boundschecks2.scala
@@ -6,8 +6,8 @@ object test {
 
   class C[X <: Tree](x: X)
 
-  val foo: C[{*} Tree] = ??? // error
-  type T = C[{*} Tree] // error
+  val foo: C[Tree^] = ??? // error
+  type T = C[Tree^] // error
   val bar: T -> T = ???
-  val baz: C[{*} Tree] -> Unit = ??? // error
+  val baz: C[Tree^] -> Unit = ??? // error
 }
diff --git a/tests/neg-custom-args/captures/box-adapt-boxing.scala b/tests/neg-custom-args/captures/box-adapt-boxing.scala
index 7a624d4225fc..ea133051a21a 100644
--- a/tests/neg-custom-args/captures/box-adapt-boxing.scala
+++ b/tests/neg-custom-args/captures/box-adapt-boxing.scala
@@ -1,23 +1,23 @@
 trait Cap
 
-def main(io: {*} Cap, fs: {*} Cap): Unit = {
-  val test1: {} Unit -> Unit = _ => { // error
-    type Op = [T] -> ({io} T -> Unit) -> Unit
-    val f: ({io} Cap) -> Unit = ???
+def main(io: Cap^, fs: Cap^): Unit = {
+  val test1: Unit -> Unit = _ => { // error
+    type Op = [T] -> (T ->{io} Unit) -> Unit
+    val f: (Cap^{io}) -> Unit = ???
     val op: Op = ???
-    op[{io} Cap](f)
+    op[Cap^{io}](f)
     // expected type of f: {io} (box {io} Cap) -> Unit
     // actual type: ({io} Cap) -> Unit
     // adapting f to the expected type will also
     //   charge the environment with {io}
   }
 
-  val test2: {} Unit -> Unit = _ => {
+  val test2: Unit -> Unit = _ => {
     type Box[X] = X
     type Op0[X] = Box[X] -> Unit
     type Op1[X] = Unit -> Box[X]
-    val f: Unit -> ({io} Cap) -> Unit = ???
-    val test: {} Op1[{io} Op0[{io} Cap]] = f
+    val f: Unit -> (Cap^{io}) -> Unit = ???
+    val test: Op1[Op0[Cap^{io}]^{io}]^{} = f
     // expected: {} Unit -> box {io} (box {io} Cap) -> Unit
     // actual: Unit -> ({io} Cap) -> Unit
     //
@@ -31,8 +31,8 @@ def main(io: {*} Cap, fs: {*} Cap): Unit = {
     type Box[X] = X
     type Id[X] = Box[X] -> Unit
     type Op[X] = Unit -> Box[X]
-    val f: Unit -> ({io} Cap) -> Unit = ???
-    val g: Op[{fs} Id[{io} Cap]] = f // error
-    val h: {} Op[{io} Id[{io} Cap]] = f
+    val f: Unit -> (Cap^{io}) -> Unit = ???
+    val g: Op[Id[Cap^{io}]^{fs}] = f // error
+    val h: Op[Id[Cap^{io}]^{io}] = f
   }
 }
diff --git a/tests/neg-custom-args/captures/box-adapt-cases.scala b/tests/neg-custom-args/captures/box-adapt-cases.scala
index 049ff385d73c..faaf256e470b 100644
--- a/tests/neg-custom-args/captures/box-adapt-cases.scala
+++ b/tests/neg-custom-args/captures/box-adapt-cases.scala
@@ -3,27 +3,27 @@ trait Cap { def use(): Int }
 def test1(): Unit = {
   type Id[X] = [T] -> (op: X => T) -> T
 
-  val x: Id[{*} Cap] = ???
+  val x: Id[Cap^] = ???
   x(cap => cap.use())  // error
 }
 
-def test2(io: {*} Cap): Unit = {
+def test2(io: Cap^{*}): Unit = {
   type Id[X] = [T] -> (op: X -> T) -> T
 
-  val x: Id[{io} Cap] = ???
+  val x: Id[Cap^{io}] = ???
   x(cap => cap.use())  // error
 }
 
-def test3(io: {*} Cap): Unit = {
-  type Id[X] = [T] -> (op: {io} X -> T) -> T
+def test3(io: Cap^{*}): Unit = {
+  type Id[X] = [T] -> (op: X ->{io} T) -> T
 
-  val x: Id[{io} Cap] = ???
+  val x: Id[Cap^{io}] = ???
   x(cap => cap.use())  // ok
 }
 
-def test4(io: {*} Cap, fs: {*} Cap): Unit = {
-  type Id[X] = [T] -> (op: {io} X -> T) -> T
+def test4(io: Cap^{*}, fs: Cap^{*}): Unit = {
+  type Id[X] = [T] -> (op: X ->{io} T) -> T
 
-  val x: Id[{io, fs} Cap] = ???
+  val x: Id[Cap^{io, fs}] = ???
   x(cap => cap.use())  // error
 }
diff --git a/tests/neg-custom-args/captures/box-adapt-cov.scala b/tests/neg-custom-args/captures/box-adapt-cov.scala
index 2040a1c4654d..ebdb68cf0ca4 100644
--- a/tests/neg-custom-args/captures/box-adapt-cov.scala
+++ b/tests/neg-custom-args/captures/box-adapt-cov.scala
@@ -1,14 +1,14 @@
 trait Cap
 
-def test1(io: {*} Cap) = {
+def test1(io: Cap^{*}) = {
   type Op[X] = [T] -> Unit -> X
-  val f: Op[{io} Cap] = ???
-  val x: [T] -> Unit -> ({io} Cap) = f  // error
+  val f: Op[Cap^{io}] = ???
+  val x: [T] -> Unit -> Cap^{io} = f  // error
 }
 
-def test2(io: {*} Cap) = {
-  type Op[X] = [T] -> Unit -> {io} X
-  val f: Op[{io} Cap] = ???
-  val x: Unit -> ({io} Cap) = f[Unit]  // error
-  val x1: {io} Unit -> ({io} Cap) = f[Unit]  // ok
+def test2(io: Cap^{*}) = {
+  type Op[X] = [T] -> Unit -> X^{io}
+  val f: Op[Cap^{io}] = ???
+  val x: Unit -> Cap^{io} = f[Unit]  // error
+  val x1: Unit ->{io} Cap^{io} = f[Unit]  // ok
 }
diff --git a/tests/neg-custom-args/captures/box-adapt-cs.scala b/tests/neg-custom-args/captures/box-adapt-cs.scala
index e35388efd203..a5344d52c30f 100644
--- a/tests/neg-custom-args/captures/box-adapt-cs.scala
+++ b/tests/neg-custom-args/captures/box-adapt-cs.scala
@@ -1,19 +1,17 @@
 trait Cap { def use(): Int }
 
-def test1(io: {*} Cap): Unit = {
-  type Id[X] = [T] -> (op: {io} X -> T) -> T
+def test1(io: Cap^{*}): Unit = {
+  type Id[X] = [T] -> (op: X ->{io} T) -> T
 
-  val x: Id[{io} Cap] = ???
-  val f: ({*} Cap) -> Unit = ???
+  val x: Id[Cap^{io}] = ???
+  val f: (Cap^{*}) -> Unit = ???
   x(f)  // ok
-  // actual: {*} Cap -> Unit
-  // expected: {io} box {io} Cap -> Unit
 }
 
-def test2(io: {*} Cap): Unit = {
-  type Id[X] = [T] -> (op: {*} X -> T) -> T
+def test2(io: Cap^{*}): Unit = {
+  type Id[X] = [T] -> (op: X => T) -> T
 
-  val x: Id[{*} Cap] = ???
-  val f: ({io} Cap) -> Unit = ???
+  val x: Id[Cap^] = ???
+  val f: Cap^{io} -> Unit = ???
   x(f)  // error
 }
diff --git a/tests/neg-custom-args/captures/box-adapt-depfun.scala b/tests/neg-custom-args/captures/box-adapt-depfun.scala
index 294e2c33f7fa..357cfb4a8d9d 100644
--- a/tests/neg-custom-args/captures/box-adapt-depfun.scala
+++ b/tests/neg-custom-args/captures/box-adapt-depfun.scala
@@ -1,23 +1,23 @@
 trait Cap { def use(): Int }
 
-def test1(io: {*} Cap): Unit = {
-  type Id[X] = [T] -> (op: {io} X -> T) -> T
+def test1(io: Cap^): Unit = {
+  type Id[X] = [T] -> (op: X ->{io} T) -> T
 
-  val x: Id[{io} Cap] = ???
+  val x: Id[Cap]^{io} = ???
   x(cap => cap.use())  // ok
 }
 
-def test2(io: {*} Cap): Unit = {
-  type Id[X] = [T] -> (op: {io} (x: X) -> T) -> T
+def test2(io: Cap^): Unit = {
+  type Id[X] = [T] -> (op: (x: X) ->{io} T) -> T
 
-  val x: Id[{io} Cap] = ???
+  val x: Id[Cap^{io}] = ???
   x(cap => cap.use())
   // should work when the expected type is a dependent function
 }
 
-def test3(io: {*} Cap): Unit = {
-  type Id[X] = [T] -> (op: {} (x: X) -> T) -> T
+def test3(io: Cap^{*}): Unit = {
+  type Id[X] = [T] -> (op: (x: X) ->{} T) -> T
 
-  val x: Id[{io} Cap] = ???
+  val x: Id[Cap^{io}] = ???
   x(cap => cap.use()) // error
 }
diff --git a/tests/neg-custom-args/captures/box-adapt-typefun.scala b/tests/neg-custom-args/captures/box-adapt-typefun.scala
index b14b07e72e9b..bbc953f74e9e 100644
--- a/tests/neg-custom-args/captures/box-adapt-typefun.scala
+++ b/tests/neg-custom-args/captures/box-adapt-typefun.scala
@@ -1,13 +1,13 @@
 trait Cap { def use(): Int }
 
-def test1(io: {*} Cap): Unit = {
+def test1(io: Cap^{*}): Unit = {
   type Op[X] = [T] -> X -> Unit
-  val f: [T] -> ({io} Cap) -> Unit = ???
-  val op: Op[{io} Cap] = f // error
+  val f: [T] -> (Cap^{io}) -> Unit = ???
+  val op: Op[Cap^{io}] = f // error
 }
 
-def test2(io: {*} Cap): Unit = {
+def test2(io: Cap^{*}): Unit = {
   type Lazy[X] = [T] -> Unit -> X
-  val f: Lazy[{io} Cap] = ???
-  val test: [T] -> Unit -> ({io} Cap) = f // error
+  val f: Lazy[Cap^{io}] = ???
+  val test: [T] -> Unit -> (Cap^{io}) = f // error
 }
diff --git a/tests/neg-custom-args/captures/capt-depfun.scala b/tests/neg-custom-args/captures/capt-depfun.scala
index c01eed7c4b25..95eed2c29659 100644
--- a/tests/neg-custom-args/captures/capt-depfun.scala
+++ b/tests/neg-custom-args/captures/capt-depfun.scala
@@ -6,4 +6,4 @@ class Str
 def f(y: Cap, z: Cap) =
   def g(): C @retains(y, z) = ???
   val ac: ((x: Cap) => Str @retains(x) => Str @retains(x)) = ???
-  val dc: (({y, z} Str) => {y, z} Str) = ac(g()) // error
+  val dc: ((Str^{y, z}) => Str^{y, z}) = ac(g()) // error
diff --git a/tests/neg-custom-args/captures/capt-env.scala b/tests/neg-custom-args/captures/capt-env.scala
index 52fa4abfdaa8..6602678af167 100644
--- a/tests/neg-custom-args/captures/capt-env.scala
+++ b/tests/neg-custom-args/captures/capt-env.scala
@@ -1,5 +1,5 @@
 class C
-type Cap = {*} C
+type Cap = C^
 
 class Pair[+A, +B](x: A, y: B):
     def fst: A = x
diff --git a/tests/neg-custom-args/captures/capt-wf-typer.scala b/tests/neg-custom-args/captures/capt-wf-typer.scala
index 4fc50caed1f7..09b2841d3c77 100644
--- a/tests/neg-custom-args/captures/capt-wf-typer.scala
+++ b/tests/neg-custom-args/captures/capt-wf-typer.scala
@@ -1,11 +1,11 @@
 import annotation.retains
 class C
-type Cap = {*} C
+type Cap = C^
 
 object foo
 
 def test(c: Cap, other: String): Unit =
-  val x7: {c} String = ??? // OK
+  val x7: String^{c} = ??? // OK
   val x8: String @retains(x7 + x7) = ??? // error
   val x9: String @retains(foo) = ??? // error
   ()
\ No newline at end of file
diff --git a/tests/neg-custom-args/captures/capt-wf2.scala b/tests/neg-custom-args/captures/capt-wf2.scala
index ddde535fcab0..6c65e0dc77f7 100644
--- a/tests/neg-custom-args/captures/capt-wf2.scala
+++ b/tests/neg-custom-args/captures/capt-wf2.scala
@@ -1,5 +1,5 @@
 @annotation.capability class C
 
 def test(c: C) =
-  var x: {c} Any = ???
-  val y: {x} Any = x  // error
+  var x: Any^{c} = ???
+  val y: Any^{x} = x  // error
diff --git a/tests/neg-custom-args/captures/capt2.scala b/tests/neg-custom-args/captures/capt2.scala
index 8b08832dfdb9..cd6f41424a22 100644
--- a/tests/neg-custom-args/captures/capt2.scala
+++ b/tests/neg-custom-args/captures/capt2.scala
@@ -1,9 +1,9 @@
 //import scala.retains
 class C
-type Cap = {*} C
+type Cap = C^
 
-def f1(c: Cap): (() -> {c} C) = () => c // error, but would be OK under capture abbreciations for funciton types
-def f2(c: Cap): ({c} () -> C) = () => c // error
+def f1(c: Cap): (() -> C^{c}) = () => c // error, but would be OK under capture abbreciations for funciton types
+def f2(c: Cap): (() ->{c} C) = () => c // error
 
 def h5(x: Cap): () -> C =
   f1(x)  // error
diff --git a/tests/neg-custom-args/captures/caseclass/Test_2.scala b/tests/neg-custom-args/captures/caseclass/Test_2.scala
index 4eac6a260292..bffc0a295bdc 100644
--- a/tests/neg-custom-args/captures/caseclass/Test_2.scala
+++ b/tests/neg-custom-args/captures/caseclass/Test_2.scala
@@ -2,7 +2,7 @@
 def test(c: C) =
   val pure: () -> Unit = () => ()
   val impure: () => Unit = pure
-  val mixed: {c} () -> Unit = pure
+  val mixed: () ->{c} Unit = pure
   val x = Ref(impure)
   val _: Ref = x // error
   val y = x.copy()
@@ -16,10 +16,10 @@ def test(c: C) =
   val yc2: Ref = y2
 
   val x3 = Ref(mixed)
-  val _: {c} Ref = x3
+  val _: Ref^{c} = x3
   val y3 = x3.copy()
-  val yc3: {c} Ref = y3
+  val yc3: Ref^{c} = y3
 
   val y4 = y3 match
     case Ref(xx) => xx
-  val y4c: {x3} () -> Unit = y4
+  val y4c: () ->{x3} Unit = y4
diff --git a/tests/neg-custom-args/captures/cc-depfun.scala b/tests/neg-custom-args/captures/cc-depfun.scala
index c4ef303f4712..106a73dd7ce1 100644
--- a/tests/neg-custom-args/captures/cc-depfun.scala
+++ b/tests/neg-custom-args/captures/cc-depfun.scala
@@ -1,9 +1,9 @@
 trait Cap { def use(): Unit }
 
 def main() = {
-  val f: (io: {*} Cap) -> {} () -> Unit =
+  val f: (io: Cap^) -> () ->{} Unit =
     io => () => io.use()  // error
 
-  val g: ({*} Cap) -> {} () -> Unit =
+  val g: (Cap^) -> () ->{} Unit =
     io => () => io.use()  // error
 }
diff --git a/tests/neg-custom-args/captures/cc-this2.check b/tests/neg-custom-args/captures/cc-this2.check
index 086524d307a2..9db2f4efcc5a 100644
--- a/tests/neg-custom-args/captures/cc-this2.check
+++ b/tests/neg-custom-args/captures/cc-this2.check
@@ -3,4 +3,4 @@
 2 |class D extends C: // error
   |^
   |reference (scala.caps.* : Any) is not included in allowed capture set {} of pure base class class C
-3 |  this: {*} D =>
+3 |  this: D^ =>
diff --git a/tests/neg-custom-args/captures/cc-this2/D_2.scala b/tests/neg-custom-args/captures/cc-this2/D_2.scala
index 793f3f6353a9..b22e5e456092 100644
--- a/tests/neg-custom-args/captures/cc-this2/D_2.scala
+++ b/tests/neg-custom-args/captures/cc-this2/D_2.scala
@@ -1,3 +1,3 @@
 
 class D extends C: // error
-  this: {*} D =>
+  this: D^ =>
diff --git a/tests/neg-custom-args/captures/class-constr.scala b/tests/neg-custom-args/captures/class-constr.scala
index eeedf1043f37..9afb6972ccfa 100644
--- a/tests/neg-custom-args/captures/class-constr.scala
+++ b/tests/neg-custom-args/captures/class-constr.scala
@@ -6,10 +6,10 @@ class C(x: Cap, @constructorOnly y: Cap)
 
 def test(a: Cap, b: Cap) =
   val f = () => C(a, b)
-  val f_ok: {a, b} () -> {a} C = f
-  val f_no1: {a, b} () -> C = f // error
-  val f_no2: {a} () -> {a} C = f // error
-  val f_no3: {b} () -> {a} C = f // error
+  val f_ok: () ->{a, b} C^{a} = f
+  val f_no1: () ->{a, b} C = f // error
+  val f_no2: () ->{a} C^{a} = f // error
+  val f_no3: () ->{a} C^{a} = f // error
 
   class D:
     val xz =
@@ -19,6 +19,6 @@ def test(a: Cap, b: Cap) =
       println(b)
       2
   val d = () => new D()
-  val d_ok1: {a, b} () -> {a, b} D = d
-  val d_ok2: () -> {a, b} D = d  // because of function shorthand
-  val d_ok3: {a, b} () -> {b} D = d // error, but should work
+  val d_ok1: () ->{a, b} D^{a, b} = d
+  val d_ok2: () -> D^{a, b} = d  // because of function shorthand
+  val d_ok3: () ->{a, b} D^{b} = d // error, but should work
diff --git a/tests/neg-custom-args/captures/classes.scala b/tests/neg-custom-args/captures/classes.scala
index e4c141ea981b..3572e31a6f50 100644
--- a/tests/neg-custom-args/captures/classes.scala
+++ b/tests/neg-custom-args/captures/classes.scala
@@ -1,12 +1,12 @@
 class B
-type Cap = {*} B
+type Cap = B^
 class C0(n: Cap) // was error: class parameter must be a `val`, now OK
 
 class C(val n: Cap):
-  def foo(): {n} B = n
+  def foo(): B^{n} = n
 
 def test(x: Cap, y: Cap) =
   val c0 = C(x)
   val c1: C = c0  // error
   val c2 = if ??? then C(x) else identity(C(y))
-  val c3: {x} C { val n: {x, y} B } = c2  // error
+  val c3: C { val n: B^{x, y} }^{x} = c2  // error
diff --git a/tests/neg-custom-args/captures/ctest.scala b/tests/neg-custom-args/captures/ctest.scala
index 08bec16d8177..37d6ad034936 100644
--- a/tests/neg-custom-args/captures/ctest.scala
+++ b/tests/neg-custom-args/captures/ctest.scala
@@ -1,5 +1,5 @@
 class CC
-type Cap = {*} CC
+type Cap = CC^
 
 def test(cap1: Cap, cap2: Cap) =
   var b: List[String => String] = Nil // was error, now OK
diff --git a/tests/neg-custom-args/captures/emptyref-in-self.scala b/tests/neg-custom-args/captures/emptyref-in-self.scala
index 60f782deca6b..8bac47212f5b 100644
--- a/tests/neg-custom-args/captures/emptyref-in-self.scala
+++ b/tests/neg-custom-args/captures/emptyref-in-self.scala
@@ -1,3 +1,3 @@
-class Zip[A, B](underlying: String, other: {*} String) {
-  this: {underlying, other} Zip[A, B] =>  // error
+class Zip[A, B](underlying: String, other: String^) {
+  this: Zip[A, B]^{underlying, other} =>  // error
 }
diff --git a/tests/neg-custom-args/captures/filevar.scala b/tests/neg-custom-args/captures/filevar.scala
index 9251be8f1592..474ba36b0e79 100644
--- a/tests/neg-custom-args/captures/filevar.scala
+++ b/tests/neg-custom-args/captures/filevar.scala
@@ -5,10 +5,10 @@ class File:
   def write(x: String): Unit = ???
 
 class Service:
-  var file: {*} File = uninitialized
+  var file: File^ = uninitialized
   def log = file.write("log")  // error
 
-def withFile[T](op: (f: {*} File) => T): T =
+def withFile[T](op: (f: File^) => T): T =
   op(new File)
 
 def test =
diff --git a/tests/neg-custom-args/captures/heal-tparam-cs.scala b/tests/neg-custom-args/captures/heal-tparam-cs.scala
index 3ff34d0a8a42..f4c293e33d01 100644
--- a/tests/neg-custom-args/captures/heal-tparam-cs.scala
+++ b/tests/neg-custom-args/captures/heal-tparam-cs.scala
@@ -2,31 +2,31 @@ import language.experimental.captureChecking
 
 trait Cap { def use(): Unit }
 
-def localCap[T](op: (cap: {*} Cap) => T): T = ???
+def localCap[T](op: (cap: Cap^{*}) => T): T = ???
 
-def main(io: {*} Cap, net: {*} Cap): Unit = {
+def main(io: Cap^{*}, net: Cap^{*}): Unit = {
   val test1 = localCap { cap => // error
     () => { cap.use() }
   }
 
-  val test2: (cap: {*} Cap) -> {cap} () -> Unit =
+  val test2: (cap: Cap^{*}) -> () ->{cap} Unit =
     localCap { cap =>  // should work
-      (cap1: {*} Cap) => () => { cap1.use() }
+      (cap1: Cap^{*}) => () => { cap1.use() }
     }
 
-  val test3: (cap: {io} Cap) -> {io} () -> Unit =
+  val test3: (cap: Cap^{io}) -> () ->{io} Unit =
     localCap { cap =>  // should work
-      (cap1: {io} Cap) => () => { cap1.use() }
+      (cap1: Cap^{io}) => () => { cap1.use() }
     }
 
-  val test4: (cap: {io} Cap) -> {net} () -> Unit =
+  val test4: (cap: Cap^{io}) -> () ->{net} Unit =
     localCap { cap =>  // error
-      (cap1: {io} Cap) => () => { cap1.use() }
+      (cap1: Cap^{io}) => () => { cap1.use() }
     }
 
-  def localCap2[T](op: (cap: {io} Cap) => T): T = ???
+  def localCap2[T](op: (cap: Cap^{io}) => T): T = ???
 
-  val test5: {io} () -> Unit =
+  val test5: () ->{io} Unit =
     localCap2 { cap =>  // ok
       () => { cap.use() }
     }
diff --git a/tests/neg-custom-args/captures/i15049.scala b/tests/neg-custom-args/captures/i15049.scala
index 4e32172c025d..f12bb8028797 100644
--- a/tests/neg-custom-args/captures/i15049.scala
+++ b/tests/neg-custom-args/captures/i15049.scala
@@ -1,10 +1,10 @@
 class Session:
   def request = "Response"
 class Foo:
-  private val session: {*} Session = new Session
-  def withSession[T](f: ({*} Session) => T): T = f(session)
+  private val session: Session^{*} = new Session
+  def withSession[T](f: (Session^{*}) => T): T = f(session)
 
 def Test =
   val f = new Foo
   f.withSession(s => s).request // error
-  f.withSession[{*} Session](t => t) // error
+  f.withSession[Session^](t => t) // error
diff --git a/tests/neg-custom-args/captures/i15749.scala b/tests/neg-custom-args/captures/i15749.scala
index 00d1811498f7..b5aa233e7401 100644
--- a/tests/neg-custom-args/captures/i15749.scala
+++ b/tests/neg-custom-args/captures/i15749.scala
@@ -1,13 +1,13 @@
 class Unit
 object unit extends Unit
 
-type Top = {*} Any
+type Top = Any^{*}
 
-type LazyVal[T] = {*} Unit -> T
+type LazyVal[T] = Unit ->{*} T
 
 class Foo[T](val x: T)
 
-// Foo[□ {*} Unit -> T]
+// Foo[□ Unit => T]
 type BoxedLazyVal[T] = Foo[LazyVal[T]]
 
 def force[A](v: BoxedLazyVal[A]): A =
diff --git a/tests/neg-custom-args/captures/i15749a.scala b/tests/neg-custom-args/captures/i15749a.scala
index 9e439e28e98c..8a39db98c964 100644
--- a/tests/neg-custom-args/captures/i15749a.scala
+++ b/tests/neg-custom-args/captures/i15749a.scala
@@ -1,21 +1,21 @@
 class Unit
 object unit extends Unit
 
-type Top = {*} Any
+type Top = Any^
 
-type Wrapper[T] = [X] -> (op: {*} T -> X) -> X
+type Wrapper[T] = [X] -> (op: T ->{*} X) -> X
 
 def test =
 
   def wrapper[T](x: T): Wrapper[T] =
-    [X] => (op: {*} T -> X) => op(x)
+    [X] => (op: T ->{*} X) => op(x)
 
-  def strictMap[A <: Top, B <: Top](mx: Wrapper[A])(f: {*} A -> B): Wrapper[B] =
+  def strictMap[A <: Top, B <: Top](mx: Wrapper[A])(f: A ->{*} B): Wrapper[B] =
     mx((x: A) => wrapper(f(x)))
 
-  def force[A](thunk: {*} Unit -> A): A = thunk(unit)
+  def force[A](thunk: Unit ->{*} A): A = thunk(unit)
 
-  def forceWrapper[A](mx: Wrapper[{*} Unit -> A]): Wrapper[A] =
+  def forceWrapper[A](mx: Wrapper[Unit ->{*} A]): Wrapper[A] =
     // Γ ⊢ mx: Wrapper[□ {*} Unit => A]
     // `force` should be typed as ∀(□ {*} Unit -> A) A, but it can not
-    strictMap[{*} Unit -> A, A](mx)(t => force[A](t)) // error
+    strictMap[Unit ->{*} A, A](mx)(t => force[A](t)) // error
diff --git a/tests/neg-custom-args/captures/i15921.scala b/tests/neg-custom-args/captures/i15921.scala
index 291673746e33..233ef23991fc 100644
--- a/tests/neg-custom-args/captures/i15921.scala
+++ b/tests/neg-custom-args/captures/i15921.scala
@@ -1,7 +1,7 @@
 trait Stream { def close(): Unit = (); def write(x: Any): Unit = () }
 
 object Test {
-  def usingLogFile[T](op: (c: {*} Stream) => T): T =
+  def usingLogFile[T](op: (c: Stream^) => T): T =
     val logFile = new Stream { }
     val result = op(logFile)
     logFile.close()
diff --git a/tests/neg-custom-args/captures/i15923-cases.scala b/tests/neg-custom-args/captures/i15923-cases.scala
index 5fbb95355a60..2b034009fdc7 100644
--- a/tests/neg-custom-args/captures/i15923-cases.scala
+++ b/tests/neg-custom-args/captures/i15923-cases.scala
@@ -2,14 +2,14 @@ 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]) = {
+def foo(x: Id[Cap^{*}]) = {
   x(_.use())  // error
 }
 
-def bar(io: {*} Cap, x: Id[{io} Cap]) = {
+def bar(io: Cap^{*}, x: Id[Cap^{io}]) = {
   x(_.use())
 }
 
-def barAlt(a: {*} Cap, b: {*} Cap, x: Id[{a, b} Cap]) = {
+def barAlt(a: Cap^{*}, b: Cap^{*}, x: Id[Cap]^{a, b}) = {
   x(_.use())
 }
diff --git a/tests/neg-custom-args/captures/i15923.scala b/tests/neg-custom-args/captures/i15923.scala
index ac7ee995150e..3ce9d6121396 100644
--- a/tests/neg-custom-args/captures/i15923.scala
+++ b/tests/neg-custom-args/captures/i15923.scala
@@ -3,8 +3,8 @@ type Id[X] = [T] -> (op: X => T) -> T
 def mkId[X](x: X): Id[X] = [T] => (op: X => T) => op(x)
 
 def bar() = {
-  def withCap[X](op: ({*} Cap) => X): X = {
-    val cap: {*} Cap = new Cap { def use() = { println("cap is used"); 0 } }
+  def withCap[X](op: (Cap^) => X): X = {
+    val cap: Cap^ = new Cap { def use() = { println("cap is used"); 0 } }
     val result = op(cap)
     result
   }
diff --git a/tests/neg-custom-args/captures/i16114.scala b/tests/neg-custom-args/captures/i16114.scala
index cc491226f9df..706196fd7182 100644
--- a/tests/neg-custom-args/captures/i16114.scala
+++ b/tests/neg-custom-args/captures/i16114.scala
@@ -1,46 +1,46 @@
 trait Cap { def use(): Int; def close(): Unit }
-def mkCap(): {*} Cap = ???
+def mkCap(): Cap^ = ???
 
 def expect[T](x: T): x.type = x
 
-def withCap[T](op: ({*} Cap) => T): T = {
-  val cap: {*} Cap = mkCap()
+def withCap[T](op: Cap^ => T): T = {
+  val cap: Cap^ = mkCap()
   val result = op(cap)
   cap.close()
   result
 }
 
-def main(fs: {*} Cap): Unit = {
-  def badOp(io: {*} Cap): {} Unit -> Unit = {
-    val op1: {io} Unit -> Unit = (x: Unit) =>  // error // limitation
-      expect[{*} Cap] {
+def main(fs: Cap^): Unit = {
+  def badOp(io: Cap^{*}): Unit ->{} Unit = {
+    val op1: Unit ->{io} Unit = (x: Unit) =>  // error // limitation
+      expect[Cap^] {
         io.use()
         fs
       }
 
-    val op2: {fs} Unit -> Unit = (x: Unit) =>  // error // limitation
-      expect[{*} Cap] {
+    val op2: Unit ->{fs} Unit = (x: Unit) =>  // error // limitation
+      expect[Cap^] {
         fs.use()
         io
       }
 
-    val op3: {io} Unit -> Unit = (x: Unit) =>  // ok
-      expect[{*} Cap] {
+    val op3: Unit ->{io} Unit = (x: Unit) =>  // ok
+      expect[Cap^] {
         io.use()
         io
       }
 
-    val op4: {} Unit -> Unit = (x: Unit) =>  // ok
-      expect[{*} Cap](io)
+    val op4: Unit ->{} Unit = (x: Unit) =>  // ok
+      expect[Cap^](io)
 
-    val op: {} Unit -> Unit = (x: Unit) =>  // error
-      expect[{*} Cap] {
+    val op: Unit -> Unit = (x: Unit) =>  // error
+      expect[Cap^] {
         io.use()
         io
       }
     op
   }
 
-  val leaked: {} Unit -> Unit = withCap(badOp)
+  val leaked: Unit -> Unit = withCap(badOp)
   leaked(())
 }
diff --git a/tests/neg-custom-args/captures/impurefuns.scala b/tests/neg-custom-args/captures/impurefuns.scala
new file mode 100644
index 000000000000..d15d9a466307
--- /dev/null
+++ b/tests/neg-custom-args/captures/impurefuns.scala
@@ -0,0 +1,3 @@
+def f(x: Object^): Any =
+  val f: Int =>{x} Int = ???  // error // error // error
+  f
diff --git a/tests/neg-custom-args/captures/inner-classes.scala b/tests/neg-custom-args/captures/inner-classes.scala
index cf4073b36f81..181b830e4996 100644
--- a/tests/neg-custom-args/captures/inner-classes.scala
+++ b/tests/neg-custom-args/captures/inner-classes.scala
@@ -5,21 +5,21 @@ object test:
   def foo(fs: FileSystem) =
 
     trait LazyList[+A]:
-      this: {fs} LazyList[A] =>
+      this: LazyList[A]^{fs} =>
 
       def isEmpty: Boolean
       def head: A
-      def tail: {this} LazyList[A]
+      def tail: LazyList[A]^{this}
 
     object LazyNil extends LazyList[Nothing]:
       def isEmpty: Boolean = true
       def head = ???
       def tail = ???
 
-    final class LazyCons[+T](val x: T, val xs: () => {*} LazyList[T]) extends LazyList[T]: // error
+    final class LazyCons[+T](val x: T, val xs: () => LazyList[T]^) extends LazyList[T]: // error
       def isEmpty = false
       def head = x
-      def tail: {this} LazyList[T] = xs()
+      def tail: LazyList[T]^{this} = xs()
     end LazyCons
 
     new LazyCons(1, () => LazyNil)
diff --git a/tests/neg-custom-args/captures/lazyref.scala b/tests/neg-custom-args/captures/lazyref.scala
index 797781ac5360..99aa10d5d2b2 100644
--- a/tests/neg-custom-args/captures/lazyref.scala
+++ b/tests/neg-custom-args/captures/lazyref.scala
@@ -1,5 +1,5 @@
 class CC
-type Cap = {*} CC
+type Cap = CC^
 
 class LazyRef[T](val elem: () => T):
   val get: () => T = elem
diff --git a/tests/neg-custom-args/captures/override-adapt-box-selftype.scala b/tests/neg-custom-args/captures/override-adapt-box-selftype.scala
index a4dc92429192..32efd57b5b5a 100644
--- a/tests/neg-custom-args/captures/override-adapt-box-selftype.scala
+++ b/tests/neg-custom-args/captures/override-adapt-box-selftype.scala
@@ -4,45 +4,45 @@ class IO
 class C
 
 object Test1 {
-  abstract class A[X] { this: {} A[X] =>
+  abstract class A[X] { this: A[X] =>
     def foo(x: X): X
   }
 
-  def test(io: {*} IO) = {
-    class B extends A[{io} C] {  // X =:= {io} C // error
-      override def foo(x: {io} C): {io} C = ???
+  def test(io: IO^) = {
+    class B extends A[C^{io}] {  // X =:= {io} C // error
+      override def foo(x: C^{io}): C^{io} = ???
     }
   }
 }
 
-def Test2(io: {*} IO, fs: {io} IO, ct: {*} IO) = {
-  abstract class A[X] { this: {io} A[X] =>
+def Test2(io: IO^{*}, fs: IO^{io}, ct: IO^) = {
+  abstract class A[X] { this: A[X]^{io} =>
     def foo(x: X): X
   }
 
-  class B1 extends A[{io} C] {
-    override def foo(x: {io} C): {io} C = ???
+  class B1 extends A[C^{io}] {
+    override def foo(x: C^{io}): C^{io} = ???
   }
 
-  class B2 extends A[{ct} C] {  // error
-    override def foo(x: {ct} C): {ct} C = ???
+  class B2 extends A[C^{ct}] {  // error
+    override def foo(x: C^{ct}): C^{ct} = ???
   }
 
-  class B3 extends A[{fs} C] {
-    override def foo(x: {fs} C): {fs} C = ???
+  class B3 extends A[C^{fs}] {
+    override def foo(x: C^{fs}): C^{fs} = ???
   }
 }
 
-def Test3(io: {*} IO, ct: {*} IO) = {
-  abstract class A[X] { this: {*} A[X] =>
+def Test3(io: IO^, ct: IO^) = {
+  abstract class A[X] { this: A[X]^ =>
     def foo(x: X): X
   }
 
-  class B1 extends A[{io} C] {
-    override def foo(x: {io} C): {io} C = ???
+  class B1 extends A[C^{io}] {
+    override def foo(x: C^{io}): C^{io} = ???
   }
 
-  class B2 extends A[{io, ct} C] {
-    override def foo(x: {io, ct} C): {io, ct} C = ???
+  class B2 extends A[C^{io, ct}] {
+    override def foo(x: C^{io, ct}): C^{io, ct} = ???
   }
 }
diff --git a/tests/neg-custom-args/captures/override-adapt-box.scala b/tests/neg-custom-args/captures/override-adapt-box.scala
index 64ba8743bf91..8b6d8e2b8afd 100644
--- a/tests/neg-custom-args/captures/override-adapt-box.scala
+++ b/tests/neg-custom-args/captures/override-adapt-box.scala
@@ -1,14 +1,14 @@
 import language.experimental.captureChecking
 
-abstract class A[X] { this: ({} A[X]) =>
+abstract class A[X] { this: A[X]^{} =>
   def foo(x: X): X
 }
 
 class IO
 class C
 
-def test(io: {*} IO) = {
-  class B extends A[{io} C] {  // X =:= {io} C  // error
-    override def foo(x: {io} C): {io} C = ???
+def test(io: IO^{*}) = {
+  class B extends A[C^{io}] {  // X =:= {io} C  // error
+    override def foo(x: C^{io}): C^{io} = ???
   }
 }
diff --git a/tests/neg-custom-args/captures/override-boxed.scala b/tests/neg-custom-args/captures/override-boxed.scala
index 720b50732f61..1e7afd5e3d09 100644
--- a/tests/neg-custom-args/captures/override-boxed.scala
+++ b/tests/neg-custom-args/captures/override-boxed.scala
@@ -1,7 +1,8 @@
+
 class A
 
-def test(x: {*} Any) =
+def test(x: Any^{*}) =
   abstract class Getter:
-    def get(): {x} A
-  class PolyGetter[T <: {x} A] extends Getter:
+    def get(): A^{x}
+  class PolyGetter[T <: A^{x}] extends Getter:
     override def get(): T = ??? // error
diff --git a/tests/neg-custom-args/captures/stack-alloc.scala b/tests/neg-custom-args/captures/stack-alloc.scala
index b646c0736f2c..027f2b3e005c 100644
--- a/tests/neg-custom-args/captures/stack-alloc.scala
+++ b/tests/neg-custom-args/captures/stack-alloc.scala
@@ -5,7 +5,7 @@ class Pooled
 val stack = mutable.ArrayBuffer[Pooled]()
 var nextFree = 0
 
-def withFreshPooled[T](op: ({*} Pooled) => T): T =
+def withFreshPooled[T](op: Pooled^ => T): T =
   if nextFree >= stack.size then stack.append(new Pooled)
   val pooled = stack(nextFree)
   nextFree = nextFree + 1
diff --git a/tests/neg-custom-args/captures/try3.scala b/tests/neg-custom-args/captures/try3.scala
index 8c5bc18bf3be..5a569aa5fd8d 100644
--- a/tests/neg-custom-args/captures/try3.scala
+++ b/tests/neg-custom-args/captures/try3.scala
@@ -1,8 +1,8 @@
 import java.io.IOException
 
 class CT[E]
-type CanThrow[E] = {*} CT[E]
-type Top  = {*} Any
+type CanThrow[E] = CT[E]^
+type Top  = Any^
 
 def handle[E <: Exception, T <: Top](op: CanThrow[E] ?=> T)(handler: E => T): T =
   val x: CanThrow[E] = ???
diff --git a/tests/neg-custom-args/captures/unbox.scala b/tests/neg-custom-args/captures/unbox.scala
index c615cf1d9176..18a86a1237ff 100644
--- a/tests/neg-custom-args/captures/unbox.scala
+++ b/tests/neg-custom-args/captures/unbox.scala
@@ -1,4 +1,4 @@
-type Proc = {*} () => Unit
+type Proc = () => Unit
 
 val xs: List[Proc] = ???
 
diff --git a/tests/pending/neg/cc-depfun.scala b/tests/pending/neg/cc-depfun.scala
new file mode 100644
index 000000000000..4d600872d208
--- /dev/null
+++ b/tests/pending/neg/cc-depfun.scala
@@ -0,0 +1,14 @@
+import language.experimental.captureChecking
+
+// compare with neg-custom-args/captures/depfun.scala, which produces errors
+// but the errors go away if ->{} gets replaced by ->.
+
+trait Cap { def use(): Unit }
+
+def main() = {
+  val f: (io: Cap^) -> () -> Unit =
+    io => () => io.use()  // error
+
+  val g: (Cap^) -> () -> Unit =
+    io => () => io.use()  // error
+}
diff --git a/tests/pos-custom-args/captures/lazylists-mono.scala b/tests/pos-custom-args/captures/lazylists-mono.scala
index d0f88d0de6a3..c91bedd8f1cf 100644
--- a/tests/pos-custom-args/captures/lazylists-mono.scala
+++ b/tests/pos-custom-args/captures/lazylists-mono.scala
@@ -6,12 +6,12 @@ type Cap = CC^
 def test(E: Cap) =
 
   trait LazyList[+A]:
-    protected def contents: () ->{E} (A, {E} LazyList[A])
+    protected def contents: () ->{E} (A, LazyList[A]^{E})
     def isEmpty: Boolean
     def head: A = contents()._1
-    def tail: {E} LazyList[A] = contents()._2
+    def tail: LazyList[A]^{E} = contents()._2
 
-  class LazyCons[+A](override val contents: () ->{E} (A, {E} LazyList[A]))
+  class LazyCons[+A](override val contents: () ->{E} (A, LazyList[A]^{E}))
   extends LazyList[A]:
     def isEmpty: Boolean = false
 
diff --git a/tests/pos-custom-args/captures/lists.scala b/tests/pos-custom-args/captures/lists.scala
index 4e76ed3d5e1d..56473e68d49f 100644
--- a/tests/pos-custom-args/captures/lists.scala
+++ b/tests/pos-custom-args/captures/lists.scala
@@ -73,18 +73,18 @@ def test(c: Cap, d: Cap, e: Cap) =
   val b3 = zs.map(eff[Cap ->{d, y} Unit])
   val b3c: LIST[Cap ->{d, y} Unit]^{e} = b3
   val b4 = zs.map(eff)
-  val b4c: LIST[{d, c} Cap -> Unit]^{e} = b4
-  val b5 = map[{d, y} Cap -> Unit, {d, y} Cap -> Unit](eff)(zs)
-  val b5c: LIST[{d, c} Cap -> Unit]^{e} = b5
-  val b6 = m1[{d, y} Cap -> Unit, {d, y} Cap -> Unit](eff)(zs)
-  val b6c: LIST[{d, c} Cap -> Unit]^{e} = b6
+  val b4c: LIST[Cap ->{d, c} Unit]^{e} = b4
+  val b5 = map[Cap ->{d, y} Unit, Cap ->{d, y} Unit](eff)(zs)
+  val b5c: LIST[Cap ->{d, c} Unit]^{e} = b5
+  val b6 = m1[Cap ->{d, y} Unit, Cap ->{d, y} Unit](eff)(zs)
+  val b6c: LIST[Cap ->{d, c} Unit]^{e} = b6
 
-  val c0 = eff2[{d, y} Cap -> Unit]
-  val c0c: ({d, y} Cap -> Unit) ->{e, d, y}  Cap ->{d, y} Unit = c0
+  val c0 = eff2[Cap ->{d, y} Unit]
+  val c0c: (Cap ->{d, y} Unit) ->{e, d, y}  Cap ->{d, y} Unit = c0
   val c1 = zs.map[Cap ->{d, y} Unit](a0)
-  val c1c: LIST[{d, y} Cap -> Unit]^{e} = c1
+  val c1c: LIST[Cap ->{d, y} Unit]^{e} = c1
   val c2 = zs.map[Cap ->{d, y} Unit](eff2[Cap ->{d, y} Unit])
-  val c2c: LIST[{d, y} Cap -> Unit]^{e} = c2
+  val c2c: LIST[Cap ->{d, y} Unit]^{e} = c2
   val c3 = zs.map(eff2[Cap ->{d, y} Unit])
   val c3c: LIST[Cap ->{d, y} Unit]^{e} = c3
 
diff --git a/tests/pos-custom-args/captures/trickyTrailingUpArrow.scala b/tests/pos-custom-args/captures/trickyTrailingUpArrow.scala
index e9d1f50848c0..71b663de5354 100644
--- a/tests/pos-custom-args/captures/trickyTrailingUpArrow.scala
+++ b/tests/pos-custom-args/captures/trickyTrailingUpArrow.scala
@@ -4,3 +4,6 @@ object Test:
   x += 1
 
   inline def ctx(using c: String) = c
+
+  val y: String^ -> Unit = ???
+  val z: String^ ?-> Unit = ???
diff --git a/tests/pos-with-compiler-cc/dotc/transform/TreeMapWithStages.scala b/tests/pos-with-compiler-cc/dotc/transform/TreeMapWithStages.scala
index c721c838d316..9dd1000af954 100644
--- a/tests/pos-with-compiler-cc/dotc/transform/TreeMapWithStages.scala
+++ b/tests/pos-with-compiler-cc/dotc/transform/TreeMapWithStages.scala
@@ -18,7 +18,7 @@ import scala.annotation.constructorOnly
  *                     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 =>
+abstract class TreeMapWithStages(@constructorOnly ictx: Context) extends TreeMapWithImplicits { this: TreeMapWithStages^{} =>
 
   import tpd._
   import TreeMapWithStages._
diff --git a/tests/pos/boxmap-paper.scala b/tests/pos/boxmap-paper.scala
index eb6e5f48d81c..ea4c31f099c4 100644
--- a/tests/pos/boxmap-paper.scala
+++ b/tests/pos/boxmap-paper.scala
@@ -13,25 +13,25 @@ def map[A, B](c: Cell[A])(f: A => B): Cell[B]
 def pureMap[A, B](c: Cell[A])(f: A -> B): Cell[B]
   = c[Cell[B]]((x: A) => cell(f(x)))
 
-def lazyMap[A, B](c: Cell[A])(f: A => B): {f} () -> Cell[B]
+def lazyMap[A, B](c: Cell[A])(f: A => B): () ->{f} Cell[B]
   = () => c[Cell[B]]((x: A) => cell(f(x)))
 
 trait IO:
   def print(s: String): Unit
 
-def test(io: {*} IO) =
+def test(io: IO^{*}) =
 
-  val loggedOne: {io} () -> Int = () => { io.print("1"); 1 }
+  val loggedOne: () ->{io} Int = () => { io.print("1"); 1 }
 
-  val c: Cell[{io} () -> Int]
-      = cell[{io} () -> Int](loggedOne)
+  val c: Cell[() ->{io} Int]
+      = cell[() ->{io} Int](loggedOne)
 
-  val g = (f: {io} () -> Int) =>
+  val g = (f: () ->{io} Int) =>
     val x = f(); io.print(" + ")
     val y = f(); io.print(s" = ${x + y}")
 
-  val r = lazyMap[{io} () -> Int, Unit](c)(f => g(f))
-  val r2 = lazyMap[{io} () -> Int, Unit](c)(g)
+  val r = lazyMap[() ->{io} Int, Unit](c)(f => g(f))
+  val r2 = lazyMap[() ->{io} Int, Unit](c)(g)
   val r3 = lazyMap(c)(g)
   val _ = r()
   val _ = r2()

From ab2ff3baa2f3bcc24e83cf50ce56cd9f0f4c927d Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Mon, 1 May 2023 12:09:51 +0200
Subject: [PATCH 528/657] Change encoding of capturing ByNameTypeTrees

---
 compiler/src/dotty/tools/dotc/ast/TreeInfo.scala | 16 +++++++++-------
 .../src/dotty/tools/dotc/parsing/Parsers.scala   |  7 ++++---
 .../tools/dotc/printing/RefinedPrinter.scala     | 13 +++++--------
 3 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
index 5b409b6fec9a..34823a3ba0c8 100644
--- a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
+++ b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
@@ -473,13 +473,15 @@ trait UntypedTreeInfo extends TreeInfo[Untyped] { self: Trees.Instance[Untyped]
    */
   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)
+    def apply(tp: Tree)(using Context): untpd.ByNameTypeTree =
+      untpd.ByNameTypeTree(
+        untpd.CapturesAndResult(
+          untpd.captureRoot.withSpan(tp.span.startPos) :: Nil, tp))
+
+    def unapply(tp: Tree)(using Context): Option[Tree] = tp match
+      case untpd.ByNameTypeTree(
+        untpd.CapturesAndResult(id @ Select(_, nme.CAPTURE_ROOT) :: Nil, result))
+      if id.span == result.span.startPos => Some(result)
       case _ => None
   end ImpureByNameTypeTree
 }
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 5c306302361b..67816b28a722 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -1936,9 +1936,10 @@ object Parsers {
     def paramTypeOf(core: () => Tree): Tree =
       if in.token == ARROW || isPureArrow(nme.PUREARROW) then
         val isImpure = in.token == ARROW
-        val tp = atSpan(in.skipToken()):
-          ByNameTypeTree(if isImpure then core() else capturesAndResult(core))
-        if isImpure && Feature.pureFunsEnabled then ImpureByNameTypeTree(tp) else tp
+        atSpan(in.skipToken()):
+          val tp = if isImpure then core() else capturesAndResult(core)
+          if isImpure && Feature.pureFunsEnabled then ImpureByNameTypeTree(tp)
+          else ByNameTypeTree(tp)
       else
         core()
 
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index 2e2ef69ace3f..eef230496bfc 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -566,9 +566,10 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           toText(sel) ~ keywordStr(" match ") ~ blockText(cases) ~
           (" <: " ~ toText(bound) provided !bound.isEmpty)
         }
+      case ImpureByNameTypeTree(tpt) =>
+        "=> " ~ toTextLocal(tpt)
       case ByNameTypeTree(tpt) =>
-        (if Feature.pureFunsEnabled then "-> " else "=> ")
-        ~ toTextLocal(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)(" = " ~ _)
@@ -742,12 +743,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case CapturesAndResult(refs, parent) =>
         changePrec(GlobalPrec)("^{" ~ Text(refs.map(toText), ", ") ~ "} " ~ toText(parent))
       case CapturingTypeTree(refs, parent) =>
-        parent match
-          case ImpureByNameTypeTree(bntpt) =>
-            "=> " ~ toTextLocal(bntpt)
-          case _ =>
-            toText(parent) ~ "^"
-            ~ changePrec(GlobalPrec)("{" ~ Text(refs.map(toText), ", ") ~ "}")
+        toText(parent) ~ "^"
+        ~ changePrec(GlobalPrec)("{" ~ Text(refs.map(toText), ", ") ~ "}")
       case _ =>
         tree.fallbackToText(this)
     }

From dbe0ec98c1fcef1345d4eb213889664c1b77b9f7 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Mon, 1 May 2023 12:13:27 +0200
Subject: [PATCH 529/657] Drop CapturingTypeTree

---
 compiler/src/dotty/tools/dotc/ast/Desugar.scala       | 10 ----------
 compiler/src/dotty/tools/dotc/ast/TreeInfo.scala      |  3 ---
 compiler/src/dotty/tools/dotc/ast/untpd.scala         | 11 -----------
 .../dotty/tools/dotc/printing/RefinedPrinter.scala    |  3 ---
 4 files changed, 27 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index e0cba60950fa..e658a3e9a142 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -1824,14 +1824,6 @@ object desugar {
         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)`
-        parent match
-          case ByNameTypeTree(restpt) =>
-            cpy.ByNameTypeTree(parent)(makeRetaining(restpt, refs, tpnme.retainsByName))
-          case _ =>
-            makeRetaining(parent, refs, tpnme.retains)
       case f: FunctionWithMods if f.hasErasedParams => makeFunctionWithValDefs(f, pt)
     }
     desugared.withSpan(tree.span)
@@ -1991,8 +1983,6 @@ object desugar {
             case _ => traverseChildren(tree)
           }
         }.traverse(body)
-      case CapturingTypeTree(refs, parent) =>
-        collect(parent)
       case _ =>
     }
     collect(tree)
diff --git a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
index 34823a3ba0c8..a2e3277c9f81 100644
--- a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
+++ b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
@@ -223,9 +223,6 @@ trait TreeInfo[T <: Untyped] { self: Trees.Instance[T] =>
   /** 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 */
diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
index 910b0f84758a..231454921a36 100644
--- a/compiler/src/dotty/tools/dotc/ast/untpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -147,9 +147,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     case Floating
   }
 
-  /** {x1, ..., xN} T   (only relevant under captureChecking) */
-  case class CapturingTypeTree(refs: List[Tree], parent: Tree)(implicit @constructorOnly src: SourceFile) extends TypTree
-
   /** {x1, ..., xN} T   (only relevant under captureChecking) */
   case class CapturesAndResult(refs: List[Tree], parent: Tree)(implicit @constructorOnly src: SourceFile) extends TypTree
 
@@ -668,10 +665,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
       case tree: CapturesAndResult if (refs eq tree.refs) && (parent eq tree.parent) => tree
       case _ => finalize(tree, untpd.CapturesAndResult(refs, parent))
 
-    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))
@@ -735,8 +728,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         cpy.MacroTree(tree)(transform(expr))
       case CapturesAndResult(refs, parent) =>
         cpy.CapturesAndResult(tree)(transform(refs), transform(parent))
-      case CapturingTypeTree(refs, parent) =>
-        cpy.CapturingTypeTree(tree)(transform(refs), transform(parent))
       case _ =>
         super.transformMoreCases(tree)
     }
@@ -796,8 +787,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
         this(x, expr)
       case CapturesAndResult(refs, parent) =>
         this(this(x, refs), parent)
-      case CapturingTypeTree(refs, parent) =>
-        this(this(x, refs), parent)
       case _ =>
         super.foldMoreCases(x, tree)
     }
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index eef230496bfc..e6fe55ccb2fc 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -742,9 +742,6 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         prefix ~~ idx.toString ~~ "|" ~~ tptText ~~ "|" ~~ argsText ~~ "|" ~~ contentText ~~ postfix
       case CapturesAndResult(refs, parent) =>
         changePrec(GlobalPrec)("^{" ~ Text(refs.map(toText), ", ") ~ "} " ~ toText(parent))
-      case CapturingTypeTree(refs, parent) =>
-        toText(parent) ~ "^"
-        ~ changePrec(GlobalPrec)("{" ~ Text(refs.map(toText), ", ") ~ "}")
       case _ =>
         tree.fallbackToText(this)
     }

From c24f875ff3ee39d267bb08d08a66e81a64313592 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Mon, 1 May 2023 14:43:37 +0200
Subject: [PATCH 530/657] Change root capability to `cap`

---
 .../src/dotty/tools/dotc/cc/CaptureSet.scala  |  8 +++----
 .../dotty/tools/dotc/cc/CheckCaptures.scala   | 18 +++++++--------
 .../dotty/tools/dotc/core/Definitions.scala   |  2 +-
 .../src/dotty/tools/dotc/core/StdNames.scala  |  3 +--
 .../src/dotty/tools/dotc/core/Types.scala     |  2 +-
 .../dotty/tools/dotc/parsing/Parsers.scala    |  3 +--
 .../tools/dotc/printing/PlainPrinter.scala    |  2 +-
 library/src/scala/caps.scala                  |  3 ++-
 tests/neg-custom-args/boxmap.scala            |  6 ++---
 tests/neg-custom-args/capt-wf.scala           |  6 ++---
 .../captures/box-adapt-cases.scala            |  6 ++---
 .../captures/box-adapt-cov.scala              |  4 ++--
 .../captures/box-adapt-cs.scala               |  6 ++---
 .../captures/box-adapt-depfun.scala           |  2 +-
 .../captures/box-adapt-typefun.scala          |  4 ++--
 .../captures/capt-depfun.scala                |  2 +-
 .../captures/capt-depfun2.scala               |  2 +-
 .../neg-custom-args/captures/capt-test.scala  |  4 ++--
 tests/neg-custom-args/captures/capt1.scala    | 12 +++++-----
 tests/neg-custom-args/captures/capt3.scala    |  2 +-
 tests/neg-custom-args/captures/cc-this2.check |  2 +-
 tests/neg-custom-args/captures/cc1.scala      |  2 +-
 .../captures/exception-definitions.check      |  2 +-
 .../captures/heal-tparam-cs.scala             |  8 +++----
 tests/neg-custom-args/captures/i15049.scala   |  4 ++--
 tests/neg-custom-args/captures/i15749.scala   |  6 ++---
 tests/neg-custom-args/captures/i15749a.scala  | 16 +++++++-------
 .../captures/i15923-cases.scala               |  6 ++---
 tests/neg-custom-args/captures/i16114.scala   |  2 +-
 tests/neg-custom-args/captures/io.scala       |  8 +++----
 .../captures/lazylists-exceptions.check       |  2 +-
 .../neg-custom-args/captures/lazylists1.scala |  6 ++---
 .../override-adapt-box-selftype.scala         |  2 +-
 .../captures/override-adapt-box.scala         |  2 +-
 .../captures/override-boxed.scala             |  2 +-
 tests/neg-custom-args/captures/real-try.check |  6 ++---
 tests/neg-custom-args/captures/real-try.scala |  2 +-
 tests/neg-custom-args/captures/try.check      |  2 +-
 tests/neg-custom-args/captures/try.scala      |  4 ++--
 .../captures/usingLogFile.check               | 12 +++++-----
 tests/neg-custom-args/captures/vars.check     |  6 ++---
 tests/pos-custom-args/captures/byname.scala   |  2 +-
 .../captures/caps-universal.scala             |  2 +-
 .../captures/capt-depfun.scala                |  4 ++--
 .../captures/capt-depfun2.scala               |  2 +-
 tests/pos-custom-args/captures/capt0.scala    |  2 +-
 tests/pos-custom-args/captures/capt1.scala    |  2 +-
 tests/pos-custom-args/captures/capt2.scala    |  2 +-
 .../pos-custom-args/captures/cc-expand.scala  |  2 +-
 .../pos-custom-args/captures/overrides.scala  |  2 +-
 tests/pos-custom-args/captures/try.scala      |  2 +-
 .../pos-with-compiler-cc/dotc/ast/Trees.scala |  4 ++--
 .../pos-with-compiler-cc/dotc/ast/untpd.scala |  2 +-
 .../dotc/cc/CaptureAnnotation.scala           |  2 +-
 .../dotc/core/Annotations.scala               |  2 +-
 .../dotc/core/Contexts.scala                  |  2 +-
 .../dotc/core/Decorators.scala                |  8 +++----
 .../dotc/core/GadtConstraint.scala            |  4 ++--
 .../dotc/core/Names.scala                     | 10 ++++-----
 .../dotc/core/Substituters.scala              | 18 +++++++--------
 .../dotc/core/TypeOps.scala                   |  2 +-
 .../dotc/core/Types.scala                     | 14 ++++++------
 .../dotc/typer/ProtoTypes.scala               | 22 +++++++++----------
 tests/pos/boxmap-paper.scala                  |  2 +-
 .../captures/colltest5/Test_2.scala           |  4 ++--
 65 files changed, 158 insertions(+), 159 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala b/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
index 2b9fe9d3d923..509fecd4d3b4 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
@@ -70,7 +70,7 @@ sealed abstract class CaptureSet extends Showable:
     assert(!isConst)
     asInstanceOf[Var]
 
-  /** Does this capture set contain the root reference `*` as element? */
+  /** Does this capture set contain the root reference `cap` as element? */
   final def isUniversal(using Context) =
     elems.exists {
       case ref: TermRef => ref.symbol == defn.captureRoot
@@ -133,7 +133,7 @@ sealed abstract class CaptureSet extends Showable:
    *  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 `*`.
+   *  root capability `cap`.
    */
   def mightAccountFor(x: CaptureRef)(using Context): Boolean =
     reporting.trace(i"$this mightAccountFor $x, ${x.captureSetOfInfo}?", show = true) {
@@ -270,7 +270,7 @@ sealed abstract class CaptureSet extends Showable:
   def substParams(tl: BindingType, to: List[Type])(using Context) =
     map(Substituters.SubstParamsMap(tl, to))
 
-  /** Invoke handler if this set has (or later aquires) the root capability `*` */
+  /** Invoke handler if this set has (or later aquires) the root capability `cap` */
   def disallowRootCapability(handler: () => Context ?=> Unit)(using Context): this.type =
     if isUniversal then handler()
     this
@@ -372,7 +372,7 @@ object CaptureSet:
     def isConst = isSolved
     def isAlwaysEmpty = false
 
-    /** A handler to be invoked if the root reference `*` is added to this set */
+    /** A handler to be invoked if the root reference `cap` is added to this set */
     var rootAddedHandler: () => Context ?=> Unit = () => ()
 
     var description: String = ""
diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index f9401a0c509f..e77c72c422ca 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -433,7 +433,7 @@ class CheckCaptures extends Recheck, SymTransformer:
             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 `*`
+              // get capture sets. This is important to avoid false widenings to `cap`
               // 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.
@@ -582,7 +582,7 @@ class CheckCaptures extends Recheck, SymTransformer:
           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 `*`.
+              em"""The $kind's type $wtp is not allowed to capture the root capability `cap`.
                   |This usually means that a capability persists longer than its allowed lifetime.""",
               tree.srcPos)
           }
@@ -768,9 +768,9 @@ class CheckCaptures extends Recheck, SymTransformer:
             styp1.capturing(if alwaysConst then CaptureSet(cs1.elems) else cs1).forceBoxStatus(resultBoxed)
 
           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 `*`
+            val criticalSet =          // the set which is not allowed to have `cap`
+              if covariant then cs1    // can't box with `cap`
+              else expected.captureSet // can't unbox with `cap`
             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
@@ -779,11 +779,11 @@ class CheckCaptures extends Recheck, SymTransformer:
                 println(i"cannot box/unbox $actual vs $expected")
               actual
             else
-              // Disallow future addition of `*` to `criticalSet`.
+              // Disallow future addition of `cap` to `criticalSet`.
               criticalSet.disallowRootCapability { () =>
                 report.error(
                   em"""$actual cannot be box-converted to $expected
-                      |since one of their capture sets contains the root capability `*`""",
+                      |since one of their capture sets contains the root capability `cap`""",
                 pos)
               }
               if !insertBox then  // unboxing
@@ -922,8 +922,8 @@ class CheckCaptures extends Recheck, SymTransformer:
      *    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.
+     *  This also causes soundness issues, since `f` in ?1 should be widened to `cap`,
+     *  giving rise to an error that `cap` 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.
diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
index b7211b3ce5e3..82b1a6354321 100644
--- a/compiler/src/dotty/tools/dotc/core/Definitions.scala
+++ b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -968,7 +968,7 @@ class Definitions {
   @tu lazy val BreakClass: Symbol = requiredClass("scala.util.boundary.Break")
 
   @tu lazy val CapsModule: Symbol = requiredModule("scala.caps")
-    @tu lazy val captureRoot: TermSymbol = CapsModule.requiredValue("*")
+    @tu lazy val captureRoot: TermSymbol = CapsModule.requiredValue("cap")
     @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")
diff --git a/compiler/src/dotty/tools/dotc/core/StdNames.scala b/compiler/src/dotty/tools/dotc/core/StdNames.scala
index e5ca0710447d..5c718ef26289 100644
--- a/compiler/src/dotty/tools/dotc/core/StdNames.scala
+++ b/compiler/src/dotty/tools/dotc/core/StdNames.scala
@@ -286,8 +286,7 @@ object StdNames {
 // ----- Term names -----------------------------------------
 
     // Compiler-internal
-    val CAPTURE_ROOT: N             = "*"
-    val CAPTURE_ROOT_ALT: N         = "any"
+    val CAPTURE_ROOT: N             = "cap"
     val CONSTRUCTOR: N              = "<init>"
     val STATIC_CONSTRUCTOR: N       = "<clinit>"
     val EVT2U: N                    = "evt2u$"
diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index 165037d65979..0a374cadd2ec 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -2102,7 +2102,7 @@ object Types {
      */
     final def isTracked(using Context): Boolean = canBeTracked && !captureSetOfInfo.isAlwaysEmpty
 
-    /** Is this reference the root capability `*` ? */
+    /** Is this reference the root capability `cap` ? */
     def isRootCapability(using Context): Boolean = false
 
     /** Normalize reference so that it can be compared with `eq` for equality */
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 67816b28a722..9376b995b011 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -1444,7 +1444,6 @@ object Parsers {
       if in.token == THIS then simpleRef()
       else termIdent() match
         case Ident(nme.CAPTURE_ROOT) => captureRoot
-        case Ident(nme.CAPTURE_ROOT_ALT) => captureRoot
         case id => id
 
     /**  CaptureSet ::=  `{` CaptureRef {`,` CaptureRef} `}`    -- under captureChecking
@@ -1681,7 +1680,7 @@ object Parsers {
 
     def refinedType() = refinedTypeRest(withType())
 
-    /** Disambiguation: a `^` is treated as a postfix operator meaning `^{any}`
+    /** Disambiguation: a `^` is treated as a postfix operator meaning `^{cap}`
      *  if followed by `{`, `->`, or `?->`,
      *  or followed by a new line (significant or not),
      *  or followed by a token that cannot start an infix type.
diff --git a/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala b/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
index 91e152c57048..fa58c467bfa5 100644
--- a/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
@@ -386,7 +386,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
 
   def toTextCaptureRef(tp: Type): Text =
     homogenize(tp) match
-      case tp: TermRef if tp.symbol == defn.captureRoot => Str("*")
+      case tp: TermRef if tp.symbol == defn.captureRoot => Str("cap")
       case tp: SingletonType => toTextRef(tp)
       case _ => toText(tp)
 
diff --git a/library/src/scala/caps.scala b/library/src/scala/caps.scala
index fb1721f98b35..921b370ff5b0 100644
--- a/library/src/scala/caps.scala
+++ b/library/src/scala/caps.scala
@@ -5,7 +5,8 @@ import annotation.experimental
 @experimental object caps:
 
   /** The universal capture reference */
-  val `*`: Any = ()
+  val `*`: Any = () // OLD
+  val cap: Any = () // NEW
 
   object unsafe:
 
diff --git a/tests/neg-custom-args/boxmap.scala b/tests/neg-custom-args/boxmap.scala
index e66b0a8ec808..cdc8253acf2a 100644
--- a/tests/neg-custom-args/boxmap.scala
+++ b/tests/neg-custom-args/boxmap.scala
@@ -1,5 +1,5 @@
 import annotation.retains
-type Top = Any @retains(caps.*)
+type Top = Any @retains(caps.cap)
 
 type Box[+T <: Top] = ([K <: Top] -> (T => K) -> K)
 
@@ -16,6 +16,6 @@ def test[A <: Top, B <: Top] =
   def lazymap[A <: Top, B <: Top](b: Box[A])(f: A => B) =
     () => b[Box[B]]((x: A) => box(f(x)))
   val x0: (b: Box[A]) -> (f: A => B) -> (() -> Box[B]) = lazymap[A, B]  // error
-  val x: (b: Box[A]) -> (f: A => B) -> {b, f} (() -> Box[B]) = lazymap[A, B]  // works
-  val y: (b: Box[A]) -> (f: A => B) -> {*} (() -> Box[B]) = lazymap[A, B]  // works
+  val x: (b: Box[A]) -> (f: A => B) ->{b, f} (() -> Box[B]) = lazymap[A, B]  // works
+  val y: (b: Box[A]) -> (f: A => B) ->{cap} (() -> Box[B]) = lazymap[A, B]  // works
   ()
diff --git a/tests/neg-custom-args/capt-wf.scala b/tests/neg-custom-args/capt-wf.scala
index fe883af0ba8e..67e1bc9906fe 100644
--- a/tests/neg-custom-args/capt-wf.scala
+++ b/tests/neg-custom-args/capt-wf.scala
@@ -14,9 +14,9 @@ def test(c: Cap, other: String): Unit =
   val x5: C^{c, c} = ??? // error: redundant
   // val x6: C^{c}^{c} = ??? // would be syntax error
   val x7: Cap^{c} = ??? // error: redundant
-  // val x8: C^{c}^{*} = ??? // would be syntax error
-  val x9: C^{c, *}  = ??? // error: redundant
-  val x10: C^{*, c} = ??? // error: redundant
+  // val x8: C^{c}^{cap} = ??? // would be syntax error
+  val x9: C^{c, cap}  = ??? // error: redundant
+  val x10: C^{cap, c} = ??? // error: redundant
 
   def even(n: Int): Boolean = if n == 0 then true else odd(n - 1)
   def odd(n: Int): Boolean = if n == 1 then true else even(n - 1)
diff --git a/tests/neg-custom-args/captures/box-adapt-cases.scala b/tests/neg-custom-args/captures/box-adapt-cases.scala
index faaf256e470b..351fab2bd8a5 100644
--- a/tests/neg-custom-args/captures/box-adapt-cases.scala
+++ b/tests/neg-custom-args/captures/box-adapt-cases.scala
@@ -7,21 +7,21 @@ def test1(): Unit = {
   x(cap => cap.use())  // error
 }
 
-def test2(io: Cap^{*}): Unit = {
+def test2(io: Cap^{cap}): Unit = {
   type Id[X] = [T] -> (op: X -> T) -> T
 
   val x: Id[Cap^{io}] = ???
   x(cap => cap.use())  // error
 }
 
-def test3(io: Cap^{*}): Unit = {
+def test3(io: Cap^{cap}): Unit = {
   type Id[X] = [T] -> (op: X ->{io} T) -> T
 
   val x: Id[Cap^{io}] = ???
   x(cap => cap.use())  // ok
 }
 
-def test4(io: Cap^{*}, fs: Cap^{*}): Unit = {
+def test4(io: Cap^{cap}, fs: Cap^{cap}): Unit = {
   type Id[X] = [T] -> (op: X ->{io} T) -> T
 
   val x: Id[Cap^{io, fs}] = ???
diff --git a/tests/neg-custom-args/captures/box-adapt-cov.scala b/tests/neg-custom-args/captures/box-adapt-cov.scala
index ebdb68cf0ca4..96901e81458d 100644
--- a/tests/neg-custom-args/captures/box-adapt-cov.scala
+++ b/tests/neg-custom-args/captures/box-adapt-cov.scala
@@ -1,12 +1,12 @@
 trait Cap
 
-def test1(io: Cap^{*}) = {
+def test1(io: Cap^{cap}) = {
   type Op[X] = [T] -> Unit -> X
   val f: Op[Cap^{io}] = ???
   val x: [T] -> Unit -> Cap^{io} = f  // error
 }
 
-def test2(io: Cap^{*}) = {
+def test2(io: Cap^{cap}) = {
   type Op[X] = [T] -> Unit -> X^{io}
   val f: Op[Cap^{io}] = ???
   val x: Unit -> Cap^{io} = f[Unit]  // error
diff --git a/tests/neg-custom-args/captures/box-adapt-cs.scala b/tests/neg-custom-args/captures/box-adapt-cs.scala
index a5344d52c30f..a39ed0200151 100644
--- a/tests/neg-custom-args/captures/box-adapt-cs.scala
+++ b/tests/neg-custom-args/captures/box-adapt-cs.scala
@@ -1,14 +1,14 @@
 trait Cap { def use(): Int }
 
-def test1(io: Cap^{*}): Unit = {
+def test1(io: Cap^{cap}): Unit = {
   type Id[X] = [T] -> (op: X ->{io} T) -> T
 
   val x: Id[Cap^{io}] = ???
-  val f: (Cap^{*}) -> Unit = ???
+  val f: (Cap^{cap}) -> Unit = ???
   x(f)  // ok
 }
 
-def test2(io: Cap^{*}): Unit = {
+def test2(io: Cap^{cap}): Unit = {
   type Id[X] = [T] -> (op: X => T) -> T
 
   val x: Id[Cap^] = ???
diff --git a/tests/neg-custom-args/captures/box-adapt-depfun.scala b/tests/neg-custom-args/captures/box-adapt-depfun.scala
index 357cfb4a8d9d..9416ffa040ab 100644
--- a/tests/neg-custom-args/captures/box-adapt-depfun.scala
+++ b/tests/neg-custom-args/captures/box-adapt-depfun.scala
@@ -15,7 +15,7 @@ def test2(io: Cap^): Unit = {
   // should work when the expected type is a dependent function
 }
 
-def test3(io: Cap^{*}): Unit = {
+def test3(io: Cap^{cap}): Unit = {
   type Id[X] = [T] -> (op: (x: X) ->{} T) -> T
 
   val x: Id[Cap^{io}] = ???
diff --git a/tests/neg-custom-args/captures/box-adapt-typefun.scala b/tests/neg-custom-args/captures/box-adapt-typefun.scala
index bbc953f74e9e..65a06cd68ed9 100644
--- a/tests/neg-custom-args/captures/box-adapt-typefun.scala
+++ b/tests/neg-custom-args/captures/box-adapt-typefun.scala
@@ -1,12 +1,12 @@
 trait Cap { def use(): Int }
 
-def test1(io: Cap^{*}): Unit = {
+def test1(io: Cap^{cap}): Unit = {
   type Op[X] = [T] -> X -> Unit
   val f: [T] -> (Cap^{io}) -> Unit = ???
   val op: Op[Cap^{io}] = f // error
 }
 
-def test2(io: Cap^{*}): Unit = {
+def test2(io: Cap^{cap}): Unit = {
   type Lazy[X] = [T] -> Unit -> X
   val f: Lazy[Cap^{io}] = ???
   val test: [T] -> Unit -> (Cap^{io}) = f // error
diff --git a/tests/neg-custom-args/captures/capt-depfun.scala b/tests/neg-custom-args/captures/capt-depfun.scala
index 95eed2c29659..20226b239198 100644
--- a/tests/neg-custom-args/captures/capt-depfun.scala
+++ b/tests/neg-custom-args/captures/capt-depfun.scala
@@ -1,6 +1,6 @@
 import annotation.retains
 class C
-type Cap = C @retains(caps.*)
+type Cap = C @retains(caps.cap)
 class Str
 
 def f(y: Cap, z: Cap) =
diff --git a/tests/neg-custom-args/captures/capt-depfun2.scala b/tests/neg-custom-args/captures/capt-depfun2.scala
index 52dd74aabf9f..cb4bc5f9634d 100644
--- a/tests/neg-custom-args/captures/capt-depfun2.scala
+++ b/tests/neg-custom-args/captures/capt-depfun2.scala
@@ -1,6 +1,6 @@
 import annotation.retains
 class C
-type Cap = C @retains(caps.*)
+type Cap = C @retains(caps.cap)
 class Str
 
 def f(y: Cap, z: Cap) =
diff --git a/tests/neg-custom-args/captures/capt-test.scala b/tests/neg-custom-args/captures/capt-test.scala
index 1799fc5073ca..13368aeea190 100644
--- a/tests/neg-custom-args/captures/capt-test.scala
+++ b/tests/neg-custom-args/captures/capt-test.scala
@@ -2,8 +2,8 @@ import annotation.retains
 import language.experimental.erasedDefinitions
 
 class CT[E <: Exception]
-type CanThrow[E <: Exception] = CT[E] @retains(caps.*)
-type Top  = Any @retains(caps.*)
+type CanThrow[E <: Exception] = CT[E] @retains(caps.cap)
+type Top  = Any @retains(caps.cap)
 
 infix type throws[R, E <: Exception] = (erased CanThrow[E]) ?=> R
 
diff --git a/tests/neg-custom-args/captures/capt1.scala b/tests/neg-custom-args/captures/capt1.scala
index 59ba874b02f5..69b4c9984494 100644
--- a/tests/neg-custom-args/captures/capt1.scala
+++ b/tests/neg-custom-args/captures/capt1.scala
@@ -1,21 +1,21 @@
 import annotation.retains
 class C
-def f(x: C @retains(caps.*), y: C): () -> C =
+def f(x: C @retains(caps.cap), y: C): () -> C =
   () => if x == null then y else y  // error
 
-def g(x: C @retains(caps.*), y: C): Matchable =
+def g(x: C @retains(caps.cap), y: C): Matchable =
   () => if x == null then y else y  // error
 
-def h1(x: C @retains(caps.*), y: C): Any =
+def h1(x: C @retains(caps.cap), y: C): Any =
   def f() = if x == null then y else y
   () => f()  // ok
 
-def h2(x: C @retains(caps.*)): Matchable =
+def h2(x: C @retains(caps.cap)): Matchable =
   def f(y: Int) = if x == null then y else y  // error
   f
 
 class A
-type Cap = C @retains(caps.*)
+type Cap = C @retains(caps.cap)
 
 def h3(x: Cap): A =
   class F(y: Int) extends A:   // error
@@ -27,7 +27,7 @@ def h4(x: Cap, y: Int): A =
     def m() = if x == null then y else y
 
 def foo() =
-  val x: C @retains(caps.*) = ???
+  val x: C @retains(caps.cap) = ???
   def h[X](a: X)(b: X) = a
   val z2 = h[() -> Cap](() => x) // error
     (() => C())  // error
diff --git a/tests/neg-custom-args/captures/capt3.scala b/tests/neg-custom-args/captures/capt3.scala
index 84164d433029..44a7ffdc6c4a 100644
--- a/tests/neg-custom-args/captures/capt3.scala
+++ b/tests/neg-custom-args/captures/capt3.scala
@@ -1,6 +1,6 @@
 import annotation.retains
 class C
-type Cap = C @retains(caps.*)
+type Cap = C @retains(caps.cap)
 
 def test1() =
   val x: Cap = C()
diff --git a/tests/neg-custom-args/captures/cc-this2.check b/tests/neg-custom-args/captures/cc-this2.check
index 9db2f4efcc5a..e0df7c857c85 100644
--- a/tests/neg-custom-args/captures/cc-this2.check
+++ b/tests/neg-custom-args/captures/cc-this2.check
@@ -2,5 +2,5 @@
 -- Error: tests/neg-custom-args/captures/cc-this2/D_2.scala:2:6 --------------------------------------------------------
 2 |class D extends C: // error
   |^
-  |reference (scala.caps.* : Any) is not included in allowed capture set {} of pure base class class C
+  |reference (scala.caps.cap : Any) is not included in allowed capture set {} of pure base class class C
 3 |  this: D^ =>
diff --git a/tests/neg-custom-args/captures/cc1.scala b/tests/neg-custom-args/captures/cc1.scala
index 10a9793eabe8..6787b417a3b2 100644
--- a/tests/neg-custom-args/captures/cc1.scala
+++ b/tests/neg-custom-args/captures/cc1.scala
@@ -1,5 +1,5 @@
 import annotation.retains
 object Test:
 
-  def f[A <: Matchable @retains(caps.*)](x: A): Matchable = x // error
+  def f[A <: Matchable @retains(caps.cap)](x: A): Matchable = x // error
 
diff --git a/tests/neg-custom-args/captures/exception-definitions.check b/tests/neg-custom-args/captures/exception-definitions.check
index 23dbe0fb6529..8dca91bc8e43 100644
--- a/tests/neg-custom-args/captures/exception-definitions.check
+++ b/tests/neg-custom-args/captures/exception-definitions.check
@@ -1,7 +1,7 @@
 -- Error: tests/neg-custom-args/captures/exception-definitions.scala:2:6 -----------------------------------------------
 2 |class Err extends Exception: // error
   |^
-  |reference (scala.caps.* : Any) is not included in allowed capture set {} of pure base class class Throwable
+  |reference (scala.caps.cap : Any) is not included in allowed capture set {} of pure base class class Throwable
 3 |  self: Err^ =>
 -- Error: tests/neg-custom-args/captures/exception-definitions.scala:10:6 ----------------------------------------------
 10 |class Err4(c: Any^) extends AnyVal // error
diff --git a/tests/neg-custom-args/captures/heal-tparam-cs.scala b/tests/neg-custom-args/captures/heal-tparam-cs.scala
index f4c293e33d01..173de2b1cbb5 100644
--- a/tests/neg-custom-args/captures/heal-tparam-cs.scala
+++ b/tests/neg-custom-args/captures/heal-tparam-cs.scala
@@ -2,16 +2,16 @@ import language.experimental.captureChecking
 
 trait Cap { def use(): Unit }
 
-def localCap[T](op: (cap: Cap^{*}) => T): T = ???
+def localCap[T](op: (cap: Cap^{cap}) => T): T = ???
 
-def main(io: Cap^{*}, net: Cap^{*}): Unit = {
+def main(io: Cap^{cap}, net: Cap^{cap}): Unit = {
   val test1 = localCap { cap => // error
     () => { cap.use() }
   }
 
-  val test2: (cap: Cap^{*}) -> () ->{cap} Unit =
+  val test2: (cap: Cap^{cap}) -> () ->{cap} Unit =
     localCap { cap =>  // should work
-      (cap1: Cap^{*}) => () => { cap1.use() }
+      (cap1: Cap^{cap}) => () => { cap1.use() }
     }
 
   val test3: (cap: Cap^{io}) -> () ->{io} Unit =
diff --git a/tests/neg-custom-args/captures/i15049.scala b/tests/neg-custom-args/captures/i15049.scala
index f12bb8028797..bc65db2147f8 100644
--- a/tests/neg-custom-args/captures/i15049.scala
+++ b/tests/neg-custom-args/captures/i15049.scala
@@ -1,8 +1,8 @@
 class Session:
   def request = "Response"
 class Foo:
-  private val session: Session^{*} = new Session
-  def withSession[T](f: (Session^{*}) => T): T = f(session)
+  private val session: Session^{cap} = new Session
+  def withSession[T](f: (Session^{cap}) => T): T = f(session)
 
 def Test =
   val f = new Foo
diff --git a/tests/neg-custom-args/captures/i15749.scala b/tests/neg-custom-args/captures/i15749.scala
index b5aa233e7401..32947c146021 100644
--- a/tests/neg-custom-args/captures/i15749.scala
+++ b/tests/neg-custom-args/captures/i15749.scala
@@ -1,9 +1,9 @@
 class Unit
 object unit extends Unit
 
-type Top = Any^{*}
+type Top = Any^{cap}
 
-type LazyVal[T] = Unit ->{*} T
+type LazyVal[T] = Unit ->{cap} T
 
 class Foo[T](val x: T)
 
@@ -11,5 +11,5 @@ class Foo[T](val x: T)
 type BoxedLazyVal[T] = Foo[LazyVal[T]]
 
 def force[A](v: BoxedLazyVal[A]): A =
-  // Γ ⊢ v.x : □ {*} Unit -> A
+  // Γ ⊢ v.x : □ {cap} Unit -> A
   v.x(unit)  // error: (unbox v.x)(unit), where (unbox v.x) should be untypable
\ No newline at end of file
diff --git a/tests/neg-custom-args/captures/i15749a.scala b/tests/neg-custom-args/captures/i15749a.scala
index 8a39db98c964..e4d70efa5206 100644
--- a/tests/neg-custom-args/captures/i15749a.scala
+++ b/tests/neg-custom-args/captures/i15749a.scala
@@ -3,19 +3,19 @@ object unit extends Unit
 
 type Top = Any^
 
-type Wrapper[T] = [X] -> (op: T ->{*} X) -> X
+type Wrapper[T] = [X] -> (op: T ->{cap} X) -> X
 
 def test =
 
   def wrapper[T](x: T): Wrapper[T] =
-    [X] => (op: T ->{*} X) => op(x)
+    [X] => (op: T ->{cap} X) => op(x)
 
-  def strictMap[A <: Top, B <: Top](mx: Wrapper[A])(f: A ->{*} B): Wrapper[B] =
+  def strictMap[A <: Top, B <: Top](mx: Wrapper[A])(f: A ->{cap} B): Wrapper[B] =
     mx((x: A) => wrapper(f(x)))
 
-  def force[A](thunk: Unit ->{*} A): A = thunk(unit)
+  def force[A](thunk: Unit ->{cap} A): A = thunk(unit)
 
-  def forceWrapper[A](mx: Wrapper[Unit ->{*} A]): Wrapper[A] =
-    // Γ ⊢ mx: Wrapper[□ {*} Unit => A]
-    // `force` should be typed as ∀(□ {*} Unit -> A) A, but it can not
-    strictMap[Unit ->{*} A, A](mx)(t => force[A](t)) // error
+  def forceWrapper[A](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 ->{cap} A, A](mx)(t => force[A](t)) // error
diff --git a/tests/neg-custom-args/captures/i15923-cases.scala b/tests/neg-custom-args/captures/i15923-cases.scala
index 2b034009fdc7..9a103c976a8e 100644
--- a/tests/neg-custom-args/captures/i15923-cases.scala
+++ b/tests/neg-custom-args/captures/i15923-cases.scala
@@ -2,14 +2,14 @@ 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^{*}]) = {
+def foo(x: Id[Cap^{cap}]) = {
   x(_.use())  // error
 }
 
-def bar(io: Cap^{*}, x: Id[Cap^{io}]) = {
+def bar(io: Cap^{cap}, x: Id[Cap^{io}]) = {
   x(_.use())
 }
 
-def barAlt(a: Cap^{*}, b: Cap^{*}, x: Id[Cap]^{a, b}) = {
+def barAlt(a: Cap^{cap}, b: Cap^{cap}, x: Id[Cap]^{a, b}) = {
   x(_.use())
 }
diff --git a/tests/neg-custom-args/captures/i16114.scala b/tests/neg-custom-args/captures/i16114.scala
index 706196fd7182..d22c7f02d5fb 100644
--- a/tests/neg-custom-args/captures/i16114.scala
+++ b/tests/neg-custom-args/captures/i16114.scala
@@ -11,7 +11,7 @@ def withCap[T](op: Cap^ => T): T = {
 }
 
 def main(fs: Cap^): Unit = {
-  def badOp(io: Cap^{*}): Unit ->{} Unit = {
+  def badOp(io: Cap^{cap}): Unit ->{} Unit = {
     val op1: Unit ->{io} Unit = (x: Unit) =>  // error // limitation
       expect[Cap^] {
         io.use()
diff --git a/tests/neg-custom-args/captures/io.scala b/tests/neg-custom-args/captures/io.scala
index ae686d6b154e..f481bf357fc8 100644
--- a/tests/neg-custom-args/captures/io.scala
+++ b/tests/neg-custom-args/captures/io.scala
@@ -3,17 +3,17 @@ sealed trait IO:
   def puts(msg: Any): Unit = println(msg)
 
 def test1 =
-  val IO : IO @retains(caps.*) = new IO {}
+  val IO : IO @retains(caps.cap) = new IO {}
   def foo = {IO; IO.puts("hello") }
   val x : () -> Unit = () => foo  // error: Found: (() -> Unit) retains IO; Required: () -> Unit
 
 def test2 =
-  val IO : IO @retains(caps.*) = new IO {}
-  def puts(msg: Any, io: IO @retains(caps.*)) = println(msg)
+  val IO : IO @retains(caps.cap) = new IO {}
+  def puts(msg: Any, io: IO @retains(caps.cap)) = println(msg)
   def foo() = puts("hello", IO)
   val x : () -> Unit = () => foo()  // error: Found: (() -> Unit) retains IO; Required: () -> Unit
 
-type Capability[T] = T @retains(caps.*)
+type Capability[T] = T @retains(caps.cap)
 
 def test3 =
   val IO : Capability[IO] = new IO {}
diff --git a/tests/neg-custom-args/captures/lazylists-exceptions.check b/tests/neg-custom-args/captures/lazylists-exceptions.check
index 4c451b1fea8a..03278f25e8dc 100644
--- a/tests/neg-custom-args/captures/lazylists-exceptions.check
+++ b/tests/neg-custom-args/captures/lazylists-exceptions.check
@@ -1,7 +1,7 @@
 -- 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 `*`.
+   |  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.
 37 |    tabulate(10) { i =>
 38 |      if i > 9 then throw Ex1()
diff --git a/tests/neg-custom-args/captures/lazylists1.scala b/tests/neg-custom-args/captures/lazylists1.scala
index 88d9e5672b5d..99472c13ebec 100644
--- a/tests/neg-custom-args/captures/lazylists1.scala
+++ b/tests/neg-custom-args/captures/lazylists1.scala
@@ -1,8 +1,8 @@
 class CC
-type Cap = CC^{*}
+type Cap = CC^{cap}
 
 trait LazyList[+A]:
-  this: LazyList[A]^{*} =>
+  this: LazyList[A]^{cap} =>
 
   def isEmpty: Boolean
   def head: A
@@ -13,7 +13,7 @@ object LazyNil extends LazyList[Nothing]:
   def head = ???
   def tail = ???
 
-extension [A](xs: LazyList[A]^{*})
+extension [A](xs: LazyList[A]^{cap})
   def map[B](f: A => B): LazyList[B]^{xs, f} =
     final class Mapped extends LazyList[B]:
       this: (Mapped^{xs, f}) =>
diff --git a/tests/neg-custom-args/captures/override-adapt-box-selftype.scala b/tests/neg-custom-args/captures/override-adapt-box-selftype.scala
index 32efd57b5b5a..f44add78e246 100644
--- a/tests/neg-custom-args/captures/override-adapt-box-selftype.scala
+++ b/tests/neg-custom-args/captures/override-adapt-box-selftype.scala
@@ -15,7 +15,7 @@ object Test1 {
   }
 }
 
-def Test2(io: IO^{*}, fs: IO^{io}, ct: IO^) = {
+def Test2(io: IO^{cap}, fs: IO^{io}, ct: IO^) = {
   abstract class A[X] { this: A[X]^{io} =>
     def foo(x: X): X
   }
diff --git a/tests/neg-custom-args/captures/override-adapt-box.scala b/tests/neg-custom-args/captures/override-adapt-box.scala
index 8b6d8e2b8afd..70023dfbc941 100644
--- a/tests/neg-custom-args/captures/override-adapt-box.scala
+++ b/tests/neg-custom-args/captures/override-adapt-box.scala
@@ -7,7 +7,7 @@ abstract class A[X] { this: A[X]^{} =>
 class IO
 class C
 
-def test(io: IO^{*}) = {
+def test(io: IO^{cap}) = {
   class B extends A[C^{io}] {  // X =:= {io} C  // error
     override def foo(x: C^{io}): C^{io} = ???
   }
diff --git a/tests/neg-custom-args/captures/override-boxed.scala b/tests/neg-custom-args/captures/override-boxed.scala
index 1e7afd5e3d09..d66d28d15aaa 100644
--- a/tests/neg-custom-args/captures/override-boxed.scala
+++ b/tests/neg-custom-args/captures/override-boxed.scala
@@ -1,7 +1,7 @@
 
 class A
 
-def test(x: Any^{*}) =
+def test(x: Any^{cap}) =
   abstract class Getter:
     def get(): A^{x}
   class PolyGetter[T <: A^{x}] extends Getter:
diff --git a/tests/neg-custom-args/captures/real-try.check b/tests/neg-custom-args/captures/real-try.check
index c46d1e075075..0b4da5af27b5 100644
--- a/tests/neg-custom-args/captures/real-try.check
+++ b/tests/neg-custom-args/captures/real-try.check
@@ -1,7 +1,7 @@
 -- Error: tests/neg-custom-args/captures/real-try.scala:12:2 -----------------------------------------------------------
 12 |  try  // error
    |  ^
-   |  The expression's type () => Unit is not allowed to capture the root capability `*`.
+   |  The expression's type () => Unit is not allowed to capture the root capability `cap`.
    |  This usually means that a capability persists longer than its allowed lifetime.
 13 |    () => foo(1)
 14 |  catch
@@ -10,7 +10,7 @@
 -- Error: tests/neg-custom-args/captures/real-try.scala:18:2 -----------------------------------------------------------
 18 |  try  // error
    |  ^
-   |  The expression's type () => Cell[Unit]^? is not allowed to capture the root capability `*`.
+   |  The expression's type () => Cell[Unit]^? is not allowed to capture the root capability `cap`.
    |  This usually means that a capability persists longer than its allowed lifetime.
 19 |    () => Cell(foo(1))
 20 |  catch
@@ -19,5 +19,5 @@
 -- Error: tests/neg-custom-args/captures/real-try.scala:30:4 -----------------------------------------------------------
 30 |  b.x // error
    |  ^^^
-   |  The expression's type box () => Unit is not allowed to capture the root capability `*`.
+   |  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.
diff --git a/tests/neg-custom-args/captures/real-try.scala b/tests/neg-custom-args/captures/real-try.scala
index 94e1eafd9af2..03e168032122 100644
--- a/tests/neg-custom-args/captures/real-try.scala
+++ b/tests/neg-custom-args/captures/real-try.scala
@@ -22,7 +22,7 @@ def test() =
     case _: Ex2 => ???
 
   val b = try  // ok here, but error on use
-    Cell(() => foo(1))//: Cell[box {ev} () => Unit] <: Cell[box {*} () => Unit]
+    Cell(() => foo(1))//: Cell[box {ev} () => Unit] <: Cell[box {cap} () => Unit]
   catch
     case _: Ex1 => ???
     case _: Ex2 => ???
diff --git a/tests/neg-custom-args/captures/try.check b/tests/neg-custom-args/captures/try.check
index 604f7bb1efb4..f85ca468e6e5 100644
--- a/tests/neg-custom-args/captures/try.check
+++ b/tests/neg-custom-args/captures/try.check
@@ -38,7 +38,7 @@
 39 |        22
 40 |  } {  // error
    |           ^
-   |           The expression's type box () => Int is not allowed to capture the root capability `*`.
+   |           The expression's type box () => Int is not allowed to capture the root capability `cap`.
    |           This usually means that a capability persists longer than its allowed lifetime.
 41 |    (ex: Exception) => () => 22
 42 |  }
diff --git a/tests/neg-custom-args/captures/try.scala b/tests/neg-custom-args/captures/try.scala
index 9489766d41be..ef375c62b817 100644
--- a/tests/neg-custom-args/captures/try.scala
+++ b/tests/neg-custom-args/captures/try.scala
@@ -2,8 +2,8 @@ import annotation.retains
 import language.experimental.erasedDefinitions
 
 class CT[E <: Exception]
-type CanThrow[E <: Exception] = CT[E] @retains(caps.*)
-type Top  = Any @retains(caps.*)
+type CanThrow[E <: Exception] = CT[E] @retains(caps.cap)
+type Top  = Any @retains(caps.cap)
 
 infix type throws[R, E <: Exception] = (erased CanThrow[E]) ?=> R
 
diff --git a/tests/neg-custom-args/captures/usingLogFile.check b/tests/neg-custom-args/captures/usingLogFile.check
index 99e895c74ee7..17b9146ce71c 100644
--- a/tests/neg-custom-args/captures/usingLogFile.check
+++ b/tests/neg-custom-args/captures/usingLogFile.check
@@ -2,11 +2,11 @@
 33 |  later3() // error
    |  ^^^^^^
    |  box () => Unit cannot be box-converted to a type that can be selected or applied
-   |  since one of their capture sets contains the root capability `*`
+   |  since one of their capture sets contains the root capability `cap`
 -- Error: tests/neg-custom-args/captures/usingLogFile.scala:37:9 -------------------------------------------------------
 37 |  later4.x() // error
    |  ^^^^^^^^
-   |  The expression's type box () => Unit is not allowed to capture the root capability `*`.
+   |  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/usingLogFile.scala:23:6 -------------------------------------------------------
 23 |  val later = usingLogFile { f => () => f.write(0) } // error
@@ -18,7 +18,7 @@
 -- Error: tests/neg-custom-args/captures/usingLogFile.scala:29:9 -------------------------------------------------------
 29 |  later2.x()  // error
    |  ^^^^^^^^
-   |  The expression's type box () => Unit is not allowed to capture the root capability `*`.
+   |  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/usingLogFile.scala:47:6 -------------------------------------------------------
 47 |  val later = usingLogFile { f => () => f.write(0) } // error
@@ -30,10 +30,10 @@
 -- Error: tests/neg-custom-args/captures/usingLogFile.scala:62:25 ------------------------------------------------------
 62 |    val later = usingFile("out", f => (y: Int) => xs.foreach(x => f.write(x + y))) // error
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |                The expression's type box (x$0: Int) => Unit is not allowed to capture the root capability `*`.
-   |                This usually means that a capability persists longer than its allowed lifetime.
+   |               The expression's type box (x$0: Int) => 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/usingLogFile.scala:71:25 ------------------------------------------------------
 71 |    val later = usingFile("logfile", usingLogger(_, l => () => l.log("test"))) // error
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |                The expression's type box () => Unit is not allowed to capture the root capability `*`.
+   |                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.
diff --git a/tests/neg-custom-args/captures/vars.check b/tests/neg-custom-args/captures/vars.check
index b0420c7e5179..565101359673 100644
--- a/tests/neg-custom-args/captures/vars.check
+++ b/tests/neg-custom-args/captures/vars.check
@@ -16,16 +16,16 @@
 16 |  a("")  // error
    |  ^
    |  box String => String cannot be box-converted to a type that can be selected or applied
-   |  since one of their capture sets contains the root capability `*`
+   |  since one of their capture sets contains the root capability `cap`
 -- Error: tests/neg-custom-args/captures/vars.scala:17:4 ---------------------------------------------------------------
 17 |  b.head // error
    |  ^^^^^^
-   |  The expression's type box String => String is not allowed to capture the root capability `*`.
+   |  The expression's type box String => String 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/vars.scala:32:8 ---------------------------------------------------------------
 32 |  local { cap3 => // error
    |  ^
-   |  The expression's type box (x$0: String) => String is not allowed to capture the root capability `*`.
+   |  The expression's type box (x$0: String) => String is not allowed to capture the root capability `cap`.
    |  This usually means that a capability persists longer than its allowed lifetime.
 33 |    def g(x: String): String = if cap3 == cap3 then "" else "a"
 34 |    g
diff --git a/tests/pos-custom-args/captures/byname.scala b/tests/pos-custom-args/captures/byname.scala
index 780214ebdffd..efd76618469d 100644
--- a/tests/pos-custom-args/captures/byname.scala
+++ b/tests/pos-custom-args/captures/byname.scala
@@ -6,7 +6,7 @@ class I
 
 def test(cap1: Cap, cap2: Cap): I^{cap1} =
   def f() = if cap1 == cap1 then I() else I()
-  def h(x: ->{any} I) = x
+  def h(x: ->{cap} I) = x
   h(f()) // OK
   def hh(x: -> I @retainsByName(cap1)) = x
   h(f())
diff --git a/tests/pos-custom-args/captures/caps-universal.scala b/tests/pos-custom-args/captures/caps-universal.scala
index 77ce10c4e42e..3768c640fd68 100644
--- a/tests/pos-custom-args/captures/caps-universal.scala
+++ b/tests/pos-custom-args/captures/caps-universal.scala
@@ -1,7 +1,7 @@
 import annotation.retains
 
 val foo: Int => Int = x => x
-val bar: (Int -> Int) @retains(caps.*) = foo
+val bar: (Int -> Int) @retains(caps.cap) = foo
 val baz: Int => Int = bar
 
 
diff --git a/tests/pos-custom-args/captures/capt-depfun.scala b/tests/pos-custom-args/captures/capt-depfun.scala
index 3a896b8acb8e..e3abbe0994c5 100644
--- a/tests/pos-custom-args/captures/capt-depfun.scala
+++ b/tests/pos-custom-args/captures/capt-depfun.scala
@@ -1,6 +1,6 @@
 import annotation.retains
 class C
-type Cap = C @retains(caps.*)
+type Cap = C @retains(caps.cap)
 
 type T = (x: Cap) -> String @retains(x)
 
@@ -8,7 +8,7 @@ type ID[X] = X
 
 val aa: ((x: Cap) -> String @retains(x)) = (x: Cap) => ""
 
-def f(y: Cap, z: Cap): String @retains(caps.*) =
+def f(y: Cap, z: Cap): String @retains(caps.cap) =
   val a: ((x: Cap) -> String @retains(x)) = (x: Cap) => ""
   val b = a(y)
   val c: String @retains(y) = b
diff --git a/tests/pos-custom-args/captures/capt-depfun2.scala b/tests/pos-custom-args/captures/capt-depfun2.scala
index 96e97de95d72..e4645cfcc920 100644
--- a/tests/pos-custom-args/captures/capt-depfun2.scala
+++ b/tests/pos-custom-args/captures/capt-depfun2.scala
@@ -1,6 +1,6 @@
 import annotation.retains
 class C
-type Cap = C @retains(caps.*)
+type Cap = C @retains(caps.cap)
 
 def f(y: Cap, z: Cap) =
   def g(): C @retains(y, z) = ???
diff --git a/tests/pos-custom-args/captures/capt0.scala b/tests/pos-custom-args/captures/capt0.scala
index fca48170b6f5..013ff3a4ee19 100644
--- a/tests/pos-custom-args/captures/capt0.scala
+++ b/tests/pos-custom-args/captures/capt0.scala
@@ -3,5 +3,5 @@ object Test:
   def test() =
     val x: Any^ = "abc"
     val y: Object @scala.annotation.retains(x) = ???
-    val z: Object @scala.annotation.retains(x, caps.*) = y: Object @annotation.retains(x)
+    val z: Object @scala.annotation.retains(x, caps.cap) = y: Object @annotation.retains(x)
 
diff --git a/tests/pos-custom-args/captures/capt1.scala b/tests/pos-custom-args/captures/capt1.scala
index 865b382f4e9f..8d2285f1fa50 100644
--- a/tests/pos-custom-args/captures/capt1.scala
+++ b/tests/pos-custom-args/captures/capt1.scala
@@ -3,7 +3,7 @@ type Cap = C^
 def f1(c: Cap): () ->{c} c.type = () => c // ok
 
 def f2: Int =
-  val g: Boolean ->{any} Int = ???
+  val g: Boolean ->{cap} Int = ???
   val x = g(true)
   x
 
diff --git a/tests/pos-custom-args/captures/capt2.scala b/tests/pos-custom-args/captures/capt2.scala
index 498dbd371ca0..45381bf602ed 100644
--- a/tests/pos-custom-args/captures/capt2.scala
+++ b/tests/pos-custom-args/captures/capt2.scala
@@ -1,6 +1,6 @@
 import annotation.retains
 class C
-type Cap = C @retains(caps.*)
+type Cap = C @retains(caps.cap)
 
 def test1() =
   val y: String^ = ""
diff --git a/tests/pos-custom-args/captures/cc-expand.scala b/tests/pos-custom-args/captures/cc-expand.scala
index 1d398353a5ec..1bed7b1cf001 100644
--- a/tests/pos-custom-args/captures/cc-expand.scala
+++ b/tests/pos-custom-args/captures/cc-expand.scala
@@ -5,7 +5,7 @@ object Test:
   class B
   class C
   class CTC
-  type CT = CTC @retains(caps.*)
+  type CT = CTC @retains(caps.cap)
 
   def test(ct: CT, dt: CT) =
 
diff --git a/tests/pos-custom-args/captures/overrides.scala b/tests/pos-custom-args/captures/overrides.scala
index 7e70afe7a327..ac5b9cd9ddc4 100644
--- a/tests/pos-custom-args/captures/overrides.scala
+++ b/tests/pos-custom-args/captures/overrides.scala
@@ -1,4 +1,4 @@
-import caps.*
+import caps.cap
 
 abstract class Foo:
   def foo: () => Unit = () => ()
diff --git a/tests/pos-custom-args/captures/try.scala b/tests/pos-custom-args/captures/try.scala
index b2dcf6f11dd0..05c41be69001 100644
--- a/tests/pos-custom-args/captures/try.scala
+++ b/tests/pos-custom-args/captures/try.scala
@@ -2,7 +2,7 @@ import annotation.retains
 import language.experimental.erasedDefinitions
 
 class CT[E <: Exception]
-type CanThrow[E <: Exception] = CT[E] @retains(caps.*)
+type CanThrow[E <: Exception] = CT[E] @retains(caps.cap)
 
 infix type throws[R, E <: Exception] = (erased CanThrow[E]) ?-> R
 
diff --git a/tests/pos-with-compiler-cc/dotc/ast/Trees.scala b/tests/pos-with-compiler-cc/dotc/ast/Trees.scala
index aa1c06a7ca85..0b1842603316 100644
--- a/tests/pos-with-compiler-cc/dotc/ast/Trees.scala
+++ b/tests/pos-with-compiler-cc/dotc/ast/Trees.scala
@@ -1394,7 +1394,7 @@ object Trees {
         case _ =>
           sourced
 
-    abstract class TreeMap(val cpy: TreeCopier = inst.cpy) { self: TreeMap @retains(caps.*) =>
+    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")
@@ -1520,7 +1520,7 @@ object Trees {
       }
     }
 
-    abstract class TreeAccumulator[X] { self: TreeAccumulator[X] @retains(caps.*) =>
+    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
 
diff --git a/tests/pos-with-compiler-cc/dotc/ast/untpd.scala b/tests/pos-with-compiler-cc/dotc/ast/untpd.scala
index b4dc6d0622c0..a6d3bc5a072c 100644
--- a/tests/pos-with-compiler-cc/dotc/ast/untpd.scala
+++ b/tests/pos-with-compiler-cc/dotc/ast/untpd.scala
@@ -742,7 +742,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   }
 
   abstract class UntypedTreeAccumulator[X] extends TreeAccumulator[X] {
-    self: UntypedTreeAccumulator[X] @retains(caps.*) =>
+    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)
diff --git a/tests/pos-with-compiler-cc/dotc/cc/CaptureAnnotation.scala b/tests/pos-with-compiler-cc/dotc/cc/CaptureAnnotation.scala
index 2e750865f407..67222f07efbb 100644
--- a/tests/pos-with-compiler-cc/dotc/cc/CaptureAnnotation.scala
+++ b/tests/pos-with-compiler-cc/dotc/cc/CaptureAnnotation.scala
@@ -51,7 +51,7 @@ case class CaptureAnnotation(refs: CaptureSet, boxed: Boolean)(cls: Symbol) exte
       this.refs == refs && this.boxed == boxed && this.symbol == that.symbol
     case _ => false
 
-  override def mapWith(tm: TypeMap @retains(caps.*))(using Context) =
+  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
diff --git a/tests/pos-with-compiler-cc/dotc/core/Annotations.scala b/tests/pos-with-compiler-cc/dotc/core/Annotations.scala
index f3fee3da78ec..f307d4a36697 100644
--- a/tests/pos-with-compiler-cc/dotc/core/Annotations.scala
+++ b/tests/pos-with-compiler-cc/dotc/core/Annotations.scala
@@ -55,7 +55,7 @@ object Annotations {
      *  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.*))(using Context) =
+    def mapWith(tm: TypeMap @retains(caps.cap))(using Context) =
       val args = arguments
       if args.isEmpty then this
       else
diff --git a/tests/pos-with-compiler-cc/dotc/core/Contexts.scala b/tests/pos-with-compiler-cc/dotc/core/Contexts.scala
index 2ce714937f97..37fde2d7b604 100644
--- a/tests/pos-with-compiler-cc/dotc/core/Contexts.scala
+++ b/tests/pos-with-compiler-cc/dotc/core/Contexts.scala
@@ -110,7 +110,7 @@ object Contexts {
   inline def inDetachedContext[T](inline op: DetachedContext ?-> T)(using ctx: Context): T =
     op(using ctx.detach)
 
-  type Context = ContextCls @retains(caps.*)
+  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
diff --git a/tests/pos-with-compiler-cc/dotc/core/Decorators.scala b/tests/pos-with-compiler-cc/dotc/core/Decorators.scala
index a4c3938a0909..f9844c6eaab6 100644
--- a/tests/pos-with-compiler-cc/dotc/core/Decorators.scala
+++ b/tests/pos-with-compiler-cc/dotc/core/Decorators.scala
@@ -84,7 +84,7 @@ object Decorators {
    *  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.*)): List[U] =
+    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] = {
@@ -230,11 +230,11 @@ object Decorators {
   end extension
 
   extension [T](xs: Seq[T])
-    final def collectCC[U](pf: PartialFunction[T, U] @retains(caps.*)): Seq[U] =
+    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.*))
-    def orElseCC(g: PartialFunction[A, B] @retains(caps.*)): PartialFunction[A, B] @retains(f, g) =
+  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)
diff --git a/tests/pos-with-compiler-cc/dotc/core/GadtConstraint.scala b/tests/pos-with-compiler-cc/dotc/core/GadtConstraint.scala
index 46b7e07649b8..fcf1215c604f 100644
--- a/tests/pos-with-compiler-cc/dotc/core/GadtConstraint.scala
+++ b/tests/pos-with-compiler-cc/dotc/core/GadtConstraint.scala
@@ -225,7 +225,7 @@ sealed trait GadtConstraint (
 
   // ---- Private ----------------------------------------------------------
 
-  private def externalize(tp: Type, theMap: TypeMap @retains(caps.*) | Null = null)(using Context): Type = tp match
+  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
@@ -238,7 +238,7 @@ sealed trait GadtConstraint (
   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.*) | Null = null)(using Context): Boolean = tp match {
+  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 =>
diff --git a/tests/pos-with-compiler-cc/dotc/core/Names.scala b/tests/pos-with-compiler-cc/dotc/core/Names.scala
index cb68299101ad..e6ea66f4025b 100644
--- a/tests/pos-with-compiler-cc/dotc/core/Names.scala
+++ b/tests/pos-with-compiler-cc/dotc/core/Names.scala
@@ -74,10 +74,10 @@ object Names {
      *  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.*)): ThisName
+    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.*)): ThisName =
+    def replaceDeep(f: PartialFunction[Name, Name] @retains(caps.cap)): ThisName =
       replace(f.orElseCC {
         case DerivedName(underlying, info: QualifiedInfo) =>
           underlying.replaceDeep(f).derived(info)
@@ -340,7 +340,7 @@ object Names {
     override def toSimpleName: SimpleName = this
     override final def mangle: SimpleName = encode
 
-    override def replace(f: PartialFunction[Name, Name] @retains(caps.*)): ThisName =
+    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)
@@ -440,7 +440,7 @@ object Names {
     override def mangled: TypeName = toTermName.mangled.toTypeName
     override def mangledString: String = toTermName.mangledString
 
-    override def replace(f: PartialFunction[Name, Name] @retains(caps.*)): ThisName = toTermName.replace(f).toTypeName
+    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
@@ -473,7 +473,7 @@ object Names {
     override def toSimpleName: SimpleName = termName(toString)
     override final def mangle: SimpleName = encode.toSimpleName
 
-    override def replace(f: PartialFunction[Name, Name] @retains(caps.*)): ThisName =
+    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
diff --git a/tests/pos-with-compiler-cc/dotc/core/Substituters.scala b/tests/pos-with-compiler-cc/dotc/core/Substituters.scala
index 1e86274f663e..6f7e02ec4dde 100644
--- a/tests/pos-with-compiler-cc/dotc/core/Substituters.scala
+++ b/tests/pos-with-compiler-cc/dotc/core/Substituters.scala
@@ -10,7 +10,7 @@ import annotation.retains
  */
 object Substituters:
 
-  final def subst(tp: Type, from: BindingType, to: BindingType, theMap: SubstBindingMap @retains(caps.*) | Null)(using Context): Type =
+  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
@@ -26,7 +26,7 @@ object Substituters:
           .mapOver(tp)
     }
 
-  final def subst1(tp: Type, from: Symbol, to: Type, theMap: Subst1Map @retains(caps.*) | Null)(using Context): Type =
+  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
@@ -40,7 +40,7 @@ object Substituters:
           .mapOver(tp)
     }
 
-  final def subst2(tp: Type, from1: Symbol, to1: Type, from2: Symbol, to2: Type, theMap: Subst2Map @retains(caps.*)  | Null)(using Context): Type =
+  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
@@ -55,7 +55,7 @@ object Substituters:
           .mapOver(tp)
     }
 
-  final def subst(tp: Type, from: List[Symbol], to: List[Type], theMap: SubstMap @retains(caps.*) | Null)(using Context): Type =
+  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
@@ -75,7 +75,7 @@ object Substituters:
           .mapOver(tp)
     }
 
-  final def substSym(tp: Type, from: List[Symbol], to: List[Symbol], theMap: SubstSymMap @retains(caps.*) | Null)(using Context): Type =
+  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
@@ -106,7 +106,7 @@ object Substituters:
           .mapOver(tp)
     }
 
-  final def substThis(tp: Type, from: ClassSymbol, to: Type, theMap: SubstThisMap @retains(caps.*) | Null)(using Context): Type =
+  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
@@ -120,7 +120,7 @@ object Substituters:
           .mapOver(tp)
     }
 
-  final def substRecThis(tp: Type, from: Type, to: Type, theMap: SubstRecThisMap @retains(caps.*) | Null)(using Context): Type =
+  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
@@ -134,7 +134,7 @@ object Substituters:
           .mapOver(tp)
     }
 
-  final def substParam(tp: Type, from: ParamRef, to: Type, theMap: SubstParamMap @retains(caps.*) | Null)(using Context): Type =
+  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
@@ -148,7 +148,7 @@ object Substituters:
           .mapOver(tp)
     }
 
-  final def substParams(tp: Type, from: BindingType, to: List[Type], theMap: SubstParamsMap @retains(caps.*) | Null)(using Context): Type =
+  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
diff --git a/tests/pos-with-compiler-cc/dotc/core/TypeOps.scala b/tests/pos-with-compiler-cc/dotc/core/TypeOps.scala
index ad71f3100817..717da533a439 100644
--- a/tests/pos-with-compiler-cc/dotc/core/TypeOps.scala
+++ b/tests/pos-with-compiler-cc/dotc/core/TypeOps.scala
@@ -128,7 +128,7 @@ object TypeOps:
     pre.isStable || !ctx.phase.isTyper
 
   /** Implementation of Types#simplified */
-  def simplify(tp: Type, theMap: SimplifyMap @retains(caps.*) | Null)(using Context): Type = {
+  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 =>
diff --git a/tests/pos-with-compiler-cc/dotc/core/Types.scala b/tests/pos-with-compiler-cc/dotc/core/Types.scala
index f94e9ac6d645..e4b30888a5dc 100644
--- a/tests/pos-with-compiler-cc/dotc/core/Types.scala
+++ b/tests/pos-with-compiler-cc/dotc/core/Types.scala
@@ -115,7 +115,7 @@ object Types {
     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.*) | Null): Boolean =
+      def test(t: Type, theAcc: TypeAccumulator[Boolean] @retains(caps.cap) | Null): Boolean =
         if t.mightBeProvisional then
           t.mightBeProvisional = t match
             case t: TypeRef =>
@@ -2158,8 +2158,8 @@ object Types {
   /** A trait for proto-types, used as expected types in typer */
   trait ProtoType extends Type {
     def isMatchedBy(tp: Type, keepConstraint: Boolean = false)(using Context): Boolean
-    def fold[T](x: T, ta: TypeAccumulator[T] @retains(caps.*))(using Context): T
-    def map(tm: TypeMap @retains(caps.*))(using Context): ProtoType
+    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`.
@@ -3773,7 +3773,7 @@ object Types {
         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.*) | Null): DependencyStatus =
+      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.
@@ -4351,7 +4351,7 @@ object Types {
     private var myEvalRunId: RunId = NoRunId
     private var myEvalued: Type = uninitialized
 
-    def isGround(acc: TypeAccumulator[Boolean] @retains(caps.*))(using Context): Boolean =
+    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
 
@@ -5552,7 +5552,7 @@ object Types {
    *  BiTypeMaps should map capture references to capture references.
    */
   trait BiTypeMap extends TypeMap:
-    thisMap: BiTypeMap @retains(caps.*) =>
+    thisMap: BiTypeMap @retains(caps.cap) =>
 
     /** The inverse of the type map as a function */
     def inverse(tp: Type): Type
@@ -6106,7 +6106,7 @@ object Types {
 
   abstract class TypeAccumulator[T](implicit protected val accCtx: Context)
   extends VariantTraversal with ((T, Type) => T) {
-    this: TypeAccumulator[T] @annotation.retains(caps.*) =>
+    this: TypeAccumulator[T] @annotation.retains(caps.cap) =>
 
     def apply(x: T, tp: Type): T
 
diff --git a/tests/pos-with-compiler-cc/dotc/typer/ProtoTypes.scala b/tests/pos-with-compiler-cc/dotc/typer/ProtoTypes.scala
index 838cca3f6fa7..77fd2c1d6d66 100644
--- a/tests/pos-with-compiler-cc/dotc/typer/ProtoTypes.scala
+++ b/tests/pos-with-compiler-cc/dotc/typer/ProtoTypes.scala
@@ -125,8 +125,8 @@ object ProtoTypes {
   /** A trait for prototypes that match all types */
   trait MatchAlways extends ProtoType, caps.Pure {
     def isMatchedBy(tp1: Type, keepConstraint: Boolean)(using Context): Boolean = true
-    def map(tm: TypeMap @retains(caps.*))(using Context): ProtoType = this
-    def fold[T](x: T, ta: TypeAccumulator[T] @retains(caps.*))(using Context): T = x
+    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
   }
 
@@ -239,8 +239,8 @@ object ProtoTypes {
     override def unusableForInference(using Context): Boolean =
       memberProto.unusableForInference
 
-    def map(tm: TypeMap @retains(caps.*))(using Context): SelectionProto = derivedSelectionProto(name, tm(memberProto), compat)
-    def fold[T](x: T, ta: TypeAccumulator[T] @retains(caps.*))(using Context): T = ta(x, memberProto)
+    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)
@@ -542,10 +542,10 @@ object ProtoTypes {
 
     override def toString: String = s"FunProto(${args mkString ","} => $resultType)"
 
-    def map(tm: TypeMap @retains(caps.*))(using Context): FunProto =
+    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.*))(using Context): T =
+    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 =
@@ -600,9 +600,9 @@ object ProtoTypes {
     override def unusableForInference(using Context): Boolean =
       argType.unusableForInference || resType.unusableForInference
 
-    def map(tm: TypeMap @retains(caps.*))(using Context): ViewProto = derivedViewProto(tm(argType), tm(resultType))
+    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.*))(using Context): T =
+    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 =
@@ -653,10 +653,10 @@ object ProtoTypes {
     override def unusableForInference(using Context): Boolean =
       targs.exists(_.tpe.unusableForInference)
 
-    def map(tm: TypeMap @retains(caps.*))(using Context): PolyProto =
+    def map(tm: TypeMap @retains(caps.cap))(using Context): PolyProto =
       derivedPolyProto(targs, tm(resultType))
 
-    def fold[T](x: T, ta: TypeAccumulator[T] @retains(caps.*))(using Context): T =
+    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 =
@@ -834,7 +834,7 @@ object ProtoTypes {
   /** Approximate occurrences of parameter types and uninstantiated typevars
    *  by wildcard types.
    */
-  private def wildApprox(tp: Type, theMap: WildApproxMap @retains(caps.*) | Null, seen: Set[TypeParamRef], internal: Set[TypeLambda])(using Context): Type =
+  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
diff --git a/tests/pos/boxmap-paper.scala b/tests/pos/boxmap-paper.scala
index ea4c31f099c4..7c2c005e6a61 100644
--- a/tests/pos/boxmap-paper.scala
+++ b/tests/pos/boxmap-paper.scala
@@ -19,7 +19,7 @@ def lazyMap[A, B](c: Cell[A])(f: A => B): () ->{f} Cell[B]
 trait IO:
   def print(s: String): Unit
 
-def test(io: IO^{*}) =
+def test(io: IO^{cap}) =
 
   val loggedOne: () ->{io} Int = () => { io.print("1"); 1 }
 
diff --git a/tests/run-custom-args/captures/colltest5/Test_2.scala b/tests/run-custom-args/captures/colltest5/Test_2.scala
index d6b4e43483e6..fbb22039c327 100644
--- a/tests/run-custom-args/captures/colltest5/Test_2.scala
+++ b/tests/run-custom-args/captures/colltest5/Test_2.scala
@@ -5,7 +5,7 @@ object Test {
   import colltest5.strawman.collections.*
   import CollectionStrawMan5.*
 
-  def seqOps(xs: Seq[Int]) = { // try with Seq[Int]^{any}
+  def seqOps(xs: Seq[Int]) = { // try with Seq[Int]^{cap}
     val strPlusInt: (String, Int) => String = _ + _
     val intPlusStr: (Int, String) => String = _ + _
     val isEven: Int => Boolean = _ % 2 == 0
@@ -61,7 +61,7 @@ object Test {
     println(xs16)
   }
 
-  def viewOps(xs: View[Int]^{any}) = {
+  def viewOps(xs: View[Int]^{cap}) = {
     val strPlusInt: (String, Int) => String = _ + _
     val intPlusStr: (Int, String) => String = _ + _
     val isEven: Int => Boolean = _ % 2 == 0

From f01ad50bd5bdf0c5d5be54a9c452cbb069defddc Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Tue, 2 May 2023 10:08:55 +0200
Subject: [PATCH 531/657] Deprecate caps.* and update MimaFilters

---
 library/src/scala/caps.scala | 7 +++++--
 project/MiMaFilters.scala    | 1 +
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/library/src/scala/caps.scala b/library/src/scala/caps.scala
index 921b370ff5b0..6b7b085bbc06 100644
--- a/library/src/scala/caps.scala
+++ b/library/src/scala/caps.scala
@@ -4,9 +4,12 @@ import annotation.experimental
 
 @experimental object caps:
 
+  /** The universal capture reference (deprecated) */
+  @deprecated("Use `cap` instead")
+  val `*`: Any = ()
+
   /** The universal capture reference */
-  val `*`: Any = () // OLD
-  val cap: Any = () // NEW
+  val cap: Any = ()
 
   object unsafe:
 
diff --git a/project/MiMaFilters.scala b/project/MiMaFilters.scala
index d53eeb7077a4..5009d68a7247 100644
--- a/project/MiMaFilters.scala
+++ b/project/MiMaFilters.scala
@@ -5,6 +5,7 @@ object MiMaFilters {
   val Library: Seq[ProblemFilter] = Seq(
     ProblemFilters.exclude[DirectMissingMethodProblem]("scala.caps.unsafeBox"),
     ProblemFilters.exclude[DirectMissingMethodProblem]("scala.caps.unsafeUnbox"),
+    ProblemFilters.exclude[DirectMissingMethodProblem]("scala.caps.cap"),
     ProblemFilters.exclude[DirectMissingMethodProblem]("scala.CanEqual.canEqualMap"),
     ProblemFilters.exclude[MissingClassProblem]("scala.caps$Pure"),
     ProblemFilters.exclude[MissingClassProblem]("scala.caps$unsafe$"),

From 3927cec7b525fae49a902b8c59dfa6bee621ae33 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Wed, 3 May 2023 12:07:33 +0200
Subject: [PATCH 532/657] Change to new syntax in doc comments

... and fix a missing change when printing trees
---
 .../src/dotty/tools/dotc/cc/CheckCaptures.scala   | 12 ++++++------
 .../src/dotty/tools/dotc/parsing/Parsers.scala    | 15 +++++++--------
 .../tools/dotc/printing/RefinedPrinter.scala      |  4 ++--
 3 files changed, 15 insertions(+), 16 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index e77c72c422ca..72a166dbbecc 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -52,12 +52,12 @@ object CheckCaptures:
    *  @param outer0        the next enclosing environment
    */
   case class Env(
-    owner: Symbol,
-    nestedInOwner: Boolean,
-    captured: CaptureSet,
-    isBoxed: Boolean,
-    outer0: Env | Null
-  ):
+      owner: Symbol,
+      nestedInOwner: Boolean,
+      captured: CaptureSet,
+      isBoxed: Boolean,
+      outer0: Env | Null):
+
     def outer = outer0.nn
 
     def isOutermost = outer0 == null
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 9376b995b011..1dab95d75225 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -1462,12 +1462,11 @@ object Parsers {
      *                   |  FunParamClause ‘=>>’ Type
      *                   |  MatchType
      *                   |  InfixType
-     *                   |  CaptureSet Type                            -- under captureChecking
      *  FunType        ::=  (MonoFunType | PolyFunType)
      *  MonoFunType    ::=  FunTypeArgs (‘=>’ | ‘?=>’) Type
-     *                   |  (‘->’ | ‘?->’ ) Type                       -- under pureFunctions
+     *                   |  (‘->’ | ‘?->’ ) [CaptureSet] Type          -- under pureFunctions
      *  PolyFunType    ::=  HKTypeParamClause '=>' Type
-     *                   |  HKTypeParamClause ‘->’ Type                -- under pureFunctions
+     *                   |  HKTypeParamClause ‘->’ [CaptureSet] Type   -- under pureFunctions
      *  FunTypeArgs    ::=  InfixType
      *                   |  `(' [ [ ‘[using]’ ‘['erased']  FunArgType {`,' FunArgType } ] `)'
      *                   |  '(' [ ‘[using]’ ‘['erased'] TypedFunParam {',' TypedFunParam } ')'
@@ -1951,13 +1950,13 @@ object Parsers {
 
     /** FunArgType ::=  Type
      *               |  `=>' Type
-     *               |  [CaptureSet] `->' Type
+     *               |  `->' [CaptureSet] Type
      */
     val funArgType: () => Tree = () => paramTypeOf(typ)
 
     /** ParamType  ::=  ParamValueType
      *               |  `=>' ParamValueType
-     *               |  [CaptureSet] `->' ParamValueType
+     *               |  `->' [CaptureSet] ParamValueType
      */
     def paramType(): Tree = paramTypeOf(paramValueType)
 
@@ -2096,7 +2095,7 @@ object Parsers {
      *                      |  ‘inline’ InfixExpr MatchClause
      *  Bindings          ::=  `(' [Binding {`,' Binding}] `)'
      *  Binding           ::=  (id | `_') [`:' Type]
-     *  Ascription        ::=  `:' [CaptureSet] InfixType
+     *  Ascription        ::=  `:' InfixType
      *                      |  `:' Annotation {Annotation}
      *                      |  `:' `_' `*'
      *  Catches           ::=  ‘catch’ (Expr | ExprCaseClause)
@@ -4155,8 +4154,8 @@ object Parsers {
       stats.toList
     }
 
-    /** SelfType ::=  id [‘:’ [CaptureSet] InfixType] ‘=>’
-     *            |  ‘this’ ‘:’ [CaptureSet] InfixType ‘=>’
+    /** SelfType ::=  id [‘:’ InfixType] ‘=>’
+     *            |  ‘this’ ‘:’ InfixType ‘=>’
      */
     def selfType(): ValDef =
       if (in.isIdent || in.token == THIS)
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index e6fe55ccb2fc..0a059fdf00eb 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -628,7 +628,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         def toTextAnnot =
           toTextLocal(arg) ~~ annotText(annot.symbol.enclosingClass, annot)
         def toTextRetainsAnnot =
-          try changePrec(GlobalPrec)(toTextCaptureSet(captureSet) ~ " " ~ toText(arg))
+          try changePrec(GlobalPrec)(toText(arg) ~ "^" ~ toTextCaptureSet(captureSet))
           catch case ex: IllegalCaptureRef => toTextAnnot
         if annot.symbol.maybeOwner == defn.RetainsAnnot
             && Feature.ccEnabled && Config.printCaptureSetsAsPrefix && !printDebug
@@ -741,7 +741,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         val tptText = toTextGlobal(tpt)
         prefix ~~ idx.toString ~~ "|" ~~ tptText ~~ "|" ~~ argsText ~~ "|" ~~ contentText ~~ postfix
       case CapturesAndResult(refs, parent) =>
-        changePrec(GlobalPrec)("^{" ~ Text(refs.map(toText), ", ") ~ "} " ~ toText(parent))
+        changePrec(GlobalPrec)("^{" ~ Text(refs.map(toText), ", ") ~ "}" ~ toText(parent))
       case _ =>
         tree.fallbackToText(this)
     }

From ed9f4b21d9f6f67c6e745acbe1afe92c2ac256ed Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Wed, 3 May 2023 18:41:02 +0200
Subject: [PATCH 533/657] Allow new capture syntax only if capture checking is
 enabled

---
 compiler/src/dotty/tools/dotc/parsing/Parsers.scala | 6 +++---
 1 file 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 1dab95d75225..33bd46f619aa 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -1453,7 +1453,7 @@ object Parsers {
     }
 
     def capturesAndResult(core: () => Tree): Tree =
-      if in.token == LBRACE && in.offset == in.lastOffset
+      if Feature.ccEnabled && in.token == LBRACE && in.offset == in.lastOffset
       then CapturesAndResult(captureSet(), core())
       else core()
 
@@ -1685,7 +1685,7 @@ object Parsers {
      *  or followed by a token that cannot start an infix type.
      *  Otherwise it is treated as an infix operator.
      */
-    private def isTrailingUpArrow =
+    private def isCaptureUpArrow =
       val ahead = in.lookahead
       ahead.token == LBRACE
       || ahead.isIdent(nme.PUREARROW)
@@ -1699,7 +1699,7 @@ object Parsers {
         refinedTypeRest(atSpan(startOffset(t)) {
           RefinedTypeTree(rejectWildcardType(t), refinement(indentOK = true))
         })
-      else if in.isIdent(nme.UPARROW) && isTrailingUpArrow then
+      else if Feature.ccEnabled && in.isIdent(nme.UPARROW) && isCaptureUpArrow then
         val upArrowStart = in.offset
         in.nextToken()
         def cs =

From 77f537881d5cbfb548720237f853352c184eee9b Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Thu, 4 May 2023 18:22:26 +0200
Subject: [PATCH 534/657] Fix typo (#17416)

[skip ci]
---
 staging/src/scala/quoted/staging/Compiler.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/staging/src/scala/quoted/staging/Compiler.scala b/staging/src/scala/quoted/staging/Compiler.scala
index c9abe3fa75c3..fbe6a3915a08 100644
--- a/staging/src/scala/quoted/staging/Compiler.scala
+++ b/staging/src/scala/quoted/staging/Compiler.scala
@@ -13,7 +13,7 @@ object Compiler:
 
   /** Create a new instance of the compiler using the the classloader of the application.
    *
-   * Usuage:
+   * Usage:
    * ```
    * import scala.quoted.staging._
    * given Compiler = Compiler.make(getClass.getClassLoader)

From 90f4253bf871cce9b79073759757696b001f5634 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Fri, 5 May 2023 12:49:59 +0200
Subject: [PATCH 535/657] Add test

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

diff --git a/tests/pos/i17381.scala b/tests/pos/i17381.scala
new file mode 100644
index 000000000000..3d8aac8e9f67
--- /dev/null
+++ b/tests/pos/i17381.scala
@@ -0,0 +1,9 @@
+import reflect.Selectable.reflectiveSelectable
+
+type Y = { type T = String; def u(): T }
+
+trait Test {
+
+  val y1: Y
+  val y2 = y1.u()
+}
\ No newline at end of file

From 830230fa2a47ff18994b5820283332c40f65eeb3 Mon Sep 17 00:00:00 2001
From: som-snytt <som.snytt@gmail.com>
Date: Mon, 8 May 2023 00:14:01 -0700
Subject: [PATCH 536/657] Avoid deprecated URL ctor in scaladoc (#17426)

Follow-up to https://github.com/lampepfl/dotty/pull/17403 includes
scaladoc.
---
 scaladoc/src/dotty/tools/scaladoc/ExternalDocLink.scala   | 8 ++++----
 .../src/dotty/tools/scaladoc/renderers/Resources.scala    | 4 ++--
 .../src/dotty/tools/scaladoc/renderers/SiteRenderer.scala | 5 ++---
 3 files changed, 8 insertions(+), 9 deletions(-)

diff --git a/scaladoc/src/dotty/tools/scaladoc/ExternalDocLink.scala b/scaladoc/src/dotty/tools/scaladoc/ExternalDocLink.scala
index fd4963bcce4a..536d759388f3 100644
--- a/scaladoc/src/dotty/tools/scaladoc/ExternalDocLink.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/ExternalDocLink.scala
@@ -1,6 +1,6 @@
 package dotty.tools.scaladoc
 
-import java.net.URL
+import java.net.{URI, URL}
 import scala.util.matching._
 import scala.util.{ Try, Success, Failure }
 
@@ -30,7 +30,7 @@ object ExternalDocLink:
   def parseLegacy(mapping: String): Either[String, ExternalDocLink] =
     mapping.split("#").toList match
       case path :: apiUrl :: Nil => for {
-        url <- tryParse(mapping, "url")(URL(stripIndex(apiUrl)))
+        url <- tryParse(mapping, "url")(URI(stripIndex(apiUrl)).toURL)
       } yield ExternalDocLink(
         List(s"${Regex.quote(path)}.*".r),
         url,
@@ -42,7 +42,7 @@ object ExternalDocLink:
   def parse(mapping: String): Either[String, ExternalDocLink] =
 
     def parsePackageList(elements: List[String]) = elements match
-     case List(urlStr) => tryParse(mapping, "packageList")(Some(URL(urlStr)))
+     case List(urlStr) => tryParse(mapping, "packageList")(Some(URI(urlStr).toURL))
      case Nil => Right(None)
      case other => fail(mapping, s"Provided multiple package lists: $other")
 
@@ -57,7 +57,7 @@ object ExternalDocLink:
       case regexStr :: docToolStr :: urlStr :: rest =>
         for {
           regex <- tryParse(mapping, "regex")(regexStr.r)
-          url <- tryParse(mapping, "url")(URL(stripIndex(urlStr)))
+          url <- tryParse(mapping, "url")(URI(stripIndex(urlStr)).toURL)
           doctool <- doctoolByName(docToolStr)
           packageList <- parsePackageList(rest)
         } yield ExternalDocLink(
diff --git a/scaladoc/src/dotty/tools/scaladoc/renderers/Resources.scala b/scaladoc/src/dotty/tools/scaladoc/renderers/Resources.scala
index 27af3ac5dee6..b84c07b4bade 100644
--- a/scaladoc/src/dotty/tools/scaladoc/renderers/Resources.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/renderers/Resources.scala
@@ -2,7 +2,7 @@ package dotty.tools.scaladoc
 package renderers
 
 import util.HTML._
-import java.net.URL
+import java.net.{URI, URL}
 import java.nio.file.Paths
 import java.nio.file.Path
 import java.nio.file.Files
@@ -565,4 +565,4 @@ trait Resources(using ctx: DocContext) extends Locations, Writer:
         case Resource.URL(url) =>
           Nil
         case Resource.URLToCopy(url, dest) =>
-          Seq(copy(new URL(url).openStream(), dest))
+          Seq(copy(URI(url).toURL.openStream(), dest))
diff --git a/scaladoc/src/dotty/tools/scaladoc/renderers/SiteRenderer.scala b/scaladoc/src/dotty/tools/scaladoc/renderers/SiteRenderer.scala
index ef80b4f2d327..ef7c06416e27 100644
--- a/scaladoc/src/dotty/tools/scaladoc/renderers/SiteRenderer.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/renderers/SiteRenderer.scala
@@ -3,8 +3,7 @@ package renderers
 
 import util.HTML._
 import scala.jdk.CollectionConverters._
-import java.net.URI
-import java.net.URL
+import java.net.{URI, URL}
 import dotty.tools.scaladoc.site._
 import scala.util.Try
 import org.jsoup.Jsoup
@@ -40,7 +39,7 @@ trait SiteRenderer(using DocContext) extends Locations:
 
     def processLocalLink(str: String): String =
       val staticSiteRootPath = content.ctx.root.toPath.toAbsolutePath
-      def asValidURL: Option[String] = Try(URL(str)).toOption.map(_ => str)
+      def asValidURL: Option[String] = Try(URI(str).toURL).toOption.map(_ => str)
       def asAsset: Option[String] = Option.when(
         Files.exists(staticSiteRootPath.resolve("_assets").resolve(str.stripPrefix("/")))
       )(

From c9dc8e72cc406d6bb7407fff8a97acc130e9ad6a Mon Sep 17 00:00:00 2001
From: Fengyun Liu <fengyun.liu.cs@gmail.com>
Date: Mon, 8 May 2023 23:12:18 +0200
Subject: [PATCH 537/657] Fix #17435: A simpler fix

This commit replaces #17382 with a simpler fix.
---
 .../tools/dotc/transform/TypeTestsCasts.scala | 63 +++----------------
 1 file changed, 8 insertions(+), 55 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala b/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
index 979538b56fc5..f5cb8eab73a4 100644
--- a/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala
@@ -53,7 +53,7 @@ object TypeTestsCasts {
    *  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. if `X` is `T1 | T2`, checkable(T1, P) && checkable(T2, P) or (isCheckDefinitelyFalse(T1, P) && checkable(T2, P)) or (checkable(T1, P) && isCheckDefinitelyFalse(T2, P)).
+   *  9. if `X` is `T1 | T2`, checkable(T1, P) && checkable(T2, P).
    *  10. otherwise, ""
    */
   def whyUncheckable(X: Type, P: Type, span: Span)(using Context): String = atPhase(Phases.refchecksPhase.next) {
@@ -132,42 +132,8 @@ object TypeTestsCasts {
 
     }
 
-    /** Whether the check X.isInstanceOf[P] is definitely false? */
-    def isCheckDefinitelyFalse(X: Type, P: Type)(using Context): Boolean = trace(s"isCheckDefinitelyFalse(${X.show}, ${P.show})") {
-      X.widenDealias match
-      case AndType(x1, x2) =>
-        isCheckDefinitelyFalse(x1, P) || isCheckDefinitelyFalse(x2, P)
-
-      case x =>
-        P.widenDealias match
-        case AndType(p1, p2) =>
-          isCheckDefinitelyFalse(x, p1) || isCheckDefinitelyFalse(x, p2)
-
-        case p =>
-          val pSpace = Typ(p)
-          val xSpace = Typ(x)
-          if pSpace.canDecompose then
-            val ps = pSpace.decompose.map(_.tp)
-            ps.forall(p => isCheckDefinitelyFalse(x, p))
-          else if xSpace.canDecompose then
-            val xs = xSpace.decompose.map(_.tp)
-            xs.forall(x => isCheckDefinitelyFalse(x, p))
-          else
-            if x.typeSymbol.isClass && p.typeSymbol.isClass then
-              val xClass = effectiveClass(x)
-              val pClass = effectiveClass(p)
-
-              val bothAreClasses = !xClass.is(Trait) && !pClass.is(Trait)
-              val notXsubP = !xClass.derivesFrom(pClass)
-              val notPsubX = !pClass.derivesFrom(xClass)
-              bothAreClasses && notXsubP && notPsubX
-              || xClass.is(Final) && notXsubP
-              || pClass.is(Final) && notPsubX
-            else
-              false
-    }
-
-    def recur(X: Type, P: Type): String = (X <:< P) ||| (P.dealias match {
+    def recur(X: Type, P: Type): String = trace(s"recur(${X.show}, ${P.show})") {
+      (X <:< P) ||| P.dealias.match
       case _: SingletonType     => ""
       case _: TypeProxy
       if isAbstract(P)          => i"it refers to an abstract type member or type parameter"
@@ -176,7 +142,7 @@ object TypeTestsCasts {
           case defn.ArrayOf(tpE)   => recur(tpE, tpT)
           case _                   => recur(defn.AnyType, tpT)
         }
-      case tpe: AppliedType     =>
+      case tpe @ AppliedType(tycon, targs)     =>
         X.widenDealias match {
           case OrType(tp1, tp2) =>
             // This case is required to retrofit type inference,
@@ -184,24 +150,11 @@ object TypeTestsCasts {
             //   - T1 <:< T2 | T3
             //   - T1 & T2 <:< T3
             // See TypeComparer#either
-            val res1 = recur(tp1, P)
-            val res2 = recur(tp2, P)
-
-            if res1.isEmpty && res2.isEmpty then
-              res1
-            else if res2.isEmpty then
-              if isCheckDefinitelyFalse(tp1, P) then res2
-              else res1
-            else if res1.isEmpty then
-              if isCheckDefinitelyFalse(tp2, P) then res1
-              else res2
-            else
-              res1
+            recur(tp1, P) && recur(tp2, P)
 
-          case _ =>
+          case x =>
             // always false test warnings are emitted elsewhere
-            X.classSymbol.exists && P.classSymbol.exists &&
-              !X.classSymbol.asClass.mayHaveCommonChild(P.classSymbol.asClass)
+            TypeComparer.provablyDisjoint(x, tpe.derivedAppliedType(tycon, targs.map(_ => WildcardType)))
             || typeArgsTrivial(X, tpe)
             ||| i"its type arguments can't be determined from $X"
         }
@@ -215,7 +168,7 @@ object TypeTestsCasts {
       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))
 

From 4aa062be648043c9300e807daaf633c5026d8a24 Mon Sep 17 00:00:00 2001
From: Fengyun Liu <fengyun.liu.cs@gmail.com>
Date: Tue, 9 May 2023 07:51:35 +0200
Subject: [PATCH 538/657] Add test

---
 .../neg-custom-args/isInstanceOf/i17435.scala | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 tests/neg-custom-args/isInstanceOf/i17435.scala

diff --git a/tests/neg-custom-args/isInstanceOf/i17435.scala b/tests/neg-custom-args/isInstanceOf/i17435.scala
new file mode 100644
index 000000000000..e32149db3137
--- /dev/null
+++ b/tests/neg-custom-args/isInstanceOf/i17435.scala
@@ -0,0 +1,23 @@
+import scala.collection.mutable
+
+object Test:
+  type JsonPrimitive = String | Int | Double | Boolean | None.type
+
+  type Rec[JA[_], JO[_], A] = A match
+    case JsonPrimitive => JsonPrimitive | JA[Rec[JA, JO, JsonPrimitive]] | JO[Rec[JA, JO, JsonPrimitive]]
+    case _ => A | JA[Rec[JA, JO, A]] | JO[Rec[JA, JO, A]]
+
+  type Json = Rec[[A] =>> mutable.Buffer[A], [A] =>> mutable.Map[String, A], JsonPrimitive]
+
+  type JsonObject = mutable.Map[String, Json]
+
+  type JsonArray = mutable.Buffer[Json]
+
+  def encode(x: Json): Int = x match
+    case str: String => 1
+    case b: Boolean => 2
+    case i: Int => 3
+    case d: Double => 4
+    case arr: JsonArray => 5    // error
+    case obj: JsonObject => 6   // error
+    case _ => 7

From 982ce3fc36535eb7cb96cf7d25694937b9005ced Mon Sep 17 00:00:00 2001
From: "github-actions[bot]"
 <41898282+github-actions[bot]@users.noreply.github.com>
Date: Tue, 9 May 2023 10:47:47 +0200
Subject: [PATCH 539/657] Sync with the stable documentation branch (#17419)

This pull request is syncing the main with changes from
language-reference-stable.

It was created automatically after
bd9e0f7484167a07ae13c4e264a4cc2974aca223 by @bishabosha

---------

Co-authored-by: Jamie Thompson <bishbashboshjt@gmail.com>
---
 .../reference/contextual/derivation-macro.md  | 280 +++++++++---------
 docs/_docs/reference/contextual/derivation.md | 148 +++++----
 2 files changed, 226 insertions(+), 202 deletions(-)

diff --git a/docs/_docs/reference/contextual/derivation-macro.md b/docs/_docs/reference/contextual/derivation-macro.md
index be7565616913..4b8dcffec846 100644
--- a/docs/_docs/reference/contextual/derivation-macro.md
+++ b/docs/_docs/reference/contextual/derivation-macro.md
@@ -4,15 +4,11 @@ title: "How to write a type class `derived` method using macros"
 nightlyOf: https://docs.scala-lang.org/scala3/reference/contextual/derivation-macro.html
 ---
 
-In the main [derivation](./derivation.md) documentation page, we explained the
-details behind `Mirror`s and type class derivation. Here we demonstrate how to
-implement a type class `derived` method using macros only. We follow the same
-example of deriving `Eq` instances and for simplicity we support a `Product`
-type e.g., a case class `Person`. The low-level method we will use to implement
-the `derived` method exploits quotes, splices of both expressions and types and
-the `scala.quoted.Expr.summon` method which is the equivalent of
-`summonFrom`. The former is suitable for use in a quote context, used within
-macros.
+In the main [derivation](./derivation.md) documentation page, we explained the details behind `Mirror`s and type class derivation.
+Here we demonstrate how to implement a type class `derived` method using macros only.
+We follow the same example of deriving `Eq` instances and for simplicity we support a `Product` type e.g., a case class `Person`.
+The low-level technique that we will use to implement the `derived` method exploits quotes, splices of both expressions and types and the `scala.quoted.Expr.summon` method which is the equivalent of `scala.compiletime.summonFrom`.
+The former is suitable for use in a quote context, used within macros.
 
 As in the original code, the type class definition is the same:
 
@@ -21,185 +17,187 @@ trait Eq[T]:
   def eqv(x: T, y: T): Boolean
 ```
 
-we need to implement a method `Eq.derived` on the companion object of `Eq` that
-produces a quoted instance for `Eq[T]`. Here is a possible signature,
+We need to implement an inline method `Eq.derived` on the companion object of `Eq` that calls into a macro to produce a quoted instance for `Eq[T]`.
+Here is a possible signature:
+
 
 ```scala
-given derived[T: Type](using Quotes): Expr[Eq[T]]
+inline def derived[T]: Eq[T] = ${ derivedMacro[T] }
+
+def derivedMacro[T: Type](using Quotes): Expr[Eq[T]] = ???
 ```
 
-and for comparison reasons we give the same signature we had with `inline`:
+Note, that since a type is used in a subsequent macro compilation stage it will need to be lifted to a `quoted.Type` by using the corresponding context bound (seen in `derivedMacro`).
 
+
+For comparison, here is the signature of the inline `derived` method from the [main derivation page](./derivation.md):
 ```scala
-inline given derived[T](using Mirror.Of[T]): Eq[T] = ???
+inline def derived[T](using m: Mirror.Of[T]): Eq[T] = ???
 ```
 
-Note, that since a type is used in a subsequent stage it will need to be lifted
-to a `Type` by using the corresponding context bound. Also, note that we can
-summon the quoted `Mirror` inside the body of the `derived` thus we can omit it
-from the signature. The body of the `derived` method is shown below:
+Note that the macro-based `derived` signature does not have a `Mirror` parameter.
+This is because we can summon the `Mirror` inside the body of `derivedMacro` thus we can omit it from the signature.
+
+One additional possibility with the body of `derivedMacro` here as opposed to the one with `inline` is that with macros it is simpler to create a fully optimised method body for `eqv`.
 
+Let's say we wanted to derive an `Eq` instance for the following case class `Person`,
+```scala
+case class Person(name: String, age: Int) derives Eq
+```
+
+the equality check we are going to generate is the following:
 
 ```scala
-given derived[T: Type](using Quotes): Expr[Eq[T]] =
-  import quotes.reflect.*
+(x: Person, y: Person) =>
+  summon[Eq[String]].eqv(x.productElement(0), y.productElement(0))
+  && summon[Eq[Int]].eqv(x.productElement(1), y.productElement(1))
+```
+
+> Note that it is possible, by using the [reflection API](../metaprogramming/reflection.md), to further optimise and directly reference the fields of `Person`, but for clear understanding we will only use quoted expressions.
+
+The code to generates this body can be seen in the `eqProductBody` method, shown here as part of the definition for the `derivedMacro` method:
+
+
+```scala
+def derivedMacro[T: Type](using Quotes): Expr[Eq[T]] =
 
   val ev: Expr[Mirror.Of[T]] = Expr.summon[Mirror.Of[T]].get
 
   ev match
     case '{ $m: Mirror.ProductOf[T] { type MirroredElemTypes = elementTypes }} =>
-      val elemInstances = summonAll[elementTypes]
+      val elemInstances = summonInstances[T, elementTypes]
       def eqProductBody(x: Expr[Product], y: Expr[Product])(using Quotes): Expr[Boolean] = {
-        elemInstances.zipWithIndex.foldLeft(Expr(true)) {
-          case (acc, ('{ $elem: Eq[t] }, index)) =>
-            val indexExpr = Expr(index)
-            val e1 = '{ $x.productElement($indexExpr).asInstanceOf[t] }
-            val e2 = '{ $y.productElement($indexExpr).asInstanceOf[t] }
-            '{ $acc && $elem.eqv($e1, $e2) }
-         }
+        if elemInstances.isEmpty then
+          Expr(true)
+        else
+          elemInstances.zipWithIndex.map {
+            case ('{ $elem: Eq[t] }, index) =>
+              val indexExpr = Expr(index)
+              val e1 = '{ $x.productElement($indexExpr).asInstanceOf[t] }
+              val e2 = '{ $y.productElement($indexExpr).asInstanceOf[t] }
+              '{ $elem.eqv($e1, $e2) }
+          }.reduce((acc, elem) => '{ $acc && $elem })
+        end if
       }
       '{ eqProduct((x: T, y: T) => ${eqProductBody('x.asExprOf[Product], 'y.asExprOf[Product])}) }
 
-  // case for Mirror.ProductOf[T]
-  // ...
+    // case for Mirror.SumOf[T] ...
 ```
 
-Note, that in the `inline` case we can merely write
-`summonAll[m.MirroredElemTypes]` inside the inline method but here, since
-`Expr.summon` is required, we can extract the element types in a macro fashion.
-Being inside a macro, our first reaction would be to write the code below. Since
-the path inside the type argument is not stable this cannot be used:
+Note, that in the version without macros, we can merely write `summonInstances[T, m.MirroredElemTypes]` inside the inline method but here, since `Expr.summon` is required, we can extract the element types in a macro fashion.
+Being inside a macro, our first reaction would be to write the code below:
 
 ```scala
 '{
-  summonAll[$m.MirroredElemTypes]
+  summonInstances[T, $m.MirroredElemTypes]
 }
 ```
 
-Instead we extract the tuple-type for element types using pattern matching over
-quotes and more specifically of the refined type:
+However, since the path inside the type argument is not stable this cannot be used.
+Instead we extract the tuple-type for element types using pattern matching over quotes and more specifically of the refined type:
 
 ```scala
    case '{ $m: Mirror.ProductOf[T] { type MirroredElemTypes = elementTypes }} => ...
 ```
 
-Shown below is the implementation of `summonAll` as a macro. We assume that
-given instances for our primitive types exist.
-
-```scala
-def summonAll[T: Type](using Quotes): List[Expr[Eq[_]]] =
-   Type.of[T] match
-      case '[String *: tpes] => '{ summon[Eq[String]] } :: summonAll[tpes]
-      case '[Int *: tpes]    => '{ summon[Eq[Int]] }    :: summonAll[tpes]
-      case '[tpe *: tpes]    => derived[tpe] :: summonAll[tpes]
-      case '[EmptyTuple]     => Nil
-```
-
-One additional difference with the body of `derived` here as opposed to the one
-with `inline` is that with macros we need to synthesize the body of the code during the
-macro-expansion time. That is the rationale behind the `eqProductBody` function.
-Assuming that we calculate the equality of two `Person`s defined with a case
-class that holds a name of type [`String`](https://scala-lang.org/api/3.x/scala/Predef$.html#String-0)
-and an age of type `Int`, the equality check we want to generate is the following:
-
-```scala
-   true
-   && Eq[String].eqv(x.productElement(0),y.productElement(0))
-   && Eq[Int].eqv(x.productElement(1), y.productElement(1))
-```
-
-## Calling the derived method inside the macro
+Shown below is the implementation of `summonInstances` as a macro, which for each type `elem` in the tuple type, calls
+`deriveOrSummon[T, elem]`.
 
-Following the rules in [Macros](../metaprogramming/metaprogramming.md) we create two methods.
-One that hosts the top-level splice `eqv` and one that is the implementation.
-Alternatively and what is shown below is that we can call the `eqv` method
-directly. The `eqGen` can trigger the derivation.
+To understand `deriveOrSummon`, consider that if `elem` derives from the parent `T` type, then it is a recursive derivation.
+Recursive derivation usually happens for types such as `scala.collection.immutable.::`. If `elem` does not derive from `T`, then there must exist a contextual `Eq[elem]` instance.
 
 ```scala
-extension [T](inline x: T)
-   inline def === (inline y: T)(using eq: Eq[T]): Boolean = eq.eqv(x, y)
-
-inline given eqGen[T]: Eq[T] = ${ Eq.derived[T] }
-```
-
-Note, that we use inline method syntax and we can compare instance such as
-`Sm(Person("Test", 23)) === Sm(Person("Test", 24))` for e.g., the following two
-types:
-
-```scala
-case class Person(name: String, age: Int)
-
-enum Opt[+T]:
-   case Sm(t: T)
-   case Nn
+def summonInstances[T: Type, Elems: Type](using Quotes): List[Expr[Eq[?]]] =
+  Type.of[Elems] match
+    case '[elem *: elems] => deriveOrSummon[T, elem] :: summonInstances[T, elems]
+    case '[EmptyTuple]    => Nil
+
+def deriveOrSummon[T: Type, Elem: Type](using Quotes): Expr[Eq[Elem]] =
+  Type.of[Elem] match
+    case '[T] => deriveRec[T, Elem]
+    case _    => '{ summonInline[Eq[Elem]] }
+
+def deriveRec[T: Type, Elem: Type](using Quotes): Expr[Eq[Elem]] =
+  Type.of[T] match
+    case '[Elem] => '{ error("infinite recursive derivation") }
+    case _       => derivedMacro[Elem] // recursive derivation
 ```
 
 The full code is shown below:
 
 ```scala
+import compiletime.*
 import scala.deriving.*
 import scala.quoted.*
 
 
 trait Eq[T]:
-   def eqv(x: T, y: T): Boolean
+  def eqv(x: T, y: T): Boolean
 
 object Eq:
-   given Eq[String] with
-      def eqv(x: String, y: String) = x == y
-
-   given Eq[Int] with
-      def eqv(x: Int, y: Int) = x == y
-
-   def eqProduct[T](body: (T, T) => Boolean): Eq[T] =
-      new Eq[T]:
-         def eqv(x: T, y: T): Boolean = body(x, y)
-
-   def eqSum[T](body: (T, T) => Boolean): Eq[T] =
-      new Eq[T]:
-         def eqv(x: T, y: T): Boolean = body(x, y)
-
-   def summonAll[T: Type](using Quotes): List[Expr[Eq[_]]] =
-      Type.of[T] match
-         case '[String *: tpes] => '{ summon[Eq[String]] } :: summonAll[tpes]
-         case '[Int *: tpes]    => '{ summon[Eq[Int]] }    :: summonAll[tpes]
-         case '[tpe *: tpes]    => derived[tpe] :: summonAll[tpes]
-         case '[EmptyTuple]     => Nil
-
-   given derived[T: Type](using q: Quotes): Expr[Eq[T]] =
-      import quotes.reflect.*
-
-      val ev: Expr[Mirror.Of[T]] = Expr.summon[Mirror.Of[T]].get
-
-      ev match
-         case '{ $m: Mirror.ProductOf[T] { type MirroredElemTypes = elementTypes }} =>
-            val elemInstances = summonAll[elementTypes]
-            val eqProductBody: (Expr[T], Expr[T]) => Expr[Boolean] = (x, y) =>
-               elemInstances.zipWithIndex.foldLeft(Expr(true: Boolean)) {
-                  case (acc, (elem, index)) =>
-                     val e1 = '{$x.asInstanceOf[Product].productElement(${Expr(index)})}
-                     val e2 = '{$y.asInstanceOf[Product].productElement(${Expr(index)})}
-
-                     '{ $acc && $elem.asInstanceOf[Eq[Any]].eqv($e1, $e2) }
-               }
-            '{ eqProduct((x: T, y: T) => ${eqProductBody('x, 'y)}) }
-
-         case '{ $m: Mirror.SumOf[T] { type MirroredElemTypes = elementTypes }} =>
-            val elemInstances = summonAll[elementTypes]
-            val eqSumBody: (Expr[T], Expr[T]) => Expr[Boolean] = (x, y) =>
-               val ordx = '{ $m.ordinal($x) }
-               val ordy = '{ $m.ordinal($y) }
-
-               val elements = Expr.ofList(elemInstances)
-               '{ $ordx == $ordy && $elements($ordx).asInstanceOf[Eq[Any]].eqv($x, $y) }
-
-         '{ eqSum((x: T, y: T) => ${eqSumBody('x, 'y)}) }
-   end derived
+  given Eq[String] with
+    def eqv(x: String, y: String) = x == y
+
+  given Eq[Int] with
+    def eqv(x: Int, y: Int) = x == y
+
+  def eqProduct[T](body: (T, T) => Boolean): Eq[T] =
+    new Eq[T]:
+      def eqv(x: T, y: T): Boolean = body(x, y)
+
+  def eqSum[T](body: (T, T) => Boolean): Eq[T] =
+    new Eq[T]:
+      def eqv(x: T, y: T): Boolean = body(x, y)
+
+  def summonInstances[T: Type, Elems: Type](using Quotes): List[Expr[Eq[?]]] =
+    Type.of[Elems] match
+      case '[elem *: elems] => deriveOrSummon[T, elem] :: summonInstances[T, elems]
+      case '[EmptyTuple]    => Nil
+
+  def deriveOrSummon[T: Type, Elem: Type](using Quotes): Expr[Eq[Elem]] =
+    Type.of[Elem] match
+      case '[T] => deriveRec[T, Elem]
+      case _    => '{ summonInline[Eq[Elem]] }
+
+  def deriveRec[T: Type, Elem: Type](using Quotes): Expr[Eq[Elem]] =
+    Type.of[T] match
+      case '[Elem] => '{ error("infinite recursive derivation") }
+      case _       => derivedMacro[Elem] // recursive derivation
+
+  inline def derived[T]: Eq[T] = ${ derivedMacro[T] }
+
+  def derivedMacro[T: Type](using Quotes): Expr[Eq[T]] =
+
+    val ev: Expr[Mirror.Of[T]] = Expr.summon[Mirror.Of[T]].get
+
+    ev match
+      case '{ $m: Mirror.ProductOf[T] { type MirroredElemTypes = elementTypes }} =>
+        val elemInstances = summonInstances[T, elementTypes]
+        def eqProductBody(x: Expr[Product], y: Expr[Product])(using Quotes): Expr[Boolean] = {
+          if elemInstances.isEmpty then
+            Expr(true)
+          else
+            elemInstances.zipWithIndex.map {
+              case ('{ $elem: Eq[t] }, index) =>
+                val indexExpr = Expr(index)
+                val e1 = '{ $x.productElement($indexExpr).asInstanceOf[t] }
+                val e2 = '{ $y.productElement($indexExpr).asInstanceOf[t] }
+                '{ $elem.eqv($e1, $e2) }
+            }.reduce((acc, elem) => '{ $acc && $elem })
+          end if
+        }
+        '{ eqProduct((x: T, y: T) => ${eqProductBody('x.asExprOf[Product], 'y.asExprOf[Product])}) }
+
+      case '{ $m: Mirror.SumOf[T] { type MirroredElemTypes = elementTypes }} =>
+        val elemInstances = summonInstances[T, elementTypes]
+        val elements = Expr.ofList(elemInstances)
+
+        def eqSumBody(x: Expr[T], y: Expr[T])(using Quotes): Expr[Boolean] =
+          val ordx = '{ $m.ordinal($x) }
+          val ordy = '{ $m.ordinal($y) }
+          '{ $ordx == $ordy && $elements($ordx).asInstanceOf[Eq[Any]].eqv($x, $y) }
+
+        '{ eqSum((x: T, y: T) => ${eqSumBody('x, 'y)}) }
+  end derivedMacro
 end Eq
-
-object Macro3:
-   extension [T](inline x: T)
-      inline def === (inline y: T)(using eq: Eq[T]): Boolean = eq.eqv(x, y)
-
-   inline given eqGen[T]: Eq[T] = ${ Eq.derived[T] }
 ```
diff --git a/docs/_docs/reference/contextual/derivation.md b/docs/_docs/reference/contextual/derivation.md
index 853f7868aa9a..66d0cf3fdf38 100644
--- a/docs/_docs/reference/contextual/derivation.md
+++ b/docs/_docs/reference/contextual/derivation.md
@@ -312,9 +312,8 @@ worked out example of such a library, see [Shapeless 3](https://github.com/miles
 
 ## How to write a type class `derived` method using low level mechanisms
 
-The low-level method we will use to implement a type class `derived` method in this example exploits three new
-type-level constructs in Scala 3: inline methods, inline matches, and implicit searches via  `summonInline` or `summonFrom`. Given this definition of the
-`Eq` type class,
+The low-level method we will use to implement a type class `derived` method in this example exploits three new type-level constructs in Scala 3: inline methods, inline matches, and implicit searches via  `summonInline` or `summonFrom`.
+Given this definition of the `Eq` type class,
 
 ```scala
 trait Eq[T]:
@@ -322,77 +321,98 @@ trait Eq[T]:
 ```
 
 we need to implement a method `Eq.derived` on the companion object of `Eq` that produces a given instance for `Eq[T]` given
-a `Mirror[T]`. Here is a possible implementation,
+a `Mirror[T]`.
+Here is a possible implementation,
 
 ```scala
 import scala.deriving.Mirror
 
-inline given derived[T](using m: Mirror.Of[T]): Eq[T] =
-  val elemInstances = summonAll[m.MirroredElemTypes]           // (1)
-  inline m match                                               // (2)
+inline def derived[T](using m: Mirror.Of[T]): Eq[T] =
+  lazy val elemInstances = summonInstances[T, m.MirroredElemTypes] // (1)
+  inline m match                                                   // (2)
     case s: Mirror.SumOf[T]     => eqSum(s, elemInstances)
     case p: Mirror.ProductOf[T] => eqProduct(p, elemInstances)
 ```
 
-Note that `derived` is defined as an `inline` given. This means that the method will be expanded at
-call sites (for instance the compiler generated instance definitions in the companion objects of ADTs which have a
-`derived Eq` clause), and also that it can be used recursively if necessary, to compute instances for children.
+Note that `derived` is defined as an `inline def`.
+This means that the method will be inlined at all call sites (for instance the compiler generated instance definitions in the companion objects of ADTs which have a `deriving Eq` clause).
 
-The body of this method (1) first materializes the `Eq` instances for all the child types of type the instance is
-being derived for. This is either all the branches of a sum type or all the fields of a product type. The
-implementation of `summonAll` is `inline` and uses Scala 3's `summonInline` construct to collect the instances as a
-`List`,
+> Inlining of complex code is potentially expensive if overused (meaning slower compile times) so we should be careful to limit how many times `derived` is called for the same type.
+> For example, when computing an instance for a sum type, it may be necessary to call `derived` recursively to compute an instance for a one of its child cases.
+> That child case may in turn be a product type, that declares a field referring back to the parent sum type.
+> To compute the instance for this field, we should not call `derived` recursively, but instead summon from the context.
+> Typically the found given instance will be the root given instance that initially called `derived`.
+
+The body of `derived` (1) first materializes the `Eq` instances for all the child types of type the instance is being derived for.
+This is either all the branches of a sum type or all the fields of a product type.
+The implementation of `summonInstances` is `inline` and uses Scala 3's `summonInline` construct to collect the instances as a `List`,
 
 ```scala
-inline def summonAll[T <: Tuple]: List[Eq[_]] =
-  inline erasedValue[T] match
+inline def summonInstances[T, Elems <: Tuple]: List[Eq[?]] =
+  inline erasedValue[Elems] match
+    case _: (elem *: elems) => deriveOrSummon[T, elem] :: summonInstances[T, elems]
     case _: EmptyTuple => Nil
-    case _: (t *: ts) => summonInline[Eq[t]] :: summonAll[ts]
+
+inline def deriveOrSummon[T, Elem]: Eq[Elem] =
+  inline erasedValue[Elem] match
+    case _: T => deriveRec[T, Elem]
+    case _    => summonInline[Eq[Elem]]
+
+inline def deriveRec[T, Elem]: Eq[Elem] =
+  inline erasedValue[T] match
+    case _: Elem => error("infinite recursive derivation")
+    case _       => Eq.derived[Elem](using summonInline[Mirror.Of[Elem]]) // recursive derivation
 ```
 
 with the instances for children in hand the `derived` method uses an `inline match` to dispatch to methods which can
-construct instances for either sums or products (2). Note that because `derived` is `inline` the match will be
-resolved at compile-time and only the left-hand side of the matching case will be inlined into the generated code with
-types refined as revealed by the match.
+construct instances for either sums or products (2).
+Note that because `derived` is `inline` the match will be resolved at compile-time and only the right-hand side of the matching case will be inlined into the generated code with types refined as revealed by the match.
 
-In the sum case, `eqSum`, we use the runtime `ordinal` values of the arguments to `eqv` to first check if the two
-values are of the same subtype of the ADT (3) and then, if they are, to further test for equality based on the `Eq`
-instance for the appropriate ADT subtype using the auxiliary method `check` (4).
+In the sum case, `eqSum`, we use the runtime `ordinal` values of the arguments to `eqv` to first check if the two values are of the same subtype of the ADT (3) and then, if they are, to further test for equality based on the `Eq` instance for the appropriate ADT subtype using the auxiliary method `check` (4).
 
 ```scala
 import scala.deriving.Mirror
 
-def eqSum[T](s: Mirror.SumOf[T], elems: List[Eq[_]]): Eq[T] =
+def eqSum[T](s: Mirror.SumOf[T], elems: => List[Eq[?]]): Eq[T] =
   new Eq[T]:
     def eqv(x: T, y: T): Boolean =
       val ordx = s.ordinal(x)                            // (3)
-      (s.ordinal(y) == ordx) && check(elems(ordx))(x, y) // (4)
+      (s.ordinal(y) == ordx) && check(x, y, elems(ordx)) // (4)
 ```
 
-In the product case, `eqProduct` we test the runtime values of the arguments to `eqv` for equality as products based
-on the `Eq` instances for the fields of the data type (5),
+In the product case, `eqProduct` we test the runtime values of the arguments to `eqv` for equality as products based on the `Eq` instances for the fields of the data type (5),
 
 ```scala
 import scala.deriving.Mirror
 
-def eqProduct[T](p: Mirror.ProductOf[T], elems: List[Eq[_]]): Eq[T] =
+def eqProduct[T](p: Mirror.ProductOf[T], elems: => List[Eq[?]]): Eq[T] =
   new Eq[T]:
     def eqv(x: T, y: T): Boolean =
-      iterator(x).zip(iterator(y)).zip(elems.iterator).forall {  // (5)
-        case ((x, y), elem) => check(elem)(x, y)
-      }
+      iterable(x).lazyZip(iterable(y)).lazyZip(elems).forall(check)
 ```
 
+Both `eqSum` and `eqProduct` have a by-name parameter `elems`, because the argument passed is the reference to the lazy `elemInstances` value.
+
 Pulling this all together we have the following complete implementation,
 
 ```scala
 import scala.deriving.*
-import scala.compiletime.{erasedValue, summonInline}
+import scala.compiletime.{error, erasedValue, summonInline}
 
-inline def summonAll[T <: Tuple]: List[Eq[_]] =
-  inline erasedValue[T] match
+inline def summonInstances[T, Elems <: Tuple]: List[Eq[?]] =
+  inline erasedValue[Elems] match
+    case _: (elem *: elems) => deriveOrSummon[T, elem] :: summonInstances[T, elems]
     case _: EmptyTuple => Nil
-    case _: (t *: ts) => summonInline[Eq[t]] :: summonAll[ts]
+
+inline def deriveOrSummon[T, Elem]: Eq[Elem] =
+  inline erasedValue[Elem] match
+    case _: T => deriveRec[T, Elem]
+    case _    => summonInline[Eq[Elem]]
+
+inline def deriveRec[T, Elem]: Eq[Elem] =
+  inline erasedValue[T] match
+    case _: Elem => error("infinite recursive derivation")
+    case _       => Eq.derived[Elem](using summonInline[Mirror.Of[Elem]]) // recursive derivation
 
 trait Eq[T]:
   def eqv(x: T, y: T): Boolean
@@ -401,26 +421,25 @@ object Eq:
   given Eq[Int] with
     def eqv(x: Int, y: Int) = x == y
 
-  def check(elem: Eq[_])(x: Any, y: Any): Boolean =
+  def check(x: Any, y: Any, elem: Eq[?]): Boolean =
     elem.asInstanceOf[Eq[Any]].eqv(x, y)
 
-  def iterator[T](p: T) = p.asInstanceOf[Product].productIterator
+  def iterable[T](p: T): Iterable[Any] = new AbstractIterable[Any]:
+    def iterator: Iterator[Any] = p.asInstanceOf[Product].productIterator
 
-  def eqSum[T](s: Mirror.SumOf[T], elems: => List[Eq[_]]): Eq[T] =
+  def eqSum[T](s: Mirror.SumOf[T], elems: => List[Eq[?]]): Eq[T] =
     new Eq[T]:
       def eqv(x: T, y: T): Boolean =
         val ordx = s.ordinal(x)
-        (s.ordinal(y) == ordx) && check(elems(ordx))(x, y)
+        (s.ordinal(y) == ordx) && check(x, y, elems(ordx))
 
-  def eqProduct[T](p: Mirror.ProductOf[T], elems: => List[Eq[_]]): Eq[T] =
+  def eqProduct[T](p: Mirror.ProductOf[T], elems: => List[Eq[?]]): Eq[T] =
     new Eq[T]:
       def eqv(x: T, y: T): Boolean =
-        iterator(x).zip(iterator(y)).zip(elems.iterator).forall {
-          case ((x, y), elem) => check(elem)(x, y)
-        }
+        iterable(x).lazyZip(iterable(y)).lazyZip(elems).forall(check)
 
-  inline given derived[T](using m: Mirror.Of[T]): Eq[T] =
-    lazy val elemInstances = summonAll[m.MirroredElemTypes]
+  inline def derived[T](using m: Mirror.Of[T]): Eq[T] =
+    lazy val elemInstances = summonInstances[T, m.MirroredElemTypes]
     inline m match
       case s: Mirror.SumOf[T]     => eqSum(s, elemInstances)
       case p: Mirror.ProductOf[T] => eqProduct(p, elemInstances)
@@ -430,32 +449,39 @@ end Eq
 we can test this relative to a simple ADT like so,
 
 ```scala
-enum Opt[+T] derives Eq:
-  case Sm(t: T)
-  case Nn
+enum Lst[+T] derives Eq:
+  case Cns(t: T, ts: Lst[T])
+  case Nl
+
+extension [T](t: T) def ::(ts: Lst[T]): Lst[T] = Lst.Cns(t, ts)
 
 @main def test(): Unit =
-  import Opt.*
-  val eqoi = summon[Eq[Opt[Int]]]
-  assert(eqoi.eqv(Sm(23), Sm(23)))
-  assert(!eqoi.eqv(Sm(23), Sm(13)))
-  assert(!eqoi.eqv(Sm(23), Nn))
+  import Lst.*
+  val eqoi = summon[Eq[Lst[Int]]]
+  assert(eqoi.eqv(23 :: 47 :: Nl, 23 :: 47 :: Nl))
+  assert(!eqoi.eqv(23 :: Nl, 7 :: Nl))
+  assert(!eqoi.eqv(23 :: Nl, Nl))
 ```
 
-In this case the code that is generated by the inline expansion for the derived `Eq` instance for `Opt` looks like the
+In this case the code that is generated by the inline expansion for the derived `Eq` instance for `Lst` looks like the
 following, after a little polishing,
 
 ```scala
-given derived$Eq[T](using eqT: Eq[T]): Eq[Opt[T]] =
-  eqSum(
-    summon[Mirror[Opt[T]]],
+given derived$Eq[T](using eqT: Eq[T]): Eq[Lst[T]] =
+  eqSum(summon[Mirror.Of[Lst[T]]], {/* cached lazily */
     List(
-      eqProduct(summon[Mirror[Sm[T]]], List(summon[Eq[T]])),
-      eqProduct(summon[Mirror[Nn.type]], Nil)
+      eqProduct(summon[Mirror.Of[Cns[T]]], {/* cached lazily */
+        List(summon[Eq[T]], summon[Eq[Lst[T]]])
+      }),
+      eqProduct(summon[Mirror.Of[Nl.type]], {/* cached lazily */
+        Nil
+      })
     )
-  )
+  })
 ```
 
+The `lazy` modifier on `elemInstances` is necessary for preventing infinite recursion in the derived instance for recursive types such as `Lst`.
+
 Alternative approaches can be taken to the way that `derived` methods can be defined. For example, more aggressively
 inlined variants using Scala 3 macros, whilst being more involved for type class authors to write than the example
 above, can produce code for type classes like `Eq` which eliminate all the abstraction artefacts (eg. the `Lists` of
@@ -469,7 +495,7 @@ given eqSum[A](using inst: => K0.CoproductInstances[Eq, A]): Eq[A] with
     [t] => (eqt: Eq[t], t0: t, t1: t) => eqt.eqv(t0, t1)
   )
 
-given eqProduct[A](using inst: K0.ProductInstances[Eq, A]): Eq[A] with
+given eqProduct[A](using inst: => K0.ProductInstances[Eq, A]): Eq[A] with
   def eqv(x: A, y: A): Boolean = inst.foldLeft2(x, y)(true: Boolean)(
     [t] => (acc: Boolean, eqt: Eq[t], t0: t, t1: t) =>
       Complete(!eqt.eqv(t0, t1))(false)(true)

From 46cd9c9bf0d67a338f3fc824bd1fa23aa3af1f93 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 9 May 2023 12:59:39 +0200
Subject: [PATCH 540/657] Remove redundant case override in TreeTypeMap

This case is handled in the same way by TreeMap.
---
 compiler/src/dotty/tools/dotc/ast/TreeTypeMap.scala | 5 -----
 compiler/src/dotty/tools/dotc/ast/Trees.scala       | 4 ++--
 2 files changed, 2 insertions(+), 7 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/TreeTypeMap.scala b/compiler/src/dotty/tools/dotc/ast/TreeTypeMap.scala
index faeafae97f5e..955892b2ae22 100644
--- a/compiler/src/dotty/tools/dotc/ast/TreeTypeMap.scala
+++ b/compiler/src/dotty/tools/dotc/ast/TreeTypeMap.scala
@@ -146,11 +146,6 @@ class TreeTypeMap(
           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 tree1 =>
           super.transform(tree1)
       }
diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala
index 77583a9a77e2..704425fbf25b 100644
--- a/compiler/src/dotty/tools/dotc/ast/Trees.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala
@@ -1563,8 +1563,8 @@ object Trees {
               cpy.Quote(tree)(transform(body)(using quoteContext))
             case tree @ Splice(expr) =>
               cpy.Splice(tree)(transform(expr)(using spliceContext))
-            case tree @ Hole(_, _, args, content, tpt) =>
-              cpy.Hole(tree)(args = transform(args), content = transform(content), tpt = transform(tpt))
+            case tree @ Hole(isTerm, idx, args, content, tpt) =>
+              cpy.Hole(tree)(isTerm, idx, transform(args), transform(content), transform(tpt))
             case _ =>
               transformMoreCases(tree)
           }

From 50d630312bbdb8a0926da831a6b2a2d2f2ab531c Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 9 May 2023 13:05:18 +0200
Subject: [PATCH 541/657] Remove unnecessary isTermHole method from Hole

---
 compiler/src/dotty/tools/dotc/ast/Trees.scala              | 7 +++----
 compiler/src/dotty/tools/dotc/ast/tpd.scala                | 4 ++--
 compiler/src/dotty/tools/dotc/ast/untpd.scala              | 2 +-
 .../src/dotty/tools/dotc/printing/RefinedPrinter.scala     | 4 ++--
 compiler/src/dotty/tools/dotc/quoted/PickledQuotes.scala   | 4 ++--
 compiler/src/dotty/tools/dotc/transform/TreeChecker.scala  | 6 +++---
 6 files changed, 13 insertions(+), 14 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala
index 704425fbf25b..61009f48a8f0 100644
--- a/compiler/src/dotty/tools/dotc/ast/Trees.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala
@@ -1033,16 +1033,15 @@ object Trees {
   /** 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 isTerm 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] {
+  case class Hole[+T <: Untyped](override val isTerm: 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
+    override def isType: Boolean = !isTerm
   }
 
   def flatten[T <: Untyped](trees: List[Tree[T]]): List[Tree[T]] = {
diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
index 3a957c8f4612..d26735bdeb05 100644
--- a/compiler/src/dotty/tools/dotc/ast/tpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -397,8 +397,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   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)
+  def Hole(isTerm: Boolean, idx: Int, args: List[Tree], content: Tree, tpt: Tree)(using Context): Hole =
+    ta.assignType(untpd.Hole(isTerm, idx, args, content, tpt), tpt)
 
   // ------ Making references ------------------------------------------------------
 
diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
index 30f58fba44ec..895423638eb2 100644
--- a/compiler/src/dotty/tools/dotc/ast/untpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -424,7 +424,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   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)
+  def Hole(isTerm: Boolean, idx: Int, args: List[Tree], content: Tree, tpt: Tree)(implicit src: SourceFile): Hole = new Hole(isTerm, idx, args, content, tpt)
 
   // ------ Additional creation methods for untyped only -----------------
 
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index 93de33778750..6cad9b500940 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -724,8 +724,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case Splice(expr) =>
         val spliceTypeText = (keywordStr("[") ~ toTextGlobal(tree.typeOpt) ~ keywordStr("]")).provided(printDebug && tree.typeOpt.exists)
         keywordStr("$") ~ spliceTypeText ~ keywordStr("{") ~ toTextGlobal(expr) ~ keywordStr("}")
-      case Hole(isTermHole, idx, args, content, tpt) =>
-        val (prefix, postfix) = if isTermHole then ("{{{", "}}}") else ("[[[", "]]]")
+      case Hole(isTerm, idx, args, content, tpt) =>
+        val (prefix, postfix) = if isTerm then ("{{{", "}}}") else ("[[[", "]]]")
         val argsText = toTextGlobal(args, ", ")
         val contentText = toTextGlobal(content)
         val tptText = toTextGlobal(tpt)
diff --git a/compiler/src/dotty/tools/dotc/quoted/PickledQuotes.scala b/compiler/src/dotty/tools/dotc/quoted/PickledQuotes.scala
index 43e2aae4c58c..89efcb4272ec 100644
--- a/compiler/src/dotty/tools/dotc/quoted/PickledQuotes.scala
+++ b/compiler/src/dotty/tools/dotc/quoted/PickledQuotes.scala
@@ -100,9 +100,9 @@ object PickledQuotes {
   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, _, _) =>
+        case Hole(isTerm, idx, args, _, _) =>
           inContext(SpliceScope.contextWithNewSpliceScope(tree.sourcePos)) {
-            if isTermHole then
+            if isTerm then
               val quotedExpr = termHole match
                 case ExprHole.V1(evalHole) =>
                   evalHole.nn.apply(idx, reifyExprHoleV1Args(args), QuotesImpl())
diff --git a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
index f9240d6091c4..6d066ff4dc76 100644
--- a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
@@ -658,7 +658,7 @@ object TreeChecker {
         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
+      val tree1 @ Hole(isTerm, _, args, content, tpt) = super.typedHole(tree, pt): @unchecked
 
       // Check that we only add the captured type `T` instead of a more complex type like `List[T]`.
       // If we have `F[T]` with captured `F` and `T`, we should list `F` and `T` separately in the args.
@@ -666,7 +666,7 @@ object TreeChecker {
         assert(arg.isTerm || arg.tpe.isInstanceOf[TypeRef], "Expected TypeRef in Hole type args but got: " + arg.tpe)
 
       // Check result type of the hole
-      if isTermHole then assert(tpt.typeOpt <:< pt)
+      if isTerm 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
@@ -682,7 +682,7 @@ object TreeChecker {
         else defn.QuotedTypeClass.typeRef.appliedTo(arg.typeOpt.widenTermRefExpr)
       }
       val expectedResultType =
-        if isTermHole then defn.QuotedExprClass.typeRef.appliedTo(tpt.typeOpt)
+        if isTerm 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)

From c909024fa54c225007a29eb9d539695b86405fbd Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 9 May 2023 08:39:03 +0200
Subject: [PATCH 542/657] Only check newVal/newMethod privateWithin on
 -Xcheck-macros

Closes #17432
---
 .../src/scala/quoted/runtime/impl/QuotesImpl.scala     | 10 ++++++----
 tests/{neg => neg-macros}/i17351/Macro_1.scala         |  0
 tests/{neg => neg-macros}/i17351/Test_2.scala          |  0
 3 files changed, 6 insertions(+), 4 deletions(-)
 rename tests/{neg => neg-macros}/i17351/Macro_1.scala (100%)
 rename tests/{neg => neg-macros}/i17351/Test_2.scala (100%)

diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
index df7ec3da51af..4231781e2754 100644
--- a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
+++ b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
@@ -2540,13 +2540,15 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
       def newMethod(owner: Symbol, name: String, tpe: TypeRepr): Symbol =
         newMethod(owner, name, tpe, Flags.EmptyFlags, noSymbol)
       def newMethod(owner: Symbol, name: String, tpe: TypeRepr, flags: Flags, privateWithin: Symbol): Symbol =
-        assert(!privateWithin.exists || privateWithin.isType, "privateWithin must be a type symbol or `Symbol.noSymbol`")
+        xCheckMacroAssert(!privateWithin.exists || privateWithin.isType, "privateWithin must be a type symbol or `Symbol.noSymbol`")
+        val privateWithin1 = if privateWithin.isTerm then Symbol.noSymbol else privateWithin
         checkValidFlags(flags.toTermFlags, Flags.validMethodFlags)
-        dotc.core.Symbols.newSymbol(owner, name.toTermName, flags | dotc.core.Flags.Method, tpe, privateWithin)
+        dotc.core.Symbols.newSymbol(owner, name.toTermName, flags | dotc.core.Flags.Method, tpe, privateWithin1)
       def newVal(owner: Symbol, name: String, tpe: TypeRepr, flags: Flags, privateWithin: Symbol): Symbol =
-        assert(!privateWithin.exists || privateWithin.isType, "privateWithin must be a type symbol or `Symbol.noSymbol`")
+        xCheckMacroAssert(!privateWithin.exists || privateWithin.isType, "privateWithin must be a type symbol or `Symbol.noSymbol`")
+        val privateWithin1 = if privateWithin.isTerm then Symbol.noSymbol else privateWithin
         checkValidFlags(flags.toTermFlags, Flags.validValFlags)
-        dotc.core.Symbols.newSymbol(owner, name.toTermName, flags, tpe, privateWithin)
+        dotc.core.Symbols.newSymbol(owner, name.toTermName, flags, tpe, privateWithin1)
       def newBind(owner: Symbol, name: String, flags: Flags, tpe: TypeRepr): Symbol =
         checkValidFlags(flags.toTermFlags, Flags.validBindFlags)
         dotc.core.Symbols.newSymbol(owner, name.toTermName, flags | dotc.core.Flags.Case, tpe)
diff --git a/tests/neg/i17351/Macro_1.scala b/tests/neg-macros/i17351/Macro_1.scala
similarity index 100%
rename from tests/neg/i17351/Macro_1.scala
rename to tests/neg-macros/i17351/Macro_1.scala
diff --git a/tests/neg/i17351/Test_2.scala b/tests/neg-macros/i17351/Test_2.scala
similarity index 100%
rename from tests/neg/i17351/Test_2.scala
rename to tests/neg-macros/i17351/Test_2.scala

From 968ebab3a525555fe50054fc5d6f504efe6db73c Mon Sep 17 00:00:00 2001
From: Lucas <leblanc.lucas29@gmail.com>
Date: Thu, 4 May 2023 10:52:01 +0200
Subject: [PATCH 543/657] Add test for BlogParser and Can parse a String

---
 .../tools/scaladoc/site/BlogParser.scala      | 33 +++++++++----------
 .../tools/scaladoc/site/BlogParserTest.scala  | 19 +++++++++++
 2 files changed, 34 insertions(+), 18 deletions(-)
 create mode 100644 scaladoc/test/dotty/tools/scaladoc/site/BlogParserTest.scala

diff --git a/scaladoc/src/dotty/tools/scaladoc/site/BlogParser.scala b/scaladoc/src/dotty/tools/scaladoc/site/BlogParser.scala
index 6fd3d3db0c8d..68e709a339b2 100644
--- a/scaladoc/src/dotty/tools/scaladoc/site/BlogParser.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/site/BlogParser.scala
@@ -1,29 +1,26 @@
-package dotty.tools.scaladoc
-package site
+package dotty.tools.scaladoc.site
 
 import com.fasterxml.jackson.databind.ObjectMapper
 import com.fasterxml.jackson.dataformat.yaml.YAMLFactory
 import com.fasterxml.jackson.databind.DeserializationFeature
 import java.io.File
-import scala.beans._
+import scala.beans.{BooleanBeanProperty, BeanProperty}
+import scala.util.Try
 
 case class BlogConfig(
-  @BeanProperty var input: String,
-  @BeanProperty var output: String,
-  @BooleanBeanProperty var hidden: Boolean
+  @BeanProperty input: String,
+  @BeanProperty output: String,
+  @BooleanBeanProperty hidden: Boolean
 ):
-    def this() = this(null, null, false)
+  def this() = this(null, null, false)
 
 object BlogParser:
-  def readYml(root: File): BlogConfig =
-    val ymlFile = root.toPath
-    .resolve("blog.yml")
-    .toFile
+  def readYml(content: File | String): BlogConfig =
+    val mapper = ObjectMapper(YAMLFactory())
+      .findAndRegisterModules()
 
-    if ymlFile.exists then
-      val mapper = new ObjectMapper(new YAMLFactory())
-      mapper.findAndRegisterModules();
-
-      val blogConfig: BlogConfig = mapper.readValue(ymlFile, classOf[BlogConfig])
-      blogConfig
-    else new BlogConfig
+    content match
+      case f: File =>
+        val ymlFile = f.toPath.resolve("blog.yml").toFile
+        if ymlFile.exists then mapper.readValue(ymlFile, classOf[BlogConfig]) else new BlogConfig
+      case s: String => Try(mapper.readValue(s, classOf[BlogConfig])).getOrElse(new BlogConfig)
diff --git a/scaladoc/test/dotty/tools/scaladoc/site/BlogParserTest.scala b/scaladoc/test/dotty/tools/scaladoc/site/BlogParserTest.scala
new file mode 100644
index 000000000000..e27c257c8e4a
--- /dev/null
+++ b/scaladoc/test/dotty/tools/scaladoc/site/BlogParserTest.scala
@@ -0,0 +1,19 @@
+package dotty.tools.scaladoc
+package site
+
+import org.junit.Test
+import org.junit.Assert._
+
+class BlogParserTest:
+
+  private val blogConfig =
+    """input: blog
+      |output: blog
+      |hidden: false
+      |""".stripMargin
+
+  @Test
+  def loadBlog(): Unit = assertEquals(
+    BlogConfig("blog", "blog", false),
+    BlogParser.readYml(blogConfig)
+  )
\ No newline at end of file

From 156ec83c59dbed4b1d8e4adb118d82c0de1e1d8d Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Tue, 9 May 2023 17:28:38 +0200
Subject: [PATCH 544/657] Address review comments

---
 compiler/src/dotty/tools/dotc/parsing/Parsers.scala | 2 +-
 tests/neg-custom-args/boxmap.scala                  | 4 ++--
 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 33bd46f619aa..2f51af8549ae 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -1673,7 +1673,7 @@ object Parsers {
       infixOps(t, canStartInfixTypeTokens, refinedTypeFn, Location.ElseWhere, ParseKind.Type,
         isOperator = !followingIsVararg() && !isPureArrow)
 
-    /** RefinedType   ::=  WithType {[nl] (Refinement} [`^` CaptureSet]
+    /** RefinedType   ::=  WithType {[nl] Refinement} [`^` CaptureSet]
      */
     val refinedTypeFn: Location => Tree = _ => refinedType()
 
diff --git a/tests/neg-custom-args/boxmap.scala b/tests/neg-custom-args/boxmap.scala
index cdc8253acf2a..1696ac3505e4 100644
--- a/tests/neg-custom-args/boxmap.scala
+++ b/tests/neg-custom-args/boxmap.scala
@@ -16,6 +16,6 @@ def test[A <: Top, B <: Top] =
   def lazymap[A <: Top, B <: Top](b: Box[A])(f: A => B) =
     () => b[Box[B]]((x: A) => box(f(x)))
   val x0: (b: Box[A]) -> (f: A => B) -> (() -> Box[B]) = lazymap[A, B]  // error
-  val x: (b: Box[A]) -> (f: A => B) ->{b, f} (() -> Box[B]) = lazymap[A, B]  // works
-  val y: (b: Box[A]) -> (f: A => B) ->{cap} (() -> Box[B]) = lazymap[A, B]  // works
+  val x: (b: Box[A]) -> (f: A => B) -> (() ->{b, f} Box[B]) = lazymap[A, B]  // works
+  val y: (b: Box[A]) -> (f: A => B) -> (() ->{cap} Box[B]) = lazymap[A, B]  // works
   ()

From da01fd7514aee6ac09407088e0dbfea7c82692b9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Marks?= <pmarks@virtuslab.com>
Date: Tue, 9 May 2023 19:39:08 +0200
Subject: [PATCH 545/657] Do not run scaladoc tests on queue branches (#16923)

Instead, run it on the `merge_group` trigger.

This is a very minor change that allows us for easier filtering of
actions.
---
 .github/workflows/scaladoc.yaml | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/scaladoc.yaml b/.github/workflows/scaladoc.yaml
index 9ccbe34788ce..3108f2b94562 100644
--- a/.github/workflows/scaladoc.yaml
+++ b/.github/workflows/scaladoc.yaml
@@ -4,9 +4,11 @@ on:
   push:
     branches-ignore:
       - 'language-reference-stable'
+      - 'gh-readonly-queue/**'
   pull_request:
     branches-ignore:
       - 'language-reference-stable'
+  merge_group:
 permissions:
   contents: read
 
@@ -15,7 +17,8 @@ jobs:
     env:
       AZURE_STORAGE_SAS_TOKEN: ${{ secrets.AZURE_STORAGE_SAS_TOKEN }}
     runs-on: ubuntu-latest
-    if: "(    github.event_name == 'pull_request'
+    if: "github.event_name == 'merge_group'
+         || (    github.event_name == 'pull_request'
            && !contains(github.event.pull_request.body, '[skip ci]')
            && !contains(github.event.pull_request.body, '[skip docs]')
          )

From 68e720ced5685fdc26c7d887c33c1c3aed269e15 Mon Sep 17 00:00:00 2001
From: Guillaume Raffin <theelectronwill@gmail.com>
Date: Sun, 5 Mar 2023 19:12:47 +0100
Subject: [PATCH 546/657] Support records in JavaParsers

This is a port of scala/scala#9551
---
 .../src/dotty/tools/dotc/core/StdNames.scala  |  7 ++
 .../tools/dotc/parsing/JavaParsers.scala      | 82 +++++++++++++++++--
 .../dotty/tools/dotc/parsing/JavaTokens.scala |  3 +
 tests/pos/java-records/FromScala.scala        | 15 ++++
 tests/pos/java-records/R1.java                |  9 ++
 5 files changed, 109 insertions(+), 7 deletions(-)
 create mode 100644 tests/pos/java-records/FromScala.scala
 create mode 100644 tests/pos/java-records/R1.java

diff --git a/compiler/src/dotty/tools/dotc/core/StdNames.scala b/compiler/src/dotty/tools/dotc/core/StdNames.scala
index 27e97a92b48e..c54a60f5a8fa 100644
--- a/compiler/src/dotty/tools/dotc/core/StdNames.scala
+++ b/compiler/src/dotty/tools/dotc/core/StdNames.scala
@@ -204,6 +204,7 @@ object StdNames {
     final val Null: N                = "Null"
     final val Object: N              = "Object"
     final val FromJavaObject: N      = "<FromJavaObject>"
+    final val Record: N              = "Record"
     final val Product: N             = "Product"
     final val PartialFunction: N     = "PartialFunction"
     final val PrefixType: N          = "PrefixType"
@@ -912,6 +913,10 @@ object StdNames {
     final val VOLATILEkw: N     = kw("volatile")
     final val WHILEkw: N        = kw("while")
 
+    final val RECORDid: N         = "record"
+    final val VARid: N            = "var"
+    final val YIELDid: N          = "yield"
+
     final val BoxedBoolean: N       = "java.lang.Boolean"
     final val BoxedByte: N          = "java.lang.Byte"
     final val BoxedCharacter: N     = "java.lang.Character"
@@ -944,6 +949,8 @@ object StdNames {
     final val JavaSerializable: N    = "java.io.Serializable"
   }
 
+
+
   class JavaTermNames extends JavaNames[TermName] {
     protected def fromString(s: String): TermName = termName(s)
   }
diff --git a/compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala b/compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala
index daeebcbcc17c..71aeee05fe10 100644
--- a/compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala
@@ -20,7 +20,9 @@ import StdNames._
 import reporting._
 import dotty.tools.dotc.util.SourceFile
 import util.Spans._
+
 import scala.collection.mutable.ListBuffer
+import scala.collection.immutable.ListMap
 
 object JavaParsers {
 
@@ -96,8 +98,12 @@ object JavaParsers {
     def javaLangDot(name: Name): Tree =
       Select(javaDot(nme.lang), name)
 
+    /** Tree representing `java.lang.Object` */
     def javaLangObject(): Tree = javaLangDot(tpnme.Object)
 
+    /** Tree representing `java.lang.Record` */
+    def javaLangRecord(): Tree = javaLangDot(tpnme.Record)
+
     def arrayOf(tpt: Tree): AppliedTypeTree =
       AppliedTypeTree(scalaDot(tpnme.Array), List(tpt))
 
@@ -555,6 +561,14 @@ object JavaParsers {
 
     def definesInterface(token: Int): Boolean = token == INTERFACE || token == AT
 
+    /** If the next token is the identifier "record", convert it into the RECORD token.
+      * This makes it easier to handle records in various parts of the code,
+      * in particular when a `parentToken` is passed to some functions.
+      */
+    def adaptRecordIdentifier(): Unit =
+      if in.token == IDENTIFIER && in.name == jnme.RECORDid then
+        in.token = RECORD
+
     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()
@@ -581,6 +595,16 @@ object JavaParsers {
                    TypeTree(), methodBody()).withMods(mods)
           }
         }
+      } else if (in.token == LBRACE && rtptName != nme.EMPTY && parentToken == RECORD) {
+        /*
+        record RecordName(T param1, ...) {
+          RecordName { // <- here
+            // methodBody
+          }
+        }
+        */
+        methodBody()
+        Nil
       }
       else {
         var mods1 = mods
@@ -717,12 +741,11 @@ object JavaParsers {
       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)
+    def memberDecl(start: Offset, mods: Modifiers, parentToken: Int, parentTParams: List[TypeDef]): List[Tree] = in.token match
+      case CLASS | ENUM | RECORD | INTERFACE | AT =>
+        typeDecl(start, if definesInterface(parentToken) then mods | Flags.JavaStatic else mods)
       case _ =>
         termDecl(start, mods, parentToken, parentTParams)
-    }
 
     def makeCompanionObject(cdef: TypeDef, statics: List[Tree]): Tree =
       atSpan(cdef.span) {
@@ -804,6 +827,49 @@ object JavaParsers {
       addCompanionObject(statics, cls)
     }
 
+    def recordDecl(start: Offset, mods: Modifiers): List[Tree] =
+      accept(RECORD)
+      val nameOffset = in.offset
+      val name = identForType()
+      val tparams = typeParams()
+      val header = formalParams()
+      val superclass = javaLangRecord() // records always extend java.lang.Record
+      val interfaces = interfacesOpt() // records may implement interfaces
+      val (statics, body) = typeBody(RECORD, name, tparams)
+
+      // We need to generate accessors for every param, if no method with the same name is already defined
+
+      var fieldsByName = header.map(v => (v.name, (v.tpt, v.mods.annotations))).to(ListMap)
+
+      for case DefDef(name, paramss, _, _) <- body
+      if paramss.isEmpty && fieldsByName.contains(name)
+      do
+        fieldsByName -= name
+      end for
+
+      val accessors =
+        (for (name, (tpt, annots)) <- fieldsByName yield
+          DefDef(name, Nil, tpt, unimplementedExpr)
+            .withMods(Modifiers(Flags.JavaDefined | Flags.Method | Flags.Synthetic))
+        ).toList
+
+      // generate the canonical constructor
+      val canonicalConstructor = makeConstructor(header, tparams)
+
+      // return the trees
+      val recordTypeDef = atSpan(start, nameOffset) {
+        TypeDef(name,
+          makeTemplate(
+            parents = superclass :: interfaces,
+            stats = canonicalConstructor :: accessors ::: body,
+            tparams = tparams,
+            false
+          )
+        )
+      }
+      addCompanionObject(statics, recordTypeDef)
+    end recordDecl
+
     def interfaceDecl(start: Offset, mods: Modifiers): List[Tree] = {
       accept(INTERFACE)
       val nameOffset = in.offset
@@ -846,7 +912,8 @@ object JavaParsers {
         else if (in.token == SEMI)
           in.nextToken()
         else {
-          if (in.token == ENUM || definesInterface(in.token)) mods |= Flags.JavaStatic
+          adaptRecordIdentifier()
+          if (in.token == ENUM || in.token == RECORD || definesInterface(in.token)) mods |= Flags.JavaStatic
           val decls = memberDecl(start, mods, parentToken, parentTParams)
           (if (mods.is(Flags.JavaStatic) || inInterface && !(decls exists (_.isInstanceOf[DefDef])))
             statics
@@ -947,13 +1014,13 @@ object JavaParsers {
       }
     }
 
-    def typeDecl(start: Offset, mods: Modifiers): List[Tree] = in.token match {
+    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 RECORD    => recordDecl(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 {
@@ -1004,6 +1071,7 @@ object JavaParsers {
         if (in.token != EOF) {
           val start = in.offset
           val mods = modifiers(inInterface = false)
+          adaptRecordIdentifier() // needed for typeDecl
           buf ++= typeDecl(start, mods)
         }
       }
diff --git a/compiler/src/dotty/tools/dotc/parsing/JavaTokens.scala b/compiler/src/dotty/tools/dotc/parsing/JavaTokens.scala
index 3e73b6d95adb..2b7882173e00 100644
--- a/compiler/src/dotty/tools/dotc/parsing/JavaTokens.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/JavaTokens.scala
@@ -41,6 +41,9 @@ object JavaTokens extends TokensCommon {
   inline val SWITCH = 133;           enter(SWITCH, "switch")
   inline val ASSERT = 134;           enter(ASSERT, "assert")
 
+  /** contextual keywords (turned into keywords in certain conditions, see JLS 3.9 of Java 9+) */
+  inline val RECORD = 135;           enter(RECORD, "record")
+
   /** special symbols */
   inline val EQEQ = 140
   inline val BANGEQ = 141
diff --git a/tests/pos/java-records/FromScala.scala b/tests/pos/java-records/FromScala.scala
new file mode 100644
index 000000000000..d9b9f4d2e129
--- /dev/null
+++ b/tests/pos/java-records/FromScala.scala
@@ -0,0 +1,15 @@
+object C:
+  def useR1 =
+    // constructor signature
+    val r = R1(123, "hello")
+
+    // accessors
+    val i: Int = r.i
+    val s: String = r.s
+
+    // methods
+    val iRes: Int = r.getInt()
+    val sRes: String = r.getString()
+
+    // supertype
+    val record: java.lang.Record = r
diff --git a/tests/pos/java-records/R1.java b/tests/pos/java-records/R1.java
new file mode 100644
index 000000000000..832d288547ab
--- /dev/null
+++ b/tests/pos/java-records/R1.java
@@ -0,0 +1,9 @@
+public record R1(int i, String s) {
+  public String getString() {
+    return s + i;
+  }
+
+  public int getInt() {
+    return 0;
+  }
+}

From ed126d9657c8eb4886bee3bb2e05310c8f41a8ef Mon Sep 17 00:00:00 2001
From: Guillaume Raffin <theelectronwill@gmail.com>
Date: Tue, 7 Mar 2023 17:46:27 +0100
Subject: [PATCH 547/657] Fix record's constructor

Co-authored-by: Guillaume Martres <smarter@users.noreply.github.com>
---
 compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala | 5 +++--
 compiler/src/dotty/tools/dotc/typer/Typer.scala         | 2 +-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala b/compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala
index 71aeee05fe10..5ab187871542 100644
--- a/compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala
@@ -854,7 +854,8 @@ object JavaParsers {
         ).toList
 
       // generate the canonical constructor
-      val canonicalConstructor = makeConstructor(header, tparams)
+      val canonicalConstructor =
+        DefDef(nme.CONSTRUCTOR, joinParams(tparams, List(header)), TypeTree(), EmptyTree).withMods(Modifiers(Flags.JavaDefined, mods.privateWithin))
 
       // return the trees
       val recordTypeDef = atSpan(start, nameOffset) {
@@ -863,7 +864,7 @@ object JavaParsers {
             parents = superclass :: interfaces,
             stats = canonicalConstructor :: accessors ::: body,
             tparams = tparams,
-            false
+            true
           )
         )
       }
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 7eb8519739c6..02df12ecc0bc 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -3589,7 +3589,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     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)
+    assert(pt.exists && !pt.isInstanceOf[ExprType] || ctx.reporter.errorsReported, i"tree: $tree, pt: $pt")
     def methodStr = err.refStr(methPart(tree).tpe)
 
     def readapt(tree: Tree)(using Context) = adapt(tree, pt, locked)

From d1df3eed906ffd5b79a0d4fb0051d6dad7e92ff2 Mon Sep 17 00:00:00 2001
From: Guillaume Raffin <theelectronwill@gmail.com>
Date: Tue, 7 Mar 2023 18:08:51 +0100
Subject: [PATCH 548/657] Add more record tests and only run them on java >= 16

Co-authored-by: Guillaume Martres <smarter@users.noreply.github.com>
---
 .../dotty/tools/dotc/CompilationTests.scala   | 11 +++--
 .../pos-java16+/java-records/FromScala.scala  | 43 +++++++++++++++++++
 tests/pos-java16+/java-records/IntLike.scala  |  2 +
 .../{pos => pos-java16+}/java-records/R1.java |  0
 tests/pos-java16+/java-records/R2.java        | 13 ++++++
 tests/pos-java16+/java-records/R3.java        | 22 ++++++++++
 tests/pos/java-records/FromScala.scala        | 15 -------
 7 files changed, 88 insertions(+), 18 deletions(-)
 create mode 100644 tests/pos-java16+/java-records/FromScala.scala
 create mode 100644 tests/pos-java16+/java-records/IntLike.scala
 rename tests/{pos => pos-java16+}/java-records/R1.java (100%)
 create mode 100644 tests/pos-java16+/java-records/R2.java
 create mode 100644 tests/pos-java16+/java-records/R3.java
 delete mode 100644 tests/pos/java-records/FromScala.scala

diff --git a/compiler/test/dotty/tools/dotc/CompilationTests.scala b/compiler/test/dotty/tools/dotc/CompilationTests.scala
index c782c78f8eb7..8107e1579525 100644
--- a/compiler/test/dotty/tools/dotc/CompilationTests.scala
+++ b/compiler/test/dotty/tools/dotc/CompilationTests.scala
@@ -29,7 +29,7 @@ class CompilationTests {
 
   @Test def pos: Unit = {
     implicit val testGroup: TestGroup = TestGroup("compilePos")
-    aggregateTests(
+    var tests = List(
       compileFile("tests/pos/nullarify.scala", defaultOptions.and("-Ycheck:nullarify")),
       compileFile("tests/pos-special/utf8encoded.scala", explicitUTF8),
       compileFile("tests/pos-special/utf16encoded.scala", explicitUTF16),
@@ -65,8 +65,13 @@ class CompilationTests {
       compileFile("tests/pos-special/extend-java-enum.scala", defaultOptions.and("-source", "3.0-migration")),
       compileFile("tests/pos-custom-args/help.scala", defaultOptions.and("-help", "-V", "-W", "-X", "-Y")),
       compileFile("tests/pos-custom-args/i13044.scala", defaultOptions.and("-Xmax-inlines:33")),
-      compileFile("tests/pos-custom-args/jdk-8-app.scala", defaultOptions.and("-release:8")),
-    ).checkCompile()
+      compileFile("tests/pos-custom-args/jdk-8-app.scala", defaultOptions.and("-release:8"))
+    )
+
+    if scala.util.Properties.isJavaAtLeast("16") then
+      tests ::= compileFilesInDir("tests/pos-java16+", defaultOptions.and("-Ysafe-init"))
+
+    aggregateTests(tests*).checkCompile()
   }
 
   @Test def rewrites: Unit = {
diff --git a/tests/pos-java16+/java-records/FromScala.scala b/tests/pos-java16+/java-records/FromScala.scala
new file mode 100644
index 000000000000..67747e658432
--- /dev/null
+++ b/tests/pos-java16+/java-records/FromScala.scala
@@ -0,0 +1,43 @@
+object C:
+  def useR1: Unit =
+    // constructor signature
+    val r = R1(123, "hello")
+
+    // accessors
+    val i: Int = r.i
+    val s: String = r.s
+
+    // methods
+    val iRes: Int = r.getInt()
+    val sRes: String = r.getString()
+
+    // supertype
+    val record: java.lang.Record = r
+
+  def useR2: Unit =
+    // constructor signature
+    val r2 = R2.R(123, "hello")
+
+    // accessors signature
+    val i: Int = r2.i
+    val s: String = r2.s
+
+    // method
+    val i2: Int = r2.getInt
+
+    // supertype
+    val isIntLike: IntLike = r2
+    val isRecord: java.lang.Record = r2
+
+  def useR3 =
+    // constructor signature
+    val r3 = R3(123, 42L, "hi")
+    new R3("hi", 123)
+    // accessors signature
+    val i: Int = r3.i
+    val l: Long = r3.l
+    val s: String = r3.s
+    // method
+    val l2: Long = r3.l(43L, 44L)
+    // supertype
+    val isRecord: java.lang.Record = r3
diff --git a/tests/pos-java16+/java-records/IntLike.scala b/tests/pos-java16+/java-records/IntLike.scala
new file mode 100644
index 000000000000..1f760018a975
--- /dev/null
+++ b/tests/pos-java16+/java-records/IntLike.scala
@@ -0,0 +1,2 @@
+trait IntLike:
+  def getInt: Int
diff --git a/tests/pos/java-records/R1.java b/tests/pos-java16+/java-records/R1.java
similarity index 100%
rename from tests/pos/java-records/R1.java
rename to tests/pos-java16+/java-records/R1.java
diff --git a/tests/pos-java16+/java-records/R2.java b/tests/pos-java16+/java-records/R2.java
new file mode 100644
index 000000000000..01da13d83b65
--- /dev/null
+++ b/tests/pos-java16+/java-records/R2.java
@@ -0,0 +1,13 @@
+public class R2 {
+    final record R(int i, String s) implements IntLike {
+        public int getInt() {
+            return i;
+        }
+
+        // Canonical constructor
+        // public R(int i, java.lang.String s) {
+        //     this.i = i;
+        //     this.s = s.intern();
+        // }
+    }
+}
diff --git a/tests/pos-java16+/java-records/R3.java b/tests/pos-java16+/java-records/R3.java
new file mode 100644
index 000000000000..616481a0ae1f
--- /dev/null
+++ b/tests/pos-java16+/java-records/R3.java
@@ -0,0 +1,22 @@
+public record R3(int i, long l, String s) {
+
+    // User-specified accessor
+    public int i() {
+        return i + 1; // evil >:)
+    }
+
+    // Not an accessor - too many parameters
+    public long l(long a1, long a2) {
+        return a1 + a2;
+    }
+
+    // Secondary constructor
+    public R3(String s, int i) {
+        this(i, 42L, s);
+    }
+
+    // Compact constructor
+    public R3 {
+        s = s.intern();
+    }
+}
\ No newline at end of file
diff --git a/tests/pos/java-records/FromScala.scala b/tests/pos/java-records/FromScala.scala
deleted file mode 100644
index d9b9f4d2e129..000000000000
--- a/tests/pos/java-records/FromScala.scala
+++ /dev/null
@@ -1,15 +0,0 @@
-object C:
-  def useR1 =
-    // constructor signature
-    val r = R1(123, "hello")
-
-    // accessors
-    val i: Int = r.i
-    val s: String = r.s
-
-    // methods
-    val iRes: Int = r.getInt()
-    val sRes: String = r.getString()
-
-    // supertype
-    val record: java.lang.Record = r

From 2f91c59fcb54b373a783bd545a72700ee12719b6 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Wed, 10 May 2023 10:35:58 +0200
Subject: [PATCH 549/657] Only transform the body of the quote with
 QuoteTransformer

---
 compiler/src/dotty/tools/dotc/transform/Splicing.scala | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/Splicing.scala b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
index 71bcaa4fcec0..b482e9311c74 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicing.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
@@ -86,8 +86,9 @@ class Splicing extends MacroTransform:
     override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
       assert(level == 0)
       tree match
-        case Apply(Select(_: Quote, nme.apply), _) =>
-          QuoteTransformer().transform(tree)
+        case tree: Quote =>
+          val body1 = QuoteTransformer().transform(tree.body)(using quoteContext)
+          cpy.Quote(tree)(body = body1)
         case tree: DefDef if tree.symbol.is(Inline) =>
           // Quotes in inlined methods are only pickled after they are inlined.
           tree
@@ -95,7 +96,6 @@ class Splicing extends MacroTransform:
           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 */
@@ -108,6 +108,7 @@ class Splicing extends MacroTransform:
     private val typeHoles = mutable.Map.empty[TermRef, Hole]
 
     override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
+      assert(level > 0)
       tree match
         case tree: Splice if level == 1 =>
           val holeIdx = numHoles

From b65ef59d9bdd6a524eaef2bc12a4e33ca1e0375b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Pa=C5=82ka?= <prolativus@gmail.com>
Date: Wed, 10 May 2023 13:41:35 +0200
Subject: [PATCH 550/657] Raise a warning instead of an error for a type
 ascription on a pattern other than a variable or a number literal. This
 partially reverts the changes from
 https://github.com/lampepfl/dotty/pull/16150. This change is motivated by not
 breaking source compatibility for a number of projects in the Open Community
 Build.

---
 .../dotty/tools/dotc/parsing/Parsers.scala    | 10 +--
 docs/_docs/internals/syntax.md                |  5 +-
 docs/_docs/reference/syntax.md                |  5 +-
 .../fatal-warnings}/i10994.scala              |  0
 .../fatal-warnings}/i15893.scala              |  6 +-
 tests/neg/t5702-neg-bad-and-wild.check        | 10 ++-
 tests/pending/run/i15893.scala                |  6 +-
 tests/pos/i10994.scala                        |  2 +
 tests/pos/i15893.scala                        | 61 +++++++++++++++++++
 9 files changed, 83 insertions(+), 22 deletions(-)
 rename tests/{neg => neg-custom-args/fatal-warnings}/i10994.scala (100%)
 rename tests/{neg => neg-custom-args/fatal-warnings}/i15893.scala (89%)
 create mode 100644 tests/pos/i10994.scala
 create mode 100644 tests/pos/i15893.scala

diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 7fecdd2c5eae..170332f7abe8 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -2871,14 +2871,14 @@ object Parsers {
       if (isIdent(nme.raw.BAR)) { in.nextToken(); pattern1(location) :: patternAlts(location) }
       else Nil
 
-    /**  Pattern1     ::= PatVar Ascription
-     *                  | [‘-’] integerLiteral Ascription
-     *                  | [‘-’] floatingPointLiteral Ascription
-     *                  | Pattern2
+    /**  Pattern1     ::= Pattern2 [Ascription]
      */
     def pattern1(location: Location = Location.InPattern): Tree =
       val p = pattern2()
-      if (isVarPattern(p) || p.isInstanceOf[Number]) && in.isColon then
+      if in.isColon then
+        val isVariableOrNumber = isVarPattern(p) || p.isInstanceOf[Number]
+        if !isVariableOrNumber then
+          warning(em"Only variable and number literal patterns can have type ascriptions")
         in.nextToken()
         ascription(p, location)
       else p
diff --git a/docs/_docs/internals/syntax.md b/docs/_docs/internals/syntax.md
index c4e71ad11612..e667a429afed 100644
--- a/docs/_docs/internals/syntax.md
+++ b/docs/_docs/internals/syntax.md
@@ -314,10 +314,7 @@ TypeCaseClauses   ::=  TypeCaseClause { TypeCaseClause }
 TypeCaseClause    ::=  ‘case’ (InfixType | ‘_’) ‘=>’ Type [semi]
 
 Pattern           ::=  Pattern1 { ‘|’ Pattern1 }                                Alternative(pats)
-Pattern1          ::=  PatVar ‘:’ RefinedType                                   Bind(name, Typed(Ident(wildcard), tpe))
-                    | [‘-’] integerLiteral ‘:’ RefinedType                      Typed(pat, tpe)
-                    | [‘-’] floatingPointLiteral ‘:’ RefinedType                Typed(pat, tpe)
-                    |  Pattern2
+Pattern1          ::=  Pattern2 [‘:’ RefinedType]                               Bind(name, Typed(Ident(wildcard), tpe))
 Pattern2          ::=  [id ‘@’] InfixPattern [‘*’]                              Bind(name, pat)
 InfixPattern      ::=  SimplePattern { id [nl] SimplePattern }                  InfixOp(pat, op, pat)
 SimplePattern     ::=  PatVar                                                   Ident(wildcard)
diff --git a/docs/_docs/reference/syntax.md b/docs/_docs/reference/syntax.md
index dd2e7ce118c4..28259d94afb4 100644
--- a/docs/_docs/reference/syntax.md
+++ b/docs/_docs/reference/syntax.md
@@ -312,10 +312,7 @@ TypeCaseClauses   ::=  TypeCaseClause { TypeCaseClause }
 TypeCaseClause    ::=  ‘case’ (InfixType | ‘_’) ‘=>’ Type [semi]
 
 Pattern           ::=  Pattern1 { ‘|’ Pattern1 }
-Pattern1          ::=  PatVar ‘:’ RefinedType
-                    | [‘-’] integerLiteral ‘:’ RefinedType
-                    | [‘-’] floatingPointLiteral ‘:’ RefinedType
-                    |  Pattern2
+Pattern1          ::=  Pattern2 [‘:’ RefinedType]
 Pattern2          ::=  [id ‘@’] InfixPattern [‘*’]
 InfixPattern      ::=  SimplePattern { id [nl] SimplePattern }
 SimplePattern     ::=  PatVar
diff --git a/tests/neg/i10994.scala b/tests/neg-custom-args/fatal-warnings/i10994.scala
similarity index 100%
rename from tests/neg/i10994.scala
rename to tests/neg-custom-args/fatal-warnings/i10994.scala
diff --git a/tests/neg/i15893.scala b/tests/neg-custom-args/fatal-warnings/i15893.scala
similarity index 89%
rename from tests/neg/i15893.scala
rename to tests/neg-custom-args/fatal-warnings/i15893.scala
index 997c51179099..f23e6150106a 100644
--- a/tests/neg/i15893.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15893.scala
@@ -22,7 +22,7 @@ transparent inline def transparentInlineMod2(inline n: NatT):  NatT = inline n m
   case Succ(Zero()) => Succ(Zero())
   case Succ(Succ(predPredN)) => transparentInlineMod2(predPredN)
 
-def dependentlyTypedMod2[N <: NatT](n: N): Mod2[N] = n match // exhaustivity warning; unexpected
+def dependentlyTypedMod2[N <: NatT](n: N): Mod2[N] = n match
   case Zero(): Zero => Zero() // error
   case Succ(Zero()): Succ[Zero] => Succ(Zero()) // error
   case Succ(Succ(predPredN)): Succ[Succ[_]] => dependentlyTypedMod2(predPredN) // error
@@ -57,5 +57,5 @@ inline def transparentInlineFoo(inline n: NatT): NatT = inline transparentInline
   println(transparentInlineMod2(Succ(Succ(Succ(Zero()))))) // prints Succ(Zero()), as expected
   println(transparentInlineFoo(Succ(Succ(Succ(Zero()))))) // prints Zero(), as expected
   println(dependentlyTypedMod2(Succ(Succ(Succ(Zero()))))) // runtime error; unexpected
-//  println(inlineDependentlyTypedMod2(Succ(Succ(Succ(Zero()))))) // doesn't compile; unexpected
-//  println(transparentInlineDependentlyTypedMod2(Succ(Succ(Succ(Zero()))))) // doesn't compile; unexpected
+  println(inlineDependentlyTypedMod2(Succ(Succ(Succ(Zero()))))) // prints Succ(Zero()), as expected
+  println(transparentInlineDependentlyTypedMod2(Succ(Succ(Succ(Zero()))))) // prints Succ(Zero()), as expected
diff --git a/tests/neg/t5702-neg-bad-and-wild.check b/tests/neg/t5702-neg-bad-and-wild.check
index 731195411069..36ac71b2e1e7 100644
--- a/tests/neg/t5702-neg-bad-and-wild.check
+++ b/tests/neg/t5702-neg-bad-and-wild.check
@@ -10,10 +10,10 @@
    |                       pattern expected
    |
    | longer explanation available when compiling with `-explain`
--- [E040] Syntax Error: tests/neg/t5702-neg-bad-and-wild.scala:13:22 ---------------------------------------------------
+-- [E040] Syntax Error: tests/neg/t5702-neg-bad-and-wild.scala:13:23 ---------------------------------------------------
 13 |      case List(1, _*3:) =>  // error // error
-   |                      ^
-   |                      ')' expected, but ':' found
+   |                       ^
+   |                       an identifier expected, but ')' found
 -- [E032] Syntax Error: tests/neg/t5702-neg-bad-and-wild.scala:15:18 ---------------------------------------------------
 15 |      case List(x*, 1) => // error: pattern expected
    |                  ^
@@ -56,6 +56,10 @@
    |                   Recursive value $1$ needs type
    |
    | longer explanation available when compiling with `-explain`
+-- Warning: tests/neg/t5702-neg-bad-and-wild.scala:13:22 ---------------------------------------------------------------
+13 |      case List(1, _*3:) =>  // error // error
+   |                      ^
+   |                      Only variable and number literal patterns can have type ascriptions
 -- Warning: tests/neg/t5702-neg-bad-and-wild.scala:22:20 ---------------------------------------------------------------
 22 |    val K(x @ _*) = k
    |                    ^
diff --git a/tests/pending/run/i15893.scala b/tests/pending/run/i15893.scala
index dedec2138f2a..d9cd2822e971 100644
--- a/tests/pending/run/i15893.scala
+++ b/tests/pending/run/i15893.scala
@@ -24,7 +24,7 @@ transparent inline def transparentInlineMod2(inline n: NatT):  NatT = inline n m
   case Succ(Zero()) => Succ(Zero())
   case Succ(Succ(predPredN)) => transparentInlineMod2(predPredN)
 */
-def dependentlyTypedMod2[N <: NatT](n: N): Mod2[N] = n match // exhaustivity warning; unexpected
+def dependentlyTypedMod2[N <: NatT](n: N): Mod2[N] = n match
   case Zero(): Zero => Zero()
   case Succ(Zero()): Succ[Zero] => Succ(Zero())
   case Succ(Succ(predPredN)): Succ[Succ[_]] => dependentlyTypedMod2(predPredN)
@@ -61,5 +61,5 @@ inline def transparentInlineFoo(inline n: NatT): NatT = inline transparentInline
   println(transparentInlineFoo(Succ(Succ(Succ(Zero()))))) // prints Zero(), as expected
 */
   println(dependentlyTypedMod2(Succ(Succ(Succ(Zero()))))) // runtime error; unexpected
-//  println(inlineDependentlyTypedMod2(Succ(Succ(Succ(Zero()))))) // doesn't compile; unexpected
-//  println(transparentInlineDependentlyTypedMod2(Succ(Succ(Succ(Zero()))))) // doesn't compile; unexpected
+//  println(inlineDependentlyTypedMod2(Succ(Succ(Succ(Zero()))))) // prints Succ(Zero()), as expected
+//  println(transparentInlineDependentlyTypedMod2(Succ(Succ(Succ(Zero()))))) // prints Succ(Zero()), as expected
diff --git a/tests/pos/i10994.scala b/tests/pos/i10994.scala
new file mode 100644
index 000000000000..99ae647466b1
--- /dev/null
+++ b/tests/pos/i10994.scala
@@ -0,0 +1,2 @@
+def foo = true match
+  case (b: Boolean): Boolean => ()
diff --git a/tests/pos/i15893.scala b/tests/pos/i15893.scala
new file mode 100644
index 000000000000..af6e7ae38ad2
--- /dev/null
+++ b/tests/pos/i15893.scala
@@ -0,0 +1,61 @@
+sealed trait NatT
+case class Zero() extends NatT
+case class Succ[+N <: NatT](n: N) extends NatT
+
+type Mod2[N <: NatT] <: NatT = N match
+  case Zero => Zero
+  case Succ[Zero] => Succ[Zero]
+  case Succ[Succ[predPredN]] => Mod2[predPredN]
+
+def mod2(n: NatT):  NatT = n match
+  case Zero() => Zero()
+  case Succ(Zero()) => Succ(Zero())
+  case Succ(Succ(predPredN)) => mod2(predPredN)
+
+inline def inlineMod2(inline n: NatT):  NatT = inline n match
+  case Zero() => Zero()
+  case Succ(Zero()) => Succ(Zero())
+  case Succ(Succ(predPredN)) => inlineMod2(predPredN)
+
+transparent inline def transparentInlineMod2(inline n: NatT):  NatT = inline n match
+  case Zero() => Zero()
+  case Succ(Zero()) => Succ(Zero())
+  case Succ(Succ(predPredN)) => transparentInlineMod2(predPredN)
+
+def dependentlyTypedMod2[N <: NatT](n: N): Mod2[N] = n match
+  case Zero(): Zero => Zero() // warning
+  case Succ(Zero()): Succ[Zero] => Succ(Zero()) // warning
+  case Succ(Succ(predPredN)): Succ[Succ[_]] => dependentlyTypedMod2(predPredN) // warning
+
+inline def inlineDependentlyTypedMod2[N <: NatT](inline n: N): Mod2[N] = inline n match
+  case Zero(): Zero => Zero() // warning
+  case Succ(Zero()): Succ[Zero] => Succ(Zero()) // warning
+  case Succ(Succ(predPredN)): Succ[Succ[_]] => inlineDependentlyTypedMod2(predPredN) // warning
+
+transparent inline def transparentInlineDependentlyTypedMod2[N <: NatT](inline n: N): Mod2[N] = inline n match
+  case Zero(): Zero => Zero() // warning
+  case Succ(Zero()): Succ[Zero] => Succ(Zero()) // warning
+  case Succ(Succ(predPredN)): Succ[Succ[_]] => transparentInlineDependentlyTypedMod2(predPredN) // warning
+
+def foo(n: NatT): NatT = mod2(n) match
+  case Succ(Zero()) => Zero()
+  case _ => n
+
+inline def inlineFoo(inline n: NatT): NatT = inline inlineMod2(n) match
+  case Succ(Zero()) => Zero()
+  case _ => n
+
+inline def transparentInlineFoo(inline n: NatT): NatT = inline transparentInlineMod2(n) match
+  case Succ(Zero()) => Zero()
+  case _ => n
+
+@main def main(): Unit =
+  println(mod2(Succ(Succ(Succ(Zero()))))) // prints Succ(Zero()), as expected
+  println(foo(Succ(Succ(Succ(Zero()))))) // prints Zero(), as expected
+  println(inlineMod2(Succ(Succ(Succ(Zero()))))) // prints Succ(Zero()), as expected
+  println(inlineFoo(Succ(Succ(Succ(Zero()))))) // prints Succ(Succ(Succ(Zero()))); unexpected
+  println(transparentInlineMod2(Succ(Succ(Succ(Zero()))))) // prints Succ(Zero()), as expected
+  println(transparentInlineFoo(Succ(Succ(Succ(Zero()))))) // prints Zero(), as expected
+  println(dependentlyTypedMod2(Succ(Succ(Succ(Zero()))))) // runtime error; unexpected
+  println(inlineDependentlyTypedMod2(Succ(Succ(Succ(Zero()))))) // prints Succ(Zero()), as expected
+  println(transparentInlineDependentlyTypedMod2(Succ(Succ(Succ(Zero()))))) // prints Succ(Zero()), as expected

From 5bafff7cc96f1f31f6e77620ca509dfa55d816b4 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Wed, 10 May 2023 16:39:12 +0100
Subject: [PATCH 551/657] Normalize match type usage during implicit lookup

---
 .../dotty/tools/dotc/core/TypeComparer.scala  |  2 +-
 .../dotty/tools/dotc/core/TypeErrors.scala    |  3 +++
 .../dotty/tools/dotc/typer/Implicits.scala    |  7 ++++++
 tests/pos/i17395.scala                        | 25 +++++++++++++++++++
 4 files changed, 36 insertions(+), 1 deletion(-)
 create mode 100644 tests/pos/i17395.scala

diff --git a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
index 465978d329e6..ee8b8c3cdfcc 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
@@ -3180,7 +3180,7 @@ class TrackingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
             tp
       case Nil =>
         val casesText = MatchTypeTrace.noMatchesText(scrut, cases)
-        throw TypeError(em"Match type reduction $casesText")
+        throw MatchTypeReductionError(em"Match type reduction $casesText")
 
     inFrozenConstraint {
       // Empty types break the basic assumption that if a scrutinee and a
diff --git a/compiler/src/dotty/tools/dotc/core/TypeErrors.scala b/compiler/src/dotty/tools/dotc/core/TypeErrors.scala
index 24a207da6836..f59bd08da779 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeErrors.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeErrors.scala
@@ -46,6 +46,9 @@ object TypeError:
     def toMessage(using Context) = msg
 end TypeError
 
+class MatchTypeReductionError(msg: Message)(using Context) extends TypeError:
+  def toMessage(using Context) = msg
+
 class MalformedType(pre: Type, denot: Denotation, absMembers: Set[Name])(using Context) 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(", ")}"
 
diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
index a9631ad45e28..b5a20b6838bf 100644
--- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -634,6 +634,13 @@ trait ImplicitRunInfo:
             case t: TypeLambda =>
               for p <- t.paramRefs do partSeen += p
               traverseChildren(t)
+            case t: MatchType =>
+              traverseChildren(t)
+              traverse(try t.normalized catch case _: MatchTypeReductionError => t)
+            case MatchType.InDisguise(mt)
+                if !t.isInstanceOf[LazyRef] // skip recursive applications (eg. Tuple.Map)
+            =>
+              traverse(mt)
             case t =>
               traverseChildren(t)
 
diff --git a/tests/pos/i17395.scala b/tests/pos/i17395.scala
new file mode 100644
index 000000000000..87c0a45a9ff5
--- /dev/null
+++ b/tests/pos/i17395.scala
@@ -0,0 +1,25 @@
+trait TC[T]
+
+object TC {
+  def optionTCForPart[T](implicit tc: TC[ExtractPart[T]]): TC[Option[ExtractPart[T]]] = new TC[Option[ExtractPart[T]]] {}
+}
+
+type ExtractPart[T] = T match {
+  case PartField[t] => t
+}
+type PartField[T] = Any { type Part = T }
+
+class ValuePartHolder {
+  type Part = Value
+}
+
+class Value
+object Value {
+  implicit val tcValue: TC[Value] = new {}
+}
+
+@main def main(): Unit = {
+//  import Value.tcValue // explicit import works around the issue, but shouldn't be necessary
+  val tc = TC.optionTCForPart[ValuePartHolder]
+  println(tc)
+}

From 8eb125da4b09cc3536423f1d0684dca153c8552b Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Thu, 4 May 2023 18:15:21 +0200
Subject: [PATCH 552/657] Do postchecking inside out.

Previously we sometimes got a "non=private definition with nonempty capturing type needs
explicit type ascription error" that hid a more important error such as a leaking universal
capture set.
---
 .../dotty/tools/dotc/cc/CheckCaptures.scala   | 112 +++++++++---------
 1 file changed, 59 insertions(+), 53 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index 72a166dbbecc..2866f4667b37 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -986,61 +986,67 @@ class CheckCaptures extends Recheck, SymTransformer:
      *   - 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)
+      val checker = new TreeTraverser:
+        def traverse(tree: Tree)(using Context): Unit =
+          traverseChildren(tree)
+          check(tree)
+        def check(tree: Tree) = tree match
+          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 _ =>
-            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 _ =>
-      }
+            args.foreach(healTypeParam(_))
+          case _ =>
+        end check
+      end checker
+      checker.traverse(unit)
       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

From 05bce382e9239c46ba6b2507f95406aed21d5e27 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Fri, 5 May 2023 12:28:47 +0200
Subject: [PATCH 553/657] Implement sealed type variables

Abolish restriction that box/unbox cannot be done with `cap`.

Instead, do a deep check for `cap`

 - in type arguments for `sealed` type variables
 - in the types of mutable vars
 - in the type of `try` under the `saferExceptions` language import

The caps.unsafe.{unsafeBox, unsafeUnbox, unsafeBoxFunArg} methods are not longer
needed and are deprecated. Instead there is an annotation annotation.unchecked.uncheckedCaptures that
can be added to a mutable variable to turn off checking its type.

These changes in behavior are introduced in 3.3. Older source versions
still support the old behavior (which corresponds to the paper).

So to run examples in the paper as described there, they need a `-source 3.2` or a
language import.

    import language.`3.2`.
---
 .../src/dotty/tools/dotc/cc/CaptureOps.scala  |  4 +
 .../dotty/tools/dotc/cc/CheckCaptures.scala   | 42 +++++++---
 compiler/src/dotty/tools/dotc/cc/Setup.scala  | 20 ++++-
 .../tools/dotc/config/SourceVersion.scala     |  2 +
 .../dotty/tools/dotc/core/Definitions.scala   |  2 +
 .../src/dotty/tools/dotc/core/Types.scala     | 17 +++-
 .../dotty/tools/dotc/parsing/Parsers.scala    | 33 ++++----
 .../dotty/tools/dotc/transform/Recheck.scala  | 13 ++-
 .../src/dotty/tools/dotc/typer/Checking.scala |  7 +-
 .../src/dotty/tools/dotc/typer/Typer.scala    |  2 +-
 .../unchecked/uncheckedCapabilityLeaks.scala  | 12 +++
 library/src/scala/caps.scala                  |  7 ++
 .../captures/box-adapt-cases.scala            |  2 +-
 .../neg-custom-args/captures/capt-test.scala  |  6 +-
 tests/neg-custom-args/captures/capt1.check    |  9 +--
 tests/neg-custom-args/captures/capt1.scala    |  2 +-
 tests/neg-custom-args/captures/ctest.scala    |  4 +-
 tests/neg-custom-args/captures/filevar.scala  |  4 +-
 .../captures/heal-tparam-cs.scala             |  4 +-
 tests/neg-custom-args/captures/i15049.scala   |  4 +-
 tests/neg-custom-args/captures/i15772.check   |  8 +-
 tests/neg-custom-args/captures/i15923.scala   |  8 +-
 .../captures/lazylists-exceptions.check       |  5 +-
 tests/neg-custom-args/captures/real-try.check | 31 +++++---
 tests/neg-custom-args/captures/real-try.scala |  6 +-
 .../captures/sealed-leaks.scala               | 20 +++++
 .../captures/stack-alloc.scala                |  2 +-
 tests/neg-custom-args/captures/try.check      | 35 ++++----
 tests/neg-custom-args/captures/try.scala      |  8 +-
 tests/neg-custom-args/captures/try3.scala     |  6 +-
 tests/neg-custom-args/captures/unbox.scala    |  1 +
 .../captures/usingLogFile.check               | 79 +++++++++++--------
 .../captures/usingLogFile.scala               | 25 +++---
 tests/neg-custom-args/captures/vars.check     | 42 +++++-----
 tests/neg-custom-args/captures/vars.scala     | 12 +--
 tests/pos-custom-args/captures/capt-env.scala |  8 ++
 .../captures/i15749.scala                     |  2 +-
 .../captures/i15749a.scala                    |  8 +-
 .../captures/i15923-cases.scala               |  2 +-
 .../captures/i15925.scala                     |  6 +-
 .../captures/unsafe-unbox.scala               |  7 +-
 tests/pos-custom-args/captures/vars1.scala    | 23 ++++--
 tests/pos-with-compiler-cc/dotc/Run.scala     |  5 +-
 .../dotc/core/Scopes.scala                    |  7 +-
 .../dotc/core/TypeComparer.scala              | 11 +--
 .../dotc/core/tasty/TreeUnpickler.scala       | 10 +--
 .../dotc/typer/Namer.scala                    |  4 +-
 .../dotc/typer/Typer.scala                    | 15 ++--
 48 files changed, 371 insertions(+), 221 deletions(-)
 create mode 100644 library/src/scala/annotation/unchecked/uncheckedCapabilityLeaks.scala
 create mode 100644 tests/neg-custom-args/captures/sealed-leaks.scala
 create mode 100644 tests/pos-custom-args/captures/capt-env.scala
 rename tests/{neg-custom-args => pos-custom-args}/captures/i15749.scala (73%)
 rename tests/{neg-custom-args => pos-custom-args}/captures/i15749a.scala (62%)
 rename tests/{neg-custom-args => pos-custom-args}/captures/i15923-cases.scala (89%)
 rename tests/{neg-custom-args => pos-custom-args}/captures/i15925.scala (69%)

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
index decd428f5365..3ba26c92cab5 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureOps.scala
@@ -6,6 +6,7 @@ import core.*
 import Types.*, Symbols.*, Contexts.*, Annotations.*, Flags.*
 import ast.{tpd, untpd}
 import Decorators.*, NameOps.*
+import config.SourceVersion
 import config.Printers.capt
 import util.Property.Key
 import tpd.*
@@ -19,6 +20,9 @@ private[cc] def retainedElems(tree: Tree)(using Context): List[Tree] = tree matc
   case Apply(_, Typed(SeqLiteral(elems, _), _) :: Nil) => elems
   case _ => Nil
 
+def allowUniversalInBoxed(using Context) =
+  Feature.sourceVersion.isAtLeast(SourceVersion.`3.3`)
+
 /** An exception thrown if a @retains argument is not syntactically a CaptureRef */
 class IllegalCaptureRef(tpe: Type) extends Exception
 
diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index 2866f4667b37..9e0263d63b38 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -128,6 +128,20 @@ object CheckCaptures:
       if remaining.accountsFor(firstRef) then
         report.warning(em"redundant capture: $remaining already accounts for $firstRef", ann.srcPos)
 
+  def disallowRootCapabilitiesIn(tp: Type, what: String, have: String, addendum: String, pos: SrcPos)(using Context) =
+    val check = new TypeTraverser:
+      def traverse(t: Type) =
+        if variance >= 0 then
+        t.captureSet.disallowRootCapability: () =>
+          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""",
+            pos)
+        traverseChildren(t)
+    check.traverse(tp)
+
 class CheckCaptures extends Recheck, SymTransformer:
   thisPhase =>
 
@@ -525,6 +539,15 @@ class CheckCaptures extends Recheck, SymTransformer:
         case _ =>
       super.recheckTyped(tree)
 
+    override def recheckTry(tree: Try, pt: Type)(using Context): Type =
+      val tp = super.recheckTry(tree, pt)
+      if allowUniversalInBoxed && Feature.enabled(Feature.saferExceptions) then
+        disallowRootCapabilitiesIn(tp,
+          "Result of `try`", "have type",
+          "This is often caused by a locally generated exception capability leaking as part of its result.",
+          tree.srcPos)
+      tp
+
     /* 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 =
@@ -588,7 +611,7 @@ class CheckCaptures extends Recheck, SymTransformer:
           }
           checkNotUniversal(parent)
         case _ =>
-      checkNotUniversal(typeToCheck)
+      if !allowUniversalInBoxed then checkNotUniversal(typeToCheck)
       super.recheckFinish(tpe, tree, pt)
 
     /** Massage `actual` and `expected` types using the methods below before checking conformance */
@@ -771,7 +794,7 @@ class CheckCaptures extends Recheck, SymTransformer:
             val criticalSet =          // the set which is not allowed to have `cap`
               if covariant then cs1    // can't box with `cap`
               else expected.captureSet // can't unbox with `cap`
-            if criticalSet.isUniversal && expected.isValueType then
+            if criticalSet.isUniversal && expected.isValueType && !allowUniversalInBoxed 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`.
@@ -779,13 +802,14 @@ class CheckCaptures extends Recheck, SymTransformer:
                 println(i"cannot box/unbox $actual vs $expected")
               actual
             else
-              // Disallow future addition of `cap` to `criticalSet`.
-              criticalSet.disallowRootCapability { () =>
-                report.error(
-                  em"""$actual cannot be box-converted to $expected
-                      |since one of their capture sets contains the root capability `cap`""",
-                pos)
-              }
+              if !allowUniversalInBoxed then
+                // Disallow future addition of `cap` to `criticalSet`.
+                criticalSet.disallowRootCapability { () =>
+                  report.error(
+                    em"""$actual cannot be box-converted to $expected
+                        |since one of their capture sets contains the root capability `cap`""",
+                  pos)
+                }
               if !insertBox then  // unboxing
                 markFree(criticalSet, pos)
               adaptedType(!boxed)
diff --git a/compiler/src/dotty/tools/dotc/cc/Setup.scala b/compiler/src/dotty/tools/dotc/cc/Setup.scala
index fc16422e1373..09f9695abfe1 100644
--- a/compiler/src/dotty/tools/dotc/cc/Setup.scala
+++ b/compiler/src/dotty/tools/dotc/cc/Setup.scala
@@ -411,11 +411,28 @@ extends tpd.TreeTraverser:
           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
         )
+        if allowUniversalInBoxed && tree.symbol.is(Mutable)
+            && !tree.symbol.hasAnnotation(defn.UncheckedCapturesAnnot)
+        then
+          CheckCaptures.disallowRootCapabilitiesIn(tpt.knownType,
+            i"Mutable variable ${tree.symbol.name}", "have type",
+            "This restriction serves to prevent local capabilities from escaping the scope where they are defined.",
+            tree.srcPos)
         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
+
+        if allowUniversalInBoxed then
+          val polyType = fn.tpe.widen.asInstanceOf[TypeLambda]
+          for case (arg: TypeTree, pinfo, pname) <- args.lazyZip(polyType.paramInfos).lazyZip((polyType.paramNames)) do
+            if pinfo.bounds.hi.hasAnnotation(defn.Caps_SealedAnnot) then
+              def where = if fn.symbol.exists then i" in the body of ${fn.symbol}" else ""
+              CheckCaptures.disallowRootCapabilitiesIn(arg.knownType,
+                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)
       case _ =>
         traverseChildren(tree)
     tree match
@@ -494,11 +511,10 @@ extends tpd.TreeTraverser:
 
   def apply(tree: Tree)(using Context): Unit =
     traverse(tree)(using ctx.withProperty(Setup.IsDuringSetupKey, Some(())))
-end Setup
 
 object Setup:
   val IsDuringSetupKey = new Property.Key[Unit]
 
   def isDuringSetup(using Context): Boolean =
     ctx.property(IsDuringSetupKey).isDefined
-
+end Setup
\ No newline at end of file
diff --git a/compiler/src/dotty/tools/dotc/config/SourceVersion.scala b/compiler/src/dotty/tools/dotc/config/SourceVersion.scala
index 4b9b1b247856..b8fa7994ce0c 100644
--- a/compiler/src/dotty/tools/dotc/config/SourceVersion.scala
+++ b/compiler/src/dotty/tools/dotc/config/SourceVersion.scala
@@ -18,6 +18,8 @@ enum SourceVersion:
 
   def isAtLeast(v: SourceVersion) = stable.ordinal >= v.ordinal
 
+  def isAtMost(v: SourceVersion) = stable.ordinal <= v.ordinal
+
 object SourceVersion extends Property.Key[SourceVersion]:
   def defaultSourceVersion = `3.3`
 
diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
index 82b1a6354321..da2ec78b5179 100644
--- a/compiler/src/dotty/tools/dotc/core/Definitions.scala
+++ b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -973,6 +973,7 @@ class Definitions {
     @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_SealedAnnot: ClassSymbol = requiredClass("scala.caps.Sealed")
 
   // Annotation base classes
   @tu lazy val AnnotationClass: ClassSymbol = requiredClass("scala.annotation.Annotation")
@@ -1021,6 +1022,7 @@ class Definitions {
   @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 VolatileAnnot: ClassSymbol = requiredClass("scala.volatile")
   @tu lazy val WithPureFunsAnnot: ClassSymbol = requiredClass("scala.annotation.internal.WithPureFuns")
   @tu lazy val BeanGetterMetaAnnot: ClassSymbol = requiredClass("scala.annotation.meta.beanGetter")
diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index 0942cc5ca981..2e3ab1a5ded8 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -3960,10 +3960,15 @@ object Types {
 
     protected def toPInfo(tp: Type)(using Context): PInfo
 
+    /** If `tparam` is a sealed type parameter symbol of a polymorphic method, add
+     *  a @caps.Sealed annotation to the upperbound in `tp`.
+     */
+    protected def addSealed(tparam: ParamInfo, tp: Type)(using Context): Type = tp
+
     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 => params.map(param => toPInfo(addSealed(param, tl.integrate(params, param.paramInfo)))),
         tl => tl.integrate(params, resultType))
   }
 
@@ -4285,6 +4290,16 @@ object Types {
         resultTypeExp: PolyType => Type)(using Context): PolyType =
       unique(new PolyType(paramNames)(paramInfosExp, resultTypeExp))
 
+    override protected def addSealed(tparam: ParamInfo, tp: Type)(using Context): Type =
+      tparam match
+        case tparam: Symbol if tparam.is(Sealed) =>
+          tp match
+            case tp @ TypeBounds(lo, hi) =>
+              tp.derivedTypeBounds(lo,
+                AnnotatedType(hi, Annotation(defn.Caps_SealedAnnot, tparam.span)))
+            case _ => tp
+        case _ => tp
+
     def unapply(tl: PolyType): Some[(List[LambdaParam], Type)] =
       Some((tl.typeParams, tl.resType))
   }
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 2f51af8549ae..8d13bdeed68f 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -3152,7 +3152,9 @@ object Parsers {
      *                         id [HkTypeParamClause] TypeParamBounds
      *
      *  DefTypeParamClause::=  ‘[’ DefTypeParam {‘,’ DefTypeParam} ‘]’
-     *  DefTypeParam      ::=  {Annotation} id [HkTypeParamClause] TypeParamBounds
+     *  DefTypeParam      ::=  {Annotation}
+     *                         [`sealed`]                                    -- under captureChecking
+     *                         id [HkTypeParamClause] TypeParamBounds
      *
      *  TypTypeParamClause::=  ‘[’ TypTypeParam {‘,’ TypTypeParam} ‘]’
      *  TypTypeParam      ::=  {Annotation} id [HkTypePamClause] TypeBounds
@@ -3162,24 +3164,25 @@ object Parsers {
      */
     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 checkVarianceOK(): Boolean =
+        val ok = ownerKind != ParamOwner.Def && ownerKind != ParamOwner.TypeParam
+        if !ok then syntaxError(em"no `+/-` variance annotation allowed here")
+        in.nextToken()
+        ok
 
       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)
+        var mods = annotsAsMods() | Param
+        if ownerKind == ParamOwner.Class then mods |= PrivateLocal
+        if Feature.ccEnabled && in.token == SEALED then
+          if ownerKind == ParamOwner.Def then mods |= Sealed
+          else syntaxError(em"`sealed` modifier only allowed for method type parameters")
+          in.nextToken()
+        if isIdent(nme.raw.PLUS) && checkVarianceOK() then
+          mods |= Covariant
+        else if isIdent(nme.raw.MINUS) && checkVarianceOK() then
+          mods |= Contravariant
         atSpan(start, nameStart) {
           val name =
             if (isAbstractOwner && in.token == USCORE) {
diff --git a/compiler/src/dotty/tools/dotc/transform/Recheck.scala b/compiler/src/dotty/tools/dotc/transform/Recheck.scala
index c524bbb7702f..527c73d02250 100644
--- a/compiler/src/dotty/tools/dotc/transform/Recheck.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Recheck.scala
@@ -4,7 +4,7 @@ package transform
 
 import core.*
 import Symbols.*, Contexts.*, Types.*, ContextOps.*, Decorators.*, SymDenotations.*
-import Flags.*, SymUtils.*, NameKinds.*, Denotations.Denotation
+import Flags.*, SymUtils.*, NameKinds.*, Denotations.{Denotation, SingleDenotation}
 import ast.*
 import Names.Name
 import Phases.Phase
@@ -22,7 +22,7 @@ import StdNames.nme
 import reporting.trace
 import annotation.constructorOnly
 import cc.CaptureSet.IdempotentCaptRefMap
-import dotty.tools.dotc.core.Denotations.SingleDenotation
+import annotation.tailrec
 
 object Recheck:
   import tpd.*
@@ -406,7 +406,14 @@ abstract class Recheck extends Phase, SymTransformer:
       NoType
 
     def recheckStats(stats: List[Tree])(using Context): Unit =
-      stats.foreach(recheck(_))
+      @tailrec def traverse(stats: List[Tree])(using Context): Unit = stats match
+        case (imp: Import) :: rest =>
+          traverse(rest)(using ctx.importContext(imp, imp.symbol))
+        case stat :: rest =>
+          recheck(stat)
+          traverse(rest)
+        case _ =>
+      traverse(stats)
 
     def recheckDef(tree: ValOrDefDef, sym: Symbol)(using Context): Unit =
       inContext(ctx.localContext(tree, sym)) {
diff --git a/compiler/src/dotty/tools/dotc/typer/Checking.scala b/compiler/src/dotty/tools/dotc/typer/Checking.scala
index 436721a6774b..b2ab5332c3b2 100644
--- a/compiler/src/dotty/tools/dotc/typer/Checking.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Checking.scala
@@ -506,7 +506,12 @@ object Checking {
         // 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}")
+      val illegal = sym.flags & ClassOnlyFlags
+      if sym.is(TypeParam) && illegal == Sealed && Feature.ccEnabled && cc.allowUniversalInBoxed then
+        if !sym.owner.is(Method) then
+          fail(em"only method type parameters can be sealed")
+      else
+        fail(em"only classes can be ${illegal.flagsString}")
     if (sym.is(AbsOverride) && !sym.owner.is(Trait))
       fail(AbstractOverrideOnlyInTraits(sym))
     if sym.is(Trait) then
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 9f13071ae4b7..cfc9e968ef41 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -608,7 +608,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       ownType match
         case ownType: TermRef if ownType.symbol.is(ConstructorProxy) =>
           findRef(name, pt, EmptyFlags, ConstructorProxy, tree.srcPos) match
-            case shadowed: TermRef =>
+            case shadowed: TermRef if !shadowed.symbol.maybeOwner.isEmptyPackage =>
               pt match
                 case pt: FunOrPolyProto =>
                   def err(shadowedIsApply: Boolean) =
diff --git a/library/src/scala/annotation/unchecked/uncheckedCapabilityLeaks.scala b/library/src/scala/annotation/unchecked/uncheckedCapabilityLeaks.scala
new file mode 100644
index 000000000000..477ac6d742f7
--- /dev/null
+++ b/library/src/scala/annotation/unchecked/uncheckedCapabilityLeaks.scala
@@ -0,0 +1,12 @@
+package scala.annotation
+package unchecked
+
+/** An annotation for mutable variables that are allowed to capture
+ *  the root capability `cap`. Allowing this is not capture safe since
+ *  it can cause leakage of capabilities from local scopes by assigning
+ *  values retaining such capabilties to the annotated variable in
+ *  an outer scope.
+ */
+class uncheckedCaptures extends StaticAnnotation
+
+
diff --git a/library/src/scala/caps.scala b/library/src/scala/caps.scala
index 6b7b085bbc06..4981353d61be 100644
--- a/library/src/scala/caps.scala
+++ b/library/src/scala/caps.scala
@@ -27,8 +27,15 @@ import annotation.experimental
      *  avoids the error that would be raised when unboxing `*`.
      */
     extension [T, U](f: T => U) def unsafeBoxFunArg: T => U = f
+
   end unsafe
 
+  /** An annotation that expresses the sealed modifier on a type parameter
+   *  Should not be directly referred to in source
+   */
+  @deprecated("The Sealed annotation should not be directly used in source code.\nUse the `sealed` modifier on type parameters instead.")
+  class Sealed extends annotation.Annotation
+
   /** Mixing in this trait forces a trait or class to be pure, i.e.
    *  have no capabilities retained in its self type.
    */
diff --git a/tests/neg-custom-args/captures/box-adapt-cases.scala b/tests/neg-custom-args/captures/box-adapt-cases.scala
index 351fab2bd8a5..7010444eecb5 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
+  x(cap => cap.use())  // was error, now OK
 }
 
 def test2(io: Cap^{cap}): Unit = {
diff --git a/tests/neg-custom-args/captures/capt-test.scala b/tests/neg-custom-args/captures/capt-test.scala
index 13368aeea190..f14951f410c4 100644
--- a/tests/neg-custom-args/captures/capt-test.scala
+++ b/tests/neg-custom-args/captures/capt-test.scala
@@ -14,14 +14,14 @@ def raise[E <: Exception](e: E): Nothing throws E = throw e
 def foo(x: Boolean): Int throws Fail =
   if x then 1 else raise(Fail())
 
-def handle[E <: Exception, R <: Top](op: (CanThrow[E]) => R)(handler: E => R): R =
+def handle[E <: Exception, sealed R <: Top](op: (CanThrow[E]) => R)(handler: E => R): R =
   val x: CanThrow[E] = ???
   try op(x)
   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 f51d4631782d..85d3b2a7ddcb 100644
--- a/tests/neg-custom-args/captures/capt1.check
+++ b/tests/neg-custom-args/captures/capt1.check
@@ -40,14 +40,7 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/capt1.scala:32:24 ----------------------------------------
 32 |  val z2 = h[() -> Cap](() => x) // error
    |                        ^^^^^^^
-   |                        Found:    () ->{x} Cap
+   |                        Found:    () ->{x} box C^
    |                        Required: () -> box C^
    |
    | longer explanation available when compiling with `-explain`
--- [E007] Type Mismatch Error: tests/neg-custom-args/captures/capt1.scala:33:5 -----------------------------------------
-33 |    (() => C())  // error
-   |     ^^^^^^^^^
-   |     Found:    () ->? Cap
-   |     Required: () -> box C^
-   |
-   | longer explanation available when compiling with `-explain`
diff --git a/tests/neg-custom-args/captures/capt1.scala b/tests/neg-custom-args/captures/capt1.scala
index 69b4c9984494..651184e8d2c9 100644
--- a/tests/neg-custom-args/captures/capt1.scala
+++ b/tests/neg-custom-args/captures/capt1.scala
@@ -30,7 +30,7 @@ def foo() =
   val x: C @retains(caps.cap) = ???
   def h[X](a: X)(b: X) = a
   val z2 = h[() -> Cap](() => x) // error
-    (() => C())  // error
+    (() => C())
   val z3 = h[(() -> Cap) @retains(x)](() => x)(() => C())  // ok
   val z4 = h[(() -> Cap) @retains(x)](() => x)(() => C())  // what was inferred for z3
 
diff --git a/tests/neg-custom-args/captures/ctest.scala b/tests/neg-custom-args/captures/ctest.scala
index 37d6ad034936..ad10b43a7773 100644
--- a/tests/neg-custom-args/captures/ctest.scala
+++ b/tests/neg-custom-args/captures/ctest.scala
@@ -2,5 +2,5 @@ class CC
 type Cap = CC^
 
 def test(cap1: Cap, cap2: Cap) =
-  var b: List[String => String] = Nil // was error, now OK
-  val bc = b.head // error
+  var b: List[String => String] = Nil // error
+  val bc = b.head // was error, now OK
diff --git a/tests/neg-custom-args/captures/filevar.scala b/tests/neg-custom-args/captures/filevar.scala
index 474ba36b0e79..830563f51de3 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
-  def log = file.write("log")  // error
+  var file: File^ = uninitialized  // error
+  def log = file.write("log")
 
 def withFile[T](op: (f: File^) => T): T =
   op(new File)
diff --git a/tests/neg-custom-args/captures/heal-tparam-cs.scala b/tests/neg-custom-args/captures/heal-tparam-cs.scala
index 173de2b1cbb5..58d12f8b6ce5 100644
--- a/tests/neg-custom-args/captures/heal-tparam-cs.scala
+++ b/tests/neg-custom-args/captures/heal-tparam-cs.scala
@@ -2,7 +2,7 @@ import language.experimental.captureChecking
 
 trait Cap { def use(): Unit }
 
-def localCap[T](op: (cap: Cap^{cap}) => T): T = ???
+def localCap[sealed T](op: (cap: Cap^{cap}) => T): T = ???
 
 def main(io: Cap^{cap}, net: Cap^{cap}): Unit = {
   val test1 = localCap { cap => // error
@@ -24,7 +24,7 @@ def main(io: Cap^{cap}, net: Cap^{cap}): Unit = {
       (cap1: Cap^{io}) => () => { cap1.use() }
     }
 
-  def localCap2[T](op: (cap: Cap^{io}) => T): T = ???
+  def localCap2[sealed T](op: (cap: Cap^{io}) => T): T = ???
 
   val test5: () ->{io} Unit =
     localCap2 { cap =>  // ok
diff --git a/tests/neg-custom-args/captures/i15049.scala b/tests/neg-custom-args/captures/i15049.scala
index bc65db2147f8..d978e0e1ad0f 100644
--- a/tests/neg-custom-args/captures/i15049.scala
+++ b/tests/neg-custom-args/captures/i15049.scala
@@ -2,9 +2,9 @@ class Session:
   def request = "Response"
 class Foo:
   private val session: Session^{cap} = new Session
-  def withSession[T](f: (Session^{cap}) => T): T = f(session)
+  def withSession[sealed T](f: (Session^{cap}) => T): T = f(session)
 
-def Test =
+def Test: Unit =
   val f = new Foo
   f.withSession(s => s).request // error
   f.withSession[Session^](t => t) // error
diff --git a/tests/neg-custom-args/captures/i15772.check b/tests/neg-custom-args/captures/i15772.check
index e77d4022451d..949f7ca48588 100644
--- a/tests/neg-custom-args/captures/i15772.check
+++ b/tests/neg-custom-args/captures/i15772.check
@@ -12,11 +12,11 @@
    |                               Required: Observe[C^]
    |
    | longer explanation available when compiling with `-explain`
--- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i15772.scala:33:34 ---------------------------------------
+-- [E007] Type Mismatch Error: tests/neg-custom-args/captures/i15772.scala:33:33 ---------------------------------------
 33 |  val boxed2 : Observe[C]^ = box2(c) // error
-   |                                  ^
-   |                                  Found:    C^
-   |                                  Required: box C{val arg: C^?}^
+   |                             ^^^^^^^
+   |                             Found:    (C{val arg: C^}^ => Unit) ->? Unit
+   |                             Required: (C => Unit) => Unit
    |
    | 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/i15923.scala b/tests/neg-custom-args/captures/i15923.scala
index 3ce9d6121396..3994b34f5928 100644
--- a/tests/neg-custom-args/captures/i15923.scala
+++ b/tests/neg-custom-args/captures/i15923.scala
@@ -3,12 +3,12 @@ type Id[X] = [T] -> (op: X => T) -> T
 def mkId[X](x: X): Id[X] = [T] => (op: X => T) => op(x)
 
 def bar() = {
-  def withCap[X](op: (Cap^) => X): X = {
+  def withCap[sealed X](op: (Cap^) => X): X = {
     val cap: Cap^ = new Cap { def use() = { println("cap is used"); 0 } }
     val result = op(cap)
     result
   }
 
-  val leak = withCap(cap => mkId(cap))
-  leak { cap => cap.use() }   // error
-}
+  val leak = withCap(cap => mkId(cap))  // error
+  leak { cap => cap.use() }
+}
\ No newline at end of file
diff --git a/tests/neg-custom-args/captures/lazylists-exceptions.check b/tests/neg-custom-args/captures/lazylists-exceptions.check
index 03278f25e8dc..f58ed265d3be 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.
+   |  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/real-try.check b/tests/neg-custom-args/captures/real-try.check
index 0b4da5af27b5..c8df3777bcfa 100644
--- a/tests/neg-custom-args/captures/real-try.check
+++ b/tests/neg-custom-args/captures/real-try.check
@@ -1,8 +1,15 @@
+-- [E129] Potential Issue Warning: tests/neg-custom-args/captures/real-try.scala:30:4 ----------------------------------
+30 |  b.x
+   |  ^^^
+   |  A pure expression does nothing in statement position; you may be omitting necessary parentheses
+   |
+   | longer explanation available when compiling with `-explain`
 -- Error: tests/neg-custom-args/captures/real-try.scala:12:2 -----------------------------------------------------------
 12 |  try  // error
    |  ^
-   |  The expression's type () => Unit is not allowed to capture the root capability `cap`.
-   |  This usually means that a capability persists longer than its allowed lifetime.
+   |  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.
 13 |    () => foo(1)
 14 |  catch
 15 |    case _: Ex1 => ???
@@ -10,14 +17,20 @@
 -- Error: tests/neg-custom-args/captures/real-try.scala:18:2 -----------------------------------------------------------
 18 |  try  // error
    |  ^
-   |  The expression's type () => Cell[Unit]^? is not allowed to capture the root capability `cap`.
-   |  This usually means that a capability persists longer than its allowed lifetime.
+   |  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.
 19 |    () => Cell(foo(1))
 20 |  catch
 21 |    case _: Ex1 => ???
 22 |    case _: Ex2 => ???
--- Error: tests/neg-custom-args/captures/real-try.scala:30:4 -----------------------------------------------------------
-30 |  b.x // 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/real-try.scala:24:10 ----------------------------------------------------------
+24 |  val b = try  // error
+   |          ^
+   |          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.
+25 |    Cell(() => foo(1))//: Cell[box {ev} () => Unit] <: Cell[box {cap} () => Unit]
+26 |  catch
+27 |    case _: Ex1 => ???
+28 |    case _: Ex2 => ???
diff --git a/tests/neg-custom-args/captures/real-try.scala b/tests/neg-custom-args/captures/real-try.scala
index 03e168032122..a826fdaa4af7 100644
--- a/tests/neg-custom-args/captures/real-try.scala
+++ b/tests/neg-custom-args/captures/real-try.scala
@@ -8,7 +8,7 @@ def foo(i: Int): (CanThrow[Ex1], CanThrow[Ex2]) ?-> Unit =
 
 class Cell[+T](val x: T)
 
-def test() =
+def test(): Unit =
   try  // error
     () => foo(1)
   catch
@@ -21,10 +21,10 @@ def test() =
     case _: Ex1 => ???
     case _: Ex2 => ???
 
-  val b = try  // ok here, but error on use
+  val b = try  // error
     Cell(() => foo(1))//: Cell[box {ev} () => Unit] <: Cell[box {cap} () => Unit]
   catch
     case _: Ex1 => ???
     case _: Ex2 => ???
 
-  b.x // error
+  b.x
diff --git a/tests/neg-custom-args/captures/sealed-leaks.scala b/tests/neg-custom-args/captures/sealed-leaks.scala
new file mode 100644
index 000000000000..bf46b52194c1
--- /dev/null
+++ b/tests/neg-custom-args/captures/sealed-leaks.scala
@@ -0,0 +1,20 @@
+
+import java.io.*
+def Test2 =
+
+  def usingLogFile[sealed T](op: FileOutputStream^ => T): T =
+    val logFile = FileOutputStream("log")
+    val result = op(logFile)
+    logFile.close()
+    result
+
+  val later = usingLogFile { f => () => f.write(0) } // error
+  val later2 = usingLogFile[(() => Unit) | Null] { f => () => f.write(0) } // error
+
+  var x: (FileOutputStream^) | Null = null  // error
+  def foo(f: FileOutputStream^, g: FileOutputStream^) =
+    var y = if ??? then f else g  // error
+
+  usingLogFile { f => x = f }
+
+  later()
\ No newline at end of file
diff --git a/tests/neg-custom-args/captures/stack-alloc.scala b/tests/neg-custom-args/captures/stack-alloc.scala
index 027f2b3e005c..71b544dbe88d 100644
--- a/tests/neg-custom-args/captures/stack-alloc.scala
+++ b/tests/neg-custom-args/captures/stack-alloc.scala
@@ -5,7 +5,7 @@ class Pooled
 val stack = mutable.ArrayBuffer[Pooled]()
 var nextFree = 0
 
-def withFreshPooled[T](op: Pooled^ => T): T =
+def withFreshPooled[sealed T](op: Pooled^ => T): T =
   if nextFree >= stack.size then stack.append(new Pooled)
   val pooled = stack(nextFree)
   nextFree = nextFree + 1
diff --git a/tests/neg-custom-args/captures/try.check b/tests/neg-custom-args/captures/try.check
index f85ca468e6e5..4af370bfba1a 100644
--- a/tests/neg-custom-args/captures/try.check
+++ b/tests/neg-custom-args/captures/try.check
@@ -1,12 +1,10 @@
--- [E007] Type Mismatch Error: tests/neg-custom-args/captures/try.scala:23:49 ------------------------------------------
+-- Error: tests/neg-custom-args/captures/try.scala:23:16 ---------------------------------------------------------------
 23 |  val a = handle[Exception, CanThrow[Exception]] { // error
-   |                                                 ^
-   |                                                 Found:    CT[Exception]^ ->? CanThrow[Exception]
-   |                                                 Required: CanThrow[Exception] => box CT[Exception]^
-24 |    (x: CanThrow[Exception]) => x
-25 |  }{
-   |
-   | longer explanation available when compiling with `-explain`
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |          Sealed type variable R cannot  be instantiated to box CT[Exception]^ since
+   |          that type captures the root capability `cap`.
+   |          This is often caused by a local capability in the body of method handle
+   |          leaking as part of its result.
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/try.scala:29:43 ------------------------------------------
 29 |  val b = handle[Exception, () -> Nothing] {  // error
    |                                           ^
@@ -22,7 +20,7 @@
 49 |    () =>
 50 |      raise(new Exception)(using x)
 51 |      22
-52 |} {  // error
+52 |} { // error
    |                        ^
    |                        Found:    () ->{x$0} Int
    |                        Required: () -> Int
@@ -30,15 +28,10 @@
 54 |}
    |
    | longer explanation available when compiling with `-explain`
--- Error: tests/neg-custom-args/captures/try.scala:40:4 ----------------------------------------------------------------
-35 |  val xx = handle {
-36 |    (x: CanThrow[Exception]) =>
-37 |      () =>
-38 |        raise(new Exception)(using x)
-39 |        22
-40 |  } {  // error
-   |           ^
-   |           The expression's type box () => Int is not allowed to capture the root capability `cap`.
-   |           This usually means that a capability persists longer than its allowed lifetime.
-41 |    (ex: Exception) => () => 22
-42 |  }
+-- Error: tests/neg-custom-args/captures/try.scala:35:11 ---------------------------------------------------------------
+35 |  val xx = handle {  // error
+   |           ^^^^^^
+   |           Sealed type variable R cannot  be instantiated to box () => Int since
+   |           that type captures the root capability `cap`.
+   |           This is often caused by a local capability in the body of method handle
+   |           leaking as part of its result.
diff --git a/tests/neg-custom-args/captures/try.scala b/tests/neg-custom-args/captures/try.scala
index ef375c62b817..3c6f0605d8b9 100644
--- a/tests/neg-custom-args/captures/try.scala
+++ b/tests/neg-custom-args/captures/try.scala
@@ -14,7 +14,7 @@ def raise[E <: Exception](e: E): Nothing throws E = throw e
 def foo(x: Boolean): Int throws Fail =
   if x then 1 else raise(Fail())
 
-def handle[E <: Exception, R <: Top](op: CanThrow[E] => R)(handler: E => R): R =
+def handle[E <: Exception, sealed R <: Top](op: CanThrow[E] => R)(handler: E => R): R =
   val x: CanThrow[E] = ???
   try op(x)
   catch case ex: E => handler(ex)
@@ -32,12 +32,12 @@ def test =
     (ex: Exception) => ???
   }
 
-  val xx = handle {
+  val xx = handle {  // error
     (x: CanThrow[Exception]) =>
       () =>
         raise(new Exception)(using x)
         22
-  } {  // error
+  } {
     (ex: Exception) => () => 22
   }
   val yy = xx :: Nil
@@ -49,6 +49,6 @@ val global: () -> Int = handle {
     () =>
       raise(new Exception)(using x)
       22
-} {  // error
+} { // error
   (ex: Exception) => () => 22
 }
diff --git a/tests/neg-custom-args/captures/try3.scala b/tests/neg-custom-args/captures/try3.scala
index 5a569aa5fd8d..4c6835353c3f 100644
--- a/tests/neg-custom-args/captures/try3.scala
+++ b/tests/neg-custom-args/captures/try3.scala
@@ -4,7 +4,7 @@ class CT[E]
 type CanThrow[E] = CT[E]^
 type Top  = Any^
 
-def handle[E <: Exception, T <: Top](op: CanThrow[E] ?=> T)(handler: E => T): T =
+def handle[E <: Exception, sealed T <: Top](op: CanThrow[E] ?=> T)(handler: E => T): T =
   val x: CanThrow[E] = ???
   try op(using x)
   catch case ex: E => handler(ex)
@@ -14,12 +14,12 @@ def raise[E <: Exception](ex: E)(using CanThrow[E]): Nothing =
 
 @main def Test: Int =
   def f(a: Boolean) =
-    handle {
+    handle {  // error
       if !a then raise(IOException())
       (b: Boolean) =>
         if !b then raise(IOException())
         0
-    } {  // error
+    } {
       ex => (b: Boolean) => -1
     }
   val g = f(true)
diff --git a/tests/neg-custom-args/captures/unbox.scala b/tests/neg-custom-args/captures/unbox.scala
index 18a86a1237ff..33702a954068 100644
--- a/tests/neg-custom-args/captures/unbox.scala
+++ b/tests/neg-custom-args/captures/unbox.scala
@@ -1,3 +1,4 @@
+import language.`3.2`
 type Proc = () => Unit
 
 val xs: List[Proc] = ???
diff --git a/tests/neg-custom-args/captures/usingLogFile.check b/tests/neg-custom-args/captures/usingLogFile.check
index 17b9146ce71c..f9230e37a1cf 100644
--- a/tests/neg-custom-args/captures/usingLogFile.check
+++ b/tests/neg-custom-args/captures/usingLogFile.check
@@ -1,39 +1,54 @@
--- Error: tests/neg-custom-args/captures/usingLogFile.scala:33:2 -------------------------------------------------------
-33 |  later3() // error
-   |  ^^^^^^
-   |  box () => Unit cannot be box-converted to a type that can be selected or applied
-   |  since one of their capture sets contains the root capability `cap`
--- Error: tests/neg-custom-args/captures/usingLogFile.scala:37:9 -------------------------------------------------------
-37 |  later4.x() // 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/usingLogFile.scala:23:6 -------------------------------------------------------
+-- Error: tests/neg-custom-args/captures/usingLogFile.scala:31:6 -------------------------------------------------------
+31 |  var later3: () => Unit = () => ()  // error
+   |  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |  Mutable variable later3 cannot have type box () => Unit since
+   |  that type captures the root capability `cap`.
+   |  This restriction serves to prevent local capabilities from escaping the scope where they are defined.
+-- Error: tests/neg-custom-args/captures/usingLogFile.scala:35:6 -------------------------------------------------------
+35 |  var later4: Cell[() => Unit] = Cell(() => ())  // error
+   |  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |  Mutable variable later4 cannot have type Test2.Cell[() => Unit] since
+   |  the part () => Unit of that type captures the root capability `cap`.
+   |  This restriction serves to prevent local capabilities from escaping the scope where they are defined.
+-- Error: tests/neg-custom-args/captures/usingLogFile.scala:23:14 ------------------------------------------------------
 23 |  val later = usingLogFile { f => () => f.write(0) } // error
-   |  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |  Non-local value later cannot have an inferred type
-   |  () ->{x$0} Unit
-   |  with non-empty capture set {x$0}.
-   |  The type needs to be declared explicitly.
--- Error: tests/neg-custom-args/captures/usingLogFile.scala:29:9 -------------------------------------------------------
-29 |  later2.x()  // 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.
+   |              ^^^^^^^^^^^^
+   |              Sealed type variable T cannot  be instantiated to box () => Unit since
+   |              that type captures the root capability `cap`.
+   |              This is often caused by a local capability in the body of method usingLogFile
+   |              leaking as part of its result.
+-- Error: tests/neg-custom-args/captures/usingLogFile.scala:28:23 ------------------------------------------------------
+28 |  private val later2 = usingLogFile { f => Cell(() => f.write(0)) } // error
+   |                       ^^^^^^^^^^^^
+   |                       Sealed type variable T cannot  be instantiated to box Test2.Cell[() => Unit]^? since
+   |                       the part () => Unit of that type captures the root capability `cap`.
+   |                       This is often caused by a local capability in the body of method usingLogFile
+   |                       leaking as part of its result.
 -- Error: tests/neg-custom-args/captures/usingLogFile.scala:47:6 -------------------------------------------------------
 47 |  val later = usingLogFile { f => () => f.write(0) } // error
    |  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |  Non-local value later cannot have an inferred type
-   |  () ->{x$0} Unit
-   |  with non-empty capture set {x$0}.
+   |  () => Unit
+   |  with non-empty capture set {x$0, cap}.
    |  The type needs to be declared explicitly.
--- Error: tests/neg-custom-args/captures/usingLogFile.scala:62:25 ------------------------------------------------------
+-- Error: tests/neg-custom-args/captures/usingLogFile.scala:62:16 ------------------------------------------------------
 62 |    val later = usingFile("out", f => (y: Int) => xs.foreach(x => f.write(x + y))) // error
-   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |               The expression's type box (x$0: Int) => 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/usingLogFile.scala:71:25 ------------------------------------------------------
-71 |    val later = usingFile("logfile", usingLogger(_, l => () => l.log("test"))) // 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.
+   |                ^^^^^^^^^
+   |                Sealed type variable T cannot  be instantiated to box (x$0: Int) => Unit since
+   |                that type captures the root capability `cap`.
+   |                This is often caused by a local capability in the body of method usingFile
+   |                leaking as part of its result.
+-- Error: tests/neg-custom-args/captures/usingLogFile.scala:71:16 ------------------------------------------------------
+71 |    val later = usingFile("logfile",            // error
+   |                ^^^^^^^^^
+   |                Sealed type variable T cannot  be instantiated to box () => Unit since
+   |                that type captures the root capability `cap`.
+   |                This is often caused by a local capability in the body of method usingFile
+   |                leaking as part of its result.
+-- Error: tests/neg-custom-args/captures/usingLogFile.scala:72:6 -------------------------------------------------------
+72 |      usingLogger(_, l => () => l.log("test"))) // error
+   |      ^^^^^^^^^^^
+   |      Sealed type variable T cannot  be instantiated to box () => Unit since
+   |      that type captures the root capability `cap`.
+   |      This is often caused by a local capability in the body of method usingLogger
+   |      leaking as part of its result.
diff --git a/tests/neg-custom-args/captures/usingLogFile.scala b/tests/neg-custom-args/captures/usingLogFile.scala
index 1e281f130b8a..40c90b934464 100644
--- a/tests/neg-custom-args/captures/usingLogFile.scala
+++ b/tests/neg-custom-args/captures/usingLogFile.scala
@@ -3,7 +3,7 @@ import annotation.capability
 
 object Test1:
 
-  def usingLogFile[T](op: FileOutputStream => T): T =
+  def usingLogFile[sealed T](op: FileOutputStream => T): T =
     val logFile = FileOutputStream("log")
     val result = op(logFile)
     logFile.close()
@@ -14,7 +14,7 @@ object Test1:
 
 object Test2:
 
-  def usingLogFile[T](op: FileOutputStream^ => T): T =
+  def usingLogFile[sealed T](op: FileOutputStream^ => T): T =
     val logFile = FileOutputStream("log")
     val result = op(logFile)
     logFile.close()
@@ -25,20 +25,20 @@ object Test2:
 
   class Cell[+T](val x: T)
 
-  private val later2 = usingLogFile { f => Cell(() => f.write(0)) }
-  later2.x()  // error
+  private val later2 = usingLogFile { f => Cell(() => f.write(0)) } // error
+  later2.x()
 
-  var later3: () => Unit = () => ()
+  var later3: () => Unit = () => ()  // error
   usingLogFile { f => later3 = () => f.write(0) }
-  later3() // error
+  later3()
 
-  var later4: Cell[() => Unit] = Cell(() => ())
+  var later4: Cell[() => Unit] = Cell(() => ())  // error
   usingLogFile { f => later4 = Cell(() => f.write(0)) }
-  later4.x() // error
+  later4.x()
 
 object Test3:
 
-  def usingLogFile[T](op: FileOutputStream^ => T) =
+  def usingLogFile[sealed T](op: FileOutputStream^ => T) =
     val logFile = FileOutputStream("log")
     val result = op(logFile)
     logFile.close()
@@ -50,7 +50,7 @@ object Test4:
   class Logger(f: OutputStream^):
     def log(msg: String): Unit = ???
 
-  def usingFile[T](name: String, op: OutputStream^ => T): T =
+  def usingFile[sealed T](name: String, op: OutputStream^ => T): T =
     val f = new FileOutputStream(name)
     val result = op(f)
     f.close()
@@ -63,10 +63,11 @@ object Test4:
     later(1)
 
 
-  def usingLogger[T](f: OutputStream^, op: Logger^{f} => T): T =
+  def usingLogger[sealed T](f: OutputStream^, op: Logger^{f} => T): T =
     val logger = Logger(f)
     op(logger)
 
   def test =
-    val later = usingFile("logfile", usingLogger(_, l => () => l.log("test"))) // error
+    val later = usingFile("logfile",            // error
+      usingLogger(_, l => () => l.log("test"))) // error
     later()
diff --git a/tests/neg-custom-args/captures/vars.check b/tests/neg-custom-args/captures/vars.check
index 565101359673..e7055c810bb0 100644
--- a/tests/neg-custom-args/captures/vars.check
+++ b/tests/neg-custom-args/captures/vars.check
@@ -1,3 +1,15 @@
+-- Error: tests/neg-custom-args/captures/vars.scala:13:6 ---------------------------------------------------------------
+13 |  var a: String => String = f // error
+   |  ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |  Mutable variable a cannot have type box String => String since
+   |  that type captures the root capability `cap`.
+   |  This restriction serves to prevent local capabilities from escaping the scope where they are defined.
+-- Error: tests/neg-custom-args/captures/vars.scala:14:6 ---------------------------------------------------------------
+14 |  var b: List[String => String] = Nil // error
+   |  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |  Mutable variable b cannot have type List[String => String] since
+   |  the part String => String of that type captures the root capability `cap`.
+   |  This restriction serves to prevent local capabilities from escaping the scope where they are defined.
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/vars.scala:11:24 -----------------------------------------
 11 |  val z2c: () -> Unit = z2  // error
    |                        ^^
@@ -5,28 +17,10 @@
    |                        Required: () -> Unit
    |
    | longer explanation available when compiling with `-explain`
--- [E007] Type Mismatch Error: tests/neg-custom-args/captures/vars.scala:15:10 -----------------------------------------
-15 |  val u = a  // error
-   |          ^
-   |          Found:    (a : box String => String)
-   |          Required: (x$0: String) => String
-   |
-   | longer explanation available when compiling with `-explain`
--- Error: tests/neg-custom-args/captures/vars.scala:16:2 ---------------------------------------------------------------
-16 |  a("")  // error
-   |  ^
-   |  box String => String cannot be box-converted to a type that can be selected or applied
-   |  since one of their capture sets contains the root capability `cap`
--- Error: tests/neg-custom-args/captures/vars.scala:17:4 ---------------------------------------------------------------
-17 |  b.head // error
-   |  ^^^^^^
-   |  The expression's type box String => String 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/vars.scala:32:8 ---------------------------------------------------------------
+-- Error: tests/neg-custom-args/captures/vars.scala:32:2 ---------------------------------------------------------------
 32 |  local { cap3 => // error
-   |  ^
-   |  The expression's type box (x$0: String) => String is not allowed to capture the root capability `cap`.
-   |  This usually means that a capability persists longer than its allowed lifetime.
-33 |    def g(x: String): String = if cap3 == cap3 then "" else "a"
-34 |    g
-35 |  }
+   |  ^^^^^
+   |  Sealed type variable T cannot  be instantiated to box (x$0: String) => String since
+   |  that type captures the root capability `cap`.
+   |  This is often caused by a local capability in the body of method local
+   |  leaking as part of its result.
diff --git a/tests/neg-custom-args/captures/vars.scala b/tests/neg-custom-args/captures/vars.scala
index e437d087d5a2..b7761952167e 100644
--- a/tests/neg-custom-args/captures/vars.scala
+++ b/tests/neg-custom-args/captures/vars.scala
@@ -10,11 +10,11 @@ def test(cap1: Cap, cap2: Cap) =
   val z2 = () => { x = identity }
   val z2c: () -> Unit = z2  // error
 
-  var a: String => String = f // was error, now OK
-  var b: List[String => String] = Nil // was error, now OK
-  val u = a  // error
-  a("")  // error
-  b.head // error
+  var a: String => String = f // error
+  var b: List[String => String] = Nil // error
+  val u = a  // was error, now ok
+  a("")  // was error, now ok
+  b.head // was error, now ok
 
   def scope =
     val cap3: Cap = CC()
@@ -27,7 +27,7 @@ def test(cap1: Cap, cap2: Cap) =
   val s = scope
   val sc: String => String = scope
 
-  def local[T](op: Cap -> T): T = op(CC())
+  def local[sealed T](op: Cap -> T): T = op(CC())
 
   local { cap3 => // error
     def g(x: String): String = if cap3 == cap3 then "" else "a"
diff --git a/tests/pos-custom-args/captures/capt-env.scala b/tests/pos-custom-args/captures/capt-env.scala
new file mode 100644
index 000000000000..be24ed618606
--- /dev/null
+++ b/tests/pos-custom-args/captures/capt-env.scala
@@ -0,0 +1,8 @@
+class C
+type Cap = C^
+
+def test(c: Cap) =
+  def x = () => () => c; ()
+  def y = () => x()
+  def z = () => x()()
+
diff --git a/tests/neg-custom-args/captures/i15749.scala b/tests/pos-custom-args/captures/i15749.scala
similarity index 73%
rename from tests/neg-custom-args/captures/i15749.scala
rename to tests/pos-custom-args/captures/i15749.scala
index 32947c146021..4959c003a918 100644
--- a/tests/neg-custom-args/captures/i15749.scala
+++ b/tests/pos-custom-args/captures/i15749.scala
@@ -12,4 +12,4 @@ type BoxedLazyVal[T] = Foo[LazyVal[T]]
 
 def force[A](v: BoxedLazyVal[A]): A =
   // Γ ⊢ v.x : □ {cap} Unit -> A
-  v.x(unit)  // error: (unbox v.x)(unit), where (unbox v.x) should be untypable
\ No newline at end of file
+  v.x(unit)  // was error: (unbox v.x)(unit), where (unbox v.x) should be untypable, now ok
\ No newline at end of file
diff --git a/tests/neg-custom-args/captures/i15749a.scala b/tests/pos-custom-args/captures/i15749a.scala
similarity index 62%
rename from tests/neg-custom-args/captures/i15749a.scala
rename to tests/pos-custom-args/captures/i15749a.scala
index e4d70efa5206..fe5f4d75dae1 100644
--- a/tests/neg-custom-args/captures/i15749a.scala
+++ b/tests/pos-custom-args/captures/i15749a.scala
@@ -1,5 +1,5 @@
 class Unit
-object unit extends Unit
+object u extends Unit
 
 type Top = Any^
 
@@ -10,12 +10,12 @@ def test =
   def wrapper[T](x: T): Wrapper[T] =
     [X] => (op: T ->{cap} X) => op(x)
 
-  def strictMap[A <: Top, B <: Top](mx: Wrapper[A])(f: A ->{cap} B): Wrapper[B] =
+  def strictMap[A <: Top, sealed B <: Top](mx: Wrapper[A])(f: A ->{cap} B): Wrapper[B] =
     mx((x: A) => wrapper(f(x)))
 
-  def force[A](thunk: Unit ->{cap} A): A = thunk(unit)
+  def force[A](thunk: Unit ->{cap} A): A = thunk(u)
 
-  def forceWrapper[A](mx: Wrapper[Unit ->{cap} A]): Wrapper[A] =
+  def forceWrapper[sealed A](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 ->{cap} A, A](mx)(t => force[A](t)) // error
diff --git a/tests/neg-custom-args/captures/i15923-cases.scala b/tests/pos-custom-args/captures/i15923-cases.scala
similarity index 89%
rename from tests/neg-custom-args/captures/i15923-cases.scala
rename to tests/pos-custom-args/captures/i15923-cases.scala
index 9a103c976a8e..136b8950eb26 100644
--- a/tests/neg-custom-args/captures/i15923-cases.scala
+++ b/tests/pos-custom-args/captures/i15923-cases.scala
@@ -3,7 +3,7 @@ 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^{cap}]) = {
-  x(_.use())  // error
+  x(_.use())  // was error, now OK
 }
 
 def bar(io: Cap^{cap}, x: Id[Cap^{io}]) = {
diff --git a/tests/neg-custom-args/captures/i15925.scala b/tests/pos-custom-args/captures/i15925.scala
similarity index 69%
rename from tests/neg-custom-args/captures/i15925.scala
rename to tests/pos-custom-args/captures/i15925.scala
index 433d27a98414..63b6962ff9f8 100644
--- a/tests/neg-custom-args/captures/i15925.scala
+++ b/tests/pos-custom-args/captures/i15925.scala
@@ -1,13 +1,13 @@
 import language.experimental.captureChecking
 
 class Unit
-object unit extends Unit
+object u extends Unit
 
 type Foo[X] = [T] -> (op: X => T) -> T
 type Lazy[X] = Unit => X
 
 def force[X](fx: Foo[Lazy[X]]): X =
-  fx[X](f => f(unit))  // error
+  fx[X](f => f(u))
 
 def force2[X](fx: Foo[Unit => X]): X =
-  fx[X](f => f(unit))  // error
+  fx[X](f => f(u))
diff --git a/tests/pos-custom-args/captures/unsafe-unbox.scala b/tests/pos-custom-args/captures/unsafe-unbox.scala
index b228d8c07925..63a32d58f640 100644
--- a/tests/pos-custom-args/captures/unsafe-unbox.scala
+++ b/tests/pos-custom-args/captures/unsafe-unbox.scala
@@ -1,4 +1,7 @@
-import caps.unsafe.*
+import annotation.unchecked.uncheckedCaptures
 def test =
+  @uncheckedCaptures
   var finalizeActions = collection.mutable.ListBuffer[() => Unit]()
-  val action = finalizeActions.remove(0).unsafeUnbox
+  val action = finalizeActions.remove(0)
+
+
diff --git a/tests/pos-custom-args/captures/vars1.scala b/tests/pos-custom-args/captures/vars1.scala
index c008bac2e72f..56548e5a9c30 100644
--- a/tests/pos-custom-args/captures/vars1.scala
+++ b/tests/pos-custom-args/captures/vars1.scala
@@ -1,9 +1,12 @@
 import caps.unsafe.*
+import annotation.unchecked.uncheckedCaptures
 
 object Test:
   type ErrorHandler = (Int, String) => Unit
 
+  @uncheckedCaptures
   var defaultIncompleteHandler: ErrorHandler = ???
+  @uncheckedCaptures
   var incompleteHandler: ErrorHandler = defaultIncompleteHandler
   val x = incompleteHandler.unsafeUnbox
   val _ : ErrorHandler = x
@@ -11,11 +14,17 @@ object Test:
 
   def defaultIncompleteHandler1(): ErrorHandler = ???
   val defaultIncompleteHandler2: ErrorHandler = ???
-  var incompleteHandler1: ErrorHandler = defaultIncompleteHandler1().unsafeBox
-  var incompleteHandler2: ErrorHandler = defaultIncompleteHandler2.unsafeBox
-  private var incompleteHandler7 = defaultIncompleteHandler1().unsafeBox
-  private var incompleteHandler8 = defaultIncompleteHandler2.unsafeBox
+  @uncheckedCaptures
+  var incompleteHandler1: ErrorHandler = defaultIncompleteHandler1()
+  @uncheckedCaptures
+  var incompleteHandler2: ErrorHandler = defaultIncompleteHandler2
+  @uncheckedCaptures
+  private var incompleteHandler7 = defaultIncompleteHandler1()
+  @uncheckedCaptures
+  private var incompleteHandler8 = defaultIncompleteHandler2
+
+  incompleteHandler1 = defaultIncompleteHandler2
+  incompleteHandler1 = defaultIncompleteHandler2
+  val saved = incompleteHandler1
+
 
-  incompleteHandler1 = defaultIncompleteHandler2.unsafeBox
-  incompleteHandler1 = defaultIncompleteHandler2.unsafeBox
-  val saved = incompleteHandler1.unsafeUnbox
diff --git a/tests/pos-with-compiler-cc/dotc/Run.scala b/tests/pos-with-compiler-cc/dotc/Run.scala
index 16a955afca1a..96f8c6a7b06f 100644
--- a/tests/pos-with-compiler-cc/dotc/Run.scala
+++ b/tests/pos-with-compiler-cc/dotc/Run.scala
@@ -32,7 +32,7 @@ import scala.collection.mutable
 import scala.util.control.NonFatal
 import scala.io.Codec
 import annotation.constructorOnly
-import caps.unsafe.unsafeUnbox
+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 {
@@ -165,6 +165,7 @@ class Run(comp: Compiler, @constructorOnly ictx0: Context) extends ImplicitRunIn
   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
@@ -275,7 +276,7 @@ class Run(comp: Compiler, @constructorOnly ictx0: Context) extends ImplicitRunIn
       Rewrites.writeBack()
     suppressions.runFinished(hasErrors = ctx.reporter.hasErrors)
     while (finalizeActions.nonEmpty) {
-      val action = finalizeActions.remove(0).unsafeUnbox
+      val action = finalizeActions.remove(0)
       action()
     }
     compiling = false
diff --git a/tests/pos-with-compiler-cc/dotc/core/Scopes.scala b/tests/pos-with-compiler-cc/dotc/core/Scopes.scala
index 3b4cf9a98c54..7ab68ddf78a2 100644
--- a/tests/pos-with-compiler-cc/dotc/core/Scopes.scala
+++ b/tests/pos-with-compiler-cc/dotc/core/Scopes.scala
@@ -1,8 +1,3 @@
-/* NSC -- new Scala compiler
- * Copyright 2005-2012 LAMP/EPFL
- * @author  Martin Odersky
- */
-
 package dotty.tools
 package dotc
 package core
@@ -17,6 +12,7 @@ import Denotations._
 import printing.Texts._
 import printing.Printer
 import SymDenotations.NoDenotation
+import annotation.unchecked.uncheckedCaptures
 
 import collection.mutable
 
@@ -220,6 +216,7 @@ object Scopes {
     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 */
diff --git a/tests/pos-with-compiler-cc/dotc/core/TypeComparer.scala b/tests/pos-with-compiler-cc/dotc/core/TypeComparer.scala
index 67b9f063e9d0..0e1fc277865a 100644
--- a/tests/pos-with-compiler-cc/dotc/core/TypeComparer.scala
+++ b/tests/pos-with-compiler-cc/dotc/core/TypeComparer.scala
@@ -25,7 +25,7 @@ import reporting.trace
 import annotation.constructorOnly
 import cc.{CapturingType, derivedCapturingType, CaptureSet, stripCapturing, isBoxedCapturing, boxed, boxedUnlessFun, boxedIfTypeParam, isAlwaysPure}
 import language.experimental.pureFunctions
-import caps.unsafe.*
+import annotation.unchecked.uncheckedCaptures
 
 /** Provides methods to compare types.
  */
@@ -33,17 +33,18 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
   import TypeComparer._
   Stats.record("TypeComparer")
 
-  private var myContext: Context = initctx.unsafeBox
-  def comparerContext: Context = myContext.unsafeUnbox
+  @uncheckedCaptures
+  private var myContext: Context = initctx
+  def comparerContext: Context = myContext
 
-  protected given [DummySoItsADef]: Context = myContext.unsafeUnbox
+  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.unsafeBox
+    myContext = c
     state = c.typerState
     monitored = false
     GADTused = false
diff --git a/tests/pos-with-compiler-cc/dotc/core/tasty/TreeUnpickler.scala b/tests/pos-with-compiler-cc/dotc/core/tasty/TreeUnpickler.scala
index b87cde4a6ad1..fcc449af3632 100644
--- a/tests/pos-with-compiler-cc/dotc/core/tasty/TreeUnpickler.scala
+++ b/tests/pos-with-compiler-cc/dotc/core/tasty/TreeUnpickler.scala
@@ -47,7 +47,7 @@ import dotty.tools.tasty.TastyFormat._
 import scala.annotation.constructorOnly
 import scala.annotation.internal.sharable
 import language.experimental.pureFunctions
-import caps.unsafe.{unsafeUnbox, unsafeBox}
+import annotation.unchecked.uncheckedCaptures
 
 /** Unpickler for typed trees
  *  @param reader              the reader from which to unpickle
@@ -1086,15 +1086,15 @@ class TreeUnpickler(reader: TastyReader,
 
     def readIndexedStats[T](exprOwner: Symbol, end: Addr, k: (List[Tree], Context) => T = sameTrees)(using Context): T =
       val buf = new mutable.ListBuffer[Tree]
-      var curCtx = ctx.unsafeBox
+      @uncheckedCaptures var curCtx = ctx
       while currentAddr.index < end.index do
-        val stat = readIndexedStat(exprOwner)(using curCtx.unsafeUnbox)
+        val stat = readIndexedStat(exprOwner)(using curCtx)
         buf += stat
         stat match
-          case stat: Import => curCtx = curCtx.unsafeUnbox.importContext(stat, stat.symbol).unsafeBox
+          case stat: Import => curCtx = curCtx.importContext(stat, stat.symbol)
           case _ =>
       assert(currentAddr.index == end.index)
-      k(buf.toList, curCtx.unsafeUnbox)
+      k(buf.toList, curCtx)
 
     def readStats[T](exprOwner: Symbol, end: Addr, k: (List[Tree], Context) => T = sameTrees)(using Context): T = {
       fork.indexStats(end)
diff --git a/tests/pos-with-compiler-cc/dotc/typer/Namer.scala b/tests/pos-with-compiler-cc/dotc/typer/Namer.scala
index 548f645a23d9..8487192b9d8a 100644
--- a/tests/pos-with-compiler-cc/dotc/typer/Namer.scala
+++ b/tests/pos-with-compiler-cc/dotc/typer/Namer.scala
@@ -29,7 +29,7 @@ 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.
@@ -930,6 +930,8 @@ class Namer { typer: Typer =>
   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)
 
diff --git a/tests/pos-with-compiler-cc/dotc/typer/Typer.scala b/tests/pos-with-compiler-cc/dotc/typer/Typer.scala
index aa286446a334..0baae1730f4a 100644
--- a/tests/pos-with-compiler-cc/dotc/typer/Typer.scala
+++ b/tests/pos-with-compiler-cc/dotc/typer/Typer.scala
@@ -54,7 +54,8 @@ import config.Config
 import language.experimental.pureFunctions
 
 import scala.annotation.constructorOnly
-import caps.unsafe.{unsafeBox, unsafeUnbox}
+import annotation.unchecked.uncheckedCaptures
+
 
 object Typer {
 
@@ -1673,11 +1674,11 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
    *  and the patterns of the Match tree and the MatchType correspond.
    */
   def typedDependentMatchFinish(tree: untpd.Match, sel: Tree, wideSelType: Type, cases: List[untpd.CaseDef], pt: MatchType)(using Context): Tree = {
-    var caseCtx = ctx.unsafeBox
+    @uncheckedCaptures var caseCtx = ctx
     val cases1 = tree.cases.zip(pt.cases)
       .map { case (cas, tpe) =>
-        val case1 = typedCase(cas, sel, wideSelType, tpe)(using caseCtx.unsafeUnbox)
-        caseCtx = Nullables.afterPatternContext(sel, case1.pat).unsafeBox
+        val case1 = typedCase(cas, sel, wideSelType, tpe)(using caseCtx)
+        caseCtx = Nullables.afterPatternContext(sel, case1.pat)
         case1
       }
       .asInstanceOf[List[CaseDef]]
@@ -1692,10 +1693,10 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
   }
 
   def typedCases(cases: List[untpd.CaseDef], sel: Tree, wideSelType: Type, pt: Type)(using Context): List[CaseDef] =
-    var caseCtx = ctx.unsafeBox
+    @uncheckedCaptures var caseCtx = ctx
     cases.mapconserve { cas =>
-      val case1 = typedCase(cas, sel, wideSelType, pt)(using caseCtx.unsafeUnbox)
-      caseCtx = Nullables.afterPatternContext(sel, case1.pat).unsafeBox
+      val case1 = typedCase(cas, sel, wideSelType, pt)(using caseCtx)
+      caseCtx = Nullables.afterPatternContext(sel, case1.pat)
       case1
     }
 

From d96b65c16b4671ba24b9656ae57aa082623665f8 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Fri, 5 May 2023 12:46:25 +0200
Subject: [PATCH 554/657] Deprecate unsafe{Box,Unbox} methods

---
 library/src/scala/caps.scala                  | 33 +++++++++++--------
 .../no-experimental/dotty-experimental.scala  |  2 +-
 .../dotc/transform/init/Semantic.scala        |  3 +-
 .../dotc/typer/TypeAssigner.scala             |  3 +-
 4 files changed, 22 insertions(+), 19 deletions(-)

diff --git a/library/src/scala/caps.scala b/library/src/scala/caps.scala
index 4981353d61be..866e5dbd18cd 100644
--- a/library/src/scala/caps.scala
+++ b/library/src/scala/caps.scala
@@ -13,20 +13,25 @@ import annotation.experimental
 
   object unsafe:
 
-    /** If argument is of type `cs T`, converts to type `box cs T`. This
-     *  avoids the error that would be raised when boxing `*`.
-     */
-    extension [T](x: T) def unsafeBox: T = x
-
-    /** If argument is of type `box cs T`, converts to type `cs T`. This
-     *  avoids the error that would be raised when unboxing `*`.
-     */
-    extension [T](x: T) def unsafeUnbox: T = x
-
-    /** If argument is of type `box cs T`, converts to type `cs T`. This
-     *  avoids the error that would be raised when unboxing `*`.
-     */
-    extension [T, U](f: T => U) def unsafeBoxFunArg: T => U = f
+    extension [T](x: T)
+      /** If argument is of type `cs T`, converts to type `box cs T`. This
+      *  avoids the error that would be raised when boxing `*`.
+      */
+      @deprecated(since = "3.3")
+      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 `*`.
+       */
+      @deprecated(since = "3.3")
+      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 `*`.
+       */
+      @deprecated(since = "3.3")
+      def unsafeBoxFunArg: T => U = f
 
   end unsafe
 
diff --git a/tests/pos-custom-args/no-experimental/dotty-experimental.scala b/tests/pos-custom-args/no-experimental/dotty-experimental.scala
index 320c68dbea50..72d16ddd9b15 100644
--- a/tests/pos-custom-args/no-experimental/dotty-experimental.scala
+++ b/tests/pos-custom-args/no-experimental/dotty-experimental.scala
@@ -1,6 +1,6 @@
 package dotty.tools
 object test {
 
-  val x = caps.unsafe.unsafeBox
+  val x = caps.cap
 
 }
diff --git a/tests/pos-with-compiler-cc/dotc/transform/init/Semantic.scala b/tests/pos-with-compiler-cc/dotc/transform/init/Semantic.scala
index 14873938bf78..6ddc0e18d995 100644
--- a/tests/pos-with-compiler-cc/dotc/transform/init/Semantic.scala
+++ b/tests/pos-with-compiler-cc/dotc/transform/init/Semantic.scala
@@ -18,7 +18,6 @@ import Errors.*
 
 import scala.collection.mutable
 import scala.annotation.tailrec
-import caps.unsafe.unsafeBoxFunArg
 
 object Semantic:
 
@@ -1670,7 +1669,7 @@ object Semantic:
       }
 
       // initialize super classes after outers are set
-      tasks.foreach(((task: () => Unit) => task()).unsafeBoxFunArg)
+      tasks.foreach((task: () => Unit) => task())
         // !cc! .asInstanceOf needed to convert from `(() => Unit) -> Unit` to  `(box () => Unit) -> Unit`.
     end if
 
diff --git a/tests/pos-with-compiler-cc/dotc/typer/TypeAssigner.scala b/tests/pos-with-compiler-cc/dotc/typer/TypeAssigner.scala
index 2edcc37b613d..cb7bf2f2505d 100644
--- a/tests/pos-with-compiler-cc/dotc/typer/TypeAssigner.scala
+++ b/tests/pos-with-compiler-cc/dotc/typer/TypeAssigner.scala
@@ -12,7 +12,6 @@ import collection.mutable
 import reporting._
 import Checking.{checkNoPrivateLeaks, checkNoWildcard}
 import cc.CaptureSet
-import caps.unsafe.unsafeBoxFunArg
 
 trait TypeAssigner {
   import tpd.*
@@ -27,7 +26,7 @@ trait TypeAssigner {
           qual.isEmpty ||
           sym.name == qual ||
           sym.is(Module) && sym.name.stripModuleClassSuffix == qual)
-    ctx.outersIterator.map(((ctx: Context) => ctx.owner).unsafeBoxFunArg).find(qualifies) match {
+    ctx.outersIterator.map((ctx: Context) => ctx.owner).find(qualifies) match {
       case Some(c) if packageOK || !c.is(Package) =>
         c
       case _ =>

From 60c541e56484588d9e855e9512d9dfdbe30c8eb2 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Fri, 5 May 2023 15:02:06 +0200
Subject: [PATCH 555/657] Update MiMaFilters

---
 project/MiMaFilters.scala | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/project/MiMaFilters.scala b/project/MiMaFilters.scala
index 5009d68a7247..c5b00510bece 100644
--- a/project/MiMaFilters.scala
+++ b/project/MiMaFilters.scala
@@ -6,9 +6,11 @@ object MiMaFilters {
     ProblemFilters.exclude[DirectMissingMethodProblem]("scala.caps.unsafeBox"),
     ProblemFilters.exclude[DirectMissingMethodProblem]("scala.caps.unsafeUnbox"),
     ProblemFilters.exclude[DirectMissingMethodProblem]("scala.caps.cap"),
+    ProblemFilters.exclude[MissingClassProblem]("scala.caps$Sealed"),
     ProblemFilters.exclude[DirectMissingMethodProblem]("scala.CanEqual.canEqualMap"),
     ProblemFilters.exclude[MissingClassProblem]("scala.caps$Pure"),
     ProblemFilters.exclude[MissingClassProblem]("scala.caps$unsafe$"),
+    ProblemFilters.exclude[MissingClassProblem]("scala.annotation.unchecked.uncheckedCaptures"),
     ProblemFilters.exclude[MissingFieldProblem]("scala.runtime.stdLibPatches.language.3.3-migration"),
     ProblemFilters.exclude[MissingFieldProblem]("scala.runtime.stdLibPatches.language.3.3"),
     ProblemFilters.exclude[MissingClassProblem]("scala.runtime.stdLibPatches.language$3$u002E3$"),

From a8f583d17b1dcdbbecf87dbb43d1026aeebec06f Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Wed, 10 May 2023 18:32:42 +0200
Subject: [PATCH 556/657] Change * to cap in compiler comments and one output
 string

---
 compiler/src/dotty/tools/dotc/ast/TreeInfo.scala          | 4 ++--
 compiler/src/dotty/tools/dotc/cc/CaptureSet.scala         | 4 ++--
 compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala      | 6 +++---
 compiler/src/dotty/tools/dotc/cc/Setup.scala              | 4 ++--
 compiler/src/dotty/tools/dotc/cc/Synthetics.scala         | 6 +++---
 compiler/src/dotty/tools/dotc/core/Definitions.scala      | 2 +-
 compiler/src/dotty/tools/dotc/core/Flags.scala            | 2 +-
 compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala | 2 +-
 8 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
index a2e3277c9f81..2d335d1ed380 100644
--- a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
+++ b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
@@ -464,8 +464,8 @@ trait UntypedTreeInfo extends TreeInfo[Untyped] { self: Trees.Instance[Untyped]
     }
   }
 
-  /** 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`
+  /** Under pureFunctions: A builder and extractor for `=> T`, which is an alias for `->{cap} T`.
+   *  Only trees of the form `=> T` are matched; trees written directly as `->{cap} T`
    *  are ignored by the extractor.
    */
   object ImpureByNameTypeTree:
diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala b/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
index 509fecd4d3b4..ce903acab411 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
@@ -319,7 +319,7 @@ object CaptureSet:
   /** The empty capture set `{}` */
   val empty: CaptureSet.Const = Const(emptySet)
 
-  /** The universal capture set `{*}` */
+  /** The universal capture set `{cap}` */
   def universal(using Context): CaptureSet =
     defn.captureRoot.termRef.singletonCaptureSet
 
@@ -429,7 +429,7 @@ object CaptureSet:
 
     /** 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.
+     *  of this set. The universal set {cap} is a sound fallback.
      */
     final def upperApprox(origin: CaptureSet)(using Context): CaptureSet =
       if computingApprox then universal
diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index 9e0263d63b38..6ec360eca938 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -884,7 +884,7 @@ class CheckCaptures extends Recheck, SymTransformer:
 
     /** 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
+     *  without an explicit self type have the universal capture set `{cap}` 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.
@@ -941,9 +941,9 @@ class CheckCaptures extends Recheck, SymTransformer:
      *  that this type parameter can't see.
      *  For example, when capture checking the following expression:
      *
-     *    def usingLogFile[T](op: (f: {*} File) => T): T = ...
+     *    def usingLogFile[T](op: (f: {cap} File) => T): T = ...
      *
-     *    usingLogFile[box ?1 () -> Unit] { (f: {*} File) => () => { f.write(0) } }
+     *    usingLogFile[box ?1 () -> Unit] { (f: {cap} 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 `cap`,
diff --git a/compiler/src/dotty/tools/dotc/cc/Setup.scala b/compiler/src/dotty/tools/dotc/cc/Setup.scala
index 09f9695abfe1..bbe54f14b86c 100644
--- a/compiler/src/dotty/tools/dotc/cc/Setup.scala
+++ b/compiler/src/dotty/tools/dotc/cc/Setup.scala
@@ -122,7 +122,7 @@ extends tpd.TreeTraverser:
           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
+              // we assume Any is a shorthand of {cap} Any, so if Any is an upper
               // bound, the type is taken to be impure.
           else superTypeIsImpure(tp.superType)
         case tp: (RefinedOrRecType | MatchType) =>
@@ -155,7 +155,7 @@ extends tpd.TreeTraverser:
         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
+          && !refs.isUniversal // if refs is {cap}, an added variable would not change anything
         case _ =>
           false
     }.showing(i"can have inferred capture $tp = $result", capt)
diff --git a/compiler/src/dotty/tools/dotc/cc/Synthetics.scala b/compiler/src/dotty/tools/dotc/cc/Synthetics.scala
index dacbd27e0f35..5fe68dd6a7ac 100644
--- a/compiler/src/dotty/tools/dotc/cc/Synthetics.scala
+++ b/compiler/src/dotty/tools/dotc/cc/Synthetics.scala
@@ -54,9 +54,9 @@ object Synthetics:
 
   /** 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)
+   *    case class CC(a: {d} A, b: B, {cap} 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 }
+   *    def apply(a': {d} A, b: B, {cap} 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.
    */
@@ -123,7 +123,7 @@ object Synthetics:
     case _ =>
       info
 
-  /** Augment an unapply of type `(x: C): D` to `(x: {*} C): {x} D` */
+  /** Augment an unapply of type `(x: C): D` to `(x: {cap} C): {x} D` */
   private def addUnapplyCaptures(info: Type)(using Context): Type = info match
     case info: MethodType =>
       val paramInfo :: Nil = info.paramInfos: @unchecked
diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
index da2ec78b5179..eed22ba3808c 100644
--- a/compiler/src/dotty/tools/dotc/core/Definitions.scala
+++ b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -106,7 +106,7 @@ class Definitions {
    *      }
    *  ImpureXYZFunctionN follow this template:
    *
-   *      type ImpureXYZFunctionN[-T0,...,-T{N-1}, +R] = {*} XYZFunctionN[T0,...,T{N-1}, R]
+   *      type ImpureXYZFunctionN[-T0,...,-T{N-1}, +R] = {cap} XYZFunctionN[T0,...,T{N-1}, R]
    */
   private def newFunctionNType(name: TypeName): Symbol = {
     val impure = name.startsWith("Impure")
diff --git a/compiler/src/dotty/tools/dotc/core/Flags.scala b/compiler/src/dotty/tools/dotc/core/Flags.scala
index 47e7a85952b2..8100bea374eb 100644
--- a/compiler/src/dotty/tools/dotc/core/Flags.scala
+++ b/compiler/src/dotty/tools/dotc/core/Flags.scala
@@ -315,7 +315,7 @@ object Flags {
   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>", "<{*}>")
+  val (_, HasDefault @ _, Impure @ _) = newFlags(27, "<hasdefault>", "<impure>")
 
   /** An extension method, or a collective extension instance */
   val (Extension @ _, ExtensionMethod @ _, _) = newFlags(28, "<extension>")
diff --git a/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala b/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
index fa58c467bfa5..f3540502597c 100644
--- a/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
@@ -163,7 +163,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
       boxText ~ toTextLocal(parent) ~ "^"
       ~ (refsText provided refsText != rootSetText)
 
-  final protected def rootSetText = Str("{*}")
+  final protected def rootSetText = Str("{cap}")
 
   def toText(tp: Type): Text = controlled {
     homogenize(tp) match {

From d836de633a13a44a6ed47b003a4b1abd9d201a19 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Mon, 6 Mar 2023 19:36:55 +0100
Subject: [PATCH 557/657] Allow lines starting with a dot to fall outside
 previous indentation widths

If line following some indented code starts with a '`.`' and its indentation width is different from the
indentation widths of the two neighboring regions by more than a single space, the line accepted even
if it does not match a previous indentation width.
---
 .../dotty/tools/dotc/parsing/Parsers.scala    |  2 --
 .../dotty/tools/dotc/parsing/Scanners.scala   | 27 +++++++++++++++----
 .../other-new-features/indentation.md         | 15 ++++++++++-
 tests/neg/outdent-dot.check                   | 18 +++++++++++++
 tests/neg/outdent-dot.scala                   | 13 +++++++++
 tests/pos/outdent-dot.scala                   | 13 +++++++++
 6 files changed, 80 insertions(+), 8 deletions(-)
 create mode 100644 tests/neg/outdent-dot.check
 create mode 100644 tests/neg/outdent-dot.scala
 create mode 100644 tests/pos/outdent-dot.scala

diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 2f51af8549ae..e157d5b6b7ac 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -3599,8 +3599,6 @@ object Parsers {
       }
     }
 
-
-
     /** DefDef  ::=  DefSig [‘:’ Type] ‘=’ Expr
      *            |  this TypelessClauses [DefImplicitClause] `=' ConstrExpr
      *  DefDcl  ::=  DefSig `:' Type
diff --git a/compiler/src/dotty/tools/dotc/parsing/Scanners.scala b/compiler/src/dotty/tools/dotc/parsing/Scanners.scala
index 933661b7c5c9..fac73bfb4992 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Scanners.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Scanners.scala
@@ -611,11 +611,17 @@ object Scanners {
               case r: Indented =>
                 insert(OUTDENT, offset)
                 handleNewIndentWidth(r.enclosing, ir =>
-                  val lw = lastWidth
-                  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 $lw"""))
+                  if next.token == DOT
+                      && !nextWidth.isClose(r.indentWidth)
+                      && !nextWidth.isClose(ir.indentWidth)
+                  then
+                    ir.otherIndentWidths += nextWidth
+                  else
+                    val lw = lastWidth
+                    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 $lw"""))
               case r =>
                 if skipping then
                   if r.enclosing.isClosedByUndentAt(nextWidth) then
@@ -1666,6 +1672,17 @@ object Scanners {
 
     def < (that: IndentWidth): Boolean = this <= that && !(that <= this)
 
+    /** Does `this` differ from `that` by not more than a single space? */
+    def isClose(that: IndentWidth): Boolean = this match
+      case Run(ch1, n1) =>
+        that match
+          case Run(ch2, n2) => ch1 == ch2 && ch1 != '\t' && (n1 - n2).abs <= 1
+          case Conc(l, r) => false
+      case Conc(l1, r1) =>
+        that match
+          case Conc(l2, r2) => l1 == l2 && r1.isClose(r2)
+          case _ => false
+
     def toPrefix: String = this match {
       case Run(ch, n) => ch.toString * n
       case Conc(l, r) => l.toPrefix ++ r.toPrefix
diff --git a/docs/_docs/reference/other-new-features/indentation.md b/docs/_docs/reference/other-new-features/indentation.md
index f53bf0995727..de73bb67d451 100644
--- a/docs/_docs/reference/other-new-features/indentation.md
+++ b/docs/_docs/reference/other-new-features/indentation.md
@@ -100,7 +100,7 @@ There are two rules:
 
      - An `<outdent>` is finally inserted in front of a comma that follows a statement sequence starting with an `<indent>` if the indented region is itself enclosed in parentheses.
 
-It is an error if the indentation width of the token following an `<outdent>` does not match the indentation of some previous line in the enclosing indentation region. For instance, the following would be rejected.
+It is generally an error if the indentation width of the token following an `<outdent>` does not match the indentation of some previous line in the enclosing indentation region. For instance, the following would be rejected.
 
 ```scala
 if x < 0 then
@@ -109,6 +109,19 @@ if x < 0 then
     x
 ```
 
+However, there is one exception to this rule: If the next line starts with a '`.`' _and_ the indentation
+width is different from the indentation widths of the two neighboring regions by more than a single space, the line accepted. For instance, the following is OK:
+
+```scala
+xs.map: x =>
+    x + 1
+  .filter: x =>
+    x > 0
+```
+Here, the line starting with `.filter` does not have an indentation level matching a previous line,
+but it is still accepted since it starts with a '`.`' and differs in at least two spaces from the
+indentation levels of both the region that is closed and the next outer region.
+
 Indentation tokens are only inserted in regions where newline statement separators are also inferred:
 at the top-level, inside braces `{...}`, but not inside parentheses `(...)`, patterns or types.
 
diff --git a/tests/neg/outdent-dot.check b/tests/neg/outdent-dot.check
new file mode 100644
index 000000000000..c93c3bcfba73
--- /dev/null
+++ b/tests/neg/outdent-dot.check
@@ -0,0 +1,18 @@
+-- Error: tests/neg/outdent-dot.scala:6:5 ------------------------------------------------------------------------------
+6 |     .toString  // error
+  |     ^
+  |     The start of this line does not match any of the previous indentation widths.
+  |     Indentation width of current line : 5 spaces
+  |     This falls between previous widths: 2 spaces and 6 spaces
+-- Error: tests/neg/outdent-dot.scala:11:3 -----------------------------------------------------------------------------
+11 |   .filter: x =>  // error
+   |   ^
+   |   The start of this line does not match any of the previous indentation widths.
+   |   Indentation width of current line : 3 spaces
+   |   This falls between previous widths: 2 spaces and 6 spaces
+-- Error: tests/neg/outdent-dot.scala:13:4 -----------------------------------------------------------------------------
+13 |    println("foo")  // error
+   |    ^
+   |    The start of this line does not match any of the previous indentation widths.
+   |    Indentation width of current line : 4 spaces
+   |    This falls between previous widths: 2 spaces and 6 spaces
diff --git a/tests/neg/outdent-dot.scala b/tests/neg/outdent-dot.scala
new file mode 100644
index 000000000000..d0e882a3c073
--- /dev/null
+++ b/tests/neg/outdent-dot.scala
@@ -0,0 +1,13 @@
+def Block(f: => Int): Int = f
+
+def bar(): String =
+  Block:
+      2 + 2
+     .toString  // error
+
+def foo(xs: List[Int]) =
+  xs.map: x =>
+      x + 1
+   .filter: x =>  // error
+      x > 0
+    println("foo")  // error
diff --git a/tests/pos/outdent-dot.scala b/tests/pos/outdent-dot.scala
new file mode 100644
index 000000000000..c09bb673743a
--- /dev/null
+++ b/tests/pos/outdent-dot.scala
@@ -0,0 +1,13 @@
+def Block(f: => Int): Int = f
+
+def bar(): String =
+  Block:
+      2 + 2
+    .toString
+
+def foo(xs: List[Int]) =
+  xs.map: x =>
+      x + 1
+    .filter: x =>
+      x > 0
+    println("foo")

From 3b5b3c04fdf6bc1406c312ad29958ecd3717b102 Mon Sep 17 00:00:00 2001
From: Jamie Thompson <bishbashboshjt@gmail.com>
Date: Thu, 11 May 2023 09:50:08 +0200
Subject: [PATCH 558/657] revert extra-line

---
 scaladoc/resources/dotty_res/styles/theme/layout/container.css | 1 -
 1 file changed, 1 deletion(-)

diff --git a/scaladoc/resources/dotty_res/styles/theme/layout/container.css b/scaladoc/resources/dotty_res/styles/theme/layout/container.css
index 1d42c5529f00..53ede0e3dfff 100644
--- a/scaladoc/resources/dotty_res/styles/theme/layout/container.css
+++ b/scaladoc/resources/dotty_res/styles/theme/layout/container.css
@@ -24,7 +24,6 @@ p {
   height: auto;
 }
 
-
 /* Scrollbar */
 
 ::-webkit-scrollbar {

From 8fa7187be508f4ea328bf3be2488a110472d9f68 Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Thu, 11 May 2023 09:15:53 +0200
Subject: [PATCH 559/657] deps: update various sbt plugins

This updates the following:

- sbt-sonatype from 3.9.10 -> 3.9.20
- sbt-pgp (now under com.github.sbt) 2.0.0 -> 2.2.1
- sbt-buildinfo from 0.9.0 -> 0.11.0
- sbt-mima-plugin from 1.1.0 -> 1.1.2
---
 project/plugins.sbt | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/project/plugins.sbt b/project/plugins.sbt
index aba843ca2c3c..efc390ac93c5 100644
--- a/project/plugins.sbt
+++ b/project/plugins.sbt
@@ -8,14 +8,14 @@ libraryDependencySchemes +=
 
 addSbtPlugin("org.scala-js" % "sbt-scalajs" % "1.12.0")
 
-addSbtPlugin("org.xerial.sbt" % "sbt-sonatype" % "3.9.10")
+addSbtPlugin("org.xerial.sbt" % "sbt-sonatype" % "3.9.20")
 
-addSbtPlugin("com.jsuereth" % "sbt-pgp" % "2.0.0")
+addSbtPlugin("com.github.sbt" % "sbt-pgp" % "2.2.1")
 
 addSbtPlugin("org.xerial.sbt" % "sbt-pack" % "0.13")
 
 addSbtPlugin("pl.project13.scala" % "sbt-jmh" % "0.4.3")
 
-addSbtPlugin("com.eed3si9n" % "sbt-buildinfo" % "0.9.0")
+addSbtPlugin("com.eed3si9n" % "sbt-buildinfo" % "0.11.0")
 
-addSbtPlugin("com.typesafe" % "sbt-mima-plugin" % "1.1.0")
+addSbtPlugin("com.typesafe" % "sbt-mima-plugin" % "1.1.2")

From 07c395bb7d0b4239ab163e2b5c8f44febfcdb2c4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20Pa=C5=82ka?= <prolativus@gmail.com>
Date: Thu, 11 May 2023 13:26:45 +0200
Subject: [PATCH 560/657] * Preserve the more restrictive syntax for typed
 patterns in the language specification * Make the parser's warning a
 migration warning

---
 .../src/dotty/tools/dotc/parsing/Parsers.scala    | 15 +++++++++++++--
 .../test/dotty/tools/dotc/CompilationTests.scala  |  1 +
 docs/_docs/internals/syntax.md                    |  5 ++++-
 docs/_docs/reference/syntax.md                    |  5 ++++-
 tests/neg-custom-args/i10994.check                |  7 +++++++
 tests/neg-custom-args/i10994.scala                |  2 ++
 tests/neg/t5702-neg-bad-and-wild.check            |  5 ++++-
 tests/pos/i10994.scala                            |  2 +-
 8 files changed, 36 insertions(+), 6 deletions(-)
 create mode 100644 tests/neg-custom-args/i10994.check
 create mode 100644 tests/neg-custom-args/i10994.scala

diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 170332f7abe8..dfb9c5c6cb58 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -2871,14 +2871,25 @@ object Parsers {
       if (isIdent(nme.raw.BAR)) { in.nextToken(); pattern1(location) :: patternAlts(location) }
       else Nil
 
-    /**  Pattern1     ::= Pattern2 [Ascription]
+    /**  Pattern1     ::= PatVar Ascription
+     *                  | [‘-’] integerLiteral Ascription
+     *                  | [‘-’] floatingPointLiteral Ascription
+     *                  | Pattern2
      */
     def pattern1(location: Location = Location.InPattern): Tree =
       val p = pattern2()
       if in.isColon then
         val isVariableOrNumber = isVarPattern(p) || p.isInstanceOf[Number]
         if !isVariableOrNumber then
-          warning(em"Only variable and number literal patterns can have type ascriptions")
+          report.gradualErrorOrMigrationWarning(
+            em"""Type ascriptions after patterns other than:
+                |  * variable pattern, e.g. `case x: String =>`
+                |  * number literal pattern, e.g. `case 10.5: Double =>`
+                |are no longer supported. Remove the type ascription or move it to a separate variable pattern.""",
+            in.sourcePos(),
+            warnFrom = `3.3`,
+            errorFrom = future
+          )
         in.nextToken()
         ascription(p, location)
       else p
diff --git a/compiler/test/dotty/tools/dotc/CompilationTests.scala b/compiler/test/dotty/tools/dotc/CompilationTests.scala
index c782c78f8eb7..93bc2a5dd883 100644
--- a/compiler/test/dotty/tools/dotc/CompilationTests.scala
+++ b/compiler/test/dotty/tools/dotc/CompilationTests.scala
@@ -185,6 +185,7 @@ class CompilationTests {
       compileFile("tests/neg-custom-args/i13026.scala", defaultOptions.and("-print-lines")),
       compileFile("tests/neg-custom-args/i13838.scala", defaultOptions.and("-Ximplicit-search-limit", "1000")),
       compileFile("tests/neg-custom-args/jdk-9-app.scala", defaultOptions.and("-release:8")),
+      compileFile("tests/neg-custom-args/i10994.scala", defaultOptions.and("-source", "future")),
     ).checkExpectedErrors()
   }
 
diff --git a/docs/_docs/internals/syntax.md b/docs/_docs/internals/syntax.md
index e667a429afed..2817a7477b10 100644
--- a/docs/_docs/internals/syntax.md
+++ b/docs/_docs/internals/syntax.md
@@ -314,7 +314,10 @@ TypeCaseClauses   ::=  TypeCaseClause { TypeCaseClause }
 TypeCaseClause    ::=  ‘case’ (InfixType | ‘_’) ‘=>’ Type [semi]
 
 Pattern           ::=  Pattern1 { ‘|’ Pattern1 }                                Alternative(pats)
-Pattern1          ::=  Pattern2 [‘:’ RefinedType]                               Bind(name, Typed(Ident(wildcard), tpe))
+Pattern1          ::=  PatVar ‘:’ RefinedType                                   Bind(name, Typed(Ident(wildcard), tpe))
+                    |  [‘-’] integerLiteral ‘:’ RefinedType                     Typed(pat, tpe)
+                    |  [‘-’] floatingPointLiteral ‘:’ RefinedType               Typed(pat, tpe)
+                    |  Pattern2
 Pattern2          ::=  [id ‘@’] InfixPattern [‘*’]                              Bind(name, pat)
 InfixPattern      ::=  SimplePattern { id [nl] SimplePattern }                  InfixOp(pat, op, pat)
 SimplePattern     ::=  PatVar                                                   Ident(wildcard)
diff --git a/docs/_docs/reference/syntax.md b/docs/_docs/reference/syntax.md
index 28259d94afb4..a705c5a3fd79 100644
--- a/docs/_docs/reference/syntax.md
+++ b/docs/_docs/reference/syntax.md
@@ -312,7 +312,10 @@ TypeCaseClauses   ::=  TypeCaseClause { TypeCaseClause }
 TypeCaseClause    ::=  ‘case’ (InfixType | ‘_’) ‘=>’ Type [semi]
 
 Pattern           ::=  Pattern1 { ‘|’ Pattern1 }
-Pattern1          ::=  Pattern2 [‘:’ RefinedType]
+Pattern1          ::=  PatVar ‘:’ RefinedType
+                    |  [‘-’] integerLiteral ‘:’ RefinedType
+                    |  [‘-’] floatingPointLiteral ‘:’ RefinedType
+                    |  Pattern2
 Pattern2          ::=  [id ‘@’] InfixPattern [‘*’]
 InfixPattern      ::=  SimplePattern { id [nl] SimplePattern }
 SimplePattern     ::=  PatVar
diff --git a/tests/neg-custom-args/i10994.check b/tests/neg-custom-args/i10994.check
new file mode 100644
index 000000000000..c540a04657c3
--- /dev/null
+++ b/tests/neg-custom-args/i10994.check
@@ -0,0 +1,7 @@
+-- Error: tests/neg-custom-args/i10994.scala:2:19 ----------------------------------------------------------------------
+2 |  case (b: Boolean): Boolean => () // error
+  |                   ^
+  |                   Type ascriptions after patterns other than:
+  |                     * variable pattern, e.g. `case x: String =>`
+  |                     * number literal pattern, e.g. `case 10.5: Double =>`
+  |                   are no longer supported. Remove the type ascription or move it to a separate variable pattern.
diff --git a/tests/neg-custom-args/i10994.scala b/tests/neg-custom-args/i10994.scala
new file mode 100644
index 000000000000..65695ccf4352
--- /dev/null
+++ b/tests/neg-custom-args/i10994.scala
@@ -0,0 +1,2 @@
+def foo = true match
+  case (b: Boolean): Boolean => () // error
diff --git a/tests/neg/t5702-neg-bad-and-wild.check b/tests/neg/t5702-neg-bad-and-wild.check
index 36ac71b2e1e7..c461b76ea70b 100644
--- a/tests/neg/t5702-neg-bad-and-wild.check
+++ b/tests/neg/t5702-neg-bad-and-wild.check
@@ -59,7 +59,10 @@
 -- Warning: tests/neg/t5702-neg-bad-and-wild.scala:13:22 ---------------------------------------------------------------
 13 |      case List(1, _*3:) =>  // error // error
    |                      ^
-   |                      Only variable and number literal patterns can have type ascriptions
+   |                  Type ascriptions after patterns other than:
+   |                    * variable pattern, e.g. `case x: String =>`
+   |                    * number literal pattern, e.g. `case 10.5: Double =>`
+   |                  are no longer supported. Remove the type ascription or move it to a separate variable pattern.
 -- Warning: tests/neg/t5702-neg-bad-and-wild.scala:22:20 ---------------------------------------------------------------
 22 |    val K(x @ _*) = k
    |                    ^
diff --git a/tests/pos/i10994.scala b/tests/pos/i10994.scala
index 99ae647466b1..b7b6a3661649 100644
--- a/tests/pos/i10994.scala
+++ b/tests/pos/i10994.scala
@@ -1,2 +1,2 @@
 def foo = true match
-  case (b: Boolean): Boolean => ()
+  case (b: Boolean): Boolean => () // warning

From 0ee80f94a36bc523493fd9a8665d860e036537fd Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Fri, 5 May 2023 13:06:47 +0200
Subject: [PATCH 561/657] Place staged type captures in Quote AST

---
 .../dotty/tools/dotc/CompilationUnit.scala    |   2 +-
 .../src/dotty/tools/dotc/ast/Desugar.scala    |   2 +-
 compiler/src/dotty/tools/dotc/ast/Trees.scala |  21 ++-
 compiler/src/dotty/tools/dotc/ast/tpd.scala   |   4 +-
 compiler/src/dotty/tools/dotc/ast/untpd.scala |   2 +-
 .../src/dotty/tools/dotc/core/Phases.scala    |   4 +
 .../tools/dotc/core/tasty/TreePickler.scala   |   2 +-
 .../tools/dotc/core/tasty/TreeUnpickler.scala |   2 +-
 .../dotty/tools/dotc/inlines/Inliner.scala    |   2 +-
 .../dotty/tools/dotc/parsing/Parsers.scala    |   4 +-
 .../tools/dotc/printing/RefinedPrinter.scala  |   5 +-
 .../tools/dotc/staging/CrossStageSafety.scala |  80 +++++-----
 .../tools/dotc/staging/DirectTypeOf.scala     |  25 ----
 .../dotty/tools/dotc/staging/HealType.scala   |  12 +-
 .../tools/dotc/staging/QuoteTypeTags.scala    |  50 ++-----
 .../tools/dotc/transform/MegaPhase.scala      |   2 +-
 .../tools/dotc/transform/PickleQuotes.scala   | 137 ++++++++++++------
 .../tools/dotc/transform/ReifiedReflect.scala |   2 +-
 .../dotty/tools/dotc/transform/Splicer.scala  |  10 +-
 .../dotty/tools/dotc/transform/Splicing.scala |  89 ++++--------
 .../dotty/tools/dotc/transform/Staging.scala  |   2 +-
 .../tools/dotc/transform/TreeChecker.scala    |  30 ++++
 .../tools/dotc/transform/patmat/Space.scala   |   2 +-
 .../tools/dotc/typer/QuotesAndSplices.scala   |   6 +-
 .../src/dotty/tools/dotc/typer/ReTyper.scala  |   3 +-
 25 files changed, 249 insertions(+), 251 deletions(-)
 delete mode 100644 compiler/src/dotty/tools/dotc/staging/DirectTypeOf.scala

diff --git a/compiler/src/dotty/tools/dotc/CompilationUnit.scala b/compiler/src/dotty/tools/dotc/CompilationUnit.scala
index 8e4989f13c3d..8415646eb16c 100644
--- a/compiler/src/dotty/tools/dotc/CompilationUnit.scala
+++ b/compiler/src/dotty/tools/dotc/CompilationUnit.scala
@@ -157,7 +157,7 @@ object CompilationUnit {
       if tree.symbol.is(Flags.Inline) then
         containsInline = true
       tree match
-        case tpd.Quote(_) =>
+        case _: tpd.Quote =>
           containsQuote = true
         case tree: tpd.Apply if tree.symbol == defn.QuotedTypeModule_of =>
           containsQuote = true
diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index e658a3e9a142..8a080972fb31 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -1976,7 +1976,7 @@ object desugar {
         trees foreach collect
       case Block(Nil, expr) =>
         collect(expr)
-      case Quote(body) =>
+      case Quote(body, _) =>
         new UntypedTreeTraverser {
           def traverse(tree: untpd.Tree)(using Context): Unit = tree match {
             case Splice(expr) => collect(expr)
diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala
index 61009f48a8f0..f4c3240c03bd 100644
--- a/compiler/src/dotty/tools/dotc/ast/Trees.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala
@@ -690,9 +690,14 @@ object Trees {
    *  when type checking. TASTy files will not contain type quotes. Type quotes are used again
    *  in the `staging` phase to represent the reification of `Type.of[T]]`.
    *
+   *  Type tags `tags` are always empty before the `staging` phase. Tags for stage inconsistent
+   *  types are added in the `staging` phase to level 0 quotes. Tags for types that refer to
+   *  definitions in an outer quote are added in the `splicing` phase
+   *
    *  @param  body  The tree that was quoted
+   *  @param  tags  Term references to instances of `Type[T]` for `T`s that are used in the quote
    */
-  case class Quote[+T <: Untyped] private[ast] (body: Tree[T])(implicit @constructorOnly src: SourceFile)
+  case class Quote[+T <: Untyped] private[ast] (body: Tree[T], tags: List[Tree[T]])(implicit @constructorOnly src: SourceFile)
     extends TermTree[T] {
     type ThisTree[+T <: Untyped] = Quote[T]
 
@@ -1313,9 +1318,9 @@ object Trees {
         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 Quote(tree: Tree)(body: Tree)(using Context): Quote = tree match {
-        case tree: Quote if (body eq tree.body) => tree
-        case _ => finalize(tree, untpd.Quote(body)(sourceFile(tree)))
+      def Quote(tree: Tree)(body: Tree, tags: List[Tree])(using Context): Quote = tree match {
+        case tree: Quote if (body eq tree.body) && (tags eq tree.tags) => tree
+        case _ => finalize(tree, untpd.Quote(body, tags)(sourceFile(tree)))
       }
       def Splice(tree: Tree)(expr: Tree)(using Context): Splice = tree match {
         case tree: Splice if (expr eq tree.expr) => tree
@@ -1558,8 +1563,8 @@ object Trees {
             case Thicket(trees) =>
               val trees1 = transform(trees)
               if (trees1 eq trees) tree else Thicket(trees1)
-            case tree @ Quote(body) =>
-              cpy.Quote(tree)(transform(body)(using quoteContext))
+            case Quote(body, tags) =>
+              cpy.Quote(tree)(transform(body)(using quoteContext), transform(tags))
             case tree @ Splice(expr) =>
               cpy.Splice(tree)(transform(expr)(using spliceContext))
             case tree @ Hole(isTerm, idx, args, content, tpt) =>
@@ -1703,8 +1708,8 @@ object Trees {
               this(this(x, arg), annot)
             case Thicket(ts) =>
               this(x, ts)
-            case Quote(body) =>
-              this(x, body)(using quoteContext)
+            case Quote(body, tags) =>
+              this(this(x, body)(using quoteContext), tags)
             case Splice(expr) =>
               this(x, expr)(using spliceContext)
             case Hole(_, _, args, content, tpt) =>
diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
index d26735bdeb05..503c1a0b1b39 100644
--- a/compiler/src/dotty/tools/dotc/ast/tpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -170,8 +170,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def Inlined(call: Tree, bindings: List[MemberDef], expansion: Tree)(using Context): Inlined =
     ta.assignType(untpd.Inlined(call, bindings, expansion), bindings, expansion)
 
-  def Quote(body: Tree)(using Context): Quote =
-    untpd.Quote(body).withBodyType(body.tpe)
+  def Quote(body: Tree, tags: List[Tree])(using Context): Quote =
+    untpd.Quote(body, tags).withBodyType(body.tpe)
 
   def Splice(expr: Tree, tpe: Type)(using Context): Splice =
     untpd.Splice(expr).withType(tpe)
diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
index dbac7ceaaf05..479d85f6e383 100644
--- a/compiler/src/dotty/tools/dotc/ast/untpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -397,7 +397,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   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 Quote(body: Tree)(implicit src: SourceFile): Quote = new Quote(body)
+  def Quote(body: Tree, tags: List[Tree])(implicit src: SourceFile): Quote = new Quote(body, tags)
   def Splice(expr: Tree)(implicit src: SourceFile): Splice = new Splice(expr)
   def TypeTree()(implicit src: SourceFile): TypeTree = new TypeTree()
   def InferredTypeTree()(implicit src: SourceFile): TypeTree = new InferredTypeTree()
diff --git a/compiler/src/dotty/tools/dotc/core/Phases.scala b/compiler/src/dotty/tools/dotc/core/Phases.scala
index 00e017430a5f..3c4c45ab254a 100644
--- a/compiler/src/dotty/tools/dotc/core/Phases.scala
+++ b/compiler/src/dotty/tools/dotc/core/Phases.scala
@@ -211,6 +211,7 @@ object Phases {
     private var mySbtExtractDependenciesPhase: Phase = _
     private var myPicklerPhase: Phase = _
     private var myInliningPhase: Phase = _
+    private var myStagingPhase: Phase = _
     private var mySplicingPhase: Phase = _
     private var myFirstTransformPhase: Phase = _
     private var myCollectNullableFieldsPhase: Phase = _
@@ -235,6 +236,7 @@ object Phases {
     final def sbtExtractDependenciesPhase: Phase = mySbtExtractDependenciesPhase
     final def picklerPhase: Phase = myPicklerPhase
     final def inliningPhase: Phase = myInliningPhase
+    final def stagingPhase: Phase = myStagingPhase
     final def splicingPhase: Phase = mySplicingPhase
     final def firstTransformPhase: Phase = myFirstTransformPhase
     final def collectNullableFieldsPhase: Phase = myCollectNullableFieldsPhase
@@ -262,6 +264,7 @@ object Phases {
       mySbtExtractDependenciesPhase = phaseOfClass(classOf[sbt.ExtractDependencies])
       myPicklerPhase = phaseOfClass(classOf[Pickler])
       myInliningPhase = phaseOfClass(classOf[Inlining])
+      myStagingPhase = phaseOfClass(classOf[Staging])
       mySplicingPhase = phaseOfClass(classOf[Splicing])
       myFirstTransformPhase = phaseOfClass(classOf[FirstTransform])
       myCollectNullableFieldsPhase = phaseOfClass(classOf[CollectNullableFields])
@@ -449,6 +452,7 @@ object Phases {
   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 stagingPhase(using Context): Phase               = ctx.base.stagingPhase
   def splicingPhase(using Context): Phase               = ctx.base.splicingPhase
   def firstTransformPhase(using Context): Phase         = ctx.base.firstTransformPhase
   def refchecksPhase(using Context): Phase              = ctx.base.refchecksPhase
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
index 5662b17b6697..898ef2ed0c6c 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -665,7 +665,7 @@ class TreePickler(pickler: TastyPickler) {
               pickleTree(hi)
               pickleTree(alias)
           }
-        case tree @ Quote(body) =>
+        case tree @ Quote(body, Nil) =>
           // TODO: Add QUOTE tag to TASTy
           assert(body.isTerm,
             """Quote with type should not be pickled.
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
index 10395a488640..659d96a386ea 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
@@ -1269,7 +1269,7 @@ class TreeUnpickler(reader: TastyReader,
 
       def quotedExpr(fn: Tree, args: List[Tree]): Tree =
         val TypeApply(_, targs) = fn: @unchecked
-        untpd.Quote(args.head).withBodyType(targs.head.tpe)
+        untpd.Quote(args.head, Nil).withBodyType(targs.head.tpe)
 
       def splicedExpr(fn: Tree, args: List[Tree]): Tree =
         val TypeApply(_, targs) = fn: @unchecked
diff --git a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
index ccef777380e1..54decf137b42 100644
--- a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
@@ -827,7 +827,7 @@ class Inliner(val call: tpd.Tree)(using Context):
 
     override def typedQuote(tree: untpd.Quote, pt: Type)(using Context): Tree =
       super.typedQuote(tree, pt) match
-        case Quote(Splice(inner)) => inner
+        case Quote(Splice(inner), _) => inner
         case tree1 =>
           ctx.compilationUnit.needsStaging = true
           tree1
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 8d13bdeed68f..2a496b03e652 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -1243,7 +1243,7 @@ object Parsers {
               }
             }
             in.nextToken()
-            Quote(t)
+            Quote(t, Nil)
           }
           else
             if !in.featureEnabled(Feature.symbolLiterals) then
@@ -2480,7 +2480,7 @@ object Parsers {
               val body =
                 if (in.token == LBRACKET) inBrackets(typ())
                 else stagedBlock()
-              Quote(body)
+              Quote(body, Nil)
             }
           }
         case NEW =>
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index 75085469b7d2..47dac083cfce 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -726,11 +726,12 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         "Thicket {" ~~ toTextGlobal(trees, "\n") ~~ "}"
       case MacroTree(call) =>
         keywordStr("macro ") ~ toTextGlobal(call)
-      case tree @ Quote(body) =>
+      case tree @ Quote(body, tags) =>
+        val tagsText = (keywordStr("<") ~ toTextGlobal(tags, ", ") ~ keywordStr(">")).provided(tree.tags.nonEmpty)
         val exprTypeText = (keywordStr("[") ~ toTextGlobal(tree.bodyType) ~ keywordStr("]")).provided(printDebug && tree.typeOpt.exists)
         val open = if (body.isTerm) keywordStr("{") else keywordStr("[")
         val close = if (body.isTerm) keywordStr("}") else keywordStr("]")
-        keywordStr("'") ~ exprTypeText ~ open ~ toTextGlobal(body) ~ close
+        keywordStr("'") ~ tagsText ~ exprTypeText ~ open ~ toTextGlobal(body) ~ close
       case Splice(expr) =>
         val spliceTypeText = (keywordStr("[") ~ toTextGlobal(tree.typeOpt) ~ keywordStr("]")).provided(printDebug && tree.typeOpt.exists)
         keywordStr("$") ~ spliceTypeText ~ keywordStr("{") ~ toTextGlobal(expr) ~ keywordStr("}")
diff --git a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
index feb93c3c6319..8360d8e08211 100644
--- a/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
+++ b/compiler/src/dotty/tools/dotc/staging/CrossStageSafety.scala
@@ -16,28 +16,36 @@ import dotty.tools.dotc.util.Property
 import dotty.tools.dotc.util.Spans._
 import dotty.tools.dotc.util.SrcPos
 
-/** Checks that staging level consistency holds and heals staged types .
+/** 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`.
+ *  Healing a type consists in replacing locally defined types defined at staging level 0 and used in higher levels.
+ *  For each type local `T` that is defined at level 0 and used in a quote, we summon a tag `t: Type[T]`. This `t`
+ *  tag must be defined at level 0. The tags will be listed in the `tags` of the level 0 quote (`'<t>{ ... }`) and
+ *  each reference to `T` will be replaced by `t.Underlying` in the body of the quote.
+ *
+ *  We delay the healing of types in quotes at level 1 or higher until those quotes reach level 0. At this point
+ *  more types will be statically known and fewer types will need to be healed. This also keeps the nested quotes
+ *  in their original form, we do not want macro users to see any artifacts of this phase in quoted expressions
+ *  they might inspect.
+ *
+ *  Type heal example:
  *
- *  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]()
+ *      '{ .. T .. }
  *      ()
  *    }
  *
  *  is transformed to
  *
- *    '{
- *      type t$1 = summon[Type[T]].Underlying
- *      val x: List[t$1] = List[t$1]();
+ *    '<t>{ // where `t` is a given term of type `Type[T]`
+ *      val x: List[t.Underlying] = List[t.Underlying]();
+ *      '{ .. t.Underlying .. }
  *      ()
  *     }
  *
@@ -56,11 +64,18 @@ class CrossStageSafety extends TreeMapWithStages {
       case tree: Quote =>
         if (ctx.property(InAnnotation).isDefined)
           report.error("Cannot have a quote in an annotation", tree.srcPos)
-        val body1 = transformQuoteBody(tree.body, tree.span)
-        val stripAnnotationsDeep: TypeMap = new TypeMap:
-          def apply(tp: Type): Type = mapOver(tp.stripAnnots)
-        val bodyType1 = healType(tree.srcPos)(stripAnnotationsDeep(tree.bodyType))
-        cpy.Quote(tree)(body1).withBodyType(bodyType1)
+
+        val tree1 =
+          val stripAnnotationsDeep: TypeMap = new TypeMap:
+            def apply(tp: Type): Type = mapOver(tp.stripAnnots)
+          val bodyType1 = healType(tree.srcPos)(stripAnnotationsDeep(tree.bodyType))
+          tree.withBodyType(bodyType1)
+
+        if level == 0 then
+          val (tags, body1) = inContextWithQuoteTypeTags { transform(tree1.body)(using quoteContext) }
+          cpy.Quote(tree1)(body1, tags)
+        else
+          super.transform(tree1)
 
       case CancelledSplice(tree) =>
         transform(tree) // Optimization: `${ 'x }` --> `x`
@@ -74,22 +89,18 @@ class CrossStageSafety extends TreeMapWithStages {
       case tree @ QuotedTypeOf(body) =>
         if (ctx.property(InAnnotation).isDefined)
           report.error("Cannot have a quote in an annotation", tree.srcPos)
-        body.tpe match
-          case DirectTypeOf(termRef) =>
-            // Optimization: `quoted.Type.of[x.Underlying](quotes)`  -->  `x`
-            ref(termRef).withSpan(tree.span)
-          case _ =>
-            transformQuoteBody(body, tree.span) match
-              case DirectTypeOf.Healed(termRef) =>
-                // Optimization: `quoted.Type.of[@SplicedType type T = x.Underlying; T](quotes)`  -->  `x`
-                ref(termRef).withSpan(tree.span)
-              case transformedBody =>
-                val quotes = transform(tree.args.head)
-                // `quoted.Type.of[<body>](quotes)`  --> `quoted.Type.of[<body2>](quotes)`
-                val TypeApply(fun, _) = tree.fun: @unchecked
-                if level != 0 then cpy.Apply(tree)(cpy.TypeApply(tree.fun)(fun, transformedBody :: Nil), quotes :: Nil)
-                else tpd.Quote(transformedBody).select(nme.apply).appliedTo(quotes).withSpan(tree.span)
 
+        if level == 0 then
+          val (tags, body1) = inContextWithQuoteTypeTags { transform(body)(using quoteContext) }
+          val quotes = transform(tree.args.head)
+          tags match
+            case tag :: Nil if body1.isType && body1.tpe =:= tag.tpe.select(tpnme.Underlying) =>
+              tag // Optimization: `quoted.Type.of[x.Underlying](quotes)`  -->  `x`
+            case _ =>
+              // `quoted.Type.of[<body>](<quotes>)` --> `'[<body1>].apply(<quotes>)`
+              tpd.Quote(body1, tags).select(nme.apply).appliedTo(quotes).withSpan(tree.span)
+        else
+          super.transform(tree)
       case _: DefDef if tree.symbol.isInlineMethod =>
         tree
 
@@ -137,17 +148,6 @@ class CrossStageSafety extends TreeMapWithStages {
         super.transform(tree)
   end transform
 
-  private def transformQuoteBody(body: Tree, span: Span)(using Context): Tree = {
-    val taggedTypes = new QuoteTypeTags(span)
-    val contextWithQuote =
-      if level == 0 then contextWithQuoteTypeTags(taggedTypes)(using quoteContext)
-      else quoteContext
-    val transformedBody = transform(body)(using contextWithQuote)
-    taggedTypes.getTypeTags match
-      case Nil  => transformedBody
-      case tags => tpd.Block(tags, transformedBody).withSpan(body.span)
-  }
-
   def transformTypeAnnotationSplices(tp: Type)(using Context) = new TypeMap {
     def apply(tp: Type): Type = tp match
       case tp: AnnotatedType =>
@@ -234,7 +234,7 @@ class CrossStageSafety extends TreeMapWithStages {
     def unapply(tree: Splice): Option[Tree] =
       def rec(tree: Tree): Option[Tree] = tree match
         case Block(Nil, expr) => rec(expr)
-        case Quote(inner) => Some(inner)
+        case Quote(inner, _) => Some(inner)
         case _ => None
       rec(tree.expr)
 }
diff --git a/compiler/src/dotty/tools/dotc/staging/DirectTypeOf.scala b/compiler/src/dotty/tools/dotc/staging/DirectTypeOf.scala
deleted file mode 100644
index 488d8ff2a88e..000000000000
--- a/compiler/src/dotty/tools/dotc/staging/DirectTypeOf.scala
+++ /dev/null
@@ -1,25 +0,0 @@
-package dotty.tools.dotc.staging
-
-import dotty.tools.dotc.ast.{tpd, untpd}
-import dotty.tools.dotc.core.Contexts._
-import dotty.tools.dotc.core.Symbols._
-import dotty.tools.dotc.core.Types._
-
-object DirectTypeOf:
-  import tpd.*
-
-  /** Matches `x.Underlying` and extracts the TermRef to `x` */
-  def unapply(tpe: Type)(using Context): Option[TermRef] = tpe match
-    case tp @ TypeRef(x: TermRef, _) if tp.symbol == defn.QuotedType_splice => Some(x)
-    case _ => None
-
-  object Healed:
-    /** Matches `{ @SplicedType type T = x.Underlying; T }` and extracts the TermRef to `x` */
-    def unapply(body: Tree)(using Context): Option[TermRef] =
-      body match
-        case Block(List(tdef: TypeDef), tpt: TypeTree) =>
-          tpt.tpe match
-            case tpe: TypeRef if tpe.typeSymbol == tdef.symbol =>
-              DirectTypeOf.unapply(tdef.rhs.tpe.hiBound)
-            case _ => None
-        case _ => None
diff --git a/compiler/src/dotty/tools/dotc/staging/HealType.scala b/compiler/src/dotty/tools/dotc/staging/HealType.scala
index 2facb64746b3..023271960b40 100644
--- a/compiler/src/dotty/tools/dotc/staging/HealType.scala
+++ b/compiler/src/dotty/tools/dotc/staging/HealType.scala
@@ -25,7 +25,7 @@ class HealType(pos: SrcPos)(using Context) extends TypeMap {
    *
    *  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
+   *  The tag is recorded by an instance of `QuoteTypeTags` directly if the splice is explicit
    *  or indirectly by `tryHeal`.
    */
   def apply(tp: Type): Type =
@@ -43,11 +43,9 @@ class HealType(pos: SrcPos)(using Context) extends TypeMap {
 
   private def healTypeRef(tp: TypeRef): Type =
     tp.prefix match
-      case NoPrefix if tp.typeSymbol.hasAnnotation(defn.QuotedRuntime_SplicedTypeAnnot) =>
-        tp
       case prefix: TermRef if tp.symbol.isTypeSplice =>
         checkNotWildcardSplice(tp)
-        if level == 0 then tp else getQuoteTypeTags.getTagRef(prefix)
+        if level == 0 then tp else getTagRef(prefix)
       case _: NamedType | _: ThisType | NoPrefix =>
         if levelInconsistentRootOfPath(tp).exists then
           tryHeal(tp)
@@ -58,7 +56,7 @@ class HealType(pos: SrcPos)(using Context) extends TypeMap {
 
   private object NonSpliceAlias:
     def unapply(tp: TypeRef)(using Context): Option[Type] = tp.underlying match
-      case TypeAlias(alias) if !tp.symbol.isTypeSplice && !tp.typeSymbol.hasAnnotation(defn.QuotedRuntime_SplicedTypeAnnot) => Some(alias)
+      case TypeAlias(alias) if !tp.symbol.isTypeSplice => Some(alias)
       case _ => None
 
   private def checkNotWildcardSplice(splice: TypeRef): Unit =
@@ -78,7 +76,7 @@ class HealType(pos: SrcPos)(using Context) extends TypeMap {
 
   /** 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]]}`.
+   *  reference to a type alias containing the equivalent of `${summon[quoted.Type[T]]}.Underlying`.
    *  Emits an error if `T` cannot be healed and returns `T`.
    */
   protected def tryHeal(tp: TypeRef): Type = {
@@ -88,7 +86,7 @@ class HealType(pos: SrcPos)(using Context) extends TypeMap {
       case tp: TermRef =>
         ctx.typer.checkStable(tp, pos, "type witness")
         if levelOf(tp.symbol) > 0 then tp.select(tpnme.Underlying)
-        else getQuoteTypeTags.getTagRef(tp)
+        else getTagRef(tp)
       case _: SearchFailureType =>
         report.error(
           ctx.typer.missingArgMsg(tag, reqType, "")
diff --git a/compiler/src/dotty/tools/dotc/staging/QuoteTypeTags.scala b/compiler/src/dotty/tools/dotc/staging/QuoteTypeTags.scala
index d6f0a6576085..0b5032ea5a6d 100644
--- a/compiler/src/dotty/tools/dotc/staging/QuoteTypeTags.scala
+++ b/compiler/src/dotty/tools/dotc/staging/QuoteTypeTags.scala
@@ -1,52 +1,24 @@
 package dotty.tools.dotc.staging
 
-import dotty.tools.dotc.ast.{tpd, untpd}
-import dotty.tools.dotc.core.Annotations._
+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._
 import dotty.tools.dotc.core.StdNames._
-import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.Types._
 import dotty.tools.dotc.staging.StagingLevel.*
 import dotty.tools.dotc.util.Property
-import dotty.tools.dotc.util.Spans._
 
-object QuoteTypeTags {
+import scala.collection.mutable.LinkedHashSet
 
-  private val TaggedTypes = new Property.Key[QuoteTypeTags]
+object QuoteTypeTags:
 
-  def contextWithQuoteTypeTags(taggedTypes: QuoteTypeTags)(using Context) =
-    ctx.fresh.setProperty(TaggedTypes, taggedTypes)
+  private val TaggedTypes = new Property.Key[LinkedHashSet[TermRef]]
 
-  def getQuoteTypeTags(using Context): QuoteTypeTags =
-    ctx.property(TaggedTypes).get
-}
+  def inContextWithQuoteTypeTags(body: Context ?=> tpd.Tree)(using Context): (List[tpd.Tree], tpd.Tree) =
+    val tags = LinkedHashSet.empty[TermRef]
+    val transformed = body(using ctx.fresh.setProperty(TaggedTypes, tags))
+    (tags.toList.map(tpd.ref(_)), transformed)
 
-class QuoteTypeTags(span: Span)(using Context) {
-  import tpd.*
-
-  private val tags = collection.mutable.LinkedHashMap.empty[TermRef, TypeDef]
-
-  def getTagRef(spliced: TermRef): TypeRef = {
-    val typeDef = tags.getOrElseUpdate(spliced, 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(rhs.tpe.dealias.typeSymbol.name.toTypeName),
-      flags = Synthetic,
-      info = TypeAlias(splicedTree.tpe.select(tpnme.Underlying)),
-      coord = span).asType
-    local.addAnnotation(Annotation(defn.QuotedRuntime_SplicedTypeAnnot, span))
-    ctx.typeAssigner.assignType(untpd.TypeDef(local.name, alias), local)
-  }
-}
+  def getTagRef(spliced: TermRef)(using Context): Type =
+    ctx.property(TaggedTypes).get += spliced
+    spliced.select(tpnme.Underlying)
diff --git a/compiler/src/dotty/tools/dotc/transform/MegaPhase.scala b/compiler/src/dotty/tools/dotc/transform/MegaPhase.scala
index 7ad109b67751..b4e8c3acbc5c 100644
--- a/compiler/src/dotty/tools/dotc/transform/MegaPhase.scala
+++ b/compiler/src/dotty/tools/dotc/transform/MegaPhase.scala
@@ -402,7 +402,7 @@ class MegaPhase(val miniPhases: Array[MiniPhase]) extends Phase {
       case tree: Quote =>
         inContext(prepQuote(tree, start)(using outerCtx)) {
           val body = transformTree(tree.body, start)(using quoteContext)
-          goQuote(cpy.Quote(tree)(body), start)
+          goQuote(cpy.Quote(tree)(body, Nil), start)
         }
       case tree: Splice =>
         inContext(prepSplice(tree, start)(using outerCtx)) {
diff --git a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
index 581b320ed9df..98bca65093fa 100644
--- a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
@@ -9,6 +9,7 @@ import Contexts._
 import Symbols._
 import Constants._
 import ast.Trees._
+import ast.untpd
 import ast.TreeTypeMap
 import SymUtils._
 import NameKinds._
@@ -27,9 +28,7 @@ import scala.annotation.constructorOnly
  *
  *  Transforms top level quote
  *   ```
- *   '{ ...
- *      @TypeSplice type X0 = {{ 0 | .. | contentsTpe0 | .. }}
- *      @TypeSplice type X2 = {{ 1 | .. | contentsTpe1 | .. }}
+ *   '<a,b>{ ...
  *      val x1: U1 = ???
  *      val x2: U2 = ???
  *      ...
@@ -45,22 +44,19 @@ import scala.annotation.constructorOnly
  *    ```
  *     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
+ *         @TypeSplice type A // with bounds that do not contain captured types
+ *         @TypeSplice type B // 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
+ *         {{{ 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
- *       },
+ *       typeHole = Seq(a, b),
  *       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
@@ -87,9 +83,6 @@ class PickleQuotes extends MacroTransform {
         assert(Inlines.inInlineMethod)
       case tree: Splice =>
         assert(Inlines.inInlineMethod)
-      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 =
@@ -100,7 +93,9 @@ class PickleQuotes extends MacroTransform {
       tree match
         case Apply(Select(quote: Quote, nme.apply), List(quotes)) =>
           val (contents, quote1) = makeHoles(quote)
-          val pickled = PickleQuotes.pickle(quote1, quotes, contents)
+          val quote2 = encodeTypeArgs(quote1)
+          val contents1 = contents ::: quote.tags
+          val pickled = PickleQuotes.pickle(quote2, quotes, contents1)
           transform(pickled) // pickle quotes that are in the contents
         case tree: DefDef if !tree.rhs.isEmpty && tree.symbol.isInlineMethod =>
           tree
@@ -114,12 +109,12 @@ class PickleQuotes extends MacroTransform {
       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)
+            assert(isTerm)
+            assert(!content.isEmpty)
+            contents += content
+            val holeType = getTermHoleType(tree.tpe)
             val hole = cpy.Hole(tree)(content = EmptyTree, TypeTree(holeType))
-            if isTerm then Inlined(EmptyTree, Nil, hole).withSpan(tree.span) else hole
+            cpy.Inlined(tree)(EmptyTree, Nil, hole)
           case tree: DefTree =>
             val newAnnotations = tree.symbol.annotations.mapconserve { annot =>
               annot.derivedAnnotation(transform(annot.tree)(using ctx.withOwner(tree.symbol)))
@@ -139,25 +134,6 @@ class PickleQuotes extends MacroTransform {
         }
       }
 
-      /** 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 isLocalPath(pre) =>
-            val hiBound = tp.typeSymbol.info match
-              case info: ClassInfo => info.parents.reduce(_ & _)
-              case info => info.hiBound
-            apply(hiBound)
-          case tp =>
-            mapOver(tp)
-
-        private def isLocalPath(tp: Type): Boolean = tp match
-          case NoPrefix => true
-          case tp: TermRef if !tp.symbol.is(Package) => isLocalPath(tp.prefix)
-          case tp => false
-      }
-
       /** 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
@@ -180,14 +156,78 @@ class PickleQuotes extends MacroTransform {
 
     val holeMaker = new HoleContentExtractor
     val body1 = holeMaker.transform(quote.body)
-    val body2 =
-      if quote.isTypeQuote then body1
-      else Inlined(Inlines.inlineCallTrace(ctx.owner, quote.sourcePos), Nil, body1)
-    val quote1 = cpy.Quote(quote)(body2)
+    val quote1 = cpy.Quote(quote)(body1, quote.tags)
 
     (holeMaker.getContents(), quote1)
   end makeHoles
 
+  /** Encode quote tags as holes in the quote body.
+   *
+   *  ```scala
+   *    '<t, u>{ ... t.Underlying ... u.Underlying ... }
+   *  ```
+   *  becomes
+   * ```scala
+   *  '<t, u>{
+   *    type T = {{ 0 | .. | .. | .. }}
+   *    type U = {{ 1 | .. | .. | .. }}
+   *    ... T ... U ...
+   *  }
+   * ```
+   */
+  private def encodeTypeArgs(quote: tpd.Quote)(using Context): tpd.Quote =
+    if quote.tags.isEmpty then quote
+    else
+      val tdefs = quote.tags.zipWithIndex.map(mkTagSymbolAndAssignType)
+      val typeMapping = quote.tags.map(_.tpe).zip(tdefs.map(_.symbol.typeRef)).toMap
+      val typeMap = new TypeMap {
+        override def apply(tp: Type): Type = tp match
+          case TypeRef(tag: TermRef, _) if tp.typeSymbol == defn.QuotedType_splice =>
+            typeMapping.getOrElse(tag, tp)
+          case _ => mapOver(tp)
+      }
+      def treeMap(tree: Tree): Tree = tree match
+          case Select(qual, _) if tree.symbol == defn.QuotedType_splice =>
+            typeMapping.get(qual.tpe) match
+              case Some(tag) => TypeTree(tag).withSpan(tree.span)
+              case None => tree
+          case _ => tree
+      val body1 = new TreeTypeMap(typeMap, treeMap).transform(quote.body)
+      cpy.Quote(quote)(Block(tdefs, body1), quote.tags)
+
+  private def mkTagSymbolAndAssignType(typeArg: Tree, idx: Int)(using Context): TypeDef = {
+    val holeType = getTypeHoleType(typeArg.tpe.select(tpnme.Underlying))
+    val hole = cpy.Hole(typeArg)(isTerm = false, idx, Nil, EmptyTree, TypeTree(holeType))
+    val local = newSymbol(
+      owner = ctx.owner,
+      name = UniqueName.fresh(hole.tpe.dealias.typeSymbol.name.toTypeName),
+      flags = Synthetic,
+      info = TypeAlias(typeArg.tpe.select(tpnme.Underlying)),
+      coord = typeArg.span
+    ).asType
+    local.addAnnotation(Annotation(defn.QuotedRuntime_SplicedTypeAnnot, typeArg.span))
+    ctx.typeAssigner.assignType(untpd.TypeDef(local.name, hole), local).withSpan(typeArg.span)
+  }
+
+  /** 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 isLocalPath(pre) =>
+        val hiBound = tp.typeSymbol.info match
+          case info: ClassInfo => info.parents.reduce(_ & _)
+          case info => info.hiBound
+        apply(hiBound)
+      case tp =>
+        mapOver(tp)
+
+    private def isLocalPath(tp: Type): Boolean = tp match
+      case NoPrefix => true
+      case tp: TermRef if !tp.symbol.is(Package) => isLocalPath(tp.prefix)
+      case tp => false
+  }
+
 }
 
 object PickleQuotes {
@@ -286,7 +326,10 @@ object PickleQuotes {
       *  this closure is always applied directly to the actual context and the BetaReduce phase removes it.
       */
     def pickleAsTasty() = {
-      val pickleQuote = PickledQuotes.pickleQuote(body)
+      val body1 =
+        if body.isType then body
+        else Inlined(Inlines.inlineCallTrace(ctx.owner, quote.sourcePos), Nil, body)
+      val pickleQuote = PickledQuotes.pickleQuote(body1)
       val pickledQuoteStrings = pickleQuote match
         case x :: Nil => Literal(Constant(x))
         case xs => tpd.mkList(xs.map(x => Literal(Constant(x))), TypeTree(defn.StringType))
diff --git a/compiler/src/dotty/tools/dotc/transform/ReifiedReflect.scala b/compiler/src/dotty/tools/dotc/transform/ReifiedReflect.scala
index bd0c063cd21a..6e73d683fa2c 100644
--- a/compiler/src/dotty/tools/dotc/transform/ReifiedReflect.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ReifiedReflect.scala
@@ -75,7 +75,7 @@ trait ReifiedReflect:
       .select(defn.Quotes_reflect_TypeRepr_of)
       .appliedToType(tpe)
       .appliedTo(
-        tpd.Quote(TypeTree(tpe))
+        tpd.Quote(TypeTree(tpe), Nil)
           .select(nme.apply)
           .appliedTo(quotesTree)
       )
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicer.scala b/compiler/src/dotty/tools/dotc/transform/Splicer.scala
index 8f45fd94d205..741c770e2c77 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicer.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicer.scala
@@ -44,7 +44,7 @@ object Splicer {
    *  See: `Staging`
    */
   def splice(tree: Tree, splicePos: SrcPos, spliceExpansionPos: SrcPos, classLoader: ClassLoader)(using Context): Tree = tree match {
-    case Quote(quotedTree) => quotedTree
+    case Quote(quotedTree, Nil) => quotedTree
     case _ =>
       val macroOwner = newSymbol(ctx.owner, nme.MACROkw, Macro | Synthetic, defn.AnyType, coord = tree.span)
       try
@@ -136,7 +136,7 @@ object Splicer {
     *  See: `Staging`
     */
   def checkValidMacroBody(tree: Tree)(using Context): Unit = tree match {
-    case Quote(_) => // ok
+    case Quote(_, Nil) => // ok
     case _ =>
       type Env = Set[Symbol]
 
@@ -155,7 +155,7 @@ object Splicer {
         case Block(Nil, expr) => checkIfValidArgument(expr)
         case Typed(expr, _) => checkIfValidArgument(expr)
 
-        case Apply(Select(Quote(body), nme.apply), _) =>
+        case Apply(Select(Quote(body, _), nme.apply), _) =>
           val noSpliceChecker = new TreeTraverser {
             def traverse(tree: Tree)(using Context): Unit = tree match
               case Splice(_) =>
@@ -203,7 +203,7 @@ object Splicer {
         case Typed(expr, _) =>
           checkIfValidStaticCall(expr)
 
-        case Apply(Select(Quote(quoted), nme.apply), _) =>
+        case Apply(Select(Quote(quoted, Nil), nme.apply), _) =>
           // OK, canceled and warning emitted
 
         case Call(fn, args)
@@ -240,7 +240,7 @@ object Splicer {
 
     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(Quote(body), nme.apply), _) =>
+      case Apply(Select(Quote(body, _), nme.apply), _) =>
         val body1 = body match {
           case expr: Ident if expr.symbol.isAllOf(InlineByNameProxy) =>
             // inline proxy for by-name parameter
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicing.scala b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
index b482e9311c74..bf7eb2dedb7d 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicing.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
@@ -23,6 +23,7 @@ import dotty.tools.dotc.quoted._
 import dotty.tools.dotc.config.ScalaRelease.*
 import dotty.tools.dotc.staging.StagingLevel.*
 import dotty.tools.dotc.staging.QuoteTypeTags
+import dotty.tools.dotc.staging.QuoteTypeTags.*
 
 import scala.annotation.constructorOnly
 
@@ -88,7 +89,7 @@ class Splicing extends MacroTransform:
       tree match
         case tree: Quote =>
           val body1 = QuoteTransformer().transform(tree.body)(using quoteContext)
-          cpy.Quote(tree)(body = body1)
+          cpy.Quote(tree)(body1, tree.tags)
         case tree: DefDef if tree.symbol.is(Inline) =>
           // Quotes in inlined methods are only pickled after they are inlined.
           tree
@@ -117,18 +118,6 @@ class Splicing extends MacroTransform:
           val newSplicedCode1 = splicer.transformSplice(tree.expr, 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) 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, hole)
-              hole
-          cpy.TypeDef(tree)(rhs = hole)
         case _: Template =>
           for sym <- tree.symbol.owner.info.decls do
             quotedDefs += sym
@@ -174,14 +163,13 @@ class Splicing extends MacroTransform:
    *  ```
    *  is transformed into
    * ```scala
-   *  {{{ <holeIdx++> | T2 | x, X | (x$1: Expr[T1], X$1: Type[X]) => (using Quotes) ?=> {... ${x$1} ...  X$1.Underlying ...}  }}}
+   *  {{{ <holeIdx++> | T2 | x, X | (x$1: Expr[T1], X$1: Type[X]) => (using Quotes) ?=> '<X$1>{... ${x$1} ...  X$1.Underlying ...}  }}}
    *  ```
    */
   private class SpliceTransformer(spliceOwner: Symbol, isCaptured: Symbol => Boolean) extends Transformer:
     private var refBindingMap = mutable.LinkedHashMap.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: QuoteTypeTags | Null = null // TODO: add to the context
 
     def transformSplice(tree: tpd.Tree, tpe: Type, holeIdx: Int)(using Context): tpd.Tree =
       assert(level == 0)
@@ -229,33 +217,23 @@ class Splicing extends MacroTransform:
           else super.transform(tree)
         case CapturedApplication(fn, argss) =>
           transformCapturedApplication(tree, fn, argss)
-        case Apply(Select(Quote(body), nme.apply), quotes :: Nil) if level == 0 && body.isTerm =>
+        case Apply(Select(Quote(body, _), nme.apply), quotes :: Nil) if level == 0 && body.isTerm =>
           body match
             case _: RefTree if isCaptured(body.symbol) => capturedTerm(body)
             case _ => withCurrentQuote(quotes) { super.transform(tree) }
-        case Quote(body) if level == 0 =>
-          val newBody =
-            if body.isTerm then transformLevel0QuoteContent(body)(using quoteContext)
-            else if containsCapturedType(body.tpe) then capturedPartTypes(body)
-            else body
-          cpy.Quote(tree)(newBody)
+        case tree: Quote if level == 0 =>
+          if tree.body.isTerm then transformLevel0Quote(tree)
+          else if containsCapturedType(tree.body.tpe) then capturedPartTypes(tree)
+          else tree
         case _ =>
           super.transform(tree)
 
-    private def transformLevel0QuoteContent(tree: Tree)(using Context): Tree =
+    private def transformLevel0Quote(quote: Quote)(using Context): Tree =
       // transform and collect new healed types
-      val old = healedTypes
-      healedTypes = new 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)
+      val (tags, body1) = inContextWithQuoteTypeTags {
+        transform(quote.body)(using quoteContext)
+      }
+      cpy.Quote(quote)(body1, quote.tags ::: tags)
 
     class ArgsClause(val args: List[Tree]):
       def isTerm: Boolean = args.isEmpty || args.head.isTerm
@@ -341,35 +319,26 @@ class Splicing extends MacroTransform:
         .getOrElseUpdate(tree.symbol, (TypeTree(tree.tpe), newQuotedTypeClassBinding(tpe)))._2
       bindingSym
 
-    private def capturedPartTypes(tpt: Tree)(using Context): Tree =
-      val old = healedTypes
-      healedTypes = QuoteTypeTags(tpt.span)
-      val capturePartTypes = new TypeMap {
-        def apply(tp: Type) = tp match {
-          case typeRef: TypeRef if containsCapturedType(typeRef) =>
-            val termRef = refBindingMap
-              .getOrElseUpdate(typeRef.symbol, (TypeTree(typeRef), newQuotedTypeClassBinding(typeRef)))._2.termRef
-            val tagRef = healedTypes.nn.getTagRef(termRef)
-            tagRef
-          case _ =>
-            mapOver(tp)
+    private def capturedPartTypes(quote: Quote)(using Context): Tree =
+      val (tags, body1) = inContextWithQuoteTypeTags {
+        val capturePartTypes = new TypeMap {
+          def apply(tp: Type) = tp match {
+            case typeRef: TypeRef if containsCapturedType(typeRef) =>
+              val termRef = refBindingMap
+                .getOrElseUpdate(typeRef.symbol, (TypeTree(typeRef), newQuotedTypeClassBinding(typeRef)))._2.termRef
+              val tagRef = getTagRef(termRef)
+              tagRef
+            case _ =>
+              mapOver(tp)
+          }
         }
+        TypeTree(capturePartTypes(quote.body.tpe.widenTermRefExpr))
       }
-      val captured = capturePartTypes(tpt.tpe.widenTermRefExpr)
-      val newHealedTypes = healedTypes.nn.getTypeTags
-      healedTypes = old
-      tpt match
-        case block: Block =>
-          cpy.Block(block)(newHealedTypes ::: block.stats, TypeTree(captured))
-        case _ =>
-          if newHealedTypes.nonEmpty then
-            cpy.Block(tpt)(newHealedTypes, TypeTree(captured))
-          else
-            tpt
+      cpy.Quote(quote)(body1, quote.tags ::: tags)
 
     private def getTagRefFor(tree: Tree)(using Context): Tree =
       val capturedTypeSym = capturedType(tree)
-      TypeTree(healedTypes.nn.getTagRef(capturedTypeSym.termRef))
+      TypeTree(getTagRef(capturedTypeSym.termRef))
 
     private def withCurrentQuote[T](newQuotes: Tree)(body: => T)(using Context): T =
       if level == 0 then
@@ -392,7 +361,7 @@ class Splicing extends MacroTransform:
       Splice(closure, tpe)
 
     private def quoted(expr: Tree)(using Context): Tree =
-      tpd.Quote(expr).select(nme.apply).appliedTo(quotes.nn)
+      tpd.Quote(expr, Nil).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 {
diff --git a/compiler/src/dotty/tools/dotc/transform/Staging.scala b/compiler/src/dotty/tools/dotc/transform/Staging.scala
index 35a67e670457..43cbe80ce8c4 100644
--- a/compiler/src/dotty/tools/dotc/transform/Staging.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Staging.scala
@@ -31,7 +31,7 @@ class Staging extends MacroTransform {
   override def allowsImplicitSearch: Boolean = true
 
   override def checkPostCondition(tree: Tree)(using Context): Unit =
-    if (ctx.phase <= splicingPhase) {
+    if (ctx.phase <= stagingPhase) {
       // Recheck that staging level consistency holds but do not heal any inconsistent types as they should already have been heald
       tree match {
         case PackageDef(pid, _) if tree.symbol.owner == defn.RootClass =>
diff --git a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
index 6d066ff4dc76..d51f5d283946 100644
--- a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
@@ -20,6 +20,8 @@ import ast.{tpd, untpd}
 import util.Chars._
 import collection.mutable
 import ProtoTypes._
+import staging.StagingLevel
+import inlines.Inlines.inInlineMethod
 
 import dotty.tools.backend.jvm.DottyBackendInterface.symExtensions
 
@@ -657,6 +659,34 @@ object TreeChecker {
       else
         super.typedPackageDef(tree)
 
+    override def typedQuote(tree: untpd.Quote, pt: Type)(using Context): Tree =
+      if ctx.phase <= stagingPhase.prev then
+        assert(tree.tags.isEmpty, i"unexpected tags in Quote before staging phase: ${tree.tags}")
+      else
+        assert(!tree.body.isInstanceOf[untpd.Splice] || inInlineMethod, i"missed quote cancellation in $tree")
+        assert(!tree.body.isInstanceOf[untpd.Hole] || inInlineMethod, i"missed quote cancellation in $tree")
+        if StagingLevel.level != 0 then
+          assert(tree.tags.isEmpty, i"unexpected tags in Quote at staging level ${StagingLevel.level}: ${tree.tags}")
+
+      for tag <- tree.tags do
+        assert(tag.isInstanceOf[RefTree], i"expected RefTree in Quote but was: $tag")
+
+      val tree1 = super.typedQuote(tree, pt)
+      for tag <- tree.tags do
+        assert(tag.typeOpt.derivesFrom(defn.QuotedTypeClass), i"expected Quote tag to be of type `Type` but was: ${tag.tpe}")
+
+      tree1 match
+        case Quote(body, targ :: Nil) if body.isType =>
+          assert(!(body.tpe =:= targ.tpe.select(tpnme.Underlying)), i"missed quote cancellation in $tree1")
+        case _ =>
+
+      tree1
+
+    override def typedSplice(tree: untpd.Splice, pt: Type)(using Context): Tree =
+      if stagingPhase <= ctx.phase then
+        assert(!tree.expr.isInstanceOf[untpd.Quote] || inInlineMethod, i"missed quote cancellation in $tree")
+      super.typedSplice(tree, pt)
+
     override def typedHole(tree: untpd.Hole, pt: Type)(using Context): Tree = {
       val tree1 @ Hole(isTerm, _, args, content, tpt) = super.typedHole(tree, pt): @unchecked
 
diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index b18cc55364d8..7238756454b3 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -312,7 +312,7 @@ object SpaceEngine {
   def isIrrefutableQuotedPattern(unapp: tpd.Tree, implicits: List[tpd.Tree], pt: Type)(using Context): Boolean = {
     implicits.headOption match
       // pattern '{ $x: T }
-      case Some(tpd.Apply(tpd.Select(tpd.Quote(tpd.TypeApply(fn, List(tpt))), nme.apply), _))
+      case Some(tpd.Apply(tpd.Select(tpd.Quote(tpd.TypeApply(fn, List(tpt)), _), nme.apply), _))
           if unapp.symbol.owner.eq(defn.QuoteMatching_ExprMatchModule)
           && fn.symbol.eq(defn.QuotedRuntimePatterns_patternHole) =>
         pt <:< defn.QuotedExprClass.typeRef.appliedTo(tpt.tpe)
diff --git a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
index 3a5ea05726a5..8b8858e16596 100644
--- a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
+++ b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
@@ -61,7 +61,7 @@ trait QuotesAndSplices {
       // TODO typecheck directly (without `exprQuote`)
       val exprQuoteTree = untpd.Apply(untpd.ref(defn.QuotedRuntime_exprQuote.termRef), tree.body)
       val quotedExpr = typedApply(exprQuoteTree, pt)(using quoteContext) match
-        case Apply(TypeApply(fn, tpt :: Nil), quotedExpr :: Nil) => untpd.Quote(quotedExpr).withBodyType(tpt.tpe)
+        case Apply(TypeApply(fn, tpt :: Nil), quotedExpr :: Nil) => untpd.Quote(quotedExpr, Nil).withBodyType(tpt.tpe)
       makeInlineable(quotedExpr.select(nme.apply).appliedTo(quotes).withSpan(tree.span))
   }
 
@@ -75,7 +75,7 @@ trait QuotesAndSplices {
     record("typedSplice")
     checkSpliceOutsideQuote(tree)
     tree.expr match {
-      case untpd.Quote(innerExpr) if innerExpr.isTerm =>
+      case untpd.Quote(innerExpr, Nil) if innerExpr.isTerm =>
         report.warning("Canceled quote directly inside a splice. ${ '{ XYZ } } is equivalent to XYZ.", tree.srcPos)
         return typed(innerExpr, pt)
       case _ =>
@@ -442,7 +442,7 @@ trait QuotesAndSplices {
 
     val quoteClass = if (quoted.isTerm) defn.QuotedExprClass else defn.QuotedTypeClass
     val quotedPattern =
-      if (quoted.isTerm) tpd.Quote(shape).select(nme.apply).appliedTo(quotes)
+      if (quoted.isTerm) tpd.Quote(shape, Nil).select(nme.apply).appliedTo(quotes)
       else ref(defn.QuotedTypeModule_of.termRef).appliedToTypeTree(shape).appliedTo(quotes)
 
     val matchModule = if quoted.isTerm then defn.QuoteMatching_ExprMatch else defn.QuoteMatching_TypeMatch
diff --git a/compiler/src/dotty/tools/dotc/typer/ReTyper.scala b/compiler/src/dotty/tools/dotc/typer/ReTyper.scala
index f8cfd4ca3ae0..ddc7a02fb4fb 100644
--- a/compiler/src/dotty/tools/dotc/typer/ReTyper.scala
+++ b/compiler/src/dotty/tools/dotc/typer/ReTyper.scala
@@ -98,7 +98,8 @@ class ReTyper(nestingLevel: Int = 0) extends Typer(nestingLevel) with ReChecking
   override def typedQuote(tree: untpd.Quote, pt: Type)(using Context): Tree =
     assertTyped(tree)
     val body1 = typed(tree.body, tree.bodyType)(using quoteContext)
-    untpd.cpy.Quote(tree)(body1).withType(tree.typeOpt)
+    for tag <- tree.tags do assertTyped(tag)
+    untpd.cpy.Quote(tree)(body1, tree.tags).withType(tree.typeOpt)
 
   override def typedSplice(tree: untpd.Splice, pt: Type)(using Context): Tree =
     assertTyped(tree)

From 95d20669eefe23e0e1375e735ae0d91ed031a4c3 Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Thu, 11 May 2023 14:53:08 +0200
Subject: [PATCH 562/657] deps: bump sbt-pack to latest 0.17

This pr bumps sbt-pack to the latest 0.17 and also accounts for a
breaking change that was introduced in
https://github.com/xerial/sbt-pack/pull/324 meaning that `pack` now must
be scoped.
---
 project/Build.scala | 2 +-
 project/plugins.sbt | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/project/Build.scala b/project/Build.scala
index c5586c68f981..30c3aded5be4 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -1949,7 +1949,7 @@ object ScaladocConfigs {
   }
 
   lazy val DefaultGenerationConfig = Def.task {
-    def distLocation = (dist / pack).value
+    def distLocation = (dist / Compile / pack).value
     DefaultGenerationSettings.value
   }
 
diff --git a/project/plugins.sbt b/project/plugins.sbt
index aba843ca2c3c..2d8c9d22928d 100644
--- a/project/plugins.sbt
+++ b/project/plugins.sbt
@@ -12,7 +12,7 @@ addSbtPlugin("org.xerial.sbt" % "sbt-sonatype" % "3.9.10")
 
 addSbtPlugin("com.jsuereth" % "sbt-pgp" % "2.0.0")
 
-addSbtPlugin("org.xerial.sbt" % "sbt-pack" % "0.13")
+addSbtPlugin("org.xerial.sbt" % "sbt-pack" % "0.17")
 
 addSbtPlugin("pl.project13.scala" % "sbt-jmh" % "0.4.3")
 

From 2e712686411e0634605d3bcb6232ce06ffddd298 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Wed, 10 May 2023 15:47:09 +0200
Subject: [PATCH 563/657] Remove `tpt` from `Hole`

Now the type is kept in the `Hole` node.
---
 compiler/src/dotty/tools/dotc/ast/Trees.scala | 43 +++++++++----------
 compiler/src/dotty/tools/dotc/ast/tpd.scala   |  6 +--
 compiler/src/dotty/tools/dotc/ast/untpd.scala |  2 +-
 .../tools/dotc/core/tasty/TreePickler.scala   |  4 +-
 .../tools/dotc/core/tasty/TreeUnpickler.scala |  4 +-
 .../tools/dotc/printing/RefinedPrinter.scala  |  6 +--
 .../tools/dotc/quoted/PickledQuotes.scala     |  6 +--
 .../tools/dotc/transform/PickleQuotes.scala   |  7 +--
 .../dotty/tools/dotc/transform/Splicing.scala |  2 +-
 .../tools/dotc/transform/TreeChecker.scala    | 13 +++---
 .../tools/dotc/typer/QuotesAndSplices.scala   |  3 +-
 .../src/dotty/tools/dotc/typer/ReTyper.scala  |  3 ++
 12 files changed, 52 insertions(+), 47 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala
index f4c3240c03bd..f3d7369d8d5d 100644
--- a/compiler/src/dotty/tools/dotc/ast/Trees.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala
@@ -746,6 +746,19 @@ object Trees {
       s"TypeTree${if (hasType) s"[$typeOpt]" else ""}"
   }
 
+  /** 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 isTerm 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.
+   */
+  case class Hole[+T <: Untyped](override val isTerm: Boolean, idx: Int, args: List[Tree[T]], content: Tree[T])(implicit @constructorOnly src: SourceFile) extends Tree[T] {
+    type ThisTree[+T <: Untyped] <: Hole[T]
+    override def isType: Boolean = !isTerm
+  }
+
   /** 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.
@@ -1035,20 +1048,6 @@ object Trees {
   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 isTerm 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](override val isTerm: 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 isType: Boolean = !isTerm
-  }
-
   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 {
@@ -1406,9 +1405,9 @@ object Trees {
         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 {
+      def Hole(tree: Tree)(isTerm: Boolean, idx: Int, args: List[Tree], content: 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)))
+        case _ => finalize(tree, untpd.Hole(isTerm, idx, args, content)(sourceFile(tree)))
       }
 
       // Copier methods with default arguments; these demand that the original tree
@@ -1431,8 +1430,8 @@ object Trees {
         TypeDef(tree: Tree)(name, rhs)
       def Template(tree: Template)(using Context)(constr: DefDef = tree.constr, parents: List[Tree] = tree.parents, derived: List[untpd.Tree] = tree.derived, self: ValDef = tree.self, body: LazyTreeList = tree.unforcedBody): 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)
+      def Hole(tree: Hole)(isTerm: Boolean = tree.isTerm, idx: Int = tree.idx, args: List[Tree] = tree.args, content: Tree = tree.content)(using Context): Hole =
+        Hole(tree: Tree)(isTerm, idx, args, content)
 
     }
 
@@ -1567,8 +1566,8 @@ object Trees {
               cpy.Quote(tree)(transform(body)(using quoteContext), transform(tags))
             case tree @ Splice(expr) =>
               cpy.Splice(tree)(transform(expr)(using spliceContext))
-            case tree @ Hole(isTerm, idx, args, content, tpt) =>
-              cpy.Hole(tree)(isTerm, idx, transform(args), transform(content), transform(tpt))
+            case tree @ Hole(isTerm, idx, args, content) =>
+              cpy.Hole(tree)(isTerm, idx, transform(args), transform(content))
             case _ =>
               transformMoreCases(tree)
           }
@@ -1712,8 +1711,8 @@ object Trees {
               this(this(x, body)(using quoteContext), tags)
             case Splice(expr) =>
               this(x, expr)(using spliceContext)
-            case Hole(_, _, args, content, tpt) =>
-              this(this(this(x, args), content), tpt)
+            case Hole(_, _, args, content) =>
+              this(this(x, args), content)
             case _ =>
               foldMoreCases(x, tree)
           }
diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
index 503c1a0b1b39..76e16cc00a90 100644
--- a/compiler/src/dotty/tools/dotc/ast/tpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -176,6 +176,9 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def Splice(expr: Tree, tpe: Type)(using Context): Splice =
     untpd.Splice(expr).withType(tpe)
 
+  def Hole(isTerm: Boolean, idx: Int, args: List[Tree], content: Tree, tpe: Type)(using Context): Hole =
+    untpd.Hole(isTerm, idx, args, content).withType(tpe)
+
   def TypeTree(tp: Type, inferred: Boolean = false)(using Context): TypeTree =
     (if inferred then untpd.InferredTypeTree() else untpd.TypeTree()).withType(tp)
 
@@ -397,9 +400,6 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def Throw(expr: Tree)(using Context): Tree =
     ref(defn.throwMethod).appliedTo(expr)
 
-  def Hole(isTerm: Boolean, idx: Int, args: List[Tree], content: Tree, tpt: Tree)(using Context): Hole =
-    ta.assignType(untpd.Hole(isTerm, idx, args, content, tpt), tpt)
-
   // ------ Making references ------------------------------------------------------
 
   def prefixIsElidable(tp: NamedType)(using Context): Boolean = {
diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
index 479d85f6e383..91299be537e8 100644
--- a/compiler/src/dotty/tools/dotc/ast/untpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -424,7 +424,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   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(isTerm: Boolean, idx: Int, args: List[Tree], content: Tree, tpt: Tree)(implicit src: SourceFile): Hole = new Hole(isTerm, idx, args, content, tpt)
+  def Hole(isTerm: Boolean, idx: Int, args: List[Tree], content: Tree)(implicit src: SourceFile): Hole = new Hole(isTerm, idx, args, content)
 
   // ------ Additional creation methods for untyped only -----------------
 
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
index 898ef2ed0c6c..645c6f81e539 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -685,11 +685,11 @@ class TreePickler(pickler: TastyPickler) {
               .appliedTo(expr)
               .withSpan(tree.span)
           )
-        case Hole(_, idx, args, _, tpt) =>
+        case Hole(_, idx, args, _) =>
           writeByte(HOLE)
           withLength {
             writeNat(idx)
-            pickleType(tpt.tpe, richTypes = true)
+            pickleType(tree.tpe, richTypes = true)
             args.foreach(pickleTree)
           }
       }
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
index 659d96a386ea..98bd7152ff37 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
@@ -1457,7 +1457,7 @@ class TreeUnpickler(reader: TastyReader,
               val idx = readNat()
               val tpe = readType()
               val args = until(end)(readTree())
-              Hole(true, idx, args, EmptyTree, TypeTree(tpe)).withType(tpe)
+              Hole(true, idx, args, EmptyTree, tpe)
             case _ =>
               readPathTree()
           }
@@ -1491,7 +1491,7 @@ class TreeUnpickler(reader: TastyReader,
           val idx = readNat()
           val tpe = readType()
           val args = until(end)(readTree())
-          Hole(false, idx, args, EmptyTree, TypeTree(tpe)).withType(tpe)
+          Hole(false, idx, args, EmptyTree, tpe)
         case _ =>
           if (isTypeTreeTag(nextByte)) readTree()
           else {
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index 47dac083cfce..0b539db283ed 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -735,12 +735,12 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case Splice(expr) =>
         val spliceTypeText = (keywordStr("[") ~ toTextGlobal(tree.typeOpt) ~ keywordStr("]")).provided(printDebug && tree.typeOpt.exists)
         keywordStr("$") ~ spliceTypeText ~ keywordStr("{") ~ toTextGlobal(expr) ~ keywordStr("}")
-      case Hole(isTerm, idx, args, content, tpt) =>
+      case Hole(isTerm, idx, args, content) =>
         val (prefix, postfix) = if isTerm then ("{{{", "}}}") else ("[[[", "]]]")
         val argsText = toTextGlobal(args, ", ")
         val contentText = toTextGlobal(content)
-        val tptText = toTextGlobal(tpt)
-        prefix ~~ idx.toString ~~ "|" ~~ tptText ~~ "|" ~~ argsText ~~ "|" ~~ contentText ~~ postfix
+        val tpeText = toTextGlobal(tree.typeOpt)
+        prefix ~~ idx.toString ~~ "|" ~~ tpeText ~~ "|" ~~ argsText ~~ "|" ~~ contentText ~~ postfix
       case CapturesAndResult(refs, parent) =>
         changePrec(GlobalPrec)("^{" ~ Text(refs.map(toText), ", ") ~ "}" ~ toText(parent))
       case _ =>
diff --git a/compiler/src/dotty/tools/dotc/quoted/PickledQuotes.scala b/compiler/src/dotty/tools/dotc/quoted/PickledQuotes.scala
index 89efcb4272ec..7596549fe401 100644
--- a/compiler/src/dotty/tools/dotc/quoted/PickledQuotes.scala
+++ b/compiler/src/dotty/tools/dotc/quoted/PickledQuotes.scala
@@ -100,7 +100,7 @@ object PickledQuotes {
   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(isTerm, idx, args, _, _) =>
+        case Hole(isTerm, idx, args, _) =>
           inContext(SpliceScope.contextWithNewSpliceScope(tree.sourcePos)) {
             if isTerm then
               val quotedExpr = termHole match
@@ -165,7 +165,7 @@ object PickledQuotes {
             val tree = typeHole match
               case TypeHole.V1(evalHole) =>
                 tdef.rhs match
-                  case TypeBoundsTree(_, Hole(_, idx, args, _, _), _) =>
+                  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)
@@ -173,7 +173,7 @@ object PickledQuotes {
                     // 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
+                val Hole(_, idx, _, _) = tdef.rhs: @unchecked
                 PickledQuotes.quotedTypeToTree(types.nn.apply(idx))
             (tdef.symbol, tree.tpe)
         }.toMap
diff --git a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
index 98bca65093fa..5abc92681295 100644
--- a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
@@ -14,6 +14,7 @@ import ast.TreeTypeMap
 import SymUtils._
 import NameKinds._
 import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.ast.untpd
 import dotty.tools.dotc.config.ScalaRelease.*
 
 import scala.collection.mutable
@@ -108,12 +109,12 @@ class PickleQuotes extends MacroTransform {
       private val contents = List.newBuilder[Tree]
       override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
         tree match
-          case tree @ Hole(isTerm, _, _, content, _) =>
+          case tree @ Hole(isTerm, _, _, content) =>
             assert(isTerm)
             assert(!content.isEmpty)
             contents += content
             val holeType = getTermHoleType(tree.tpe)
-            val hole = cpy.Hole(tree)(content = EmptyTree, TypeTree(holeType))
+            val hole = untpd.cpy.Hole(tree)(content = EmptyTree).withType(holeType)
             cpy.Inlined(tree)(EmptyTree, Nil, hole)
           case tree: DefTree =>
             val newAnnotations = tree.symbol.annotations.mapconserve { annot =>
@@ -197,7 +198,7 @@ class PickleQuotes extends MacroTransform {
 
   private def mkTagSymbolAndAssignType(typeArg: Tree, idx: Int)(using Context): TypeDef = {
     val holeType = getTypeHoleType(typeArg.tpe.select(tpnme.Underlying))
-    val hole = cpy.Hole(typeArg)(isTerm = false, idx, Nil, EmptyTree, TypeTree(holeType))
+    val hole = untpd.cpy.Hole(typeArg)(isTerm = false, idx, Nil, EmptyTree).withType(holeType)
     val local = newSymbol(
       owner = ctx.owner,
       name = UniqueName.fresh(hole.tpe.dealias.typeSymbol.name.toTypeName),
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicing.scala b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
index bf7eb2dedb7d..ff5dc5042eaf 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicing.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicing.scala
@@ -181,7 +181,7 @@ class Splicing extends MacroTransform:
       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))
+      tpd.Hole(true, holeIdx, refs, closure, tpe)
 
     override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
       tree match
diff --git a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
index d51f5d283946..e50fb9d8b09c 100644
--- a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
@@ -688,7 +688,10 @@ object TreeChecker {
       super.typedSplice(tree, pt)
 
     override def typedHole(tree: untpd.Hole, pt: Type)(using Context): Tree = {
-      val tree1 @ Hole(isTerm, _, args, content, tpt) = super.typedHole(tree, pt): @unchecked
+      val tree1 @ Hole(isTerm, idx, args, content) = super.typedHole(tree, pt): @unchecked
+
+      assert(idx >= 0, i"hole should not have negative index: $tree")
+      assert(isTerm || tree.args.isEmpty, i"type hole should not have arguments: $tree")
 
       // Check that we only add the captured type `T` instead of a more complex type like `List[T]`.
       // If we have `F[T]` with captured `F` and `T`, we should list `F` and `T` separately in the args.
@@ -696,8 +699,8 @@ object TreeChecker {
         assert(arg.isTerm || arg.tpe.isInstanceOf[TypeRef], "Expected TypeRef in Hole type args but got: " + arg.tpe)
 
       // Check result type of the hole
-      if isTerm then assert(tpt.typeOpt <:< pt)
-      else assert(tpt.typeOpt =:= pt)
+      if isTerm then assert(tree1.typeOpt <:< pt)
+      else assert(tree1.typeOpt =:= pt)
 
       // Check that the types of the args conform to the types of the contents of the hole
       val argQuotedTypes = args.map { arg =>
@@ -712,8 +715,8 @@ object TreeChecker {
         else defn.QuotedTypeClass.typeRef.appliedTo(arg.typeOpt.widenTermRefExpr)
       }
       val expectedResultType =
-        if isTerm then defn.QuotedExprClass.typeRef.appliedTo(tpt.typeOpt)
-        else defn.QuotedTypeClass.typeRef.appliedTo(tpt.typeOpt)
+        if isTerm then defn.QuotedExprClass.typeRef.appliedTo(tree1.typeOpt)
+        else defn.QuotedTypeClass.typeRef.appliedTo(tree1.typeOpt)
       val contextualResult =
         defn.FunctionOf(List(defn.QuotesClass.typeRef), expectedResultType, isContextual = true)
       val expectedContentType =
diff --git a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
index 8b8858e16596..ea2b380dc0ed 100644
--- a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
+++ b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
@@ -116,8 +116,7 @@ trait QuotesAndSplices {
   }
 
   def typedHole(tree: untpd.Hole, pt: Type)(using Context): Tree =
-    val tpt = typedType(tree.tpt)
-    assignType(tree, tpt)
+    throw new UnsupportedOperationException("cannot type check a Hole node")
 
   /** Types a splice applied to some arguments `$f(arg1, ..., argn)` in a quote pattern.
    *
diff --git a/compiler/src/dotty/tools/dotc/typer/ReTyper.scala b/compiler/src/dotty/tools/dotc/typer/ReTyper.scala
index ddc7a02fb4fb..1fa6e967fbe1 100644
--- a/compiler/src/dotty/tools/dotc/typer/ReTyper.scala
+++ b/compiler/src/dotty/tools/dotc/typer/ReTyper.scala
@@ -111,6 +111,9 @@ class ReTyper(nestingLevel: Int = 0) extends Typer(nestingLevel) with ReChecking
     val expr1 = typed(tree.expr, quoteType)(using spliceContext)
     untpd.cpy.Splice(tree)(expr1).withType(tree.typeOpt)
 
+  override def typedHole(tree: untpd.Hole, pt: Type)(using Context): Tree =
+    promote(tree)
+
   override def localDummy(cls: ClassSymbol, impl: untpd.Template)(using Context): Symbol = impl.symbol
 
   override def retrieveSym(tree: untpd.Tree)(using Context): Symbol = tree.symbol

From 449cbc226e8facb3d69fd9cfb9b5213ba65e43a7 Mon Sep 17 00:00:00 2001
From: Matt Bovel <matthieu@bovel.net>
Date: Tue, 9 May 2023 19:58:18 +0200
Subject: [PATCH 564/657] Warn when calling methods of topClasses on Predef or
 on package objects

Co-Authored-By: Dale Wijnand <dale.wijnand@gmail.com>
Co-Authored-By: itielsa <38278165+itielsa@users.noreply.github.com>
---
 .../tools/dotc/reporting/ErrorMessageID.scala |  2 +
 .../dotty/tools/dotc/reporting/messages.scala | 19 +++++
 .../dotty/tools/dotc/typer/RefChecks.scala    | 20 +++++
 compiler/test/dotty/tools/utils.scala         |  4 +-
 tests/neg/i17266.check                        | 84 +++++++++++++++++++
 tests/neg/i17266.scala                        | 49 +++++++++++
 6 files changed, 177 insertions(+), 1 deletion(-)
 create mode 100644 tests/neg/i17266.check
 create mode 100644 tests/neg/i17266.scala

diff --git a/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala b/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
index cc2741bcb614..1802139de502 100644
--- a/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
@@ -194,6 +194,8 @@ enum ErrorMessageID(val isActive: Boolean = true) extends java.lang.Enum[ErrorMe
   case MissingArgumentListID // errorNumber: 178
   case MatchTypeScrutineeCannotBeHigherKindedID // errorNumber: 179
   case AmbiguousExtensionMethodID // errorNumber 180
+  case CallToAnyRefMethodOnPredefID // errorNumber: 181
+  case CallToAnyRefMethodOnPackageObjectID // errorNumber: 182
 
   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 98a5d73223ac..299d15e65443 100644
--- a/compiler/src/dotty/tools/dotc/reporting/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/messages.scala
@@ -2288,6 +2288,25 @@ class PureExpressionInStatementPosition(stat: untpd.Tree, val exprOwner: Symbol)
         |It can be removed without changing the semantics of the program. This may indicate an error."""
 }
 
+class CallToAnyRefMethodOnPredef(stat: untpd.Tree, method: Symbol)(using Context)
+  extends Message(CallToAnyRefMethodOnPredefID) {
+  def kind = MessageKind.PotentialIssue
+  def msg(using Context) = i"Suspicious call to ${hl("Predef." + method.name)}"
+  def explain(using Context) =
+    i"""Top-level unqualified calls to ${hl("AnyRef")} or ${hl("Any")} methods such as ${hl(method.name.toString)} are
+       |resolved to calls on ${hl("Predef")}. This might not be what you intended."""
+}
+
+class CallToAnyRefMethodOnPackageObject(stat: untpd.Tree, method: Symbol)(using Context)
+  extends Message(CallToAnyRefMethodOnPackageObjectID) {
+  def kind = MessageKind.PotentialIssue
+  def msg(using Context) = i"Suspicious top-level call to ${hl("this." + method.name)}"
+  def explain(using Context) =
+    i"""Top-level calls to ${hl("AnyRef")} or ${hl("Any")} methods are resolved to calls on the
+       |synthetic package object generated for the current file. This might not be
+       |what you intended."""
+}
+
 class TraitCompanionWithMutableStatic()(using Context)
   extends SyntaxMsg(TraitCompanionWithMutableStaticID) {
   def msg(using Context) = i"Companion of traits cannot define mutable @static fields"
diff --git a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
index 73331046b41f..108a141e28c6 100644
--- a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
+++ b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
@@ -1090,6 +1090,17 @@ object RefChecks {
 
   end checkImplicitNotFoundAnnotation
 
+  def checkSynchronizedCall(tree: Tree, symbol: Symbol)(using Context) =
+    if symbol.exists && defn.topClasses.contains(symbol.owner) then
+      tree.tpe match
+        case tp: NamedType =>
+          val prefixSymbol = tp.prefix.typeSymbol
+          if prefixSymbol == defn.ScalaPredefModuleClass then
+            report.warning(CallToAnyRefMethodOnPredef(tree, symbol), tree)
+          if prefixSymbol.isPackageObject && !tp.symbol.isConstructor then
+            report.warning(CallToAnyRefMethodOnPackageObject(tree, symbol), tree)
+        case _ => ()
+
 }
 import RefChecks._
 
@@ -1168,6 +1179,15 @@ class RefChecks extends MiniPhase { thisPhase =>
       report.error(ex, tree.srcPos)
       tree
   }
+
+  override def transformSelect(tree: Select)(using Context): Tree =
+    checkSynchronizedCall(tree, tree.denot.symbol)
+    tree
+
+  override def transformIdent(tree: Ident)(using Context): Tree =
+    checkSynchronizedCall(tree, tree.symbol)
+    tree
+
 }
 
 /* todo: rewrite and re-enable
diff --git a/compiler/test/dotty/tools/utils.scala b/compiler/test/dotty/tools/utils.scala
index bfedc338f25a..75918674146c 100644
--- a/compiler/test/dotty/tools/utils.scala
+++ b/compiler/test/dotty/tools/utils.scala
@@ -17,8 +17,10 @@ import scala.util.control.{ControlThrowable, NonFatal}
 
 import dotc.config.CommandLineParser
 
+object Dummy
+
 def scripts(path: String): Array[File] = {
-  val dir = new File(this.getClass.getResource(path).getPath)
+  val dir = new File(Dummy.getClass.getResource(path).getPath)
   assert(dir.exists && dir.isDirectory, "Couldn't load scripts dir")
   dir.listFiles.filter { f =>
     val path = if f.isDirectory then f.getPath + "/" else f.getPath
diff --git a/tests/neg/i17266.check b/tests/neg/i17266.check
new file mode 100644
index 000000000000..11742a5f2378
--- /dev/null
+++ b/tests/neg/i17266.check
@@ -0,0 +1,84 @@
+-- [E181] Potential Issue Error: tests/neg/i17266.scala:4:2 ------------------------------------------------------------
+4 |  synchronized { // error
+  |  ^^^^^^^^^^^^
+  |  Suspicious call to Predef.synchronized
+  |---------------------------------------------------------------------------------------------------------------------
+  | Explanation (enabled by `-explain`)
+  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  | Top-level unqualified calls to AnyRef or Any methods such as synchronized are
+  | resolved to calls on Predef. This might not be what you intended.
+   ---------------------------------------------------------------------------------------------------------------------
+-- [E182] Potential Issue Error: tests/neg/i17266.scala:9:7 ------------------------------------------------------------
+9 |  this.synchronized { // error
+  |  ^^^^^^^^^^^^^^^^^
+  |  Suspicious top-level call to this.synchronized
+  |---------------------------------------------------------------------------------------------------------------------
+  | Explanation (enabled by `-explain`)
+  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+  | Top-level calls to AnyRef or Any methods are resolved to calls on the
+  | synthetic package object generated for the current file. This might not be
+  | what you intended.
+   ---------------------------------------------------------------------------------------------------------------------
+-- [E181] Potential Issue Error: tests/neg/i17266.scala:22:2 -----------------------------------------------------------
+22 |  wait() // error
+   |  ^^^^
+   |  Suspicious call to Predef.wait
+   |--------------------------------------------------------------------------------------------------------------------
+   | Explanation (enabled by `-explain`)
+   |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   | Top-level unqualified calls to AnyRef or Any methods such as wait are
+   | resolved to calls on Predef. This might not be what you intended.
+    --------------------------------------------------------------------------------------------------------------------
+-- [E182] Potential Issue Error: tests/neg/i17266.scala:25:7 -----------------------------------------------------------
+25 |  this.wait() // error
+   |  ^^^^^^^^^
+   |  Suspicious top-level call to this.wait
+   |--------------------------------------------------------------------------------------------------------------------
+   | Explanation (enabled by `-explain`)
+   |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   | Top-level calls to AnyRef or Any methods are resolved to calls on the
+   | synthetic package object generated for the current file. This might not be
+   | what you intended.
+    --------------------------------------------------------------------------------------------------------------------
+-- [E181] Potential Issue Error: tests/neg/i17266.scala:32:2 -----------------------------------------------------------
+32 |  wait(10) // error
+   |  ^^^^
+   |  Suspicious call to Predef.wait
+   |--------------------------------------------------------------------------------------------------------------------
+   | Explanation (enabled by `-explain`)
+   |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   | Top-level unqualified calls to AnyRef or Any methods such as wait are
+   | resolved to calls on Predef. This might not be what you intended.
+    --------------------------------------------------------------------------------------------------------------------
+-- [E182] Potential Issue Error: tests/neg/i17266.scala:35:7 -----------------------------------------------------------
+35 |  this.wait(10) // error
+   |  ^^^^^^^^^
+   |  Suspicious top-level call to this.wait
+   |--------------------------------------------------------------------------------------------------------------------
+   | Explanation (enabled by `-explain`)
+   |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   | Top-level calls to AnyRef or Any methods are resolved to calls on the
+   | synthetic package object generated for the current file. This might not be
+   | what you intended.
+    --------------------------------------------------------------------------------------------------------------------
+-- [E181] Potential Issue Error: tests/neg/i17266.scala:42:2 -----------------------------------------------------------
+42 |  hashCode() // error
+   |  ^^^^^^^^
+   |  Suspicious call to Predef.hashCode
+   |--------------------------------------------------------------------------------------------------------------------
+   | Explanation (enabled by `-explain`)
+   |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   | Top-level unqualified calls to AnyRef or Any methods such as hashCode are
+   | resolved to calls on Predef. This might not be what you intended.
+    --------------------------------------------------------------------------------------------------------------------
+-- [E182] Potential Issue Error: tests/neg/i17266.scala:45:7 -----------------------------------------------------------
+45 |  this.hashCode() // error
+   |  ^^^^^^^^^^^^^
+   |  Suspicious top-level call to this.hashCode
+   |--------------------------------------------------------------------------------------------------------------------
+   | Explanation (enabled by `-explain`)
+   |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   | Top-level calls to AnyRef or Any methods are resolved to calls on the
+   | synthetic package object generated for the current file. This might not be
+   | what you intended.
+    --------------------------------------------------------------------------------------------------------------------
diff --git a/tests/neg/i17266.scala b/tests/neg/i17266.scala
new file mode 100644
index 000000000000..1edcebf4781c
--- /dev/null
+++ b/tests/neg/i17266.scala
@@ -0,0 +1,49 @@
+// scalac: -Werror -explain
+
+def test1 =
+  synchronized { // error
+    println("hello")
+  }
+
+def test2 =
+  this.synchronized { // error
+    println("hello")
+  }
+
+object MyLib
+
+def test3 =
+  import MyLib.*
+  synchronized { // not an error (should be?)
+    println("hello")
+  }
+
+def test4 =
+  wait() // error
+
+def test5 =
+  this.wait() // error
+
+def test6 =
+  import MyLib.*
+  wait() // not an error (should be?)
+
+def test7 =
+  wait(10) // error
+
+def test8 =
+  this.wait(10) // error
+
+def test9 =
+  import MyLib.*
+  wait(10) // not an error (should be?)
+
+def test10 =
+  hashCode() // error
+
+def test11 =
+  this.hashCode() // error
+
+def test12 =
+  import MyLib.*
+  hashCode() // not an error (should be?)

From 5c4e59731038e942460f3f40c4a23a78000047e4 Mon Sep 17 00:00:00 2001
From: Matt Bovel <matthieu@bovel.net>
Date: Thu, 11 May 2023 15:06:59 +0200
Subject: [PATCH 565/657] Warn on unqualified top-level calls to Any or AnyRef
 methods

---
 .../tools/dotc/reporting/ErrorMessageID.scala |   3 +-
 .../dotty/tools/dotc/reporting/messages.scala |  19 +--
 .../dotty/tools/dotc/typer/RefChecks.scala    |  21 +--
 tests/neg/i17266.check                        | 148 +++++++++---------
 tests/neg/i17266.scala                        | 127 +++++++++++++--
 5 files changed, 199 insertions(+), 119 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala b/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
index 1802139de502..fc679210db17 100644
--- a/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
@@ -194,8 +194,7 @@ enum ErrorMessageID(val isActive: Boolean = true) extends java.lang.Enum[ErrorMe
   case MissingArgumentListID // errorNumber: 178
   case MatchTypeScrutineeCannotBeHigherKindedID // errorNumber: 179
   case AmbiguousExtensionMethodID // errorNumber 180
-  case CallToAnyRefMethodOnPredefID // errorNumber: 181
-  case CallToAnyRefMethodOnPackageObjectID // errorNumber: 182
+  case UnqualifiedCallToAnyRefMethodID // errorNumber: 181
 
   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 299d15e65443..d205b816214c 100644
--- a/compiler/src/dotty/tools/dotc/reporting/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/messages.scala
@@ -2288,23 +2288,14 @@ class PureExpressionInStatementPosition(stat: untpd.Tree, val exprOwner: Symbol)
         |It can be removed without changing the semantics of the program. This may indicate an error."""
 }
 
-class CallToAnyRefMethodOnPredef(stat: untpd.Tree, method: Symbol)(using Context)
-  extends Message(CallToAnyRefMethodOnPredefID) {
+class UnqualifiedCallToAnyRefMethod(stat: untpd.Tree, method: Symbol)(using Context)
+  extends Message(UnqualifiedCallToAnyRefMethodID) {
   def kind = MessageKind.PotentialIssue
-  def msg(using Context) = i"Suspicious call to ${hl("Predef." + method.name)}"
+  def msg(using Context) = i"Suspicious top-level unqualified call to ${hl(method.name.toString)}"
   def explain(using Context) =
     i"""Top-level unqualified calls to ${hl("AnyRef")} or ${hl("Any")} methods such as ${hl(method.name.toString)} are
-       |resolved to calls on ${hl("Predef")}. This might not be what you intended."""
-}
-
-class CallToAnyRefMethodOnPackageObject(stat: untpd.Tree, method: Symbol)(using Context)
-  extends Message(CallToAnyRefMethodOnPackageObjectID) {
-  def kind = MessageKind.PotentialIssue
-  def msg(using Context) = i"Suspicious top-level call to ${hl("this." + method.name)}"
-  def explain(using Context) =
-    i"""Top-level calls to ${hl("AnyRef")} or ${hl("Any")} methods are resolved to calls on the
-       |synthetic package object generated for the current file. This might not be
-       |what you intended."""
+       |resolved to calls on ${hl("Predef")} or on imported methods. This might not be what
+       |you intended."""
 }
 
 class TraitCompanionWithMutableStatic()(using Context)
diff --git a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
index 108a141e28c6..fe28a8b18833 100644
--- a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
+++ b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
@@ -1090,16 +1090,11 @@ object RefChecks {
 
   end checkImplicitNotFoundAnnotation
 
-  def checkSynchronizedCall(tree: Tree, symbol: Symbol)(using Context) =
-    if symbol.exists && defn.topClasses.contains(symbol.owner) then
-      tree.tpe match
-        case tp: NamedType =>
-          val prefixSymbol = tp.prefix.typeSymbol
-          if prefixSymbol == defn.ScalaPredefModuleClass then
-            report.warning(CallToAnyRefMethodOnPredef(tree, symbol), tree)
-          if prefixSymbol.isPackageObject && !tp.symbol.isConstructor then
-            report.warning(CallToAnyRefMethodOnPackageObject(tree, symbol), tree)
-        case _ => ()
+  def checkAnyRefMethodCall(tree: Tree)(using Context) =
+    if tree.symbol.exists
+       && defn.topClasses.contains(tree.symbol.owner)
+       && (!ctx.owner.enclosingClass.exists || ctx.owner.enclosingClass.isPackageObject) then
+      report.warning(UnqualifiedCallToAnyRefMethod(tree, tree.symbol), tree)
 
 }
 import RefChecks._
@@ -1180,12 +1175,8 @@ class RefChecks extends MiniPhase { thisPhase =>
       tree
   }
 
-  override def transformSelect(tree: Select)(using Context): Tree =
-    checkSynchronizedCall(tree, tree.denot.symbol)
-    tree
-
   override def transformIdent(tree: Ident)(using Context): Tree =
-    checkSynchronizedCall(tree, tree.symbol)
+    checkAnyRefMethodCall(tree)
     tree
 
 }
diff --git a/tests/neg/i17266.check b/tests/neg/i17266.check
index 11742a5f2378..7e07e3d43de4 100644
--- a/tests/neg/i17266.check
+++ b/tests/neg/i17266.check
@@ -1,84 +1,88 @@
 -- [E181] Potential Issue Error: tests/neg/i17266.scala:4:2 ------------------------------------------------------------
 4 |  synchronized { // error
   |  ^^^^^^^^^^^^
-  |  Suspicious call to Predef.synchronized
+  |  Suspicious top-level unqualified call to synchronized
   |---------------------------------------------------------------------------------------------------------------------
   | Explanation (enabled by `-explain`)
   |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
   | Top-level unqualified calls to AnyRef or Any methods such as synchronized are
-  | resolved to calls on Predef. This might not be what you intended.
+  | resolved to calls on Predef or on imported methods. This might not be what
+  | you intended.
    ---------------------------------------------------------------------------------------------------------------------
--- [E182] Potential Issue Error: tests/neg/i17266.scala:9:7 ------------------------------------------------------------
-9 |  this.synchronized { // error
-  |  ^^^^^^^^^^^^^^^^^
-  |  Suspicious top-level call to this.synchronized
-  |---------------------------------------------------------------------------------------------------------------------
-  | Explanation (enabled by `-explain`)
-  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-  | Top-level calls to AnyRef or Any methods are resolved to calls on the
-  | synthetic package object generated for the current file. This might not be
-  | what you intended.
-   ---------------------------------------------------------------------------------------------------------------------
--- [E181] Potential Issue Error: tests/neg/i17266.scala:22:2 -----------------------------------------------------------
-22 |  wait() // error
-   |  ^^^^
-   |  Suspicious call to Predef.wait
-   |--------------------------------------------------------------------------------------------------------------------
-   | Explanation (enabled by `-explain`)
-   |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-   | Top-level unqualified calls to AnyRef or Any methods such as wait are
-   | resolved to calls on Predef. This might not be what you intended.
-    --------------------------------------------------------------------------------------------------------------------
--- [E182] Potential Issue Error: tests/neg/i17266.scala:25:7 -----------------------------------------------------------
-25 |  this.wait() // error
-   |  ^^^^^^^^^
-   |  Suspicious top-level call to this.wait
-   |--------------------------------------------------------------------------------------------------------------------
-   | Explanation (enabled by `-explain`)
-   |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-   | Top-level calls to AnyRef or Any methods are resolved to calls on the
-   | synthetic package object generated for the current file. This might not be
-   | what you intended.
-    --------------------------------------------------------------------------------------------------------------------
--- [E181] Potential Issue Error: tests/neg/i17266.scala:32:2 -----------------------------------------------------------
-32 |  wait(10) // error
-   |  ^^^^
-   |  Suspicious call to Predef.wait
-   |--------------------------------------------------------------------------------------------------------------------
-   | Explanation (enabled by `-explain`)
-   |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-   | Top-level unqualified calls to AnyRef or Any methods such as wait are
-   | resolved to calls on Predef. This might not be what you intended.
-    --------------------------------------------------------------------------------------------------------------------
--- [E182] Potential Issue Error: tests/neg/i17266.scala:35:7 -----------------------------------------------------------
-35 |  this.wait(10) // error
-   |  ^^^^^^^^^
-   |  Suspicious top-level call to this.wait
-   |--------------------------------------------------------------------------------------------------------------------
-   | Explanation (enabled by `-explain`)
-   |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-   | Top-level calls to AnyRef or Any methods are resolved to calls on the
-   | synthetic package object generated for the current file. This might not be
-   | what you intended.
-    --------------------------------------------------------------------------------------------------------------------
--- [E181] Potential Issue Error: tests/neg/i17266.scala:42:2 -----------------------------------------------------------
-42 |  hashCode() // error
-   |  ^^^^^^^^
-   |  Suspicious call to Predef.hashCode
-   |--------------------------------------------------------------------------------------------------------------------
-   | Explanation (enabled by `-explain`)
-   |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-   | Top-level unqualified calls to AnyRef or Any methods such as hashCode are
-   | resolved to calls on Predef. This might not be what you intended.
-    --------------------------------------------------------------------------------------------------------------------
--- [E182] Potential Issue Error: tests/neg/i17266.scala:45:7 -----------------------------------------------------------
-45 |  this.hashCode() // error
-   |  ^^^^^^^^^^^^^
-   |  Suspicious top-level call to this.hashCode
+-- [E181] Potential Issue Error: tests/neg/i17266.scala:17:2 -----------------------------------------------------------
+17 |  synchronized { // error
+   |  ^^^^^^^^^^^^
+   |  Suspicious top-level unqualified call to synchronized
    |--------------------------------------------------------------------------------------------------------------------
    | Explanation (enabled by `-explain`)
    |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-   | Top-level calls to AnyRef or Any methods are resolved to calls on the
-   | synthetic package object generated for the current file. This might not be
-   | what you intended.
+   | Top-level unqualified calls to AnyRef or Any methods such as synchronized are
+   | resolved to calls on Predef or on imported methods. This might not be what
+   | you intended.
     --------------------------------------------------------------------------------------------------------------------
+-- [E181] Potential Issue Error: tests/neg/i17266.scala:108:2 ----------------------------------------------------------
+108 |  wait() // error
+    |  ^^^^
+    |  Suspicious top-level unqualified call to wait
+    |-------------------------------------------------------------------------------------------------------------------
+    | Explanation (enabled by `-explain`)
+    |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+    | Top-level unqualified calls to AnyRef or Any methods such as wait are
+    | resolved to calls on Predef or on imported methods. This might not be what
+    | you intended.
+     -------------------------------------------------------------------------------------------------------------------
+-- [E181] Potential Issue Error: tests/neg/i17266.scala:115:2 ----------------------------------------------------------
+115 |  wait() // error
+    |  ^^^^
+    |  Suspicious top-level unqualified call to wait
+    |-------------------------------------------------------------------------------------------------------------------
+    | Explanation (enabled by `-explain`)
+    |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+    | Top-level unqualified calls to AnyRef or Any methods such as wait are
+    | resolved to calls on Predef or on imported methods. This might not be what
+    | you intended.
+     -------------------------------------------------------------------------------------------------------------------
+-- [E181] Potential Issue Error: tests/neg/i17266.scala:121:2 ----------------------------------------------------------
+121 |  wait(10) // error
+    |  ^^^^
+    |  Suspicious top-level unqualified call to wait
+    |-------------------------------------------------------------------------------------------------------------------
+    | Explanation (enabled by `-explain`)
+    |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+    | Top-level unqualified calls to AnyRef or Any methods such as wait are
+    | resolved to calls on Predef or on imported methods. This might not be what
+    | you intended.
+     -------------------------------------------------------------------------------------------------------------------
+-- [E181] Potential Issue Error: tests/neg/i17266.scala:128:2 ----------------------------------------------------------
+128 |  wait(10) // error
+    |  ^^^^
+    |  Suspicious top-level unqualified call to wait
+    |-------------------------------------------------------------------------------------------------------------------
+    | Explanation (enabled by `-explain`)
+    |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+    | Top-level unqualified calls to AnyRef or Any methods such as wait are
+    | resolved to calls on Predef or on imported methods. This might not be what
+    | you intended.
+     -------------------------------------------------------------------------------------------------------------------
+-- [E181] Potential Issue Error: tests/neg/i17266.scala:134:2 ----------------------------------------------------------
+134 |  hashCode() // error
+    |  ^^^^^^^^
+    |  Suspicious top-level unqualified call to hashCode
+    |-------------------------------------------------------------------------------------------------------------------
+    | Explanation (enabled by `-explain`)
+    |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+    | Top-level unqualified calls to AnyRef or Any methods such as hashCode are
+    | resolved to calls on Predef or on imported methods. This might not be what
+    | you intended.
+     -------------------------------------------------------------------------------------------------------------------
+-- [E181] Potential Issue Error: tests/neg/i17266.scala:141:2 ----------------------------------------------------------
+141 |  hashCode() // error
+    |  ^^^^^^^^
+    |  Suspicious top-level unqualified call to hashCode
+    |-------------------------------------------------------------------------------------------------------------------
+    | Explanation (enabled by `-explain`)
+    |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+    | Top-level unqualified calls to AnyRef or Any methods such as hashCode are
+    | resolved to calls on Predef or on imported methods. This might not be what
+    | you intended.
+     -------------------------------------------------------------------------------------------------------------------
diff --git a/tests/neg/i17266.scala b/tests/neg/i17266.scala
index 1edcebf4781c..5b74ea76810b 100644
--- a/tests/neg/i17266.scala
+++ b/tests/neg/i17266.scala
@@ -6,7 +6,7 @@ def test1 =
   }
 
 def test2 =
-  this.synchronized { // error
+  this.synchronized { // not an error (should be?)
     println("hello")
   }
 
@@ -14,36 +14,131 @@ object MyLib
 
 def test3 =
   import MyLib.*
-  synchronized { // not an error (should be?)
+  synchronized { // error
     println("hello")
   }
 
 def test4 =
+  1.synchronized { // not an error (should be?)
+    println("hello")
+  }
+
+object Test4:
+  synchronized { // not an error
+    println("hello")
+  }
+
+object Test5:
+  def test5 =
+    synchronized { // not an error
+      println("hello")
+    }
+
+object Test6:
+  import MyLib.*
+  synchronized { // not an error
+    println("hello")
+  }
+
+object Test7:
+  import MyLib.*
+  def test7 =
+    synchronized { // not an error
+      println("hello")
+    }
+
+/*
+object Test7b:
+  def test8 =
+    import MyLib.*
+    synchronized { // already an error: Reference to synchronized is ambiguous.
+      println("hello")
+    }
+*/
+
+class Test8:
+  synchronized { // not an error
+    println("hello")
+  }
+
+class Test9:
+  def test5 =
+    synchronized { // not an error
+      println("hello")
+    }
+
+class Test10:
+  import MyLib.*
+  synchronized { // not an error
+    println("hello")
+  }
+
+class Test11:
+  import MyLib.*
+  def test7 =
+    synchronized { // not an error
+      println("hello")
+    }
+
+trait Test12:
+  synchronized { // not an error
+    println("hello")
+  }
+
+trait Test13:
+  def test5 =
+    synchronized { // not an error
+      println("hello")
+    }
+
+trait Test14:
+  import MyLib.*
+  synchronized { // not an error
+    println("hello")
+  }
+
+trait Test15:
+  import MyLib.*
+  def test7 =
+    synchronized { // not an error
+      println("hello")
+    }
+
+def test16 =
   wait() // error
 
-def test5 =
-  this.wait() // error
+def test17 =
+  this.wait() // not an error (should be?)
 
-def test6 =
+def test18 =
   import MyLib.*
-  wait() // not an error (should be?)
+  wait() // error
 
-def test7 =
+def test19 =
+  1.wait() // not an error (should be?)
+
+def test20 =
   wait(10) // error
 
-def test8 =
-  this.wait(10) // error
+def test21 =
+  this.wait(10) // not an error (should be?)
 
-def test9 =
+def test22 =
   import MyLib.*
-  wait(10) // not an error (should be?)
+  wait(10) // error
+
+def test23 =
+  1.wait(10) // not an error (should be?)
 
-def test10 =
+def test24 =
   hashCode() // error
 
-def test11 =
-  this.hashCode() // error
+def test25 =
+  this.hashCode() // not an error (should be?)
 
-def test12 =
+def test26 =
   import MyLib.*
-  hashCode() // not an error (should be?)
+  hashCode() // error
+
+def test27 =
+  1.hashCode()// not an error (should be? probably not)

From 77eb00f681462704597349f33cb8566bf49a04d2 Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Fri, 12 May 2023 08:26:48 +0200
Subject: [PATCH 566/657] test: add in regression test for #5700

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

diff --git a/tests/pos/i5700.scala b/tests/pos/i5700.scala
new file mode 100644
index 000000000000..69892dea16f4
--- /dev/null
+++ b/tests/pos/i5700.scala
@@ -0,0 +1,5 @@
+// https://github.com/lampepfl/dotty/issues/5700
+object noRecursionLimit:
+  type M = { type T[+A]; type Ev >: T[Any] <: T[Nothing] }
+  val M: M = ().asInstanceOf[M]
+  def dcast(m: M.T[Any]): M.T[Int] = m: M.Ev

From b080235ed1e7aba3a5d603dd34ae27360f521958 Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Fri, 12 May 2023 08:32:34 +0200
Subject: [PATCH 567/657] test: add regression test for #7790

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

diff --git a/tests/pos/i7790.scala b/tests/pos/i7790.scala
new file mode 100644
index 000000000000..0a0e2d2ce347
--- /dev/null
+++ b/tests/pos/i7790.scala
@@ -0,0 +1,9 @@
+// https://github.com/lampepfl/dotty/issues/7790
+trait Foo:
+  given Int = 10
+  def map(f: Int ?=> Int) = f
+  def map(f: Int ?=> String) = f
+
+@main def Test =
+  val m: Foo = ???
+  m.map((x: Int) ?=> x)

From 77a44df63655dfa4a7dcad2148e76e2813f8623d Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Fri, 12 May 2023 08:37:13 +0200
Subject: [PATCH 568/657] test: add in regression test for #7653

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

diff --git a/tests/pos/i7653.scala b/tests/pos/i7653.scala
new file mode 100644
index 000000000000..8511b6eef69b
--- /dev/null
+++ b/tests/pos/i7653.scala
@@ -0,0 +1,22 @@
+// https://github.com/lampepfl/dotty/issues/7653
+
+object options2 {
+  type Option[T] = {
+    def isEmpty: Boolean
+  }
+  type None[T] = Option[T]
+  val none: () => Option[Nothing] = () =>
+    new {
+      def isEmpty = true
+    }
+  val mkNone0: [T] => () => Option[Nothing] = [T] =>
+    () =>
+      new {
+        def isEmpty = true
+    }
+  val mkNone: [T] => () => Option[T] = [T] =>
+    () =>
+      new {
+        def isEmpty = true
+    }
+}

From 01e7c73e2ebc7c451faf13366b5978aa260beb28 Mon Sep 17 00:00:00 2001
From: som-snytt <som.snytt@gmail.com>
Date: Thu, 11 May 2023 23:51:57 -0700
Subject: [PATCH 569/657] Test require indent after colon at EOL in REPL
 (#17452)

Follow-up https://github.com/lampepfl/dotty/pull/16466

with test from https://github.com/lampepfl/dotty/pull/14092

which was sadly ignored.

Co-authored-by: Gagandeep kalra <gagandeepkalra1994@gmail.com>
---
 compiler/test/dotty/tools/repl/ReplCompilerTests.scala | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/compiler/test/dotty/tools/repl/ReplCompilerTests.scala b/compiler/test/dotty/tools/repl/ReplCompilerTests.scala
index bcb08cd232d7..ecdfeb512e1b 100644
--- a/compiler/test/dotty/tools/repl/ReplCompilerTests.scala
+++ b/compiler/test/dotty/tools/repl/ReplCompilerTests.scala
@@ -347,6 +347,12 @@ class ReplCompilerTests extends ReplTest:
     assertEquals("java.lang.AssertionError: assertion failed", all.head)
   }
 
+  @Test def `i13097 expect lambda after colon` = contextually:
+    assert(ParseResult.isIncomplete("val x = List(42).foreach:"))
+
+  @Test def `i13097 expect template after colon` = contextually:
+    assert(ParseResult.isIncomplete("class C:"))
+
 object ReplCompilerTests:
 
   private val pattern = Pattern.compile("\\r[\\n]?|\\n");

From e9272d5d3a61d87cfe7abe5280db03bae13b41bd Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Fri, 12 May 2023 10:04:35 +0200
Subject: [PATCH 570/657] docs: remove legacy information from core data
 structures (#17464)

This PR is taken from the conversation in
https://github.com/lampepfl/dotty/issues/4015.

> I had a look at it, I think we should just drop core-data-structures.
> There's nothing that's still valuable to know today.

So I dropped most of this, but I also kept a bit of background
information that I found interesting and moved it into the dotc-scalac
page where we have some more info about symbols, denotations, and
differences between dotc/scalac. I thought it fit in nicely there, but
let me know if you'd think it should go somewhere else.

closes #4015

~Based on the comment in
https://github.com/lampepfl/dotty/pull/16776#issuecomment-1542404541, I
made this against language reference stable. I'm assuming this is
correct?~
---
 docs/_docs/internals/core-data-structures.md | 117 -------------------
 docs/_docs/internals/dotc-scalac.md          |  60 ++++++++--
 docs/sidebar.yml                             |   1 -
 3 files changed, 50 insertions(+), 128 deletions(-)
 delete mode 100644 docs/_docs/internals/core-data-structures.md

diff --git a/docs/_docs/internals/core-data-structures.md b/docs/_docs/internals/core-data-structures.md
deleted file mode 100644
index d42a24f0e426..000000000000
--- a/docs/_docs/internals/core-data-structures.md
+++ /dev/null
@@ -1,117 +0,0 @@
----
-layout: doc-page
-title: Core Data Structures
----
-
-(The following is work in progress)
-
-## Symbols and SymDenotations
-
- - why symbols are not enough: their contents change all the time
- - they change themselvesSo a `Symbol`
- - reference: string + sig
-
-
-Dotc is different from most other compilers in that it is centered around the idea of
-maintaining views of various artifacts associated with code. These views are indexed
-by tne
-
-A symbol refers to a definition in a source program. Traditionally,
- compilers store context-dependent data in a _symbol table_. The
- symbol then is the central reference to address context-dependent
- data. But for `scalac`'s requirements it turns out that symbols are
- both too little and too much for this task.
-
-Too little: The attributes of a symbol depend on the phase. Examples:
-Types are gradually simplified by several phases. Owners are changed
-in phases `LambdaLift` (when methods are lifted out to an enclosing
-class) and Flatten (when all classes are moved to top level). Names
-are changed when private members need to be accessed from outside
-their class (for instance from a nested class or a class implementing
-a trait). So a functional compiler, a `Symbol` by itself met mean
-much. Instead we are more interested in the attributes of a symbol at
-a given phase.
-
-`scalac` has a concept for "attributes of a symbol at
-
-Too much: If a symbol is used to refer to a definition in another
-compilation unit, we get problems for incremental recompilation. The
-unit containing the symbol might be changed and recompiled, which
-might mean that the definition referred to by the symbol is deleted or
-changed. This leads to the problem of stale symbols that refer to
-definitions that no longer exist in this form. Scala 2 compiler tried to
-address this problem by _rebinding_ symbols appearing in certain cross
-module references, but it turned out to be too difficult to do this
-reliably for all kinds of references. Scala 3 compiler attacks the problem at
-the root instead. The fundamental problem is that symbols are too
-specific to serve as a cross-module reference in a system with
-incremental compilation. They refer to a particular definition, but
-that definition may not persist unchanged after an edit.
-
-`scalac` uses instead a different approach: A cross module reference is
-always type, either a `TermRef` or ` TypeRef`. A reference type contains
-a prefix type and a name. The definition the type refers to is established
-dynamically based on these fields.
-
-
-a system where sources can be recompiled at any instance,
-
- the concept of a `Denotation`.
-
- Since definitions are transformed by phases,
-
-
-The [Dotty project](https://github.com/lampepfl/dotty)
-is a platform to develop new technology for Scala
-tooling and to try out concepts of future Scala language versions.
-Its compiler is a new design intended to reflect the
-lessons we learned from work with the Scala compiler. A clean redesign
-today will let us iterate faster with new ideas in the future.
-
-Today we reached an important milestone: The Dotty compiler can
-compile itself, and the compiled compiler can act as a drop-in for the
-original one. This is what one calls a *bootstrap*.
-
-## Why is this important?
-
-The main reason is that this gives us a some validation of the
-*trustworthiness* of the compiler itself. Compilers are complex beasts,
-and many things can go wrong. By far the worst things that can go
-wrong are bugs where incorrect code is produced. It's not fun debugging code that looks perfectly
-fine, yet gets translated to something subtly wrong by the compiler.
-
-Having the compiler compile itself is a good test to demonstrate that
-the generated code has reached a certain level of quality. Not only is
-a compiler a large program (44k lines in the case of dotty), it is
-also one that exercises a large part of the language in quite
-intricate ways. Moreover, bugs in the code of a compiler don't tend to
-go unnoticed, precisely because every part of a compiler feeds into
-other parts and all together are necessary to produce a correct
-translation.
-
-## Are We Done Yet?
-
-Far from it! The compiler is still very rough. A lot more work is
-needed to
-
- - make it more robust, in particular when analyzing incorrect programs,
- - improve error messages and warnings,
- - improve the efficiency of some of the generated code,
- - embed it in external tools such as sbt, REPL, IDEs,
- - remove restrictions on what Scala code can be compiled,
- - help in migrating Scala code that will have to be changed.
-
-## What Are the Next Steps?
-
-Over the coming weeks and months, we plan to work on the following topics:
-
- - Make snapshot releases.
- - Get the Scala standard library to compile.
- - Work on SBT integration of the compiler.
- - Work on IDE support.
- - Investigate the best way to obtaining a REPL.
- - Work on the build infrastructure.
-
-If you want to get your hands dirty with any of this, now is a good moment to get involved!
-To get started: <https://github.com/lampepfl/dotty>.
-
diff --git a/docs/_docs/internals/dotc-scalac.md b/docs/_docs/internals/dotc-scalac.md
index 3f88502934b7..03baad375eb1 100644
--- a/docs/_docs/internals/dotc-scalac.md
+++ b/docs/_docs/internals/dotc-scalac.md
@@ -6,7 +6,50 @@ title: "Differences between Scalac and Dotty"
 Overview explanation how symbols, named types and denotations hang together:
 [Denotations1]
 
-## Denotation ##
+## Some background
+
+Dotc is different from most other compilers in that it is centered around the
+idea of maintaining views of various artifacts associated with code. These views
+are indexed by tne.
+
+A symbol refers to a definition in a source program. Traditionally, compilers
+store context-dependent data in a _symbol table_. The symbol then is the central
+reference to address context-dependent data. But for `scalac`'s requirements it
+turns out that symbols are both too little and too much for this task.
+
+### Too little
+
+The attributes of a symbol depend on the phase. Examples: Types are
+gradually simplified by several phases. Owners are changed in phases
+`LambdaLift` (when methods are lifted out to an enclosing class) and Flatten
+(when all classes are moved to top level). Names are changed when private
+members need to be accessed from outside their class (for instance from a nested
+class or a class implementing a trait). So a functional compiler, a `Symbol` by
+itself met mean much. Instead we are more interested in the attributes of a
+symbol at a given phase.
+
+### Too much
+
+If a symbol is used to refer to a definition in another compilation unit, we get
+problems for incremental recompilation. The unit containing the symbol might be
+changed and recompiled, which might mean that the definition referred to by the
+symbol is deleted or changed. This leads to the problem of stale symbols that
+refer to definitions that no longer exist in this form. Scala 2 compiler tried
+to address this problem by _rebinding_ symbols appearing in certain cross module
+references, but it turned out to be too difficult to do this reliably for all
+kinds of references. Scala 3 compiler attacks the problem at the root instead.
+The fundamental problem is that symbols are too specific to serve as a
+cross-module reference in a system with incremental compilation. They refer to a
+particular definition, but that definition may not persist unchanged after an
+edit.
+
+`scalac` uses instead a different approach: A cross module reference is always
+type, either a `TermRef` or ` TypeRef`. A reference type contains a prefix type
+and a name. The definition the type refers to is established dynamically based
+on these fields.
+
+## Denotation
+
 Comment with a few details: [Denotations2]
 
 A `Denotation` is the result of a name lookup during a given period
@@ -21,7 +64,7 @@ A `Denotation` is the result of a name lookup during a given period
 Denotations of methods have a signature ([Signature1]), which
 uniquely identifies overloaded methods.
 
-### Denotation vs. SymDenotation ###
+### Denotation vs. SymDenotation
 A `SymDenotation` is an extended denotation that has symbol-specific properties
 (that may change over phases)
 * `flags`
@@ -31,7 +74,7 @@ A `SymDenotation` is an extended denotation that has symbol-specific properties
 `SymDenotation` implements lazy types (similar to scalac). The type completer
 assigns the denotation's `info`.
 
-### Implicit Conversion ###
+### Implicit Conversion
 There is an implicit conversion:
 ```scala
 core.Symbols.toDenot(sym: Symbol)(implicit ctx: Context): SymDenotation
@@ -42,7 +85,7 @@ implicit conversion does **not** need to be imported, it is part of the
 implicit scope of the type `Symbol` (check the Scala spec). However, it can
 only be applied if an implicit `Context` is in scope.
 
-## Symbol ##
+## Symbol
 * `Symbol` instances have a `SymDenotation`
 * Most symbol properties in the Scala 2 compiler are now in the denotation (in the Scala 3 compiler).
 
@@ -57,7 +100,7 @@ if (sym is Flags.PackageClass)  // Scala 3 (*)
 `(*)` Symbols are implicitly converted to their denotation, see above. Each
 `SymDenotation` has flags that can be queried using the `is` method.
 
-## Flags ##
+## Flags
 * Flags are instances of the value class `FlagSet`, which encapsulates a
   `Long`
 * Each flag is either valid for types, terms, or both
@@ -74,7 +117,7 @@ if (sym is Flags.PackageClass)  // Scala 3 (*)
   `ModuleVal` / `ModuleClass` for either of the two.
 * `flags.is(Method | Param)`: true if `flags` has either of the two
 
-## Tree ##
+## Tree
 * Trees don't have symbols
   - `tree.symbol` is `tree.denot.symbol`
   - `tree.denot` is `tree.tpe.denot` where the `tpe` is a `NamdedType` (see
@@ -86,13 +129,10 @@ if (sym is Flags.PackageClass)  // Scala 3 (*)
     obtained from the symbol that the type refers to. This symbol is searched
     using `prefix.member(name)`.
 
-
-## Type ##
+## Type
  * `MethodType(paramSyms, resultType)` from scalac =>
     `mt @ MethodType(paramNames, paramTypes)`. Result type is `mt.resultType`
 
-`@todo`
-
 [Denotations1]: https://github.com/lampepfl/dotty/blob/a527f3b1e49c0d48148ccfb2eb52e3302fc4a349/compiler/src/dotty/tools/dotc/core/Denotations.scala#L27-L72
 [Denotations2]: https://github.com/lampepfl/dotty/blob/a527f3b1e49c0d48148ccfb2eb52e3302fc4a349/compiler/src/dotty/tools/dotc/core/Denotations.scala#L77-L103
 [Signature1]: https://github.com/lampepfl/dotty/blob/a527f3b1e49c0d48148ccfb2eb52e3302fc4a349/compiler/src/dotty/tools/dotc/core/Signature.scala#L9-L33
diff --git a/docs/sidebar.yml b/docs/sidebar.yml
index 1e791472bceb..d640f15ffa6f 100644
--- a/docs/sidebar.yml
+++ b/docs/sidebar.yml
@@ -189,7 +189,6 @@ subsection:
     subsection:
       - page: internals/backend.md
       - page: internals/classpaths.md
-      - page: internals/core-data-structures.md
       - page: internals/contexts.md
       - page: internals/dotc-scalac.md
       - page: internals/higher-kinded-v2.md

From 8cc9ba3cc0f047f0e112a01f0407d46ea21afafd Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Fri, 12 May 2023 10:03:47 +0200
Subject: [PATCH 571/657] Only set needsInlining if not transforming the
 inlined call.

---
 compiler/src/dotty/tools/dotc/core/Mode.scala     |  3 +++
 .../dotty/tools/dotc/transform/PostTyper.scala    | 15 ++++++++-------
 tests/neg/i17168.scala                            |  2 +-
 3 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/Mode.scala b/compiler/src/dotty/tools/dotc/core/Mode.scala
index 40a45b9f4678..ea63eb6a419b 100644
--- a/compiler/src/dotty/tools/dotc/core/Mode.scala
+++ b/compiler/src/dotty/tools/dotc/core/Mode.scala
@@ -141,4 +141,7 @@ object Mode {
    *  Type `Null` becomes a subtype of non-primitive value types in TypeComparer.
    */
   val RelaxedOverriding: Mode = newMode(30, "RelaxedOverriding")
+
+  /** We are checking the original call of an Inlined node */
+  val InlinedCall: Mode = newMode(31, "InlinedCall")
 }
diff --git a/compiler/src/dotty/tools/dotc/transform/PostTyper.scala b/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
index 597b5aa5885f..09f0fa49c527 100644
--- a/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
@@ -283,16 +283,14 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
           if tree.isType then
             checkNotPackage(tree)
           else
-            if tree.symbol.is(Inline) && !Inlines.inInlineMethod then
-              ctx.compilationUnit.needsInlining = true
             checkNoConstructorProxy(tree)
+            registerNeedsInlining(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
+          registerNeedsInlining(tree)
           if name.isTypeName then
             Checking.checkRealizable(qual.tpe, qual.srcPos)
             withMode(Mode.Type)(super.transform(checkNotPackage(tree)))
@@ -344,8 +342,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
         case tree: TypeApply =>
           if tree.symbol.isQuote then
             ctx.compilationUnit.needsStaging = true
-          if tree.symbol.is(Inline) then
-            ctx.compilationUnit.needsInlining = true
+          registerNeedsInlining(tree)
           val tree1 @ TypeApply(fn, args) = normalizeTypeArgs(tree)
           for arg <- args do
             checkInferredWellFormed(arg)
@@ -363,7 +360,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
         case Inlined(call, bindings, expansion) if !call.isEmpty =>
           val pos = call.sourcePos
           CrossVersionChecks.checkExperimentalRef(call.symbol, pos)
-          super.transform(call)
+          withMode(Mode.InlinedCall)(transform(call))
           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 =>
@@ -505,6 +502,10 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
     private def normalizeErasedRhs(rhs: Tree, sym: Symbol)(using Context) =
       if (sym.isEffectivelyErased) dropInlines.transform(rhs) else rhs
 
+    private def registerNeedsInlining(tree: Tree)(using Context): Unit =
+      if tree.symbol.is(Inline) && !Inlines.inInlineMethod && !ctx.mode.is(Mode.InlinedCall) then
+        ctx.compilationUnit.needsInlining = true
+
     /** Check if the definition has macro annotation and sets `compilationUnit.hasMacroAnnotations` if needed. */
     private def registerIfHasMacroAnnotations(tree: DefTree)(using Context) =
       if !Inlines.inInlineMethod && MacroAnnotations.hasMacroAnnotation(tree.symbol) then
diff --git a/tests/neg/i17168.scala b/tests/neg/i17168.scala
index 6e82cc15abfc..c31889c979b7 100644
--- a/tests/neg/i17168.scala
+++ b/tests/neg/i17168.scala
@@ -1,3 +1,3 @@
 type F[X <: String] = X
 
-val a = summon[F[Int] =:= Int] // error
\ No newline at end of file
+val a = summon[F[Int] =:= Int] // error

From c27f8705b5f65410de923a2ceb95768588bd6c77 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Thu, 4 May 2023 09:15:00 +0200
Subject: [PATCH 572/657] Avoid retraversing parts of the tree that do not
 contain Quote trees

---
 compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
index 5abc92681295..e7a628f68663 100644
--- a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
@@ -95,9 +95,8 @@ class PickleQuotes extends MacroTransform {
         case Apply(Select(quote: Quote, nme.apply), List(quotes)) =>
           val (contents, quote1) = makeHoles(quote)
           val quote2 = encodeTypeArgs(quote1)
-          val contents1 = contents ::: quote.tags
-          val pickled = PickleQuotes.pickle(quote2, quotes, contents1)
-          transform(pickled) // pickle quotes that are in the contents
+          val contents1 = contents.map(transform(_)) ::: quote.tags
+          PickleQuotes.pickle(quote2, quotes, contents1)
         case tree: DefDef if !tree.rhs.isEmpty && tree.symbol.isInlineMethod =>
           tree
         case _ =>

From 75b01265713e6bd9f7869bc3323a3430266a3b1d Mon Sep 17 00:00:00 2001
From: Lucas Leblanc <44496264+Dedelweiss@users.noreply.github.com>
Date: Fri, 12 May 2023 10:31:55 +0200
Subject: [PATCH 573/657] Refactor: Sync Contributing section from Scala-lang
 Guide to Dotty website (#17459)

---
 .../images/contribution/breakpoint.jpg        | Bin 0 -> 137341 bytes
 .../images/contribution/call-stack.jpg        | Bin 0 -> 305288 bytes
 .../contribution/conditional-breakpoint.jpg   | Bin 0 -> 146193 bytes
 .../images/contribution/create-config.jpg     | Bin 0 -> 140865 bytes
 .../images/contribution/debug-console.jpg     | Bin 0 -> 157192 bytes
 .../images/contribution/import-build.jpg      | Bin 0 -> 64305 bytes
 .../contribution/launch-config-file.jpg       | Bin 0 -> 61379 bytes
 .../images/contribution/start-debugger.jpg    | Bin 0 -> 102513 bytes
 docs/_assets/images/contribution/toolbar.jpg  | Bin 0 -> 111169 bytes
 .../contributing/architecture/context.md      |  53 +++++
 docs/_docs/contributing/architecture/index.md |  14 ++
 .../contributing/architecture/lifecycle.md    |  90 ++++++++
 .../_docs/contributing/architecture/phases.md | 108 +++++++++
 .../contributing/architecture/symbols.md      |  70 ++++++
 docs/_docs/contributing/architecture/time.md  |  68 ++++++
 docs/_docs/contributing/architecture/types.md | 147 ++++++++++++
 .../contributing/contribute-knowledge.md      |  12 -
 docs/_docs/contributing/getting-started.md    |  68 ++++--
 docs/_docs/contributing/index.md              |  45 ++++
 docs/_docs/contributing/issues/areas.md       |  70 ++++++
 docs/_docs/contributing/issues/cause.md       | 115 ++++++++++
 docs/_docs/contributing/issues/checklist.md   | 135 +++++++++++
 docs/_docs/contributing/issues/debugging.md   | 189 ++++++++++++++++
 docs/_docs/contributing/issues/efficiency.md  |  24 ++
 docs/_docs/contributing/issues/index.md       |  17 ++
 docs/_docs/contributing/issues/inspection.md  | 181 +++++++++++++++
 .../other-debugging.md}                       |  20 +-
 docs/_docs/contributing/issues/reproduce.md   | 127 +++++++++++
 docs/_docs/contributing/issues/testing.md     | 212 ++++++++++++++++++
 docs/_docs/contributing/procedures/index.md   |   4 +
 docs/_docs/contributing/procedures/vulpix.md  |   1 -
 docs/_docs/contributing/testing.md            | 207 -----------------
 docs/_docs/contributing/tools/index.md        |   5 +
 docs/_docs/contributing/tools/scalafix.md     |   2 -
 docs/_docs/contributing/workflow.md           |  19 ++
 docs/sidebar.yml                              |  26 ++-
 36 files changed, 1770 insertions(+), 259 deletions(-)
 create mode 100644 docs/_assets/images/contribution/breakpoint.jpg
 create mode 100644 docs/_assets/images/contribution/call-stack.jpg
 create mode 100644 docs/_assets/images/contribution/conditional-breakpoint.jpg
 create mode 100644 docs/_assets/images/contribution/create-config.jpg
 create mode 100644 docs/_assets/images/contribution/debug-console.jpg
 create mode 100644 docs/_assets/images/contribution/import-build.jpg
 create mode 100644 docs/_assets/images/contribution/launch-config-file.jpg
 create mode 100644 docs/_assets/images/contribution/start-debugger.jpg
 create mode 100644 docs/_assets/images/contribution/toolbar.jpg
 create mode 100644 docs/_docs/contributing/architecture/context.md
 create mode 100644 docs/_docs/contributing/architecture/index.md
 create mode 100644 docs/_docs/contributing/architecture/lifecycle.md
 create mode 100644 docs/_docs/contributing/architecture/phases.md
 create mode 100644 docs/_docs/contributing/architecture/symbols.md
 create mode 100644 docs/_docs/contributing/architecture/time.md
 create mode 100644 docs/_docs/contributing/architecture/types.md
 delete mode 100644 docs/_docs/contributing/contribute-knowledge.md
 create mode 100644 docs/_docs/contributing/issues/areas.md
 create mode 100644 docs/_docs/contributing/issues/cause.md
 create mode 100644 docs/_docs/contributing/issues/checklist.md
 create mode 100644 docs/_docs/contributing/issues/debugging.md
 create mode 100644 docs/_docs/contributing/issues/efficiency.md
 create mode 100644 docs/_docs/contributing/issues/index.md
 create mode 100644 docs/_docs/contributing/issues/inspection.md
 rename docs/_docs/contributing/{debugging.md => issues/other-debugging.md} (94%)
 create mode 100644 docs/_docs/contributing/issues/reproduce.md
 create mode 100644 docs/_docs/contributing/issues/testing.md
 delete mode 100644 docs/_docs/contributing/testing.md

diff --git a/docs/_assets/images/contribution/breakpoint.jpg b/docs/_assets/images/contribution/breakpoint.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..748088c269c98ddff0acfc7968b4f6b1331f83cd
GIT binary patch
literal 137341
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
ViKq^~LTvC}{fBjbN&nBv{{SdTgS`L%

literal 0
HcmV?d00001

diff --git a/docs/_assets/images/contribution/call-stack.jpg b/docs/_assets/images/contribution/call-stack.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..8fac2371a6c18c490a680e5463722e442d2bc2e6
GIT binary patch
literal 305288
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%0A6ygu8sOc9w>5cFu5`=)VgH
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

literal 0
HcmV?d00001

diff --git a/docs/_assets/images/contribution/conditional-breakpoint.jpg b/docs/_assets/images/contribution/conditional-breakpoint.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..11bab89d3f477d75aeecc14aa2bb88822edb763b
GIT binary patch
literal 146193
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

literal 0
HcmV?d00001

diff --git a/docs/_assets/images/contribution/create-config.jpg b/docs/_assets/images/contribution/create-config.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..60479233ee70fba759eb065f07c42d7c73176a3f
GIT binary patch
literal 140865
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%0AB)6~Y0L!?GRdW!!)=l&q9SRw^mV
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
Vu|>SIXIDO${2BarqrtzI{|`LDS8@OV

literal 0
HcmV?d00001

diff --git a/docs/_assets/images/contribution/debug-console.jpg b/docs/_assets/images/contribution/debug-console.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..c9a669019d65f4222c92ebb201bf4fc997823371
GIT binary patch
literal 157192
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

literal 0
HcmV?d00001

diff --git a/docs/_assets/images/contribution/import-build.jpg b/docs/_assets/images/contribution/import-build.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..79be8450cd4ad27f3364d13d47322ed6eedc6b0b
GIT binary patch
literal 64305
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
E0fs-rwEzGB

literal 0
HcmV?d00001

diff --git a/docs/_assets/images/contribution/launch-config-file.jpg b/docs/_assets/images/contribution/launch-config-file.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..4270f6b2326a8d430f16f98acc43fde7740659f2
GIT binary patch
literal 61379
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
VtD8sk9AF3ld47k~zvBL%|JgR9limOT

literal 0
HcmV?d00001

diff --git a/docs/_assets/images/contribution/start-debugger.jpg b/docs/_assets/images/contribution/start-debugger.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..edf17d700afc4ed9dc5f842667132af742fe1e4f
GIT binary patch
literal 102513
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
MuSYu!_&xW301&<VOaK4?

literal 0
HcmV?d00001

diff --git a/docs/_assets/images/contribution/toolbar.jpg b/docs/_assets/images/contribution/toolbar.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..22ae60ba27e1d3db5aa9711d03014fe9a08dfde3
GIT binary patch
literal 111169
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
GuKzz@9W{gi

literal 0
HcmV?d00001

diff --git a/docs/_docs/contributing/architecture/context.md b/docs/_docs/contributing/architecture/context.md
new file mode 100644
index 000000000000..cd38ee437867
--- /dev/null
+++ b/docs/_docs/contributing/architecture/context.md
@@ -0,0 +1,53 @@
+---
+layout: doc-page
+title: Contexts
+---
+
+`dotc` has almost no global state (with the exception of the name table,
+which hashes strings into unique names). Instead, all
+essential bits of information that can vary over a compiler [run](./lifecycle.md) are collected
+in a `Context` (defined in [Contexts]).
+
+Most methods in the compiler depend on an implicit anonymous `Context` parameter,
+and a typical definition looks like the following:
+```scala
+import dotty.tools.dotc.Contexts.{Context, ctx}
+
+def doFoo(using Context): Unit =
+  val current = ctx.run // access the Context parameter with `ctx`
+```
+
+## Memory Leaks
+> **Careful:** Contexts can be heavy so beware of memory leaks
+
+It is good practice to ensure that implicit contexts are not
+captured in closures or other long-lived objects, in order to avoid space leaks
+in the case where a closure can survive several compiler runs (e.g. a
+lazy completer for a library class that is never required). In that case, the
+convention is that the `Context` be an explicit parameter, to track its usage.
+
+## Context Properties
+
+| Context property  | description                            |
+|-------------------|----------------------------------------|
+| `compilationUnit` | current compilation unit               |
+| `phase`           | current phase                          |
+| `run`             | current run                            |
+| `period`          | current period                         |
+| `settings`        | the config passed to the compiler      |
+| `reporter`        | operations for logging errors/warnings |
+| `definitions`     | the standard built in definitions      |
+| `platform`        | operations for the underlying platform |
+| `tree`            | current tree                           |
+| `scope`           | current scope                          |
+| `typer`           | current typer                          |
+| `owner`           | current owner symbol                   |
+| `outer`           | outer Context                          |
+| `mode`            | type checking mode                     |
+| `typerState`      |                                        |
+| `searchHistory`   |                                        |
+| `implicits`       |                                        |
+| ...               | and so on                              |
+
+
+[Contexts]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/core/Contexts.scala
diff --git a/docs/_docs/contributing/architecture/index.md b/docs/_docs/contributing/architecture/index.md
new file mode 100644
index 000000000000..9b976cc643cd
--- /dev/null
+++ b/docs/_docs/contributing/architecture/index.md
@@ -0,0 +1,14 @@
+---
+layout: index
+title: High Level Architecture
+---
+
+This chapter of the guide describes the architecture and concepts of `dotc`,
+the Scala 3 compiler, including answers to questions such as:
+- "What are the transformations that happen to my code?"
+- "How do I run a compiler programatically?"
+- "What are symbols, denotations, names and types?"
+- "What is a compiler phase?"
+- "What is the compiler Context?"
+
+and many more.
diff --git a/docs/_docs/contributing/architecture/lifecycle.md b/docs/_docs/contributing/architecture/lifecycle.md
new file mode 100644
index 000000000000..2cf58f477da3
--- /dev/null
+++ b/docs/_docs/contributing/architecture/lifecycle.md
@@ -0,0 +1,90 @@
+---
+layout: doc-page
+title: Compiler Overview
+---
+
+At a high level, `dotc` is an interactive compiler (see [what is a compiler?](../index.md#what-is-a-compiler)),
+and can be invoked frequently, for example to answer questions for an IDE, provide REPL completions,
+or to manage incremental builds and more. Each of these use cases requires a customised
+workflow, but sharing a common core.
+
+## Introducing the Compiler's Lifecycle
+
+#### Core
+Customisation is provided by extending the [Compiler] class, which maintains an ordered
+list of [phases][Phases], and how to [run][Run] them. Each interaction with a compiler
+creates a new run, which is a complete iteration of the compiler's phases over a list
+of input sources. Each run has the capability to create new definitions or
+invalidate older ones, and `dotc` can [track these changes over time](../architecture/time.md).
+
+#### Runs
+During a run, the input sources are converted to [compilation units][CompilationUnit] (i.e. the abstraction of
+compiler state associated with each input source); then iteratively: a single phase is applied to
+every compilation unit before progressing to the next phase.
+
+#### Phases
+A phase is an abstract transformation over a compilation unit, it is usually responsible
+for transforming the trees and types representing the code of a source file. Some phases of
+the compiler are:
+- `parser`, which converts text that matches Scala's
+  [syntax] into abstract syntax trees, ASTs
+- `typer`, which checks that trees conform to expected types
+- `erasure`, which retypes a more simplified program into one that has the same types as the JVM.
+- `genBCode`, the JVM backend, which converts erased compiler trees into Java bytecode format.
+
+[You can read more about phases here](../architecture/phases.md#phase-categories).
+
+#### Drivers
+
+The core compiler also requires a lot of state to be initialised before use, such as [settings][ScalaSettings]
+and the [Context](../architecture/context.md). For convenience, the [Driver] class contains high level functions for
+configuring the compiler and invoking it programatically. The object [Main] inherits from `Driver`
+and is invoked by the `scalac` script.
+
+## Code Structure
+
+The code of the compiler is found in the package [dotty.tools],
+containing the following sub-packages:
+```scala
+tools // contains helpers and the `scala` generic runner
+├── backend // Compiler backends (currently JVM and JS)
+├── dotc // The main compiler, with subpackages:
+│   ├── ast // Abstract syntax trees
+│   ├── classpath
+│   ├── config // Compiler configuration, settings, platform specific definitions.
+│   ├── core // Core data structures and operations, with specific subpackages for:
+│   │   ├── classfile // Reading of Java classfiles into core data structures
+│   │   ├── tasty // Reading and writing of TASTY files to/from core data structures
+│   │   └── unpickleScala2 // Reading of Scala2 symbol information into core data structures
+│   ├── decompiler // pretty printing TASTY as code
+│   ├── fromtasty // driver for recompilation from TASTY
+│   ├── interactive // presentation compiler and code completions
+│   ├── parsing // Scanner and parser
+│   ├── plugins // compile plugin definitions
+│   ├── printing // Pretty-printing trees, types and other data
+│   ├── profile // internals for profiling the compiler
+│   ├── quoted // internals for quoted reflection
+│   ├── reporting // Reporting of error messages, warnings and other info.
+│   ├── rewrites // Helpers for rewriting Scala 2's constructs into Scala 3's.
+│   ├── sbt // Helpers for communicating with the Zinc compiler.
+│   ├── semanticdb // Helpers for exporting semanticdb from trees.
+│   ├── transform // Miniphases and helpers for tree transformations.
+│   ├── typer // Type-checking
+│   └── util // General purpose utility classes and modules.
+├── io // Helper modules for file access and classpath handling.
+├── repl // REPL driver and interaction with the terminal
+├── runner // helpers for the `scala` generic runner script
+└── scripting // scala runner for the -script argument
+```
+
+
+[Phases]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/core/Phases.scala
+[CompilationUnit]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/CompilationUnit.scala
+
+[dotty.tools]: https://github.com/lampepfl/dotty/tree/master/compiler/src/dotty/tools
+[ScalaSettings]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala
+[syntax]: https://docs.scala-lang.org/scala3/reference/syntax.html
+[Main]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/Main.scala
+[Driver]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/Driver.scala
+[Compiler]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/Compiler.scala
+[Run]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/Run.scala
\ No newline at end of file
diff --git a/docs/_docs/contributing/architecture/phases.md b/docs/_docs/contributing/architecture/phases.md
new file mode 100644
index 000000000000..15690dfe4e4e
--- /dev/null
+++ b/docs/_docs/contributing/architecture/phases.md
@@ -0,0 +1,108 @@
+---
+layout: doc-page
+title: Compiler Phases
+---
+
+As described in the [compiler overview](lifecycle.md#phases), `dotc` is divided into a list of [phases][Phase],
+specified in the [Compiler] class.
+
+#### Printing the phases of the Compiler
+
+a flattened list of all the phases can be displayed by invoking
+the compiler with the `-Xshow-phases` flag:
+```
+$ scalac -Xshow-phases
+```
+
+## Phase Groups
+
+In class [Compiler] you can access the list of phases with the method `phases`:
+
+```scala
+def phases: List[List[Phase]] =
+  frontendPhases ::: picklerPhases ::: transformPhases ::: backendPhases
+```
+
+You can see that phases are actually grouped into sublists, given by the signature
+`List[List[Phase]]`; that is, each sublist forms a phase group that is then *fused* into a
+single tree traversal when a [Run] is executed.
+
+Phase fusion allows each phase of a group to be small and modular,
+(each performing a single function), while reducing the number of tree traversals
+and increasing performance.
+
+Phases are able to be grouped together if they inherit from [MiniPhase].
+
+## Phase Categories
+
+Phases fall into four categories, allowing customisation by sub-classes of [Compiler]:
+
+### `frontendPhases`
+In the main compiler these include [parser], [typer], [posttyper],
+[prepjsinterop] and phases for producing SemanticDB and communicating with the
+incremental compiler Zinc.
+The [parser] reads source programs and generates untyped abstract syntax trees, which
+in [typer] are then typechecked and transformed into typed abstract syntax trees.
+Following is [posttyper], performing checks and cleanups that require a fully typed program.
+In particular, it
+- creates super accessors representing `super` calls in traits
+- creates implementations of compiler-implemented methods,
+such as `equals` and `hashCode` for case classes.
+- marks [compilation units][CompilationUnit] that require inline expansion, or quote pickling
+- simplifies trees of erased definitions
+- checks variance of type parameters
+- mark parameters passed unchanged from subclass to superclass for later pruning.
+
+### `picklerPhases`
+These phases start with [pickler], which serializes typed trees
+produced by the `frontendPhases` into TASTy format. Following is [inlining],
+which expand calls to inline methods, and [postInlining] providing implementations
+of the [Mirror] framework for inlined calls.
+Finally are [staging], which ensures that quotes conform to the
+[Phase Consistency Principle (PCP)][PCP], and [pickleQuotes] which converts quoted
+trees to embedded TASTy strings.
+
+### `transformPhases`
+These phases are concerned with tranformation into lower-level forms
+suitable for the runtime system, with two sub-groupings:
+- High-level transformations: All phases from [firstTransform] to [erasure].
+  Most of these phases transform syntax trees, expanding high-level constructs
+  to more primitive ones.
+  - An important transform phase is [patternMatcher], which converts match
+    trees and patterns into lower level forms, as well as checking the
+    exhaustivity of sealed types, and unreachability of pattern cases.
+  - Some phases perform further checks on more primitive trees,
+    e.g. [refchecks] verifies that no abstract methods exist in concrete classes,
+    and [initChecker] checks that fields are not used before initialisation.
+  - The last phase in the group, [erasure] translates all
+    types into types supported directly by the JVM. To do this, it performs
+    another type checking pass, but using the rules of the JVM's type system
+    instead of Scala's.
+- Low-level transformations: All phases from `ElimErasedValueType` to
+  `CollectSuperCalls`. These further transform trees until they are essentially a
+  structured version of Java bytecode.
+
+### `backendPhases`
+These map the transformed trees to Java classfiles or SJSIR files.
+
+[CompilationUnit]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/CompilationUnit.scala
+[Compiler]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/Compiler.scala
+[Phase]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/core/Phases.scala
+[MiniPhase]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/transform/MegaPhase.scala
+[Run]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/Run.scala
+[parser]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/parsing/ParserPhase.scala
+[typer]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/typer/TyperPhase.scala
+[posttyper]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
+[prepjsinterop]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/transform/sjs/PrepJSInterop.scala
+[pickler]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/transform/Pickler.scala
+[inlining]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/transform/Inlining.scala
+[postInlining]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/transform/PostInlining.scala
+[staging]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/transform/Staging.scala
+[pickleQuotes]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
+[refchecks]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
+[initChecker]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/transform/init/Checker.scala
+[firstTransform]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala
+[patternMatcher]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala
+[erasure]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/transform/Erasure.scala
+[Mirror]: https://github.com/lampepfl/dotty/blob/master/library/src/scala/deriving/Mirror.scala
+[PCP]: {{ site.scala3ref }}/metaprogramming/macros.html#the-phase-consistency-principle
diff --git a/docs/_docs/contributing/architecture/symbols.md b/docs/_docs/contributing/architecture/symbols.md
new file mode 100644
index 000000000000..c19588a4ff12
--- /dev/null
+++ b/docs/_docs/contributing/architecture/symbols.md
@@ -0,0 +1,70 @@
+---
+layout: doc-page
+title: Symbols
+---
+
+As discussed previously, `dotc` [maintains time-indexed views](time.md) of various
+compiler artifacts. The following sections discuss how they are managed in the compiler.
+
+## Symbols
+
+Defined in [Symbols], a `Symbol` is a unique identifier for a definition (e.g. a method,
+type, or field).  A `ClassSymbol` extends `Symbol` and represents either a
+`class`, or a `trait`, or an `object`. A `Symbol` can even refer to non-Scala entities,
+such as from the Java standard library.
+
+## Definitions are Dynamic
+
+Traditionally, compilers store context-dependent data in a _symbol table_.
+Where a symbol then is the central reference to address context-dependent data.
+`dotc` instead uses a phase-indexed function (known as
+a [Denotation][Denotations]) to compute views of definitions across phases,
+as many of attributes associated with definitions are phase-dependent. For example:
+- types are gradually simplified by several phases,
+- owners change in [lambdaLift] (local methods are lifted to an enclosing class)
+  and [flatten] (when inner classes are moved to the top level)
+- Names are changed when private members need to be accessed from outside
+  their class (for instance from a nested class or a class implementing
+  a trait).
+
+Additionally, symbols are not suitable to be used as a reference to
+a definition in another [compilation unit][CompilationUnit].
+In the context of incremental compilation, a symbol from
+an external compilation unit may be deleted or changed, making the reference
+stale. To counter this, `dotc` types trees of cross-module references with either
+a `TermRef` or `TypeRef`. A reference type contains a prefix type and a name.
+The denotation that the type refers to is established dynamically based on
+these fields.
+
+## Denotations
+
+On its own a `Symbol` has no structure. Its semantic meaning is given by being associated
+with a [Denotation][Denotations].
+
+A denotation is the result of resolving a name during a given period, containing the information
+describing some entity (either a term or type), indexed by phase. Denotations usually have a
+reference to a selected symbol, but not always, for example if the denotation is overloaded,
+i.e. a `MultiDenotation`.
+
+### SymDenotations
+All definition symbols will contain a `SymDenotation`. The denotation, in turn, contains:
+- a reverse link to the source symbol
+- a reference to the enclosing symbol that defined the source symbol:
+  - for a local variable, the enclosing method
+  - for a field or class, the enclosing class
+- a set of [flags], describing the definition (e.g. whether it's a trait or mutable).
+- the type of the definition (through the `info` method)
+- a [signature][Signature1], which uniquely identifies overloaded methods (or else `NotAMethod`).
+- and more.
+
+A class symbol will instead be associated with a `ClassDenotation`, which extends `SymDenotation`
+with some additional fields specific for classes.
+
+[Signature1]: https://github.com/lampepfl/dotty/blob/a527f3b1e49c0d48148ccfb2eb52e3302fc4a349/compiler/src/dotty/tools/dotc/core/Signature.scala#L9-L33
+[Symbols]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/core/Symbols.scala
+[flatten]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/transform/Flatten.scala
+[lambdaLift]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/transform/LambdaLift.scala
+[CompilationUnit]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/CompilationUnit.scala
+[Denotations]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/core/Denotations.scala
+[SymDenotations]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
+[flags]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/core/Flags.scala
diff --git a/docs/_docs/contributing/architecture/time.md b/docs/_docs/contributing/architecture/time.md
new file mode 100644
index 000000000000..588b1ce40bb2
--- /dev/null
+++ b/docs/_docs/contributing/architecture/time.md
@@ -0,0 +1,68 @@
+---
+layout: doc-page
+title: Time in the Compiler
+---
+
+In the [compiler overview](lifecycle.md) section, we saw that `dotc` is an interactive compiler,
+and so can answer questions about entities as they come into existance and change throughout time,
+for example:
+- which new definitions were added in a REPL session?
+- which definitions were replaced in an incremental build?
+- how are definitions simplified as they are adapted to the runtime system?
+
+## Hours, Minutes, and Periods
+
+For the compiler to be able to resolve the above temporal questions, and more, it maintains
+a concept of time. Additionally, because interactions are frequent, it is important to
+persist knowledge of entities between interactions, allowing the compiler to remain performant.
+Knowing about time allows the compiler to efficiently mark entities as being outdated.
+
+Conceptually, `dotc` works like a clock, where its minutes are represented by [phases](phases.md),
+and its hours by [runs]. Like a clock, each run passes once each of its phases have completed
+sequentially, and then a new run can begin. Phases are further grouped into [periods], where
+during a period certain entities of the compiler remain stable.
+
+## Time Travel
+
+During a run, each phase can rewrite the world as the compiler sees it, for example:
+- to transform trees,
+- to gradually simplify type from Scala types to JVM types,
+- to move definitions out of inner scopes to outer ones, fitting the JVM's model,
+- and so on.
+
+Because definitions can [change over time](symbols.md#definitions-are-dynamic), various artifacts associated with them
+are stored non-destructively, and views of the definition created earlier, or later
+in the compiler can be accessed by using the `atPhase` method, defined in [Contexts].
+
+As an example, assume the following definitions are available in a [Context](context.md):
+```scala
+class Box { type X }
+
+def foo(b: Box)(x: b.X): List[b.X] = List(x)
+```
+
+You can compare the type of definition `foo` after the [typer] phase and after the [erasure] phase
+by using `atPhase`:
+```scala
+import dotty.tools.dotc.core.Contexts.{Context, atPhase}
+import dotty.tools.dotc.core.Phases.{typerPhase, erasurePhase}
+import dotty.tools.dotc.core.Decorators.i
+
+given Context = …
+
+val fooDef: Symbol = … // `def foo(b: Box)(x: b.X): List[b.X]`
+
+println(i"$fooDef after typer   => ${atPhase(typerPhase.next)(fooDef.info)}")
+println(i"$fooDef after erasure => ${atPhase(erasurePhase.next)(fooDef.info)}")
+```
+and see the following output:
+```
+method foo after typer   => (b: Box)(x: b.X): scala.collection.immutable.List[b.X]
+method foo after erasure => (b: Box, x: Object): scala.collection.immutable.List
+```
+
+[runs]: https://github.com/lampepfl/dotty/blob/a527f3b1e49c0d48148ccfb2eb52e3302fc4a349/compiler/src/dotty/tools/dotc/Run.scala
+[periods]: https://github.com/lampepfl/dotty/blob/a527f3b1e49c0d48148ccfb2eb52e3302fc4a349/compiler/src/dotty/tools/dotc/core/Periods.scala
+[Contexts]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/core/Contexts.scala
+[typer]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/typer/TyperPhase.scala
+[erasure]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/transform/Erasure.scala
diff --git a/docs/_docs/contributing/architecture/types.md b/docs/_docs/contributing/architecture/types.md
new file mode 100644
index 000000000000..64543e555e69
--- /dev/null
+++ b/docs/_docs/contributing/architecture/types.md
@@ -0,0 +1,147 @@
+---
+layout: doc-page
+title: Compiler Types
+---
+
+## Common Types and their Representation
+
+Type representations in `dotc` derive from the class `dotty.tools.dotc.core.Types.Type`,
+defined in [Types.scala]. The `toString` method on `Type` will display types in a
+format corresponding to the backing data structure, e.g. `ExprType(...)`
+corresponds to `class ExprType`, defined in [Types.scala].
+
+> You can inspect the representation of any type using the [dotty.tools.printTypes][DottyTypeStealer]
+> script, its usage and integration into your debugging workflow is [described here](../issues/inspection.md).
+
+### Types of Definitions
+
+The following table describes definitions in Scala 3, followed by the `dotc` representation
+of two types - a reference to the definition, and then its underlying type.
+
+**Note**: in the following types, `p` refers to the self-type of the enclosing scope of
+the definition, or `NoPrefix` for local definitions and parameters.
+
+Definition              | Reference       | Underlying Type
+------------------------|-----------------|-------------------------
+`type Z >: A <: B`      | `TypeRef(p, Z)` | `RealTypeBounds(A, B)`
+`type Z = A`            | `TypeRef(p, Z)` | `TypeAlias(A)`
+`type F[T] = T match …` | `TypeRef(p, F)` | `MatchAlias([T] =>> T match …)`
+`class C`               | `TypeRef(p, C)` | `ClassInfo(p, C, …)`
+`trait T`               | `TypeRef(p, T)` | `ClassInfo(p, T, …)`
+`object o`              | `TermRef(p, o)` | `TypeRef(p, o$)` where `o$` is a class
+`def f(x: A): x.type`   | `TermRef(p, f)` | `MethodType(x, A, TermParamRef(x))`
+`def f[T <: A]: T`      | `TermRef(p, f)` | `PolyType(T, <: A, TypeParamRef(T))`
+`def f: A`              | `TermRef(p, f)` | `ExprType(A)`
+`(x: => A)`             | `TermRef(p, x)` | `ExprType(A)` where `x` is a parameter
+`val x: A`              | `TermRef(p, x)` | `A`
+
+### Types of Values
+
+The following types may appear in part of the type of an expression:
+
+Type                      | Representation
+--------------------------|------------------------------
+`x.y.type`                | `TermRef(x, y)`
+`X#T`                     | `TypeRef(X, T)`
+`x.y.T` and `x.y.type#T`  | `TypeRef(TermRef(x, y), T)`
+`this.type`               | `ThisType(C)` where `C` is the enclosing class
+`"hello"`                 | `ConstantType(Constant("hello"))`
+`A & B`                   | `AndType(A, B)`
+`A | B`                   | `OrType(A, B)`
+`A @foo`                  | `AnnotatedType(A, @foo)`
+`[T <: A] =>> T`          | `HKTypeLambda(T, <: A, TypeParamRef(T))`
+`x.C[A, B]`               | `AppliedType(x.C, List(A, B))`
+`C { type A = T }`        | `RefinedType(C, A, T)`<br/>when `T` is not a member of `C`
+`C { type X = Y }`        | `RecType(RefinedType(C, X, z.Y))`<br/>when `X` and `Y` are members of `C`<br/>and `z` is a `RecThis` over the enclosing `RecType`
+`super.x.type`            | `TermRef(SuperType(…), x)`
+
+## Constructing Types
+
+### Method Definition Types
+
+You can see above that method definitions can have an underlying type of
+either `PolyType`, `MethodType`, or `ExprType`. `PolyType` and `MethodType`
+may be mixed recursively however, and either can appear as the result type of the other.
+
+Take this example as given:
+
+```scala
+def f[A, B <: Seq[A]](x: A, y: B): Unit
+```
+it can be constructed by the following code:
+
+```scala
+import dotty.tools.dotc.core.Types.*
+import dotty.tools.dotc.core.Symbols.*
+import dotty.tools.dotc.core.Contexts.*
+import dotty.tools.dotc.core.Decorators.*
+
+given Context = … // contains the definitions of the compiler
+
+val f: Symbol = … // def f[A, B <: Seq[A]](x: A, y: B): Unit
+
+f.info = PolyType(
+  List("A".toTypeName, "B".toTypeName))(
+  pt => List(
+    TypeBounds(defn.NothingType, defn.AnyType),
+    TypeBounds(defn.NothingType, AppliedType(defn.SeqType, List(pt.newParamRef(0))))
+  ),
+  pt => MethodType(
+    List("x".toTermName, "y".toTermName))(
+    mt => List(pt.newParamRef(0), pt.newParamRef(1)),
+    mt => defn.UnitType
+  )
+)
+```
+
+Note that `pt.newParamRef(0)` and `pt.newParamRef(1)` refers to the
+type parameters `A` and `B` respectively.
+
+## Proxy Types and Ground Types
+Types in `dotc` are divided into two semantic kinds:
+- Ground Types (inheriting from either `CachedGroundType` or `UncachedGroundType`)
+- Proxy Types (inheriting from `TypeProxy` via either `CachedProxyType` or `UncachedProxyType`)
+
+A Proxy Type is anything that can be considered to be an abstraction of another type,
+which can be accessed by the `underlying` method of the `TypeProxy` class. It's dual, the
+Ground Type has no meaningful underlying type, typically it is the type of method and class
+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]:
+
+```
+Type -+- proxy_type --+- NamedType --------+- TypeRef
+      |               |                     \
+      |               +- SingletonType ----+- TermRef
+      |               |                    +- ThisType
+      |               |                    +- SuperType
+      |               |                    +- ConstantType
+      |               |                    +- TermParamRef
+      |               |                    +- RecThis
+      |               |                    +- SkolemType
+      |               +- TypeParamRef
+      |               +- RefinedOrRecType -+-- RefinedType
+      |               |                   -+-- RecType
+      |               +- AppliedType
+      |               +- TypeBounds
+      |               +- ExprType
+      |               +- AnnotatedType
+      |               +- TypeVar
+      |               +- HKTypeLambda
+      |               +- MatchType
+      |
+      +- ground_type -+- AndType
+                      +- OrType
+                      +- MethodOrPoly -----+-- PolyType
+                      |                    +-- MethodType
+                      +- ClassInfo
+                      +- NoType
+                      +- NoPrefix
+                      +- ErrorType
+                      +- WildcardType
+
+```
+
+[Types.scala]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/core/Types.scala
+[DottyTypeStealer]: https://github.com/lampepfl/dotty/blob/master/compiler/test/dotty/tools/DottyTypeStealer.scala
diff --git a/docs/_docs/contributing/contribute-knowledge.md b/docs/_docs/contributing/contribute-knowledge.md
deleted file mode 100644
index 7164774ac1df..000000000000
--- a/docs/_docs/contributing/contribute-knowledge.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-layout: doc-page
-title: Contributing Knowledge
----
-
-# Contribute Internals-related Knowledge
-If you know anything useful at all about Dotty, feel free to log this knowledge:
-
-- [📜Log the Knowledge](https://github.com/lampepfl/dotty-knowledge/issues/new)
-- [🎓More about Logging the Knowledge](https://github.com/lampepfl/dotty-knowledge/blob/master/README.md)
-
-In short, no need to make it pretty, particularly human-readable or give it a particular structure. Just dump the knowledge you have and we'll take it from there.
\ No newline at end of file
diff --git a/docs/_docs/contributing/getting-started.md b/docs/_docs/contributing/getting-started.md
index c842fd0a49d0..239e738bbfbb 100644
--- a/docs/_docs/contributing/getting-started.md
+++ b/docs/_docs/contributing/getting-started.md
@@ -3,15 +3,41 @@ layout: doc-page
 title: Getting Started
 ---
 
+## Scala CLA
 
+Sometime before submitting your pull request you'll want to make sure you have
+signed the [Scala CLA][scala-cla]. You can read more about why we require a CLA
+and what exactly is included in it [here][scala-cla].
 
-Requirements
-------------
-Make sure that you are using macOS or Linux (or WSL on Windows) with Java 8 or newer. You can determine which version of the JDK is the
-default by typing `java -version` in a Terminal window.
+## Making sure the team is aware
+
+Before digging into an issue or starting on a new feature it's a good idea to
+make sure an [issue][dotty-issue] or a [discussion][dotty-discussion] has been
+created outlining what you plan to work on. This is both for your and the team's
+benefit. It ensures you get the help you need, and also gives the compiler team
+a heads-up that someone is working on an issue.
+
+For some small changes like documentation, this isn't always necessary, but it's
+never a bad idea to check.
+
+## Requirements
+
+- [git] is essential for managing the Scala 3 code, and contributing to GitHub,
+  where the code is hosted.
+- A Java Virtual Machine (JDK 8 or higher), required for running the build tool.
+  - download Java from [Oracle Java 8][java8], [Oracle Java 11][java11],
+   or [AdoptOpenJDK 8/11][adopt]. Refer to [JDK Compatibility][compat] for Scala/Java compatibility detail.
+  - Verify that the JVM is installed by running the following command in a terminal: `java -version`.
+- [sbt][sbt-download], the build tool required to build the Scala 3 compiler and libraries.
+
+## Nice To Have
+
+An IDE, such as [Metals] will help you develop in Scala 3 with features such as autocompletion or goto-definition,
+and with the [VS Code][vs-code] text editor you can even use the Scala debugger, or create interactive worksheets for an
+iterative workflow.
+
+## Compiling and Running
 
-Compiling and Running
----------------------
 Start by cloning the repository:
 
 ```bash
@@ -48,8 +74,8 @@ $ scala HelloWorld
 ```
 
 
-Starting a REPL
----------------
+## Starting a REPL
+
 ```bash
 $ sbt
 > repl
@@ -64,8 +90,9 @@ or via bash:
 ```bash
 $ scala
 ```
-Publish to local repository
----------------------------------
+
+## Publish to local repository
+
 To test our cloned compiler on local projects:
 
 ```bash
@@ -79,8 +106,8 @@ ThisBuild / scalaVersion := "<dotty-version>-bin-SNAPSHOT"
 where `dotty-version` can be found in the file `project/Build.scala`, like `3.0.0-M2`
 
 
-Generating Documentation
--------------------------
+## Generating Documentation
+
 To generate this page and other static page docs, run
 ```bash
 $ sbt
@@ -92,9 +119,22 @@ Before contributing to Dotty, we invite you to consult the
 [Dotty Developer Guidelines](https://github.com/lampepfl/dotty/blob/main/CONTRIBUTING.md).
 
 
-Community
--------------
+## Community
+
 The main development discussion channels are:
 - [github.com/lampepfl/dotty/discussions](https://github.com/lampepfl/dotty/discussions)
 - [contributors.scala-lang.org](https://contributors.scala-lang.org)
 - [gitter.im/scala/contributors](https://gitter.im/scala/contributors)
+
+[git]: https://git-scm.com
+[Metals]: https://scalameta.org/metals/
+[vs-code]: https://code.visualstudio.com
+[lampepfl/dotty]: https://github.com/lampepfl/dotty
+[sbt-download]: https://www.scala-sbt.org/download.html
+[java8]: https://www.oracle.com/java/technologies/javase-jdk8-downloads.html
+[java11]: https://www.oracle.com/java/technologies/javase-jdk11-downloads.html
+[adopt]: https://adoptopenjdk.net/
+[compat]: /overviews/jdk-compatibility/overview.html
+[scala-cla]: https://www.lightbend.com/contribute/cla/scala
+[dotty-issue]: https://github.com/lampepfl/dotty/issues
+[dotty-discussion]: https://github.com/lampepfl/dotty/discussions
diff --git a/docs/_docs/contributing/index.md b/docs/_docs/contributing/index.md
index 6cf0def2d5e2..27954aefd7a1 100644
--- a/docs/_docs/contributing/index.md
+++ b/docs/_docs/contributing/index.md
@@ -2,3 +2,48 @@
 layout: index
 title: Contributing
 ---
+
+This guide is intended to give new contributors the knowledge they need to
+become productive and fix issues or implement new features in Scala 3. It
+also documents the inner workings of the Scala 3 compiler, `dotc`.
+
+### This is a living document
+
+Keep in mind that the code for `dotc` is continually changing, so the ideas
+discussed in this guide may fall out of date. This is a living document, so
+please consider contributing to it on
+[GitHub](https://github.com/scala/docs.scala-lang/tree/main/_overviews/scala3-contribution)
+if you notice anything out of date, or report any issues
+[here](https://github.com/scala/docs.scala-lang/issues).
+
+### Get the Most from This Guide
+
+`dotc` is built with Scala 3, fully utilising its [new
+features](/scala3/new-in-scala3.html). It is recommended that you first have
+some familiarity with Scala 3 to get the most out of this guide. You can learn
+more in the [language reference]({{ site.scala3ref }}).
+
+Many code snippets in this guide make use of shell commands (a line beginning
+with `$`), and in this case a `bash` compatible shell is assumed. You may have
+to look up how to translate commands to your shell.
+
+### What is a Compiler?
+
+Let's start at the beginning and first look at the question of "what is a
+compiler?". A compiler is a program that takes as input text, representing a
+program in one language and produces as output the same program, written in
+another programming language.
+
+#### The Scala Compiler
+
+As an example, `dotc` takes text input, verifies that it is a valid Scala program
+and then produces as output the same program, but written in Java bytecode, and optionally
+in SJSIR when producing Scala.js output.
+
+### Contribute Internals-related Knowledge
+If you know anything useful at all about Dotty, feel free to log this knowledge:
+
+- [📜Log the Knowledge](https://github.com/lampepfl/dotty-knowledge/issues/new)
+- [🎓More about Logging the Knowledge](https://github.com/lampepfl/dotty-knowledge/blob/master/README.md)
+
+In short, no need to make it pretty, particularly human-readable or give it a particular structure. Just dump the knowledge you have and we'll take it from there.
\ No newline at end of file
diff --git a/docs/_docs/contributing/issues/areas.md b/docs/_docs/contributing/issues/areas.md
new file mode 100644
index 000000000000..4f9adf79ba77
--- /dev/null
+++ b/docs/_docs/contributing/issues/areas.md
@@ -0,0 +1,70 @@
+---
+layout: doc-page
+title: Common Issue Locations
+---
+
+Many issues are localised to small domains of the compiler and are self-contained,
+here is a non-exhaustive list of such domains, and the files associated with them:
+
+### Pretty Printing of Types and Trees
+
+Objects in the compiler that inherit from [Showable] can be pretty printed.
+The pretty-printing of objects is used in many places, from debug output,
+to user-facing error messages and printing of trees after each phase.
+
+Look in [RefinedPrinter] (or its parent class [PlainPrinter]) for the implementation of pretty printing.
+
+### Content of Error Messages
+
+You can find the definitions of most error messages in [messages] (with IDs
+defined in [ErrorMessageID]). If the message is not defined there, try the
+`-Ydebug-error` compiler flag, which will print a stack trace leading to the
+production of the error, and the contents of the message.
+
+### Compiler Generated Given Instances
+
+If the issue lies in given instances provided by the compiler, such as `scala.reflect.ClassTag`,
+`scala.deriving.Mirror`, `scala.reflect.TypeTest`, `scala.CanEqual`, `scala.ValueOf`,
+`scala.reflect.Manifest`, etc, look in [Synthesizer], which provides factories for
+given instances.
+
+### Compiler Generated Methods
+
+Members can be generated for many classes, such as `equals` and `hashCode`
+for case classes and value classes, and `ordinal` and `fromProduct` for Mirrors.
+To change the implementation, see [SyntheticMembers].
+
+### Code Completions
+For suggestions to auto-complete method selections, see [Completion].
+
+### Enum Desugaring
+See [Desugar] and [DesugarEnums].
+
+### Pattern Match Exhaustivity
+See [Space].
+
+### Metaprogramming
+
+#### Quotes Reflection
+See the [quoted runtime package][quotes-impl].
+
+#### Inline match
+See [Inliner].
+
+#### Compiletime Ops Types
+See `tryCompiletimeConstantFold` in [Types].
+
+[Showable]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/printing/Showable.scala
+[PlainPrinter]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
+[RefinedPrinter]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+[ErrorMessageID]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala
+[messages]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/reporting/messages.scala
+[Synthesizer]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/typer/Synthesizer.scala
+[SyntheticMembers]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/transform/SyntheticMembers.scala
+[quotes-impl]: https://github.com/lampepfl/dotty/tree/master/compiler/src/scala/quoted/runtime/impl
+[Inliner]: https://github.com/lampepfl/dotty/blob/main/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
+[Types]: https://github.com/lampepfl/dotty/tree/master/compiler/src/dotty/tools/dotc/core/Types.scala
+[Completion]: https://github.com/lampepfl/dotty/tree/master/compiler/src/dotty/tools/dotc/interactive/Completion.scala
+[DesugarEnums]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/ast/DesugarEnums.scala
+[Desugar]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+[Space]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
diff --git a/docs/_docs/contributing/issues/cause.md b/docs/_docs/contributing/issues/cause.md
new file mode 100644
index 000000000000..5bb04e894f70
--- /dev/null
+++ b/docs/_docs/contributing/issues/cause.md
@@ -0,0 +1,115 @@
+---
+layout: doc-page
+title: Finding the Cause of an Issue
+---
+
+In this section, you will be able to answer questions such as:
+- where does an error happen in a codebase?
+- when during compilation was a particular tree introduced?
+- where is a particular object created?
+- where is a particular value assigned to a variable?
+
+> You may be able to quickly find the source responsible for an issue by consulting [common issue locations](../issues/areas.md)
+
+## What phase generated a particular tree?
+
+As described in the [compiler lifecycle](../architecture/lifecycle.md#phases), each phase transforms the trees
+and types that represent your code in a certain way.
+
+To print the code as it is transformed through the compiler, use the compiler flag `-Xprint:all`.
+After each phase group is completed, you will see the resulting trees representing the code.
+
+> It is recommended to test `-Xprint:all` on a single, small file, otherwise a lot of unnecessary
+> output will be generated.
+
+### Trace a Tree Creation Site
+
+When you see a problematic tree appear after a certain phase group, you know to isolate the rest of
+your search to the code of that phase. For example if you found a problematic tree after phase
+`posttyper`, the problem most likely appears in the code of [PostTyper]. We can trace the exact point
+the tree was generated by looking for its unique ID, and then generating a stack trace at its creation:
+
+1. Run the compiler with `-Xprint:posttyper` and `-Yshow-tree-ids` flags.
+   This will only print the trees of the `posttyper` phase. This time you should see the tree
+   in question be printed alongside its ID. You'll see something like `println#223("Hello World"#37)`.
+2. Copy the ID of the desired tree.
+3. Run the compiler with `-Ydebug-tree-with-id <tree-id>` flag. The compiler will print a stack trace
+   pointing to the creation site of the tree with the provided ID.
+
+### Enhanced Tree Printing
+
+As seen above `-Xprint:<phase>` can be enhanced with further configuration flags, found in
+[ScalaSettings]. For example, you can additionally print the type of a tree with `-Xprint-types`.
+
+## Increasing Logging Output
+Once you have identified the phase that generated a certain tree, you can then increase
+logging in that phase, to try and detect erroneous states:
+
+- general logging within a phase can be enabled with the `-Ylog` compiler flag, such as
+  - `-Ylog:<phase1>,<phase2>,...` for individual phases
+  - `-Ylog:all` for all phases.
+- Additionally, various parts of the compiler have specialised logging objects, defined in [Printers].
+  Change any of the printers of interest from `noPrinter` to `default` and increase output specialised
+  to that domain.
+
+## Navigating to Where an Error is Generated
+
+The compiler issues user facing errors for code that is not valid, such as the type mismatch
+of assigning an `Int` to a `Boolean` value. Sometimes these errors do not match what is expected, which could be a bug.
+
+To discover why such a *spurious* error is generated, you can trace the code that generated the error by
+adding the `-Ydebug-error` compiler flag, e.g. `scala3/scalac -Ydebug-error Test.scala`.
+This flag forces a stack trace to be printed each time an error happens, from the site where it occurred.
+
+Analysing the trace will give you a clue about the objects involved in producing the error.
+For example, you can add some debug statements before the error is issued to discover
+the state of the compiler. [See some useful ways to debug values.](./inspection.md)
+
+### Where was a particular object created?
+
+If you navigate to the site of the error, and discover a problematic object, you will want to know
+why it exists in such a state, as it could be the cause of the error. You can discover the
+creation site of that object to understand the logic that created it.
+
+You can do this by injecting a *tracer* into the class of an instance in question.
+A tracer is the following variable:
+```scala
+val tracer = Thread.currentThread.getStackTrace.mkString("\n")
+```
+When placed as a member definition at a class, it will contain a stack trace pointing at where exactly
+its particular instance was created.
+
+Once you've injected a tracer into a class, you can `println` that tracer from the error site or
+other site you've found the object in question.
+
+#### Procedure
+
+1.  Determine the type of the object in question. You can use one of the following techniques to do so:
+     - Use an IDE to get the type of an expression, or save the expression to a `val`
+       and see its inferred type.
+     - Use `println` to print the object or use `getClass` on that object.
+2.  Locate the type definition for the type of that object.
+3.  Add a field `val tracer = Thread.currentThread.getStackTrace.mkString("\n")` to that type definition.
+4.  `println(x.tracer)` (where `x` is the name of the object in question) from the original site where you
+    encountered the object. This will give you the stack trace pointing to the place where the
+    constructor of that object was invoked.
+
+### Where was a particular value assigned to a variable?
+
+Say you have a certain [type](../architecture/types.md) assigned to a [Denotation] and you would like to know why it has that
+specific type. The type of a denotation is defined by `var myInfo: Type`, and can be assigned multiple times.
+In this case, knowing the creation site of that `Type`, as described above, is not useful; instead, you need to
+know the *assignment* (not *creation*) site.
+
+This is done similarly to how you trace the creation site. Conceptually, you need to create a proxy for that variable that will log every write operation to it. Practically, if you are trying to trace the assignments to a variable `myInfo` of type `Type`, first, rename it to `myInfo_debug`. Then, insert the following at the same level as that variable:
+
+```scala
+var tracer = "",
+def myInfo: Type = myInfo_debug,
+def myInfo_=(x: Type) = { tracer = Thread.currentThread.getStackTrace.mkString("\n"); myInfo_debug = x }
+```
+
+[Printers]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/config/Printers.scala
+[Denotation]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/core/Denotations.scala
+[PostTyper]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
+[ScalaSettings]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala
diff --git a/docs/_docs/contributing/issues/checklist.md b/docs/_docs/contributing/issues/checklist.md
new file mode 100644
index 000000000000..e2fcf32531de
--- /dev/null
+++ b/docs/_docs/contributing/issues/checklist.md
@@ -0,0 +1,135 @@
+---
+layout: doc-page
+title: Pull Request Checklist
+---
+
+Once you solved the issue you were working on, you'll likely want to see your
+changes added to the [Scala 3 repo][lampepfl/dotty]. To do that, you need to
+prepare a [pull request][pull-request] with your changes. Assuming that the team
+is aware of what you've been working, here are some final steps that you'll want
+to keep in mind as you create your PR.
+
+### 1. Sign the CLA
+
+Make sure you have signed the [Scala CLA][cla]. If you have any questions about
+what this is and why it's required you can read further about it [here][cla].
+
+### 2. Make sure your work is on its own branch
+
+When submitting your pull request it's always best to ensure the branch name is
+unique to the changes you're working on. It's important not to submit your PR on
+your `main` branch as this blocks maintainers from making any changes to your PR
+if necessary.
+
+### 3: Add Tests
+
+Add at least one test that replicates the problem in the issue, and that shows it is now resolved.
+
+You may of course add variations of the test code to try and eliminate edge cases.
+[Become familiar with testing in Scala 3](./testing.md).
+
+### 4: Add Documentation
+
+Please ensure that all code is documented to explain its use, even if only internal
+changes are made. This refers to scaladocs and also any changes that might be
+necessary in the reference docs.
+
+### 5: Double check everything
+
+Here are a couple tips to keep in mind.
+
+- [DRY (Don't Repeat Yourself)][dry]
+- [Scouts Rule][scouts]
+- When adding new code try use [optional braces]. If you're rewriting old code,
+  you should also use optional braces unless it introduces more code changes
+  that necessary.
+
+### 6: Commit Messages
+
+Here are some guidelines when writing commits for Dotty.
+
+1. If your work spans multiple local commits (for example; if you do safe point
+   commits while working in a feature branch or work in a branch for long time
+   doing merges/rebases etc.) then please do not commit it all but rewrite the
+   history by squashing the commits into one large commit which is accompanied
+   by a detailed commit message for (as discussed in the following sections).
+   For more info, see the article: [Git Workflow][git-workflow]. Additionally,
+   every commit should be able to be used in isolation—that is, each commit must
+   build and pass all tests.
+
+2. The first line should be a descriptive sentence about what the commit is
+   doing. It should be possible to fully understand what the commit does by just
+   reading this single line. It is **not ok** to only list the ticket number,
+   type "minor fix" or similar. If the commit has a corresponding ticket,
+   include a reference to the ticket number, prefixed with "Closes #", at the
+   beginning of the first line followed by the title of the ticket, assuming
+   that it aptly and concisely summarizes the commit in a single line. If the
+   commit is a small fix, then you are done. If not, go to 3.
+
+3. Following the single line description (ideally no more than 70 characters
+   long) should be a blank line followed by an enumerated list with the details
+   of the commit.
+
+4. Add keywords for your commit (depending on the degree of automation we reach,
+   the list may change over time):
+    * ``Review by @githubuser`` - will notify the reviewer via GitHub. Everyone
+      is encouraged to give feedback, however. (Remember that @-mentions will
+      result in notifications also when pushing to a WIP branch, so please only
+      include this in your commit message when you're ready for your pull
+      request to be reviewed. Alternatively, you may request a review in the
+      pull request's description.)
+    * ``Fix/Fixing/Fixes/Close/Closing/Refs #ticket`` - if you want to mark the
+      ticket as fixed in the issue tracker (Assembla understands this).
+    * ``backport to _branch name_`` - if the fix needs to be cherry-picked to
+      another branch (like 2.9.x, 2.10.x, etc)
+
+Example:
+
+```
+fix: here is your pr title briefly mentioning the topic
+
+Here is the body of your pr with some more information
+  - Details 1
+  - Details 2
+  - Details 3
+
+Closes #2
+```
+
+### 7: Create your PR!
+
+When the feature or fix is completed you should open a [Pull
+Request](https://help.github.com/articles/using-pull-requests) on GitHub.
+
+If you're not actually finished yet and are just looking for some initial input
+on your approach, feel free to open a [Draft PR][draft]. This lets reviewers
+know that you're not finished yet. It's also a good idea to put a [wip] in front
+of your pr title to make this extra clear.
+
+Shortly after creating your pull request a maintainer should assign someone to
+review it. If this doesn't happen after a few days, feel free to ping someone on
+the [Scala Contributors Discor][discord] or tag someone on the PR. Depending on
+the type of pull request there might be multiple people that take a look at your
+changes. There might also be community input as we try to keep the review
+process as open as possible.
+
+### 8: Addressing feedback
+
+More than likely you'll get feedback from the reviewers, so you'll want to make
+sure to address everything. When in doubt, don't hesitate to ask for
+clarification or more information.
+
+Once you finally see the "LGTM" (Looks Good To Me or Let's Get This Merged)
+you're PR will be merged in!
+
+[pull-request]: https://docs.github.com/en?query=pull+requests
+[lampepfl/dotty]: https://github.com/lampepfl/dotty
+[cla]: http://typesafe.com/contribute/cla/scala
+[issues]: https://github.com/lampepfl/dotty/issues
+[full-list]: https://github.com/lampepfl/dotty/blob/master/CONTRIBUTING.md
+[discord]: https://discord.gg/TSmY9zkHar
+[dry]: https://www.oreilly.com/library/view/97-things-every/9780596809515/ch30.html
+[scouts]: https://www.oreilly.com/library/view/97-things-every/9780596809515/ch08.html
+[optional-braces]: https://docs.scala-lang.org/scala3/reference/other-new-features/indentation.html
+[draft]: https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/about-pull-requests#draft-pull-requests
+[git-workflow]: http://sandofsky.com/blog/git-workflow.html
diff --git a/docs/_docs/contributing/issues/debugging.md b/docs/_docs/contributing/issues/debugging.md
new file mode 100644
index 000000000000..2d8a9e5941e4
--- /dev/null
+++ b/docs/_docs/contributing/issues/debugging.md
@@ -0,0 +1,189 @@
+---
+layout: doc-page
+title: Debugging the Compiler
+---
+
+The debugger is a powerful tool to navigate the internals of the compiler and track bugs.
+
+You can start the Scala debugger in VSCode using [Metals](https://scalameta.org/metals/).
+In this page you will learn how to configure it, and how to use it.
+
+## Importing the project in VSCode using Metals
+
+The first step is to import the build in Metals, if it has not yet been imported.
+
+To do so you can open the [lampefl/dotty][lampepfl/dotty] repository in VSCode and click `Import build` in Metals view.
+It may take a few minutes to import, compile and index the full project.
+
+![Import build](/images/contribution/import-build.jpg)
+
+If you have any trouble with importing, you can try to switch the build server from Bloop to sbt,
+by running the `Metals: Switch build server` command from VSCode command palette.
+
+## Configuring the debugger
+
+To configure the debugger in VSCode, you can go to the `Run and Debug` view and click `create a launch.json file`.
+It creates the `launch.json` file in the `.vscode` folder, in which we will define the debug configurations.
+
+![Create launch.json file](/images/contribution/launch-config-file.jpg)
+
+To create a debug configuration:
+- Open the `.vscode/launch.json` file
+- Click the `Add Configuration` button
+- Go down the list of templates and select `Scala: Run main class`
+
+![Create configuration](/images/contribution/create-config.jpg)
+
+The added configuration should look like this:
+```json
+{
+  "type": "scala",
+  "request": "launch",
+  "name": "Untitled",
+  "mainClass": "???",
+  "args": [],
+  "jvmOptions": [],
+  "env": {}
+}
+```
+
+This is a template that you need to fill out.
+First You can give a `name` to your configuration, for instance `Debug Scala 3 Compiler`.
+
+The two most important parameters, to debug the compiler, are `mainClass` and `args`.
+The `mainClass` of the compiler is `dotty.tools.dotc.Main`.
+In the `args` you need to specify the compiler arguments, which must contain at least a Scala file to compile and a `-classpath` option.
+
+To start with, we can compile the `../tests/pos/HelloWorld.scala` file.
+In the classpath, we always need at least the `scala-library_2.13` and the bootstrapped `scala3-library_3`.
+To locate them on your filesystem you can run the `export scala3-library-bootstrapped/fullClasspath` command in sbt.
+
+```
+$ sbt
+> export scala3-library-bootstrapped/fullClasspath
+/home/user/lampepfl/dotty/out/bootstrap/scala3-library-bootstrapped/scala-3.3.1-RC1-bin-SNAPSHOT-nonbootstrapped/classes:/home/user/.cache/coursier/v1/https/repo1.maven.org/maven2/org/scala-lang/scala-library/2.13.10/scala-library-2.13.10.jar
+[success] Total time: 1 s, completed Mar 10, 2023, 4:37:43 PM
+```
+
+Note that it is important to use the bootstrapped version of the `scala3-library` to get the correct TASTy version.
+
+Additionally you can add the `-color` and `never` arguments to prevent the compiler from printing ANSI codes as strings in the debug console.
+
+Here is the final configuration:
+```json
+{
+  "type": "scala",
+  "request": "launch",
+  "name": "Debug Scala 3 Compiler",
+  "mainClass": "dotty.tools.dotc.Main",
+  "args": [
+    "../tests/pos/HelloWorld.scala",
+    "-classpath",
+    // To replace with your own paths
+    "/home/user/lampepfl/dotty/out/bootstrap/scala3-library-bootstrapped/scala-3.3.1-RC1-bin-SNAPSHOT-nonbootstrapped/classes:/home/user/.cache/coursier/v1/https/repo1.maven.org/maven2/org/scala-lang/scala-library/2.13.10/scala-library-2.13.10.jar",
+    "-color",
+    "never"
+    ],
+  "jvmOptions": [],
+  "env": {}
+}
+```
+
+## Customizing the debug configurations
+
+### Compiling several files at once
+
+You can compile more than one Scala file, by adding them in the `args`:
+```json
+"args": [
+  "file1.scala",
+  "file2.scala",
+  "-classpath",
+  "/home/user/lampepfl/dotty/out/bootstrap/scala3-library-bootstrapped/scala-3.3.1-RC1-bin-SNAPSHOT-nonbootstrapped/classes:/home/user/.cache/coursier/v1/https/repo1.maven.org/maven2/org/scala-lang/scala-library/2.13.10/scala-library-2.13.10.jar"
+]
+```
+
+### Depending on a library
+
+To add a dependency to an external library you need to download it and all its transitive dependencies, and to add them in the classpath.
+The Coursier CLI can help you to do that.
+For instance to add a dependency to cats you can run:
+```
+$ cs fetch org.typelevel::cats-core:2.+ --classpath --scala-version 3 --exclude org.scala-lang:scala-library --exclude org.scala-lang:scala3-library
+/home/user/.cache/coursier/v1/https/repo1.maven.org/maven2/org/typelevel/cats-core_3/2.9.0/cats-core_3-2.9.0.jar:/home/user/.cache/coursier/v1/https/repo1.maven.org/maven2/org/typelevel/cats-kernel_3/2.9.0/cats-kernel_3-2.9.0.jar
+```
+
+And concatenate the output into the classpath argument, which should already contain the scala-library_2.13 and the bootstrapped scala3-library:
+
+```json
+"args": [
+  "using-cats.scala",
+  "-classpath",
+  "/home/user/lampepfl/dotty/out/bootstrap/scala3-library-bootstrapped/scala-3.3.1-RC1-bin-SNAPSHOT-nonbootstrapped/classes:/home/user/.cache/coursier/v1/https/repo1.maven.org/maven2/org/scala-lang/scala-library/2.13.10/scala-library-2.13.10.jar:/home/user/.cache/coursier/v1/https/repo1.maven.org/maven2/org/typelevel/cats-core_3/2.9.0/cats-core_3-2.9.0.jar:/home/user/.cache/coursier/v1/https/repo1.maven.org/maven2/org/typelevel/cats-kernel_3/2.9.0/cats-kernel_3-2.9.0.jar"
+]
+```
+
+### Add more compiler options
+
+In the `args` you can add any additional compiler option you want.
+
+For instance you can add `-Xprint:all` to print all the generated trees after each mega phase.
+
+Run `scalac -help` to get an overview of the available compiler options.
+
+### Defining more than one launch configuration
+
+You can create as many debug configurations as you need: to compile different files, with different compiler options or different classpaths.
+
+## Starting the debugger
+
+Before starting the debugger you need to put a breakpoint in the part of the code that you want to debug.
+If you don't know where to start, you can put a breakpoint in the `main` method of the `dotty.tools.dotc.Driver` trait.
+
+![First breakpoint](/images/contribution/breakpoint.jpg)
+
+Now to start the debugger, open the debug view, find the drop-down list of all the debug configurations and click on yours.
+The debugger should start and pause on your breakpoint.
+
+![Start debugger](/images/contribution/start-debugger.jpg)
+
+## Using the debugger
+
+### Navigating the call stack
+
+When the debugger has paused, you can see the current call stack in the `Debug and Run` view.
+Each frame of the call stack contains different variables, whose values you can see in the `Variables` section of the `Debug and Run` view.
+
+![Call stack](/images/contribution/call-stack.jpg)
+
+Analysing the call stack and the variables can help you understand the path taken by the compiler to reach that state.
+
+### The debugging steps
+
+The debug toolbar contains the `Continue / Pause`, `Step Over`, `Step Into`, `Step Out`, `Restart` and `Stop` buttons.
+
+![Debugging steps](/images/contribution/toolbar.jpg)
+
+You can use the step buttons to execute the code step by step and get a precise understanding of the program.
+
+### The debug console
+
+When the debugger has paused, you can evaluate any Scala 3 expression in the debug console.
+This is useful to inspect some values or to execute some parts of the code.
+
+For instance, you can evaluate `tree.show` to pretty-print a tree.
+
+![Import build](/images/contribution/debug-console.jpg)
+
+### Conditional breakpoints
+
+In a breakpoint you can define a condition, in the form of a Boolean expression written in Scala.
+The program will stop on the breakpoint as soon as the condition is met.
+
+To add a condition, right-click on a breakpoint and pick `Edit breakpoint...`.
+
+For instance, if you know that a bug happens on typing a method `foo`, you can use the condition `tree.symbol.name.show == "foo"` in a breakpoint in the `Typer`.
+
+![Import build](/images/contribution/conditional-breakpoint.jpg)
+
+[lampepfl/dotty]: https://github.com/lampepfl/dotty
diff --git a/docs/_docs/contributing/issues/efficiency.md b/docs/_docs/contributing/issues/efficiency.md
new file mode 100644
index 000000000000..07307646a4bb
--- /dev/null
+++ b/docs/_docs/contributing/issues/efficiency.md
@@ -0,0 +1,24 @@
+---
+layout: doc-page
+title: Improving Your Workflow
+---
+
+In the previous sections of this chapter, you saw some techniques for
+working with the compiler. Some of these techniques can be used
+repetitively, e.g.:
+
+- Navigating stack frames
+- Printing variables in certain ways
+- Instrumenting variable definitions with tracers
+
+The above procedures often take a lot of time when done manually, reducing productivity:
+as the cost (in terms of time and effort) is high, you may avoid attempting to do so,
+and possibly miss valuable information.
+
+If you're doing those things really frequently, it is recommended to script your editor
+to reduce the number of steps. E.g. navigating to the definition of a stack frame
+part when you click it, or instrumenting variables for printing.
+
+An example of how it is done for Sublime Text 3 is [here](https://github.com/anatoliykmetyuk/scala-debug-sublime).
+
+True, it takes some time to script your editor, but if you spend a lot of time with issues, it pays off.
diff --git a/docs/_docs/contributing/issues/index.md b/docs/_docs/contributing/issues/index.md
new file mode 100644
index 000000000000..db348d7edd9d
--- /dev/null
+++ b/docs/_docs/contributing/issues/index.md
@@ -0,0 +1,17 @@
+---
+layout: index
+title: Finding the Cause of an Issue
+---
+
+An issue found in the [GitHub repo][lampepfl/dotty] usually describes some code that
+manifests undesired behaviour.
+
+This chapter of the guide describes the different steps to contribute to Dotty:
+- [Reproducing an Issue](./reproduce.md)
+- [Finding the Cause of an Issue](./cause.md)
+- [Debugging the Compiler](./debugging.md)
+- [Other debugging techniques](./other-debugging.md)
+- [Inspect the values](./inspection.md)
+- [Improving your workflow](./efficiency.md)
+- [Testing a Fix](./testing.md)
+- [Checklist](./checklist.md)
diff --git a/docs/_docs/contributing/issues/inspection.md b/docs/_docs/contributing/issues/inspection.md
new file mode 100644
index 000000000000..abedc09ecd3b
--- /dev/null
+++ b/docs/_docs/contributing/issues/inspection.md
@@ -0,0 +1,181 @@
+---
+layout: doc-page
+title: How to Inspect Values
+---
+
+In this section, you will find out how to debug the contents of certain objects
+while the compiler is running, and inspect produced artifacts of the compiler.
+
+## Inspecting variables in-place
+
+Frequently you will need to inspect the content of a particular variable.
+You can either use `println`s or the debugger, more info on how to setup the latter.
+
+In the remeainder of this article we'll use `println(<someUsefulExpression>)` inserted in the code, but the same effect can be accomplished by stopping at a breakpoint, and typing `<someUsefulExpression>` in the [debug console](./debugging.md#the-debug-console) of the debugger.
+
+When printing a variable, it's always a good idea to call `show` on that variable: `println(x.show)`.
+Many objects of the compiler define `show`, returning a human-readable string.
+e.g. if called on a tree, the output will be the tree's representation as source code, rather than
+the underlying raw data.
+
+Sometimes you need to print flags. Flags are metadata attached to [symbols] containing information such as whether a
+class is abstract, comes from Java, what modifiers a variable has (private, protected etc) and so on.
+Flags are stored in a single `Long` value, each bit of which represents whether a particular flag is set.
+
+To print flags, you can use the `flagsString` method, e.g. `println(x.flagsString)`.
+
+## Pretty Printing with a String Interpolator
+
+You can also pretty print objects with string interpolators,
+these default to call `.show` when possible, avoiding boilerplate
+and also helping format error messages.
+
+Import them with the following:
+
+```scala
+import dotty.tools.dotc.core.Decorators.*
+```
+
+Here is a table of explanations for their use:
+
+| Usage  | Description                       |
+|--------|-----------------------------------|
+|`i""`   | General purpose string formatting. It calls `.show` on objects <br/> mixing in Showable, `String.valueOf` otherwise |
+|`em""`  | Formatting for error messages: Like `i` but suppress <br/>follow-on, error messages after the first one if some <br/>of their arguments are "non-sensical". |
+|`ex""`  | Formatting with added explanations: Like `em`, but add <br/>explanations to give more info about type variables<br/>and to disambiguate where needed. |
+
+
+## Obtaining debug output from the compiler
+
+As explained in [navigation](../issues/cause.md), we can debug the code being generated as it is transformed
+through the compiler. As well as plain tree output, there are many compiler options that
+add extra debug information to trees when compiling a file; you can find the full list
+in [ScalaSettings].
+
+## Stopping the compiler early
+Sometimes you may want to stop the compiler after a certain phase, for example to prevent
+knock-on errors from occurring from a bug in an earlier phase. Use the flag
+`-Ystop-after:<phase-name>` to prevent any phases executing afterwards.
+
+> e.g. `-Xprint:<phase>` where `phase` is a miniphase, will print after
+> the whole phase group is complete, which may be several miniphases after `phase`.
+> Instead you can use `-Ystop-after:<phase> -Xprint:<phase>` to stop
+> immediately after the miniphase and see the trees that you intended.
+
+## Printing TASTy of a Class
+
+If you are working on an issue related to TASTy, it is good to know how to inspect
+the contents of a TASTy file, produced from compilation of Scala files.
+
+The next example uses an [issue directory](../issues/reproduce.md#dotty-issue-workspace) to compile a class and print its TASTy.
+In the directory, you should create a file `tasty/Foo.scala` (with contents of `class Foo`),
+and create a file `tasty/launch.iss` with the following contents:
+
+```
+$ (rm -rv out || true) && mkdir out # clean up compiler output, create `out` dir.
+
+scala3/scalac -d $here/out $here/Foo.scala
+
+scala3/scalac -print-tasty $here/out/Foo.tasty
+```
+
+With sbt command `issue tasty` you will see output such as the following:
+
+```
+--------------------------------------------------------------------------------
+local/foo/out/Foo.tasty
+--------------------------------------------------------------------------------
+Names:
+   0: ASTs
+   1: <empty>
+   2: Foo
+   3: <init>
+...
+```
+and so on.
+
+## Inspecting The Representation of Types
+
+> [learn more about types](../architecture/types.md) in `dotc`.
+
+If you are curious about the representation of a type, say `[T] =>> List[T]`,
+you can use a helper program [dotty.tools.printTypes][DottyTypeStealer],
+it prints the internal representation of types, along with their class. It can be
+invoked from the sbt shell with three arguments as follows:
+```bash
+sbt:scala3> scala3-compiler/Test/runMain
+  dotty.tools.printTypes
+  <source>
+  <kind>
+  <typeStrings*>
+```
+
+- The first argument, `source`, is an arbitrary string that introduces some Scala definitions.
+It may be the empty string `""`.
+- The second argument, `kind`, determines the format of the following arguments,
+accepting one of the following options:
+  - `rhs` - accept return types of definitions
+  - `class` - accept signatures for classes
+  - `method` - accept signatures for methods
+  - `type` - accept signatures for type definitions
+  - The empty string `""`, in which case `rhs` will be assumed.
+- The remaining arguments are type signature strings, accepted in the format determined by
+`kind`, and collected into a sequence `typeStrings`. Signatures are the part of a definition
+that comes after its name, (or a simple type in the case of `rhs`) and may reference
+definitions introduced by the `source` argument.
+
+Each one of `typeStrings` is then printed, displaying their internal structure, alongside their class.
+
+### Examples
+
+Here, given a previously defined `class Box { type X }`, you can inspect the return type `Box#X`:
+```bash
+sbt:scala3> scala3-compiler/Test/runMain
+> dotty.tools.printTypes
+> "class Box { type X }"
+> "rhs"
+> "Box#X"
+[info] running (fork) dotty.tools.printTypes "class Box { type X }" rhs Box#X
+TypeRef(TypeRef(ThisType(TypeRef(NoPrefix,module class <empty>)),class Box),type X) [class dotty.tools.dotc.core.Types$CachedTypeRef]
+```
+
+Here are some other examples you can try:
+- `...printTypes "" "class" "[T] extends Seq[T] {}"`
+- `...printTypes "" "method" "(x: Int): x.type"`
+- `...printTypes "" "type" "<: Int" "= [T] =>> List[T]"`
+
+### Don't just print: extracting further information
+
+`dotty.tools.printTypes` is useful to to see the representation
+of a type at a glance, but sometimes you want to extract more. Instead, you can use the
+method `dotty.tools.DottyTypeStealer.stealType`. With the same inputs as `printTypes`,
+it returns both a `Context` containing the definitions passed, along with the list of types.
+
+As a worked example let's create a test case to verify the structure of `Box#X` that you saw earlier:
+```scala
+import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.core.Types.*
+
+import org.junit.Test
+
+import dotty.tools.DottyTypeStealer, DottyTypeStealer.Kind
+
+class StealBox:
+
+  @Test
+  def stealBox: Unit =
+    val (ictx, List(rhs)) =
+      DottyTypeStealer.stealType("class Box { type X }", Kind.rhs, "Box#X")
+
+    given Context = ictx
+
+    rhs match
+      case X @ TypeRef(Box @ TypeRef(ThisType(empty), _), _) =>
+        assert(Box.name.toString == "Box")
+        assert(X.name.toString == "X")
+        assert(empty.name.toString == "<empty>")
+```
+
+[DottyTypeStealer]: https://github.com/lampepfl/dotty/blob/master/compiler/test/dotty/tools/DottyTypeStealer.scala
+[ScalaSettings]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala
+[symbols]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
diff --git a/docs/_docs/contributing/debugging.md b/docs/_docs/contributing/issues/other-debugging.md
similarity index 94%
rename from docs/_docs/contributing/debugging.md
rename to docs/_docs/contributing/issues/other-debugging.md
index 959ad6706290..1aa0fb85e5f8 100644
--- a/docs/_docs/contributing/debugging.md
+++ b/docs/_docs/contributing/issues/other-debugging.md
@@ -1,26 +1,8 @@
 ---
 layout: doc-page
-title: Debugging Techniques
+title: Other Debugging Techniques
 ---
 
-# Debugging Techniques
-- [Setting up the playground](#setting-up-the-playground)
-- [Show for human readable output](#show-for-human-readable-output)
-- [How to disable color](#how-to-disable-color)
-- [Reporting as a non-intrusive println](#reporting-as-a-non-intrusive-println)
-- [Printing out trees after phases](#printing-out-trees-after-phases)
-- [Printing out stack traces of compile time errors](#printing-out-stack-traces-of-compile-time-errors)
-- [Configuring the printer output](#configuring-the-printer-output)
-- [Figuring out an object creation site](#figuring-out-an-object-creation-site)
-  * [Via ID](#via-id)
-  * [Via tracer](#via-tracer)
-- [Built-in Logging Architecture](#built-in-logging-architecture)
-  * [Printers](#printers)
-  * [Tracing](#tracing)
-  * [Reporter](#reporter)
-
-<small><i><a href='http://ecotrust-canada.github.io/markdown-toc/'>Table of contents generated with markdown-toc</a></i></small>
-
 ## Setting up the playground
 Consider the `../issues/Playground.scala` (relative to the Dotty directory) file is:
 
diff --git a/docs/_docs/contributing/issues/reproduce.md b/docs/_docs/contributing/issues/reproduce.md
new file mode 100644
index 000000000000..41d96327ef24
--- /dev/null
+++ b/docs/_docs/contributing/issues/reproduce.md
@@ -0,0 +1,127 @@
+---
+layout: doc-page
+title: Reproducing an Issue
+---
+
+To try fixing it, you will first need to reproduce the issue, so that
+- you can understand its cause
+- you can verify that any changes made to the codebase have a positive impact on the issue.
+
+Say you want to reproduce locally issue [#7710], you would first copy the code from the *"Minimised Code"*
+section of the issue to a file named e.g. `local/i7710.scala`,
+and then try to compile it from the sbt console opened in the dotty root directory:
+```bash
+$ sbt
+sbt:scala3> scala3/scalac -d local/out local/i7710.scala
+```
+> Here, the `-d` flag specifies a directory `local/out` where generated code will be output.
+
+You can then verify that the local reproduction has the same behaviour as originally reported in the issue.
+If so, then you can start to try and fix it. Otherwise, perhaps the issue is out of date, or
+is missing information about how to accurately reproduce the issue.
+
+## Dotty Issue Workspace
+
+Sometimes you will need more complex commands to reproduce an issue, and it is useful to script these, which
+can be done with [dotty-issue-workspace]. It allows to bundle sbt commands for issue reproduction in one
+file and then run them from the Dotty project's sbt console.
+
+### Try an Example Issue
+
+Let's use [dotty-issue-workspace] to reproduce issue [#7710]:
+1.  Follow [the steps in the README][workspace-readme] to install the plugin.
+2.  In your Issue Workspace directory (as defined in the plugin's README file,
+    "Getting Started" section, step 2), create a subdirectory for the
+    issue: `mkdir i7710`.
+3.  Create a file for the reproduction: `cd i7710; touch Test.scala`. In that file,
+    insert the code from the issue.
+4.  In the same directory, create a file `launch.iss` with the following content:
+    ```bash
+    $ (rm -rv out || true) && mkdir out # clean up compiler output, create `out` dir.
+
+    scala3/scalac -d $here/out $here/Test.scala
+    ```
+
+    - The first line, `$ (rm -rv out || true) && mkdir out` specifies a shell command
+      (it starts with `$`), in this case to ensure that there is a fresh `out`
+      directory to hold compiler output.
+    - The next line, `scala3/scalac -d $here/out $here/Test.scala` specifies an sbt
+      command, which will compile `Test.scala` and place any output into `out`.
+      `$here` is a special variable that will be replaced by the path of the parent
+      directory of `launch.iss` when executing the commands.
+5.  Now, from a terminal you can run the issue from sbt in the dotty directory
+    ([See here](../getting-started.md#compiling-and-running) for a reminder if you have not cloned the repo.):
+    ```bash
+    $ sbt
+    sbt:scala3> issue i7710
+    ```
+    This will execute all the commands in the `i7710/launch.iss` file one by one.
+    If you've set up `dotty-issue-workspace` as described in its README,
+    the `issue` task will know where to find the folder by its name.
+
+### Using Script Arguments
+
+You can use script arguments inside `launch.iss` to reduce the number of steps when
+working with issues.
+
+Say you have an issue `foo`, with two alternative files that are very similar:
+`original.scala`, which reproduces the issue, and `alt.scala`, which does not,
+and you want to compile them selectively?
+
+You can achieve this via the following `launch.iss`:
+
+```bash
+$ (rm -rv out || true) && mkdir out # clean up compiler output, create `out` dir.
+
+scala3/scalac -d $here/out $here/$1.scala # compile the first argument following `issue foo <arg>`
+```
+
+It is similar to the previous example, except now you will compile a file `$1.scala`, referring
+to the first argument passed after the issue name. The command invoked would look like
+`issue foo original` to compile `original.scala`, and `issue foo alt` for `alt.scala`.
+
+In general, you can refer to arguments passed to the `issue <issue_name>` command using
+the dollar notation: `$1` for the first argument, `$2` for the second and so on.
+
+### Multiline Commands
+
+Inside a `launch.iss` file, one command can be spread accross multiple lines. For example,
+if your command has multiple arguments, you can put each argument on a new line.
+
+Multiline commands can even have comments inbetween lines. This is useful
+if you want to try variants of a command with optional arguments (such as configuration).
+You can put the optional arguments on separate lines, and then decide when they are passed to
+the command by placing `#` in front to convert it to a comment (i.e. the argument will
+not be passed). This saves typing the same arguments each time you want to use them.
+
+The following `launch.iss` file is an example of how you can use multiline commands as a
+template for solving issues that [run compiled code](../issues/testing.md#checking-program-output). It demonstrates configuring the
+`scala3/scalac` command using compiler flags, which are commented out.
+Put your favourite flags there for quick usage.
+
+```bash
+$ (rm -rv out || true) && mkdir out # clean up compiler output, create `out` dir.
+
+scala3/scalac  # Invoke the compiler task defined by the Dotty sbt project
+  -d $here/out  # All the artefacts go to the `out` folder created earlier
+  # -Xprint:typer  # Useful debug flags, commented out and ready for quick usage. Should you need one, you can quickly access it by uncommenting it.
+  # -Ydebug-error
+  # -Yprint-debug
+  # -Yprint-debug-owners
+  # -Yshow-tree-ids
+  # -Ydebug-tree-with-id 340
+  # -Ycheck:all
+  $here/$1.scala  # Invoke the compiler on the file passed as the second argument to the `issue` command. E.g. `issue foo Hello` will compile `Hello.scala` assuming the issue folder name is `foo`.
+
+scala3/scala -classpath $here/out Test  # Run main method of `Test` generated by the compiler run.
+```
+
+## Conclusion
+
+In this section, you have seen how to reproduce an issue locally, and next you will see
+how to try and detect its root cause.
+
+[lampepfl/dotty]: https://github.com/lampepfl/dotty/issues
+[#7710]: https://github.com/lampepfl/dotty/issues/7710
+[dotty-issue-workspace]: https://github.com/anatoliykmetyuk/dotty-issue-workspace
+[workspace-readme]: https://github.com/anatoliykmetyuk/dotty-issue-workspace#getting-started
\ No newline at end of file
diff --git a/docs/_docs/contributing/issues/testing.md b/docs/_docs/contributing/issues/testing.md
new file mode 100644
index 000000000000..1f7c35c6d58a
--- /dev/null
+++ b/docs/_docs/contributing/issues/testing.md
@@ -0,0 +1,212 @@
+---
+layout: doc-page
+title: Testing Your Changes
+---
+
+It is important to add tests before a pull request, to verify that everything is working as expected,
+and act as proof of what is valid/invalid Scala code (in case it is broken in the future).
+In this section you will see the testing procedures in Scala 3.
+
+## Running all Tests
+
+Running all tests in Dotty is as simple as:
+
+```bash
+$ sbt test
+```
+Specifically, `sbt test` runs all tests that do _not_ require a bootstrapped
+compiler. In practice, this means that it runs all compilation tests meeting
+this criterion, as well as all non-compiler tests.
+
+To run all tests of Scala 3, including for compiler, REPL, libraries and more, run the following in sbt:
+
+```bash
+$ sbt
+sbt:scala3> scala3-bootstrapped/test
+```
+
+Often however it is not necessary to test everything if your changes are localised to one area,
+you will see in the following sections the different kinds of tests, and how
+to run individual tests.
+
+## Compilation Tests
+
+Compilation tests run the compiler over input files, using various settings. Input files
+are found within the `tests/` directory at the root of the compiler repo.
+
+Test input files are categorised further by placing them in the subdirectories
+of the `tests/` directory. A small selection of test categories include:
+
+- `tests/pos` – tests that should compile: pass if compiles successfully.
+- `tests/neg` – should not compile: pass if fails compilation. Useful, e.g., to test an expected compiler error.
+- `tests/run` – these tests not only compile but are also run.
+
+### Naming and Running a Test Case
+
+Tests are, by convention, named after the number of the issue they are fixing.
+e.g. if you are fixing issue 101, then the test should be named `i101.scala`, for a single-file test,
+or be within a directory called `i101/` for a multi-file test.
+
+To run the test, invoke the sbt command `testCompilation i101` (this will match all tests with `"i101"` in
+the name, so it is useful to use a unique name)
+
+The test groups – `pos`, `neg`, etc. – are defined in [CompilationTests]. If you want to run a group
+of tests, e.g. `pos`, you can do so via `testOnly *CompilationTests -- *pos` command.
+
+### Testing a Single Input File
+
+If your issue is reproducible by only one file, put that file under an appropriate category.
+For example, if your issue is about getting rid of a spurious compiler error (that is a code that doesn't compile should, in fact, compile), you can create a file `tests/pos/i101.scala`.
+
+### Testing Multiple Input Files
+
+If you need more than one file to reproduce an issue, create a directory instead of a file
+e.g. `tests/pos/i101/`, and put all the Scala files that are needed to reproduce the issue there.
+There are two ways to organise the input files within:
+
+**1: Requiring classpath dependency:** Sometimes issues require one file to be compiled after the other,
+(e.g. if the issue only happens with a library dependency, like with Java interop). In this case,
+the outputs of the first file compiled will be available to the next file compiled, available via the classpath.
+This is called *separate compilation*.
+
+To achieve this, within `tests/pos/i101/`, add a suffix `_n` to each file name, where `n` is an integer defining the
+order in which the file will compile. E.g. if you have two files, `Lib.scala` and `Main.scala`, and you need them
+compiled separately – Lib first, Main second, then name them `Lib_1.scala` and `Main_2.scala`.
+
+**2: Without classpath dependency:** If your issue does not require a classpath dependency, your files can be compiled
+in a single run, this is called *joint compilation*. In this case use file names without the `_n` suffix.
+
+### Checking Program Output
+
+`tests/run` tests verify the run-time behaviour of a test case. The output is checked by invoking a main method
+on a class `Test`, this can be done with either
+```scala
+@main def Test: Unit = assert(1 > 0)
+```
+or
+```scala
+object Test extends scala.App:
+  assert(1 > 0)
+```
+
+If your program also prints output, this can be compared against `*.check` files.
+These contain the expected output of a program. Checkfiles are named after the issue they are checking,
+e.g. `tests/run/i101.check` will check either `tests/run/i101.scala` or `tests/run/i101/`.
+
+### Checking Compilation Errors
+
+`tests/neg` tests verify that a file does not compile, and user-facing errors are produced. There are other neg
+categories such as `neg-custom-args`, i.e. with `neg` prefixing the directory name. Test files in the `neg*`
+categories require annotations for the lines where errors are expected. To do this add one `// error` token to the
+end of a line for each expected error. For example, if there are three expected errors, the end of the line should contain
+`// error // error // error`.
+
+You can verify the content of the error messages with a `*.check` file. These contain the expected output of the
+compiler. Checkfiles are named after the issue they are checking,
+e.g. `i101.check` will check either `tests/neg/i101.scala` or `tests/neg/i101/`.
+*Note:* checkfiles are not required for the test to pass, however they do add stronger constraints that the errors
+are as expected.
+
+### If Checkfiles do not Match Output
+
+If the actual output mismatches the expected output, the test framework will dump the actual output in the file
+`*.check.out` and fail the test suite. It will also output the instructions to quickly replace the expected output
+with the actual output, in the following format:
+
+```
+Test output dumped in: tests/neg/Sample.check.out
+  See diff of the checkfile
+    > diff tests/neg/Sample.check tests/neg/Sample.check.out
+  Replace checkfile with current output
+    > mv tests/neg/Sample.check.out tests/neg/Sample.check
+```
+
+### Tips for creating Checkfiles
+
+To create a checkfile for a test, you can do one of the following:
+
+1. Create an empty checkfile
+   - then add arbitrary content
+   - run the test
+   - when it fails, use the `mv` command reported by the test to replace the initial checkfile with the actual output.
+2. Manually compile the file you are testing with `scala3/scalac`
+   - copy-paste whatever console output the compiler produces to the checkfile.
+
+### Automatically Updating Checkfiles
+
+When complex or many checkfiles must be updated, `testCompilation` can run in a mode where it overrides the
+checkfiles with the test outputs.
+```bash
+$ sbt
+> testCompilation --update-checkfiles
+```
+
+Use `--help` to see all the options
+```bash
+$ sbt
+> testCompilation --help
+```
+
+### Bootstrapped-only tests
+
+To run `testCompilation` on a bootstrapped Dotty compiler, use
+`scala3-compiler-bootstrapped/testCompilation` (with the same syntax as above).
+Some tests can only be run in bootstrapped compilers; that includes all tests
+with `with-compiler` in their name.
+
+### From TASTy tests
+
+`testCompilation` has an additional mode to run tests that compile code from a `.tasty` file.
+Modify the lists in [compiler/test/dotc] to enable or disable tests from `.tasty` files.
+
+```bash
+$ sbt
+> testCompilation --from-tasty
+```
+
+## Unit Tests
+
+Unit tests cover the other areas of the compiler, such as interactions with the REPL, scripting tools and more.
+They are defined in [compiler/test], so if your use case isn't covered by this guide,
+you may need to consult the codebase. Some common areas are highlighted below:
+
+### SemanticDB tests
+
+To test the SemanticDB output from the `extractSemanticDB` phase (enabled with the `-Xsemanticdb` flag), run the following sbt command:
+```bash
+$ sbt
+sbt:scala3> scala3-compiler-bootstrapped/testOnly
+  dotty.tools.dotc.semanticdb.SemanticdbTests
+```
+
+[SemanticdbTests] uses source files in `tests/semanticdb/expect` to generate "expect files":
+these verify both
+- SemanticDB symbol occurrences inline in sourcecode (`*.expect.scala`)
+- complete output of all SemanticDB information (`metac.expect`).
+
+Expect files are used as regression tests to detect changes in the compiler.
+Their correctness is determined by human inspection.
+
+If expect files change then [SemanticdbTests] will fail, and generate new expect files, providing instructions for
+comparing the differences and replacing the outdated expect files.
+
+If you are planning to update the SemanticDB output, you can do it in bulk by running the command
+```bash
+$ sbt
+sbt:scala3> scala3-compiler/Test/runMain
+  dotty.tools.dotc.semanticdb.updateExpect
+```
+
+then compare the changes via version control.
+
+## Troubleshooting
+
+Some of the tests depend on temporary state stored in the `out` directory. In rare cases, that directory
+can enter an inconsistent state and cause spurious test failures. If you suspect a spurious test failure,
+you can run `rm -rf out/*` from the root of the repository and run your tests again. If that fails, you
+can try `git clean -xfd`.
+
+[CompilationTests]: https://github.com/lampepfl/dotty/blob/master/compiler/test/dotty/tools/dotc/CompilationTests.scala
+[compiler/test]: https://github.com/lampepfl/dotty/blob/master/compiler/test/
+[compiler/test/dotc]: https://github.com/lampepfl/dotty/tree/master/compiler/test/dotc
+[SemanticdbTests]: https://github.com/lampepfl/dotty/blob/master/compiler/test/dotty/tools/dotc/semanticdb/SemanticdbTests.scala
diff --git a/docs/_docs/contributing/procedures/index.md b/docs/_docs/contributing/procedures/index.md
index 01c76f72c00c..db2b09dbe80f 100644
--- a/docs/_docs/contributing/procedures/index.md
+++ b/docs/_docs/contributing/procedures/index.md
@@ -2,3 +2,7 @@
 layout: index
 title: Procedures
 ---
+
+This chapter of the guide describes:
+- [How to release a procedure](./release.md)
+- [How to test the vulpix framework](./vulpix.md)
\ No newline at end of file
diff --git a/docs/_docs/contributing/procedures/vulpix.md b/docs/_docs/contributing/procedures/vulpix.md
index 5e8a2eab425b..1eea2fa24778 100644
--- a/docs/_docs/contributing/procedures/vulpix.md
+++ b/docs/_docs/contributing/procedures/vulpix.md
@@ -3,7 +3,6 @@ layout: doc-page
 title: Test Vulpix Framework
 ---
 
-# Test Vulpix Framework
 If you are modifying the Vulpix framework and need a playground with dummy tests to try out your modifications, do the following.
 
 Create the directory structure for the playground:
diff --git a/docs/_docs/contributing/testing.md b/docs/_docs/contributing/testing.md
deleted file mode 100644
index a01cdb08f8ab..000000000000
--- a/docs/_docs/contributing/testing.md
+++ /dev/null
@@ -1,207 +0,0 @@
----
-layout: doc-page
-title: Testing in Dotty
----
-
-Running all tests in Dotty is as simple as:
-
-```bash
-$ sbt test
-```
-
-Specifically, `sbt test` runs all tests that do _not_ require a bootstrapped
-compiler. In practice, this means that it runs all compilation tests meeting
-this criterion, as well as all non-compiler tests.
-
-The entire suite of tests can be run using the bootstrapped compiler as follows:
-
-```bash
-$ sbt
-> scala3-bootstrapped/test
-```
-
-There are currently several forms of tests in Dotty. These can be split into
-two categories:
-
-## Unit tests
-These tests can be found in `<sub-project>/test` and are used to check
-functionality of specific parts of the codebase in isolation e.g: parsing,
-scanning and message errors.
-
-To run all tests in e.g., for the compiler test-suite you can write:
-
-```bash
-$ sbt
-> scala3-compiler/test
-```
-
-To run a single test class you use `testOnly` and the fully qualified class name.
-For example:
-
-```bash
-> testOnly dotty.tools.dotc.transform.TreeTransformerTest
-```
-
-The test command follows a regular expression-based syntax `testOnly * -- *`.
-The right-hand side picks a range of names for methods and the left-hand side picks a range of class names and their
-fully-qualified paths.
-
-Consequently, you can restrict the aforementioned executed test to a subset of methods by appending ``-- *method_name``.
-The example below picks up all methods with the name `canOverwrite`:
-
-```bash
-> testOnly dotty.tools.dotc.transform.TreeTransformerTest -- *canOverwrite
-```
-
-Additionally, you can run all tests named `method_name`, in any class, without providing a class name:
-
-```bash
-> testOnly -- *canOverwrite
-```
-
-You can also run all paths of classes of a certain name:
-
-```bash
-> testOnly *.TreeTransformerTest
-```
-
-### Testing with checkfiles
-Some tests support checking the output of the run or the compilation against a checkfile. A checkfile is a file in which the expected output of the compilation or run is defined. A test against a checkfile fails if the actual output mismatches the expected output.
-
-Currently, the `run` and `neg` (compilation must fail for the test to succeed) tests support the checkfiles. `run`'s checkfiles contain an expected run output of the successfully compiled program. `neg`'s checkfiles contain an expected error output during compilation.
-
-Absence of a checkfile is **not** a condition for the test failure. E.g. if a `neg` test fails with the expected number of errors and there is no checkfile for it, the test still passes.
-
-Checkfiles are located in the same directories as the tests they check, have the same name as these tests with the extension `*.check`. E.g. if you have a test named `tests/neg/foo.scala`, you can create a checkfile for it named `tests/neg/foo.check`. And if you have a test composed of several files in a single directory, e.g. `tests/neg/manyScalaFiles`, the checkfile will be `tests/neg/manyScalaFiles.check`.
-
-If the actual output mismatches the expected output, the test framework will dump the actual output in the file `*.check.out` and fail the test suite. It will also output the instructions to quickly replace the expected output with the actual output, in the following format:
-
-```
-Test output dumped in: tests/playground/neg/Sample.check.out
-  See diff of the checkfile
-    > diff tests/playground/neg/Sample.check tests/playground/neg/Sample.check.out
-  Replace checkfile with current output
-    > mv tests/playground/neg/Sample.check.out tests/playground/neg/Sample.check
-```
-
-To create a checkfile for a test, you can do one of the following:
-
-- Create a dummy checkfile with a random content, run the test, and, when it fails, use the `mv` command reported by the test to replace the dummy checkfile with the actual output.
-- Manually compile the file you are testing with `scalac` and copy-paste whatever console output the compiler produces to the checkfile.
-
-## Integration tests
-These tests are Scala source files expected to compile with Dotty (pos tests),
-along with their expected output (run tests) or errors (neg tests).
-
-All of these tests are contained in the `./tests/*` directories and can be run with the `testCompilation` command. Tests in folders named `with-compiler` are an exception, see next section.
-
-Currently to run these tests you need to invoke from sbt:
-
-```bash
-$ sbt
-> testCompilation
-```
-
-(which is effectively the same with `testOnly dotty.tools.dotc.CompilationTests`)
-
-It is also possible to run tests filtered, again from sbt:
-
-```bash
-$ sbt
-> testCompilation companions
-```
-
-This will run both the test `./tests/pos/companions.scala` and
-`./tests/neg/companions.scala` since both of these match the given string.
-This also means that you could run `testCompilation` with no arguments to run all integration tests.
-
-When complex checkfiles must be updated, `testCompilation` can run in a mode where it overrides the checkfiles with the test outputs.
-```bash
-$ sbt
-> testCompilation --update-checkfiles
-```
-
-Use `--help` to see all the options
-```bash
-$ sbt
-> testCompilation --help
-```
-
-### Joint and separate sources compilation
-
-When the sources of a test consist of multiple source files places in a single directory they are passed to the compiler in a single run and the compiler decides in which order to compile them. In some cases, however, to reproduce a specific test scenario it might be necessary to compile the source files in several steps in a specified order. To achieve that one can add a `_${step_index}` suffix to a file name (before the `.scala` or `.java` extension) indicating the order of compilation. E.g. if the test directory contains files named `Foo_1.scala`, `Bar_2.scala` and `Baz_2.scala` then `Foo_1.scala` will be compiled first and after that `Bar_2.scala` together with `Baz_2.scala`.
-
-The other kind of suffix that can modify how particular files are compiled is `_c${compilerVersion}`. When specified, the file will be compiled with a specific version of the compiler instead of the one developed on the current branch.
-
-Different suffixes can be mixed together (their order is not important although consistency is advised), e.g. `Foo_1_c3.0.2`, `Bar_2_c3.1.0`.
-
-### Bootstrapped-only tests
-
-To run `testCompilation` on a bootstrapped Dotty compiler, use
-`scala3-compiler-bootstrapped/testCompilation` (with the same syntax as above).
-Some tests can only be run in bootstrapped compilers; that includes all tests
-with `with-compiler` in their name.
-
-### From TASTy tests
-
-`testCompilation` has an additional mode to run tests that compile code from a `.tasty` file.
- Modify blacklist and whitelists in `compiler/test/dotc` to enable or disable tests from `.tasty` files.
-
- ```bash
- $ sbt
- > testCompilation --from-tasty
- ```
-
- This mode can be run under `scala3-compiler-bootstrapped/testCompilation` to test on a bootstrapped Dotty compiler.
-
-### SemanticDB tests
-
-```bash
-$ sbt
-> scala3-compiler-bootstrapped/testOnly dotty.tools.dotc.semanticdb.SemanticdbTests
-```
-
-The output of the `extractSemanticDB` phase, enabled with `-Xsemanticdb` is tested with the bootstrapped JUnit test
-`dotty.tools.dotc.semanticdb.SemanticdbTests`. It uses source files in `tests/semanticdb/expect` to generate
-two kinds of output file that are compared with "expect files": placement of semanticdb symbol occurrences inline in
-sourcecode (`*.expect.scala`), for human verification by inspection; and secondly metap formatted output which outputs
-all information stored in semanticdb (`metac.expect`).
-Expect files are used as regression tests to detect changes in the compiler.
-
-The test suite will create a new file if it detects any difference, which can be compared with the
-original expect file, or if the user wants to globally replace all expect files for semanticdb they can use
-`scala3-compiler-bootstrapped/test:runMain dotty.tools.dotc.semanticdb.updateExpect`, and compare the changes via version
-control.
-
-### Test regimes
-
-Continuous integration, managed by GitHub Actions, does not run all jobs when a pull request is created.
-In particular, test jobs for testing under JDK 8 and Windows are not run. Those jobs are run only for the nightly build.
-
-If a PR may fail differentially under either JDK 8 or Windows, the test jobs may be triggered by adding
-a special command to the PR comment text:
-
-```
-[test_java8]
-[test_windows_full]
-```
-Furthermore, CI tests are bootstrapped. A job to also run tests non-bootstrapped may be triggered manually:
-```
-[test_non_bootstrapped]
-```
-A trivial PR, such as a fix for a typo in a comment or when contributing other documentation, may benefit by skipping CI tests altogether:
-```
-[skip ci]
-```
-Other jobs which are normally run can also be selectively skipped:
-```
-[skip community_build]
-[skip test_windows_fast]
-```
-
-## Troubleshooting
-
-Some of the tests depend on temporary state stored in the `out` directory. In rare cases, that directory
-can enter an inconsistent state and cause spurious test failures. If you suspect a spurious test failure,
-you can run `rm -rf out/*` from the root of the repository and run your tests again. If that fails, you
-can try `git clean -xfd`.
diff --git a/docs/_docs/contributing/tools/index.md b/docs/_docs/contributing/tools/index.md
index 92503ee82013..e784e3e15d61 100644
--- a/docs/_docs/contributing/tools/index.md
+++ b/docs/_docs/contributing/tools/index.md
@@ -2,3 +2,8 @@
 layout: index
 title: IDEs and Tools
 ---
+
+This chapter of the guide describes how to use Dotty with IDEs and other tools:
+- [IDEs](./ide.md)
+- [Use Mill](./mill.md)
+- [Use Scalafix](./scalafix.md)
diff --git a/docs/_docs/contributing/tools/scalafix.md b/docs/_docs/contributing/tools/scalafix.md
index 58c7d0eb7b3a..30c7050f8b3e 100644
--- a/docs/_docs/contributing/tools/scalafix.md
+++ b/docs/_docs/contributing/tools/scalafix.md
@@ -3,8 +3,6 @@ layout: doc-page
 title: Working with Scalafix
 ---
 
-# Working with Scalafix
-
 First, create a new rule as follows (command from https://scalacenter.github.io/scalafix/docs/developers/setup.html):
 
 ```bash
diff --git a/docs/_docs/contributing/workflow.md b/docs/_docs/contributing/workflow.md
index 956ce2998c75..36d91bf02707 100644
--- a/docs/_docs/contributing/workflow.md
+++ b/docs/_docs/contributing/workflow.md
@@ -103,8 +103,27 @@ The basics of working with Dotty codebase are documented [here](https://dotty.ep
 
 |                        Command                       |                                                          Description                                                          |
 |------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------|
+| `scala3/scalac`                                      |  Run the compiler directly, with any current changes.                                                                         |
+| `scala3/scala`                                       |  Run the main method of a given class name.                                                                                   |
 | `scalac ../issues/Playground.scala`                  | Compile the given file – path relative to the Dotty directory. Output the compiled class files to the Dotty directory itself. |
 | `scala Playground`                                   | Run the compiled class `Playground`. Dotty directory is on classpath by default.                                              |
 | `repl`                                               | Start REPL                                                                                                                    |
+| `scala3/scalac -print-tasty Foo.tasty`               |  Print the TASTy of top-level class `Foo`                                                                                     |
+| `scala3-bootstrapped/test`                           |  Run all tests for Scala 3. (Slow, recommended for CI only)                                                                   |
+| `scala3-bootstrapped/publishLocal`                   |  Build Scala 3 locally. (Use to debug a specific project)                                                                     |
+| `scalac ../issues/Playground.scala`                  |  Compile the given file – path relative to the Dotty directory. Output the compiled class files to the Dotty directory itself.|
 | `testOnly dotty.tools.dotc.CompilationTests -- *pos` | Run test (method) `pos` from `CompilationTests` suite.                                                                        |
 | `testCompilation sample`                             | In all test suites, run test files containing the word `sample` in their title.                                               |
+| `scala3-compiler/Test/runMain dotty.tools.printTypes`|  Print types underlying representation                                                                                        |
+
+
+## Shell Commands
+
+| Command                              | Description                                                      |
+|--------------------------------------|------------------------------------------------------------------|
+| `rm -rv *.tasty *.class out || true` | clean all compiled artifacts, from root dotty directory          |
+
+<!-- Todo: add cheatsheet for compiler flags, and places to go in code for certain issues -->
+
+
+
diff --git a/docs/sidebar.yml b/docs/sidebar.yml
index d640f15ffa6f..345134cf2e9b 100644
--- a/docs/sidebar.yml
+++ b/docs/sidebar.yml
@@ -166,11 +166,18 @@ subsection:
     directory: docs/contributing
     index: contributing/index.md
     subsection:
-      - page: contributing/contribute-knowledge.md
       - page: contributing/getting-started.md
-      - page: contributing/workflow.md
-      - page: contributing/testing.md
-      - page: contributing/debugging.md
+      - index: contributing/workflow.md
+        subsection:
+          - page: contributing/issues/reproduce.md
+          - page: contributing/issues/cause.md
+          - page: contributing/issues/areas.md
+          - page: contributing/issues/debugging.md
+          - page: contributing/issues/other-debugging.md
+          - page: contributing/issues/inspection.md
+          - page: contributing/issues/efficiency.md
+          - page: contributing/issues/testing.md
+          - page: contributing/issues/checklist.md
       - title: IDEs and Tools
         directory: tools
         index: contributing/tools/index.md
@@ -179,10 +186,21 @@ subsection:
           - page: contributing/tools/mill.md
           - page: contributing/tools/scalafix.md
       - title: Procedures
+        directory: procedures
         index: contributing/procedures/index.md
         subsection:
           - page: contributing/procedures/release.md
           - page: contributing/procedures/vulpix.md
+      - title: High Level Architecture
+        directory: architecture
+        index: contributing/architecture/index.md
+        subsection:
+          - page: contributing/architecture/lifecycle.md
+          - page: contributing/architecture/context.md
+          - page: contributing/architecture/phases.md
+          - page: contributing/architecture/types.md
+          - page: contributing/architecture/time.md
+          - page: contributing/architecture/symbols.md
   - title: Internals
     directory: docs/internals
     index: internals/index.md

From 5c4493b65b00827f0486101216fee64120e3c732 Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Fri, 12 May 2023 11:51:34 +0200
Subject: [PATCH 574/657] test: add in a regression test for #8300

Closes #8300
---
 tests/pos/i8300.scala | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 tests/pos/i8300.scala

diff --git a/tests/pos/i8300.scala b/tests/pos/i8300.scala
new file mode 100644
index 000000000000..f106b24dbd1c
--- /dev/null
+++ b/tests/pos/i8300.scala
@@ -0,0 +1,15 @@
+// https://github.com/lampepfl/dotty/issues/8300
+
+type Bar[X] = X match {
+  case List[a] => List[Tuple1[a]]
+  case Set[a]  => Set[Tuple1[a]]
+}
+
+object Test:
+  (Set(1, 2, 3), List("a", "b")).map(
+    [A] =>
+      (a: A) =>
+        a match {
+          case it: Iterable[x] => it.map(Tuple1(_)).asInstanceOf[Bar[A]]
+      }
+  )

From ab64f155bc748a0b4da33ca0004025350b601c3b Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Fri, 12 May 2023 11:57:31 +0200
Subject: [PATCH 575/657] test: add in a regression test for #8321

Closes #8321
---
 tests/pos/i8321.scala | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 tests/pos/i8321.scala

diff --git a/tests/pos/i8321.scala b/tests/pos/i8321.scala
new file mode 100644
index 000000000000..825598d0b668
--- /dev/null
+++ b/tests/pos/i8321.scala
@@ -0,0 +1,9 @@
+
+object Test:
+  inline def concat[A <: Tuple, B <: Tuple](
+      a: Option[A],
+      b: Option[B]
+  ): Option[Tuple.Concat[A, B]] =
+    a.zip(b).map(_ ++ _)
+
+  concat(Some(1, 2), Some(3, 4))

From d23db881918b7916bfe5fbfd8fabd13466916495 Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Fri, 12 May 2023 12:29:18 +0200
Subject: [PATCH 576/657] test: add in a regression test for #8742

There was also some other tests that were _very_ similar to this, so it
seemed like the logical place to also just include this one instead of
creating another file for it.

Closes #8742
---
 tests/neg-custom-args/fatal-warnings/i8711.check | 4 ++++
 tests/neg-custom-args/fatal-warnings/i8711.scala | 5 +++++
 2 files changed, 9 insertions(+)

diff --git a/tests/neg-custom-args/fatal-warnings/i8711.check b/tests/neg-custom-args/fatal-warnings/i8711.check
index 0035af0755d4..491d1678b5ac 100644
--- a/tests/neg-custom-args/fatal-warnings/i8711.check
+++ b/tests/neg-custom-args/fatal-warnings/i8711.check
@@ -6,3 +6,7 @@
 12 |    case x: C => x // error
    |         ^^^^
    |         Unreachable case
+-- [E030] Match case Unreachable Error: tests/neg-custom-args/fatal-warnings/i8711.scala:17:9 --------------------------
+17 |    case x: (B | C) => x // error
+   |         ^^^^^^^^^^
+   |         Unreachable case
diff --git a/tests/neg-custom-args/fatal-warnings/i8711.scala b/tests/neg-custom-args/fatal-warnings/i8711.scala
index e37f7a8b039f..46fc5a85c90a 100644
--- a/tests/neg-custom-args/fatal-warnings/i8711.scala
+++ b/tests/neg-custom-args/fatal-warnings/i8711.scala
@@ -12,4 +12,9 @@ object Test {
     case x: C => x // error
     case _ =>
   }
+
+  def baz(x: A) = x match {
+    case x: (B | C) => x // error
+    case _          =>
+  }
 }

From c5badad29946e07fbf3bcfea33ce1c54ebde5bfe Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Fri, 12 May 2023 13:32:29 +0200
Subject: [PATCH 577/657] test: add in a regression test for #9361

Closes #9361
---
 tests/pos/i9361.scala | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 tests/pos/i9361.scala

diff --git a/tests/pos/i9361.scala b/tests/pos/i9361.scala
new file mode 100644
index 000000000000..18efd203d885
--- /dev/null
+++ b/tests/pos/i9361.scala
@@ -0,0 +1,9 @@
+// https://github.com/lampepfl/dotty/issues/9361
+
+import scala.quoted._
+
+trait CPM[F[_]]
+
+def matchTerm(t: Expr[Any])(using qctx: Quotes): Unit =
+  t match
+    case '{ ??? : CPM[m2] } => ???

From 627b558c534f86861c3cfda7599a9fb2d583830f Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Fri, 12 May 2023 14:02:03 +0200
Subject: [PATCH 578/657] Refactor way we handle hole contents and tags while
 pickling quotes

---
 .../tools/dotc/transform/PickleQuotes.scala   | 43 ++++++++-----------
 1 file changed, 19 insertions(+), 24 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
index e7a628f68663..563e7dad20dd 100644
--- a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
@@ -33,11 +33,11 @@ import scala.annotation.constructorOnly
  *      val x1: U1 = ???
  *      val x2: U2 = ???
  *      ...
- *      {{{ 3 | x1 | contents0 | T0 }}} // hole
+ *      {{{ 3 | x1 | holeContents0 | T0 }}} // hole
  *      ...
- *      {{{ 4 | x2 | contents1 | T1 }}} // hole
+ *      {{{ 4 | x2 | holeContents1 | T1 }}} // hole
  *      ...
- *      {{{ 5 | x1, x2 | contents2 | T2 }}} // hole
+ *      {{{ 5 | x1, x2 | holeContents2 | T2 }}} // hole
  *      ...
  *    }
  *    ```
@@ -93,25 +93,25 @@ class PickleQuotes extends MacroTransform {
     override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
       tree match
         case Apply(Select(quote: Quote, nme.apply), List(quotes)) =>
-          val (contents, quote1) = makeHoles(quote)
+          val (holeContents, quote1) = extractHolesContents(quote)
           val quote2 = encodeTypeArgs(quote1)
-          val contents1 = contents.map(transform(_)) ::: quote.tags
-          PickleQuotes.pickle(quote2, quotes, contents1)
+          val holeContents1 = holeContents.map(transform(_))
+          PickleQuotes.pickle(quote2, quotes, holeContents1)
         case tree: DefDef if !tree.rhs.isEmpty && tree.symbol.isInlineMethod =>
           tree
         case _ =>
           super.transform(tree)
   }
 
-  private def makeHoles(quote: tpd.Quote)(using Context): (List[Tree], tpd.Quote) =
+  private def extractHolesContents(quote: tpd.Quote)(using Context): (List[Tree], tpd.Quote) =
     class HoleContentExtractor extends Transformer:
-      private val contents = List.newBuilder[Tree]
+      private val holeContents = List.newBuilder[Tree]
       override def transform(tree: tpd.Tree)(using Context): tpd.Tree =
         tree match
           case tree @ Hole(isTerm, _, _, content) =>
             assert(isTerm)
             assert(!content.isEmpty)
-            contents += content
+            holeContents += content
             val holeType = getTermHoleType(tree.tpe)
             val hole = untpd.cpy.Hole(tree)(content = EmptyTree).withType(holeType)
             cpy.Inlined(tree)(EmptyTree, Nil, hole)
@@ -147,10 +147,10 @@ class PickleQuotes extends MacroTransform {
             mapOver(tp)
       }
 
-      /** Get the contents of the transformed tree */
+      /** Get the holeContents of the transformed tree */
       def getContents() =
-        val res = contents.result
-        contents.clear()
+        val res = holeContents.result
+        holeContents.clear()
         res
     end HoleContentExtractor
 
@@ -159,7 +159,7 @@ class PickleQuotes extends MacroTransform {
     val quote1 = cpy.Quote(quote)(body1, quote.tags)
 
     (holeMaker.getContents(), quote1)
-  end makeHoles
+  end extractHolesContents
 
   /** Encode quote tags as holes in the quote body.
    *
@@ -236,7 +236,7 @@ object PickleQuotes {
   val name: String = "pickleQuotes"
   val description: String = "turn quoted trees into explicit run-time data structures"
 
-  def pickle(quote: Quote, quotes: Tree, contents: List[Tree])(using Context) = {
+  def pickle(quote: Quote, quotes: Tree, holeContents: List[Tree])(using Context) = {
     val body = quote.body
     val bodyType = quote.bodyType
 
@@ -334,19 +334,14 @@ object PickleQuotes {
         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)))
+        if quote.tags.isEmpty then Literal(Constant(null)) // keep pickled quote without holeContents as small as possible
+        else SeqLiteral(quote.tags, 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
+        if holeContents.isEmpty then Literal(Constant(null)) // keep pickled quote without holeContents as small as possible
         else
           Lambda(
             MethodType(
@@ -354,7 +349,7 @@ object PickleQuotes {
               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 cases = holeContents.zipWithIndex.map { case (splice, idx) =>
                 val defn.FunctionOf(argTypes, defn.FunctionOf(quotesType :: _, _, _), _) = splice.tpe: @unchecked
                 val rhs = {
                   val spliceArgs = argTypes.zipWithIndex.map { (argType, i) =>
@@ -413,7 +408,7 @@ object PickleQuotes {
       case _ => None
 
     if body.isType then
-      if contents.isEmpty && body.symbol.isPrimitiveValueClass then taggedType()
+      if holeContents.isEmpty && body.symbol.isPrimitiveValueClass then taggedType()
       else pickleAsTasty()
     else
       getLiteral(body) match

From 71959523381bbb6450dbb6c76e98b03dff205623 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Fri, 12 May 2023 14:21:35 +0200
Subject: [PATCH 579/657] Remove illegal use of WildcardType

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

diff --git a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
index 563e7dad20dd..19443dfb42e3 100644
--- a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
@@ -337,7 +337,7 @@ object PickleQuotes {
       // This and all closures in typeSplices are removed by the BetaReduce phase
       val types =
         if quote.tags.isEmpty then Literal(Constant(null)) // keep pickled quote without holeContents as small as possible
-        else SeqLiteral(quote.tags, TypeTree(defn.QuotedTypeClass.typeRef.appliedTo(WildcardType)))
+        else SeqLiteral(quote.tags, TypeTree(defn.QuotedTypeClass.typeRef.appliedTo(TypeBounds.emptyPolyKind)))
 
       // This and all closures in termSplices are removed by the BetaReduce phase
       val termHoles =

From c779c26582c72d4802a3a89b3eb8634a5d2b7e07 Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Fri, 12 May 2023 17:42:08 +0200
Subject: [PATCH 580/657] test: add in a regression test for #10242

Closes #10242
---
 tests/pos/i10242.scala | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 tests/pos/i10242.scala

diff --git a/tests/pos/i10242.scala b/tests/pos/i10242.scala
new file mode 100644
index 000000000000..707c4c9f0a0c
--- /dev/null
+++ b/tests/pos/i10242.scala
@@ -0,0 +1,32 @@
+// https://github.com/lampepfl/dotty/issues/10242  
+type Foo[A, B <: A] = A
+
+type Bar[A] = A match {
+  case Foo[String, x] => Unit
+}
+
+import scala.compiletime.ops.int.*
+
+sealed trait HList
+final case class HCons[H <: Int & Singleton, T <: HList](head: H, tail: T)
+    extends HList
+sealed trait HNil extends HList
+case object HNil extends HNil
+
+sealed trait Tensor[T, S <: HList]
+
+object tf:
+  def zeros[S <: HList](shape: S): Tensor[Float, S] = ???
+
+  type NumElements[X <: HList] <: Int = X match
+    case HNil              => 1
+    case HCons[head, tail] => head * NumElements[tail]
+
+  def reshape[T, From <: HList, To <: HList](
+      tensor: Tensor[T, From],
+      shape: To
+  )(using NumElements[From] =:= NumElements[To]): Tensor[T, To] = ???
+
+object test:
+  val x = HCons(1, HCons(2, HNil))
+  val y = tf.reshape(tf.zeros(x), HCons(2, HCons(1, HNil)))

From 9310fc8561d1ee1677b64ef2886975f73ed3f6d7 Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Fri, 12 May 2023 08:40:43 +0200
Subject: [PATCH 581/657] test: add in regression test for #7445

This adds in a regression test for the minimized issue, but the original
one now has a different issue with pickling. I've added this in as well,
but added it to the excludes.
---
 compiler/test/dotc/pos-test-pickling.blacklist |  3 +++
 tests/pos/i7445a.scala                         | 10 ++++++++++
 tests/pos/i7445b.scala                         | 12 ++++++++++++
 3 files changed, 25 insertions(+)
 create mode 100644 tests/pos/i7445a.scala
 create mode 100644 tests/pos/i7445b.scala

diff --git a/compiler/test/dotc/pos-test-pickling.blacklist b/compiler/test/dotc/pos-test-pickling.blacklist
index d1dd83f36ff7..86b14e584d15 100644
--- a/compiler/test/dotc/pos-test-pickling.blacklist
+++ b/compiler/test/dotc/pos-test-pickling.blacklist
@@ -94,3 +94,6 @@ i4176-gadt.scala
 i13974a.scala
 
 java-inherited-type1
+
+# recursion limit exceeded
+i7445b.scala
diff --git a/tests/pos/i7445a.scala b/tests/pos/i7445a.scala
new file mode 100644
index 000000000000..2b54166de3f0
--- /dev/null
+++ b/tests/pos/i7445a.scala
@@ -0,0 +1,10 @@
+// https://github.com/lampepfl/dotty/issues/7445
+
+object Main {
+  type O1[A] = {
+    type OutInner[X] = Unit
+    type Out = OutInner[A]
+  }
+
+  def f1: O1[Int]#Out = ???
+}
diff --git a/tests/pos/i7445b.scala b/tests/pos/i7445b.scala
new file mode 100644
index 000000000000..1d49479ef0a5
--- /dev/null
+++ b/tests/pos/i7445b.scala
@@ -0,0 +1,12 @@
+// https://github.com/lampepfl/dotty/issues/7445
+
+type O1[A] = {
+  type OutInner[Ts] <: Tuple = Ts match {
+    case EmptyTuple => EmptyTuple
+    case h *: t => h *: OutInner[t]
+  }
+
+  type Out = OutInner[A]
+}
+
+def f1: O1[(Int, Int)]#Out = ???

From 27b84f009a52b7b47c8f3982833985eab3599c59 Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Fri, 12 May 2023 11:38:25 +0200
Subject: [PATCH 582/657] test: add in a regression test for #7414

While the original reported issue does now compile, the pickling tests
fail with:

```diff
- .fun:((q: DepTest.Dep[DepTest.obj.type]#t.Dependent): scala.Unit)>@tests/pos/i7414.scala<223..235>
+ .fun:((q: DepTest.obj.Dependent): scala.Unit)>@tests/pos/i7414.scala<223..235>
```
This adds in a test for this, but adds it to the excludes. I'm assuming
this was what was meant by this comment: https://github.com/lampepfl/dotty/issues/7414#issuecomment-1545331428.

Refs: #7414
---
 compiler/test/dotc/pos-test-pickling.blacklist |  1 +
 tests/pos/i7414.scala                          | 12 ++++++++++++
 2 files changed, 13 insertions(+)
 create mode 100644 tests/pos/i7414.scala

diff --git a/compiler/test/dotc/pos-test-pickling.blacklist b/compiler/test/dotc/pos-test-pickling.blacklist
index d1dd83f36ff7..697ec4e2ec81 100644
--- a/compiler/test/dotc/pos-test-pickling.blacklist
+++ b/compiler/test/dotc/pos-test-pickling.blacklist
@@ -21,6 +21,7 @@ i15181.scala
 i15922.scala
 t5031_2.scala
 i16997.scala
+i7414.scala
 
 # Tree is huge and blows stack for printing Text
 i7034.scala
diff --git a/tests/pos/i7414.scala b/tests/pos/i7414.scala
new file mode 100644
index 000000000000..fd85ed2a2265
--- /dev/null
+++ b/tests/pos/i7414.scala
@@ -0,0 +1,12 @@
+// https://github.com/lampepfl/dotty/issues/7414
+
+object DepTest {
+  trait Trait {
+    case class Dependent()
+  }
+  object obj extends Trait
+  case class Dep[T <: Trait](t: T) {
+    def fun(q: t.Dependent): Unit = ???
+  }
+  Dep(obj).fun(obj.Dependent())
+}

From 720bff8dc45bcbdd58fa55e2fcc54fbf2c10f589 Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Sun, 14 May 2023 11:55:55 +0200
Subject: [PATCH 583/657] test: add in a regression test for #11118

This adds in a regression test showing that just like in Scala 2 a user
sees a warning about how the right hand side doesn't match the type of
the left.

closes #11118
---
 tests/neg/i11118.check | 12 ++++++++++++
 tests/neg/i11118.scala |  2 ++
 2 files changed, 14 insertions(+)
 create mode 100644 tests/neg/i11118.check
 create mode 100644 tests/neg/i11118.scala

diff --git a/tests/neg/i11118.check b/tests/neg/i11118.check
new file mode 100644
index 000000000000..0af98c7f580a
--- /dev/null
+++ b/tests/neg/i11118.check
@@ -0,0 +1,12 @@
+-- Warning: tests/neg/i11118.scala:2:12 --------------------------------------------------------------------------------
+2 |val (a,b) = (1,2,3) // error // warning
+  |            ^^^^^^^
+  |          pattern's type (Any, Any) does not match the right hand side expression's type (Int, Int, Int)
+  |
+  |          If the narrowing is intentional, this can be communicated by adding `: @unchecked` after the expression,
+  |          which may result in a MatchError at runtime.
+  |          This patch can be rewritten automatically under -rewrite -source 3.2-migration.
+-- Error: tests/neg/i11118.scala:2:4 -----------------------------------------------------------------------------------
+2 |val (a,b) = (1,2,3) // error // warning
+  |    ^
+  |    this case is unreachable since type (Int, Int, Int) is not a subclass of class Tuple2
diff --git a/tests/neg/i11118.scala b/tests/neg/i11118.scala
new file mode 100644
index 000000000000..23d9b2b604b6
--- /dev/null
+++ b/tests/neg/i11118.scala
@@ -0,0 +1,2 @@
+// https://github.com/lampepfl/dotty/issues/11118
+val (a,b) = (1,2,3) // error // warning

From bced8c8ec99fbec2f5e63b276efc2dac733afd65 Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Sun, 14 May 2023 12:20:06 +0200
Subject: [PATCH 584/657] test: add in a regression test for #11223

[skip community_build]

closes #11223
---
 tests/pos/i11223.scala | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 tests/pos/i11223.scala

diff --git a/tests/pos/i11223.scala b/tests/pos/i11223.scala
new file mode 100644
index 000000000000..a3583ca955c4
--- /dev/null
+++ b/tests/pos/i11223.scala
@@ -0,0 +1,21 @@
+object T:
+  trait M[F[_]]
+  trait EE[A, B]
+  trait AE[A]
+  trait DE[A]
+  trait CE[A]
+
+  type A1 = M[AE]
+  type D1 = M[DE] | M[[a] =>> EE[Int, a]]
+  type C1 = M[CE]
+
+  trait F[+R, +A]:
+    def <+>[U, B](b: F[U, B]): F[R | U, A] = null
+    def int: F[R | A1, Int]
+
+  def d1[A](f: => A): F[D1, A] = null
+  def m[R, A](f: F[R | C1, A]): F[R | C1, A] = null
+
+  def x = m { // adding type annotation here helps (m[D1 | A1 | C1, Int])
+    d1(123).int <+> null
+  }

From e38316ea2cb02da896e7043fdfa465888a77b2fd Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Sun, 14 May 2023 12:27:58 +0200
Subject: [PATCH 585/657] test: add in a regression test for #11255

[skip community_build]

closes #11255
---
 tests/pos/i11255.scala | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 tests/pos/i11255.scala

diff --git a/tests/pos/i11255.scala b/tests/pos/i11255.scala
new file mode 100644
index 000000000000..6dd1e100e696
--- /dev/null
+++ b/tests/pos/i11255.scala
@@ -0,0 +1,26 @@
+class A
+class B extends A
+
+object O:
+  opaque type Id[T] = T
+  extension [T](id: Id[T]) def get: T = id
+  def f[S <: A, T](ff: S => T): Id[S => T] = ???
+  def g[S <: A, T](ff: S => T): Option[S => T] = ???
+  def h[S, T](ff: S => T): Id[S => T] = ???
+
+object example:
+  import O._
+
+  val a = new A
+  val b = new B
+
+  val f1 = f((a: A) => 0)
+  f1.get.apply(a)
+  val f2 = f((b: B) => 0)
+  f2.get.apply(b)
+
+  val g1 = g((a: A) => 0)
+  g1.get.apply(a)
+
+  val h1 = h((a: A) => 0)
+  h1.get.apply(a)

From 6086e5708106cba614172aa901851ed5e14a423d Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Sun, 14 May 2023 12:53:14 +0200
Subject: [PATCH 586/657] test: add in a regression test for #11681

This adds in both the original given example and a further minimized
one.

[skip community_build]

closes #11681
---
 tests/pos/i11681.scala | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 tests/pos/i11681.scala

diff --git a/tests/pos/i11681.scala b/tests/pos/i11681.scala
new file mode 100644
index 000000000000..587285911610
--- /dev/null
+++ b/tests/pos/i11681.scala
@@ -0,0 +1,28 @@
+// https://github.com/lampepfl/dotty/issues/11681
+
+import scala.collection.Factory
+
+final case class Gen[+A]() {
+  def take[C[X] <: Iterable[X], B](
+      n: Int
+  )(implicit w: A <:< C[B], f: Factory[B, C[B]]): Gen[C[B]] =
+    Gen()
+}
+
+object Usage {
+  def expected: Gen[List[Int]] =
+    Gen[List[Int]]().take(3)
+}
+
+object example:
+  type G[A]
+  given G[H[Int]] = ???
+
+  trait H[X]
+  object H {
+    given H[Int] = ???
+  }
+
+  def take[C[_]](using w: G[C[Int]], f: C[Int]) = ???
+
+  def test = take

From 05d95dde9ac448928e3b6973e21a0f7748c1016f Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Sun, 14 May 2023 13:00:48 +0200
Subject: [PATCH 587/657] test: add in a regression test for #11706

[skip community_build]

closes #11706
---
 tests/run/i11706.check |  2 ++
 tests/run/i11706.scala | 30 ++++++++++++++++++++++++++++++
 2 files changed, 32 insertions(+)
 create mode 100644 tests/run/i11706.check
 create mode 100644 tests/run/i11706.scala

diff --git a/tests/run/i11706.check b/tests/run/i11706.check
new file mode 100644
index 000000000000..a5c8806279fa
--- /dev/null
+++ b/tests/run/i11706.check
@@ -0,0 +1,2 @@
+3
+3
diff --git a/tests/run/i11706.scala b/tests/run/i11706.scala
new file mode 100644
index 000000000000..2ba291f74a46
--- /dev/null
+++ b/tests/run/i11706.scala
@@ -0,0 +1,30 @@
+// https://github.com/lampepfl/dotty/issues/11706
+import scala.compiletime.erasedValue
+
+object Obj:
+
+  inline def length[Tuple]: Int = loop[Tuple]
+
+  private inline def loop[Tuple]: Int =
+    inline erasedValue[Tuple] match
+      case _: EmptyTuple     => 0
+      case _: (head *: tail) => 1 + loop[tail]
+
+end Obj
+
+// Same code, but in a trait instead of an object
+trait Trait:
+
+  inline def length[Tuple]: Int = loop[Tuple]
+
+  private inline final def loop[Tuple]: Int =
+    inline erasedValue[Tuple] match
+      case _: EmptyTuple     => 0
+      case _: (head *: tail) => 1 + loop[tail]
+
+end Trait
+
+@main def Test() =
+  println(Obj.length[(Int, Int, String)]) // OK
+  new Trait:
+    println(length[(Int, Int, String)]) // ERROR

From 7959821ab55523b14e71178087d10acf3dd54c55 Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Sun, 14 May 2023 13:24:08 +0200
Subject: [PATCH 588/657] test: add in a regression test for #12032

[skip community_build]

closes #12032
---
 tests/run/i12032.check |  2 ++
 tests/run/i12032.scala | 24 ++++++++++++++++++++++++
 2 files changed, 26 insertions(+)
 create mode 100644 tests/run/i12032.check
 create mode 100644 tests/run/i12032.scala

diff --git a/tests/run/i12032.check b/tests/run/i12032.check
new file mode 100644
index 000000000000..3bd1f0e29744
--- /dev/null
+++ b/tests/run/i12032.check
@@ -0,0 +1,2 @@
+foo
+bar
diff --git a/tests/run/i12032.scala b/tests/run/i12032.scala
new file mode 100644
index 000000000000..52358332e2c8
--- /dev/null
+++ b/tests/run/i12032.scala
@@ -0,0 +1,24 @@
+// https://github.com/lampepfl/dotty/issues/12032
+class Foo(val strings: Seq[String]) extends FooLowPriority
+
+trait FooLowPriority { self: Foo =>
+  @scala.annotation.targetName("appendFromProducers")
+  def append(v: String): Foo = new Foo(v +: self.strings)
+}
+
+trait FooBar { self: Foo =>
+  @scala.annotation.targetName("appendFromProducers")
+  final override def append(v: String): Foo = new Foo(self.strings :+ v)
+}
+
+object Foo {
+  type Bar = Foo with FooBar
+
+  def bar(vs: String*): Bar = new Foo(vs) with FooBar
+}
+
+@main def Test() =
+  Foo.bar("foo")
+    .append("bar")
+    .strings
+    .foreach(println)

From b4fb6873e7f89cfe29b1e23c6a3f6f98405b570a Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Sun, 14 May 2023 14:29:59 +0200
Subject: [PATCH 589/657] test: add in a regression test for #12663

This adds in all 3 examples from the issue reported.

[skip community_build]

closes #12663
---
 tests/pos/i12663.scala | 72 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 72 insertions(+)
 create mode 100644 tests/pos/i12663.scala

diff --git a/tests/pos/i12663.scala b/tests/pos/i12663.scala
new file mode 100644
index 000000000000..befbc65316cb
--- /dev/null
+++ b/tests/pos/i12663.scala
@@ -0,0 +1,72 @@
+// https://github.com/lampepfl/dotty/issues/12663
+
+final class HookComponentBuilder[Ctx, CtxFn[_]] {
+  def asd[A](f: Ctx => A): A = ???
+  def asd[A](f: CtxFn[A]): A = ???
+}
+
+object HookCtx {
+  case class P1[P, H1](props: P, hook1: H1)
+}
+
+object HookCtxFn {
+  sealed trait P1[P, H1] { type Fn[A] = (P, H1) => A }
+}
+
+object Test {
+  val b: HookComponentBuilder[
+    HookCtx.P1[String, Int],
+    HookCtxFn.P1[String, Int]#Fn
+  ] = ???
+
+  b.asd($ => $.props.length + $.hook1)
+  b.asd((props, hook1) => props.length + hook1)
+}
+
+final class HookComponentBuilder2[Ctx, CtxFn[_]] {
+  def asd[A](f: Ctx => A): A = ???
+  def asd[A](f: CtxFn[A]): A = ???
+}
+
+object HookCtx2 {
+  case class P1[P, H1](props: P, hook1: H1)
+}
+
+object HookCtxFn2 {
+  type P1[P, H1] = [A] =>> (P, H1) => A
+}
+
+object Test2 {
+  val b: HookComponentBuilder2[
+    HookCtx2.P1[String, Int],
+    HookCtxFn2.P1[String, Int]
+  ] = ???
+
+  b.asd($ => $.props.length + $.hook1)
+  b.asd((props, hook1) => props.length + hook1)
+}
+
+final class Builder[CtxFn[_]] {
+  def asd[A](f: Int => A): A = ???
+  def asd[A](f: CtxFn[A]): A = ???
+}
+
+object Test3 {
+  val b1: Builder[[Z] =>> (String, Int) => Z] = ???
+  b1.asd(identity)
+  b1.asd(_.length + _)
+
+  sealed trait Scala2TL { type F[Z] = (String, Int) => Z }
+  val b2: Builder[Scala2TL#F] = b1
+  b2.asd(identity)
+  b2.asd(_.length + _)
+
+  type Scala3TL = [Z] =>> (String, Int) => Z
+  val b3: Builder[Scala3TL] = b1
+  b3.asd(identity)
+  b3.asd(_.length + _)
+
+  val b4: Builder[({ type F[Z] = (String, Int) => Z })#F] = b1
+  b4.asd(identity)
+  b4.asd(_.length + _)
+}

From 9292bcc5afad502a316ed0f4020cd6ff83c52f11 Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Sun, 14 May 2023 14:36:06 +0200
Subject: [PATCH 590/657] test: add in a regression test for #12679

[skip community_build]

closes #12679
---
 tests/pos/i12679.scala | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 tests/pos/i12679.scala

diff --git a/tests/pos/i12679.scala b/tests/pos/i12679.scala
new file mode 100644
index 000000000000..fed62c72dd42
--- /dev/null
+++ b/tests/pos/i12679.scala
@@ -0,0 +1,9 @@
+// https://github.com/lampepfl/dotty/issues/12679
+
+object Example:
+  def foo[F[_]](qux: String, quux: String = ""): F[Unit] = ???
+
+  def foo[F[_]](qux: Boolean): F[Unit] = ???
+
+  def example[F[_]](maybeQux: Option[String], bool: Boolean) =
+    maybeQux.fold(foo[F](bool))(foo[F](_))

From 90549a702e10fa74c11019e8770391c3aa8584fd Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Sun, 14 May 2023 18:08:14 +0200
Subject: [PATCH 591/657] test: add in a regression test for #13216

[skip community_build]

closes #13216
---
 tests/run/i13216.scala | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 tests/run/i13216.scala

diff --git a/tests/run/i13216.scala b/tests/run/i13216.scala
new file mode 100644
index 000000000000..174d0f200f31
--- /dev/null
+++ b/tests/run/i13216.scala
@@ -0,0 +1,11 @@
+// https://github.com/lampepfl/dotty/issues/13216
+import scala.annotation.targetName
+
+class C(s: String) extends AnyVal {
+  def m(xs: Seq[Int]): Unit = {}
+  @targetName("m_seq2")
+  def m(xs: Seq[Seq[Int]]): Unit = {}
+}
+
+@main def Test =
+  new C("").m(Seq(123))

From e657ac837510f5d9a8993a3c3a7f0afde4dfe9bf Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Mon, 15 May 2023 08:55:04 +0200
Subject: [PATCH 592/657] Update tests/run/i11706.scala

---
 tests/run/i11706.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/run/i11706.scala b/tests/run/i11706.scala
index 2ba291f74a46..276ee408d266 100644
--- a/tests/run/i11706.scala
+++ b/tests/run/i11706.scala
@@ -27,4 +27,4 @@ end Trait
 @main def Test() =
   println(Obj.length[(Int, Int, String)]) // OK
   new Trait:
-    println(length[(Int, Int, String)]) // ERROR
+    println(length[(Int, Int, String)])

From 55678d6e948ad3bb94a25333a467e8927e2252af Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Marks?= <pmarks@virtuslab.com>
Date: Mon, 15 May 2023 09:57:52 +0200
Subject: [PATCH 593/657] Set reference version to 3.3.0-RC6

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

diff --git a/project/Build.scala b/project/Build.scala
index 30c3aded5be4..30a731511f43 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -80,7 +80,7 @@ object DottyJSPlugin extends AutoPlugin {
 object Build {
   import ScaladocConfigs._
 
-  val referenceVersion = "3.3.0-RC5"
+  val referenceVersion = "3.3.0-RC6"
 
   val baseVersion = "3.3.1-RC1"
 

From cfa9da313ecc1ce48ad451dc759ba0b2bbb40410 Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Mon, 15 May 2023 10:36:08 +0200
Subject: [PATCH 594/657] test: add in a regression test for #13334

[skip community_build]

closes #13334
---
 tests/run/i13334.scala | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 tests/run/i13334.scala

diff --git a/tests/run/i13334.scala b/tests/run/i13334.scala
new file mode 100644
index 000000000000..2ee0987c13cc
--- /dev/null
+++ b/tests/run/i13334.scala
@@ -0,0 +1,16 @@
+// https://github.com/lampepfl/dotty/issues/13334
+trait DFC
+given DFC = new DFC {}
+
+trait TC
+object TC:
+  def foo()(using DFC): Unit = {}
+
+  inline given (using DFC): TC = new TC:
+    foo()
+
+class Foo(using DFC):
+  summon[TC]
+
+@main def Test() =
+  val top = new Foo

From 6b91b5f1ea55512cc08c4c2dc2975a87379e7ef5 Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Mon, 15 May 2023 13:12:02 +0200
Subject: [PATCH 595/657] test: add in a regression test for #13691

Looks like there was already another test linked to this, but this adds
in the original example to fully close the issue.

[skip community_build]

close #13691
---
 tests/run/i13691b.scala | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 tests/run/i13691b.scala

diff --git a/tests/run/i13691b.scala b/tests/run/i13691b.scala
new file mode 100644
index 000000000000..1da726827467
--- /dev/null
+++ b/tests/run/i13691b.scala
@@ -0,0 +1,12 @@
+// https://github.com/lampepfl/dotty/issues/13691
+import language.experimental.saferExceptions
+
+trait Decoder[+T]:
+  def apply(): T
+
+given Decoder[Int throws Exception] = new Decoder[Int throws Exception]:
+  def apply(): Int throws Exception = 1
+
+@main def Test(): Unit =
+  import unsafeExceptions.canThrowAny
+  summon[Decoder[Int throws Exception]]()

From 2ac9525b658b9aa7f2e4876b85713665a597fec9 Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Mon, 15 May 2023 13:50:46 +0200
Subject: [PATCH 596/657] test: add in a regression test for #14096

[skip community_build]

closes #14096
---
 tests/pos/i14096.scala | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 tests/pos/i14096.scala

diff --git a/tests/pos/i14096.scala b/tests/pos/i14096.scala
new file mode 100644
index 000000000000..59365231b121
--- /dev/null
+++ b/tests/pos/i14096.scala
@@ -0,0 +1,7 @@
+// https://github.com/lampepfl/dotty/issues/14096
+object Test:
+  object Forte:
+    def test[T](i: Int, config: String = ""): Int = 1
+    def test[T](i: String): Int = 2
+
+  Forte.test[Int](1)

From 00d4e98a6e9cac3f0eaa4eb970de9377a63cacef Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Mon, 15 May 2023 14:05:39 +0200
Subject: [PATCH 597/657] test: add in a regression test for #14271

[skip community_build]

closes #14271
---
 tests/pos/i14271.scala | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 tests/pos/i14271.scala

diff --git a/tests/pos/i14271.scala b/tests/pos/i14271.scala
new file mode 100644
index 000000000000..8f46940afd09
--- /dev/null
+++ b/tests/pos/i14271.scala
@@ -0,0 +1,14 @@
+// https://github.com/lampepfl/dotty/issues/14271
+class Bound[T]
+class MyClass[T <: Bound[T]]
+
+class Container[V] {
+  def doSth(): V = ???
+}
+
+def bug() = {
+  val m = new Container[MyClass[_]]
+  if (true) {
+    m.doSth()
+  }
+}

From e0d1f37583654d66ce6fc6bef9e0744fb89ea1b1 Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Mon, 15 May 2023 14:10:08 +0200
Subject: [PATCH 598/657] test: add in a regression test for #14278

[skip community_build]

closes #14278
---
 tests/pos/i14278.scala | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 tests/pos/i14278.scala

diff --git a/tests/pos/i14278.scala b/tests/pos/i14278.scala
new file mode 100644
index 000000000000..ebc9376fbad5
--- /dev/null
+++ b/tests/pos/i14278.scala
@@ -0,0 +1,6 @@
+// https://github.com/lampepfl/dotty/issues/14278
+class Foo
+
+extension (foo: Foo)
+  def patch(arg: List[Int], arg2: Int = 0): Unit = {}
+  def patch(arg: Int): Unit = patch(List(arg))

From 3270d8e85b4e1b1b23a1db7eac618d0c36f41af2 Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Mon, 15 May 2023 14:29:29 +0200
Subject: [PATCH 599/657] test: add in a regression test for #14582

[skip community_build]

closes #14582
---
 tests/run/i14582.scala | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 tests/run/i14582.scala

diff --git a/tests/run/i14582.scala b/tests/run/i14582.scala
new file mode 100644
index 000000000000..bce33aa170b2
--- /dev/null
+++ b/tests/run/i14582.scala
@@ -0,0 +1,18 @@
+// https://github.com/lampepfl/dotty/issues/14582
+@main def Test() =
+  val map = Map(
+    "a" -> 1,
+    "b" -> 2
+  )
+
+  val mapView = map.view
+
+  val optionMapView = Some(mapView)
+
+  val listOfTuples: List[(String, String)] = List(("c", "d"), ("e", "f"))
+
+  val mapViewWithDefault = optionMapView.getOrElse(Map())
+
+  val result = mapViewWithDefault ++ listOfTuples
+
+  result.toSeq

From 33e71b3943f53f1c24fe889eb8411503e139379a Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Mon, 15 May 2023 14:49:21 +0200
Subject: [PATCH 600/657] test: add in a regression test for #14642

[skip community_build]

closes #14642
---
 tests/pos/i14642.scala | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 tests/pos/i14642.scala

diff --git a/tests/pos/i14642.scala b/tests/pos/i14642.scala
new file mode 100644
index 000000000000..b69da7d8d6d7
--- /dev/null
+++ b/tests/pos/i14642.scala
@@ -0,0 +1,16 @@
+// https://github.com/lampepfl/dotty/issues/14642
+case object A
+case class B()
+case class C()
+type Union = A.type | B | C
+val a: List[A.type] = ???
+val b: List[B] = ???
+val c: List[C] = ???
+val l1: List[Union] = a ++ b
+val l2: List[Union] =
+  a ++ b ++ c
+val l3: List[Union] =
+  (a: List[
+    Union
+  ]) ++ b ++ c
+val l4: List[Union] = (a: List[Union]) ++ (b ++ c)

From 8eb7041fb4cd76a4b8e5ad1f67be4f556611af06 Mon Sep 17 00:00:00 2001
From: Anatolii Kmetiuk <anatoliykmetyuk@gmail.com>
Date: Mon, 15 May 2023 15:55:19 +0200
Subject: [PATCH 601/657] Update MAINTENANCE.md

---
 MAINTENANCE.md | 32 ++++++++++++++++++++------------
 1 file changed, 20 insertions(+), 12 deletions(-)

diff --git a/MAINTENANCE.md b/MAINTENANCE.md
index d1309a6b404d..54e74f7cb7ca 100644
--- a/MAINTENANCE.md
+++ b/MAINTENANCE.md
@@ -61,28 +61,36 @@ At the end of their supervision period, the supervisor reports to the team durin
 
 The following is the list of all the principal areas of the compiler and the core team members who are responsible for their maintenance:
 
+### Compiler
 - Parser: @odersky
 - Typer: @odersky, @smarter, (@dwijnand)
 - Erasure: @smarter, @odersky
 - Enums: @bishabosha
+- Derivation & Mirrors: @bishabosha, (@dwijnand)
 - Export: @bishabosha, @odersky
 - Pattern Matching: @dwijnand, (@liufengyun), @sjrd
 - Inline: @nicolasstucki, @odersky
-- Metaprogramming (Quotes, Reflect, Staging): @nicolasstucki, @aherlihy
-- Match types: @OlivierBlanvillain, @dwijnand
-- GADT: @abgruszecki, @dwijnand
-- Scaladoc: @KacperFKorban,  @BarkingBad, @pikinier20
-- Initialization checker: @olhotak, @liufengyun, @anatoliykmetyuk
+- Metaprogramming (Quotes, Reflect, Staging): @nicolasstucki, @jchyb
+- Match types: @sjrd, @dwijnand, @Decel
+- GADT: @dwijnand, @Linyxus
+- Initialization checker: @olhotak, @liufengyun
 - Safe nulls: @noti0na1, @olhotak
+- Lazy vals: @szymon-rd, @sjrd
 - tailrec: @sjrd, @mbovel
 - JS backend: @sjrd
-- forward compat (-scala-release): @prolativ, @Kordyjan, (@nicolasstucki)
-- Benchmarks: @anatoliykmetyuk, @mbovel
-- REPL: @dwijnand, @anatoliykmetyuk, @prolativ
+- JVM backend: @sjrd
+- Java-compat: @smarter
+
+### Tooling
+- REPL: @dwijnand, @prolativ
+- Scaladoc: @Florian3k
+- SemanticDB: @tanishiking
+- Coverage: @TheElectronWill
+- Linting (especially unused warnings) / Reporting UX: @szymon-rd
+
+### Infrastructure
 - CI: @anatoliykmetyuk
 - Community Build: @anatoliykmetyuk
+- Open Community Build: @WojciechMazur
 - Vulpix: @dwijnand, @prolativ
-- JVM backend: @Kordyjan, (@sjrd)
-- Derivation & Mirrors: @bishabosha, (@dwijnand)
-- Linting (especially unused warnings) / Reporting UX: VirtusLab TBD?
-- Java-compat: @Kordyjan
+- Benchmarks: @mbovel

From b00b5c61e254c8cd468363e7c672915e1064ac98 Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Mon, 15 May 2023 17:19:59 +0200
Subject: [PATCH 602/657] test: add in regression test for #14830

[skip community_build]

closes #14830
---
 tests/pos/i14830.scala | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 tests/pos/i14830.scala

diff --git a/tests/pos/i14830.scala b/tests/pos/i14830.scala
new file mode 100644
index 000000000000..592a47c1a53c
--- /dev/null
+++ b/tests/pos/i14830.scala
@@ -0,0 +1,6 @@
+
+// https://github.com/lampepfl/dotty/issues/14830
+val a: Comparable[String] = "Fred"
+val b: { def length: Int } = "Fred"
+val c: Comparable[String] & { def length: Int } = "Fred"
+val d: Comparable[String] & { def length(): Int } = "Fred"

From a0bdfe88f38178cc7412d416f285f7a7acc4eeed Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 2 May 2023 14:41:58 +0200
Subject: [PATCH 603/657] Add SplicePattern AST to parse and type quote pattern
 splices

---
 .../src/dotty/tools/dotc/ast/Desugar.scala    |   6 +-
 compiler/src/dotty/tools/dotc/ast/Trees.scala |  25 ++++
 compiler/src/dotty/tools/dotc/ast/untpd.scala |   1 +
 .../dotty/tools/dotc/parsing/Parsers.scala    |   4 +-
 .../tools/dotc/printing/RefinedPrinter.scala  |   6 +
 .../dotty/tools/dotc/typer/Applications.scala |   2 +-
 .../tools/dotc/typer/QuotesAndSplices.scala   | 130 ++++++++----------
 .../src/dotty/tools/dotc/typer/Typer.scala    |   1 +
 8 files changed, 98 insertions(+), 77 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index 8a080972fb31..f0580c29e762 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -338,9 +338,9 @@ object desugar {
   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 =>
+      case _: untpd.SplicePattern =>
         untpd.Typed(tree, expectedTpt).withSpan(tree.span)
-      case Typed(expr: untpd.Splice, tpt) =>
+      case Typed(expr: untpd.SplicePattern, tpt) =>
         cpy.Typed(tree)(expr, untpd.makeAndType(tpt, expectedTpt).withSpan(tpt.span))
 
       // Propagate down the expected type to the leafs of the expression
@@ -1979,7 +1979,7 @@ object desugar {
       case Quote(body, _) =>
         new UntypedTreeTraverser {
           def traverse(tree: untpd.Tree)(using Context): Unit = tree match {
-            case Splice(expr) => collect(expr)
+            case SplicePattern(body, _) => collect(body)
             case _ => traverseChildren(tree)
           }
         }.traverse(body)
diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala
index f3d7369d8d5d..54c15b9909fa 100644
--- a/compiler/src/dotty/tools/dotc/ast/Trees.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala
@@ -737,6 +737,22 @@ object Trees {
     type ThisTree[+T <: Untyped] = Splice[T]
   }
 
+  /** A tree representing a pattern splice `${ pattern }`, `$ident` or `$ident(args*)` in a quote pattern.
+   *
+   *  Parser will only create `${ pattern }` and `$ident`, hence they will not have args.
+   *  While typing, the `$ident(args*)` the args are identified and desugared into a `SplicePattern`
+   *  containing them.
+   *
+   *  SplicePattern are removed after typing the pattern and are not present in TASTy.
+   *
+   *  @param body  The tree that was spliced
+   *  @param args  The arguments of the splice (the HOAS arguments)
+   */
+  case class SplicePattern[+T <: Untyped] private[ast] (body: Tree[T], args: List[Tree[T]])(implicit @constructorOnly src: SourceFile)
+    extends TermTree[T] {
+    type ThisTree[+T <: Untyped] = SplicePattern[T]
+  }
+
   /** 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] {
@@ -1147,6 +1163,7 @@ object Trees {
     type Inlined = Trees.Inlined[T]
     type Quote = Trees.Quote[T]
     type Splice = Trees.Splice[T]
+    type SplicePattern = Trees.SplicePattern[T]
     type TypeTree = Trees.TypeTree[T]
     type InferredTypeTree = Trees.InferredTypeTree[T]
     type SingletonTypeTree = Trees.SingletonTypeTree[T]
@@ -1325,6 +1342,10 @@ object Trees {
         case tree: Splice if (expr eq tree.expr) => tree
         case _ => finalize(tree, untpd.Splice(expr)(sourceFile(tree)))
       }
+      def SplicePattern(tree: Tree)(body: Tree, args: List[Tree])(using Context): SplicePattern = tree match {
+        case tree: SplicePattern if (body eq tree.body) && (args eq tree.args) => tree
+        case _ => finalize(tree, untpd.SplicePattern(body, args)(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)))
@@ -1566,6 +1587,8 @@ object Trees {
               cpy.Quote(tree)(transform(body)(using quoteContext), transform(tags))
             case tree @ Splice(expr) =>
               cpy.Splice(tree)(transform(expr)(using spliceContext))
+            case tree @ SplicePattern(body, args) =>
+              cpy.SplicePattern(tree)(transform(body)(using spliceContext), transform(args))
             case tree @ Hole(isTerm, idx, args, content) =>
               cpy.Hole(tree)(isTerm, idx, transform(args), transform(content))
             case _ =>
@@ -1711,6 +1734,8 @@ object Trees {
               this(this(x, body)(using quoteContext), tags)
             case Splice(expr) =>
               this(x, expr)(using spliceContext)
+            case SplicePattern(body, args) =>
+              this(this(x, body)(using spliceContext), args)
             case Hole(_, _, args, content) =>
               this(this(x, args), content)
             case _ =>
diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
index 91299be537e8..e3488034fef8 100644
--- a/compiler/src/dotty/tools/dotc/ast/untpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -399,6 +399,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def Inlined(call: tpd.Tree, bindings: List[MemberDef], expansion: Tree)(implicit src: SourceFile): Inlined = new Inlined(call, bindings, expansion)
   def Quote(body: Tree, tags: List[Tree])(implicit src: SourceFile): Quote = new Quote(body, tags)
   def Splice(expr: Tree)(implicit src: SourceFile): Splice = new Splice(expr)
+  def SplicePattern(body: Tree, args: List[Tree])(implicit src: SourceFile): SplicePattern = new SplicePattern(body, args)
   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)
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 7ea113cb7bc7..7a29ac3f7a38 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -1750,10 +1750,10 @@ object Parsers {
     def splice(isType: Boolean): Tree =
       val start = in.offset
       atSpan(in.offset) {
+        val inPattern = (staged & StageKind.QuotedPattern) != 0
         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) {
@@ -1769,6 +1769,8 @@ object Parsers {
             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 if inPattern then
+          SplicePattern(expr, Nil)
         else
           Splice(expr)
       }
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index 0b539db283ed..51aaa0932e5e 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -735,6 +735,12 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case Splice(expr) =>
         val spliceTypeText = (keywordStr("[") ~ toTextGlobal(tree.typeOpt) ~ keywordStr("]")).provided(printDebug && tree.typeOpt.exists)
         keywordStr("$") ~ spliceTypeText ~ keywordStr("{") ~ toTextGlobal(expr) ~ keywordStr("}")
+      case SplicePattern(pattern, args) =>
+        val spliceTypeText = (keywordStr("[") ~ toTextGlobal(tree.typeOpt) ~ keywordStr("]")).provided(printDebug && tree.typeOpt.exists)
+        keywordStr("$") ~ spliceTypeText ~ {
+          if args.isEmpty then keywordStr("{") ~ inPattern(toText(pattern)) ~ keywordStr("}")
+          else toText(pattern.symbol.name) ~ "(" ~ toTextGlobal(args, ", ") ~ ")"
+        }
       case Hole(isTerm, idx, args, content) =>
         val (prefix, postfix) = if isTerm then ("{{{", "}}}") else ("[[[", "]]]")
         val argsText = toTextGlobal(args, ", ")
diff --git a/compiler/src/dotty/tools/dotc/typer/Applications.scala b/compiler/src/dotty/tools/dotc/typer/Applications.scala
index 79d6501ccb2d..fbed4b77d3fe 100644
--- a/compiler/src/dotty/tools/dotc/typer/Applications.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Applications.scala
@@ -1097,7 +1097,7 @@ trait Applications extends Compatibility {
         }
       else {
         val app = tree.fun match
-          case _: untpd.Splice if ctx.mode.is(Mode.QuotedPattern) => typedAppliedSplice(tree, pt)
+          case _: untpd.SplicePattern => typedAppliedSplice(tree, pt)
           case _ => realApply
         app match {
           case Apply(fn @ Select(left, _), right :: Nil) if fn.hasType =>
diff --git a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
index ea2b380dc0ed..070449e3ee96 100644
--- a/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
+++ b/compiler/src/dotty/tools/dotc/typer/QuotesAndSplices.scala
@@ -17,6 +17,7 @@ import dotty.tools.dotc.core.Types._
 import dotty.tools.dotc.inlines.PrepareInlineable
 import dotty.tools.dotc.staging.StagingLevel.*
 import dotty.tools.dotc.transform.SymUtils._
+import dotty.tools.dotc.typer.ErrorReporting.errorTree
 import dotty.tools.dotc.typer.Implicits._
 import dotty.tools.dotc.typer.Inferencing._
 import dotty.tools.dotc.util.Spans._
@@ -74,45 +75,55 @@ trait QuotesAndSplices {
   def typedSplice(tree: untpd.Splice, pt: Type)(using Context): Tree = {
     record("typedSplice")
     checkSpliceOutsideQuote(tree)
+    assert(!ctx.mode.is(Mode.QuotedPattern))
     tree.expr match {
       case untpd.Quote(innerExpr, Nil) if innerExpr.isTerm =>
         report.warning("Canceled quote directly inside a splice. ${ '{ XYZ } } is equivalent to XYZ.", tree.srcPos)
         return typed(innerExpr, pt)
       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
-        Splice(pat, argType).withSpan(tree.span)
-      }
-      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 (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)
-      }
-
-      // TODO typecheck directly (without `exprSplice`)
-      val internalSplice =
-        untpd.Apply(untpd.ref(defn.QuotedRuntime_exprSplice.termRef), tree.expr)
-      typedApply(internalSplice, pt)(using spliceContext).withSpan(tree.span) match
-        case tree @ Apply(TypeApply(_, tpt :: Nil), spliced :: Nil) if tree.symbol == defn.QuotedRuntime_exprSplice =>
-          cpy.Splice(tree)(spliced)
-        case tree => tree
+    if (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)
     }
+
+    // TODO typecheck directly (without `exprSplice`)
+    val internalSplice =
+      untpd.Apply(untpd.ref(defn.QuotedRuntime_exprSplice.termRef), tree.expr)
+    typedApply(internalSplice, pt)(using spliceContext).withSpan(tree.span) match
+      case tree @ Apply(TypeApply(_, tpt :: Nil), spliced :: Nil) if tree.symbol == defn.QuotedRuntime_exprSplice =>
+        cpy.Splice(tree)(spliced)
+      case tree => tree
+  }
+
+  def typedSplicePattern(tree: untpd.SplicePattern, pt: Type)(using Context): Tree = {
+    record("typedSplicePattern")
+    if isFullyDefined(pt, ForceDegree.flipBottom) then
+      def patternOuterContext(ctx: Context): Context =
+        if (ctx.mode.is(Mode.QuotedPattern)) patternOuterContext(ctx.outer) else ctx
+      val typedArgs = tree.args.map {
+        case arg: untpd.Ident =>
+          typedExpr(arg)
+        case arg =>
+          report.error("Open pattern expected an identifier", arg.srcPos)
+          EmptyTree
+      }
+      for arg <- typedArgs if arg.symbol.is(Mutable) do // TODO support these patterns. Possibly using scala.quoted.util.Var
+        report.error("References to `var`s cannot be used in higher-order pattern", arg.srcPos)
+      val argTypes = typedArgs.map(_.tpe.widenTermRefExpr)
+      val patType = if tree.args.isEmpty then pt else defn.FunctionOf(argTypes, pt)
+      val pat = typedPattern(tree.body, defn.QuotedExprClass.typeRef.appliedTo(patType))(
+        using spliceContext.retractMode(Mode.QuotedPattern).addMode(Mode.Pattern).withOwner(patternOuterContext(ctx).owner))
+      val baseType = pat.tpe.baseType(defn.QuotedExprClass)
+      val argType = if baseType.exists then baseType.argTypesHi.head else defn.NothingType
+      untpd.cpy.SplicePattern(tree)(pat, typedArgs).withType(pt)
+    else
+      errorTree(tree, em"Type must be fully defined.\nConsider annotating the splice using a type ascription:\n  ($tree: XYZ).", tree.body.srcPos)
   }
 
   def typedHole(tree: untpd.Hole, pt: Type)(using Context): Tree =
@@ -127,29 +138,17 @@ trait QuotesAndSplices {
    */
   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
-    def isInBraces: Boolean = splice.span.end != splice.expr.span.end
-    if !isFullyDefined(pt, ForceDegree.flipBottom) then
-      report.error(em"Type must be fully defined.", splice.srcPos)
-      tree.withType(UnspecifiedErrorType)
-    else if isInBraces then // ${x}(...) match an application
+    val untpd.Apply(splice: untpd.SplicePattern, args) = tree: @unchecked
+    def isInBraces: Boolean = splice.span.end != splice.body.span.end
+    if 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)
+      val splice1 = typedSplicePattern(splice, defn.FunctionOf(argTypes, pt))
+      untpd.cpy.Apply(tree)(splice1.select(nme.apply), typedArgs).withType(pt)
     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)))
+         report.error("Missing arguments for open pattern", tree.srcPos)
+      typedSplicePattern(untpd.cpy.SplicePattern(tree)(splice.body, args), pt)
   }
 
   /** Type a pattern variable name `t` in quote pattern as `${given t$giveni: Type[t @ _]}`.
@@ -227,29 +226,16 @@ trait QuotesAndSplices {
       val freshTypeBindingsBuff = new mutable.ListBuffer[Tree]
       val typePatBuf = new mutable.ListBuffer[Tree]
       override def transform(tree: Tree)(using Context) = tree match {
-        case Typed(splice: Splice, tpt) if !tpt.tpe.derivesFrom(defn.RepeatedParamClass) =>
+        case Typed(splice @ SplicePattern(pat, Nil), tpt) if !tpt.tpe.derivesFrom(defn.RepeatedParamClass) =>
           transform(tpt) // Collect type bindings
           transform(splice)
-        case Apply(TypeApply(fn, targs), Splice(pat) :: 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 Splice(pat) =>
-          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 SplicePattern(pat, args) =>
+          val patType = pat.tpe.widen
+          val patType1 = patType.translateFromRepeated(toArray = false)
+          val pat1 = if (patType eq patType1) pat else pat.withType(patType1)
+          patBuf += pat1
+          if args.isEmpty then ref(defn.QuotedRuntimePatterns_patternHole.termRef).appliedToType(tree.tpe).withSpan(tree.span)
+          else ref(defn.QuotedRuntimePatterns_higherOrderHole.termRef).appliedToType(tree.tpe).appliedTo(SeqLiteral(args, TypeTree(defn.AnyType))).withSpan(tree.span)
         case Select(pat: Bind, _) if tree.symbol.isTypeSplice =>
           val sym = tree.tpe.dealias.typeSymbol
           if sym.exists then
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index cfc9e968ef41..9a9e194c9e0b 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -3096,6 +3096,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           case untpd.EmptyTree => tpd.EmptyTree
           case tree: untpd.Quote => typedQuote(tree, pt)
           case tree: untpd.Splice => typedSplice(tree, pt)
+          case tree: untpd.SplicePattern => typedSplicePattern(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)

From b7cc75301208f306f82db79802a81de262680f43 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 16 May 2023 10:02:12 +0200
Subject: [PATCH 604/657] Fix docs

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

diff --git a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
index 19443dfb42e3..15a1a823589c 100644
--- a/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PickleQuotes.scala
@@ -59,9 +59,9 @@ import scala.annotation.constructorOnly
  *       ]],
  *       typeHole = Seq(a, b),
  *       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
+ *         case 3 => holeContents0.apply(args(0).asInstanceOf[Expr[U1]]).apply(quotes) // beta reduced
+ *         case 4 => holeContents1.apply(args(0).asInstanceOf[Expr[U2]]).apply(quotes) // beta reduced
+ *         case 5 => holeContents2.apply(args(0).asInstanceOf[Expr[U1]], args(1).asInstanceOf[Expr[U2]]).apply(quotes) // beta reduced
  *       },
  *     )
  *    ```

From dc7a2239be0c3b6bd2e520944922cbaad6b180ff Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 16 May 2023 12:09:47 +0200
Subject: [PATCH 605/657] Remove unnecessary `tasty-inspector` dependency

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

diff --git a/project/Build.scala b/project/Build.scala
index 30a731511f43..dbf574252113 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -926,7 +926,6 @@ object Build {
   lazy val `stdlib-bootstrapped` = project.in(file("stdlib-bootstrapped")).
     withCommonSettings(Bootstrapped).
     dependsOn(dottyCompiler(Bootstrapped) % "provided; compile->runtime; test->test").
-    dependsOn(`scala3-tasty-inspector` % "test->test").
     settings(commonBootstrappedSettings).
     settings(
       moduleName := "scala-library",

From 98ad63eb3f5b5093a561e40c8f4a0c4c8d97697d Mon Sep 17 00:00:00 2001
From: Yichen Xu <yichen.x@outlook.com>
Date: Wed, 17 May 2023 00:48:14 +0200
Subject: [PATCH 606/657] Account for capture dependencies when substituting

---
 compiler/src/dotty/tools/dotc/core/Types.scala    | 3 ++-
 tests/pos-custom-args/captures/cc-dep-param.scala | 8 ++++++++
 2 files changed, 10 insertions(+), 1 deletion(-)
 create mode 100644 tests/pos-custom-args/captures/cc-dep-param.scala

diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index 2e3ab1a5ded8..73a64f2c1b8f 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -3880,7 +3880,8 @@ object Types {
     /** 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
+    def isParamDependent(using Context): Boolean =
+      paramDependencyStatus == TrueDeps || paramDependencyStatus == CaptureDeps
 
     /** Is there a dependency involving a reference in a capture set, but
      *  otherwise no true result dependency?
diff --git a/tests/pos-custom-args/captures/cc-dep-param.scala b/tests/pos-custom-args/captures/cc-dep-param.scala
new file mode 100644
index 000000000000..1440cd4d7d40
--- /dev/null
+++ b/tests/pos-custom-args/captures/cc-dep-param.scala
@@ -0,0 +1,8 @@
+import language.experimental.captureChecking
+
+trait Foo[T]
+def test(): Unit =
+  val a: Foo[Int]^ = ???
+  val useA: () ->{a} Unit = ???
+  def foo[X](x: Foo[X]^, op: () ->{x} Unit): Unit = ???
+  foo(a, useA)

From 6870649ca53597aaac404be2951ef475c053f502 Mon Sep 17 00:00:00 2001
From: Yichen Xu <yichen.x@outlook.com>
Date: Wed, 17 May 2023 00:48:52 +0200
Subject: [PATCH 607/657] Fix capture set healing

Capture set healing happens at the end of capture checking (in the `postCheck`
function), which checks the capture set in each type argument and widen the
ill-formed `TermParamRef`s by widening them. However, it is possible that a
capture set is healed first, and then get a `TermParamRef` propagated into it
later when we are healing another capture set. This lead to unsoundness.

This commit installs an handler on capture sets when healing them and will
inspect the newly added elements and heal these new elements as well.
---
 .../src/dotty/tools/dotc/cc/CaptureSet.scala  | 15 +++++++++++-
 .../dotty/tools/dotc/cc/CheckCaptures.scala   |  7 ++++--
 .../captures/usingLogFile-alt.check           |  7 ++++++
 .../captures/usingLogFile-alt.scala           | 23 +++++++++++++++++++
 .../captures/usingLogFile.check               |  7 ------
 .../captures/usingLogFile.scala               |  2 +-
 6 files changed, 50 insertions(+), 11 deletions(-)
 create mode 100644 tests/neg-custom-args/captures/usingLogFile-alt.check
 create mode 100644 tests/neg-custom-args/captures/usingLogFile-alt.scala

diff --git a/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala b/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
index ce903acab411..fdc4f66beafa 100644
--- a/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CaptureSet.scala
@@ -275,6 +275,11 @@ sealed abstract class CaptureSet extends Showable:
     if isUniversal then handler()
     this
 
+  /** Invoke handler on the elements to check wellformedness of the capture set */
+  def ensureWellformed(handler: List[CaptureRef] => Context ?=> Unit)(using Context): this.type =
+    handler(elems.toList)
+    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
@@ -375,6 +380,9 @@ object CaptureSet:
     /** A handler to be invoked if the root reference `cap` is added to this set */
     var rootAddedHandler: () => Context ?=> Unit = () => ()
 
+    /** A handler to be invoked when new elems are added to this set */
+    var newElemAddedHandler: List[CaptureRef] => Context ?=> Unit = _ => ()
+
     var description: String = ""
 
     /** Record current elements in given VarState provided it does not yet
@@ -405,7 +413,8 @@ object CaptureSet:
       if !isConst && recordElemsState() then
         elems ++= newElems
         if isUniversal then rootAddedHandler()
-        // assert(id != 2 || elems.size != 2, this)
+        newElemAddedHandler(newElems.toList)
+        // assert(id != 5 || elems.size != 3, this)
         (CompareResult.OK /: deps) { (r, dep) =>
           r.andAlso(dep.tryInclude(newElems, this))
         }
@@ -425,6 +434,10 @@ object CaptureSet:
       rootAddedHandler = handler
       super.disallowRootCapability(handler)
 
+    override def ensureWellformed(handler: List[CaptureRef] => (Context) ?=> Unit)(using Context): this.type =
+      newElemAddedHandler = handler
+      super.ensureWellformed(handler)
+
     private var computingApprox = false
 
     /** Roughly: the intersection of all constant known supersets of this set.
diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index 6ec360eca938..3df31c305a91 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -976,8 +976,11 @@ class CheckCaptures extends Recheck, SymTransformer:
           recur(refs, Nil)
 
         private def healCaptureSet(cs: CaptureSet): Unit =
-          val toInclude = widenParamRefs(cs.elems.toList.filter(!isAllowed(_)).asInstanceOf)
-          toInclude.foreach(checkSubset(_, cs, tree.srcPos))
+          def avoidance(elems: List[CaptureRef])(using Context): Unit =
+            val toInclude = widenParamRefs(elems.filter(!isAllowed(_)).asInstanceOf)
+            //println(i"HEAL $cs by widening to $toInclude")
+            toInclude.foreach(checkSubset(_, cs, tree.srcPos))
+          cs.ensureWellformed(avoidance)
 
         private var allowed: SimpleIdentitySet[TermParamRef] = SimpleIdentitySet.empty
 
diff --git a/tests/neg-custom-args/captures/usingLogFile-alt.check b/tests/neg-custom-args/captures/usingLogFile-alt.check
new file mode 100644
index 000000000000..31e97b7dfda1
--- /dev/null
+++ b/tests/neg-custom-args/captures/usingLogFile-alt.check
@@ -0,0 +1,7 @@
+-- Error: tests/neg-custom-args/captures/usingLogFile-alt.scala:18:2 ---------------------------------------------------
+18 |  usingFile(  // error
+   |  ^^^^^^^^^
+   |  Sealed type variable T cannot  be instantiated to box () => Unit since
+   |  that type captures the root capability `cap`.
+   |  This is often caused by a local capability in the body of method usingFile
+   |  leaking as part of its result.
diff --git a/tests/neg-custom-args/captures/usingLogFile-alt.scala b/tests/neg-custom-args/captures/usingLogFile-alt.scala
new file mode 100644
index 000000000000..6b529ee6f892
--- /dev/null
+++ b/tests/neg-custom-args/captures/usingLogFile-alt.scala
@@ -0,0 +1,23 @@
+// Reported in issue #17517
+
+import language.experimental.captureChecking
+import java.io.*
+
+object Test:
+  class Logger(f: OutputStream^):
+    def log(msg: String): Unit = ???
+
+  def usingFile[sealed T](name: String, op: OutputStream^ => T): T =
+    val f = new FileOutputStream(name)
+    val result = op(f)
+    f.close()
+    result
+
+  def usingLogger[sealed T](f: OutputStream^)(op: Logger^{f} => T): T = ???
+
+  usingFile(  // error
+    "foo",
+    file => {
+      usingLogger(file)(l => () => l.log("test"))
+    }
+  )
diff --git a/tests/neg-custom-args/captures/usingLogFile.check b/tests/neg-custom-args/captures/usingLogFile.check
index f9230e37a1cf..d3bc9082202c 100644
--- a/tests/neg-custom-args/captures/usingLogFile.check
+++ b/tests/neg-custom-args/captures/usingLogFile.check
@@ -45,10 +45,3 @@
    |                that type captures the root capability `cap`.
    |                This is often caused by a local capability in the body of method usingFile
    |                leaking as part of its result.
--- Error: tests/neg-custom-args/captures/usingLogFile.scala:72:6 -------------------------------------------------------
-72 |      usingLogger(_, l => () => l.log("test"))) // error
-   |      ^^^^^^^^^^^
-   |      Sealed type variable T cannot  be instantiated to box () => Unit since
-   |      that type captures the root capability `cap`.
-   |      This is often caused by a local capability in the body of method usingLogger
-   |      leaking as part of its result.
diff --git a/tests/neg-custom-args/captures/usingLogFile.scala b/tests/neg-custom-args/captures/usingLogFile.scala
index 40c90b934464..e7c23573ca6e 100644
--- a/tests/neg-custom-args/captures/usingLogFile.scala
+++ b/tests/neg-custom-args/captures/usingLogFile.scala
@@ -69,5 +69,5 @@ object Test4:
 
   def test =
     val later = usingFile("logfile",            // error
-      usingLogger(_, l => () => l.log("test"))) // error
+      usingLogger(_, l => () => l.log("test"))) // ok, since we can widen `l` to `file` instead of to `cap`
     later()

From 44fed3dd529db6686f8c7caf8479a5bb915f2299 Mon Sep 17 00:00:00 2001
From: Matt Bovel <matthieu@bovel.net>
Date: Wed, 17 May 2023 13:52:28 +0200
Subject: [PATCH 608/657] Handle empty files and truncated YAML front matter

---
 .../src/dotty/tools/scaladoc/site/common.scala   | 11 ++++++++---
 .../test-documentations/emptyPage/_docs/hello.md |  0
 .../noConfigEnd/_docs/hello.md                   |  3 +++
 .../scaladoc/site/SiteGeneratationTest.scala     | 16 ++++++++++++++++
 4 files changed, 27 insertions(+), 3 deletions(-)
 create mode 100644 scaladoc/test-documentations/emptyPage/_docs/hello.md
 create mode 100644 scaladoc/test-documentations/noConfigEnd/_docs/hello.md

diff --git a/scaladoc/src/dotty/tools/scaladoc/site/common.scala b/scaladoc/src/dotty/tools/scaladoc/site/common.scala
index c0c959cf205c..0811d217537f 100644
--- a/scaladoc/src/dotty/tools/scaladoc/site/common.scala
+++ b/scaladoc/src/dotty/tools/scaladoc/site/common.scala
@@ -63,11 +63,16 @@ def yamlParser(using ctx: StaticSiteContext): Parser = Parser.builder(defaultMar
 def loadTemplateFile(file: File, defaultTitle: Option[TemplateName] = None)(using ctx: StaticSiteContext): TemplateFile = {
   val lines = Files.readAllLines(file.toPath).asScala.toList
 
-  val (config, content) = if (lines.head == ConfigSeparator) {
+  val (config, content) = if (!lines.isEmpty && lines.head == ConfigSeparator) {
     // Taking the second occurrence of ConfigSeparator.
     // The rest may appear within the content.
-    val index = lines.drop(1).indexOf(ConfigSeparator) + 2
-    (lines.take(index), lines.drop(index))
+    val secondSeparatorIndex = lines.drop(1).indexOf(ConfigSeparator)
+    if secondSeparatorIndex != -1 then
+      (lines.take(secondSeparatorIndex + 2), lines.drop(secondSeparatorIndex + 2))
+    else
+      // If there is no second occurrence of ConfigSeparator, we assume that the
+      // whole file is config.
+      (lines.tail, Nil)
   } else (Nil, lines)
 
   val configParsed = yamlParser.parse(config.mkString(LineSeparator))
diff --git a/scaladoc/test-documentations/emptyPage/_docs/hello.md b/scaladoc/test-documentations/emptyPage/_docs/hello.md
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/scaladoc/test-documentations/noConfigEnd/_docs/hello.md b/scaladoc/test-documentations/noConfigEnd/_docs/hello.md
new file mode 100644
index 000000000000..3809c65bce02
--- /dev/null
+++ b/scaladoc/test-documentations/noConfigEnd/_docs/hello.md
@@ -0,0 +1,3 @@
+---
+title: My page
+foo: bar
diff --git a/scaladoc/test/dotty/tools/scaladoc/site/SiteGeneratationTest.scala b/scaladoc/test/dotty/tools/scaladoc/site/SiteGeneratationTest.scala
index 7ce16933997a..e012044156cc 100644
--- a/scaladoc/test/dotty/tools/scaladoc/site/SiteGeneratationTest.scala
+++ b/scaladoc/test/dotty/tools/scaladoc/site/SiteGeneratationTest.scala
@@ -95,6 +95,22 @@ class SiteGeneratationTest extends BaseHtmlTest:
     testApiPages(mainTitle = projectName, parents = Nil, hasToplevelIndexIndex = false)
   }
 
+  @Test
+  def emptyPage() = withGeneratedSite(testDocPath.resolve("emptyPage")){
+    withHtmlFile("docs/hello.html") { content =>
+      // There should be no content as the page body is empty.
+      content.assertTextsIn("#content", Nil*)
+    }
+  }
+
+  @Test
+  def noConfigEnd() = withGeneratedSite(testDocPath.resolve("noConfigEnd")){
+    withHtmlFile("docs/hello.html") { content =>
+      // There should be no content as the page body is empty.
+      content.assertTextsIn("#content", Nil*)
+    }
+  }
+
   @Test
   def staticLinking() = withGeneratedSite(testDocPath.resolve("static-links")){
 

From df20af859cd4d18bc07459a1aee507c2bde39906 Mon Sep 17 00:00:00 2001
From: Julien Richard-Foy <julien@richard-foy.fr>
Date: Wed, 17 May 2023 16:08:32 +0200
Subject: [PATCH 609/657] Clarify the purpose of the website
 https://dotty.epfl.ch

---
 CONTRIBUTING.md                     |  2 +-
 docs/_blog/index.html               |  2 +-
 docs/_docs/contributing/workflow.md |  1 +
 docs/_docs/index.md                 | 15 +--------------
 4 files changed, 4 insertions(+), 16 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 48206fd67b3c..90496bcd0c0a 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -2,4 +2,4 @@
 
 Firstly, thanks for being willing to contribute to Dotty! Head on over the
 [Scala 3 Contributing
-Guide](https://docs.scala-lang.org/scala3/guides/contribution/contribution-intro.html), which should have all the info you're looking for.
+Guide](https://dotty.epfl.ch/docs/contributing/index.html), which should have all the info you're looking for.
diff --git a/docs/_blog/index.html b/docs/_blog/index.html
index 055b069b303d..a59b8702d326 100644
--- a/docs/_blog/index.html
+++ b/docs/_blog/index.html
@@ -1,6 +1,6 @@
 ---
 layout: static-site-main
-title: Blog
+title: Blog (archive)
 ---
 <main class="container">
     <h1>{{ page.title }}</h1>
diff --git a/docs/_docs/contributing/workflow.md b/docs/_docs/contributing/workflow.md
index 36d91bf02707..fb8108e7ceb0 100644
--- a/docs/_docs/contributing/workflow.md
+++ b/docs/_docs/contributing/workflow.md
@@ -115,6 +115,7 @@ The basics of working with Dotty codebase are documented [here](https://dotty.ep
 | `testOnly dotty.tools.dotc.CompilationTests -- *pos` | Run test (method) `pos` from `CompilationTests` suite.                                                                        |
 | `testCompilation sample`                             | In all test suites, run test files containing the word `sample` in their title.                                               |
 | `scala3-compiler/Test/runMain dotty.tools.printTypes`|  Print types underlying representation                                                                                        |
+| `scaladoc/generateScalaDocumentation`               | Build the documentation website                                                                                              |
 
 
 ## Shell Commands
diff --git a/docs/_docs/index.md b/docs/_docs/index.md
index 97dc7fd5886b..e61313d81a4a 100644
--- a/docs/_docs/index.md
+++ b/docs/_docs/index.md
@@ -1,19 +1,6 @@
 ---
 layout: index
 redirectFrom: /docs/index.html
-nightlyOf: https://docs.scala-lang.org/scala3/reference/
 ---
 
-Dotty is the project name for technologies that are considered for inclusion in Scala 3. Scala has
-pioneered the fusion of object-oriented and functional programming in a typed setting. Scala 3 will
-be a big step towards realizing the full potential of these ideas. Its main objectives are to
-
-- become more opinionated by promoting programming idioms we found to work well,
-- simplify where possible,
-- eliminate inconsistencies and surprising behaviors,
-- build on strong foundations to ensure the design hangs well together,
-- consolidate language constructs to improve the language’s consistency, safety, ergonomics, and performance.
-
-In this documentation you will find information on how to use the Dotty compiler on your machine,
-navigate through the code, setup Dotty with your favorite IDE and more!
-
+This website contains the developer documentation of the Scala 3 compiler. It targets developers interested in contributing to the compiler, or learning its internals. If you want to learn how to use Scala, go [here](https://docs.scala-lang.org/).

From 813dd1e8a88d69dcca1ea504e34ec9f461362459 Mon Sep 17 00:00:00 2001
From: Julien Richard-Foy <julien@richard-foy.fr>
Date: Wed, 17 May 2023 16:20:49 +0200
Subject: [PATCH 610/657] Fix a bunch of links

---
 docs/_docs/contributing/architecture/phases.md      | 2 +-
 docs/_docs/contributing/getting-started.md          | 2 +-
 docs/_docs/contributing/index.md                    | 4 ++--
 docs/_docs/reference/metaprogramming/macros-spec.md | 2 +-
 4 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/docs/_docs/contributing/architecture/phases.md b/docs/_docs/contributing/architecture/phases.md
index 15690dfe4e4e..844ae144dddb 100644
--- a/docs/_docs/contributing/architecture/phases.md
+++ b/docs/_docs/contributing/architecture/phases.md
@@ -105,4 +105,4 @@ These map the transformed trees to Java classfiles or SJSIR files.
 [patternMatcher]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala
 [erasure]: https://github.com/lampepfl/dotty/blob/master/compiler/src/dotty/tools/dotc/transform/Erasure.scala
 [Mirror]: https://github.com/lampepfl/dotty/blob/master/library/src/scala/deriving/Mirror.scala
-[PCP]: {{ site.scala3ref }}/metaprogramming/macros.html#the-phase-consistency-principle
+[PCP]: ../../reference/metaprogramming/macros.md#the-phase-consistency-principle
diff --git a/docs/_docs/contributing/getting-started.md b/docs/_docs/contributing/getting-started.md
index 239e738bbfbb..af9f2f0783b8 100644
--- a/docs/_docs/contributing/getting-started.md
+++ b/docs/_docs/contributing/getting-started.md
@@ -134,7 +134,7 @@ The main development discussion channels are:
 [java8]: https://www.oracle.com/java/technologies/javase-jdk8-downloads.html
 [java11]: https://www.oracle.com/java/technologies/javase-jdk11-downloads.html
 [adopt]: https://adoptopenjdk.net/
-[compat]: /overviews/jdk-compatibility/overview.html
+[compat]: https://docs.scala-lang.org/overviews/jdk-compatibility/overview.html
 [scala-cla]: https://www.lightbend.com/contribute/cla/scala
 [dotty-issue]: https://github.com/lampepfl/dotty/issues
 [dotty-discussion]: https://github.com/lampepfl/dotty/discussions
diff --git a/docs/_docs/contributing/index.md b/docs/_docs/contributing/index.md
index 27954aefd7a1..0cc87e4b3500 100644
--- a/docs/_docs/contributing/index.md
+++ b/docs/_docs/contributing/index.md
@@ -19,9 +19,9 @@ if you notice anything out of date, or report any issues
 ### Get the Most from This Guide
 
 `dotc` is built with Scala 3, fully utilising its [new
-features](/scala3/new-in-scala3.html). It is recommended that you first have
+features](https://docs.scala-lang.org/scala3/new-in-scala3.html). It is recommended that you first have
 some familiarity with Scala 3 to get the most out of this guide. You can learn
-more in the [language reference]({{ site.scala3ref }}).
+more in the [language reference](../reference/overview.md).
 
 Many code snippets in this guide make use of shell commands (a line beginning
 with `$`), and in this case a `bash` compatible shell is assumed. You may have
diff --git a/docs/_docs/reference/metaprogramming/macros-spec.md b/docs/_docs/reference/metaprogramming/macros-spec.md
index 35a1b4b3d43a..27a0a2c1bdcb 100644
--- a/docs/_docs/reference/metaprogramming/macros-spec.md
+++ b/docs/_docs/reference/metaprogramming/macros-spec.md
@@ -134,7 +134,7 @@ Quotes define all the `Expr[T]` methods as extension methods.
 `Type[T]` does not have methods and therefore does not appear here.
 These methods are available as long as `Quotes` is implicitly given in the current scope.
 
-The `Quotes` instance is also the entry point to the [reflection API](./refelction.md) through the `reflect` object.
+The `Quotes` instance is also the entry point to the [reflection API](./reflection.md) through the `reflect` object.
 
 Finally, `Quotes` provides the internal logic used in quote un-pickling (`QuoteUnpickler`) in quote pattern matching (`QuoteMatching`).
 These interfaces are added to the self-type of the trait to make sure they are implemented on this object but not visible to users of `Quotes`.

From 113b08acb7ee1460519d6c4fab5d0e6a156a0810 Mon Sep 17 00:00:00 2001
From: Yichen Xu <yichen.x@outlook.com>
Date: Thu, 18 May 2023 02:19:57 +0200
Subject: [PATCH 611/657] Avoid using `Range`s in exact substitutions

This improves the completeness of capture checking in the following case:
```scala
def run(io: IO^)(op: Op^{io}): Unit = ???
val myIO: IO^ = ???
val myOp: Op^{myIO} = ???
run(myIO)(myOp)
```
The last line previously won't work because when substitute the parameter `io`
to `myIO` in the type `(op: Op^{io}): Unit` the type `Op^{io}` get approximated
into `Nothing` contravariantly. This is an overshot since the substitution [io
:= myIO] is exact (or precise) and the approximation (or avoidance) is
unnecessary.

This commit resolves this issue by checking whether the `to` only contains
`CaptureRef` in `SubstParamsMap`. If this condition is met, then it is an exact
substitution and we can apply it on the capture set without approximations.
---
 .../dotty/tools/dotc/cc/CheckCaptures.scala   | 27 +++++++++------
 .../captures/cc-subst-param-exact.scala       | 33 +++++++++++++++++++
 2 files changed, 50 insertions(+), 10 deletions(-)
 create mode 100644 tests/neg-custom-args/captures/cc-subst-param-exact.scala

diff --git a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
index 6ec360eca938..5ecd29119e3a 100644
--- a/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
+++ b/compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala
@@ -72,16 +72,23 @@ object CheckCaptures:
    */
   final class SubstParamsMap(from: BindingType, to: List[Type])(using Context)
   extends ApproximatingTypeMap, IdempotentCaptRefMap:
-    def apply(tp: Type): Type = tp match
-      case tp: ParamRef =>
-        if tp.binder == from then to(tp.paramNum) else tp
-      case tp: NamedType =>
-        if tp.prefix `eq` NoPrefix then tp
-        else tp.derivedSelect(apply(tp.prefix))
-      case _: ThisType =>
-        tp
-      case _ =>
-        mapOver(tp)
+    /** This SubstParamsMap is exact if `to` only contains `CaptureRef`s. */
+    private val isExactSubstitution: Boolean = to.forall(_.isInstanceOf[CaptureRef])
+
+    /** As long as this substitution is exact, there is no need to create `Range`s when mapping invariant positions. */
+    override protected def needsRangeIfInvariant(refs: CaptureSet): Boolean = !isExactSubstitution
+
+    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.
diff --git a/tests/neg-custom-args/captures/cc-subst-param-exact.scala b/tests/neg-custom-args/captures/cc-subst-param-exact.scala
new file mode 100644
index 000000000000..35e4acb95fdc
--- /dev/null
+++ b/tests/neg-custom-args/captures/cc-subst-param-exact.scala
@@ -0,0 +1,33 @@
+import language.experimental.captureChecking
+import caps.*
+
+trait Ref[T] { def set(x: T): T }
+def test() = {
+
+  def swap[T](x: Ref[T]^)(y: Ref[T]^{x}): Unit = ???
+  def foo[T](x: Ref[T]^): Unit =
+    swap(x)(x)
+
+  def bar[T](x: () => Ref[T]^)(y: Ref[T]^{x}): Unit =
+    swap(x())(y)  // error
+
+  def baz[T](x: Ref[T]^)(y: Ref[T]^{x}): Unit =
+    swap(x)(y)
+}
+
+trait IO
+type Op = () -> Unit
+def test2(c: IO^, f: Op^{c}) = {
+  def run(io: IO^)(op: Op^{io}): Unit = op()
+  run(c)(f)
+
+  def bad(getIO: () => IO^, g: Op^{getIO}): Unit =
+    run(getIO())(g)  // error
+}
+
+def test3() = {
+  def run(io: IO^)(op: Op^{io}): Unit = ???
+  val myIO: IO^ = ???
+  val myOp: Op^{myIO} = ???
+  run(myIO)(myOp)
+}

From 893a4c13c82d60892917a52827536c179e6ee862 Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Thu, 4 May 2023 09:18:45 +0200
Subject: [PATCH 612/657] deps: bump jackson to 2.15.1

If you're curious the release notes for this version can be found in
https://github.com/FasterXML/jackson/wiki/Jackson-Release-2.15.
---
 project/Dependencies.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/project/Dependencies.scala b/project/Dependencies.scala
index 1ac5090b7a6e..54bc6ecadfe0 100644
--- a/project/Dependencies.scala
+++ b/project/Dependencies.scala
@@ -4,7 +4,7 @@ import sbt._
  *  to ensure the same version of the dependency is used in all projects
  */
 object Dependencies {
-  private val jacksonVersion = "2.13.3"
+  private val jacksonVersion = "2.15.1"
   val `jackson-databind` =
     "com.fasterxml.jackson.core" % "jackson-databind" % jacksonVersion
   val `jackson-dataformat-yaml` =

From 5038c9c4401e9922e0d5fa11369981f722be0d9c Mon Sep 17 00:00:00 2001
From: Seth Tisue <seth@tisue.net>
Date: Thu, 18 May 2023 14:39:56 -0700
Subject: [PATCH 613/657] ClassfileParser: allow missing param names (for JDK
 21)

this is a forward port of scala/scala#10397 (fixing scala/bug#12783,
from which Scala 3 also suffers)
---
 .../dotty/tools/dotc/core/classfile/ClassfileParser.scala | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala b/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
index eeeb3767bd34..0c701eb03d38 100644
--- a/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
+++ b/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
@@ -758,10 +758,12 @@ class ClassfileParser(
         case tpnme.MethodParametersATTR =>
           val paramCount = in.nextByte
           for i <- 0 until paramCount do
-            val name = pool.getName(in.nextChar)
+            val index = in.nextChar
             val flags = in.nextChar
-            if (flags & JAVA_ACC_SYNTHETIC) == 0 then
-              res.namedParams += (i -> name.name)
+            if index != 0 then
+              val name = pool.getName(index)
+              if (flags & JAVA_ACC_SYNTHETIC) == 0 then
+                res.namedParams += (i -> name.name)
 
         case tpnme.AnnotationDefaultATTR =>
           sym.addAnnotation(Annotation(defn.AnnotationDefaultAnnot, Nil, sym.span))

From cbf1f18d9291cf05c115da929668573acfc2ecdb Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Fri, 19 May 2023 08:36:57 +0200
Subject: [PATCH 614/657] fix(scaladocs): make sure scaladocs are aligned with
 actual behavior (#17448)

This change just make sure the actual behavior is aligned with the
comments about plugin options.

refs https://github.com/lampepfl/dotty/discussions/17238
---
 compiler/src/dotty/tools/dotc/plugins/Plugin.scala  | 2 +-
 compiler/src/dotty/tools/dotc/plugins/Plugins.scala | 2 --
 2 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/plugins/Plugin.scala b/compiler/src/dotty/tools/dotc/plugins/Plugin.scala
index be6fecebb55a..1baf3a06ad9e 100644
--- a/compiler/src/dotty/tools/dotc/plugins/Plugin.scala
+++ b/compiler/src/dotty/tools/dotc/plugins/Plugin.scala
@@ -44,7 +44,7 @@ sealed trait Plugin {
 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)
+   *  @param options commandline options to the plugin.
    *  @return a list of phases to be added to the phase plan
    */
   def init(options: List[String]): List[PluginPhase]
diff --git a/compiler/src/dotty/tools/dotc/plugins/Plugins.scala b/compiler/src/dotty/tools/dotc/plugins/Plugins.scala
index 976b783c40f0..c44fe4cf59b4 100644
--- a/compiler/src/dotty/tools/dotc/plugins/Plugins.scala
+++ b/compiler/src/dotty/tools/dotc/plugins/Plugins.scala
@@ -116,8 +116,6 @@ trait Plugins {
 
   /** 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)

From e777aa52c6cf60bdcb0246731e0c7872ed157b46 Mon Sep 17 00:00:00 2001
From: Julien Richard-Foy <julien@richard-foy.fr>
Date: Fri, 19 May 2023 09:26:24 +0200
Subject: [PATCH 615/657] Clarify which websites are built by which command

---
 docs/_docs/contributing/workflow.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/docs/_docs/contributing/workflow.md b/docs/_docs/contributing/workflow.md
index fb8108e7ceb0..1d11dc61a6bf 100644
--- a/docs/_docs/contributing/workflow.md
+++ b/docs/_docs/contributing/workflow.md
@@ -115,7 +115,8 @@ The basics of working with Dotty codebase are documented [here](https://dotty.ep
 | `testOnly dotty.tools.dotc.CompilationTests -- *pos` | Run test (method) `pos` from `CompilationTests` suite.                                                                        |
 | `testCompilation sample`                             | In all test suites, run test files containing the word `sample` in their title.                                               |
 | `scala3-compiler/Test/runMain dotty.tools.printTypes`|  Print types underlying representation                                                                                        |
-| `scaladoc/generateScalaDocumentation`               | Build the documentation website                                                                                              |
+| `scaladoc/generateScalaDocumentation`                | Build the documentation website (published to https://dotty.epfl.ch)                                                          |
+| `scaladoc/generateReferenceDocumentation`            | Build the reference documentation website (published to https://docs.scala-lang.org/scala3/reference)                         |
 
 
 ## Shell Commands

From 13dd58db60a777a96f1f1d1253229bd74de42884 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Fri, 19 May 2023 16:21:34 +0200
Subject: [PATCH 616/657] Register `paramProxy` and `thisProxy` in `Quote` type

Before 5ae7861eb246461bc0f970d0e446c2b080440d18 we used to find those
types withing the `tpt`.

Fixes #17434
---
 .../dotty/tools/dotc/inlines/Inliner.scala    |  1 +
 tests/pos-macros/i17434a/Macro.scala          |  8 +++++
 tests/pos-macros/i17434a/Test.scala           | 23 +++++++++++++++
 tests/pos-macros/i17434b/Macro.scala          | 29 +++++++++++++++++++
 tests/pos-macros/i17434b/Test.scala           |  6 ++++
 tests/pos-macros/i17434c/Macro.scala          |  3 ++
 tests/pos-macros/i17434c/Test.scala           |  1 +
 tests/pos-macros/i17434d/Macro.scala          |  2 ++
 tests/pos-macros/i17434d/Test.scala           |  4 +++
 9 files changed, 77 insertions(+)
 create mode 100644 tests/pos-macros/i17434a/Macro.scala
 create mode 100644 tests/pos-macros/i17434a/Test.scala
 create mode 100644 tests/pos-macros/i17434b/Macro.scala
 create mode 100644 tests/pos-macros/i17434b/Test.scala
 create mode 100644 tests/pos-macros/i17434c/Macro.scala
 create mode 100644 tests/pos-macros/i17434c/Test.scala
 create mode 100644 tests/pos-macros/i17434d/Macro.scala
 create mode 100644 tests/pos-macros/i17434d/Test.scala

diff --git a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
index 54decf137b42..73fa2a2871a2 100644
--- a/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
+++ b/compiler/src/dotty/tools/dotc/inlines/Inliner.scala
@@ -486,6 +486,7 @@ class Inliner(val call: tpd.Tree)(using Context):
   /** Register type of leaf node */
   private def registerLeaf(tree: Tree): Unit = tree match
     case _: This | _: Ident | _: TypeTree => registerTypes.traverse(tree.typeOpt)
+    case tree: Quote => registerTypes.traverse(tree.bodyType)
     case _ =>
 
   /** Make `tree` part of inlined expansion. This means its owner has to be changed
diff --git a/tests/pos-macros/i17434a/Macro.scala b/tests/pos-macros/i17434a/Macro.scala
new file mode 100644
index 000000000000..0e399d82a9d1
--- /dev/null
+++ b/tests/pos-macros/i17434a/Macro.scala
@@ -0,0 +1,8 @@
+import scala.quoted.*
+
+object SelectDynamicMacroImpl {
+  def selectImpl[E: Type](
+    ref: Expr[SQLSyntaxProvider[_]],
+    name: Expr[String]
+  )(using Quotes): Expr[SQLSyntax] = '{SQLSyntax("foo")}
+}
diff --git a/tests/pos-macros/i17434a/Test.scala b/tests/pos-macros/i17434a/Test.scala
new file mode 100644
index 000000000000..8e7c314b238d
--- /dev/null
+++ b/tests/pos-macros/i17434a/Test.scala
@@ -0,0 +1,23 @@
+// test.scala
+import scala.language.dynamics
+
+trait SQLSyntaxProvider[A] extends Dynamic{
+  def field(name: String): SQLSyntax = ???
+
+  inline def selectDynamic(inline name: String): SQLSyntax =
+  select[A](this, name)
+
+  inline def select[E](ref: SQLSyntaxProvider[A], inline name: String): SQLSyntax =
+    ${ SelectDynamicMacroImpl.selectImpl[E]('ref, 'name) }
+}
+
+class SQLSyntax(value: String)
+trait SQLSyntaxSupport[A]
+case class ColumnSQLSyntaxProvider[S <: SQLSyntaxSupport[A], A](support: S) extends SQLSyntaxProvider[A]
+
+case class Account(id: Long, name: String)
+object Account extends SQLSyntaxSupport[Account]
+
+def Test() =
+  val p = ColumnSQLSyntaxProvider[Account.type, Account](Account)
+  assert(p.name == SQLSyntax("name"))
diff --git a/tests/pos-macros/i17434b/Macro.scala b/tests/pos-macros/i17434b/Macro.scala
new file mode 100644
index 000000000000..adca2888f777
--- /dev/null
+++ b/tests/pos-macros/i17434b/Macro.scala
@@ -0,0 +1,29 @@
+trait NameOf:
+  transparent inline def nameOf(inline expr: Any): String = ${NameOfImpl.nameOf('expr)}
+  transparent inline def nameOf[T](inline expr: T => Any): String = ${NameOfImpl.nameOf('expr)}
+object NameOf extends NameOf
+
+import scala.compiletime.*
+
+import scala.annotation.tailrec
+import scala.quoted.*
+
+object NameOfImpl {
+  def nameOf(expr: Expr[Any])(using Quotes): Expr[String] = {
+    import quotes.reflect.*
+    @tailrec def extract(tree: Tree): String = tree match {
+      case Ident(name) => name
+      case Select(_, name) => name
+      case Block(List(stmt), term) => extract(stmt)
+      case DefDef("$anonfun", _, _, Some(term)) => extract(term)
+      case Block(_, term) => extract(term)
+      case Apply(term, _) if term.symbol.fullName != "<special-ops>.throw" => extract(term)
+      case TypeApply(term, _) => extract(term)
+      case Inlined(_, _, term) => extract(term)
+      case Typed(term, _) => extract(term)
+      case _ => throw new MatchError(s"Unsupported expression: ${expr.show}")
+    }
+    val name = extract(expr.asTerm)
+    Expr(name)
+  }
+}
diff --git a/tests/pos-macros/i17434b/Test.scala b/tests/pos-macros/i17434b/Test.scala
new file mode 100644
index 000000000000..5e71f9c95965
--- /dev/null
+++ b/tests/pos-macros/i17434b/Test.scala
@@ -0,0 +1,6 @@
+import NameOf._
+def test() =
+    def func1(x: Int): String = ???
+    val funcVal = func1 _
+    assert(nameOf(funcVal) == "funcVal")
+    assert(nameOf(func1 _) == "func1")
diff --git a/tests/pos-macros/i17434c/Macro.scala b/tests/pos-macros/i17434c/Macro.scala
new file mode 100644
index 000000000000..dc3d2a533117
--- /dev/null
+++ b/tests/pos-macros/i17434c/Macro.scala
@@ -0,0 +1,3 @@
+import scala.quoted.*
+inline def foo[T](expr: T => Any): Unit = ${impl('expr)}
+def impl(expr: Expr[Any])(using Quotes): Expr[Unit] = '{}
diff --git a/tests/pos-macros/i17434c/Test.scala b/tests/pos-macros/i17434c/Test.scala
new file mode 100644
index 000000000000..6561dd193b63
--- /dev/null
+++ b/tests/pos-macros/i17434c/Test.scala
@@ -0,0 +1 @@
+def test(f: Int => Any) = foo(f)
diff --git a/tests/pos-macros/i17434d/Macro.scala b/tests/pos-macros/i17434d/Macro.scala
new file mode 100644
index 000000000000..a76c8aab58e4
--- /dev/null
+++ b/tests/pos-macros/i17434d/Macro.scala
@@ -0,0 +1,2 @@
+import scala.quoted.*
+def impl[E: Type](ref: Expr[Foo[_]])(using Quotes): Expr[Unit] = '{ }
diff --git a/tests/pos-macros/i17434d/Test.scala b/tests/pos-macros/i17434d/Test.scala
new file mode 100644
index 000000000000..3af0ddecd061
--- /dev/null
+++ b/tests/pos-macros/i17434d/Test.scala
@@ -0,0 +1,4 @@
+trait Foo[A]:
+  inline def foo(): Unit = bar[this.type](this)
+  inline def bar[E](ref: Foo[A]): Unit = ${ impl[E]('ref) }
+def test(p: Foo[Int]) = p.foo()

From da4996a132e2d44a4630c5a17173f468173333e3 Mon Sep 17 00:00:00 2001
From: Guillaume Raffin <theelectronwill@gmail.com>
Date: Tue, 7 Mar 2023 18:54:53 +0100
Subject: [PATCH 617/657] Remove synthetic record constructor if the user has
 written one manually

Co-authored-by: Guillaume Martres <smarter@users.noreply.github.com>
---
 .../dotty/tools/dotc/core/Definitions.scala    |  1 +
 .../dotty/tools/dotc/parsing/JavaParsers.scala | 10 +++++-----
 .../src/dotty/tools/dotc/typer/Namer.scala     | 18 +++++++++++++-----
 .../src/dotty/tools/dotc/typer/Typer.scala     | 12 +++++++++---
 tests/pos-java16+/java-records/R2.java         |  8 ++++----
 5 files changed, 32 insertions(+), 17 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
index b7211b3ce5e3..a4f27358f673 100644
--- a/compiler/src/dotty/tools/dotc/core/Definitions.scala
+++ b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -688,6 +688,7 @@ class Definitions {
   @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 JavaRecordClass: Symbol = getClassIfDefined("java.lang.Record")
 
   @tu lazy val JavaEnumClass: ClassSymbol = {
     val cls = requiredClass("java.lang.Enum")
diff --git a/compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala b/compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala
index 5ab187871542..6ec896dcb200 100644
--- a/compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala
@@ -21,8 +21,7 @@ import reporting._
 import dotty.tools.dotc.util.SourceFile
 import util.Spans._
 
-import scala.collection.mutable.ListBuffer
-import scala.collection.immutable.ListMap
+import scala.collection.mutable.{ListBuffer, LinkedHashMap}
 
 object JavaParsers {
 
@@ -839,7 +838,7 @@ object JavaParsers {
 
       // We need to generate accessors for every param, if no method with the same name is already defined
 
-      var fieldsByName = header.map(v => (v.name, (v.tpt, v.mods.annotations))).to(ListMap)
+      var fieldsByName = header.map(v => (v.name, (v.tpt, v.mods.annotations))).to(LinkedHashMap)
 
       for case DefDef(name, paramss, _, _) <- body
       if paramss.isEmpty && fieldsByName.contains(name)
@@ -855,7 +854,8 @@ object JavaParsers {
 
       // generate the canonical constructor
       val canonicalConstructor =
-        DefDef(nme.CONSTRUCTOR, joinParams(tparams, List(header)), TypeTree(), EmptyTree).withMods(Modifiers(Flags.JavaDefined, mods.privateWithin))
+        DefDef(nme.CONSTRUCTOR, joinParams(tparams, List(header)), TypeTree(), EmptyTree)
+          .withMods(Modifiers(Flags.JavaDefined | Flags.Synthetic, mods.privateWithin))
 
       // return the trees
       val recordTypeDef = atSpan(start, nameOffset) {
@@ -866,7 +866,7 @@ object JavaParsers {
             tparams = tparams,
             true
           )
-        )
+        ).withMods(mods)
       }
       addCompanionObject(statics, recordTypeDef)
     end recordDecl
diff --git a/compiler/src/dotty/tools/dotc/typer/Namer.scala b/compiler/src/dotty/tools/dotc/typer/Namer.scala
index 4eeb5540f137..cc4433f75a68 100644
--- a/compiler/src/dotty/tools/dotc/typer/Namer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Namer.scala
@@ -862,7 +862,6 @@ class Namer { typer: Typer =>
      *  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)
@@ -879,10 +878,19 @@ class Namer { typer: Typer =>
             !sd.symbol.is(Deferred) && sd.matches(denot)))
 
       val isClashingSynthetic =
-        denot.is(Synthetic, butNot = ConstructorProxy)
-        && desugar.isRetractableCaseClassMethodName(denot.name)
-        && isCaseClassOrCompanion(denot.owner)
-        && (definesMember || inheritsConcreteMember)
+        denot.is(Synthetic, butNot = ConstructorProxy) &&
+        (
+          (desugar.isRetractableCaseClassMethodName(denot.name)
+            && isCaseClassOrCompanion(denot.owner)
+            && (definesMember || inheritsConcreteMember)
+          )
+          ||
+          // remove synthetic constructor of a java Record if it clashes with a non-synthetic constructor
+          (denot.isConstructor
+            && denot.owner.is(JavaDefined) && denot.owner.derivesFrom(defn.JavaRecordClass)
+            && denot.owner.unforcedDecls.lookupAll(denot.name).exists(c => c != denot.symbol && c.info.matches(denot.info))
+          )
+        )
 
       if isClashingSynthetic then
         typr.println(i"invalidating clashing $denot in ${denot.owner}")
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 02df12ecc0bc..49b26122d15e 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -2433,11 +2433,17 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
   }
 
   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))
+    def canBeInvalidated(sym: Symbol): Boolean =
+      sym.is(Synthetic)
+      && (desugar.isRetractableCaseClassMethodName(sym.name) ||
+        (sym.isConstructor && sym.owner.derivesFrom(defn.JavaRecordClass)))
+
+    if !sym.info.exists then
+      // it's a discarded method (synthetic case class method or synthetic java record constructor), drop it
+      assert(canBeInvalidated(sym))
       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
diff --git a/tests/pos-java16+/java-records/R2.java b/tests/pos-java16+/java-records/R2.java
index 01da13d83b65..4b3f881628b9 100644
--- a/tests/pos-java16+/java-records/R2.java
+++ b/tests/pos-java16+/java-records/R2.java
@@ -5,9 +5,9 @@ public int getInt() {
         }
 
         // Canonical constructor
-        // public R(int i, java.lang.String s) {
-        //     this.i = i;
-        //     this.s = s.intern();
-        // }
+        public R(int i, java.lang.String s) {
+            this.i = i;
+            this.s = s.intern();
+        }
     }
 }

From ac2b53baea5555a475456b98d8b8763608de3c61 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?S=C3=A9bastien=20Doeraene?= <sjrdoeraene@gmail.com>
Date: Tue, 23 May 2023 13:35:46 +0200
Subject: [PATCH 618/657] Fix #17549: Unify how Memoize and Constructors decide
 what fields need storing.

The Memoize and Constructors have to work together and agree on
which `final val`s actually need storing in a field. Previously,
they used slightly different criteria: one on the result type, and
one on the rhs (with an additional Scala.js-specific eligibility
condition). That discrepancy resulted in the crash/wrong codegen
in the issue.

We now unify both: we avoid a field if and only if all of the
following apply:

* it is a `final val`,
* its result *type* is a `ConstantType`, and
* it is eligible according to Scala.js semantics.

In particular, there is no condition on the right-hand-side. We
avoid a field even if the right-hand-side has side effects. The
side effects are moved to the constructor regardless.

---

This introduces both progressions and regressions in the amount of
fields we generate. We can avoid fields even for side-effecting
rhs'es, as long as the result type is constant. On the other hand,
we now create a field for `final val`s with non-constant result
type, even if the rhs is a literal.

While the latter is a regression for Scala 3, it aligns with the
behavior of Scala 2. It also has the nice benefit that whether or
not a val has a field is now independent of its *implementation*,
and only dependent on its *API*. Overall, I think this is a
trade-off worth taking.

We could reintroduce that optimization in the future (but in
classes only; not in traits), if we really want to, although that
would require dedicated code.
---
 .../tools/dotc/transform/Constructors.scala   | 54 +++++++++++--------
 .../dotty/tools/dotc/transform/Memoize.scala  | 23 ++------
 .../dotty/tools/dotc/transform/SymUtils.scala | 24 ++++++++-
 .../tools/dotc/transform/sjs/JSSymUtils.scala | 17 ++++++
 tests/run/erased-inline-vals.scala            | 35 +++++++++++-
 tests/run/final-fields.check                  |  2 +-
 tests/run/i17549.check                        |  6 +++
 tests/run/i17549.scala                        | 27 ++++++++++
 8 files changed, 142 insertions(+), 46 deletions(-)
 create mode 100644 tests/run/i17549.check
 create mode 100644 tests/run/i17549.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/Constructors.scala b/compiler/src/dotty/tools/dotc/transform/Constructors.scala
index 59b90ff7f084..4dd7205e4ee0 100644
--- a/compiler/src/dotty/tools/dotc/transform/Constructors.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Constructors.scala
@@ -226,31 +226,39 @@ class Constructors extends MiniPhase with IdentityDenotTransformer { 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 =>
+          case stat @ DefDef(name, _, tpt, _) if stat.symbol.isGetter && !stat.symbol.is(Lazy) =>
             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)
+            if sym.isConstExprFinalVal then
+              if stat.rhs.isInstanceOf[Literal] then
+                clsStats += stat
+              else
+                constrStats += intoConstr(stat.rhs, sym)
+                clsStats += cpy.DefDef(stat)(rhs = Literal(sym.constExprFinalValConstantType.value).withSpan(stat.span))
+            else if !sym.owner.is(Trait) then
+              clsStats += stat
+            else
+              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 =>
diff --git a/compiler/src/dotty/tools/dotc/transform/Memoize.scala b/compiler/src/dotty/tools/dotc/transform/Memoize.scala
index 1392d00011a2..03ac15b39ffe 100644
--- a/compiler/src/dotty/tools/dotc/transform/Memoize.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Memoize.scala
@@ -20,8 +20,6 @@ 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"
@@ -130,32 +128,17 @@ class Memoize extends MiniPhase with IdentityDenotTransformer { thisPhase =>
       }
 
     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
+          && !sym.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
+        if sym.isConstExprFinalVal then
+          // const-expr final vals do not need to be transformed at all, and do not need a field
           tree
         else
           val field = newField.asTerm
diff --git a/compiler/src/dotty/tools/dotc/transform/SymUtils.scala b/compiler/src/dotty/tools/dotc/transform/SymUtils.scala
index feb841ba5c6c..c02a7d90cb8c 100644
--- a/compiler/src/dotty/tools/dotc/transform/SymUtils.scala
+++ b/compiler/src/dotty/tools/dotc/transform/SymUtils.scala
@@ -18,6 +18,8 @@ import Annotations.Annotation
 import Phases._
 import ast.tpd.Literal
 
+import dotty.tools.dotc.transform.sjs.JSSymUtils.sjsNeedsField
+
 import scala.annotation.tailrec
 
 object SymUtils:
@@ -259,9 +261,29 @@ object SymUtils:
       self.owner.info.decl(fieldName).suchThat(!_.is(Method)).symbol
     }
 
+    /** Is this symbol a constant expression final val?
+     *
+     *  This is the case if all of the following are true:
+     *
+     *  - it is a `final val`,
+     *  - its result type is a `ConstantType`, and
+     *  - it does not need an explicit field because of Scala.js semantics (see `JSSymUtils.sjsNeedsField`).
+     *
+     *  Constant expression final vals do not need an explicit field to store
+     *  their value. See the Memoize-Mixin-Constructors phase trio.
+     */
     def isConstExprFinalVal(using Context): Boolean =
       atPhaseNoLater(erasurePhase) {
-        self.is(Final) && self.info.resultType.isInstanceOf[ConstantType]
+        self.is(Final, butNot = Mutable) && self.info.resultType.isInstanceOf[ConstantType]
+      } && !self.sjsNeedsField
+
+    /** The `ConstantType` of a val known to be `isConstrExprFinalVal`.
+     *
+     *  @pre `self.isConstantExprFinalVal` is true.
+     */
+    def constExprFinalValConstantType(using Context): ConstantType =
+      atPhaseNoLater(erasurePhase) {
+        self.info.resultType.asInstanceOf[ConstantType]
       }
 
     def isField(using Context): Boolean =
diff --git a/compiler/src/dotty/tools/dotc/transform/sjs/JSSymUtils.scala b/compiler/src/dotty/tools/dotc/transform/sjs/JSSymUtils.scala
index 30eed76b18ec..115d41dd3d46 100644
--- a/compiler/src/dotty/tools/dotc/transform/sjs/JSSymUtils.scala
+++ b/compiler/src/dotty/tools/dotc/transform/sjs/JSSymUtils.scala
@@ -211,6 +211,23 @@ object JSSymUtils {
         }
       }
     }
+
+    /** 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(using Context): Boolean =
+      ctx.settings.scalajs.value && (
+        sym.owner.isJSType
+          || sym.hasAnnotation(jsdefn.JSExportTopLevelAnnot)
+          || sym.hasAnnotation(jsdefn.JSExportStaticAnnot)
+      )
+    end sjsNeedsField
   }
 
   private object JSUnaryOpMethodName {
diff --git a/tests/run/erased-inline-vals.scala b/tests/run/erased-inline-vals.scala
index 00c9c8c168c7..c39a8295af5d 100644
--- a/tests/run/erased-inline-vals.scala
+++ b/tests/run/erased-inline-vals.scala
@@ -16,6 +16,27 @@ class D:
   inline def x: Int = 5
   inline val y = 6
 
+object SideEffects:
+  val sideEffects = scala.collection.mutable.ListBuffer.empty[String]
+
+trait E:
+  final val a: 7 =
+    SideEffects.sideEffects += "E.a"
+    7
+  final val b =
+    SideEffects.sideEffects += "E.b"
+    8
+end E
+
+class F extends E:
+  final val c: 9 =
+    SideEffects.sideEffects += "F.c"
+    9
+  final val d =
+    SideEffects.sideEffects += "F.d"
+    10
+end F
+
 @main def Test =
   val b: B = new B
   assert(b.x == 1)
@@ -37,12 +58,24 @@ class D:
   assert(d.x == 5)
   assert(d.y == 6)
 
+  val f: F = new F
+  assert(SideEffects.sideEffects.toList == List("E.a", "E.b", "F.c", "F.d"))
+  assert(f.a == 7)
+  assert(f.b == 8)
+  assert(f.c == 9)
+  assert(f.d == 10)
 
   assert(classOf[B].getDeclaredMethods.size == 2)
   assert(classOf[B].getDeclaredFields.isEmpty)
 
   assert(classOf[C].getDeclaredMethods.size == 2)
-  assert(classOf[C].getDeclaredFields.isEmpty)
+  assert(classOf[C].getDeclaredFields.size == 1) // x, but not y
 
   assert(classOf[D].getDeclaredMethods.isEmpty)
   assert(classOf[D].getFields.isEmpty)
+
+  assert(classOf[E].getDeclaredMethods.size == 5)
+  assert(classOf[E].getDeclaredFields.isEmpty)
+
+  assert(classOf[F].getDeclaredMethods.size == 2)
+  assert(classOf[F].getDeclaredFields.isEmpty)
diff --git a/tests/run/final-fields.check b/tests/run/final-fields.check
index 3ebde7d7f735..af090f65a32a 100644
--- a/tests/run/final-fields.check
+++ b/tests/run/final-fields.check
@@ -2,6 +2,6 @@ T.f1
 T.f2
 T.f3
 T.f4
-3 2 -3 -4
+3 2 3 -4
 3
 g
diff --git a/tests/run/i17549.check b/tests/run/i17549.check
new file mode 100644
index 000000000000..df4c241f5ffe
--- /dev/null
+++ b/tests/run/i17549.check
@@ -0,0 +1,6 @@
+T.x
+C.y
+1
+2
+1
+2
diff --git a/tests/run/i17549.scala b/tests/run/i17549.scala
new file mode 100644
index 000000000000..165e40512153
--- /dev/null
+++ b/tests/run/i17549.scala
@@ -0,0 +1,27 @@
+trait T:
+  final val x: 1 =
+    println("T.x")
+    1
+end T
+
+trait U:
+  def x: Any
+  def y: Any
+
+class C extends T with U:
+  final val y: 2 =
+    println("C.y")
+    2
+end C
+
+object Test:
+  def main(args: Array[String]): Unit =
+    val c = new C
+    println(c.x)
+    println(c.y)
+
+    val u: U = c
+    println(u.x)
+    println(u.y)
+  end main
+end Test

From a10478d0d8de665b5e97f87dfebb350f2f2a467b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Marks?= <pmarks@virtuslab.com>
Date: Tue, 23 May 2023 23:41:34 +0200
Subject: [PATCH 619/657] Set reference version to 3.3.0

---
 project/Build.scala       |  4 ++--
 project/MiMaFilters.scala | 30 ------------------------------
 2 files changed, 2 insertions(+), 32 deletions(-)

diff --git a/project/Build.scala b/project/Build.scala
index dbf574252113..910ee7ef4f58 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -80,7 +80,7 @@ object DottyJSPlugin extends AutoPlugin {
 object Build {
   import ScaladocConfigs._
 
-  val referenceVersion = "3.3.0-RC6"
+  val referenceVersion = "3.3.0"
 
   val baseVersion = "3.3.1-RC1"
 
@@ -98,7 +98,7 @@ object Build {
    *  set to 3.1.3. If it is going to be 3.1.0, it must be set to the latest
    *  3.0.x release.
    */
-  val previousDottyVersion = "3.2.2"
+  val previousDottyVersion = "3.3.0"
 
   object CompatMode {
     final val BinaryCompatible = 0
diff --git a/project/MiMaFilters.scala b/project/MiMaFilters.scala
index c5b00510bece..112a5601615c 100644
--- a/project/MiMaFilters.scala
+++ b/project/MiMaFilters.scala
@@ -3,23 +3,7 @@ import com.typesafe.tools.mima.core._
 
 object MiMaFilters {
   val Library: Seq[ProblemFilter] = Seq(
-    ProblemFilters.exclude[DirectMissingMethodProblem]("scala.caps.unsafeBox"),
-    ProblemFilters.exclude[DirectMissingMethodProblem]("scala.caps.unsafeUnbox"),
-    ProblemFilters.exclude[DirectMissingMethodProblem]("scala.caps.cap"),
-    ProblemFilters.exclude[MissingClassProblem]("scala.caps$Sealed"),
-    ProblemFilters.exclude[DirectMissingMethodProblem]("scala.CanEqual.canEqualMap"),
-    ProblemFilters.exclude[MissingClassProblem]("scala.caps$Pure"),
-    ProblemFilters.exclude[MissingClassProblem]("scala.caps$unsafe$"),
     ProblemFilters.exclude[MissingClassProblem]("scala.annotation.unchecked.uncheckedCaptures"),
-    ProblemFilters.exclude[MissingFieldProblem]("scala.runtime.stdLibPatches.language.3.3-migration"),
-    ProblemFilters.exclude[MissingFieldProblem]("scala.runtime.stdLibPatches.language.3.3"),
-    ProblemFilters.exclude[MissingClassProblem]("scala.runtime.stdLibPatches.language$3$u002E3$"),
-    ProblemFilters.exclude[MissingClassProblem]("scala.runtime.stdLibPatches.language$3$u002E3$minusmigration$"),
-    ProblemFilters.exclude[MissingClassProblem]("scala.util.boundary"),
-    ProblemFilters.exclude[MissingClassProblem]("scala.util.boundary$"),
-    ProblemFilters.exclude[MissingClassProblem]("scala.util.boundary$Break"),
-    ProblemFilters.exclude[MissingClassProblem]("scala.util.boundary$Label"),
-    ProblemFilters.exclude[MissingClassProblem]("scala.quoted.runtime.QuoteMatching$"),
 
     // Scala.js only: new runtime support class in 3.2.3; not available to users
     ProblemFilters.exclude[MissingClassProblem]("scala.scalajs.runtime.AnonFunctionXXL"),
@@ -27,26 +11,12 @@ object MiMaFilters {
     //  New experimental features in 3.3.X
     ProblemFilters.exclude[MissingFieldProblem]("scala.runtime.stdLibPatches.language#experimental.clauseInterleaving"),
     ProblemFilters.exclude[MissingClassProblem]("scala.runtime.stdLibPatches.language$experimental$clauseInterleaving$"),
-    ProblemFilters.exclude[MissingFieldProblem]("scala.runtime.stdLibPatches.language#experimental.into"),
-    ProblemFilters.exclude[MissingClassProblem]("scala.runtime.stdLibPatches.language$experimental$into$"),
     ProblemFilters.exclude[MissingFieldProblem]("scala.runtime.stdLibPatches.language#experimental.relaxedExtensionImports"),
     ProblemFilters.exclude[MissingClassProblem]("scala.runtime.stdLibPatches.language$experimental$relaxedExtensionImports$"),
     // end of New experimental features in 3.3.X
-
-    // Added java.io.Serializable as LazyValControlState supertype
-    ProblemFilters.exclude[MissingTypesProblem]("scala.runtime.LazyVals$LazyValControlState"),
-    ProblemFilters.exclude[MissingTypesProblem]("scala.runtime.LazyVals$Waiting"),
-
   )
   val TastyCore: Seq[ProblemFilter] = Seq(
-    ProblemFilters.exclude[DirectMissingMethodProblem]("dotty.tools.tasty.TastyBuffer.reset"),
-    ProblemFilters.exclude[DirectMissingMethodProblem]("dotty.tools.tasty.TastyFormat.APPLYsigpoly"),
-    ProblemFilters.exclude[DirectMissingMethodProblem]("dotty.tools.tasty.TastyHash.pjwHash64"),
-    ProblemFilters.exclude[DirectMissingMethodProblem]("dotty.tools.tasty.util.Util.dble")
   )
   val Interfaces: Seq[ProblemFilter] = Seq(
-    ProblemFilters.exclude[ReversedMissingMethodProblem]("dotty.tools.dotc.interfaces.Diagnostic.diagnosticRelatedInformation"),
-    ProblemFilters.exclude[DirectMissingMethodProblem]("dotty.tools.dotc.interfaces.Diagnostic.diagnosticRelatedInformation"),
-    ProblemFilters.exclude[MissingClassProblem]("dotty.tools.dotc.interfaces.DiagnosticRelatedInformation")
   )
 }

From ca7c29f4b9c5dc1a70a54124e87db9839662021d Mon Sep 17 00:00:00 2001
From: Lucas Leblanc <44496264+Dedelweiss@users.noreply.github.com>
Date: Wed, 24 May 2023 08:36:37 +0200
Subject: [PATCH 620/657] Fix: Add max-width for images in api doc (#17558)

Fixes #17551
---
 .../dotty_res/styles/theme/components/api-member.css          | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/scaladoc/resources/dotty_res/styles/theme/components/api-member.css b/scaladoc/resources/dotty_res/styles/theme/components/api-member.css
index c1a491815201..47b64c304a70 100644
--- a/scaladoc/resources/dotty_res/styles/theme/components/api-member.css
+++ b/scaladoc/resources/dotty_res/styles/theme/components/api-member.css
@@ -42,6 +42,10 @@
   margin-block-end: 0;
 }
 
+.documentableElement .doc img {
+  max-width: 100%;
+}
+
 .documentableElement .annotations {
   display: none;
 }

From 484145390b860e8426e52955899f4013737c5f47 Mon Sep 17 00:00:00 2001
From: Chris Kipp <ckipp@pm.me>
Date: Wed, 24 May 2023 10:35:43 +0200
Subject: [PATCH 621/657] test: add in a regression test for #15546

[skip community_build]

closes #15546
---
 tests/pos/i15546.scala | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 tests/pos/i15546.scala

diff --git a/tests/pos/i15546.scala b/tests/pos/i15546.scala
new file mode 100644
index 000000000000..19c7f15b24f1
--- /dev/null
+++ b/tests/pos/i15546.scala
@@ -0,0 +1,14 @@
+// https://github.com/lampepfl/dotty/issues/15546
+
+trait Foo[F[_]]
+
+object Bug {
+  def apply[F[_]: Foo](
+      await: Boolean,
+      whatever: Int = 0
+  ): Nothing = ???
+
+  def apply[F[_]: Foo]: Nothing =
+    apply[F](false)
+}
+

From 390f836c5ac0d8aaa30b331745e361b75139f68a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Marks?= <pmarks@virtuslab.com>
Date: Wed, 24 May 2023 13:29:23 +0200
Subject: [PATCH 622/657] Add changelog for 3.3.1-RC1

---
 changelogs/3.3.1-RC1.md | 288 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 288 insertions(+)
 create mode 100644 changelogs/3.3.1-RC1.md

diff --git a/changelogs/3.3.1-RC1.md b/changelogs/3.3.1-RC1.md
new file mode 100644
index 000000000000..4e52eb874891
--- /dev/null
+++ b/changelogs/3.3.1-RC1.md
@@ -0,0 +1,288 @@
+# Highlights of the release
+
+- Support records in JavaParsers [#16762](https://github.com/lampepfl/dotty/pull/16762)
+- Port JVM backend refactor from Scala 2 [#15322](https://github.com/lampepfl/dotty/pull/15322)
+
+# Other changes and fixes
+
+## Backend
+
+- Disallow mixins where super calls bind to vals [#16908](https://github.com/lampepfl/dotty/pull/16908)
+- Fix #15107: Avoid re-emitting a LineNumber after only LabelNodes. [#16813](https://github.com/lampepfl/dotty/pull/16813)
+
+## Coverage
+
+- Fix #17042: Preserve the shape of secondary ctors in instrumentCoverage. [#17111](https://github.com/lampepfl/dotty/pull/17111)
+
+## Default parameters
+
+- Dupe fix when finding default arg getters [#17058](https://github.com/lampepfl/dotty/pull/17058)
+
+## Documentation
+
+- Fix: ensure syntax blocks for ebnf are marked as such [#16837](https://github.com/lampepfl/dotty/pull/16837)
+
+## Erasure
+
+- Handle `@companionClass` and `@companionMethod` meta-annotations [#17091](https://github.com/lampepfl/dotty/pull/17091)
+
+## Extension Methods
+
+- Support extension methods imported from different objects [#17050](https://github.com/lampepfl/dotty/pull/17050)
+
+## GADTs
+
+- Fix tuple member selection so it works with GADT healing [#16766](https://github.com/lampepfl/dotty/pull/16766)
+- Fix upper bound constraints, that are higher-kinded [#16744](https://github.com/lampepfl/dotty/pull/16744)
+- Split out immutable GadtConstraint [#16602](https://github.com/lampepfl/dotty/pull/16602)
+
+## Implicits
+
+- Improve subtyping check for not yet eta-expanded higher kinded types [#17139](https://github.com/lampepfl/dotty/pull/17139)
+- Harden tpd.Apply/TypeApply in case of errors [#16887](https://github.com/lampepfl/dotty/pull/16887)
+- Try to be more subtle when inferring type parameters of class parents [#16896](https://github.com/lampepfl/dotty/pull/16896)
+- Include `P` in the implicit scope of `P.this.type` [#17088](https://github.com/lampepfl/dotty/pull/17088)
+
+## Incremental Compilation
+
+- Fix under-compilation when the method type in a SAM changes [#16996](https://github.com/lampepfl/dotty/pull/16996)
+
+## Infrastructure
+
+- Set reference version to 3.3.0-RC6 [#17504](https://github.com/lampepfl/dotty/pull/17504)
+- Fix #17119: Download Coursier from GitHub directly [#17141](https://github.com/lampepfl/dotty/pull/17141)
+
+## Inline
+
+- Remove NamedArg from inlined arguments [#17228](https://github.com/lampepfl/dotty/pull/17228)
+- Don't generate a Select for a TermRef with NoPrefix [#16754](https://github.com/lampepfl/dotty/pull/16754)
+- Prepare bodies of inline forwarders eagerly [#16757](https://github.com/lampepfl/dotty/pull/16757)
+- Do not remove inline method implementations until PruneErasedDefs [#17408](https://github.com/lampepfl/dotty/pull/17408)
+
+## Java Interop
+
+- ClassfileParser: allow missing param names (for JDK 21) [#17536](https://github.com/lampepfl/dotty/pull/17536)
+
+## Linting
+
+- Improve -Wunused: locals, privates with unset vars warning #16639 [#17160](https://github.com/lampepfl/dotty/pull/17160)
+- Fix wunused false positive when deriving alias type [#17157](https://github.com/lampepfl/dotty/pull/17157)
+- Port `-Wnonunit-statement` setting for dotty [#16936](https://github.com/lampepfl/dotty/pull/16936)
+
+## Match Types
+
+- Normalize match type usage during implicit lookup [#17457](https://github.com/lampepfl/dotty/pull/17457)
+- Fix #13757: Explicitly disallow higher-kinded scrutinees of match types. [#17322](https://github.com/lampepfl/dotty/pull/17322)
+- Fix match type reduction with wildcard type arguments [#17065](https://github.com/lampepfl/dotty/pull/17065)
+- Fix check whether classtag can be generated for match types [#16708](https://github.com/lampepfl/dotty/pull/16708)
+
+## Parser
+
+- Allow lines starting with `.` to fall outside previous indentation widths [#17056](https://github.com/lampepfl/dotty/pull/17056)
+
+## Pattern Matching
+
+- Fix #11541: Specialize ClassTag[T] in exhaustivity check [#17385](https://github.com/lampepfl/dotty/pull/17385)
+- Check outer class prefixes in type projections when pattern matching [#17136](https://github.com/lampepfl/dotty/pull/17136)
+- Make unchecked cases non-`@unchecked` and non-unreachable [#16958](https://github.com/lampepfl/dotty/pull/16958)
+- Fix #16899: Better handle X instanceOf P where X is T1 | T2 [#17382](https://github.com/lampepfl/dotty/pull/17382)
+
+## Pickling
+
+- ClassfileParser: Avoid cycle when accessing companion in inner class lookup [#16882](https://github.com/lampepfl/dotty/pull/16882)
+
+## Polyfunctions
+
+- Fix type aliases in beta-reduction of polyfunctions [#17054](https://github.com/lampepfl/dotty/pull/17054)
+
+## Quotes
+
+- Register `paramProxy` and `thisProxy` in `Quote` type [#17541](https://github.com/lampepfl/dotty/pull/17541)
+- Only check newVal/newMethod privateWithin on -Xcheck-macros [#17437](https://github.com/lampepfl/dotty/pull/17437)
+- Unencode quote and splice trees [#17342](https://github.com/lampepfl/dotty/pull/17342)
+- Correctly type Expr.ofTupleFromSeq for arity > 22 [#17261](https://github.com/lampepfl/dotty/pull/17261)
+- Use TermRef to distinguish distinct Type[T] instances  [#17205](https://github.com/lampepfl/dotty/pull/17205)
+- Check level consistency of SingletonTypeTree as a type [#17209](https://github.com/lampepfl/dotty/pull/17209)
+- Fix splice type variable pattern detection [#17048](https://github.com/lampepfl/dotty/pull/17048)
+- Avoid creation of `@SplicedType` quote local refrences [#17051](https://github.com/lampepfl/dotty/pull/17051)
+- Dealias type references when healing types in quotes [#17049](https://github.com/lampepfl/dotty/pull/17049)
+- Replace quoted type variables in signature of HOAS pattern result  [#16951](https://github.com/lampepfl/dotty/pull/16951)
+- Beta-reduce directly applied PolymorphicFunction [#16623](https://github.com/lampepfl/dotty/pull/16623)
+- Use `Object.toString` for `quoted.{Expr, Type}` [#16663](https://github.com/lampepfl/dotty/pull/16663)
+- Fix Splicer.isEscapedVariable [#16838](https://github.com/lampepfl/dotty/pull/16838)
+- Fix references to class members defined in quotes [#17107](https://github.com/lampepfl/dotty/pull/17107)
+- Handle pickled forward references in pickled expressions [#16855](https://github.com/lampepfl/dotty/pull/16855)
+- Fix #16615 - crashes of path dependent types in spliced Type.of [#16773](https://github.com/lampepfl/dotty/pull/16773)
+- Disallow local term references in staged types [#16362](https://github.com/lampepfl/dotty/pull/16362)
+- Refactor level checking / type healing logic [#17082](https://github.com/lampepfl/dotty/pull/17082)
+- Dealias quoted types when staging [#17059](https://github.com/lampepfl/dotty/pull/17059)
+- Fix quotes with references to path dependent types [#17081](https://github.com/lampepfl/dotty/pull/17081)
+- Make arguments order in quote hole deterministic [#17405](https://github.com/lampepfl/dotty/pull/17405)
+- Only transform the body of the quote with QuoteTransformer [#17451](https://github.com/lampepfl/dotty/pull/17451)
+- Place staged type captures in Quote AST [#17424](https://github.com/lampepfl/dotty/pull/17424)
+- Add SplicePattern AST to parse and type quote pattern splices [#17396](https://github.com/lampepfl/dotty/pull/17396)
+
+## Reflection
+
+- -Xcheck-macros: add hint when a symbol in created twice [#16733](https://github.com/lampepfl/dotty/pull/16733)
+- Assert that symbols created using reflect API have correct privateWithin symbols [#17352](https://github.com/lampepfl/dotty/pull/17352)
+- Fix reflect.LambdaType type test [#16972](https://github.com/lampepfl/dotty/pull/16972)
+- Improve `New`/`Select` -Ycheck message [#16746](https://github.com/lampepfl/dotty/pull/16746)
+- Improve error message for CyclicReference in macros [#16749](https://github.com/lampepfl/dotty/pull/16749)
+- Add reflect `defn.FunctionClass` overloads [#16849](https://github.com/lampepfl/dotty/pull/16849)
+
+## REPL
+
+- Always load REPL classes in macros including the output directory [#16866](https://github.com/lampepfl/dotty/pull/16866)
+
+## Reporting
+
+- Improve missing argument list error [#17126](https://github.com/lampepfl/dotty/pull/17126)
+- Improve implicit parameter error message with aliases [#17125](https://github.com/lampepfl/dotty/pull/17125)
+- Improve "constructor proxy shadows outer" handling [#17154](https://github.com/lampepfl/dotty/pull/17154)
+- Clarify ambiguous reference error message [#16137](https://github.com/lampepfl/dotty/pull/16137)
+- Hint about forbidden combination of implicit values and conversions [#16735](https://github.com/lampepfl/dotty/pull/16735)
+- Attach explanation message to diagnostic message [#16787](https://github.com/lampepfl/dotty/pull/16787)
+- Propagate implicit search errors from implicit macros [#16840](https://github.com/lampepfl/dotty/pull/16840)
+- Detail UnapplyInvalidReturnType error message [#17167](https://github.com/lampepfl/dotty/pull/17167)
+- Add way to debug -Xcheck-macros tree checking [#16973](https://github.com/lampepfl/dotty/pull/16973)
+- Enrich and finesse compiler crash reporting [#17031](https://github.com/lampepfl/dotty/pull/17031)
+- Allow @implicitNotFound messages as explanations [#16893](https://github.com/lampepfl/dotty/pull/16893)
+- Include top-level symbols from same file in outer ambiguity error [#17033](https://github.com/lampepfl/dotty/pull/17033)
+- Do not issue deprecation warnings when declaring deprecated case classes [#17165](https://github.com/lampepfl/dotty/pull/17165)
+
+## Scala-JS
+
+- Fix #17344: Make implicit references to this above dynamic imports explicit. [#17357](https://github.com/lampepfl/dotty/pull/17357)
+- Fix #12621: Better error message for JS trait ctor param. [#16811](https://github.com/lampepfl/dotty/pull/16811)
+- Fix #16801: Handle Closure's of s.r.FunctionXXL. [#16809](https://github.com/lampepfl/dotty/pull/16809)
+- Fix #17549: Unify how Memoize and Constructors decide what fields need storing. [#17560](https://github.com/lampepfl/dotty/pull/17560)
+
+## Scaladoc
+
+- Feat: Add a blog configuration with yaml [#17214](https://github.com/lampepfl/dotty/pull/17214)
+- Don't render the "$" for module [#17302](https://github.com/lampepfl/dotty/pull/17302)
+- Fix: Add scrollbar to the sidebar [#17203](https://github.com/lampepfl/dotty/pull/17203)
+- Scaladoc: fix crash when processing extends call [#17260](https://github.com/lampepfl/dotty/pull/17260)
+- Fix: Modify the CSS so that the logo of the generated documentation is adaptive [#17172](https://github.com/lampepfl/dotty/pull/17172)
+- Fix: Remove the duplicate parameter when generating the scaladoc. [#17097](https://github.com/lampepfl/dotty/pull/17097)
+- Fix: padding top in mobile version [#17019](https://github.com/lampepfl/dotty/pull/17019)
+- Fix: tap target of the menu in Mobile version [#17018](https://github.com/lampepfl/dotty/pull/17018)
+- Scaladoc: Fix expand icon not changing on anchor link [#17053](https://github.com/lampepfl/dotty/pull/17053)
+- Scaladoc: fix inkuire generation for PolyTypes [#17129](https://github.com/lampepfl/dotty/pull/17129)
+- Re port scroll bar [#17463](https://github.com/lampepfl/dotty/pull/17463)
+- Handle empty files and truncated YAML front matter [#17527](https://github.com/lampepfl/dotty/pull/17527)
+
+## SemanticDB
+
+- Make sure symbol exists before calling owner [#16860](https://github.com/lampepfl/dotty/pull/16860)
+- Support LambdaType (convert from HKTypeLambda) [#16056](https://github.com/lampepfl/dotty/pull/16056)
+
+## Specification
+
+- Apply `class-shadowing.md` to the Spec [#16839](https://github.com/lampepfl/dotty/pull/16839)
+- Adding base for future Spec into the compiler repo [#16825](https://github.com/lampepfl/dotty/pull/16825)
+
+## Standard Library
+
+- Optimization: avoid NotGiven allocations [#17090](https://github.com/lampepfl/dotty/pull/17090)
+
+## Tooling
+
+- Disable `ExtractSemanticDB` phase when writing to output directory defined as JAR. [#16790](https://github.com/lampepfl/dotty/pull/16790)
+- Print owner of bind symbol with -Yprint-debug-owners [#16854](https://github.com/lampepfl/dotty/pull/16854)
+- Small fixes to allow using Metals with scaladoc with sbt [#16816](https://github.com/lampepfl/dotty/pull/16816)
+
+## Transform
+
+- Move CrossVersionChecks before FirstTransform [#17301](https://github.com/lampepfl/dotty/pull/17301)
+- Fix needsOuterIfReferenced [#17159](https://github.com/lampepfl/dotty/pull/17159)
+- Drop incorrect super accessor in trait subclass [#17062](https://github.com/lampepfl/dotty/pull/17062)
+- Generate toString only for synthetic companions of case classes [#16890](https://github.com/lampepfl/dotty/pull/16890)
+- Check trait constructor for accessibility even if not called at Typer [#17094](https://github.com/lampepfl/dotty/pull/17094)
+- Fix #17435: A simpler fix [#17436](https://github.com/lampepfl/dotty/pull/17436)
+
+## Typer
+
+- Preserve type bounds for inlined definitions in posttyper [#17190](https://github.com/lampepfl/dotty/pull/17190)
+- Change logic to find members of recursive types [#17386](https://github.com/lampepfl/dotty/pull/17386)
+- Recognize named arguments in isFunctionWithUnknownParamType [#17161](https://github.com/lampepfl/dotty/pull/17161)
+- Better comparisons for type projections [#17092](https://github.com/lampepfl/dotty/pull/17092)
+- Allow selectDynamic and applyDynamic to be extension methods [#17106](https://github.com/lampepfl/dotty/pull/17106)
+- Fix use of accessibleFrom when finding default arg getters [#16977](https://github.com/lampepfl/dotty/pull/16977)
+- Map class literal constant types [#16988](https://github.com/lampepfl/dotty/pull/16988)
+- Always use adapted type in withDenotation [#16901](https://github.com/lampepfl/dotty/pull/16901)
+- Restrict captureWildcards to only be used if needed [#16799](https://github.com/lampepfl/dotty/pull/16799)
+- Don't capture wildcards if in closure or by-name [#16732](https://github.com/lampepfl/dotty/pull/16732)
+- Infer: Don't minimise to Nothing if there's an upper bound [#16786](https://github.com/lampepfl/dotty/pull/16786)
+- Perform Matchable check only if type test is needed [#16824](https://github.com/lampepfl/dotty/pull/16824)
+- Don't eta expand unary varargs methods [#16892](https://github.com/lampepfl/dotty/pull/16892)
+- Fix beta-reduction with `Nothing` and `null` args [#16938](https://github.com/lampepfl/dotty/pull/16938)
+- Generate kind-correct wildcards when selecting from a wildcard [#17025](https://github.com/lampepfl/dotty/pull/17025)
+- Fix #16405 ctd - wildcards prematurely resolving to Nothing [#16764](https://github.com/lampepfl/dotty/pull/16764)
+- Test: add regression test for #7790 [#17473](https://github.com/lampepfl/dotty/pull/17473)
+- Properly handle `AnyVal`s as refinement members of `Selectable`s  [#16286](https://github.com/lampepfl/dotty/pull/16286)
+
+# Contributors
+
+Thank you to all the contributors who made this release possible 🎉
+
+According to `git shortlog -sn --no-merges 3.3.0..3.3.1-RC1` these are:
+
+```
+   148 Nicolas Stucki
+    65 Martin Odersky
+    51 Szymon Rodziewicz
+    49 Dale Wijnand
+    49 Quentin Bernet
+    38 Chris Kipp
+    19 David Hua
+    18 Lucas
+    18 ysthakur
+    15 Fengyun Liu
+    15 Paweł Marks
+    14 Guillaume Martres
+    14 Jamie Thompson
+    11 Sébastien Doeraene
+     9 Timothée Andres
+     8 Kacper Korban
+     7 Matt Bovel
+     7 Som Snytt
+     6 Julien Richard-Foy
+     6 Lucas Leblanc
+     5 Michał Pałka
+     4 Anatolii Kmetiuk
+     4 Guillaume Raffin
+     4 Paul Coral
+     4 Wojciech Mazur
+     4 Yichen Xu
+     3 Decel
+     3 Jan Chyb
+     2 Adrien Piquerez
+     2 Arman Bilge
+     2 Carl
+     2 Florian3k
+     2 Kenji Yoshida
+     2 Michael Pilquist
+     2 Natsu Kagami
+     2 Seth Tisue
+     2 Tomasz Godzik
+     2 Vasil Vasilev
+     2 Yadu Krishnan
+     1 Bersier
+     1 Flavio Brasil
+     1 Jan-Pieter van den Heuvel
+     1 Lukas Rytz
+     1 Miles Yucht
+     1 Mohammad Yousuf Minhaj Zia
+     1 Ondra Pelech
+     1 Philippus
+     1 Rikito Taniguchi
+     1 Simon R
+     1 brandonspark
+     1 github-actions[bot]
+     1 liang3zy22
+     1 s.bazarsadaev
+     1 Łukasz Wroński
+
+```

From dfb23f95afa8bec461674140c99b19ea3a9ab010 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Marks?= <pmarks@virtuslab.com>
Date: Wed, 24 May 2023 13:30:49 +0200
Subject: [PATCH 623/657] Release 3.3.1-RC1

---
 tasty/src/dotty/tools/tasty/TastyFormat.scala | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tasty/src/dotty/tools/tasty/TastyFormat.scala b/tasty/src/dotty/tools/tasty/TastyFormat.scala
index 226fc14acb39..39d559234868 100644
--- a/tasty/src/dotty/tools/tasty/TastyFormat.scala
+++ b/tasty/src/dotty/tools/tasty/TastyFormat.scala
@@ -290,7 +290,7 @@ object TastyFormat {
    *  compatibility, but remains backwards compatible, with all
    *  preceeding `MinorVersion`.
    */
-  final val MinorVersion: Int = 4
+  final val MinorVersion: Int = 3
 
   /** Natural Number. The `ExperimentalVersion` allows for
    *  experimentation with changes to TASTy without committing
@@ -306,7 +306,7 @@ object TastyFormat {
    *  is able to read final TASTy documents if the file's
    *  `MinorVersion` is strictly less than the current value.
    */
-  final val ExperimentalVersion: Int = 1
+  final val ExperimentalVersion: Int = 0
 
   /**This method implements a binary relation (`<:<`) between two TASTy versions.
    *

From 8f019275f8dd54fc9554d00292e02fd331ce3427 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 30 May 2023 10:00:08 +0200
Subject: [PATCH 624/657] Dealias types in New before matching quotes

Fixes #17606
---
 .../scala/quoted/runtime/impl/QuoteMatcher.scala   |  2 +-
 tests/pos-macros/i17606/Macros_1.scala             | 14 ++++++++++++++
 tests/pos-macros/i17606/Test_2.scala               |  8 ++++++++
 3 files changed, 23 insertions(+), 1 deletion(-)
 create mode 100644 tests/pos-macros/i17606/Macros_1.scala
 create mode 100644 tests/pos-macros/i17606/Test_2.scala

diff --git a/compiler/src/scala/quoted/runtime/impl/QuoteMatcher.scala b/compiler/src/scala/quoted/runtime/impl/QuoteMatcher.scala
index 5477628a30a3..bfa4c1c6d1f2 100644
--- a/compiler/src/scala/quoted/runtime/impl/QuoteMatcher.scala
+++ b/compiler/src/scala/quoted/runtime/impl/QuoteMatcher.scala
@@ -301,7 +301,7 @@ object QuoteMatcher {
             /* Match new */
             case New(tpt1) =>
               pattern match
-                case New(tpt2) if tpt1.tpe.typeSymbol == tpt2.tpe.typeSymbol => matched
+                case New(tpt2) if tpt1.tpe.dealias.typeSymbol == tpt2.tpe.dealias.typeSymbol => matched
                 case _ => notMatched
 
             /* Match this */
diff --git a/tests/pos-macros/i17606/Macros_1.scala b/tests/pos-macros/i17606/Macros_1.scala
new file mode 100644
index 000000000000..245f2df66e7b
--- /dev/null
+++ b/tests/pos-macros/i17606/Macros_1.scala
@@ -0,0 +1,14 @@
+package example
+
+import scala.quoted.*
+
+object A {
+  inline def f(inline a: Any): Boolean = ${ impl('a) }
+
+  def impl(a: Expr[Any])(using Quotes): Expr[Boolean] = {
+    a match {
+      case '{ new String($x: Array[Byte]) } => Expr(true)
+      case _ => quotes.reflect.report.errorAndAbort("Expected match", a)
+    }
+  }
+}
diff --git a/tests/pos-macros/i17606/Test_2.scala b/tests/pos-macros/i17606/Test_2.scala
new file mode 100644
index 000000000000..ebf535bc2ae9
--- /dev/null
+++ b/tests/pos-macros/i17606/Test_2.scala
@@ -0,0 +1,8 @@
+package example
+
+object Main {
+  def main(args: Array[String]): Unit = {
+    val x = A.f(new String(Array.empty[Byte]))
+    println(x)
+  }
+}

From 49680df3ecead55d5a53b065dbdf3f06b80b3812 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Sun, 25 Jun 2023 20:11:55 +0200
Subject: [PATCH 625/657] Fix accessibleType for package object prefixes

Making a package object explicit re-computes the denotations of an overloaded method.
So it should not be done after we have pruned down those denotations by an accessibility
test. We now do it before checking accessibility.

Fixes #15821
---
 .../dotty/tools/dotc/core/Denotations.scala   |  4 +--
 .../dotty/tools/dotc/typer/TypeAssigner.scala | 30 +++++++++++--------
 tests/pos/i15821.scala                        |  9 ++++++
 3 files changed, 28 insertions(+), 15 deletions(-)
 create mode 100644 tests/pos/i15821.scala

diff --git a/compiler/src/dotty/tools/dotc/core/Denotations.scala b/compiler/src/dotty/tools/dotc/core/Denotations.scala
index 82368fd4dbf5..e56cc453d34d 100644
--- a/compiler/src/dotty/tools/dotc/core/Denotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/Denotations.scala
@@ -1269,8 +1269,8 @@ object Denotations {
     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)
+      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)
diff --git a/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala b/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
index 6ac45cbcf04d..be6121e13209 100644
--- a/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
+++ b/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
@@ -77,21 +77,25 @@ trait TypeAssigner {
    *  (2) in Java compilation units, `Object` is replaced by `defn.FromJavaObjectType`
    */
   def accessibleType(tpe: Type, superAccess: Boolean)(using Context): Type =
-    tpe match
+    if ctx.isJava && tpe.isAnyRef then
+      defn.FromJavaObjectType
+    else 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)
+        val tpe1 = TypeOps.makePackageObjPrefixExplicit(tpe)
+        if tpe1 ne tpe then
+          accessibleType(tpe1, superAccess)
         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
+          val pre = tpe.prefix
+          val name = tpe.name
+          val d = tpe.denot.accessibleFrom(pre, superAccess)
+          if d eq tpe.denot then tpe
+          else if d.exists then tpe.withDenot(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 tpe.withDenot(d2)
+            else NoType
       case tpe => tpe
 
   /** Try to make `tpe` accessible, emit error if not possible */
diff --git a/tests/pos/i15821.scala b/tests/pos/i15821.scala
new file mode 100644
index 000000000000..a72d13e07bc7
--- /dev/null
+++ b/tests/pos/i15821.scala
@@ -0,0 +1,9 @@
+def main =
+  foo.bar(42)
+  foo.bar
+
+package object foo {
+  def bar[F[_]]: Unit = ???
+  def bar[F[_]](x: Int): Unit = ???
+  private[foo] def bar[F[_]](x: Int)(implicit dummy: DummyImplicit): Unit = ???
+}

From 186e4be054c0df229e4a97152635df788432a876 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Mon, 26 Jun 2023 14:53:36 +0200
Subject: [PATCH 626/657] Disable specs2 for now.

---
 .../scala/dotty/communitybuild/CommunityBuildTest.scala    | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/community-build/test/scala/dotty/communitybuild/CommunityBuildTest.scala b/community-build/test/scala/dotty/communitybuild/CommunityBuildTest.scala
index 146ad6f4f951..8837f7319117 100644
--- a/community-build/test/scala/dotty/communitybuild/CommunityBuildTest.scala
+++ b/community-build/test/scala/dotty/communitybuild/CommunityBuildTest.scala
@@ -93,7 +93,12 @@ class CommunityBuildTestC:
   @Test def sconfig = projects.sconfig.run()
   @Test def shapeless = projects.shapeless.run()
   @Test def sourcecode = projects.sourcecode.run()
-  @Test def specs2 = projects.specs2.run()
+
+  // Disabled. Currently fails in FutureMatchers.scala. The call to
+  // `checkResultFailure` goes to a protected method which is not accessible.
+  // I tried to fix it, but get test failures.
+  // @Test def specs2 = projects.specs2.run()
+
   @Test def stdLib213 = projects.stdLib213.run()
   @Test def ujson = projects.ujson.run()
   @Test def upickle = projects.upickle.run()

From 1451dc50ccc7bdf52501af02052aa1059487e393 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Marks?= <pmarks@virtuslab.com>
Date: Wed, 28 Jun 2023 15:36:01 +0200
Subject: [PATCH 627/657] Add changelog for 3.3.1-RC2

---
 changelogs/3.3.1-RC2.md | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 changelogs/3.3.1-RC2.md

diff --git a/changelogs/3.3.1-RC2.md b/changelogs/3.3.1-RC2.md
new file mode 100644
index 000000000000..f21bfa074b66
--- /dev/null
+++ b/changelogs/3.3.1-RC2.md
@@ -0,0 +1,16 @@
+# Backported fixes
+
+- Dealias types in `New`` before matching quotes [#17615](https://github.com/lampepfl/dotty/pull/17615)
+- Fix `accessibleType` for package object prefixes [#18057](https://github.com/lampepfl/dotty/pull/18057)
+
+# Contributors
+
+Thank you to all the contributors who made this release possible 🎉
+
+According to `git shortlog -sn --no-merges 3.3.1-RC1..3.3.1-RC2` these are:
+
+```
+     2 Martin Odersky
+     2 Paweł Marks
+     1 Nicolas Stucki
+```

From c9bbcb0f0297b6097eff0dd28f9d5a5cae290e8c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Marks?= <pmarks@virtuslab.com>
Date: Wed, 28 Jun 2023 15:52:38 +0200
Subject: [PATCH 628/657] Release 3.3.1-RC2

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

diff --git a/project/Build.scala b/project/Build.scala
index 910ee7ef4f58..a2ea5ce1a596 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -82,7 +82,7 @@ object Build {
 
   val referenceVersion = "3.3.0"
 
-  val baseVersion = "3.3.1-RC1"
+  val baseVersion = "3.3.1-RC2"
 
   // Versions used by the vscode extension to create a new project
   // This should be the latest published releases.
@@ -98,7 +98,7 @@ object Build {
    *  set to 3.1.3. If it is going to be 3.1.0, it must be set to the latest
    *  3.0.x release.
    */
-  val previousDottyVersion = "3.3.0"
+  val previousDottyVersion = "3.3.1-RC1"
 
   object CompatMode {
     final val BinaryCompatible = 0

From aed47fd78aec49aebf7d2d97b167e58c9c165cc2 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Wed, 5 Jul 2023 00:14:35 +0200
Subject: [PATCH 629/657] Add clause for protected visibility from package
 objects

We usually have an access rule that the access to a protected member `foo` in class `C`
must be from somewhere nested in a subclass of `C`. But that fails if the member is
accessed from a package object `p.package`. In that case, the access does not need to be in
the same object, it just has to be in package `p`. This clause was previously missing
and is now added.

Why was this only recently discovered?

#18057 fixed an issue where toplevel protected members were always accessible
because explicit package object prefixes were added after the accessibility check was done,
and would re-establish the previous members without doing an accessibility check. The fix was
done by adding package objects first, then doing he rest of the checks. But that also means
that protected toplevel objects now get checked as members of their synthetic package object
instead of as members of their package.

The change here also makes specs2 compile again.
---
 .../dotty/communitybuild/CommunityBuildTest.scala |  6 +-----
 .../dotty/tools/dotc/core/SymDenotations.scala    | 11 +++++++----
 tests/pos/i18124/definition.scala                 | 15 +++++++++++++++
 tests/pos/i18124/usage.scala                      |  8 ++++++++
 4 files changed, 31 insertions(+), 9 deletions(-)
 create mode 100644 tests/pos/i18124/definition.scala
 create mode 100644 tests/pos/i18124/usage.scala

diff --git a/community-build/test/scala/dotty/communitybuild/CommunityBuildTest.scala b/community-build/test/scala/dotty/communitybuild/CommunityBuildTest.scala
index 8837f7319117..bf6b6d431509 100644
--- a/community-build/test/scala/dotty/communitybuild/CommunityBuildTest.scala
+++ b/community-build/test/scala/dotty/communitybuild/CommunityBuildTest.scala
@@ -93,11 +93,7 @@ class CommunityBuildTestC:
   @Test def sconfig = projects.sconfig.run()
   @Test def shapeless = projects.shapeless.run()
   @Test def sourcecode = projects.sourcecode.run()
-
-  // Disabled. Currently fails in FutureMatchers.scala. The call to
-  // `checkResultFailure` goes to a protected method which is not accessible.
-  // I tried to fix it, but get test failures.
-  // @Test def specs2 = projects.specs2.run()
+  @Test def specs2 = projects.specs2.run()
 
   @Test def stdLib213 = projects.stdLib213.run()
   @Test def ujson = projects.ujson.run()
diff --git a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
index aa97435d64bb..988a37be4388 100644
--- a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -907,10 +907,13 @@ object SymDenotations {
           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""")
+          if pre.termSymbol.isPackageObject && accessWithin(pre.termSymbol.owner) then
+            true
+          else
+            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
diff --git a/tests/pos/i18124/definition.scala b/tests/pos/i18124/definition.scala
new file mode 100644
index 000000000000..1377c94fe7cd
--- /dev/null
+++ b/tests/pos/i18124/definition.scala
@@ -0,0 +1,15 @@
+// definition.scala
+package oolong.bson:
+
+  trait BsonValue
+  protected def merge(
+      base: BsonValue,
+      patch: BsonValue,
+      arraySubvalues: Boolean = false
+  ): BsonValue = ???
+
+  private def foo: Int = 1
+
+  package inner:
+    protected[bson] def bar = 2
+
diff --git a/tests/pos/i18124/usage.scala b/tests/pos/i18124/usage.scala
new file mode 100644
index 000000000000..0bc0417c01ad
--- /dev/null
+++ b/tests/pos/i18124/usage.scala
@@ -0,0 +1,8 @@
+// usage.scala
+package oolong.bson
+
+extension (bv: BsonValue)
+  def :+(other: BsonValue): BsonValue = merge(other, bv, false)
+
+val x = foo
+val y = inner.bar

From 9cae4e8af5a54916b9fa128e620bd53cf54d3e0b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Marks?= <pmarks@virtuslab.com>
Date: Wed, 5 Jul 2023 17:58:03 +0200
Subject: [PATCH 630/657] Add changelog for 3.3.1-RC3

---
 changelogs/3.3.1-RC3.md | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 changelogs/3.3.1-RC3.md

diff --git a/changelogs/3.3.1-RC3.md b/changelogs/3.3.1-RC3.md
new file mode 100644
index 000000000000..006d887c4f49
--- /dev/null
+++ b/changelogs/3.3.1-RC3.md
@@ -0,0 +1,15 @@
+# Backported fixes
+
+- Add clause for protected visibility from package objects [#18134](https://github.com/lampepfl/dotty/pull/18134)
+
+# Contributors
+
+Thank you to all the contributors who made this release possible 🎉
+
+According to `git shortlog -sn --no-merges 3.3.1-RC2..3.3.1-RC3` these are:
+
+```
+     2 Paweł Marks
+     1 Martin Odersky
+
+```

From 161de6e8e7b0e8f4fd59406bc9c1b9c79c6a634b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Marks?= <pmarks@virtuslab.com>
Date: Wed, 5 Jul 2023 17:59:29 +0200
Subject: [PATCH 631/657] Release 3.3.1-RC3

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

diff --git a/project/Build.scala b/project/Build.scala
index a2ea5ce1a596..1d4f2c7350a5 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -82,7 +82,7 @@ object Build {
 
   val referenceVersion = "3.3.0"
 
-  val baseVersion = "3.3.1-RC2"
+  val baseVersion = "3.3.1-RC3"
 
   // Versions used by the vscode extension to create a new project
   // This should be the latest published releases.
@@ -98,7 +98,7 @@ object Build {
    *  set to 3.1.3. If it is going to be 3.1.0, it must be set to the latest
    *  3.0.x release.
    */
-  val previousDottyVersion = "3.3.1-RC1"
+  val previousDottyVersion = "3.3.1-RC2"
 
   object CompatMode {
     final val BinaryCompatible = 0

From 011e6674f0b79a84c4b68a749c73b0c91d7c036e Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 9 May 2023 08:54:12 +0200
Subject: [PATCH 632/657] Revert "Include top-level symbols from same file in
 outer ambiguity error"

This reverts commit 7d4e103a941a30306ddde28a11f8bc3a8841acf8.

Closes #17433
---
 .../src/dotty/tools/dotc/typer/Typer.scala    | 19 ++++------------
 tests/neg/ambiref.check                       | 16 --------------
 tests/neg/ambiref.scala                       | 22 +------------------
 tests/pos-special/fatal-warnings/i9260.scala  |  2 +-
 tests/run/protectedacc.scala                  |  2 +-
 5 files changed, 7 insertions(+), 54 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 2e7444af8e96..cb23262d1410 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -408,16 +408,11 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
           // 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 || ctx.owner.is(Package)
+              !mbr.symbol.exists || mbr.symbol.owner == ctx.owner
             denot match
               case denot: SingleDenotation => !isCurrent(denot)
               case denot => !denot.hasAltWith(isCurrent)
 
-          /* It is an error if an identifier x is available as an inherited member in an inner scope
-           * and the same name x is defined in an outer scope in the same source file, unless
-           * the inherited member (has an overloaded alternative that) coincides with
-           * (an overloaded alternative of) the definition x.
-           */
           def checkNoOuterDefs(denot: Denotation, last: Context, prevCtx: Context): Unit =
             def sameTermOrType(d1: SingleDenotation, d2: Denotation) =
               d2.containsSym(d1.symbol) || d2.hasUniqueSym && {
@@ -434,15 +429,9 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
             val owner = outer.owner
             if (owner eq last.owner) && (outer.scope eq last.scope) then
               checkNoOuterDefs(denot, outer, prevCtx)
-            else if !owner.isRoot then
-              val found =
-                if owner.is(Package) then
-                  owner.denot.asClass.membersNamed(name)
-                    .filterWithPredicate(d => !d.symbol.is(Package) && d.symbol.source == denot.symbol.source)
-                else
-                  val scope = if owner.isClass then owner.info.decls else outer.scope
-                  scope.denotsNamed(name)
-              val competing = found.filterWithFlags(required, excluded | Synthetic)
+            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 => sameTermOrType(sd, denot))
diff --git a/tests/neg/ambiref.check b/tests/neg/ambiref.check
index 32b4078f1346..5d701b3b3b71 100644
--- a/tests/neg/ambiref.check
+++ b/tests/neg/ambiref.check
@@ -30,19 +30,3 @@
    |                and inherited subsequently in class E
    |
    | longer explanation available when compiling with `-explain`
--- [E049] Reference Error: tests/neg/ambiref.scala:43:10 ---------------------------------------------------------------
-43 |  println(global)    // error
-   |          ^^^^^^
-   |          Reference to global is ambiguous.
-   |          It is both defined in package <empty>
-   |          and inherited subsequently in object D
-   |
-   | longer explanation available when compiling with `-explain`
--- [E049] Reference Error: tests/neg/ambiref.scala:49:16 ---------------------------------------------------------------
-49 |    def t = new T { } // error
-   |                ^
-   |                Reference to T is ambiguous.
-   |                It is both defined in package p
-   |                and inherited subsequently in class C
-   |
-   | longer explanation available when compiling with `-explain`
diff --git a/tests/neg/ambiref.scala b/tests/neg/ambiref.scala
index bb48997cd465..e7a5d5efbd7e 100644
--- a/tests/neg/ambiref.scala
+++ b/tests/neg/ambiref.scala
@@ -40,24 +40,4 @@ val global = 0
 class C:
   val global = 1
 object D extends C:
-  println(global)    // error
-
-package p:
-  class T
-  trait P { trait T }
-  class C extends P:
-    def t = new T { } // error
-
-package scala:
-  trait P { trait Option[+A] }
-  class C extends P:
-    def t = new Option[String] { } // OK, competing scala.Option is not defined in the same compilation unit
-
-object test5:
-  class Mu // generates a synthetic companion object with an apply method
-  trait A {
-    val Mu = 1
-  }
-  trait B extends A {
-    def t = Mu // don't warn about synthetic companion
-  }
+  println(global)    // OK, since global is defined in package
\ No newline at end of file
diff --git a/tests/pos-special/fatal-warnings/i9260.scala b/tests/pos-special/fatal-warnings/i9260.scala
index 0392c1c96fa8..df548f393eea 100644
--- a/tests/pos-special/fatal-warnings/i9260.scala
+++ b/tests/pos-special/fatal-warnings/i9260.scala
@@ -10,7 +10,7 @@ end AstImpl
 
 object untpd extends AstImpl[Null]:
 
-  def DefDef(ast: this.Ast): DefDef = ast match
+  def DefDef(ast: Ast): DefDef = ast match
     case ast: DefDef => ast
 
 end untpd
diff --git a/tests/run/protectedacc.scala b/tests/run/protectedacc.scala
index 85aa3438faa3..a08e7201fd15 100644
--- a/tests/run/protectedacc.scala
+++ b/tests/run/protectedacc.scala
@@ -134,7 +134,7 @@ package p {
 
     abstract class X[T] extends PolyA[T] {
 
-      trait Inner extends this.B {
+      trait Inner extends B {
         def self: T;
         def self2: Node;
         def getB: Inner;

From bf10893d6bc034c5aafccecd47d38b69c0d8f274 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Marks?= <pmarks@virtuslab.com>
Date: Tue, 11 Jul 2023 12:58:07 +0200
Subject: [PATCH 633/657] Add changelog for 3.3.1-RC4

---
 changelogs/3.3.1-RC3.md |  2 +-
 changelogs/3.3.1-RC4.md | 15 +++++++++++++++
 2 files changed, 16 insertions(+), 1 deletion(-)
 create mode 100644 changelogs/3.3.1-RC4.md

diff --git a/changelogs/3.3.1-RC3.md b/changelogs/3.3.1-RC3.md
index 006d887c4f49..eb19f40b10dc 100644
--- a/changelogs/3.3.1-RC3.md
+++ b/changelogs/3.3.1-RC3.md
@@ -10,6 +10,6 @@ According to `git shortlog -sn --no-merges 3.3.1-RC2..3.3.1-RC3` these are:
 
 ```
      2 Paweł Marks
-     1 Martin Odersky
+     1 Nicolas Stucki
 
 ```
diff --git a/changelogs/3.3.1-RC4.md b/changelogs/3.3.1-RC4.md
new file mode 100644
index 000000000000..7d95e0258fad
--- /dev/null
+++ b/changelogs/3.3.1-RC4.md
@@ -0,0 +1,15 @@
+# Backported fixes
+
+- Revert "Include top-level symbols from same file in outer ambiguity error" [#17438](https://github.com/lampepfl/dotty/pull/17438)
+
+# Contributors
+
+Thank you to all the contributors who made this release possible 🎉
+
+According to `git shortlog -sn --no-merges 3.3.1-RC3..3.3.1-RC4` these are:
+
+```
+     2 Paweł Marks
+     1 Nicolas Stucki
+
+```

From 555df5304aa882e67e08c917ff4924ab5947d295 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Marks?= <pmarks@virtuslab.com>
Date: Tue, 11 Jul 2023 13:00:08 +0200
Subject: [PATCH 634/657] Release 3.3.1-RC4

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

diff --git a/project/Build.scala b/project/Build.scala
index 1d4f2c7350a5..a60932eb9e30 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -82,7 +82,7 @@ object Build {
 
   val referenceVersion = "3.3.0"
 
-  val baseVersion = "3.3.1-RC3"
+  val baseVersion = "3.3.1-RC4"
 
   // Versions used by the vscode extension to create a new project
   // This should be the latest published releases.
@@ -98,7 +98,7 @@ object Build {
    *  set to 3.1.3. If it is going to be 3.1.0, it must be set to the latest
    *  3.0.x release.
    */
-  val previousDottyVersion = "3.3.1-RC2"
+  val previousDottyVersion = "3.3.1-RC3"
 
   object CompatMode {
     final val BinaryCompatible = 0

From e1233d80c5a870ebb51c72e4b26a8fc8004b3774 Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 18 Jul 2023 14:32:36 +0200
Subject: [PATCH 635/657] Heal stage inconsistent prefixes of type projections

Fixes #17293
---
 compiler/src/dotty/tools/dotc/staging/HealType.scala |  2 +-
 tests/pos-macros/i17293.scala                        | 12 ++++++++++++
 tests/pos-macros/i17293b.scala                       | 12 ++++++++++++
 3 files changed, 25 insertions(+), 1 deletion(-)
 create mode 100644 tests/pos-macros/i17293.scala
 create mode 100644 tests/pos-macros/i17293b.scala

diff --git a/compiler/src/dotty/tools/dotc/staging/HealType.scala b/compiler/src/dotty/tools/dotc/staging/HealType.scala
index 023271960b40..7d3ca0ad2f63 100644
--- a/compiler/src/dotty/tools/dotc/staging/HealType.scala
+++ b/compiler/src/dotty/tools/dotc/staging/HealType.scala
@@ -46,7 +46,7 @@ class HealType(pos: SrcPos)(using Context) extends TypeMap {
       case prefix: TermRef if tp.symbol.isTypeSplice =>
         checkNotWildcardSplice(tp)
         if level == 0 then tp else getTagRef(prefix)
-      case _: NamedType | _: ThisType | NoPrefix =>
+      case _: TermRef | _: ThisType | NoPrefix =>
         if levelInconsistentRootOfPath(tp).exists then
           tryHeal(tp)
         else
diff --git a/tests/pos-macros/i17293.scala b/tests/pos-macros/i17293.scala
new file mode 100644
index 000000000000..57eba1181903
--- /dev/null
+++ b/tests/pos-macros/i17293.scala
@@ -0,0 +1,12 @@
+import scala.quoted.*
+
+trait OuterTrait {
+  trait X
+}
+
+def exampleMacro[T <: OuterTrait: Type](expr: Expr[T])(using Quotes): Expr[OuterTrait#X] = {
+  '{
+    val prefix: T = ${ expr }
+    new prefix.X {}
+  }
+}
diff --git a/tests/pos-macros/i17293b.scala b/tests/pos-macros/i17293b.scala
new file mode 100644
index 000000000000..a8b73ba6176b
--- /dev/null
+++ b/tests/pos-macros/i17293b.scala
@@ -0,0 +1,12 @@
+import scala.quoted.*
+
+trait OuterTrait { self =>
+  trait X
+
+  def exampleMacro[T <: self.type: Type](expr: Expr[T])(using Quotes): Expr[self.X] = {
+    '{
+      val prefix: T = ${ expr }
+      new prefix.X {}
+    }
+  }
+}
\ No newline at end of file

From 5f2450aa8ae3c00f6f52eb6a2dbe2427fe0ae6a8 Mon Sep 17 00:00:00 2001
From: Jan Chyb <jan.chyb.99@gmail.com>
Date: Tue, 25 Jul 2023 12:56:09 +0200
Subject: [PATCH 636/657] Fix regression with Overloaded methods returning
 Functions

Before the regression, FunctionOf unapply would not try dealiasing,
meaning that an aliased function type would be handled by a general
case.
To fix that, instead of handling Function types separately when
filtering overloaded methods in `resolveOverloaded1`, we allow to
fallback to the general case if the previous one returns nothing.
Along with fixing the regression, this also improves other cases,
one of which was added to the test.

Readd a separate FunctionOf case, but with a fallback
---
 .../dotty/tools/dotc/typer/Applications.scala | 52 ++++++++++---------
 tests/pos/i17245.scala                        | 20 +++++++
 2 files changed, 48 insertions(+), 24 deletions(-)
 create mode 100644 tests/pos/i17245.scala

diff --git a/compiler/src/dotty/tools/dotc/typer/Applications.scala b/compiler/src/dotty/tools/dotc/typer/Applications.scala
index fbed4b77d3fe..cb6aec26406a 100644
--- a/compiler/src/dotty/tools/dotc/typer/Applications.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Applications.scala
@@ -2062,31 +2062,35 @@ trait Applications extends Compatibility {
           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
+        val compat0 = pt match
+          case defn.FunctionOf(args, resType, _) =>
+            narrowByTypes(alts, args, resType)
+          case _ =>
+            Nil
+        if (compat0.isEmpty) then
+          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
+        else compat0
     }
 
     /** The type of alternative `alt` after instantiating its first parameter
diff --git a/tests/pos/i17245.scala b/tests/pos/i17245.scala
new file mode 100644
index 000000000000..3b5b3a74108d
--- /dev/null
+++ b/tests/pos/i17245.scala
@@ -0,0 +1,20 @@
+import scala.reflect.ClassTag
+
+trait MockSettings
+
+object Mockito {
+  def mock[T : ClassTag]: T = ???
+  def mock[T : ClassTag](settings: MockSettings): T = ???
+}
+
+trait Channel
+type OnChannel = Channel => Any
+
+@main def Test =
+  val case1: OnChannel = Mockito.mock[OnChannel]
+  val case2: OnChannel = Mockito.mock
+  val case3 = Mockito.mock[OnChannel]
+  val case4: OnChannel =  Mockito.mock[OnChannel](summon[ClassTag[OnChannel]])
+
+  // not a regressive case, but an added improvement with the fix for the above
+  val case5: Channel => Any = Mockito.mock[Channel => Any]

From b85cbb5a3a64cd7b21bf6b2cbd3f75c0f11db8fd Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Mon, 17 Jul 2023 18:34:16 +0200
Subject: [PATCH 637/657] Disallow taking singleton types of packages again

Fixes #18109
---
 compiler/src/dotty/tools/dotc/typer/Checking.scala | 13 ++++++++-----
 tests/neg/i18109.scala                             | 11 +++++++++++
 2 files changed, 19 insertions(+), 5 deletions(-)
 create mode 100644 tests/neg/i18109.scala

diff --git a/compiler/src/dotty/tools/dotc/typer/Checking.scala b/compiler/src/dotty/tools/dotc/typer/Checking.scala
index b2ab5332c3b2..df5639b50302 100644
--- a/compiler/src/dotty/tools/dotc/typer/Checking.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Checking.scala
@@ -748,13 +748,16 @@ object Checking {
     if sym.isNoValue && !ctx.isJava then
       report.error(JavaSymbolIsNotAValue(sym), tree.srcPos)
 
+  /** Check that `tree` refers to a value, unless `tree` is selected or applied
+   *  (singleton types x.type don't count as selections).
+   */
   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: RefTree if tree.name.isTermName =>
+        proto match
+          case _: SelectionProto if proto ne SingletonTypeProto => // no value check
+          case _: FunOrPolyProto => // no value check
+          case _ => checkValue(tree)
       case _ =>
     tree
 
diff --git a/tests/neg/i18109.scala b/tests/neg/i18109.scala
new file mode 100644
index 000000000000..7df13b0c36ff
--- /dev/null
+++ b/tests/neg/i18109.scala
@@ -0,0 +1,11 @@
+package foo {}
+
+package bar {
+  object Test {
+    def qux[A] = 123
+    def main(args: Array[String]): Unit = {
+      val y = qux[foo.type] // error
+      val x = valueOf[foo.type] // error
+    }
+  }
+}
\ No newline at end of file

From 110c91f5831b24c6751b30ed45f76c436be9db04 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Mon, 7 Aug 2023 18:58:54 +0200
Subject: [PATCH 638/657] A slightly more conservative version of #14128

Two changes

 - Fix `hasUpperBound` to work correctly for higher-kinded types
 - A more conservative fix in `IsFullyDefinedAccumulator`. We now maintain
   the symmetry that

     - if variance < 0, we maximize
     - if variance > 0 (and Nothing is admissible) we minimize
     - only if variance = 0, we use the upper bound as a tie breaker

   Previously, we maximized even if variance > 0 if there was an upper but
   no lower bound. But that was asymmetric since there is no corresponding
   case where we minimize at variance < 0 if there is a lower but no upper
   bound.
---
 compiler/src/dotty/tools/dotc/core/Types.scala        | 7 ++++++-
 compiler/src/dotty/tools/dotc/typer/Inferencing.scala | 6 +++++-
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index 73a64f2c1b8f..bb4fd02816a6 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -246,6 +246,11 @@ object Types {
       case _ => false
     }
 
+    /** Is this type exactly `Any`, or a type lambda ending in `Any`? */
+    def isTopOfSomeKind(using Context): Boolean = dealias match
+      case tp: TypeLambda => tp.resType.isTopOfSomeKind
+      case _ => isExactlyAny
+
     def isBottomType(using Context): Boolean =
       if ctx.mode.is(Mode.SafeNulls) && !ctx.phase.erasedTypes then hasClassSymbol(defn.NothingClass)
       else isBottomTypeAfterErasure
@@ -4813,7 +4818,7 @@ object Types {
     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.finalResultType.isExactlyAny
+    def hasUpperBound(using Context): Boolean = !currentEntry.hiBound.isTopOfSomeKind
 
     /** Unwrap to instance (if instantiated) or origin (if not), until result
      *  is no longer a TypeVar
diff --git a/compiler/src/dotty/tools/dotc/typer/Inferencing.scala b/compiler/src/dotty/tools/dotc/typer/Inferencing.scala
index 0e1c41ceef74..4d027b8750e0 100644
--- a/compiler/src/dotty/tools/dotc/typer/Inferencing.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Inferencing.scala
@@ -187,7 +187,11 @@ object Inferencing {
               // 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.hasUpperBound || tvar.hasLowerBound) then
+            else if variance >= 0 && tvar.hasLowerBound then
+              instantiate(tvar, fromBelow = true)
+            else if (variance > 0 || variance == 0 && !tvar.hasUpperBound)
+                && force.ifBottom == IfBottom.ok
+            then // if variance == 0, prefer upper bound if one is given
               instantiate(tvar, fromBelow = true)
             else if variance >= 0 && force.ifBottom == IfBottom.fail then
               fail = true

From 232c5f448f49406d6bf68ab4f5b230e4cf6aaf39 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Mon, 7 Aug 2023 11:05:44 +0100
Subject: [PATCH 639/657] Show Implicit Candidate & RefAndLevel

---
 compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala | 7 +++++++
 compiler/src/dotty/tools/dotc/printing/Printer.scala      | 5 ++++-
 compiler/src/dotty/tools/dotc/typer/Implicits.scala       | 6 ++++--
 3 files changed, 15 insertions(+), 3 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala b/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
index f3540502597c..700b3fbf525f 100644
--- a/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
@@ -640,6 +640,13 @@ class PlainPrinter(_ctx: Context) extends Printer {
     else if (pos.source.exists) s"${pos.source.file.name}:${pos.line + 1}"
     else s"(no source file, offset = ${pos.span.point})"
 
+  def toText(cand: Candidate): Text =
+    "Cand("
+      ~ toTextRef(cand.ref)
+      ~ (if cand.isConversion then " conv" else "")
+      ~ (if cand.isExtension then " ext" else "")
+      ~ Str(" L" + cand.level) ~ ")"
+
   def toText(result: SearchResult): Text = result match {
     case result: SearchSuccess =>
       "SearchSuccess: " ~ toText(result.ref) ~ " via " ~ toText(result.tree)
diff --git a/compiler/src/dotty/tools/dotc/printing/Printer.scala b/compiler/src/dotty/tools/dotc/printing/Printer.scala
index 697ab063a646..ab0c867ec31f 100644
--- a/compiler/src/dotty/tools/dotc/printing/Printer.scala
+++ b/compiler/src/dotty/tools/dotc/printing/Printer.scala
@@ -7,7 +7,7 @@ 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 typer.Implicits.*
 import util.SourcePosition
 import typer.ImportInfo
 
@@ -153,6 +153,9 @@ abstract class Printer {
   /** Textual representation of source position */
   def toText(pos: SourcePosition): Text
 
+  /** Textual representation of implicit candidates. */
+  def toText(cand: Candidate): Text
+
   /** Textual representation of implicit search result */
   def toText(result: SearchResult): Text
 
diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
index c6795ed25a0e..66f400d7eae0 100644
--- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -49,17 +49,19 @@ object Implicits:
   }
 
   /** Both search candidates and successes are references with a specific nesting level. */
-  sealed trait RefAndLevel {
+  sealed trait RefAndLevel extends Showable {
     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 {
+  case class Candidate(implicitRef: ImplicitRef, kind: Candidate.Kind, level: Int) extends RefAndLevel with Showable {
     def ref: TermRef = implicitRef.underlyingRef
 
     def isExtension = (kind & Candidate.Extension) != 0
     def isConversion = (kind & Candidate.Conversion) != 0
+
+    def toText(printer: Printer): Text = printer.toText(this)
   }
   object Candidate {
     type Kind = Int

From 48c994c7e82c2fe4be4e7bfa294ce5afc3148270 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Mon, 24 Jul 2023 15:34:17 +0100
Subject: [PATCH 640/657] Record failures to adapt application arguments

---
 .../tools/dotc/core/OrderingConstraint.scala  |  4 +-
 .../dotty/tools/dotc/typer/Applications.scala |  2 +-
 tests/neg-macros/i6762.scala                  |  2 +-
 tests/neg/enum-values.check                   |  8 ++--
 tests/neg/enumsAccess.scala                   |  2 +-
 tests/neg/i6779.check                         |  2 +-
 tests/neg/recursive-lower-constraint.scala    |  2 +-
 tests/neg/syntax-error-recovery.check         |  6 ---
 tests/neg/syntax-error-recovery.scala         |  2 +-
 tests/pos/i18163.orig.scala                   | 40 +++++++++++++++++++
 tests/pos/i18163.scala                        | 21 ++++++++++
 11 files changed, 74 insertions(+), 17 deletions(-)
 create mode 100644 tests/pos/i18163.orig.scala
 create mode 100644 tests/pos/i18163.scala

diff --git a/compiler/src/dotty/tools/dotc/core/OrderingConstraint.scala b/compiler/src/dotty/tools/dotc/core/OrderingConstraint.scala
index faea30390d2b..0328cea9b3ca 100644
--- a/compiler/src/dotty/tools/dotc/core/OrderingConstraint.scala
+++ b/compiler/src/dotty/tools/dotc/core/OrderingConstraint.scala
@@ -344,7 +344,8 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
       if newSet.isEmpty then deps.remove(referenced)
       else deps.updated(referenced, newSet)
 
-    def traverse(t: Type) = t match
+    def traverse(t: Type) = try
+      t match
       case param: TypeParamRef =>
         if hasBounds(param) then
           if variance >= 0 then coDeps = update(coDeps, param)
@@ -356,6 +357,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
           seen += tp
           traverse(tp.ref)
       case _ => traverseChildren(t)
+    catch case ex: Throwable => handleRecursive("adjust", t.show, ex)
   end Adjuster
 
   /** Adjust dependencies to account for the delta of previous entry `prevEntry`
diff --git a/compiler/src/dotty/tools/dotc/typer/Applications.scala b/compiler/src/dotty/tools/dotc/typer/Applications.scala
index fbed4b77d3fe..a9376444a911 100644
--- a/compiler/src/dotty/tools/dotc/typer/Applications.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Applications.scala
@@ -844,7 +844,7 @@ trait Applications extends Compatibility {
       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)
+        if (!success || typedArgs.exists(_.tpe.isError)) app0.withType(UnspecifiedErrorType)
         else {
           if !sameSeq(args, orderedArgs)
              && !isJavaAnnotConstr(methRef.symbol)
diff --git a/tests/neg-macros/i6762.scala b/tests/neg-macros/i6762.scala
index a8df289b26c2..054945e213d6 100644
--- a/tests/neg-macros/i6762.scala
+++ b/tests/neg-macros/i6762.scala
@@ -2,4 +2,4 @@ import scala.quoted.*
 
 type G[X]
 case class Foo[T](x: T)
-def f(word: String)(using Quotes): Expr[Foo[G[String]]] = '{Foo(${Expr(word)})} // error // error
+def f(word: String)(using Quotes): Expr[Foo[G[String]]] = '{Foo(${Expr(word)})} // error
diff --git a/tests/neg/enum-values.check b/tests/neg/enum-values.check
index 37990e8f312e..23337de1b2c4 100644
--- a/tests/neg/enum-values.check
+++ b/tests/neg/enum-values.check
@@ -24,8 +24,8 @@
    |
    |                                             failed with:
    |
-   |                                                 Found:    Array[example.Tag[?]]
-   |                                                 Required: Array[example.ListLike[?]]
+   |                                                 Found:    example.ListLike.type
+   |                                                 Required: Nothing
 -- [E008] Not Found Error: tests/neg/enum-values.scala:34:52 -----------------------------------------------------------
 34 |  val typeCtorsK: Array[TypeCtorsK[?]] = TypeCtorsK.values // error
    |                                         ^^^^^^^^^^^^^^^^^
@@ -38,8 +38,8 @@
    |
    |                                             failed with:
    |
-   |                                                 Found:    Array[example.Tag[?]]
-   |                                                 Required: Array[example.TypeCtorsK[?[_$1]]]
+   |                                                 Found:    example.TypeCtorsK.type
+   |                                                 Required: Nothing
 -- [E008] Not Found Error: tests/neg/enum-values.scala:36:6 ------------------------------------------------------------
 36 |  Tag.valueOf("Int") // error
    |  ^^^^^^^^^^^
diff --git a/tests/neg/enumsAccess.scala b/tests/neg/enumsAccess.scala
index 18b91b346b6a..8a8e9af8910f 100644
--- a/tests/neg/enumsAccess.scala
+++ b/tests/neg/enumsAccess.scala
@@ -63,7 +63,7 @@ object test5 {
   enum E5[T](x: T) {
     case C3() extends E5[INT](defaultX)// error: illegal reference  // error: illegal reference
     case C4 extends E5[INT](defaultX) // error: illegal reference  // error: illegal reference
-    case C5 extends E5[E5[_]](E5.this) // error: type mismatch
+    case C5 extends E5[E5[_]](E5.this) // error: cannot be instantiated // error: conflicting base types // error: type mismatch
   }
 
   object E5 {
diff --git a/tests/neg/i6779.check b/tests/neg/i6779.check
index 8e05c22eb640..f1e1b9d5557b 100644
--- a/tests/neg/i6779.check
+++ b/tests/neg/i6779.check
@@ -11,7 +11,7 @@
    |                             value f is not a member of T.
    |                             An extension method was tried, but could not be fully constructed:
    |
-   |                                 Test.f[G[T]](x)(given_Stuff)
+   |                                 Test.f[G[T]](x)
    |
    |                                 failed with:
    |
diff --git a/tests/neg/recursive-lower-constraint.scala b/tests/neg/recursive-lower-constraint.scala
index 8009ab5fce6e..cf45d8b95171 100644
--- a/tests/neg/recursive-lower-constraint.scala
+++ b/tests/neg/recursive-lower-constraint.scala
@@ -3,5 +3,5 @@ class Bar extends Foo[Bar]
 
 class A {
   def foo[T <: Foo[T], U >: Foo[T] <: T](x: T): T = x
-  foo(new Bar) // error
+  foo(new Bar) // error // error
 }
diff --git a/tests/neg/syntax-error-recovery.check b/tests/neg/syntax-error-recovery.check
index 0bf626210fed..18d877833d79 100644
--- a/tests/neg/syntax-error-recovery.check
+++ b/tests/neg/syntax-error-recovery.check
@@ -94,12 +94,6 @@
    |          Not found: bam
    |
    | longer explanation available when compiling with `-explain`
--- [E006] Not Found Error: tests/neg/syntax-error-recovery.scala:61:10 -------------------------------------------------
-61 |  println(bam) // error
-   |          ^^^
-   |          Not found: bam
-   |
-   | longer explanation available when compiling with `-explain`
 -- [E129] Potential Issue Warning: tests/neg/syntax-error-recovery.scala:7:2 -------------------------------------------
 6 |        2
 7 |  }
diff --git a/tests/neg/syntax-error-recovery.scala b/tests/neg/syntax-error-recovery.scala
index 775abeb97bdb..b6663cc9c70a 100644
--- a/tests/neg/syntax-error-recovery.scala
+++ b/tests/neg/syntax-error-recovery.scala
@@ -58,5 +58,5 @@ object Test2:
   def foo5(x: Int) =
     foo2(foo2(,) // error // error
 
-  println(bam) // error
+  println(bam)
 // error
\ No newline at end of file
diff --git a/tests/pos/i18163.orig.scala b/tests/pos/i18163.orig.scala
new file mode 100644
index 000000000000..eb0627254156
--- /dev/null
+++ b/tests/pos/i18163.orig.scala
@@ -0,0 +1,40 @@
+import scala.language.implicitConversions
+
+// We do have 2 `contramap` functions, one provided via `LoggerSyntax` other via `Contravariant.Ops`
+// `ContravariantMonoidal` given instances are not used, and they do not match our type. Code fails when we have at least 2 instances of them
+// Removal of `import catsSyntax._` allow to compile code
+// Removal of `import odinSyntax.LoggerSyntax` and remaining `catsSyntax` would fail to compile the `def fails`
+
+trait Foo[A]
+trait Bar[A]
+
+trait WriterT[F[_]: Contravariant, L, V]:
+  def contramap[Z](fn: Z => V): WriterT[F, L, Z] = ???
+trait Logger[F[_]]
+class WriterTLogger[F[_]] extends Logger[[G] =>> WriterT[F, List[String], G]]
+
+trait ContravariantMonoidal[F[_]] extends Invariant[F] with Contravariant[F]
+trait Invariant[F[_]]
+object Invariant:
+  given ContravariantMonoidal[Foo] = ???
+  given ContravariantMonoidal[Bar] = ???
+
+trait Contravariant[F[_]] extends Invariant[F]
+object Contravariant:
+  trait Ops[F[_], A]:
+    def contramap[B](f: B => A): F[B] = ???
+
+object catsSyntax:
+  implicit def toContravariantOps[F[_]: Contravariant, A](target: F[A]): Contravariant.Ops[F, A] = ???
+
+object odinSyntax:
+  implicit class LoggerSyntax[F[_]](logger: Logger[F]):
+    def contramap(f: String => String): Logger[F] = ???
+
+import catsSyntax._
+import odinSyntax.LoggerSyntax
+
+class Test:
+  def fails = new WriterTLogger[Option].contramap(identity)
+  def works = LoggerSyntax(new WriterTLogger[Option]).contramap(identity)
+
diff --git a/tests/pos/i18163.scala b/tests/pos/i18163.scala
new file mode 100644
index 000000000000..5c364a50dd57
--- /dev/null
+++ b/tests/pos/i18163.scala
@@ -0,0 +1,21 @@
+import scala.language.implicitConversions
+
+trait Foo[A]
+trait Bar[B]
+trait Qux[C]
+class Log[K[_]]
+
+trait Inv[F[_]]
+object Inv:
+  given monFoo: Inv[Foo] = ???
+  given monBar: Inv[Bar] = ???
+
+trait InvOps[H[_], D] { def desc(s: String): H[D] = ??? }
+trait LogOps[L[_]]    { def desc(s: String): Log[L] = ??? }
+
+class Test:
+  implicit def LogOps[Q[_]](l: Log[Q]): LogOps[Q] = ???
+  implicit def InvOps[J[_], E](j11: J[E])(implicit z: Inv[J]): InvOps[J, E] = ???
+
+  def fails = new Log[Qux].desc("fails")
+  def works = LogOps[Qux](new Log[Qux]).desc("works")

From c569a4f4c691c8eaf5536cd90e3935553932b8fd Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Tue, 1 Aug 2023 14:27:06 +0100
Subject: [PATCH 641/657] Space: Fix intersectUnrelatedAtomicTypes tracing

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

diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index 7238756454b3..002e3646c663 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -330,7 +330,7 @@ object SpaceEngine {
    * The types should be atomic (non-decomposable) and unrelated (neither
    * should be a subtype of the other).
    */
-  def intersectUnrelatedAtomicTypes(tp1: Type, tp2: Type)(sp: Space)(using Context): Space = trace(i"atomic intersection: ${AndType(tp1, tp2)}", debug) {
+  def intersectUnrelatedAtomicTypes(tp1: Type, tp2: Type)(sp: Space)(using Context): Space = trace(i"atomic intersection: ${AndType(tp1, tp2)}", debug, show) {
     // 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.

From 518c02055f3addd2b4ea08ebaa6ac9c3ae65392e Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Tue, 1 Aug 2023 14:47:31 +0100
Subject: [PATCH 642/657] Space: Make isDecomposableToChildren ignore type
 constructors

---
 .../src/dotty/tools/dotc/transform/patmat/Space.scala    | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index 002e3646c663..467b36df3805 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -642,7 +642,7 @@ object SpaceEngine {
         // For instance, from i15029, `decompose((X | Y).Field[T]) = [X.Field[T], Y.Field[T]]`.
         parts.map(tp.derivedAppliedType(_, targs))
 
-      case tp if tp.classSymbol.isDecomposableToChildren =>
+      case tp if tp.isDecomposableToChildren =>
         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...
@@ -678,8 +678,8 @@ object SpaceEngine {
     rec(tp, Nil)
   }
 
-  extension (cls: Symbol)
-    /** A type is decomposable to children if it's sealed,
+  extension (tp: Type)
+    /** A type is decomposable to children if it has a simple kind, it's sealed,
       * abstract (or a trait) - so its not a sealed concrete class that can be instantiated on its own,
       * has no anonymous children, which we wouldn't be able to name as counter-examples,
       * but does have children.
@@ -688,7 +688,8 @@ object SpaceEngine {
       * A sealed trait with subclasses that then get removed after `refineUsingParent`, decomposes to the empty list.
       * So that's why we consider whether a type has children. */
     def isDecomposableToChildren(using Context): Boolean =
-      cls.is(Sealed) && cls.isOneOf(AbstractOrTrait) && !cls.hasAnonymousChild && cls.children.nonEmpty
+      val cls = tp.classSymbol
+      tp.hasSimpleKind && cls.is(Sealed) && cls.isOneOf(AbstractOrTrait) && !cls.hasAnonymousChild && cls.children.nonEmpty
 
   val ListOfNoType    = List(NoType)
   val ListOfTypNoType = ListOfNoType.map(Typ(_, decomposed = true))

From 86782076c45e88fc16c3abb0ca8646ce4a2dd417 Mon Sep 17 00:00:00 2001
From: Dale Wijnand <dale.wijnand@gmail.com>
Date: Tue, 1 Aug 2023 16:00:31 +0100
Subject: [PATCH 643/657] Space: Revert how invariant targs are erased to fix
 regression

The motivating case (i16451) is complicated, because it involves
unchecked type arguments.  To fix the regression, I'm reverting the fix.
---
 .../tools/dotc/transform/patmat/Space.scala   | 13 ++----------
 .../suppressed-type-test-warnings.scala       |  2 ++
 .../isInstanceOf/enum-approx2.scala           |  2 ++
 .../neg-custom-args/isInstanceOf/i11178.scala |  1 +
 .../neg-custom-args/isInstanceOf/i8932.scala  |  1 +
 tests/{ => pending}/neg/i16451.check          |  0
 tests/{ => pending}/neg/i16451.scala          |  4 ----
 tests/pos/i17230.bootstrap.scala              | 16 +++++++++++++++
 tests/pos/i17230.min1.scala                   | 15 ++++++++++++++
 tests/pos/i17230.orig.scala                   | 20 +++++++++++++++++++
 10 files changed, 59 insertions(+), 15 deletions(-)
 rename tests/{ => pending}/neg/i16451.check (100%)
 rename tests/{ => pending}/neg/i16451.scala (93%)
 create mode 100644 tests/pos/i17230.bootstrap.scala
 create mode 100644 tests/pos/i17230.min1.scala
 create mode 100644 tests/pos/i17230.orig.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index 467b36df3805..eab65890c227 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -468,17 +468,8 @@ object SpaceEngine {
         WildcardType
 
       case tp @ AppliedType(tycon, args) =>
-        val args2 =
-          if tycon.isRef(defn.ArrayClass) then
-            args.map(arg => erase(arg, inArray = true, isValue = false))
-          else tycon.typeParams.lazyZip(args).map { (tparam, arg) =>
-            if isValue && tparam.paramVarianceSign == 0 then
-              // when matching against a value,
-              // any type argument for an invariant type parameter will be unchecked,
-              // meaning it won't fail to match against anything; thus the wildcard replacement
-              WildcardType
-            else erase(arg, inArray = false, isValue = false)
-          }
+        val inArray = tycon.isRef(defn.ArrayClass)
+        val args2 = args.map(arg => erase(arg, inArray = inArray, isValue = false))
         tp.derivedAppliedType(erase(tycon, inArray, isValue = false), args2)
 
       case tp @ OrType(tp1, tp2) =>
diff --git a/tests/neg-custom-args/fatal-warnings/suppressed-type-test-warnings.scala b/tests/neg-custom-args/fatal-warnings/suppressed-type-test-warnings.scala
index 175096fc6b21..92d86b3307e5 100644
--- a/tests/neg-custom-args/fatal-warnings/suppressed-type-test-warnings.scala
+++ b/tests/neg-custom-args/fatal-warnings/suppressed-type-test-warnings.scala
@@ -18,10 +18,12 @@ object Test {
   def err2[A, B](value: Foo[A, B], a: A => Int): B = value match {
     case b: Bar[B] => // spurious // error
       b.x
+    case _ => ??? // avoid fatal inexhaustivity warnings suppressing the uncheckable warning
   }
 
   def fail[A, B](value: Foo[A, B], a: A => Int): B = value match {
     case b: Bar[Int] => // error
       b.x
+    case _ => ??? // avoid fatal inexhaustivity warnings suppressing the uncheckable warning
   }
 }
diff --git a/tests/neg-custom-args/isInstanceOf/enum-approx2.scala b/tests/neg-custom-args/isInstanceOf/enum-approx2.scala
index 5e3bdef7553d..c7c8a6c4e1fb 100644
--- a/tests/neg-custom-args/isInstanceOf/enum-approx2.scala
+++ b/tests/neg-custom-args/isInstanceOf/enum-approx2.scala
@@ -4,5 +4,7 @@ case class Fun[A, B](f: Exp[A => B]) extends Exp[A => B]
 class Test {
   def eval(e: Fun[Int, Int]) = e match {
     case Fun(x: Fun[Int, Double]) => ???          // error
+    case Fun(x: Exp[Int => String]) => ???        // error
+    case _ =>
   }
 }
diff --git a/tests/neg-custom-args/isInstanceOf/i11178.scala b/tests/neg-custom-args/isInstanceOf/i11178.scala
index 71bc346e5743..47e8b4c3acab 100644
--- a/tests/neg-custom-args/isInstanceOf/i11178.scala
+++ b/tests/neg-custom-args/isInstanceOf/i11178.scala
@@ -12,6 +12,7 @@ object Test1 {
   def test[A](bar: Bar[A]) =
     bar match {
       case _: Bar[Boolean] => ??? // error
+      case _ => ???
     }
 }
 
diff --git a/tests/neg-custom-args/isInstanceOf/i8932.scala b/tests/neg-custom-args/isInstanceOf/i8932.scala
index e070fdae518c..84d2f7d4990a 100644
--- a/tests/neg-custom-args/isInstanceOf/i8932.scala
+++ b/tests/neg-custom-args/isInstanceOf/i8932.scala
@@ -6,6 +6,7 @@ class Dummy extends Bar[Nothing] with Foo[String]
 def bugReport[A](foo: Foo[A]): Foo[A] =
   foo match {
     case bar: Bar[A] => bar    // error
+    case dummy: Dummy => ???
   }
 
 def test = bugReport(new Dummy: Foo[String])
diff --git a/tests/neg/i16451.check b/tests/pending/neg/i16451.check
similarity index 100%
rename from tests/neg/i16451.check
rename to tests/pending/neg/i16451.check
diff --git a/tests/neg/i16451.scala b/tests/pending/neg/i16451.scala
similarity index 93%
rename from tests/neg/i16451.scala
rename to tests/pending/neg/i16451.scala
index 685b79477bbe..49997d2bcf92 100644
--- a/tests/neg/i16451.scala
+++ b/tests/pending/neg/i16451.scala
@@ -1,10 +1,6 @@
 // scalac: -Werror
 enum Color:
   case Red, Green
-//sealed trait Color
-//object Color:
-//  case object Red   extends Color
-//  case object Green extends Color
 
 case class Wrapper[A](value: A)
 
diff --git a/tests/pos/i17230.bootstrap.scala b/tests/pos/i17230.bootstrap.scala
new file mode 100644
index 000000000000..ef2d98d8f55b
--- /dev/null
+++ b/tests/pos/i17230.bootstrap.scala
@@ -0,0 +1,16 @@
+type Untyped = Type | Null
+
+class Type
+abstract class SearchFailureType extends Type
+
+abstract class Tree[+T <: Untyped]:
+  def tpe: T = null.asInstanceOf[T]
+
+class SearchFailureIdent[+T <: Untyped] extends Tree[T]
+
+class Test_i17230_bootstrap:
+  def t1(arg: Tree[Type]) = arg match
+    case arg: SearchFailureIdent[?] => arg.tpe match
+      case x: SearchFailureType   =>
+      case _                      =>
+    case _ =>
diff --git a/tests/pos/i17230.min1.scala b/tests/pos/i17230.min1.scala
new file mode 100644
index 000000000000..e2df63e168c1
--- /dev/null
+++ b/tests/pos/i17230.min1.scala
@@ -0,0 +1,15 @@
+// scalac: -Werror
+trait Foo:
+  type Bar[_]
+
+object Foo:
+  type Aux[B[_]] = Foo { type Bar[A] = B[A] }
+
+class Test:
+  def t1[B[_]](self: Option[Foo.Aux[B]]) = self match
+    case Some(_) => 1
+    case None    => 2
+
+  def t2[B[_]](self: Option[Foo.Aux[B]]) = self match
+    case Some(f) => 1
+    case None    => 2
diff --git a/tests/pos/i17230.orig.scala b/tests/pos/i17230.orig.scala
new file mode 100644
index 000000000000..d72a0082a116
--- /dev/null
+++ b/tests/pos/i17230.orig.scala
@@ -0,0 +1,20 @@
+// scalac: -Werror
+import scala.util.*
+
+trait Transaction {
+  type State[_]
+}
+object Transaction {
+  type of[S[_]] = Transaction { type State[A] = S[A] }
+}
+trait DynamicScope[State[_]]
+
+case class ScopeSearch[State[_]](self: Either[Transaction.of[State], DynamicScope[State]]) {
+
+  def embedTransaction[T](f: Transaction.of[State] => T): T =
+    self match {
+      case Left(integrated) => ???
+      case Right(ds)        => ???
+    }
+}
+

From 5d6891fe3de921a825d53b369cc9b3e805275753 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Marks?= <pmarks@virtuslab.com>
Date: Thu, 10 Aug 2023 09:17:12 +0200
Subject: [PATCH 644/657] Add changelog for 3.3.1-RC5

---
 changelogs/3.3.1-RC5.md | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 changelogs/3.3.1-RC5.md

diff --git a/changelogs/3.3.1-RC5.md b/changelogs/3.3.1-RC5.md
new file mode 100644
index 000000000000..e0bfc2a7fea8
--- /dev/null
+++ b/changelogs/3.3.1-RC5.md
@@ -0,0 +1,22 @@
+# Backported fixes
+
+- Heal stage inconsistent prefixes of type projections [#18239](https://github.com/lampepfl/dotty/pull/18239)
+- Fix regression #17245: Overloaded methods with ClassTags [#18286](http://github.com/lampepfl/dotty/pull/18286)
+- Disallow taking singleton types of packages again [#18232](http://github.com/lampepfl/dotty/pull/18232)
+- A slightly more conservative version of #14218 [#18352](http://github.com/lampepfl/dotty/pull/18352)
+- Record failures to adapt application arguments [#18269](http://github.com/lampepfl/dotty/pull/18269)
+- Fix regression in exhaustivity of HK types [#18303](http://github.com/lampepfl/dotty/pull/18303)
+
+# Contributors
+
+Thank you to all the contributors who made this release possible 🎉
+
+According to `git shortlog -sn --no-merges 3.3.1-RC4..3.3.1-RC5` these are:
+
+```
+     5 Dale Wijnand
+     2 Martin Odersky
+     2 Paweł Marks
+     1 Jan Chyb
+     1 Nicolas Stucki
+```

From 059748245f9e0816a8f9d837b0b2625956853aa5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Marks?= <pmarks@virtuslab.com>
Date: Thu, 10 Aug 2023 09:19:25 +0200
Subject: [PATCH 645/657] Release 3.3.1-RC5

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

diff --git a/project/Build.scala b/project/Build.scala
index a60932eb9e30..b1c6e63cef9d 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -82,7 +82,7 @@ object Build {
 
   val referenceVersion = "3.3.0"
 
-  val baseVersion = "3.3.1-RC4"
+  val baseVersion = "3.3.1-RC5"
 
   // Versions used by the vscode extension to create a new project
   // This should be the latest published releases.
@@ -98,7 +98,7 @@ object Build {
    *  set to 3.1.3. If it is going to be 3.1.0, it must be set to the latest
    *  3.0.x release.
    */
-  val previousDottyVersion = "3.3.1-RC3"
+  val previousDottyVersion = "3.3.1-RC4"
 
   object CompatMode {
     final val BinaryCompatible = 0

From 8e9b7182f41d03f412b2f2db0c8414f1411aa70c Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Thu, 13 Jul 2023 20:42:43 +0200
Subject: [PATCH 646/657] Refine infoDependsOnPrefix

infoDependsOnPrefix now also considers non-final term members. Before
8d65f19 it only considered abstract types. Constructors were classified
as non-final, which caused regression. We now exclude constructors
specifically. Maybe we should instead classify them as effectively final.

Fixes #18160
---
 .../src/dotty/tools/dotc/core/Types.scala     |  1 +
 .../tools/dotc/transform/TreeChecker.scala    |  2 +-
 tests/pos/i18160/Test_2.scala                 | 11 ++++++++
 tests/pos/i18160/repro_1.scala                | 25 +++++++++++++++++++
 4 files changed, 38 insertions(+), 1 deletion(-)
 create mode 100644 tests/pos/i18160/Test_2.scala
 create mode 100644 tests/pos/i18160/repro_1.scala

diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index bb4fd02816a6..81fc28a32fec 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -2537,6 +2537,7 @@ object Types {
           (symd.isAbstractType
             || symd.isTerm
                 && !symd.flagsUNSAFE.isOneOf(Module | Final | Param)
+                && !symd.isConstructor
                 && !symd.maybeOwner.isEffectivelyFinal)
           && prefix.sameThis(symd.maybeOwner.thisType)
           && refines(givenSelfTypeOrCompleter(prefix.cls), symd.name)
diff --git a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
index e50fb9d8b09c..34b3183a6b15 100644
--- a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
@@ -544,7 +544,7 @@ object TreeChecker {
       val TypeDef(_, impl @ Template(constr, _, _, _)) = cdef: @unchecked
       assert(cdef.symbol == cls)
       assert(impl.symbol.owner == cls)
-      assert(constr.symbol.owner == cls)
+      assert(constr.symbol.owner == cls, i"constr ${constr.symbol} in $cdef has wrong owner; should be $cls but is ${constr.symbol.owner}")
       assert(cls.primaryConstructor == constr.symbol, i"mismatch, primary constructor ${cls.primaryConstructor}, in tree = ${constr.symbol}")
       checkOwner(impl)
       checkOwner(impl.constr)
diff --git a/tests/pos/i18160/Test_2.scala b/tests/pos/i18160/Test_2.scala
new file mode 100644
index 000000000000..9ee40c3d37f9
--- /dev/null
+++ b/tests/pos/i18160/Test_2.scala
@@ -0,0 +1,11 @@
+class SynchronizedReevaluation
+class SynchronizedReevaluationApi[Api <: RescalaInterface](val api: Api){
+  import api._
+
+  def SynchronizedReevaluation[A](evt: Event[A])(implicit
+      turnSource: CreationTicket
+  ): (SynchronizedReevaluation, Event[A]) = {
+    val sync = new SynchronizedReevaluation
+    (sync, evt.map(identity)(turnSource))
+  }
+}
diff --git a/tests/pos/i18160/repro_1.scala b/tests/pos/i18160/repro_1.scala
new file mode 100644
index 000000000000..060f2d325d2d
--- /dev/null
+++ b/tests/pos/i18160/repro_1.scala
@@ -0,0 +1,25 @@
+object core {
+  final class CreationTicket[State[_]]
+}
+
+trait ReadAs[S[_], +A] { type State[V] = S[V] }
+
+trait EventCompatBundle {
+  bundle: Operators =>
+
+  trait EventCompat[+T] extends ReadAs[State, Option[T]] {
+    selfType: Event[T] =>
+    final inline def map[B](inline expression: T => B)(implicit ticket: CreationTicket): Event[B] =  ???
+  }
+}
+
+trait EventBundle extends EventCompatBundle { self: Operators =>
+  trait Event[+T] extends EventCompat[T]:
+    final override type State[V] = self.State[V]
+}
+trait Operators extends EventBundle {
+  type State[_]
+  type CreationTicket = core.CreationTicket[State]
+}
+trait RescalaInterface extends Operators
+

From d2a0b3cd298ec45ef34942b23829f305cfca6d96 Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Thu, 13 Jul 2023 20:53:37 +0200
Subject: [PATCH 647/657] Make constructors effectively final

This is mainly a cleanup.
---
 compiler/src/dotty/tools/dotc/core/SymDenotations.scala | 1 +
 compiler/src/dotty/tools/dotc/transform/init/Util.scala | 6 ++----
 compiler/src/dotty/tools/dotc/typer/RefChecks.scala     | 2 +-
 3 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
index 988a37be4388..b8c17ff61e9e 100644
--- a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -1196,6 +1196,7 @@ object SymDenotations {
       isOneOf(EffectivelyFinalFlags)
       || is(Inline, butNot = Deferred)
       || is(JavaDefinedVal, butNot = Method)
+      || isConstructor
       || !owner.isExtensibleClass
 
     /** A class is effectively sealed if has the `final` or `sealed` modifier, or it
diff --git a/compiler/src/dotty/tools/dotc/transform/init/Util.scala b/compiler/src/dotty/tools/dotc/transform/init/Util.scala
index 4e60c1325b09..ba2216504aef 100644
--- a/compiler/src/dotty/tools/dotc/transform/init/Util.scala
+++ b/compiler/src/dotty/tools/dotc/transform/init/Util.scala
@@ -75,11 +75,9 @@ object Util:
       case _ =>
         None
 
-  def resolve(cls: ClassSymbol, sym: Symbol)(using Context): Symbol = log("resove " + cls + ", " + sym, printer, (_: Symbol).show) {
-    if (sym.isEffectivelyFinal || sym.isConstructor) sym
+  def resolve(cls: ClassSymbol, sym: Symbol)(using Context): Symbol = log("resove " + cls + ", " + sym, printer, (_: Symbol).show):
+    if sym.isEffectivelyFinal then sym
     else sym.matchingMember(cls.appliedRef)
-  }
-
 
   extension (sym: Symbol)
     def hasSource(using Context): Boolean = !sym.defTree.isEmpty
diff --git a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
index fe28a8b18833..025eae3606af 100644
--- a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
+++ b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
@@ -1689,7 +1689,7 @@ class RefChecks extends MiniPhase { thisPhase =>
             // if (settings.warnNullaryUnit)
             //  checkNullaryMethodReturnType(sym)
             // if (settings.warnInaccessible) {
-            //  if (!sym.isConstructor && !sym.isEffectivelyFinal && !sym.isSynthetic)
+            //  if (!sym.isEffectivelyFinal && !sym.isSynthetic)
             //    checkAccessibilityOfReferencedTypes(tree)
             // }
             // tree match {

From 0305d8878a7dbbbc0ff398cdec0fc079f067280f Mon Sep 17 00:00:00 2001
From: Nicolas Stucki <nicolas.stucki@gmail.com>
Date: Tue, 25 Jul 2023 15:29:29 +0200
Subject: [PATCH 648/657] Do not compute `protoFormal` if `param.tpt` is empty

This was accidentally moved before of the `if (!param.tpt.isEmpty)` guard in https://github.com/lampepfl/dotty/commit/0f7c3abc3706b2054c48f3b16991741edb3a4610#diff-8c9ece1772bd78160fc1c31e988664586c9df566a1d22ff99ef99dd6d5627a90R1534

Fixes #18276
---
 .../src/dotty/tools/dotc/typer/Typer.scala    | 49 +++++++++----------
 tests/pos/i18276a.scala                       | 15 ++++++
 tests/pos/i18276b.scala                       |  9 ++++
 3 files changed, 48 insertions(+), 25 deletions(-)
 create mode 100644 tests/pos/i18276a.scala
 create mode 100644 tests/pos/i18276b.scala

diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index cb23262d1410..74be1dee9a9b 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -1596,32 +1596,31 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
     if desugared.isEmpty then
       val inferredParams: List[untpd.ValDef] =
         for ((param, i) <- params.zipWithIndex) yield
-          val (formalBounds, isErased) = protoFormal(i)
-          val param0 =
-            if (!param.tpt.isEmpty) param
-            else
-              val formal = formalBounds.loBound
-              val isBottomFromWildcard = (formalBounds ne formal) && formal.isExactlyNothing
-              val knownFormal = isFullyDefined(formal, ForceDegree.failBottom)
-              // If the expected formal is a TypeBounds wildcard argument with Nothing as lower bound,
-              // try to prioritize inferring from target. See issue 16405 (tests/run/16405.scala)
-              val paramType =
-                // Strip inferred erased annotation, to avoid accidentally inferring erasedness
-                val formal0 = if !isErased then formal.stripAnnots(_.symbol != defn.ErasedParamAnnot) else formal
-                if knownFormal && !isBottomFromWildcard then
-                  formal0
-                else
-                  inferredFromTarget(param, formal, calleeType, isErased, paramIndex).orElse(
-                    if knownFormal then formal0
-                    else 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)
+          if (!param.tpt.isEmpty) param
+          else
+            val (formalBounds, isErased) = protoFormal(i)
+            val formal = formalBounds.loBound
+            val isBottomFromWildcard = (formalBounds ne formal) && formal.isExactlyNothing
+            val knownFormal = isFullyDefined(formal, ForceDegree.failBottom)
+            // If the expected formal is a TypeBounds wildcard argument with Nothing as lower bound,
+            // try to prioritize inferring from target. See issue 16405 (tests/run/16405.scala)
+            val paramType =
+              // Strip inferred erased annotation, to avoid accidentally inferring erasedness
+              val formal0 = if !isErased then formal.stripAnnots(_.symbol != defn.ErasedParamAnnot) else formal
+              if knownFormal && !isBottomFromWildcard then
+                formal0
+              else
+                inferredFromTarget(param, formal, calleeType, isErased, paramIndex).orElse(
+                  if knownFormal then formal0
+                  else errorType(AnonymousFunctionMissingParamType(param, tree, formal), param.srcPos)
                 )
-              cpy.ValDef(param)(tpt = paramTpt)
-          if isErased then param0.withAddedFlags(Flags.Erased) else param0
+            val paramTpt = untpd.TypedSplice(
+                (if knownFormal then InferredTypeTree() else untpd.TypeTree())
+                  .withType(paramType.translateFromRepeated(toArray = false))
+                  .withSpan(param.span.endPos)
+              )
+            val param0 = cpy.ValDef(param)(tpt = paramTpt)
+            if isErased then param0.withAddedFlags(Flags.Erased) else param0
       desugared = desugar.makeClosure(inferredParams, fnBody, resultTpt, isContextual, tree.span)
 
     typed(desugared, pt)
diff --git a/tests/pos/i18276a.scala b/tests/pos/i18276a.scala
new file mode 100644
index 000000000000..46c2722fd8be
--- /dev/null
+++ b/tests/pos/i18276a.scala
@@ -0,0 +1,15 @@
+import scala.language.implicitConversions
+
+case class Assign(left: String, right: String)
+class SyntaxAnalyser extends ParsersBase {
+  val x: Parser[String ~ String] = ???
+  val y: Parser[Assign] = x.map(Assign.apply)
+}
+
+class ParsersBase {
+  trait ~[+T, +U]
+  abstract class Parser[+T]:
+    def map[U](f: T => U): Parser[U] = ???
+
+  given [A, B, X]: Conversion[(A, B) => X, (A ~ B) => X] = ???
+}
diff --git a/tests/pos/i18276b.scala b/tests/pos/i18276b.scala
new file mode 100644
index 000000000000..a4d905293472
--- /dev/null
+++ b/tests/pos/i18276b.scala
@@ -0,0 +1,9 @@
+import scala.language.implicitConversions
+
+def foo(a: Int): Int = ???
+def bar(f: () => Int): Int = ???
+
+given f: Conversion[Int => Int, () => Int] = ???
+
+def test1: Int = bar(foo) // implicit conversion applied to foo
+def test2: Int = bar(f(foo))

From 6bf8ac95d677bda402cb5ef44f15400b82481e69 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Marks?= <pmarks@virtuslab.com>
Date: Mon, 21 Aug 2023 17:20:00 +0200
Subject: [PATCH 649/657] Revert "Normalize match type usage during implicit
 lookup"

This reverts commit 5bafff7cc96f1f31f6e77620ca509dfa55d816b4.
---
 .../dotty/tools/dotc/core/TypeComparer.scala  |  2 +-
 .../dotty/tools/dotc/core/TypeErrors.scala    |  3 ---
 .../dotty/tools/dotc/typer/Implicits.scala    |  7 ------
 tests/pos/i17395.scala                        | 25 -------------------
 4 files changed, 1 insertion(+), 36 deletions(-)
 delete mode 100644 tests/pos/i17395.scala

diff --git a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
index b84af998ffb6..6857e3da38ed 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
@@ -3180,7 +3180,7 @@ class TrackingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
             tp
       case Nil =>
         val casesText = MatchTypeTrace.noMatchesText(scrut, cases)
-        throw MatchTypeReductionError(em"Match type reduction $casesText")
+        throw TypeError(em"Match type reduction $casesText")
 
     inFrozenConstraint {
       // Empty types break the basic assumption that if a scrutinee and a
diff --git a/compiler/src/dotty/tools/dotc/core/TypeErrors.scala b/compiler/src/dotty/tools/dotc/core/TypeErrors.scala
index f59bd08da779..24a207da6836 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeErrors.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeErrors.scala
@@ -46,9 +46,6 @@ object TypeError:
     def toMessage(using Context) = msg
 end TypeError
 
-class MatchTypeReductionError(msg: Message)(using Context) extends TypeError:
-  def toMessage(using Context) = msg
-
 class MalformedType(pre: Type, denot: Denotation, absMembers: Set[Name])(using Context) 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(", ")}"
 
diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
index 66f400d7eae0..4bbd6ee080b6 100644
--- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -636,13 +636,6 @@ trait ImplicitRunInfo:
             case t: TypeLambda =>
               for p <- t.paramRefs do partSeen += p
               traverseChildren(t)
-            case t: MatchType =>
-              traverseChildren(t)
-              traverse(try t.normalized catch case _: MatchTypeReductionError => t)
-            case MatchType.InDisguise(mt)
-                if !t.isInstanceOf[LazyRef] // skip recursive applications (eg. Tuple.Map)
-            =>
-              traverse(mt)
             case t =>
               traverseChildren(t)
 
diff --git a/tests/pos/i17395.scala b/tests/pos/i17395.scala
deleted file mode 100644
index 87c0a45a9ff5..000000000000
--- a/tests/pos/i17395.scala
+++ /dev/null
@@ -1,25 +0,0 @@
-trait TC[T]
-
-object TC {
-  def optionTCForPart[T](implicit tc: TC[ExtractPart[T]]): TC[Option[ExtractPart[T]]] = new TC[Option[ExtractPart[T]]] {}
-}
-
-type ExtractPart[T] = T match {
-  case PartField[t] => t
-}
-type PartField[T] = Any { type Part = T }
-
-class ValuePartHolder {
-  type Part = Value
-}
-
-class Value
-object Value {
-  implicit val tcValue: TC[Value] = new {}
-}
-
-@main def main(): Unit = {
-//  import Value.tcValue // explicit import works around the issue, but shouldn't be necessary
-  val tc = TC.optionTCForPart[ValuePartHolder]
-  println(tc)
-}

From 340303fb983405cd6b123458f3573b3cf1505c23 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Marks?= <pmarks@virtuslab.com>
Date: Tue, 22 Aug 2023 13:18:45 +0200
Subject: [PATCH 650/657] Add changelog for 3.3.1-RC6

---
 changelogs/3.3.1-RC6.md | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 changelogs/3.3.1-RC6.md

diff --git a/changelogs/3.3.1-RC6.md b/changelogs/3.3.1-RC6.md
new file mode 100644
index 000000000000..f74ab7fe7e18
--- /dev/null
+++ b/changelogs/3.3.1-RC6.md
@@ -0,0 +1,17 @@
+# Backported fixes
+
+- Refine `infoDependsOnPrefix` [#18204](https://github.com/lampepfl/dotty/pull/18204)
+- FDo not compute `protoFormal` if `param.tpt` is empty [#18288](http://github.com/lampepfl/dotty/pull/18288)
+- Revert "Normalize match type usage during implicit lookup" [#18440](http://github.com/lampepfl/dotty/pull/18440)
+
+# Contributors
+
+Thank you to all the contributors who made this release possible 🎉
+
+According to `git shortlog -sn --no-merges 3.3.1-RC4..3.3.1-RC5` these are:
+
+```
+     3	Paweł Marks
+     2	Martin Odersky
+     1	Nicolas Stucki
+```

From 5f8485e13b66b6d64b8e52161b5de10699900543 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Marks?= <pmarks@virtuslab.com>
Date: Tue, 22 Aug 2023 13:14:01 +0200
Subject: [PATCH 651/657] Release 3.3.1-RC6

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

diff --git a/project/Build.scala b/project/Build.scala
index b1c6e63cef9d..047310df0a6b 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -82,7 +82,7 @@ object Build {
 
   val referenceVersion = "3.3.0"
 
-  val baseVersion = "3.3.1-RC5"
+  val baseVersion = "3.3.1-RC6"
 
   // Versions used by the vscode extension to create a new project
   // This should be the latest published releases.
@@ -98,7 +98,7 @@ object Build {
    *  set to 3.1.3. If it is going to be 3.1.0, it must be set to the latest
    *  3.0.x release.
    */
-  val previousDottyVersion = "3.3.1-RC4"
+  val previousDottyVersion = "3.3.1-RC5"
 
   object CompatMode {
     final val BinaryCompatible = 0

From 88e6725df9fc73d9894d8ae8205a54ca8d47851d Mon Sep 17 00:00:00 2001
From: odersky <odersky@gmail.com>
Date: Mon, 28 Aug 2023 16:55:10 +0200
Subject: [PATCH 652/657] Tweak selection from self types

Previously, we rejected the case where a symbol of a self type selection
was private if was not of the enclosing class. But that symbol could shadow
a non-private symbol in a base class, so have to treat that case as well.

Fixes #18631
---
 compiler/src/dotty/tools/dotc/core/Types.scala |  7 ++++++-
 tests/pos/i18361.scala                         | 15 +++++++++++++++
 2 files changed, 21 insertions(+), 1 deletion(-)
 create mode 100644 tests/pos/i18361.scala

diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index 81fc28a32fec..fb66d133c0ba 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -808,9 +808,14 @@ object Types {
             // 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
+            d.match
               case d: SingleDenotation => if qualifies(d) then d else NoDenotation
               case d => d.filterWithPredicate(qualifies)
+            .orElse:
+              // Only inaccessible private symbols were found. But there could still be
+              // shadowed non-private symbols, so as a fallback search for those.
+              // Test case is i18361.scala.
+              findMember(name, pre, required, excluded | Private)
           else d
         else
           // There is a special case to handle:
diff --git a/tests/pos/i18361.scala b/tests/pos/i18361.scala
new file mode 100644
index 000000000000..a84d5f0a09db
--- /dev/null
+++ b/tests/pos/i18361.scala
@@ -0,0 +1,15 @@
+package test1:
+  class Service(val name: String)
+  class CrudService(name: String) extends Service(name)
+
+  trait Foo { self: CrudService =>
+    val x = self.name
+  }
+
+package test2:
+  abstract class Service[F[_]](val name: String)
+  abstract class CrudService[F[_]](name: String) extends Service[F](name)
+
+  trait Foo[F[_]] { self: CrudService[?] =>
+    val x = self.name
+  }

From fb6545872968e90798c5a411e69b79670df8e0fe Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Marks?= <pmarks@virtuslab.com>
Date: Tue, 29 Aug 2023 11:34:58 +0200
Subject: [PATCH 653/657] Revert "Add reflect `defn.FunctionClass` overloads"

This reverts commit 9571b42a2ff63e897cb566c09259f5f8d1e7a021.
---
 .../quoted/runtime/impl/QuotesImpl.scala      |  4 ---
 library/src/scala/quoted/Quotes.scala         | 19 --------------
 .../stdlibExperimentalDefinitions.scala       |  2 --
 tests/run-macros/tasty-definitions-1.check    | 26 -------------------
 .../tasty-definitions-1/quoted_1.scala        |  1 -
 5 files changed, 52 deletions(-)

diff --git a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
index e178dc81b1a3..db4e3e6c6a05 100644
--- a/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
+++ b/compiler/src/scala/quoted/runtime/impl/QuotesImpl.scala
@@ -2811,10 +2811,6 @@ class QuotesImpl private (using val ctx: Context) extends Quotes, QuoteUnpickler
         if isErased then
           throw new Exception("Erased function classes are not supported. Use a refined `scala.runtime.ErasedFunction`")
         else dotc.core.Symbols.defn.FunctionSymbol(arity, isImplicit)
-      def FunctionClass(arity: Int): Symbol =
-        FunctionClass(arity, false, false)
-      def FunctionClass(arity: Int, isContextual: Boolean): Symbol =
-        FunctionClass(arity, isContextual, false)
       def ErasedFunctionClass = dotc.core.Symbols.defn.ErasedFunctionClass
       def TupleClass(arity: Int): Symbol =
         dotc.core.Symbols.defn.TupleType(arity).nn.classSymbol.asClass
diff --git a/library/src/scala/quoted/Quotes.scala b/library/src/scala/quoted/Quotes.scala
index c7d5719b0e1f..b6e5a12da2d8 100644
--- a/library/src/scala/quoted/Quotes.scala
+++ b/library/src/scala/quoted/Quotes.scala
@@ -4295,27 +4295,8 @@ trait Quotes { self: runtime.QuoteUnpickler & runtime.QuoteMatching =>
       *   -  ...
       *   -  Nth element is `FunctionN`
       */
-      // TODO: deprecate in 3.4 and stabilize FunctionClass(Int)/FunctionClass(Int,Boolean)
-      // @deprecated("Use overload of `FunctionClass` with 1 or 2 arguments","3.4")
       def FunctionClass(arity: Int, isImplicit: Boolean = false, isErased: Boolean = false): Symbol
 
-      /** Class symbol of a function class `scala.FunctionN`.
-       *
-       *  @param arity the arity of the function where `0 <= arity`
-       *  @return class symbol of `scala.FunctionN` where `N == arity`
-       */
-      @experimental
-      def FunctionClass(arity: Int): Symbol
-
-      /** Class symbol of a context function class `scala.FunctionN` or `scala.ContextFunctionN`.
-       *
-       *  @param arity the arity of the function where `0 <= arity`
-       *  @param isContextual if it is a `scala.ContextFunctionN`
-       *  @return class symbol of `scala.FunctionN` or `scala.ContextFunctionN` where `N == arity`
-       */
-      @experimental
-      def FunctionClass(arity: Int, isContextual: Boolean): Symbol
-
       /** The `scala.runtime.ErasedFunction` built-in trait. */
       @experimental
       def ErasedFunctionClass: Symbol
diff --git a/tests/run-custom-args/tasty-inspector/stdlibExperimentalDefinitions.scala b/tests/run-custom-args/tasty-inspector/stdlibExperimentalDefinitions.scala
index 644efb54c32e..5ccdb753e9b3 100644
--- a/tests/run-custom-args/tasty-inspector/stdlibExperimentalDefinitions.scala
+++ b/tests/run-custom-args/tasty-inspector/stdlibExperimentalDefinitions.scala
@@ -63,8 +63,6 @@ val experimentalDefinitionInLibrary = Set(
   "scala.annotation.MacroAnnotation",
 
    //// New APIs: Quotes
-  // Should be stabilized in 3.4.0
-  "scala.quoted.Quotes.reflectModule.defnModule.FunctionClass",
   "scala.quoted.Quotes.reflectModule.FlagsModule.AbsOverride",
   // Can be stabilized in 3.4.0 (unsure) or later
   "scala.quoted.Quotes.reflectModule.CompilationInfoModule.XmacroSettings",
diff --git a/tests/run-macros/tasty-definitions-1.check b/tests/run-macros/tasty-definitions-1.check
index ce7251d7d3ee..4ac0e6267028 100644
--- a/tests/run-macros/tasty-definitions-1.check
+++ b/tests/run-macros/tasty-definitions-1.check
@@ -57,57 +57,31 @@ Function23
 Function24
 Function25
 ContextFunction0
-ContextFunction0
-ContextFunction1
 ContextFunction1
 ContextFunction2
-ContextFunction2
-ContextFunction3
 ContextFunction3
 ContextFunction4
-ContextFunction4
-ContextFunction5
 ContextFunction5
 ContextFunction6
-ContextFunction6
 ContextFunction7
-ContextFunction7
-ContextFunction8
 ContextFunction8
 ContextFunction9
-ContextFunction9
 ContextFunction10
-ContextFunction10
-ContextFunction11
 ContextFunction11
 ContextFunction12
-ContextFunction12
 ContextFunction13
-ContextFunction13
-ContextFunction14
 ContextFunction14
 ContextFunction15
-ContextFunction15
-ContextFunction16
 ContextFunction16
 ContextFunction17
-ContextFunction17
-ContextFunction18
 ContextFunction18
 ContextFunction19
-ContextFunction19
 ContextFunction20
-ContextFunction20
-ContextFunction21
 ContextFunction21
 ContextFunction22
-ContextFunction22
 ContextFunction23
-ContextFunction23
-ContextFunction24
 ContextFunction24
 ContextFunction25
-ContextFunction25
 class java.lang.Exception: Erased function classes are not supported. Use a refined `scala.runtime.ErasedFunction`
 ErasedFunction
 Tuple2
diff --git a/tests/run-macros/tasty-definitions-1/quoted_1.scala b/tests/run-macros/tasty-definitions-1/quoted_1.scala
index bf9e28288486..ed210706f567 100644
--- a/tests/run-macros/tasty-definitions-1/quoted_1.scala
+++ b/tests/run-macros/tasty-definitions-1/quoted_1.scala
@@ -60,7 +60,6 @@ object Macros {
       printout(defn.FunctionClass(i).name)
 
     for (i <- 0 to 25)
-      printout(defn.FunctionClass(i, isContextual = true).name)
       printout(defn.FunctionClass(i, isImplicit = true).name)
 
     // should fail

From 24cd50d2d66caeb0930032d3e23bb1a60fe02528 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Marks?= <pmarks@virtuslab.com>
Date: Tue, 29 Aug 2023 17:56:55 +0200
Subject: [PATCH 654/657] Add changelog for 3.3.1-RC7

---
 changelogs/3.3.1-RC7.md | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 changelogs/3.3.1-RC7.md

diff --git a/changelogs/3.3.1-RC7.md b/changelogs/3.3.1-RC7.md
new file mode 100644
index 000000000000..f8f093a18d11
--- /dev/null
+++ b/changelogs/3.3.1-RC7.md
@@ -0,0 +1,16 @@
+# Backported fixes
+
+- Tweak selection from self types [#18467](https://github.com/lampepfl/dotty/pull/18467)
+- Revert "Add reflect `defn.FunctionClass` overloads" [#18473](http://github.com/lampepfl/dotty/pull/18473)
+
+# Contributors
+
+Thank you to all the contributors who made this release possible 🎉
+
+According to `git shortlog -sn --no-merges 3.3.1-RC6..3.3.1-RC7` these are:
+
+```
+     3	Paweł Marks
+     1	Martin Odersky
+
+```

From ca005766359c27ea06adc18409b6e53f79732bd6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Marks?= <pmarks@virtuslab.com>
Date: Tue, 29 Aug 2023 17:58:04 +0200
Subject: [PATCH 655/657] Release 3.3.1-RC7

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

diff --git a/project/Build.scala b/project/Build.scala
index 047310df0a6b..f748ce44d4ca 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -82,7 +82,7 @@ object Build {
 
   val referenceVersion = "3.3.0"
 
-  val baseVersion = "3.3.1-RC6"
+  val baseVersion = "3.3.1-RC7"
 
   // Versions used by the vscode extension to create a new project
   // This should be the latest published releases.
@@ -98,7 +98,7 @@ object Build {
    *  set to 3.1.3. If it is going to be 3.1.0, it must be set to the latest
    *  3.0.x release.
    */
-  val previousDottyVersion = "3.3.1-RC5"
+  val previousDottyVersion = "3.3.1-RC6"
 
   object CompatMode {
     final val BinaryCompatible = 0

From 9b4ea8eb22dd96c94eb5d5c62cd0c0d277342a53 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Marks?= <pmarks@virtuslab.com>
Date: Tue, 5 Sep 2023 14:33:24 +0200
Subject: [PATCH 656/657] Add changelog for 3.3.1

Also fix typos in older changelogs
---
 changelogs/3.3.1-RC1.md |  15 ++-
 changelogs/3.3.1-RC6.md |   4 +-
 changelogs/3.3.1.md     | 287 ++++++++++++++++++++++++++++++++++++++++
 3 files changed, 302 insertions(+), 4 deletions(-)
 create mode 100644 changelogs/3.3.1.md

diff --git a/changelogs/3.3.1-RC1.md b/changelogs/3.3.1-RC1.md
index 4e52eb874891..e7d9f8f87ea9 100644
--- a/changelogs/3.3.1-RC1.md
+++ b/changelogs/3.3.1-RC1.md
@@ -42,6 +42,7 @@
 - Harden tpd.Apply/TypeApply in case of errors [#16887](https://github.com/lampepfl/dotty/pull/16887)
 - Try to be more subtle when inferring type parameters of class parents [#16896](https://github.com/lampepfl/dotty/pull/16896)
 - Include `P` in the implicit scope of `P.this.type` [#17088](https://github.com/lampepfl/dotty/pull/17088)
+- Do not compute `protoFormal` if `param.tpt` is empty [#18288](http://github.com/lampepfl/dotty/pull/18288)
 
 ## Incremental Compilation
 
@@ -71,7 +72,6 @@
 
 ## Match Types
 
-- Normalize match type usage during implicit lookup [#17457](https://github.com/lampepfl/dotty/pull/17457)
 - Fix #13757: Explicitly disallow higher-kinded scrutinees of match types. [#17322](https://github.com/lampepfl/dotty/pull/17322)
 - Fix match type reduction with wildcard type arguments [#17065](https://github.com/lampepfl/dotty/pull/17065)
 - Fix check whether classtag can be generated for match types [#16708](https://github.com/lampepfl/dotty/pull/16708)
@@ -86,6 +86,7 @@
 - Check outer class prefixes in type projections when pattern matching [#17136](https://github.com/lampepfl/dotty/pull/17136)
 - Make unchecked cases non-`@unchecked` and non-unreachable [#16958](https://github.com/lampepfl/dotty/pull/16958)
 - Fix #16899: Better handle X instanceOf P where X is T1 | T2 [#17382](https://github.com/lampepfl/dotty/pull/17382)
+- Fix regression in exhaustivity of HK types [#18303](http://github.com/lampepfl/dotty/pull/18303)
 
 ## Pickling
 
@@ -121,6 +122,7 @@
 - Only transform the body of the quote with QuoteTransformer [#17451](https://github.com/lampepfl/dotty/pull/17451)
 - Place staged type captures in Quote AST [#17424](https://github.com/lampepfl/dotty/pull/17424)
 - Add SplicePattern AST to parse and type quote pattern splices [#17396](https://github.com/lampepfl/dotty/pull/17396)
+- Dealias types in `New`` before matching quotes [#17615](https://github.com/lampepfl/dotty/pull/17615)
 
 ## Reflection
 
@@ -129,7 +131,6 @@
 - Fix reflect.LambdaType type test [#16972](https://github.com/lampepfl/dotty/pull/16972)
 - Improve `New`/`Select` -Ycheck message [#16746](https://github.com/lampepfl/dotty/pull/16746)
 - Improve error message for CyclicReference in macros [#16749](https://github.com/lampepfl/dotty/pull/16749)
-- Add reflect `defn.FunctionClass` overloads [#16849](https://github.com/lampepfl/dotty/pull/16849)
 
 ## REPL
 
@@ -222,6 +223,16 @@
 - Fix #16405 ctd - wildcards prematurely resolving to Nothing [#16764](https://github.com/lampepfl/dotty/pull/16764)
 - Test: add regression test for #7790 [#17473](https://github.com/lampepfl/dotty/pull/17473)
 - Properly handle `AnyVal`s as refinement members of `Selectable`s  [#16286](https://github.com/lampepfl/dotty/pull/16286)
+- Fix `accessibleType` for package object prefixes [#18057](https://github.com/lampepfl/dotty/pull/18057)
+- Add clause for protected visibility from package objects [#18134](https://github.com/lampepfl/dotty/pull/18134)
+- Revert "Include top-level symbols from same file in outer ambiguity error" [#17438](https://github.com/lampepfl/dotty/pull/17438)
+- Heal stage inconsistent prefixes of type projections [#18239](https://github.com/lampepfl/dotty/pull/18239)
+- Fix regression #17245: Overloaded methods with ClassTags [#18286](http://github.com/lampepfl/dotty/pull/18286)
+- Disallow taking singleton types of packages again [#18232](http://github.com/lampepfl/dotty/pull/18232)
+- A slightly more conservative version of #14218 [#18352](http://github.com/lampepfl/dotty/pull/18352)
+- Record failures to adapt application arguments [#18269](http://github.com/lampepfl/dotty/pull/18269)
+- Refine `infoDependsOnPrefix` [#18204](httpsF://github.com/lampepfl/dotty/pull/18204)
+- Tweak selection from self types [#18467](https://github.com/lampepfl/dotty/pull/18467)
 
 # Contributors
 
diff --git a/changelogs/3.3.1-RC6.md b/changelogs/3.3.1-RC6.md
index f74ab7fe7e18..96181855f1a0 100644
--- a/changelogs/3.3.1-RC6.md
+++ b/changelogs/3.3.1-RC6.md
@@ -1,14 +1,14 @@
 # Backported fixes
 
 - Refine `infoDependsOnPrefix` [#18204](https://github.com/lampepfl/dotty/pull/18204)
-- FDo not compute `protoFormal` if `param.tpt` is empty [#18288](http://github.com/lampepfl/dotty/pull/18288)
+- Do not compute `protoFormal` if `param.tpt` is empty [#18288](http://github.com/lampepfl/dotty/pull/18288)
 - Revert "Normalize match type usage during implicit lookup" [#18440](http://github.com/lampepfl/dotty/pull/18440)
 
 # Contributors
 
 Thank you to all the contributors who made this release possible 🎉
 
-According to `git shortlog -sn --no-merges 3.3.1-RC4..3.3.1-RC5` these are:
+According to `git shortlog -sn --no-merges 3.3.1-RC5..3.3.1-RC6` these are:
 
 ```
      3	Paweł Marks
diff --git a/changelogs/3.3.1.md b/changelogs/3.3.1.md
new file mode 100644
index 000000000000..5bbd6eb2861c
--- /dev/null
+++ b/changelogs/3.3.1.md
@@ -0,0 +1,287 @@
+# Highlights of the release
+
+- Support records in JavaParsers [#16762](https://github.com/lampepfl/dotty/pull/16762)
+- Port JVM backend refactor from Scala 2 [#15322](https://github.com/lampepfl/dotty/pull/15322)
+
+# Other changes and fixes
+
+## Backend
+
+- Disallow mixins where super calls bind to vals [#16908](https://github.com/lampepfl/dotty/pull/16908)
+- Fix #15107: Avoid re-emitting a LineNumber after only LabelNodes. [#16813](https://github.com/lampepfl/dotty/pull/16813)
+
+## Coverage
+
+- Fix #17042: Preserve the shape of secondary ctors in instrumentCoverage. [#17111](https://github.com/lampepfl/dotty/pull/17111)
+
+## Default parameters
+
+- Dupe fix when finding default arg getters [#17058](https://github.com/lampepfl/dotty/pull/17058)
+
+## Documentation
+
+- Fix: ensure syntax blocks for ebnf are marked as such [#16837](https://github.com/lampepfl/dotty/pull/16837)
+
+## Erasure
+
+- Handle `@companionClass` and `@companionMethod` meta-annotations [#17091](https://github.com/lampepfl/dotty/pull/17091)
+
+## Extension Methods
+
+- Support extension methods imported from different objects [#17050](https://github.com/lampepfl/dotty/pull/17050)
+
+## GADTs
+
+- Fix tuple member selection so it works with GADT healing [#16766](https://github.com/lampepfl/dotty/pull/16766)
+- Fix upper bound constraints, that are higher-kinded [#16744](https://github.com/lampepfl/dotty/pull/16744)
+- Split out immutable GadtConstraint [#16602](https://github.com/lampepfl/dotty/pull/16602)
+
+## Implicits
+
+- Improve subtyping check for not yet eta-expanded higher kinded types [#17139](https://github.com/lampepfl/dotty/pull/17139)
+- Harden tpd.Apply/TypeApply in case of errors [#16887](https://github.com/lampepfl/dotty/pull/16887)
+- Try to be more subtle when inferring type parameters of class parents [#16896](https://github.com/lampepfl/dotty/pull/16896)
+- Include `P` in the implicit scope of `P.this.type` [#17088](https://github.com/lampepfl/dotty/pull/17088)
+
+## Incremental Compilation
+
+- Fix under-compilation when the method type in a SAM changes [#16996](https://github.com/lampepfl/dotty/pull/16996)
+
+## Infrastructure
+
+- Set reference version to 3.3.0-RC6 [#17504](https://github.com/lampepfl/dotty/pull/17504)
+- Fix #17119: Download Coursier from GitHub directly [#17141](https://github.com/lampepfl/dotty/pull/17141)
+
+## Inline
+
+- Remove NamedArg from inlined arguments [#17228](https://github.com/lampepfl/dotty/pull/17228)
+- Don't generate a Select for a TermRef with NoPrefix [#16754](https://github.com/lampepfl/dotty/pull/16754)
+- Prepare bodies of inline forwarders eagerly [#16757](https://github.com/lampepfl/dotty/pull/16757)
+- Do not remove inline method implementations until PruneErasedDefs [#17408](https://github.com/lampepfl/dotty/pull/17408)
+
+## Java Interop
+
+- ClassfileParser: allow missing param names (for JDK 21) [#17536](https://github.com/lampepfl/dotty/pull/17536)
+
+## Linting
+
+- Improve -Wunused: locals, privates with unset vars warning #16639 [#17160](https://github.com/lampepfl/dotty/pull/17160)
+- Fix wunused false positive when deriving alias type [#17157](https://github.com/lampepfl/dotty/pull/17157)
+- Port `-Wnonunit-statement` setting for dotty [#16936](https://github.com/lampepfl/dotty/pull/16936)
+
+## Match Types
+
+- Normalize match type usage during implicit lookup [#17457](https://github.com/lampepfl/dotty/pull/17457)
+- Fix #13757: Explicitly disallow higher-kinded scrutinees of match types. [#17322](https://github.com/lampepfl/dotty/pull/17322)
+- Fix match type reduction with wildcard type arguments [#17065](https://github.com/lampepfl/dotty/pull/17065)
+- Fix check whether classtag can be generated for match types [#16708](https://github.com/lampepfl/dotty/pull/16708)
+
+## Parser
+
+- Allow lines starting with `.` to fall outside previous indentation widths [#17056](https://github.com/lampepfl/dotty/pull/17056)
+
+## Pattern Matching
+
+- Fix #11541: Specialize ClassTag[T] in exhaustivity check [#17385](https://github.com/lampepfl/dotty/pull/17385)
+- Check outer class prefixes in type projections when pattern matching [#17136](https://github.com/lampepfl/dotty/pull/17136)
+- Make unchecked cases non-`@unchecked` and non-unreachable [#16958](https://github.com/lampepfl/dotty/pull/16958)
+- Fix #16899: Better handle X instanceOf P where X is T1 | T2 [#17382](https://github.com/lampepfl/dotty/pull/17382)
+
+## Pickling
+
+- ClassfileParser: Avoid cycle when accessing companion in inner class lookup [#16882](https://github.com/lampepfl/dotty/pull/16882)
+
+## Polyfunctions
+
+- Fix type aliases in beta-reduction of polyfunctions [#17054](https://github.com/lampepfl/dotty/pull/17054)
+
+## Quotes
+
+- Register `paramProxy` and `thisProxy` in `Quote` type [#17541](https://github.com/lampepfl/dotty/pull/17541)
+- Only check newVal/newMethod privateWithin on -Xcheck-macros [#17437](https://github.com/lampepfl/dotty/pull/17437)
+- Unencode quote and splice trees [#17342](https://github.com/lampepfl/dotty/pull/17342)
+- Correctly type Expr.ofTupleFromSeq for arity > 22 [#17261](https://github.com/lampepfl/dotty/pull/17261)
+- Use TermRef to distinguish distinct Type[T] instances  [#17205](https://github.com/lampepfl/dotty/pull/17205)
+- Check level consistency of SingletonTypeTree as a type [#17209](https://github.com/lampepfl/dotty/pull/17209)
+- Fix splice type variable pattern detection [#17048](https://github.com/lampepfl/dotty/pull/17048)
+- Avoid creation of `@SplicedType` quote local refrences [#17051](https://github.com/lampepfl/dotty/pull/17051)
+- Dealias type references when healing types in quotes [#17049](https://github.com/lampepfl/dotty/pull/17049)
+- Replace quoted type variables in signature of HOAS pattern result  [#16951](https://github.com/lampepfl/dotty/pull/16951)
+- Beta-reduce directly applied PolymorphicFunction [#16623](https://github.com/lampepfl/dotty/pull/16623)
+- Use `Object.toString` for `quoted.{Expr, Type}` [#16663](https://github.com/lampepfl/dotty/pull/16663)
+- Fix Splicer.isEscapedVariable [#16838](https://github.com/lampepfl/dotty/pull/16838)
+- Fix references to class members defined in quotes [#17107](https://github.com/lampepfl/dotty/pull/17107)
+- Handle pickled forward references in pickled expressions [#16855](https://github.com/lampepfl/dotty/pull/16855)
+- Fix #16615 - crashes of path dependent types in spliced Type.of [#16773](https://github.com/lampepfl/dotty/pull/16773)
+- Disallow local term references in staged types [#16362](https://github.com/lampepfl/dotty/pull/16362)
+- Refactor level checking / type healing logic [#17082](https://github.com/lampepfl/dotty/pull/17082)
+- Dealias quoted types when staging [#17059](https://github.com/lampepfl/dotty/pull/17059)
+- Fix quotes with references to path dependent types [#17081](https://github.com/lampepfl/dotty/pull/17081)
+- Make arguments order in quote hole deterministic [#17405](https://github.com/lampepfl/dotty/pull/17405)
+- Only transform the body of the quote with QuoteTransformer [#17451](https://github.com/lampepfl/dotty/pull/17451)
+- Place staged type captures in Quote AST [#17424](https://github.com/lampepfl/dotty/pull/17424)
+- Add SplicePattern AST to parse and type quote pattern splices [#17396](https://github.com/lampepfl/dotty/pull/17396)
+
+## Reflection
+
+- -Xcheck-macros: add hint when a symbol in created twice [#16733](https://github.com/lampepfl/dotty/pull/16733)
+- Assert that symbols created using reflect API have correct privateWithin symbols [#17352](https://github.com/lampepfl/dotty/pull/17352)
+- Fix reflect.LambdaType type test [#16972](https://github.com/lampepfl/dotty/pull/16972)
+- Improve `New`/`Select` -Ycheck message [#16746](https://github.com/lampepfl/dotty/pull/16746)
+- Improve error message for CyclicReference in macros [#16749](https://github.com/lampepfl/dotty/pull/16749)
+- Add reflect `defn.FunctionClass` overloads [#16849](https://github.com/lampepfl/dotty/pull/16849)
+
+## REPL
+
+- Always load REPL classes in macros including the output directory [#16866](https://github.com/lampepfl/dotty/pull/16866)
+
+## Reporting
+
+- Improve missing argument list error [#17126](https://github.com/lampepfl/dotty/pull/17126)
+- Improve implicit parameter error message with aliases [#17125](https://github.com/lampepfl/dotty/pull/17125)
+- Improve "constructor proxy shadows outer" handling [#17154](https://github.com/lampepfl/dotty/pull/17154)
+- Clarify ambiguous reference error message [#16137](https://github.com/lampepfl/dotty/pull/16137)
+- Hint about forbidden combination of implicit values and conversions [#16735](https://github.com/lampepfl/dotty/pull/16735)
+- Attach explanation message to diagnostic message [#16787](https://github.com/lampepfl/dotty/pull/16787)
+- Propagate implicit search errors from implicit macros [#16840](https://github.com/lampepfl/dotty/pull/16840)
+- Detail UnapplyInvalidReturnType error message [#17167](https://github.com/lampepfl/dotty/pull/17167)
+- Add way to debug -Xcheck-macros tree checking [#16973](https://github.com/lampepfl/dotty/pull/16973)
+- Enrich and finesse compiler crash reporting [#17031](https://github.com/lampepfl/dotty/pull/17031)
+- Allow @implicitNotFound messages as explanations [#16893](https://github.com/lampepfl/dotty/pull/16893)
+- Include top-level symbols from same file in outer ambiguity error [#17033](https://github.com/lampepfl/dotty/pull/17033)
+- Do not issue deprecation warnings when declaring deprecated case classes [#17165](https://github.com/lampepfl/dotty/pull/17165)
+
+## Scala-JS
+
+- Fix #17344: Make implicit references to this above dynamic imports explicit. [#17357](https://github.com/lampepfl/dotty/pull/17357)
+- Fix #12621: Better error message for JS trait ctor param. [#16811](https://github.com/lampepfl/dotty/pull/16811)
+- Fix #16801: Handle Closure's of s.r.FunctionXXL. [#16809](https://github.com/lampepfl/dotty/pull/16809)
+- Fix #17549: Unify how Memoize and Constructors decide what fields need storing. [#17560](https://github.com/lampepfl/dotty/pull/17560)
+
+## Scaladoc
+
+- Feat: Add a blog configuration with yaml [#17214](https://github.com/lampepfl/dotty/pull/17214)
+- Don't render the "$" for module [#17302](https://github.com/lampepfl/dotty/pull/17302)
+- Fix: Add scrollbar to the sidebar [#17203](https://github.com/lampepfl/dotty/pull/17203)
+- Scaladoc: fix crash when processing extends call [#17260](https://github.com/lampepfl/dotty/pull/17260)
+- Fix: Modify the CSS so that the logo of the generated documentation is adaptive [#17172](https://github.com/lampepfl/dotty/pull/17172)
+- Fix: Remove the duplicate parameter when generating the scaladoc. [#17097](https://github.com/lampepfl/dotty/pull/17097)
+- Fix: padding top in mobile version [#17019](https://github.com/lampepfl/dotty/pull/17019)
+- Fix: tap target of the menu in Mobile version [#17018](https://github.com/lampepfl/dotty/pull/17018)
+- Scaladoc: Fix expand icon not changing on anchor link [#17053](https://github.com/lampepfl/dotty/pull/17053)
+- Scaladoc: fix inkuire generation for PolyTypes [#17129](https://github.com/lampepfl/dotty/pull/17129)
+- Re port scroll bar [#17463](https://github.com/lampepfl/dotty/pull/17463)
+- Handle empty files and truncated YAML front matter [#17527](https://github.com/lampepfl/dotty/pull/17527)
+
+## SemanticDB
+
+- Make sure symbol exists before calling owner [#16860](https://github.com/lampepfl/dotty/pull/16860)
+- Support LambdaType (convert from HKTypeLambda) [#16056](https://github.com/lampepfl/dotty/pull/16056)
+
+## Specification
+
+- Apply `class-shadowing.md` to the Spec [#16839](https://github.com/lampepfl/dotty/pull/16839)
+- Adding base for future Spec into the compiler repo [#16825](https://github.com/lampepfl/dotty/pull/16825)
+
+## Standard Library
+
+- Optimization: avoid NotGiven allocations [#17090](https://github.com/lampepfl/dotty/pull/17090)
+
+## Tooling
+
+- Disable `ExtractSemanticDB` phase when writing to output directory defined as JAR. [#16790](https://github.com/lampepfl/dotty/pull/16790)
+- Print owner of bind symbol with -Yprint-debug-owners [#16854](https://github.com/lampepfl/dotty/pull/16854)
+- Small fixes to allow using Metals with scaladoc with sbt [#16816](https://github.com/lampepfl/dotty/pull/16816)
+
+## Transform
+
+- Move CrossVersionChecks before FirstTransform [#17301](https://github.com/lampepfl/dotty/pull/17301)
+- Fix needsOuterIfReferenced [#17159](https://github.com/lampepfl/dotty/pull/17159)
+- Drop incorrect super accessor in trait subclass [#17062](https://github.com/lampepfl/dotty/pull/17062)
+- Generate toString only for synthetic companions of case classes [#16890](https://github.com/lampepfl/dotty/pull/16890)
+- Check trait constructor for accessibility even if not called at Typer [#17094](https://github.com/lampepfl/dotty/pull/17094)
+- Fix #17435: A simpler fix [#17436](https://github.com/lampepfl/dotty/pull/17436)
+
+## Typer
+
+- Preserve type bounds for inlined definitions in posttyper [#17190](https://github.com/lampepfl/dotty/pull/17190)
+- Change logic to find members of recursive types [#17386](https://github.com/lampepfl/dotty/pull/17386)
+- Recognize named arguments in isFunctionWithUnknownParamType [#17161](https://github.com/lampepfl/dotty/pull/17161)
+- Better comparisons for type projections [#17092](https://github.com/lampepfl/dotty/pull/17092)
+- Allow selectDynamic and applyDynamic to be extension methods [#17106](https://github.com/lampepfl/dotty/pull/17106)
+- Fix use of accessibleFrom when finding default arg getters [#16977](https://github.com/lampepfl/dotty/pull/16977)
+- Map class literal constant types [#16988](https://github.com/lampepfl/dotty/pull/16988)
+- Always use adapted type in withDenotation [#16901](https://github.com/lampepfl/dotty/pull/16901)
+- Restrict captureWildcards to only be used if needed [#16799](https://github.com/lampepfl/dotty/pull/16799)
+- Don't capture wildcards if in closure or by-name [#16732](https://github.com/lampepfl/dotty/pull/16732)
+- Infer: Don't minimise to Nothing if there's an upper bound [#16786](https://github.com/lampepfl/dotty/pull/16786)
+- Perform Matchable check only if type test is needed [#16824](https://github.com/lampepfl/dotty/pull/16824)
+- Don't eta expand unary varargs methods [#16892](https://github.com/lampepfl/dotty/pull/16892)
+- Fix beta-reduction with `Nothing` and `null` args [#16938](https://github.com/lampepfl/dotty/pull/16938)
+- Generate kind-correct wildcards when selecting from a wildcard [#17025](https://github.com/lampepfl/dotty/pull/17025)
+- Fix #16405 ctd - wildcards prematurely resolving to Nothing [#16764](https://github.com/lampepfl/dotty/pull/16764)
+- Test: add regression test for #7790 [#17473](https://github.com/lampepfl/dotty/pull/17473)
+- Properly handle `AnyVal`s as refinement members of `Selectable`s  [#16286](https://github.com/lampepfl/dotty/pull/16286)
+
+# Contributors
+
+Thank you to all the contributors who made this release possible 🎉
+
+According to `git shortlog -sn --no-merges 3.3.0..3.3.1` these are:
+
+```
+   152	Nicolas Stucki
+    73	Martin Odersky
+    54	Dale Wijnand
+    51	Szymon Rodziewicz
+    49	Quentin Bernet
+    38	Chris Kipp
+    31	Paweł Marks
+    19	David Hua
+    18	Lucas
+    18	ysthakur
+    15	Fengyun Liu
+    14	Guillaume Martres
+    14	Jamie Thompson
+    11	Sébastien Doeraene
+     9	Timothée Andres
+     8	Kacper Korban
+     7	Matt Bovel
+     7	Som Snytt
+     6	Julien Richard-Foy
+     6	Lucas Leblanc
+     5	Michał Pałka
+     4	Anatolii Kmetiuk
+     4	Guillaume Raffin
+     4	Jan Chyb
+     4	Paul Coral
+     4	Wojciech Mazur
+     4	Yichen Xu
+     3	Decel
+     2	Adrien Piquerez
+     2	Arman Bilge
+     2	Carl
+     2	Florian3k
+     2	Kenji Yoshida
+     2	Michael Pilquist
+     2	Natsu Kagami
+     2	Seth Tisue
+     2	Tomasz Godzik
+     2	Vasil Vasilev
+     2	Yadu Krishnan
+     1	Bersier
+     1	Flavio Brasil
+     1	Jan-Pieter van den Heuvel
+     1	Lukas Rytz
+     1	Miles Yucht
+     1	Mohammad Yousuf Minhaj Zia
+     1	Ondra Pelech
+     1	Philippus
+     1	Rikito Taniguchi
+     1	Simon R
+     1	brandonspark
+     1	github-actions[bot]
+     1	liang3zy22
+     1	s.bazarsadaev
+     1	Łukasz Wroński
+```

From 721e7c87ee95b811984b7b992728729d7094c4c4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Pawe=C5=82=20Marks?= <pmarks@virtuslab.com>
Date: Tue, 5 Sep 2023 14:35:21 +0200
Subject: [PATCH 657/657] Release 3.3.1

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

diff --git a/project/Build.scala b/project/Build.scala
index f748ce44d4ca..f3ec6bb54548 100644
--- a/project/Build.scala
+++ b/project/Build.scala
@@ -82,7 +82,7 @@ object Build {
 
   val referenceVersion = "3.3.0"
 
-  val baseVersion = "3.3.1-RC7"
+  val baseVersion = "3.3.1"
 
   // Versions used by the vscode extension to create a new project
   // This should be the latest published releases.
@@ -98,7 +98,7 @@ object Build {
    *  set to 3.1.3. If it is going to be 3.1.0, it must be set to the latest
    *  3.0.x release.
    */
-  val previousDottyVersion = "3.3.1-RC6"
+  val previousDottyVersion = "3.3.0"
 
   object CompatMode {
     final val BinaryCompatible = 0