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) {
+      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/Trees.scala

@@ -772,6 +772,14 @@ object Trees {
 
     /** Is this a definition of a class? */
     def isClassDef: Boolean = rhs.isInstanceOf[Template[_]]
+
+    def isBackquoted: Boolean = false
+  }
+
+  class BackquotedTypeDef[-T >: Untyped] private[ast] (name: TypeName, rhs: Tree[T])(implicit @constructorOnly src: SourceFile)
+    extends TypeDef[T](name, rhs) {
+    override def isBackquoted: Boolean = true
+    override def productPrefix: String = "BackquotedTypeDef"
   }
 
   /** extends parents { self => body }
@@ -985,6 +993,7 @@ object Trees {
     type DefDef = Trees.DefDef[T]
     type BackquotedDefDef = Trees.BackquotedDefDef[T]
     type TypeDef = Trees.TypeDef[T]
+    type BackquotedTypeDef = Trees.BackquotedTypeDef[T]
     type Template = Trees.Template[T]
     type Import = Trees.Import[T]
     type PackageDef = Trees.PackageDef[T]

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/ast/untpd.scala

@@ -334,6 +334,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def DefDef(name: TermName, tparams: List[TypeDef], vparamss: List[List[ValDef]], tpt: Tree, rhs: LazyTree)(implicit src: SourceFile): DefDef = new DefDef(name, tparams, vparamss, tpt, rhs)
   def BackquotedDefDef(name: TermName, tparams: List[TypeDef], vparamss: List[List[ValDef]], tpt: Tree, rhs: LazyTree)(implicit src: SourceFile): DefDef = new BackquotedDefDef(name, tparams, vparamss, tpt, rhs)
   def TypeDef(name: TypeName, rhs: Tree)(implicit src: SourceFile): TypeDef = new TypeDef(name, rhs)
+  def BackquotedTypeDef(name: TypeName, rhs: Tree)(implicit src: SourceFile): TypeDef = new BackquotedTypeDef(name, rhs)
   def Template(constr: DefDef, parents: List[Tree], derived: List[Tree], self: ValDef, body: LazyTreeList)(implicit src: SourceFile): Template =
     if (derived.isEmpty) new Template(constr, parents, self, body)
     else new DerivingTemplate(constr, parents ++ derived, self, body, derived.length)

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -2556,10 +2556,15 @@ object Parsers {
     def typeDefOrDcl(start: Offset, mods: Modifiers): Tree = {
       newLinesOpt()
       atSpan(start, nameStart) {
-        val name = ident().toTypeName
+        val nameIdent = typeIdent()
         val tparams = typeParamClauseOpt(ParamOwner.Type)
-        def makeTypeDef(rhs: Tree): Tree =
-          finalizeDef(TypeDef(name, lambdaAbstract(tparams, rhs)), mods, start)
+        def makeTypeDef(rhs: Tree): Tree = {
+          val rhs1 = lambdaAbstract(tparams, rhs)
+          val tdef =
+            if (nameIdent.isBackquoted) BackquotedTypeDef(nameIdent.name.toTypeName, rhs1)
+            else TypeDef(nameIdent.name.toTypeName, rhs1)
+          finalizeDef(tdef, mods, start)
+        }
         in.token match {
           case EQUALS =>
             in.nextToken()

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,13 +1964,50 @@ 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 =>
+                val tp1 = if (tp.typeSymbol == defn.QuotedType_splice) tp.dealias else tp
+                typeBindings.get(tp1.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)
+                  val newSym = ctx.newSymbol(sym.owner, sym.name, sym.flags, newInfo, sym.privateWithin, sym.coord)
+                  bindMap += sym -> newSym
+                  Bind(newSym, transform(tree.body)).withSpan(sym.span)
+                case _ =>
+                  super.transform(tree).withType(replaceBindingsInType(tree.tpe))
+              }
+            }
+            private[this] 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)
+              }
+            }
+          }
+
+          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) ::
+              Literal(Constant(typeBindings.nonEmpty)) ::
               implicitArgTree(defn.TastyReflectionType, tree.span) :: Nil,
             patterns = splicePat :: Nil,
             proto = pt)
@@ -1980,8 +2017,25 @@ 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
+    val freshTypeBindingsBuff = List.newBuilder[Tree]
+    def getBinding(sym: Symbol): Bind =
+      typeBindings.getOrElseUpdate(sym, {
+        val bindingBounds = sym.info
+        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 {
@@ -1996,6 +2050,12 @@ class Typer extends Namer
             val pat1 = if (patType eq patType1) pat else pat.withType(patType1)
             patBuf += pat1
           }
+        case Select(pat, _) if tree.symbol == defn.QuotedType_splice =>
+          val sym = tree.tpe.dealias.typeSymbol.asType
+          val tdef = TypeDef(sym).withSpan(sym.span)
+          freshTypeBindingsBuff += transformTypeBindingTypeDef(tdef)
+          TypeTree(tree.tpe.dealias).withSpan(tree.span)
+
         case ddef: ValOrDefDef =>
           if (ddef.symbol.hasAnnotation(defn.InternalQuoted_patternBindHoleAnnot)) {
             val bindingType = ddef.symbol.info match {
@@ -2014,17 +2074,54 @@ 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) =>
+          transformTypeBindingTypeDef(tdef)
         case _ =>
           super.transform(tree)
       }
+
+      def transformTypeBindingTypeDef(tdef: TypeDef): Tree = {
+        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(tdef)
+      }
     }
-    val result = splitter.transform(quoted)
-    (result, splitter.patBuf.toList)
+    val shape0 = splitter.transform(quoted)
+    val patterns = splitter.patBuf.toList
+    val freshTypeBindings = freshTypeBindingsBuff.result()
+
+    val shape1 = seq(
+      freshTypeBindings,
+      shape0
+    )
+    val shape2 = {
+      if (freshTypeBindings.isEmpty) shape1
+      else {
+        val isFreshTypeBindings = freshTypeBindings.map(_.symbol).toSet
+        new TreeTypeMap(
+          typeMap = {
+            case tp: TypeRef if tp.typeSymbol == defn.QuotedType_splice =>
+              val tp1 = tp.dealias
+              if (isFreshTypeBindings(tp1.typeSymbol)) tp1
+              else tp
+            case tp => tp
+          }
+        ).transform(shape1)
+      }
+    }
+
+    (typeBindings.toMap, shape2, 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") {
@@ -2070,7 +2167,28 @@ class Typer extends Namer
         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)) {
+            ctx.error(i"Spliced type pattern must not be fully defined. Consider using $pt directly", tree.expr.sourcePos)
+            tree.withType(UnspecifiedErrorType)
+          } else {
+            def spliceOwner(ctx: Context): Symbol =
+              if (ctx.mode.is(Mode.QuotedPattern)) spliceOwner(ctx.outer) else ctx.owner
+            val name = expr match {
+              case Ident(name) => ("$" + name).toTypeName
+              case Typed(Ident(name), _) => ("$" + name).toTypeName
+              case Bind(name, _) => ("$" + name).toTypeName
+              case _ => NameKinds.UniqueName.fresh("$".toTypeName)
+            }
+            val typeSym = ctx.newSymbol(spliceOwner(ctx), name, EmptyFlags, TypeBounds.empty, NoSymbol, expr.span)
+            typeSym.addAnnotation(Annotation(New(ref(defn.InternalQuoted_patternBindHoleAnnot.typeRef)).withSpan(expr.span)))
+            val pat = typedPattern(expr, defn.QuotedTypeType.appliedTo(typeSym.typeRef))(
+                spliceContext.retractMode(Mode.QuotedPattern).withOwner(spliceOwner(ctx)))
+            pat.select(tpnme.splice)
+          }
+        } 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
-
 }