WIP

Author: nicolasstucki

Foo.scala

@@ -829,6 +829,24 @@ 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 mods = tree.mods.withAddedAnnotation(New(ref(defn.InternalQuoted_patternBindHoleAnnot.typeRef)).withSpan(tree.span))
+      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.
@@ -995,6 +1013,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/Desugar.scala

@@ -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/tpd.scala

@@ -472,6 +472,16 @@ class TreePickler(pickler: TastyPickler) {
         case Bind(name, body) =>
           registerDef(tree.symbol)
           writeByte(BIND)
+          println()
+          println(tree)
+          println(tree.isTerm)
+          println(name)
+          println(body)
+          println(tree.uniqueId)
+          println(tree.symbol)
+          println(tree.symbol.info)
+          println()
+          println()
           withLength {
             pickleName(name); pickleType(tree.symbol.info); pickleTree(body)
           }

compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala

@@ -1943,23 +1943,29 @@ 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 typeBindings = splices.collect {
-            case t if t.tpe.derivesFrom(defn.QuotedTypeClass) =>
-              t.tpe.widen.argTypesHi.head.typeSymbol
-          }
-          val inQuoteTypeBinding = typeBindings.map { sym =>
-            ctx.newSymbol(sym.owner, (sym.name + "$$$").toTypeName, // TODO remove $$$, just there for debugging
-              EmptyFlags, sym.info, coord = sym.coord)
-          }
-          val shape2 =
-            seq(inQuoteTypeBinding.map(TypeDef), shape.subst(typeBindings, inQuoteTypeBinding))
+          val (typeBindings, shape, splices) = splitQuotePattern(quoted1)
+//          val typeBindings = splices.collect {
+//            case t if t.tpe.derivesFrom(defn.QuotedTypeClass) =>
+//              t.tpe.widen.argTypesHi.head.typeSymbol
+//          }
+//          val inQuoteTypeBinding = typeBindings.map { sym =>
+//            ctx.newSymbol(sym.owner, (sym.name + "$$$").toTypeName, // TODO remove $$$, just there for debugging
+//              EmptyFlags, sym.info, coord = sym.coord)
+//          }
+//          val shape2 =
+//            seq(inQuoteTypeBinding.map(TypeDef), shape.subst(typeBindings, inQuoteTypeBinding))
+
+
           val patType = defn.tupleType(splices.tpes.map(_.widen))
+
+          val typeBindingsTuple = tpd.tupleTypeTree(typeBindings)
+
           val splicePat = typed(untpd.Tuple(splices.map(untpd.TypedSplice(_))).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(shape2) ::
+              ref(defn.InternalQuoted_exprQuoteR).appliedToType(shape.tpe).appliedTo(shape) ::
               implicitArgTree(defn.TastyReflectionType, tree.span) :: Nil,
             patterns = splicePat :: Nil,
             proto = pt)
@@ -1969,8 +1975,22 @@ class Typer extends Namer
     }
   }
 
-  def splitQuotePattern(quoted: Tree)(implicit ctx: Context): (Tree, List[Tree]) = {
+  def splitQuotePattern(quoted: Tree)(implicit ctx: Context): (List[Bind], Tree, List[Tree]) = {
     val ctx0 = ctx
+
+    val typeBindings: collection.mutable.Map[Symbol, Bind] = collection.mutable.Map.empty
+    def replaceTypeBindings = new TypeMap {
+      def apply(tp: Type): Type = tp match {
+        case tp: TypeRef if tp.typeSymbol.hasAnnotation(defn.InternalQuoted_patternBindHoleAnnot) =>
+          val bindingBounds = TypeBounds.apply(defn.NothingType, defn.AnyType) // TODO recover bounds
+          val sym = ctx.newPatternBoundSymbol((tp.name + "$").toTypeName, bindingBounds, quoted.span)
+          val bind = typeBindings.getOrElseUpdate(tp.typeSymbol,
+            Bind(sym, untpd.Ident(nme.WILDCARD).withType(bindingBounds)).withSpan(quoted.span))
+          bind.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 {
@@ -1981,8 +2001,18 @@ class Typer extends Namer
           try patternHole(tree)
           finally {
             val patType = pat.tpe.widen
-            val patType1 = patType.underlyingIfRepeated(isJava = false)
+            val patType1 = replaceTypeBindings(patType.underlyingIfRepeated(isJava = false))
             val pat1 = if (patType eq patType1) pat else pat.withType(patType1)
+            println("=-=-=-============-=-=-=----=-=-=")
+            println(pat)
+            println(pat.symbol)
+            println(pat.symbol.info)
+            println()
+            println(pat1)
+            println(pat1.symbol)
+            println(pat1.symbol.info)
+            println()
+            println()
             patBuf += pat1
           }
         case ddef: ValOrDefDef =>
@@ -2008,7 +2038,7 @@ class Typer extends Namer
       }
     }
     val result = splitter.transform(quoted)
-    (result, splitter.patBuf.toList)
+    (typeBindings.toList.map(_._2), result, splitter.patBuf.toList)
   }
 
   /** A hole the shape pattern of a quoted.Matcher.unapply, representing a splice */
@@ -2065,18 +2095,32 @@ class Typer extends Namer
       case expr =>
         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 {
-            val bindingBounds = TypeBounds.apply(defn.NothingType, defn.AnyType)
-            val sym = ctx.newPatternBoundSymbol("ttt".toTypeName, bindingBounds, expr.span)
-            val bind = Bind(sym, untpd.Ident(nme.WILDCARD).withType(bindingBounds)).withSpan(expr.span)
+            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)))
 
