WIP add test for different refinement approach

Author: nicolasstucki

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

@@ -689,6 +689,9 @@ class Definitions {
   lazy val TastyTopLevelSpliceModule = ctx.requiredModule("scala.tasty.TopLevelSplice")
     lazy val TastyTopLevelSplice_tastyContext = TastyTopLevelSpliceModule.requiredMethod("tastyContext")
 
+  lazy val RefinedScrutineeType: TypeRef       = ctx.requiredClassRef("scala.RefinedScrutinee")
+  def RefinedScrutineeClass(implicit ctx: Context) = RefinedScrutineeType.symbol.asClass
+
   lazy val EqType = ctx.requiredClassRef("scala.Eq")
   def EqClass(implicit ctx: Context) = EqType.symbol.asClass
   def EqModule(implicit ctx: Context) = EqClass.companionModule

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

@@ -216,6 +216,8 @@ object StdNames {
     final val Type : N               = "Type"
     final val TypeTree: N            = "TypeTree"
 
+    final val RefinedScrutinee: N     = "RefinedScrutinee"
+
     // Annotation simple names, used in Namer
     final val BeanPropertyAnnot: N = "BeanProperty"
     final val BooleanBeanPropertyAnnot: N = "BooleanBeanProperty"

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

@@ -113,16 +113,20 @@ class FirstTransform extends MiniPhase with InfoTransformer { thisPhase =>
       ddef.tpe.widen match {
         case mt: MethodType if !mt.resType.widen.isInstanceOf[MethodicType] =>
           val resultType = mt.resType.substParam(mt.paramRefs.head, mt.paramRefs.head)
-          val refinedType = resultType.select(nme.refinedScrutinee).widen.resultType
-          if (refinedType.exists && !(refinedType <:< mt.paramRefs.head)) {
-            val paramName = mt.paramNames.head
-            val paramTpe = mt.paramRefs.head
-            val paramInfo = mt.paramInfos.head
-            ctx.error(
-              i"""Extractor with ${nme.refinedScrutinee} should refine the result type of that member.
-                 |The result type of ${nme.refinedScrutinee} should be a subtype of $paramTpe:
-                 |  def unapply($paramName: $paramInfo): ${resultType.widenDealias.classSymbol.name} { def ${nme.refinedScrutinee}: $refinedType & $paramTpe }
+          resultType match {
+            case resultType: AppliedType if resultType.derivesFrom(defn.RefinedScrutineeClass) =>
+              val refinedType :: resultType2 :: Nil = resultType.args
+              if (refinedType.exists && !(refinedType <:< mt.paramRefs.head)) {
+                val paramName = mt.paramNames.head
+                val paramTpe = mt.paramRefs.head
+                val paramInfo = mt.paramInfos.head
+                ctx.error(
+                  i"""Extractor with ${tpnme.RefinedScrutinee} should refine the result type of that member.
+                     |The scrutinee type of ${tpnme.RefinedScrutinee} should be a subtype of $paramTpe:
+                     |  def unapply($paramName: $paramInfo): ${tpnme.RefinedScrutinee}[$paramTpe & $refinedType, $resultType2]
                """.stripMargin, ddef.tpt.pos)
+              }
+            case _ =>
           }
         case _ =>
       }

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -1352,9 +1352,11 @@ class Typer extends Namer
               fun.tpe.widen match {
                 case mt: MethodType if !mt.resType.isInstanceOf[MethodType] =>
                   val resultType = mt.resType.substParam(mt.paramRefs.head, symTp0)
-                  val refinedType = resultType.select(nme.refinedScrutinee).widen.resultType
-                  if (refinedType.exists) refinedType
-                  else symTp0
+                  resultType match {
+                    case resultType: AppliedType if resultType.derivesFrom(defn.RefinedScrutineeClass) =>
+                      resultType.args.head
+                    case _ => symTp0
+                  }
                 case _ =>
                   symTp0
               }

library/src/scala/RefinedScrutinee.scala

@@ -0,0 +1,17 @@
+package scala
+
+class RefinedScrutinee[+Scrutinee /*<: Singleton*/, +Result] private (val result: Option[Result]) extends AnyVal {
+  // Scrutinee in not a singleton to provide a better error message
+
+  /** There is no result */
+  def isEmpty: Boolean = result.isEmpty
+
+  /** Get the result */
+  def get: Result = result.get
+}
+
+object RefinedScrutinee {
+  // TODO when bootstrapped: erase scrutinee as it is just an evidence for that existance of a term of type Scrutinee
+  def matchOf[Scrutinee <: Singleton, Result](/*erased*/ scrutinee: Scrutinee)(result: Result): RefinedScrutinee[Scrutinee, Result] = new RefinedScrutinee(Some(result))
+  def noMatch[Scrutinee <: Singleton, Result]: RefinedScrutinee[Scrutinee, Result] = new RefinedScrutinee(None)
+}

tests/neg/refined-binding-nat.scala

@@ -9,12 +9,7 @@ trait Peano {
   val Succ: SuccExtractor
   trait SuccExtractor {
     def apply(nat: Nat): Succ
-    def unapply(nat: Nat): SuccOpt // error: missing { def refinedScrutinee: Succ & nat.type }
-  }
-  trait SuccOpt {
-    def isEmpty: Boolean
-    def refinedScrutinee: Succ
-    def get: Nat
+    def unapply(nat: Nat): RefinedScrutinee[Succ, Nat] // error
   }
 }
 
@@ -27,11 +22,9 @@ object IntNums extends Peano {
 
   object Succ extends SuccExtractor {
     def apply(nat: Nat): Succ = nat + 1
-    def unapply(nat: Nat) = new SuccOpt { // error: missing { def refinedScrutinee: Succ & nat.type }
-      def isEmpty: Boolean = nat == 0
-      def refinedScrutinee: Succ & nat.type = nat
-      def get: Int = nat - 1
-    }
+    def unapply(nat: Nat) = // error
+      if (nat == 0) RefinedScrutinee.noMatch
+      else RefinedScrutinee.matchOf(nat)(nat - 1)
   }
 
 }
@@ -45,11 +38,9 @@ object IntNums2 extends Peano {
 
   object Succ extends SuccExtractor {
     def apply(nat: Nat): Succ = nat + 1
-    def unapply(nat: Nat): SuccOpt { def refinedScrutinee: Succ & nat.type } = new SuccOpt {
-      def isEmpty: Boolean = nat == 0
-      def refinedScrutinee: Succ & nat.type = nat
-      def get: Int = nat - 1
-    }
+    def unapply(nat: Nat): RefinedScrutinee[nat.type & Succ, Nat] =
+      if (nat == 0) RefinedScrutinee.noMatch
+      else RefinedScrutinee.matchOf(nat)(nat - 1)
   }
 
 }

tests/run/refined-binding-nat.scala

@@ -38,12 +38,7 @@ trait Peano {
   val Succ: SuccExtractor
   trait SuccExtractor {
     def apply(nat: Nat): Succ
-    def unapply(nat: Nat): SuccOpt { def refinedScrutinee: Succ & nat.type }
-  }
-  trait SuccOpt {
-    def isEmpty: Boolean
-    def refinedScrutinee: Succ
-    def get: Nat
+    def unapply(nat: Nat): RefinedScrutinee[nat.type & Succ, Nat]
   }
 }
 
@@ -58,13 +53,10 @@ object IntNums extends Peano {
 
   object Succ extends SuccExtractor {
     def apply(nat: Nat): Succ = nat + 1
-    def unapply(nat: Nat) = new SuccOpt {
-      def isEmpty: Boolean = nat == 0
-      def refinedScrutinee: Succ & nat.type = nat
-      def get: Int = nat - 1
-    }
+    def unapply(nat: Nat) =
+      if (nat == 0) RefinedScrutinee.noMatch
+      else RefinedScrutinee.matchOf(nat)(nat - 1)
   }
-
   def succDeco(succ: Succ): SuccAPI = new SuccAPI {
     def pred: Nat = succ - 1
   }
@@ -75,17 +67,7 @@ object ClassNums extends Peano {
   object ZeroObject extends NatTrait {
     override def toString: String = "ZeroObject"
   }
-  case class SuccClass(predecessor: NatTrait) extends NatTrait with SuccOpt {
-    def isEmpty: Boolean = false
-    def refinedScrutinee: this.type = this
-    def get: NatTrait = this
-  }
-
-  object SuccNoMatch extends SuccOpt {
-    def isEmpty: Boolean = true
-    def refinedScrutinee: Nothing = throw new NoSuchElementException
-    def get: NatTrait = throw new NoSuchElementException
-  }
+  case class SuccClass(predecessor: NatTrait) extends NatTrait
 
   type Nat  = NatTrait
   type Zero = ZeroObject.type
@@ -109,8 +91,8 @@ object ClassNums extends Peano {
   object Succ extends SuccExtractor {
     def apply(nat: Nat): Succ = new SuccClass(nat)
     def unapply(nat: Nat) = nat match {
-      case nat: (SuccClass & nat.type) => nat
-      case _ => SuccNoMatch
+      case nat: (SuccClass & nat.type) => RefinedScrutinee.matchOf(nat)(nat.predecessor)
+      case _ => RefinedScrutinee.noMatch
     }
   }
 

tests/run/refined-binding.scala

@@ -9,17 +9,8 @@ sealed trait Foo {
   def f(y: Y) = println("ok")
 
   object Z {
-    def unapply(arg: X) = new Opt {
-      type Scrutinee = arg.type
-      def refinedScrutinee: Y & Scrutinee = arg.asInstanceOf[Y & Scrutinee]
-    }
-  }
-
-  abstract class Opt {
-    type Scrutinee <: Singleton
-    def refinedScrutinee: Y & Scrutinee
-    def get: Int = 9
-    def isEmpty: Boolean = false
+    def unapply(arg: X): RefinedScrutinee[arg.type & Y, Int] =
+      RefinedScrutinee.matchOf(arg.asInstanceOf[arg.type & Y])(9)
   }
 }