Fix approximation direction based on variance

Author: nicolasstucki

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

@@ -650,6 +650,8 @@ class Definitions {
     @tu lazy val InternalQuoted_patternHole: Symbol = InternalQuotedModule.requiredMethod("patternHole")
     @tu lazy val InternalQuoted_patternBindHoleAnnot: ClassSymbol = InternalQuotedModule.requiredClass("patternBindHole")
     @tu lazy val InternalQuoted_QuoteTypeTagAnnot: ClassSymbol = InternalQuotedModule.requiredClass("quoteTypeTag")
+    @tu lazy val InternalQuoted_formAboveAnnot: ClassSymbol = InternalQuotedModule.requiredClass("formAbove")
+
 
   @tu lazy val InternalQuotedExprModule: Symbol = ctx.requiredModule("scala.internal.quoted.Expr")
     @tu lazy val InternalQuotedExpr_unapply: Symbol = InternalQuotedExprModule.requiredMethod(nme.unapply)

compiler/src/dotty/tools/dotc/tastyreflect/ReflectionCompilerInterface.scala

@@ -1867,6 +1867,7 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
 
   def Definitions_InternalQuoted_patternHole: Symbol = defn.InternalQuoted_patternHole
   def Definitions_InternalQuoted_patternBindHoleAnnot: Symbol = defn.InternalQuoted_patternBindHoleAnnot
+  def Definitions_InternalQuoted_formAboveAnnot: Symbol = defn.InternalQuoted_formAboveAnnot
 
   // Types
 

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

@@ -163,6 +163,16 @@ trait QuotesAndSplices { self: Typer =>
       })
 
     object splitter extends tpd.TreeMap {
+      private var variance: Int = 1
+
+      @forceInline private def atVariance[T](v: Int)(op: => T): T = {
+        val saved = variance
+        variance = v
+        val res = op
+        variance = saved
+        res
+      }
+
       val patBuf = new mutable.ListBuffer[Tree]
       val freshTypePatBuf = new mutable.ListBuffer[Tree]
       val freshTypeBindingsBuff = new mutable.ListBuffer[Tree]
@@ -206,11 +216,21 @@ trait QuotesAndSplices { self: Typer =>
           super.transform(tree)
         case tdef: TypeDef if tdef.symbol.hasAnnotation(defn.InternalQuoted_patternBindHoleAnnot) =>
           transformTypeBindingTypeDef(tdef, typePatBuf)
+         case tree @ AppliedTypeTree(tpt, args) =>
+            val args1: List[Tree] = args.zipWithConserve(tpt.tpe.typeParams.map(_.paramVariance)) { (arg, v) =>
+              arg.tpe match {
+                case _: TypeBounds => transform(arg)
+                case _ => atVariance(variance * v)(transform(arg))
+              }
+            }
+            cpy.AppliedTypeTree(tree)(transform(tpt), args1)
         case _ =>
           super.transform(tree)
       }
 
-      def transformTypeBindingTypeDef(tdef: TypeDef, buff: mutable.Builder[Tree, List[Tree]]): Tree = {
+      private def transformTypeBindingTypeDef(tdef: TypeDef, buff: mutable.Builder[Tree, List[Tree]])(implicit ctx: Context): Tree = {
+        if (variance == -1)
+          tdef.symbol.addAnnotation(Annotation(New(ref(defn.InternalQuoted_formAboveAnnot.typeRef)).withSpan(tdef.span)))
         val bindingType = getBinding(tdef.symbol).symbol.typeRef
         val bindingTypeTpe = AppliedType(defn.QuotedTypeClass.typeRef, bindingType :: Nil)
         assert(tdef.name.startsWith("$"))

library/src/scala/internal/Quoted.scala

@@ -28,6 +28,9 @@ object Quoted {
   /** A splice of a name in a quoted pattern is that marks the definition of a type splice */
   class patternType extends Annotation
 
+  /** A type pattern that must be aproximated from above */
+  class formAbove extends Annotation
+
   /** Artifact of pickled type splices
    *
    *  During quote reification a quote `'{ ... F[$t] ... }` will be transformed into

library/src/scala/internal/quoted/Matcher.scala

@@ -19,7 +19,7 @@ private[quoted] object Matcher {
 
     inline private def withEnv[T](env: Env)(body: => given Env => T): T = body given env
 
-    class SymBinding(val sym: Symbol)
+    class SymBinding(val sym: Symbol, val fromAbove: Boolean)
 
     def termMatch(scrutineeTerm: Term, patternTerm: Term, hasTypeSplices: Boolean): Option[Tuple] = {
       implicit val env: Env = Set.empty
@@ -30,7 +30,7 @@ private[quoted] object Matcher {
         // that we have found and seal them in a quoted.Type
         matchings.asOptionOfTuple.map { tup =>
           Tuple.fromArray(tup.toArray.map { // TODO improve performace
-            case x: SymBinding => internal.Context_GADT_approximation(the[Context])(x.sym, true).seal
+            case x: SymBinding => internal.Context_GADT_approximation(the[Context])(x.sym, !x.fromAbove).seal
             case x => x
           })
         }
@@ -50,7 +50,7 @@ private[quoted] object Matcher {
         // that we have found and seal them in a quoted.Type
         matchings.asOptionOfTuple.map { tup =>
           Tuple.fromArray(tup.toArray.map { // TODO improve performace
-            case x: SymBinding => internal.Context_GADT_approximation(the[Context])(x.sym, true).seal
+            case x: SymBinding => internal.Context_GADT_approximation(the[Context])(x.sym, !x.fromAbove).seal
             case x => x
           })
         }
@@ -67,11 +67,18 @@ private[quoted] object Matcher {
 
     private def hasBindAnnotation(sym: Symbol) = sym.annots.exists(isBindAnnotation)
 
+    private def hasFromAboveAnnotation(sym: Symbol) = sym.annots.exists(isFromAboveAnnotation)
+
     private def isBindAnnotation(tree: Tree): Boolean = tree match {
       case New(tpt) => tpt.symbol == internal.Definitions_InternalQuoted_patternBindHoleAnnot
       case annot => annot.symbol.owner == internal.Definitions_InternalQuoted_patternBindHoleAnnot
     }
 
+    private def isFromAboveAnnotation(tree: Tree): Boolean = tree match {
+      case New(tpt) => tpt.symbol == internal.Definitions_InternalQuoted_formAboveAnnot
+      case annot => annot.symbol.owner == internal.Definitions_InternalQuoted_formAboveAnnot
+    }
+
     /** 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 {
       case (x :: xs, y :: ys) => mtch(x, y) && matchLists(xs, ys)(mtch)
@@ -160,7 +167,7 @@ private[quoted] object Matcher {
 
         case (Block(stats1, expr1), Block(binding :: stats2, expr2)) if isTypeBinding(binding) =>
           qctx.tasty.internal.Context_GADT_addToConstraint(the[Context])(binding.symbol :: Nil)
-          matched(new SymBinding(binding.symbol)) && Block(stats1, expr1) =#= Block(stats2, expr2)
+          matched(new SymBinding(binding.symbol, hasFromAboveAnnotation(binding.symbol))) && Block(stats1, expr1) =#= Block(stats2, expr2)
 
         case (Block(stat1 :: stats1, expr1), Block(stat2 :: stats2, expr2)) =>
           withEnv(the[Env] + (stat1.symbol -> stat2.symbol)) {
@@ -170,7 +177,7 @@ private[quoted] object Matcher {
         case (scrutinee, Block(typeBindings, expr2)) if typeBindings.forall(isTypeBinding) =>
           val bindingSymbols = typeBindings.map(_.symbol)
           qctx.tasty.internal.Context_GADT_addToConstraint(the[Context])(bindingSymbols)
-          bindingSymbols.foldRight(scrutinee =#= expr2)((x, acc) => matched(new SymBinding(x)) && acc)
+          bindingSymbols.foldRight(scrutinee =#= expr2)((x, acc) => matched(new SymBinding(x, hasFromAboveAnnotation(x))) && acc)
 
         case (If(cond1, thenp1, elsep1), If(cond2, thenp2, elsep2)) =>
           cond1 =#= cond2 && thenp1 =#= thenp2 && elsep1 =#= elsep2

library/src/scala/tasty/reflect/CompilerInterface.scala

@@ -1517,6 +1517,9 @@ trait CompilerInterface {
   /** Symbol of scala.internal.Quoted.patternBindHole */
   def Definitions_InternalQuoted_patternBindHoleAnnot: Symbol
 
+  /** Symbol of scala.internal.Quoted.formAbove */
+  def Definitions_InternalQuoted_formAboveAnnot: Symbol
+
   def Definitions_UnitType: Type
   def Definitions_ByteType: Type
   def Definitions_ShortType: Type

tests/run-with-compiler/quote-type-matcher.check

@@ -0,0 +1,8 @@
+scala.Int
+
+scala.Int
+scala.Double
+
+scala.Int
+scala.Short
+scala.Double

tests/run-with-compiler/quote-type-matcher.scala

@@ -0,0 +1,27 @@
+import scala.quoted._
+import scala.reflect.ClassTag
+
+object Test {
+  implicit val toolbox: scala.quoted.Toolbox = scala.quoted.Toolbox.make(this.getClass.getClassLoader)
+  def main(args: Array[String]): Unit = withQuoteContext {
+    val '[List[Int]] = '[List[Int]]
+
+    val '[List[$int]] = '[List[Int]]
+    println(int.show)
+    println()
+
+    {
+      val '[Function1[$t1, $r]] = '[Int => Double]
+      println(t1.show)
+      println(r.show)
+      println()
+    }
+
+    {
+      val '[Function1[Function1[$t1, $r0], $r]] = '[(Int => Short) => Double]
+      println(t1.show)
+      println(r0.show)
+      println(r.show)
+    }
+  }
+}