Support GenIso for case class with one field

Author: liufengyun

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

@@ -383,6 +383,9 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with RootPositionImpl with
     }
 
     object Ident extends IdentModule {
+      def apply(tmref: TermRef)(implicit ctx: Context): Ident =
+        withDefaultPos(implicit ctx => tpd.Ident(tmref))
+
       def copy(original: Tree)(name: String)(implicit ctx: Context): Ident =
         tpd.cpy.Ident(original)(name.toTermName)
 

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

@@ -1,6 +1,7 @@
 package dotty.tools.dotc.tastyreflect
 
 import dotty.tools.dotc.core.{Contexts, Names, Types}
+import dotty.tools.dotc.core.Decorators._
 
 trait TypeOrBoundsOpsImpl extends scala.tasty.reflect.TypeOrBoundsOps with CoreImpl {
 
@@ -23,6 +24,9 @@ trait TypeOrBoundsOpsImpl extends scala.tasty.reflect.TypeOrBoundsOps with CoreI
       if (tpe.classSymbol.exists) Some(tpe.classSymbol.asClass) else None
 
     def typeSymbol(implicit ctx: Context): Symbol = tpe.typeSymbol
+
+    def memberType(member: Symbol)(implicit ctx: Context): Type =
+      member.info.asSeenFrom(tpe, member.owner)
   }
 
   def ConstantTypeDeco(x: ConstantType): Type.ConstantTypeAPI = new Type.ConstantTypeAPI {
@@ -181,6 +185,9 @@ trait TypeOrBoundsOpsImpl extends scala.tasty.reflect.TypeOrBoundsOps with CoreI
     }
 
     object TermRef extends TermRefModule {
+      def apply(qual: TypeOrBounds, name: String)(implicit ctx: Context): TermRef =
+        Types.TermRef(qual, name.toTermName)
+
       def unapply(x: TypeOrBounds)(implicit ctx: Context): Option[(String, TypeOrBounds /* Type | NoPrefix */)] = x match {
         case tp: Types.NamedType =>
           tp.designator match {

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

@@ -2,7 +2,6 @@ package scala.tasty
 package reflect
 
 trait TreeOps extends Core {
-
   // Decorators
 
   implicit def TreeDeco(tree: Tree): TreeAPI
@@ -249,6 +248,7 @@ trait TreeOps extends Core {
     /** Scala term identifier */
     val Ident: IdentModule
     abstract class IdentModule {
+      def apply(tmref: TermRef)(implicit ctx: Context): Ident
 
       def copy(original: Tree)(name: String)(implicit ctx: Context): Ident
 

library/src/scala/tasty/reflect/TypeOrBoundsOps.scala

@@ -55,6 +55,7 @@ trait TypeOrBoundsOps extends Core {
     def widen(implicit ctx: Context): Type
     def classSymbol(implicit ctx: Context): Option[ClassSymbol]
     def typeSymbol(implicit ctx: Context): Symbol
+    def memberType(member: Symbol)(implicit ctx: Context): Type
   }
 
   val IsType: IsTypeModule
@@ -107,6 +108,7 @@ trait TypeOrBoundsOps extends Core {
 
     val TermRef: TermRefModule
     abstract class TermRefModule {
+      def apply(qual: TypeOrBounds, name: String)(implicit ctx: Context): TermRef
       def unapply(typeOrBounds: TypeOrBounds)(implicit ctx: Context): Option[(String, TypeOrBounds /* Type | NoPrefix */)]
     }
 

tests/run-with-compiler/i5941/macro_1.scala

@@ -1,4 +1,4 @@
-abstract class Lens[S, T] {
+trait Lens[S, T] {
   def get(s: S): T
   def set(t: T, s: S) :S
 }
@@ -19,15 +19,15 @@ object Lens {
 
 
     // obj.copy(a = obj.a.copy(b = a.b.copy(c = v)))
-    def setterBody(obj: Term, value: Term, fields: List[String]): Term = {
+    def setterBody(obj: Term, value: Term, parts: List[String]): Term = {
       // o.copy(field = value)
       def helper(obj: Term, value: Term, field: String): Term =
         Term.Select.overloaded(obj, "copy", Nil, Term.NamedArg(field, value) :: Nil)
 
-      fields match {
+      parts match {
         case field :: Nil => helper(obj, value, field)
-        case field :: fields =>
-          helper(obj, setterBody(Term.Select.unique(obj, field), value, fields), field)
+        case field :: parts =>
+          helper(obj, setterBody(Term.Select.unique(obj, field), value, parts), field)
       }
     }
 
@@ -56,9 +56,9 @@ object Lens {
 
     // exception: getter.unseal.underlyingArgument
     getter.unseal match {
-      case Function(param :: Nil, Path(o, fields)) if o.symbol == param.symbol =>
+      case Function(param :: Nil, Path(o, parts)) if o.symbol == param.symbol =>
         '{
-          val setter = (t: T) => (s: S) => ~setterBody(('(s)).unseal, ('(t)).unseal, fields).seal[S]
+          val setter = (t: T) => (s: S) => ~setterBody(('(s)).unseal, ('(t)).unseal, parts).seal[S]
           apply(~getter)(setter)
         }
       case _ =>
@@ -79,4 +79,93 @@ object GenLens {
   class MkGenLens[S] {
     inline def apply[T](get: => (S => T)): Lens[S, T] = ~Lens.impl('(get))
   }
+}
+
+trait Iso[S, A] {
+  def from(a: A): S
+  def to(s: S): A
+}
+
+object Iso {
+  def apply[S, A](_from: A => S)(_to: S => A): Iso[S, A] = new Iso {
+    def from(a: A): S = _from(a)
+    def to(s: S): A = _to(s)
+  }
+
+  def impl[S: Type, A: Type](implicit refl: Reflection): Expr[Iso[S, A]] = {
+    import refl._
+    import util._
+    import quoted.Toolbox.Default._
+
+    val tpS = typeOf[S]
+    val tpA = typeOf[A]
+
+    // 1. S must be a case class
+    // 2. A must be a tuple
+    // 3. The parameters of S must match A
+    if (tpS.classSymbol.flatMap(cls => if (cls.flags.is(Flags.Case)) Some(true) else None).isEmpty)
+      throw new QuoteError("Only support generation for case classes")
+
+    val cls = tpS.classSymbol.get
+
+    val companion = tpS match {
+      case Type.SymRef(sym, prefix)   => Type.TermRef(prefix, sym.name)
+      case Type.TypeRef(name, prefix) => Type.TermRef(prefix, name)
+    }
+
+    if (cls.caseFields.size != 1)
+      throw new QuoteError("Use GenIso.fields for case classes more than one parameter")
+
+    val fieldTp = tpS.memberType(cls.caseFields.head)
+    if (!(fieldTp =:= tpA))
+      throw new QuoteError(s"The type of case class field $fieldTp does not match $tpA")
+
+    '{
+      // (p: S) => p._1
+      val to = (p: S) =>  ~{ Term.Select.unique(('(p)).unseal, "_1").seal[A] }
+      // (p: A) => S(p)
+      val from = (p: A) =>  ~{ Term.Select.overloaded(Term.Ident(companion), "apply", Nil, ('(p)).unseal :: Nil).seal[S] }
+      apply(from)(to)
+    }
+  }
+}
+
+object GenIso {
+  /**
+   *   GenIso[Person, String]  ~~>
+   *
+   *   Iso[Person, String]
+   *     { p => p._1 }
+   *     { p => Person(p) }
+   */
+  inline def apply[S, A]: Iso[S, A] = ~Iso.impl[S, A]
+
+  inline def fields[S, A]: Iso[S, A] = ???
+  inline def unit[S]: Iso[S, Unit] = ???
+}
+
+trait Prism[S, A] {
+  def getOption(s: S): Option[A]
+  def apply(a: A): S
+}
+
+object Prism {
+  def apply[S, A](getOpt: S => Option[A])(app: A => S): Prism[S, A] = new Prism {
+    def getOption(s: S): Option[A] = getOpt(s)
+    def apply(a: A): S = app(a)
+  }
+
+  def impl[S: Type, A: Type](implicit refl: Reflection): Expr[Prism[S, A]] = ???
+}
+
+object GenPrism {
+  /**
+   *   GenPrism[Json, JStr]  ~~>
+   *
+   *   Prism[Json, JStr]{
+   *     case JStr(v) => Some(v)
+   *      case _      => None
+   *   }(jstr => jstr)
+   */
+  inline def apply[S, A]: Prism[S, A] = ~Prism.impl[S, A]
 }

tests/run-with-compiler/i5941/usage_2.scala

@@ -1,7 +1,12 @@
 case class Address(streetNumber: Int, streetName: String)
-
 case class Employee(name: String, addr: Address)
 
+sealed trait Json
+case object JNull extends Json
+case class JStr(v: String) extends Json
+case class JNum(v: Double) extends Json
+case class JObj(v: Map[String, Json]) extends Json
+
 object Test {
   def main(args: Array[String]): Unit = {
     val len = GenLens[Address](_.streetNumber)
@@ -10,11 +15,20 @@ object Test {
     val addr2 = len.set(5, address)
     assert(len.get(addr2) == 5)
 
+    // a.b.c
     val len2 = GenLens[Employee](_.addr.streetNumber)
     val employee = Employee("Bob", Address(10, "High Street"))
     assert(len2.get(employee) == 10)
     val employee2 = len2.set(5, employee)
     assert(employee2.name == "Bob")
     assert(len2.get(employee2) == 5)
+
+    // prism
+    // val jStr: Prism[Json, JStr] = GenPrism[Json, JStr]
+    // assert(jStr.getOption(JNum(4.5)) == None)
+    // assert(jStr.getOption(JStr("hello")) == Some(JStr("hello")))
+    // assert(jStr(JStr("world")) == JStr("world"))
+
+    assert(GenIso[JStr, String].to(JStr("Hello")) == "Hello")
   }
 }