Add basic structure for refined selectable macros

Co-authored-by: Nicolas Stucki <nicolas.stucki@gmail.com>

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} ]
+ }
+}