Align case class unapply under -Yscala2-stdlib

Author: nicolasstucki

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -735,13 +735,25 @@ object desugar {
               .withMods(appMods) :: Nil
           }
         val unapplyMeth = {
+          def scala2LibCompatUnapplyRhs(unapplyParamName: Name) =
+            assert(arity <= Definitions.MaxTupleArity, "Unexpected case class with tuple larger than 22: "+ cdef.show)
+            if arity == 1 then Apply(scalaDot(nme.Option), Select(Ident(unapplyParamName), nme._1))
+            else
+              val tupleApply = Select(Ident(nme.scala), s"Tuple$arity".toTermName)
+              val members = List.tabulate(arity) { n => Select(Ident(unapplyParamName), s"_${n+1}".toTermName) }
+              Apply(scalaDot(nme.Option), Apply(tupleApply, members))
+
           val hasRepeatedParam = constrVparamss.head.exists {
             case ValDef(_, tpt, _) => isRepeated(tpt)
           }
           val methName = if (hasRepeatedParam) nme.unapplySeq else nme.unapply
           val unapplyParam = makeSyntheticParameter(tpt = classTypeRef)
-          val unapplyRHS = if (arity == 0) Literal(Constant(true)) else Ident(unapplyParam.name)
+          val unapplyRHS =
+            if (arity == 0) Literal(Constant(true))
+            else if ctx.settings.Yscala2Stdlib.value then scala2LibCompatUnapplyRhs(unapplyParam.name)
+            else Ident(unapplyParam.name)
           val unapplyResTp = if (arity == 0) Literal(Constant(true)) else TypeTree()
+
           DefDef(
             methName,
             joinParams(derivedTparams, (unapplyParam :: Nil) :: Nil),

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

@@ -177,6 +177,7 @@ object StdNames {
     final val typeTag: N    = "typeTag"
     final val Expr: N       = "Expr"
     final val String: N     = "String"
+    final val Option: N     = "Option"
     final val Annotation: N = "Annotation"
 
     // fictions we use as both types and terms

project/MiMaFilters.scala

@@ -75,9 +75,6 @@ object MiMaFilters {
         // trait $init$
         ProblemFilters.exclude[DirectMissingMethodProblem]("scala.*.$init$"),
 
-        // Case class unapply
-        ProblemFilters.exclude[IncompatibleResultTypeProblem]("scala.*.unapply"),
-
         // Value class extension methods
         ProblemFilters.exclude[DirectMissingMethodProblem]("scala.*$extension"),
         ProblemFilters.exclude[IncompatibleResultTypeProblem]("scala.*$extension"),
@@ -188,9 +185,6 @@ object MiMaFilters {
         // Companion module class: Missing type java.io.Serializable
         ProblemFilters.exclude[MissingTypesProblem]("scala.*$"),
 
-        // Case class unapply
-        ProblemFilters.exclude[IncompatibleResultTypeProblem]("scala.*.unapply"),
-
         // Mirrors
         ProblemFilters.exclude[DirectMissingMethodProblem]("scala.*.ordinal"),
         ProblemFilters.exclude[DirectMissingMethodProblem]("scala.*.fromProduct"),

stdlib-bootstrapped/test/Main.scala

@@ -1,5 +1,7 @@
 package hello
 
+import scala.util.Right
+
 enum Color:
   case Red, Green, Blue
 
@@ -9,4 +11,16 @@ object HelloWorld:
     println(Color.Red)
     println(Color.Green)
     println(Color.Blue)
+
+    testScala2UnapplySignatures()
+  }
+
+  def testScala2UnapplySignatures() = {
+    val _: Option[Int] = Some.unapply(Some(1))
+    val _: Option[Int] = Right.unapply(Right(1))
+    val _: Option[(Int, List[Int])] = ::.unapply(::(1, Nil))
+
+    val _: Option[Int] = Tuple1.unapply(Tuple1(1))
+    val _: Option[(Int, Int)] = Tuple2.unapply((1, 2))
+    val _: Option[(Int, Int, Int)] = Tuple3.unapply((1, 2, 3))
   }