Remove support -scala-output-version with quotes

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

@@ -827,9 +827,7 @@ class Definitions {
 
 
   @tu lazy val QuoteUnpicklerClass: ClassSymbol = requiredClass("scala.quoted.runtime.QuoteUnpickler")
-    @tu lazy val QuoteUnpickler_unpickleExpr: Symbol = QuoteUnpicklerClass.requiredMethod("unpickleExpr")
     @tu lazy val QuoteUnpickler_unpickleExprV2: Symbol = QuoteUnpicklerClass.requiredMethod("unpickleExprV2")
-    @tu lazy val QuoteUnpickler_unpickleType: Symbol = QuoteUnpicklerClass.requiredMethod("unpickleType")
     @tu lazy val QuoteUnpickler_unpickleTypeV2: Symbol = QuoteUnpicklerClass.requiredMethod("unpickleTypeV2")
 
   @tu lazy val QuoteMatchingClass: ClassSymbol = requiredClass("scala.quoted.runtime.QuoteMatching")

compiler/src/dotty/tools/dotc/quoted/PickledQuotes.scala

@@ -50,7 +50,7 @@ object PickledQuotes {
   /** `typeHole`/`types` argument of `QuoteUnpickler.{unpickleExpr,unpickleExprV2,unpickleType,unpickleTypeV2}` */
   enum TypeHole:
     /** `termHole` argument of `QuoteUnpickler.{unpickleExpr, unpickleType}`.
-     *  From code compiled with Scala 3.0.x and 3.1.x or with -scala-output-version 3.0 and 3.1
+     *  From code compiled with Scala 3.0.x and 3.1.x.
      *  Note: For `unpickleType` it will always be `null`.
      */
     case V1(evalHole: Null | ((Int, Seq[scala.quoted.Type[?]]) => scala.quoted.Type[?]))
@@ -65,7 +65,7 @@ object PickledQuotes {
 
   enum ExprHole:
     /** `termHole` argument of `QuoteUnpickler.{unpickleExpr, unpickleType}`.
-     *  From code compiled with Scala 3.0.x and 3.1.x or with -scala-output-version 3.0 and 3.1
+     *  From code compiled with Scala 3.0.x and 3.1.x.
      *  Note: For `unpickleType` it will always be `null`.
      */
     case V1(evalHole: Null | ((Int, Seq[ExprHole.ArgV1], scala.quoted.Quotes) => scala.quoted.Expr[?]))

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

@@ -291,9 +291,6 @@ object PickleQuotes {
       *  this closure is always applied directly to the actual context and the BetaReduce phase removes it.
       */
     def pickleAsTasty() = {
-
-      val unpickleV1 = ctx.scalaRelease <= Release3_1
-
       val pickleQuote = PickledQuotes.pickleQuote(body)
       val pickledQuoteStrings = pickleQuote match
         case x :: Nil => Literal(Constant(x))
@@ -306,26 +303,8 @@ object PickleQuotes {
 
       // This and all closures in typeSplices are removed by the BetaReduce phase
       val types =
-        if unpickleV1 then
-          if typeSplices.isEmpty then Literal(Constant(null)) // keep pickled quote without contents as small as possible
-          else
-            Lambda(
-              MethodType(
-                List(nme.idx, nme.contents).map(name => UniqueName.fresh(name).toTermName),
-                List(defn.IntType, defn.SeqType.appliedTo(defn.AnyType)),
-                defn.QuotedTypeClass.typeRef.appliedTo(WildcardType)),
-              args => {
-                val cases = typeSplices.map { case (splice, idx) =>
-                  CaseDef(Literal(Constant(idx)), EmptyTree, splice)
-                }
-                cases match
-                  case CaseDef(_, _, rhs) :: Nil => rhs
-                  case _ => Match(args(0).annotated(New(ref(defn.UncheckedAnnot.typeRef))), cases)
-              }
-            )
-          else // if unpickleV2 then
-            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 typeSplices.isEmpty then Literal(Constant(null)) // keep pickled quote without contents as small as possible
+        else SeqLiteral(typeSplices.map(_._1), TypeTree(defn.QuotedTypeClass.typeRef.appliedTo(WildcardType)))
 
       // This and all closures in termSplices are removed by the BetaReduce phase
       val termHoles =
@@ -341,12 +320,7 @@ object PickleQuotes {
                 val defn.FunctionOf(argTypes, defn.FunctionOf(quotesType :: _, _, _, _), _, _) = splice.tpe
                 val rhs = {
                   val spliceArgs = argTypes.zipWithIndex.map { (argType, i) =>
-                    val argi = args(1).select(nme.apply).appliedTo(Literal(Constant(i)))
-                    if unpickleV1 && argType.derivesFrom(defn.QuotedExprClass) then
-                      val argType1 = defn.FunctionType(1).appliedTo(defn.QuotesClass.typeRef, argType)
-                      argi.asInstance(argType1).select(nme.apply).appliedTo(args(2))
-                    else
-                      argi.asInstance(argType)
+                    args(1).select(nme.apply).appliedTo(Literal(Constant(i))).asInstance(argType)
                   }
                   val Block(List(ddef: DefDef), _) = splice
                   // TODO: beta reduce inner closure? Or wait until BetaReduce phase?
@@ -363,14 +337,10 @@ object PickleQuotes {
       val quotedType = quoteClass.typeRef.appliedTo(originalTp)
       val lambdaTpe = MethodType(defn.QuotesClass.typeRef :: Nil, quotedType)
       val unpickleMeth =
-        if unpickleV1 then
-          if isType then defn.QuoteUnpickler_unpickleType
-          else defn.QuoteUnpickler_unpickleExpr
-        else // if unpickleV2 then
-          if isType then defn.QuoteUnpickler_unpickleTypeV2
-          else defn.QuoteUnpickler_unpickleExprV2
+        if isType then defn.QuoteUnpickler_unpickleTypeV2
+        else defn.QuoteUnpickler_unpickleExprV2
       val unpickleArgs =
-        if isType && !unpickleV1 then List(pickledQuoteStrings, types)
+        if isType then List(pickledQuoteStrings, types)
         else List(pickledQuoteStrings, types, termHoles)
       quotes
         .asInstance(defn.QuoteUnpicklerClass.typeRef)

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

@@ -135,13 +135,7 @@ class Splicing extends MacroTransform:
               val hole = tpd.Hole(false, holeIdx, Nil, ref(qual), TypeTree(tp))
               typeHoles.put(qual.symbol, hole)
               hole
-          val rhs =
-            if ctx.scalaRelease <= Release3_1 then
-              val secondHoleIdx = numHoles
-              numHoles += 1
-              TypeBoundsTree(hole, cpy.Hole(hole)(idx = secondHoleIdx))
-            else hole
-          cpy.TypeDef(tree)(rhs = rhs)
+          cpy.TypeDef(tree)(rhs = hole)
         case Apply(Select(Apply(TypeApply(fn,_), List(code)),nme.apply),List(quotes))
         if fn.symbol == defn.QuotedRuntime_exprQuote =>
           super.transform(tree)(using quoteContext)