Split Select(Only)Field(WithImplicits)

NTPape · NTPape · commit 7b6df5d30a75 · 2022-03-04T22:33:21.000+01:00
diff --git a/core/shared/src/main/scala-3.x/monocle/internal/focus/ErrorHandling.scala b/core/shared/src/main/scala-3.x/monocle/internal/focus/ErrorHandling.scala
@@ -6,6 +6,8 @@ private[focus] trait ErrorHandling {
   def errorMessage(error: FocusError): String = error match {
     case FocusError.NotACaseClass(fromClass, fieldName) =>
       s"Cannot generate Lens for field '$fieldName', because '$fromClass' is not a case class"
+    case FocusError.NotACaseField(caseClass, fieldName) =>
+      s"Can only create lenses for case fields, but '$fieldName' is not a case field of '$caseClass'"
     case FocusError.NotAConcreteClass(fromClass) =>
       s"Expecting a concrete case class in the 'From' position; cannot reify type $fromClass"
     case FocusError.NotASimpleLambdaFunction =>
diff --git a/core/shared/src/main/scala-3.x/monocle/internal/focus/FocusBase.scala b/core/shared/src/main/scala-3.x/monocle/internal/focus/FocusBase.scala
@@ -13,18 +13,16 @@ private[focus] trait FocusBase {
   case class LambdaConfig(argName: String, lambdaBody: Term)
 
   enum FocusAction {
-    case SelectField(
-      fieldName: String,
-      fromType: TypeRepr,
-      toType: TypeRepr,
-      setter: Term
-    )
+    case SelectField(fieldName: String, fromType: TypeRepr, fromTypeArgs: List[TypeRepr], toType: TypeRepr)
+    case SelectFieldWithImplicits(fieldName: String, fromType: TypeRepr, toType: TypeRepr, setter: Term)
     case SelectOnlyField(
       fieldName: String,
       fromType: TypeRepr,
-      toType: TypeRepr,
-      reverseGet: Term
+      fromTypeArgs: List[TypeRepr],
+      fromCompanion: Term,
+      toType: TypeRepr
     )
+    case SelectOnlyFieldWithImplicits(fieldName: String, fromType: TypeRepr, toType: TypeRepr, reverseGet: Term)
     case KeywordSome(toType: TypeRepr)
     case KeywordAs(fromType: TypeRepr, toType: TypeRepr)
     case KeywordEach(fromType: TypeRepr, toType: TypeRepr, eachInstance: Term)
@@ -33,10 +31,14 @@ private[focus] trait FocusBase {
     case KeywordWithDefault(toType: TypeRepr, defaultValue: Term)
 
     override def toString(): String = this match {
-      case SelectField(fieldName, fromType, toType, setter) =>
-        s"SelectField($fieldName, ${fromType.show}, ${toType.show}, ${setter.asExpr.show})"
-      case SelectOnlyField(fieldName, fromType, toType, reverseGet) =>
-        s"SelectOnlyField($fieldName, ${fromType.show}, ${toType.show}, ${reverseGet.asExpr.show})"
+      case SelectField(fieldName, fromType, fromTypeArgs, toType) =>
+        s"SelectField($fieldName, ${fromType.show}, ${fromTypeArgs.map(_.show)}, ${toType.show})"
+      case SelectFieldWithImplicits(fieldName, fromType, toType, setter) =>
+        s"SelectFieldWithImplicits($fieldName, ${fromType.show}, ${toType.show}, ...)"
+      case SelectOnlyField(fieldName, fromType, fromTypeArgs, _, toType) =>
+        s"SelectOnlyField($fieldName, ${fromType.show}, ${fromTypeArgs.map(_.show)}, ..., ${toType.show})"
+      case SelectOnlyFieldWithImplicits(fieldName, fromType, toType, reverseGet) =>
+        s"SelectOnlyFieldWithImplicits($fieldName, ${fromType.show}, ${toType.show}, ...)"
       case KeywordSome(toType)                  => s"KeywordSome(${toType.show})"
       case KeywordAs(fromType, toType)          => s"KeywordAs(${fromType.show}, ${toType.show})"
       case KeywordEach(fromType, toType, _)     => s"KeywordEach(${fromType.show}, ${toType.show}, ...)"
@@ -48,6 +50,7 @@ private[focus] trait FocusBase {
 
   enum FocusError {
     case NotACaseClass(className: String, fieldName: String)
+    case NotACaseField(className: String, fieldName: String)
     case NotAConcreteClass(className: String)
     case DidNotDirectlyAccessArgument(argName: String)
     case NotASimpleLambdaFunction
diff --git a/core/shared/src/main/scala-3.x/monocle/internal/focus/features/GeneratorLoop.scala b/core/shared/src/main/scala-3.x/monocle/internal/focus/features/GeneratorLoop.scala
@@ -39,14 +39,16 @@ private[focus] trait GeneratorLoop {
 
   private def generateActionCode(action: FocusAction): Term =
     action match {
-      case a: FocusAction.SelectField        => generateSelectField(a)
-      case a: FocusAction.SelectOnlyField    => generateSelectOnlyField(a)
-      case a: FocusAction.KeywordSome        => generateSome(a)
-      case a: FocusAction.KeywordAs          => generateAs(a)
-      case a: FocusAction.KeywordEach        => generateEach(a)
-      case a: FocusAction.KeywordAt          => generateAt(a)
-      case a: FocusAction.KeywordIndex       => generateIndex(a)
-      case a: FocusAction.KeywordWithDefault => generateWithDefault(a)
+      case a: FocusAction.SelectField                  => generateSelectField(a)
+      case a: FocusAction.SelectFieldWithImplicits     => generateSelectFieldWithImplicits(a)
+      case a: FocusAction.SelectOnlyField              => generateSelectOnlyField(a)
+      case a: FocusAction.SelectOnlyFieldWithImplicits => generateSelectOnlyFieldWithImplicits(a)
+      case a: FocusAction.KeywordSome                  => generateSome(a)
+      case a: FocusAction.KeywordAs                    => generateAs(a)
+      case a: FocusAction.KeywordEach                  => generateEach(a)
+      case a: FocusAction.KeywordAt                    => generateAt(a)
+      case a: FocusAction.KeywordIndex                 => generateIndex(a)
+      case a: FocusAction.KeywordWithDefault           => generateWithDefault(a)
     }
 
   private def composeOptics(lens1: Term, lens2: Term): FocusResult[Term] =
diff --git a/core/shared/src/main/scala-3.x/monocle/internal/focus/features/SelectParserBase.scala b/core/shared/src/main/scala-3.x/monocle/internal/focus/features/SelectParserBase.scala
@@ -13,9 +13,9 @@ private[focus] trait SelectParserBase extends ParserBase {
 
   // Match on a term that is an instance of a case class
   object CaseClass {
-    def unapply(term: Term): Option[Term] =
+    def unapply(term: Term): Option[(Term, Symbol)] =
       term.tpe.classSymbol.flatMap { sym =>
-        Option.when(sym.flags.is(Flags.Case))(term)
+        Option.when(sym.flags.is(Flags.Case))((term, sym))
       }
   }
 
@@ -86,11 +86,17 @@ private[focus] trait SelectParserBase extends ParserBase {
           case Block(List(DefDef(_, List(params), _, _)), _) =>
             params.params.foldLeft[FocusResult[List[Term]]](Right(List.empty[Term])) {
               case (Right(acc), ValDef(_, t, _)) =>
-                val typeRepr: TypeRepr = t.tpe.dealias
-                Implicits.search(typeRepr) match {
-                  case success: ImplicitSearchSuccess => Right(success.tree :: acc)
-                  case _                              => FocusError.ImplicitNotFound(typeRepr.show).asResult
-                }
+                def searchForImplicit(typeRepr: TypeRepr): FocusResult[Term] =
+                  Implicits.search(typeRepr) match {
+                    case success: ImplicitSearchSuccess => Right(success.tree)
+                    case _                              => FocusError.ImplicitNotFound(typeRepr.show).asResult
+                  }
+                searchForImplicit(t.tpe)
+                  .orElse(searchForImplicit(t.tpe.dealias))
+                  .orElse(searchForImplicit(t.tpe.widen))
+                  .orElse(searchForImplicit(t.tpe.widen.dealias))
+                  .map(acc :+ _)
+
               case (Right(acc), other) =>
                 FocusError.ExpansionFailed(s"Expected value definition but found unexpected ${other.show}").asResult
               case (left @ Left(_), _) =>
diff --git a/core/shared/src/main/scala-3.x/monocle/internal/focus/features/selectfield/SelectFieldGenerator.scala b/core/shared/src/main/scala-3.x/monocle/internal/focus/features/selectfield/SelectFieldGenerator.scala
@@ -8,13 +8,32 @@ private[focus] trait SelectFieldGenerator {
 
   import macroContext.reflect._
 
+  private def generateGetter(from: Term, fieldName: String): Term =
+    Select.unique(from, fieldName) // o.field
+
   def generateSelectField(action: FocusAction.SelectField): Term = {
+    import action.{fieldName, fromType, fromTypeArgs, toType}
+
+    def generateSetter(from: Term, to: Term): Term =
+      Select.overloaded(from, "copy", fromTypeArgs, NamedArg(fieldName, to) :: Nil) // o.copy(field = value)
+
+    (fromType.asType, toType.asType) match {
+      case ('[f], '[t]) =>
+        '{
+          Lens.apply[f, t]((from: f) => ${ generateGetter('{ from }.asTerm, fieldName).asExprOf[t] })((to: t) =>
+            (from: f) => ${ generateSetter('{ from }.asTerm, '{ to }.asTerm).asExprOf[f] }
+          )
+        }.asTerm
+    }
+  }
+
+  def generateSelectFieldWithImplicits(action: FocusAction.SelectFieldWithImplicits): Term = {
     import action.{fieldName, fromType, toType, setter}
 
     (fromType.asType, toType.asType) match {
       case ('[f], '[t]) =>
         '{
-          Lens.apply[f, t]((from: f) => ${ Select.unique('{ from }.asTerm, fieldName).asExprOf[t] })(
+          Lens.apply[f, t]((from: f) => ${ generateGetter('{ from }.asTerm, fieldName).asExprOf[t] })(
             ${ setter.asExprOf[t => f => f] }
           )
         }.asTerm
diff --git a/core/shared/src/main/scala-3.x/monocle/internal/focus/features/selectfield/SelectFieldParser.scala b/core/shared/src/main/scala-3.x/monocle/internal/focus/features/selectfield/SelectFieldParser.scala
@@ -12,9 +12,13 @@ private[focus] trait SelectFieldParser {
 
     def unapply(term: Term): Option[FocusResult[(RemainingCode, FocusAction)]] = term match {
 
-      case Select(CaseClass(remainingCode), fieldName) =>
-        val fromType                = getType(remainingCode)
-        val action                  = getFieldAction(fromType, fieldName)
+      case Select(CaseClass(remainingCode, classSymbol), fieldName) =>
+        val fromType = getType(remainingCode)
+        val action = if (hasOnlyOneParameterList(classSymbol)) {
+          getFieldAction(fromType, fieldName)
+        } else {
+          getFieldActionWithImplicits(fromType, fieldName)
+        }
         val remainingCodeWithAction = action.map(a => (RemainingCode(remainingCode), a))
         Some(remainingCodeWithAction)
 
@@ -25,11 +29,23 @@ private[focus] trait SelectFieldParser {
     }
   }
 
+  private def hasOnlyOneParameterList(classSymbol: Symbol): Boolean =
+    classSymbol.primaryConstructor.paramSymss match {
+      case _ :: Nil                                    => true
+      case (head :: _) :: _ :: Nil if head.isTypeParam => true
+      case _                                           => false
+    }
+
   private def getFieldAction(fromType: TypeRepr, fieldName: String): FocusResult[FocusAction] =
+    getFieldType(fromType, fieldName).flatMap { toType =>
+      Right(FocusAction.SelectField(fieldName, fromType, getSuppliedTypeArgs(fromType), toType))
+    }
+
+  private def getFieldActionWithImplicits(fromType: TypeRepr, fieldName: String): FocusResult[FocusAction] =
     getFieldType(fromType, fieldName).flatMap { toType =>
       val typeArgs = getSuppliedTypeArgs(fromType)
       constructSetter(fieldName, fromType, toType, typeArgs).map { setter =>
-        FocusAction.SelectField(fieldName, fromType, toType, setter)
+        FocusAction.SelectFieldWithImplicits(fieldName, fromType, toType, setter)
       }
     }
 
diff --git a/core/shared/src/main/scala-3.x/monocle/internal/focus/features/selectonlyfield/SelectOnlyFieldGenerator.scala b/core/shared/src/main/scala-3.x/monocle/internal/focus/features/selectonlyfield/SelectOnlyFieldGenerator.scala
@@ -8,13 +8,32 @@ private[focus] trait SelectOnlyFieldGenerator {
 
   import macroContext.reflect._
 
+  private def generateGetter(from: Term, fieldName: String): Term =
+    Select.unique(from, fieldName) // o.field
+
   def generateSelectOnlyField(action: FocusAction.SelectOnlyField): Term = {
+    import action.{fieldName, fromType, fromTypeArgs, fromCompanion, toType}
+
+    def generateReverseGet(to: Term): Term =
+      Select.overloaded(fromCompanion, "apply", fromTypeArgs, List(to)) // Companion.apply(value)
+
+    (fromType.asType, toType.asType) match {
+      case ('[f], '[t]) =>
+        '{
+          Iso.apply[f, t]((from: f) => ${ generateGetter('{ from }.asTerm, fieldName).asExprOf[t] })((to: t) =>
+            ${ generateReverseGet('{ to }.asTerm).asExprOf[f] }
+          )
+        }.asTerm
+    }
+  }
+
+  def generateSelectOnlyFieldWithImplicits(action: FocusAction.SelectOnlyFieldWithImplicits): Term = {
     import action.{fieldName, fromType, toType, reverseGet}
 
     (fromType.asType, toType.asType) match {
       case ('[f], '[t]) =>
         '{
-          Iso.apply[f, t]((from: f) => ${ Select.unique('{ from }.asTerm, fieldName).asExprOf[t] })(
+          Iso.apply[f, t]((from: f) => ${ generateGetter('{ from }.asTerm, fieldName).asExprOf[t] })(
             ${ reverseGet.asExprOf[t => f] }
           )
         }.asTerm
diff --git a/core/shared/src/main/scala-3.x/monocle/internal/focus/features/selectonlyfield/SelectOnlyFieldParser.scala b/core/shared/src/main/scala-3.x/monocle/internal/focus/features/selectonlyfield/SelectOnlyFieldParser.scala
@@ -12,29 +12,61 @@ private[focus] trait SelectOnlyFieldParser {
 
     def unapply(term: Term): Option[FocusResult[(RemainingCode, FocusAction)]] = term match {
 
-      case Select(CaseClass(remainingCode), fieldName) if hasOnlyOneField(remainingCode) =>
-        val fromType                = getType(remainingCode)
-        val action                  = getFieldAction(fromType, fieldName)
+      case Select(CaseClass(remainingCode, classSymbol), fieldName) if notACaseField(classSymbol, fieldName) =>
+        Some(FocusError.NotACaseField(remainingCode.tpe.show, fieldName).asResult)
+
+      case Select(CaseClass(remainingCode, classSymbol), fieldName) if hasOnlyOneField(classSymbol) =>
+        val fromType = getType(remainingCode)
+        val action = if (hasOnlyOneParameterList(classSymbol)) {
+          getFieldAction(fromType, classSymbol, fieldName)
+        } else {
+          getFieldActionWithImplicits(fromType, classSymbol, fieldName)
+        }
         val remainingCodeWithAction = action.map(a => (RemainingCode(remainingCode), a))
         Some(remainingCodeWithAction)
 
       case _ => None
     }
   }
 
-  private def getFieldAction(fromType: TypeRepr, fieldName: String): FocusResult[FocusAction] =
+  private def getFieldAction(
+    fromType: TypeRepr,
+    fromClassSymbol: Symbol,
+    fieldName: String
+  ): FocusResult[FocusAction] =
     for {
-      toType    <- getFieldType(fromType, fieldName)
-      companion <- getCompanionObject(fromType)
-      supplied = getSuppliedTypeArgs(fromType)
+      toType <- getFieldType(fromType, fieldName)
+      companion = getCompanionObject(fromClassSymbol)
+      supplied  = getSuppliedTypeArgs(fromType)
+    } yield FocusAction.SelectOnlyField(fieldName, fromType, supplied, companion, toType)
+
+  private def getFieldActionWithImplicits(
+    fromType: TypeRepr,
+    fromClassSymbol: Symbol,
+    fieldName: String
+  ): FocusResult[FocusAction] =
+    for {
+      toType <- getFieldType(fromType, fieldName)
+      companion = getCompanionObject(fromClassSymbol)
+      supplied  = getSuppliedTypeArgs(fromType)
       reverseGet <- constructReverseGet(companion, fromType, toType, supplied)
-    } yield FocusAction.SelectOnlyField(fieldName, fromType, toType, reverseGet)
+    } yield FocusAction.SelectOnlyFieldWithImplicits(fieldName, fromType, toType, reverseGet)
+
+  private def hasOnlyOneField(classSymbol: Symbol): Boolean =
+    classSymbol.caseFields.length == 1
 
-  private def hasOnlyOneField(fromCode: Term): Boolean =
-    getType(fromCode).classSymbol.exists(_.caseFields.length == 1)
+  private def notACaseField(classSymbol: Symbol, fieldName: String): Boolean =
+    classSymbol.caseFields.forall(_.name != fieldName)
+
+  private def hasOnlyOneParameterList(classSymbol: Symbol): Boolean =
+    classSymbol.primaryConstructor.paramSymss match {
+      case _ :: Nil                                    => true
+      case (head :: _) :: _ :: Nil if head.isTypeParam => true
+      case _                                           => false
+    }
 
-  private def getCompanionObject(fromType: TypeRepr): FocusResult[Term] =
-    getClassSymbol(fromType).map(sym => Ref(sym.companionModule))
+  private def getCompanionObject(classSymbol: Symbol): Term =
+    Ref(classSymbol.companionModule)
 
   private case class LiftException(error: FocusError) extends Exception
 
