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

@@ -231,7 +231,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
   }
 
   def termClassTag: ClassTag[Term] = implicitly[ClassTag[Term]]
@@ -378,7 +378,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
@@ -405,7 +405,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]]
@@ -451,7 +451,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 ------------------------------------------------
@@ -462,7 +462,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
   }
 
   val Synthetic: SyntheticExtractor = new SyntheticExtractor {
@@ -605,35 +605,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
     }
   }
@@ -668,7 +668,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
     }
   }

library/src/scala/tasty/Tasty.scala

@@ -335,7 +335,7 @@ abstract class Tasty {
   type MaybeTypeTree
 
   trait AbstractMaybeTypeTree {
-    def tpe: MaybeType
+    def tpe(implicit ctx: Context): MaybeType
   }
   implicit def MaybeTypeTreeDeco(x: MaybeTypeTree): AbstractMaybeTypeTree
 
@@ -420,7 +420,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,50 @@
+
+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))
+}
+
+trait Size[Keys] { def size: Int }
+object Size {
+  def apply[Keys](v: Int): Size[Keys] = new Size { def size = v }
+  implicit val unit: Size[Unit] = Size(0)
+  implicit def cons[H, T](implicit s: Size[T]): Size[(H, T)] = Size(s.size + 1)
+}
+
+class Index[K, Keys](val index: Int) extends AnyVal
+object Index {
+
+  implicit 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
+  }
+}