Add indexed map test and couple of fixes

* Remove type vars from tasty types
* Fix impure by name arguments to macros

Author: nicolasstucki

compiler/src/dotty/tools/dotc/tasty/TastyImpl.scala

@@ -234,7 +234,7 @@ object TastyImpl extends scala.tasty.Tasty {
 
   implicit def TermDeco(t: Term): AbstractTerm = new AbstractTerm {
     def pos(implicit ctx: Context): Position = new TastyPosition(t.pos)
-    def tpe: Types.Type = t.tpe
+    def tpe(implicit ctx: Context): Types.Type = t.tpe.stripTypeVar
 
     def toExpr[T: quoted.Type](implicit ctx: Context): quoted.Expr[T] = {
       def typecheck(implicit ctx0: FreshContext) = {
@@ -410,7 +410,7 @@ object TastyImpl extends scala.tasty.Tasty {
     def unapply(x: Term)(implicit ctx: Context): Option[(Term, Int, Type)] = x match {
       case x: tpd.Select @unchecked =>
         x.name match {
-          case NameKinds.OuterSelectName(_, levels) => Some((x.qualifier, levels, x.tpe))
+          case NameKinds.OuterSelectName(_, levels) => Some((x.qualifier, levels, x.tpe.stripTypeVar))
           case _ => None
         }
       case _ => None
@@ -437,7 +437,7 @@ object TastyImpl extends scala.tasty.Tasty {
 
   implicit def PatternDeco(x: Pattern): AbstractPattern = new AbstractPattern {
     def pos(implicit ctx: Context): Position = new TastyPosition(x.pos)
-    def tpe: Types.Type = x.tpe
+    def tpe(implicit ctx: Context): Types.Type = x.tpe.stripTypeVar
   }
 
   def patternClassTag: ClassTag[Pattern] = implicitly[ClassTag[Pattern]]
@@ -483,7 +483,7 @@ object TastyImpl extends scala.tasty.Tasty {
   type MaybeTypeTree = tpd.Tree
 
   implicit def MaybeTypeTreeDeco(x: MaybeTypeTree): AbstractMaybeTypeTree = new AbstractMaybeTypeTree {
-    def tpe: Type = x.tpe
+    def tpe(implicit ctx: Context): Type = x.tpe.stripTypeVar
   }
 
   // ----- TypeTrees ------------------------------------------------
@@ -494,7 +494,7 @@ object TastyImpl extends scala.tasty.Tasty {
 
   implicit def TypeTreeDeco(x: TypeTree): AbstractTypeTree = new AbstractTypeTree {
     def pos(implicit ctx: Context): Position = new TastyPosition(x.pos)
-    def tpe: Types.Type = x.tpe
+    def tpe(implicit ctx: Context): Types.Type = x.tpe.stripTypeVar
     def toType(implicit ctx: Context): quoted.Type[_] = new quoted.Types.TreeType(x)
   }
 
@@ -638,35 +638,35 @@ object TastyImpl extends scala.tasty.Tasty {
 
   val AppliedType: AppliedTypeExtractor = new AppliedTypeExtractor {
     def unapply(x: Type)(implicit ctx: Context): Option[(Type, List[MaybeType /* Type | TypeBounds */])] = x match {
-      case Types.AppliedType(tycon, args) => Some((tycon, args))
+      case Types.AppliedType(tycon, args) => Some((tycon.stripTypeVar, args.map(_.stripTypeVar)))
       case _ => None
     }
   }
 
   val AnnotatedType: AnnotatedTypeExtractor = new AnnotatedTypeExtractor {
     def unapply(x: Type)(implicit ctx: Context): Option[(Type, Term)] = x match {
-      case Types.AnnotatedType(underlying, annot) => Some((underlying, annot.tree))
+      case Types.AnnotatedType(underlying, annot) => Some((underlying.stripTypeVar, annot.tree))
       case _ => None
     }
   }
 
   val AndType: AndTypeExtractor = new AndTypeExtractor {
     def unapply(x: Type)(implicit ctx: Context): Option[(Type, Type)] = x match {
-      case Types.AndType(left, right) => Some(left, right)
+      case Types.AndType(left, right) => Some(left.stripTypeVar, right.stripTypeVar)
       case _ => None
     }
   }
 
   val OrType: OrTypeExtractor = new OrTypeExtractor {
     def unapply(x: Type)(implicit ctx: Context): Option[(Type, Type)] = x match {
-      case Types.OrType(left, right) => Some(left, right)
+      case Types.OrType(left, right) => Some(left.stripTypeVar, right.stripTypeVar)
       case _ => None
     }
   }
 
   val ByNameType: ByNameTypeExtractor = new ByNameTypeExtractor {
     def unapply(x: Type)(implicit ctx: Context): Option[Type] = x match {
-      case Types.ExprType(resType) => Some(resType)
+      case Types.ExprType(resType) => Some(resType.stripTypeVar)
       case _ => None
     }
   }
@@ -701,7 +701,7 @@ object TastyImpl extends scala.tasty.Tasty {
 
   val RecursiveType: RecursiveTypeExtractor = new RecursiveTypeExtractor {
     def unapply(x: RecursiveType)(implicit ctx: Context): Option[Type] = x match {
-      case tp: Types.RecType => Some(tp.underlying)
+      case tp: Types.RecType => Some(tp.underlying.stripTypeVar)
       case _ => None
     }
   }

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

@@ -63,7 +63,7 @@ object Splicer {
    */
   private def getLiftedArgs(call: Tree, bindings: List[Tree])(implicit ctx: Context): List[Any] = {
     val bindMap = bindings.map {
-      case vdef: ValDef => (vdef.rhs, ref(vdef.symbol).withPos(vdef.rhs.pos))
+      case vdef: ValOrDefDef => (vdef.rhs, ref(vdef.symbol).withPos(vdef.rhs.pos))
     }.toMap
     def allArgs(call: Tree, acc: List[List[Tree]]): List[List[Tree]] = call match {
       case call: Apply => allArgs(call.fun, call.args :: acc)

library/src/scala/tasty/Tasty.scala

@@ -338,7 +338,7 @@ abstract class Tasty {
   type MaybeTypeTree
 
   trait AbstractMaybeTypeTree {
-    def tpe: MaybeType
+    def tpe(implicit ctx: Context): MaybeType
   }
   implicit def MaybeTypeTreeDeco(x: MaybeTypeTree): AbstractMaybeTypeTree
 
@@ -425,7 +425,7 @@ abstract class Tasty {
   type MaybeType
 
   trait Typed {
-    def tpe: Type
+    def tpe(implicit ctx: Context): Type
   }
 
   // ----- Types ----------------------------------------------------

tests/run/tasty-indexed-map/quoted_1.scala

@@ -0,0 +1,65 @@
+
+import scala.quoted._
+
+import scala.tasty.Universe
+import scala.tasty.util.TastyPrinter
+
+class MyMap[Keys](private val underlying: Array[Int]) extends AnyVal {
+  def get[K <: String](implicit i: Index[K, Keys]): Int = underlying(i.index)
+  def set[K <: String](value: Int)(implicit i: Index[K, Keys]): Unit = underlying(i.index) = value
+}
+
+object MyMap {
+  def create[Keys](implicit s: Size[Keys]): MyMap[Keys] = new MyMap[Keys](new Array[Int](s.size))
+}
+
+class Size[HList](val size: Int) extends AnyVal
+object Size {
+  type HList = Cons[_, _] | Unit
+  type Cons[H, T <: HList] = (H, T)
+
+  implicit inline def getSize[HL <: HList]: Size[HL] = ~sizeImpl(Universe.compilationUniverse)('[HL])
+
+  def sizeImpl[HL <: HList](u: Universe)(implicit keys: Type[HL]): Expr[Size[HL]] = {
+    import u._
+    import u.tasty._
+
+    def sizeOf(tp: MaybeType): Int = tp match {
+      case AppliedType(_, h :: t :: Nil) => 1 + sizeOf(t)
+      case _ => 0
+    }
+
+    val size = sizeOf(keys.toTasty.tpe)
+
+    '(new Size(~size.toExpr))
+  }
+}
+
+class Index[K, Keys](val index: Int) extends AnyVal
+object Index {
+
+  implicit inline def zero[K, T]: Index[K, (K, T)] = new Index(0)
+
+  implicit inline def succ[K, H, T](implicit prev: => Index[K, T]): Index[K, (H, T)] = ~succImpl(Universe.compilationUniverse)('[K], '[H], '[T])
+
+  def succImpl[K, H, T](u: Universe)(implicit k: Type[K], h: Type[H], t: Type[T]): Expr[Index[K, (H, T)]] = {
+    import u._
+    import u.tasty._
+
+    def name(tp: MaybeType): String = tp match {
+      case ConstantType(StringConstant(str)) => str
+    }
+
+    def names(tp: MaybeType): List[String] = tp match {
+      case AppliedType(_, x1 :: x2 :: Nil) => name(x1) :: names(x2)
+      case _ => Nil
+    }
+
+    val key = name(k.toTasty.tpe)
+    val keys = name(h.toTasty.tpe) :: names(t.toTasty.tpe)
+
+    val index = keys.indexOf(key)
+
+    '(new Index(~index.toExpr))
+  }
+}

tests/run/tasty-indexed-map/quoted_2.scala

@@ -0,0 +1,18 @@
+object Test {
+
+  def main(args: Array[String]): Unit = {
+    val map = MyMap.create[("foo", ("bar", ("baz", Unit)))]
+
+    map.set["foo"](9)
+    assert(map.get["foo"] == 9)
+
+    map.set["bar"](42)
+    assert(map.get["bar"] == 42)
+
+    map.set["baz"](42)
+    assert(map.get["baz"] == 42)
+
+//    map.set["banana"](42) // error
+//    assert(map.get["banana"] == 42) // error
+  }
+}