WIP Type quoted patterns with type splices

Author: nicolasstucki

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

@@ -859,6 +859,25 @@ object desugar {
       Thicket(aliasType :: companions.toList)
     }
 
+  /** Transforms
+    *
+    *    <mods> type $T >: Low <: Hi
+    *
+    *  to
+    *
+    *    @patternBindHole <mods> type $T >: Low <: Hi
+    *
+    *  if the type is a type splice.
+    */
+  def quotedPatternTypeDef(tree: TypeDef)(implicit ctx: Context): TypeDef = {
+    assert(ctx.mode.is(Mode.QuotedPattern))
+    if (tree.name.startsWith("$") /* && !tree.isBackQuoted*/) { // TODO add backquoted TypeDef
+      val patternBindHoleAnnot = New(ref(defn.InternalQuoted_patternBindHoleAnnot.typeRef)).withSpan(tree.span)
+      val mods = tree.mods.withAddedAnnotation(patternBindHoleAnnot)
+      tree.withMods(mods)
+    } else tree
+  }
+
   /** The normalized name of `mdef`. This means
    *   1. Check that the name does not redefine a Scala core class.
    *      If it does redefine, issue an error and return a mangled name instead of the original one.
@@ -1040,6 +1059,7 @@ object desugar {
     case tree: TypeDef =>
       if (tree.isClassDef) classDef(tree)
       else if (tree.mods.is(Opaque, butNot = Synthetic)) opaqueAlias(tree)
+      else if (ctx.mode.is(Mode.QuotedPattern)) quotedPatternTypeDef(tree)
       else tree
     case tree: DefDef =>
       if (tree.name.isConstructorName) tree // was already handled by enclosing classDef

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

@@ -1184,7 +1184,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   /** An extractor for typed splices */
   object Splice {
     def apply(tree: Tree)(implicit ctx: Context): Tree = {
-      val baseType = tree.tpe.baseType(defn.QuotedExprClass)
+      val baseType = tree.tpe.baseType(defn.QuotedExprClass).orElse(tree.tpe.baseType(defn.QuotedTypeClass))
       val argType =
         if (baseType != NoType) baseType.argTypesHi.head
         else defn.NothingType
@@ -1318,6 +1318,17 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     }
   }
 