-            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 {

compiler/src/dotty/tools/dotc/typer/Typer.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-2.x/scala/internal/quoted/Matcher.scala

@@ -30,7 +30,7 @@ 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] = {
     import reflection.{Bind => BindPattern, _}
 
     // TODO improve performance

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

@@ -6,32 +6,32 @@ object Test {
 //  def g(x: Int, y: Int) = x * y
 
   def res given tasty.Reflection: quoted.Expr[Int] = x match {
-    case '{1 + 2} => '{0}
-    case '{f($y)} => y
-    case '{g($y, $z)} => '{$y * $z}
-    case '{ ((a: Int) => 3)($y) } => y
-    case '{ 1 + ($y: Int)} => y
-    case '{ val a = 1 + ($y: Int); 3 } => y
-    case '{ val $y: Int = $z; println(`$y`); 1 } =>
-      val a: quoted.matching.Bind[Int] = y
-      z
-    case '{ (($y: Int) => 1 + `$y` + ($z: Int))(2) } =>
-      val a: quoted.matching.Bind[Int] = y
-      z
-    case '{ def $ff: Int = $z; `$ff` } =>
-      val a: quoted.matching.Bind[Int] = ff
-      z
-    case '{ def $ff(i: Int): Int = $z; 2 } =>
-      val a: quoted.matching.Bind[Int => Int] = ff
-      z
-    case '{ def $ff(i: Int)(j: Int): Int = $z; 2 } =>
-      val a: quoted.matching.Bind[Int => Int => Int] = ff
-      z
-    case '{ def $ff[T](i: T): Int = $z; 2 } =>
-      val a: quoted.matching.Bind[[T] => T => Int] = ff
-      z
+//    case '{1 + 2} => '{0}
+//    case '{f($y)} => y
+//    case '{g($y, $z)} => '{$y * $z}
+//    case '{ ((a: Int) => 3)($y) } => y
+//    case '{ 1 + ($y: Int)} => y
+//    case '{ val a = 1 + ($y: Int); 3 } => y
+//    case '{ val $y: Int = $z; println(`$y`); 1 } =>
+//      val a: quoted.matching.Bind[Int] = y
+//      z
+//    case '{ (($y: Int) => 1 + `$y` + ($z: Int))(2) } =>
+//      val a: quoted.matching.Bind[Int] = y
+//      z
+//    case '{ def $ff: Int = $z; `$ff` } =>
+//      val a: quoted.matching.Bind[Int] = ff
+//      z
+//    case '{ def $ff(i: Int): Int = $z; 2 } =>
+//      val a: quoted.matching.Bind[Int => Int] = ff
+//      z
+//    case '{ def $ff(i: Int)(j: Int): Int = $z; 2 } =>
+//      val a: quoted.matching.Bind[Int => Int => Int] = ff
+//      z
+//    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 = $x; (${scala.quoted.matching.Bind(t2)}: x.type); 4 } if t == t2 => ???
+    case '{ type $T; val x: $T = $a; val y: $T = x;  1 } => ???
     case _ => '{1}
   }