Add basic structure for refined selectable macros

Co-authored-by: Nicolas Stucki <[email protected]>

Author: biboudis

compiler/src/dotty/tools/dotc/tastyreflect/ReflectionCompilerInterface.scala

@@ -272,6 +272,11 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
     case _ => term
   }
 
+  def TypeRef_apply(sym: Symbol)(given Context): TypeTree = {
+    assert(sym.isType)
+    withDefaultPos(tpd.ref(sym).asInstanceOf[tpd.TypeTree])
+  }
+
   type Ref = tpd.RefTree
 
   def isInstanceOfRef(given ctx: Context): IsInstanceOf[Ref] = new {
@@ -281,8 +286,10 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
       case _ => None
   }
 
-  def Ref_apply(sym: Symbol)(given Context): Ref =
+  def Ref_apply(sym: Symbol)(given Context): Ref = {
+    assert(sym.isTerm)
     withDefaultPos(tpd.ref(sym).asInstanceOf[tpd.RefTree])
+  }
 
   type Ident = tpd.Ident
 

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

@@ -523,7 +523,7 @@ object Erasure {
     }
 
     override def typedTypeApply(tree: untpd.TypeApply, pt: Type)(implicit ctx: Context): Tree = {
-      val ntree = interceptTypeApply(tree.asInstanceOf[TypeApply])(ctx.withPhase(ctx.erasurePhase))
+      val ntree = interceptTypeApply(tree.asInstanceOf[TypeApply])(ctx.withPhase(ctx.erasurePhase)).withSpan(tree.span)
 
       ntree match {
         case TypeApply(fun, args) =>

library/src/scala/tasty/reflect/CompilerInterface.scala

@@ -559,6 +559,8 @@ trait CompilerInterface {
 
   def Inferred_apply(tpe: Type)(given ctx: Context): Inferred
 
+  def TypeRef_apply(sym: Symbol)(given ctx: Context): TypeTree
+
   /** Type tree representing a reference to definition with a given name */
   type TypeIdent <: TypeTree
 

library/src/scala/tasty/reflect/ExtractorsPrinter.scala

@@ -190,7 +190,7 @@ class ExtractorsPrinter[R <: Reflection & Singleton](val tasty: R) extends Print
       case TypeRef(qual, name) =>
         this += "TypeRef(" += qual += ", \"" += name += "\")"
       case Refinement(parent, name, info) =>
-        this += "Refinement(" += parent += ", " += name += ", " += info += ")"
+        this += "Refinement(" += parent += ", \"" += name += "\", " += info += ")"
       case AppliedType(tycon, args) =>
         this += "AppliedType(" += tycon += ", " ++= args += ")"
       case AnnotatedType(underlying, annot) =>

library/src/scala/tasty/reflect/TreeOps.scala

@@ -892,7 +892,8 @@ trait TreeOps extends Core {
     def unapply(x: TypeIdent): Some[TypeIdent] = Some(x)
 
   object TypeIdent {
-    // TODO def apply(name: String)(given ctx: Context): TypeIdent
+    def apply(sym: Symbol)(given ctx: Context): TypeTree =
+      internal.TypeRef_apply(sym)
     def copy(original: Tree)(name: String)(given ctx: Context): TypeIdent =
       internal.TypeIdent_copy(original)(name)
     def unapply(x: TypeIdent)(given ctx: Context): Option[String] = Some(x.name)

tests/run-macros/structural-macro.check

@@ -0,0 +1 @@
+((name,Emma),(age,42))

tests/run-macros/structural-macro/Macro_1.scala

@@ -0,0 +1,68 @@
+import scala.quoted._
+
+object Macro {
+
+  case class Record(elems: (String, Any)*) extends Selectable {
+    def selectDynamic(name: String): Any = elems.find(_._1 == name).get._2
+  }
+
+  inline def toHMap(s: Selectable) <: Tuple = ${ toHMapImpl('s)}
+
+  def toHMapImpl(s: Expr[Selectable])(given qctx:QuoteContext): Expr[Tuple] = {
+    import qctx.tasty.{given, _}
+
+    val repr = s.unseal.tpe.widenTermRefExpr.dealias
+
+    def rec(tpe: Type): List[(String, Type)] = {
+      tpe match {
+        case Refinement(parent, name, info: Type) => (name, info) :: rec(parent)
+        case _ => Nil
+      }
+    }
+
+    def tupleElem(name: String, info: Type): Expr[Any] = {
+      val nameExpr = Expr(name)
+      info.seal match {
+        case '[$qType] =>
+          Expr.ofTuple(Seq(nameExpr, '{$s.selectDynamic($nameExpr).asInstanceOf[$qType]}))
+      }
+    }
+
+    // val list = println(rec(repr))
+
+    val ret = rec(repr).reverse.map(e => tupleElem(e._1, e._2))
+
+    Expr.ofTuple(ret)
+  }
+
+  inline def toSelectable[T](s: Tuple)<: T = ${ toSelectableImpl('s, '[T])}
+
+  def toSelectableImpl[T](s: Expr[Tuple], tpe: Type[T])(given qctx:QuoteContext): Expr[T] = {
+    import qctx.tasty.{given, _}
+
+    val repr = s.unseal.tpe.widenTermRefExpr.dealias
+
+    println(repr.show)
+    println(repr.showExtractors)
+
+    // new Record((res2._1._1, res2._1._2), (res2._2._1, res2._2._2)).asInstanceOf[Record {val name: String; val age: Int} ]
+
+    def rec(tpe: Type): List[(String, Type)] = {
+      tpe match {
+        // todo: check number based on prefix
+        case AppliedType(_, args) => args.map{
+          case AppliedType(_, ConstantType(Constant(name: String)) :: (info: Type) :: Nil) => (name, info)
+        }
+      }
+    }
+    val r = rec(repr)
+    println(r)
+
+    println(tpe.unseal.symbol)
+    println(TypeIdent(tpe.unseal.symbol))
+
+    println('{new Record()}.unseal.showExtractors)
+
+    '{ ??? }
+  }
+}

tests/run-macros/structural-macro/Test_2.scala

@@ -0,0 +1,21 @@
+import Macro._
+
+object Test {
+
+  type Person = Record {
+    val name: String
+    val age: Int
+  }
+
+  def main(args: Array[String]): Unit = {
+    val person: Person = Record("name" -> "Emma", "age" -> 42).asInstanceOf[Person]
+
+    val res: (("name", String), ("age", Int)) = toHMap(person)
+
+    println(res)
+
+    val res2: Person = toSelectable[Record](res)
+
+    // new Record((res2._1._1, res2._1._2), (res2._2._1, res2._2._2)).asInstanceOf[Record {val name: String; val age: Int} ]
+  }
+}