+  /** Creates the tuple type tree repesentation of the type trees in `ts` */
+  def tupleTypeTree(elems: List[Tree])(implicit ctx: Context): Tree = {
+    val arity = elems.length
+    if (arity <= Definitions.MaxTupleArity && defn.TupleType(arity) != null) AppliedTypeTree(TypeTree(defn.TupleType(arity)), elems)
+    else nestedPairsType(elems)
+  }
+
+  /** Creates the nested pairs type tree repesentation of the type trees in `ts` */
+  def nestedPairsType(ts: List[Tree])(implicit ctx: Context): Tree =
+    ts.foldRight[Tree](TypeTree(defn.UnitType))((x, acc) => AppliedTypeTree(TypeTree(defn.PairType), x :: acc :: Nil))
+
   /** Replaces all positions in `tree` with zero-extent positions */
   private def focusPositions(tree: Tree)(implicit ctx: Context): Tree = {
     val transformer = new tpd.TreeMap {

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -596,6 +596,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         else keywordStr("'{") ~ toTextGlobal(dropBlock(tree)) ~ keywordStr("}")
       case Splice(tree) =>
         keywordStr("${") ~ toTextGlobal(dropBlock(tree)) ~ keywordStr("}")
+      case TypSplice(tree) =>
+        keywordStr("${") ~ toTextGlobal(dropBlock(tree)) ~ keywordStr("}")
       case tree: Applications.IntegratedTypeArgs =>
         toText(tree.app) ~ Str("(with integrated type args)").provided(ctx.settings.YprintDebug.value)
       case Thicket(trees) =>

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

@@ -150,7 +150,9 @@ class PCPCheckAndHeal(@constructorOnly ictx: Context) extends TreeMapWithStages(
     /** Is a reference to a class but not `this.type` */
     def isClassRef = sym.isClass && !tp.isInstanceOf[ThisType]
 
-    if (sym.exists && !sym.isStaticOwner && !isClassRef && !levelOK(sym))
+    if (sym.exists && !sym.isStaticOwner && !isClassRef && !levelOK(sym) &&
+        !sym.hasAnnotation(defn.InternalQuoted_patternBindHoleAnnot) // FIXME this is a workaround
+       )
       tryHeal(sym, tp, pos)
     else
       None

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

@@ -1964,11 +1964,49 @@ class Typer extends Namer
           val exprPt = pt.baseType(defn.QuotedExprClass)
           val quotedPt = if (exprPt.exists) exprPt.argTypesHi.head else defn.AnyType
           val quoted1 = typedExpr(quoted, quotedPt)(quoteContext.addMode(Mode.QuotedPattern))
-          val (shape, splices) = splitQuotePattern(quoted1)
-          val patType = defn.tupleType(splices.tpes.map(_.widen))
-          val splicePat = typed(untpd.Tuple(splices.map(untpd.TypedSplice(_))).withSpan(quoted.span), patType)
+          val (typeBindings, shape, splices) = splitQuotePattern(quoted1)
+
+          class ReplaceBindings extends TypeMap() {
+            override def apply(tp: Type): Type = tp match {
+              case tp: TypeRef =>
+                typeBindings.get(tp.typeSymbol).fold(tp)(_.symbol.typeRef)
+              case tp => mapOver(tp)
+            }
+          }
+          val replaceBindings = new ReplaceBindings
+          val patType = defn.tupleType(splices.tpes.map(tpe => replaceBindings(tpe.widen)))
+
+          val typeBindingsTuple = tpd.tupleTypeTree(typeBindings.values.toList)
+
+          val replaceBindingsInTree = new TreeMap {
+            private[this] var bindMap = Map.empty[Symbol, Symbol]
+            override def transform(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = {
+              tree match {
+                case tree: Bind =>
+                  val sym = tree.symbol
+                  val newInfo = replaceBindings(sym.info)
+                  if (sym.info =:= newInfo) super.transform(tree)
+                  else {
+                    val newSym = ctx.newSymbol(sym.owner, sym.name, sym.flags, newInfo, sym.privateWithin, sym.coord)
+                    bindMap += sym -> newSym
+                    Bind(newSym, super.transform(tree.body))
+                  }
+                case _ =>
+                  val replaceBindingsInType = new ReplaceBindings {
+                    override def apply(tp: Type): Type = tp match {
+                      case tp: TermRef => bindMap.get(tp.termSymbol).fold(tp)(_.typeRef)
+                      case tp => super.apply(tp)
+                    }
+                  }
+                  super.transform(tree).withType(replaceBindingsInType(tree.tpe))
+              }
+            }
+          }
+
+          val splicePat = typed(untpd.Tuple(splices.map(x => untpd.TypedSplice(replaceBindingsInTree.transform(x)))).withSpan(quoted.span), patType)
+
           UnApply(
-            fun = ref(defn.InternalQuotedMatcher_unapplyR).appliedToType(patType),
+            fun = ref(defn.InternalQuotedMatcher_unapplyR).appliedToTypeTrees(typeBindingsTuple :: TypeTree(patType) :: Nil),
             implicits =
               ref(defn.InternalQuoted_exprQuoteR).appliedToType(shape.tpe).appliedTo(shape) ::
               implicitArgTree(defn.TastyReflectionType, tree.span) :: Nil,
@@ -1980,8 +2018,24 @@ class Typer extends Namer
     }
   }
 
-  def splitQuotePattern(quoted: Tree)(implicit ctx: Context): (Tree, List[Tree]) = {
+  def splitQuotePattern(quoted: Tree)(implicit ctx: Context): (Map[Symbol, Bind], Tree, List[Tree]) = {
     val ctx0 = ctx
+
+    val typeBindings: collection.mutable.Map[Symbol, Bind] = collection.mutable.Map.empty
+    def getBinding(sym: Symbol): Bind =
+      typeBindings.getOrElseUpdate(sym, {
+        val bindingBounds = TypeBounds.apply(defn.NothingType, defn.AnyType) // TODO recover bounds
+        val bsym = ctx.newPatternBoundSymbol((sym.name + "$").toTypeName, bindingBounds, quoted.span)
+        Bind(bsym, untpd.Ident(nme.WILDCARD).withType(bindingBounds)).withSpan(quoted.span)
+      })
+    def replaceTypeBindings = new TypeMap {
+      def apply(tp: Type): Type = tp match {
+        case tp: TypeRef if tp.typeSymbol.hasAnnotation(defn.InternalQuoted_patternBindHoleAnnot) =>
+          getBinding(tp.typeSymbol).symbol.typeRef
+        case _ => mapOver(tp)
+      }
+    }
+
     object splitter extends tpd.TreeMap {
       val patBuf = new mutable.ListBuffer[Tree]
       override def transform(tree: Tree)(implicit ctx: Context) = tree match {
@@ -2014,17 +2068,28 @@ class Typer extends Namer
             patBuf += Bind(sym, untpd.Ident(nme.WILDCARD).withType(bindingExprTpe)).withSpan(ddef.span)
           }
           super.transform(tree)
+        case tdef: TypeDef if tdef.symbol.hasAnnotation(defn.InternalQuoted_patternBindHoleAnnot) =>
+          val bindingType = getBinding(tdef.symbol).symbol.typeRef
+          val bindingTypeTpe = AppliedType(defn.QuotedTypeType, bindingType :: Nil)
+          assert(tdef.name.startsWith("$"))
+          val bindName = tdef.name.toString.stripPrefix("$").toTermName
+          val sym = ctx0.newPatternBoundSymbol(bindName, bindingTypeTpe, tdef.span)
+          patBuf += Bind(sym, untpd.Ident(nme.WILDCARD).withType(bindingTypeTpe)).withSpan(tdef.span)
+          super.transform(tree)
         case _ =>
           super.transform(tree)
       }
     }
     val result = splitter.transform(quoted)
-    (result, splitter.patBuf.toList)
+    val patterns = splitter.patBuf.toList
+    (typeBindings.toMap, result, patterns)
   }
 
   /** A hole the shape pattern of a quoted.Matcher.unapply, representing a splice */
-  def patternHole(splice: Tree)(implicit ctx: Context): Tree =
+  def patternHole(splice: Tree)(implicit ctx: Context): Tree = {
+    val Splice(pat) = splice
     ref(defn.InternalQuoted_patternHoleR).appliedToType(splice.tpe).withSpan(splice.span)
+  }
 
   /** Translate `${ t: Expr[T] }` into expression `t.splice` while tracking the quotation level in the context */
   def typedSplice(tree: untpd.Splice, pt: Type)(implicit ctx: Context): Tree = track("typedSplice") {
@@ -2063,14 +2128,47 @@ class Typer extends Namer
 
   /** Translate ${ t: Type[T] }` into type `t.splice` while tracking the quotation level in the context */
   def typedTypSplice(tree: untpd.TypSplice, pt: Type)(implicit ctx: Context): Tree = track("typedTypSplice") {
+    // TODO factor out comon code with typedSplice
     ctx.compilationUnit.needsStaging = true
     checkSpliceOutsideQuote(tree)
     tree.expr match {
       case untpd.Quote(innerType) if innerType.isType =>
         ctx.warning("Canceled quote directly inside a splice. ${ '[ XYZ ] } is equivalent to XYZ.", tree.sourcePos)
         typed(innerType, pt)
       case expr =>
-        typedSelect(untpd.Select(tree.expr, tpnme.splice), pt)(spliceContext).withSpan(tree.span)
+        if (ctx.mode.is(Mode.QuotedPattern) && level == 1) {
+          if (isFullyDefined(pt, ForceDegree.all)) {
+            // TODO is this error still relevant here? probably not
+            ctx.error(i"Type must be fully defined.\nConsider annotating the splice using a type ascription:\n  ($tree: XYZ).", tree.expr.sourcePos)
+            tree.withType(UnspecifiedErrorType)
+          } else {
+            expr match {
+              case Ident(name) => typedIdent(untpd.Ident(("$" + name).toTypeName), pt)
+            }
+
+//            println()
+//            println(expr)
+//            println()
+//            println()
+//            val bindingBounds = TypeBounds.apply(defn.NothingType, defn.AnyType)
+//            def getName(tree: untpd.Tree): TypeName = tree match {
+//              case tree: RefTree => ("$" + tree.name).toTypeName
+//              case tree: Typed => getName(tree.expr)
+//            }
+//            val sym = ctx.newPatternBoundSymbol(getName(expr), bindingBounds, expr.span)
+//            val bind = Bind(sym, untpd.Ident(nme.WILDCARD).withType(bindingBounds)).withSpan(expr.span)
+//
+//            def spliceOwner(ctx: Context): Symbol =
+//              if (ctx.mode.is(Mode.QuotedPattern)) spliceOwner(ctx.outer) else ctx.owner
+//            val pat = typedPattern(tree.expr, defn.QuotedTypeType.appliedTo(sym.typeRef))(
+//              spliceContext.retractMode(Mode.QuotedPattern).withOwner(spliceOwner(ctx)))
+//            Splice(Typed(pat, AppliedTypeTree(TypeTree(defn.QuotedTypeType), bind :: Nil)))
+
+          }
+
+        } else {
+          typedSelect(untpd.Select(tree.expr, tpnme.splice), pt)(spliceContext).withSpan(tree.span)
+        }
     }
   }
 

library/src-2.x/scala/internal/quoted/Matcher.scala

@@ -5,7 +5,7 @@ import scala.tasty.Reflection
 
 object Matcher {
 
-  def unapply[Tup <: Tuple](scrutineeExpr: Expr[_])(implicit patternExpr: Expr[_], reflection: Reflection): Option[Tup] =
+  def unapply[TypeBindings <: Tuple, Tup <: Tuple](scrutineeExpr: Expr[_])(implicit patternExpr: Expr[_], reflection: Reflection): Option[Tup] =
     throw new Exception("running on non bootstrapped library")
 
 }

library/src-3.x/scala/internal/Quoted.scala

@@ -24,6 +24,4 @@ object Quoted {
   /** A splice of a name in a quoted pattern is desugared by wrapping getting this annotation */
   class patternBindHole extends Annotation
 
-  class patternType extends Annotation
-
 }

library/src-3.x/scala/internal/quoted/Matcher.scala

@@ -30,15 +30,28 @@ object Matcher {
    *  @param reflection instance of the reflection API (implicitly provided by the macro)
    *  @return None if it did not match, `Some(tup)` if it matched where `tup` contains `Expr[Ti]``
    */
-  def unapply[Tup <: Tuple](scrutineeExpr: Expr[_])(implicit patternExpr: Expr[_], reflection: Reflection): Option[Tup] = {
+  def unapply[TypeBindings <: Tuple, Tup <: Tuple](scrutineeExpr: Expr[_])(implicit patternExpr: Expr[_], reflection: Reflection): Option[Tup] = {
     // TODO improve performance
     import reflection.{Bind => BindPattern, _}
     import Matching._
 
     type Env = Set[(Symbol, Symbol)]
 
+    class SymBinding(val sym: Symbol)
+
     inline def withEnv[T](env: Env)(body: => given Env => T): T = body given env
 
+    def hasBindTypeAnnotation(tpt: TypeTree): Boolean = tpt match {
+      case Annotated(tpt2, Apply(Select(New(TypeIdent("patternBindHole")), "<init>"), Nil)) => true
+      case Annotated(tpt2, _) => hasBindTypeAnnotation(tpt2)
+      case _ => false
+    }
+
+    def hasBindAnnotation(sym: Symbol) = sym.annots.exists {
+      case New(tpt) => tpt.symbol == kernel.Definitions_InternalQuoted_patternBindHoleAnnot
+      case annot => annot.symbol.owner == kernel.Definitions_InternalQuoted_patternBindHoleAnnot
+    }
+
     /** Check that all trees match with `mtch` and concatenate the results with && */
     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)
@@ -63,6 +76,7 @@ object Matcher {
       /** Normalieze the tree */
       def normalize(tree: Tree): Tree = tree match {
         case Block(Nil, expr) => normalize(expr)
+        case Block(stats1, Block(stats2, expr)) => normalize(Block(stats1 ::: stats2, expr))
         case Inlined(_, Nil, expr) => normalize(expr)
         case _ => tree
       }
@@ -81,15 +95,6 @@ object Matcher {
       def bindingMatch(sym: Symbol) =
         matched(new Bind(sym.name, sym))
 
-      def hasBindTypeAnnotation(tpt: TypeTree): Boolean = tpt match {
-        case Annotated(tpt2, Apply(Select(New(TypeIdent("patternBindHole")), "<init>"), Nil)) => true
-        case Annotated(tpt2, _) => hasBindTypeAnnotation(tpt2)
-        case _ => false
-      }
-
-      def hasBindAnnotation(sym: Symbol) =
-        sym.annots.exists { case Apply(Select(New(TypeIdent("patternBindHole")),"<init>"),List()) => true; case _ => true }
-
       (scrutinee, pattern) match {
 
         // Match a scala.internal.Quoted.patternHole typed as a repeated argument and return the scrutinee tree
@@ -133,11 +138,20 @@ object Matcher {
         case (TypeApply(fn1, args1), TypeApply(fn2, args2)) if fn1.symbol == fn2.symbol =>
           fn1 =#= fn2 && args1 =##= args2
 
-        case (Block(stats1, expr1), Block(stats2, expr2)) =>
-          withEnv(the[Env] ++ stats1.map(_.symbol).zip(stats2.map(_.symbol))) {
-            stats1 =##= stats2 && expr1 =#= expr2
+        case (Block(stats1, expr1), Block(binding :: stats2, expr2)) if isTypeBinding(binding) =>
+          reflection.kernel.Context_GADT_addToConstraint(the[Context])(binding.symbol :: Nil)
+          matched(new SymBinding(binding.symbol)) && Block(stats1, expr1) =#= Block(stats2, expr2)
+
+        case (Block(stat1 :: stats1, expr1), Block(stat2 :: stats2, expr2)) =>
+          withEnv(the[Env] + (stat1.symbol -> stat2.symbol)) {
+            stat1 =#= stat2 && Block(stats1, expr1) =#= Block(stats2, expr2)
           }
 
+        case (scrutinee, Block(typeBindings, expr2)) if typeBindings.forall(isTypeBinding) =>
+          val bindingSymbols = typeBindings.map(_.symbol)
+          reflection.kernel.Context_GADT_addToConstraint(the[Context])(bindingSymbols)
+          bindingSymbols.foldRight(scrutinee =#= expr2)((x, acc) => matched(new SymBinding(x)) && acc)
+
         case (If(cond1, thenp1, elsep1), If(cond2, thenp2, elsep2)) =>
           cond1 =#= cond2 && thenp1 =#= thenp2 && elsep1 =#= elsep2
 
@@ -315,24 +329,24 @@ object Matcher {
     }
 
     def isTypeBinding(tree: Tree): Boolean = tree match {
-      case IsTypeDef(tree) =>
-        tree.symbol.annots.exists(_.symbol.owner.fullName == "scala.internal.Quoted$.patternType")
+      case IsTypeDef(tree) => hasBindAnnotation(tree.symbol)
       case _ => false
     }
 
     implied for Env = Set.empty
-    val res = patternExpr.unseal.underlyingArgument match {
-      case Block(typeBindings, pattern) if typeBindings.forall(isTypeBinding) =>
-        implicit val ctx2 = reflection.kernel.Context_GADT_setFreshGADTBounds(rootContext)
-        val bindingSymbols = typeBindings.map(_.symbol(ctx2))
-        reflection.kernel.Context_GADT_addToConstraint(ctx2)(bindingSymbols)
-        val matchings = scrutineeExpr.unseal.underlyingArgument =#= pattern
-        val constainedTypes = bindingSymbols.map(s => reflection.kernel.Context_GADT_approximation(ctx2)(s, true))
-        constainedTypes.foldRight(matchings)((x, acc) => matched(x.seal) && acc)
-      case pattern =>
-        scrutineeExpr.unseal.underlyingArgument =#= pattern
+
+    {
+      // TODO only set GADT context when needed
+      implicit val ctx2 = reflection.kernel.Context_GADT_setFreshGADTBounds(rootContext)
+      val matchings = scrutineeExpr.unseal.underlyingArgument =#= patternExpr.unseal.underlyingArgument
+      val res = matchings.asOptionOfTuple.map { tup =>
+        Tuple.fromArray(tup.toArray.map { // TODO improve code
+          case x: SymBinding => reflection.kernel.Context_GADT_approximation(ctx2)(x.sym, true).seal
+          case x => x
+        })
+      }
+      res.asInstanceOf[Option[Tup]]
     }
-    res.asOptionOfTuple.asInstanceOf[Option[Tup]]
   }
 
   /** Result of matching a part of an expression */

tests/pos/quotedPatterns.scala

@@ -30,6 +30,11 @@ object Test {
     case '{ def $ff[T](i: T): Int = $z; 2 } =>
       val a: quoted.matching.Bind[[T] => T => Int] = ff
       z
+//    case '{ poly[$t]($x); 2 } => ???
+//    case '{ val x: $t = $a; val y: `$t` = x;  1 } => ???
+    case '{ type $t <: AnyRef; val x: $t = $a; val y: $t = x;  1 } => ???
     case _ => '{1}
   }
+
+  def poly[T](x: T): Unit = ()
 }