Support for NamedTuple in focus macros

.github/workflows/ci.yml

@@ -297,7 +297,7 @@ jobs:
       - name: Submit Dependencies
         uses: scalacenter/sbt-dependency-submission@v2
         with:
-          modules-ignore: monocle-test_2.13 monocle-test_3 monocle-test_native0.5_2.13 monocle-test_native0.5_3 rootjs_2.13 rootjs_3 monocle-docs_2.13 rootjvm_2.13 rootjvm_3 rootnative_2.13 rootnative_3 monocle-test_sjs1_2.13 monocle-test_sjs1_3 monocle-example_2.13 monocle-example_3 monocle-bench_2.13 monocle-bench_3
+          modules-ignore: monocle-test_2.13 monocle-test_3 monocle-test_native0.5_2.13 monocle-test_native0.5_3 rootjs_2.13 rootjs_3 monocle-docs_2.13 scalanexttest_3 rootjvm_2.13 rootjvm_3 rootnative_2.13 rootnative_3 scalanexttest_native0.5_3 scalanexttest_sjs1_3 monocle-test_sjs1_2.13 monocle-test_sjs1_3 monocle-example_2.13 monocle-example_3 monocle-bench_2.13 monocle-bench_3
           configs-ignore: test scala-tool scala-doc-tool test-internal
 
   validate-steward:

build.sbt

@@ -105,9 +105,10 @@ lazy val buildSettings = Seq(
   }
 )
 
-lazy val catsVersion   = "2.13.0"
-lazy val scala2Version = "2.13.18"
-lazy val scala3Version = "3.3.8"
+lazy val catsVersion      = "2.13.0"
+lazy val scala2Version    = "2.13.18"
+lazy val scala3Version    = "3.3.8"
+lazy val scalaNextVersion = "3.8.4"
 
 lazy val cats              = Def.setting("org.typelevel" %%% "cats-core" % catsVersion)
 lazy val catsFree          = Def.setting("org.typelevel" %%% "cats-free" % catsVersion)
@@ -168,7 +169,8 @@ lazy val root = tlCrossRootProject.aggregate(
   unsafe,
   test,
   example,
-  bench
+  bench,
+  scalaNextTest
 )
 
 lazy val core = crossProject(JVMPlatform, JSPlatform, NativePlatform)
@@ -303,6 +305,18 @@ lazy val test = crossProject(JVMPlatform, JSPlatform, NativePlatform)
     )
   )
 
+lazy val scalaNextTest = crossProject(JVMPlatform, JSPlatform, NativePlatform)
+  .dependsOn(core, macros)
+  .jvmSettings(monocleJvmSettings)
+  .jsSettings(monocleJsSettings)
+  .nativeSettings(monocleNativeSettings)
+  .enablePlugins(NoPublishPlugin)
+  .settings(
+    crossScalaVersions := Seq(scalaNextVersion),
+    libraryDependencies ++= Seq(munitDiscipline.value),
+    scalacOptions --= Seq("-release:8", "-Ykind-projector")
+  )
+
 lazy val bench = project
   .dependsOn(core.jvm, generic.jvm, macros.jvm)
   .settings(moduleName := "monocle-bench")

core/shared/src/main/scala-3/monocle/internal/focus/FocusBase.scala

@@ -1,6 +1,7 @@
 package monocle.internal.focus
 
-import scala.quoted.Quotes
+import scala.quoted.*
+import scala.annotation.tailrec
 
 private[focus] trait FocusBase {
   val macroContext: Quotes
@@ -11,6 +12,8 @@ private[focus] trait FocusBase {
   type TypeRepr = macroContext.reflect.TypeRepr
   type Position = macroContext.reflect.Position
 
+  import macroContext.reflect.*
+
   case class LambdaConfig(argName: String, lambdaBody: Term)
 
   enum FocusAction {
@@ -22,6 +25,12 @@ private[focus] trait FocusBase {
       fromCompanion: Term,
       toType: TypeRepr
     )
+    case SelectNamedTupleField(
+      fieldName: String,
+      fromDescription: NamedTuples.Description,
+      toType: TypeRepr,
+      namedTuples: NamedTuples
+    )
     case KeywordSome(toType: TypeRepr)
     case KeywordAs(fromType: TypeRepr, toType: TypeRepr)
     case KeywordEach(fromType: TypeRepr, toType: TypeRepr, eachInstance: Term)
@@ -34,6 +43,8 @@ private[focus] trait FocusBase {
         s"SelectField($fieldName, ${fromType.show}, ${fromTypeArgs.map(_.show)}, ${toType.show})"
       case SelectOnlyField(fieldName, fromType, fromTypeArgs, _, toType) =>
         s"SelectOnlyField($fieldName, ${fromType.show}, ${fromTypeArgs.map(_.show)}, ..., ${toType.show})"
+      case SelectNamedTupleField(fieldName, fromType, toType, _) =>
+        s"SelectNamedTupleField($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}, ...)"
@@ -58,4 +69,108 @@ private[focus] trait FocusBase {
   }
 
   type FocusResult[+A] = Either[FocusError, A]
+
+  // unappliedNamedTuple is the type lambda [Names, Values] =>> NamedTuple[Names, Values], used to harvest its type symbol later on
+  final class NamedTuples private (private val unappliedNamedTuple: TypeRepr, val companion: Symbol) {
+    def isNamedTuple(tpe: TypeRepr) =
+      tpe.dealias.typeSymbol == unappliedNamedTuple.typeSymbol
+
+    // a call to NamedTuple.toTuple[Names <: Tuple, Values <: Tuple](tup: NamedTuple.NamedTuple[Names, Values]): Values
+    def toTuple(term: Term, description: NamedTuples.Description) =
+      Select
+        .unique(Ident(companion.termRef), "toTuple")
+        .appliedToTypes(description.namesTpe :: description.valuesTpe :: Nil)
+        .appliedTo(term)
+
+    def accessFieldByName(term: Term, action: FocusAction.SelectNamedTupleField): Term = {
+      val idxOfName = action.fromDescription.names.indexOf(action.fieldName)
+      val asTuple   = toTuple(term, action.fromDescription)
+      unsafeAccessFieldByIndex(asTuple, action.fromDescription, idxOfName)
+    }
+
+    def reconstructWithUpdatedField(from: Term, action: FocusAction.SelectNamedTupleField, updatedValue: Term) = {
+      val updatedFieldIdx = action.fromDescription.names.indexOf(action.fieldName)
+      val asTuple         = toTuple(from, action.fromDescription)
+      val values          =
+        Vector.tabulate(action.fromDescription.values.size) { idx =>
+          if (idx == updatedFieldIdx) updatedValue.asExpr
+          else unsafeAccessFieldByIndex(asTuple, action.fromDescription, idx).asExpr
+        }
+      construct(action.fromDescription, values)
+    }
+
+    // NamedTuple >: Tuple so to 'construct' a named tuple we can just upcast an ordinary Tuple to a NamedTuple
+    def construct(description: NamedTuples.Description, values: Seq[Expr[Any]]): Term =
+      Typed(Expr.ofTupleFromSeq(values).asTerm, TypeTree.of(using description.sourceType.asType))
+
+    // there's a chance that we're operating on a non-normalized (non TupleN) tuple (for example when N is > 22 or when using NamedTuple.From)
+    // in which case we need to fall back to using Product methods since TupleXXL <: scala.Product and '*:' (tuple cons) <: Product AND doesn't get _N accessors
+    private def unsafeAccessFieldByIndex(asTuple: Term, description: NamedTuples.Description, index: Int) = {
+      val tupleAccessor = s"_${index + 1}"
+
+      if (asTuple.tpe.typeSymbol.fieldMember(tupleAccessor).exists) {
+        Select.unique(asTuple, tupleAccessor)
+      } else {
+        val tpeAtIndex = description.values(index)
+        (asTuple.asExpr, tpeAtIndex.asType) match {
+          case '{ $prod: scala.Product } -> '[tpe] =>
+            '{ $prod.productElement(${ Expr(index) }).asInstanceOf[tpe] }.asTerm
+        }
+      }
+    }
+
+    def describe(sourceType: TypeRepr): Option[NamedTuples.Description] =
+      sourceType.dealias.simplified match {
+        case tpe @ AppliedType(_, namesTpe :: valuesTpe :: Nil) if isNamedTuple(tpe) =>
+          Some(
+            NamedTuples.Description(
+              unrollStrings(namesTpe),
+              unroll(valuesTpe),
+              sourceType,
+              namesTpe,
+              valuesTpe
+            )
+          )
+        case _ => None
+      }
+
+    private def unrollStrings(tp: TypeRepr): Vector[String] =
+      unroll(tp).map { case ConstantType(StringConstant(l)) => l }
+
+    private def unroll(tpe: TypeRepr): Vector[TypeRepr] = {
+      @tailrec def loop(curr: Type[?], acc: Vector[TypeRepr]): Vector[TypeRepr] =
+        curr match {
+          case '[head *: tail] =>
+            loop(Type.of[tail], acc.appended(TypeRepr.of[head]))
+          case '[EmptyTuple] =>
+            acc
+        }
+
+      loop(tpe.asType, Vector.empty)
+    }
+
+  }
+
+  object NamedTuples {
+    val Support: Option[NamedTuples] = {
+      val companion = Symbol.requiredModule("scala.NamedTuple")
+
+      companion
+        .declaredType("NamedTuple")
+        .headOption
+        .map(sym => NamedTuples(sym.typeRef, companion))
+    }
+
+    case class Description private[NamedTuples] (
+      names: Vector[String],
+      values: Vector[TypeRepr],
+      sourceType: TypeRepr,
+      namesTpe: TypeRepr,
+      valuesTpe: TypeRepr
+    ) {
+      def show: String =
+        s"Description($names, ${values.map(_.show)}, ${sourceType.show}, ${namesTpe.show}, ${valuesTpe.show})"
+    }
+  }
+
 }

core/shared/src/main/scala-3/monocle/internal/focus/features/GeneratorLoop.scala

@@ -2,6 +2,7 @@ package monocle.internal.focus.features
 
 import monocle.internal.focus.FocusBase
 import monocle.internal.focus.features.selectfield.SelectFieldGenerator
+import monocle.internal.focus.features.selectfield.SelectNamedTupleFieldGenerator
 import monocle.internal.focus.features.selectonlyfield.SelectOnlyFieldGenerator
 import monocle.internal.focus.features.some.SomeGenerator
 import monocle.internal.focus.features.as.AsGenerator
@@ -16,6 +17,7 @@ private[focus] trait AllFeatureGenerators
     extends FocusBase
     with SelectFieldGenerator
     with SelectOnlyFieldGenerator
+    with SelectNamedTupleFieldGenerator
     with SomeGenerator
     with AsGenerator
     with EachGenerator
@@ -38,14 +40,15 @@ 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.SelectOnlyField       => generateSelectOnlyField(a)
+      case a: FocusAction.SelectNamedTupleField => generateSelectNamedTupleField(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] =

core/shared/src/main/scala-3/monocle/internal/focus/features/ParserBase.scala

@@ -16,6 +16,6 @@ private[focus] trait ParserBase {
   }
 
   def getType(code: Term): TypeRepr =
-    code.tpe.widen.dealias
+    code.tpe.widen.dealias.simplified
 
 }

core/shared/src/main/scala-3/monocle/internal/focus/features/ParserLoop.scala

@@ -2,6 +2,7 @@ package monocle.internal.focus.features
 
 import monocle.internal.focus.FocusBase
 import monocle.internal.focus.features.selectfield.SelectFieldParser
+import monocle.internal.focus.features.selectfield.SelectNamedTupleFieldParser
 import monocle.internal.focus.features.selectonlyfield.SelectOnlyFieldParser
 import monocle.internal.focus.features.some.SomeParser
 import monocle.internal.focus.features.as.AsParser
@@ -16,6 +17,7 @@ private[focus] trait AllFeatureParsers
     with KeywordParserBase
     with SelectFieldParser
     with SelectOnlyFieldParser
+    with SelectNamedTupleFieldParser
     with SomeParser
     with AsParser
     with EachParser
@@ -58,6 +60,9 @@ private[focus] trait ParserLoop {
         case SelectField(Right(remainingCode, action)) => loop(remainingCode, action :: listSoFar)
         case SelectField(Left(error))                  => Left(error)
 
+        case SelectNamedTupleField(Right(remainingCode, action)) => loop(remainingCode, action :: listSoFar)
+        case SelectNamedTupleField(Left(error))                  => Left(error)
+
         case unexpected => FocusError.UnexpectedCodeStructure(unexpected.toString).asResult
       }
     loop(RemainingCode(config.lambdaBody), Nil)

core/shared/src/main/scala-3/monocle/internal/focus/features/SelectParserBase.scala

@@ -10,7 +10,7 @@ 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] =
-      term.tpe.classSymbol.flatMap { sym =>
+      term.tpe.simplified.classSymbol.flatMap { sym =>
         Option.when(sym.flags.is(Flags.Case))(term)
       }
   }

core/shared/src/main/scala-3/monocle/internal/focus/features/selectfield/SelectNamedTupleFieldGenerator.scala

@@ -0,0 +1,41 @@
+package monocle.internal.focus.features.selectfield
+
+import monocle.internal.focus.FocusBase
+import monocle.Lens
+import monocle.Iso
+import scala.quoted.Quotes
+import scala.quoted.Expr
+
+private[focus] trait SelectNamedTupleFieldGenerator {
+  this: FocusBase =>
+
+  import macroContext.reflect.*
+
+  def generateSelectNamedTupleField(action: FocusAction.SelectNamedTupleField): Term = {
+    def generateGetter(from: Term): Term = action.namedTuples.accessFieldByName(from, action)
+
+    def generateSetter(from: Term, to: Term): Term =
+      action.namedTuples.reconstructWithUpdatedField(from, action, to)
+
+    def generateReverseGet(to: Expr[Any]): Term =
+      action.namedTuples.construct(action.fromDescription, Vector(to))
+
+    (action.fromDescription.sourceType.asType, action.toType.asType) match {
+      case ('[f], '[t]) =>
+        if (action.fromDescription.values.size == 1) {
+          '{
+            Iso.apply[f, t]((from: f) => ${ generateGetter('from.asTerm).asExprOf[t] })((to: t) =>
+              ${ generateReverseGet('to).asExprOf[f] }
+            )
+          }.asTerm
+        } else {
+          '{
+            Lens.apply[f, t]((from: f) => ${ generateGetter('from.asTerm).asExprOf[t] })((to: t) =>
+              (from: f) => ${ generateSetter('from.asTerm, 'to.asTerm).asExprOf[f] }
+            )
+          }.asTerm
+        }
+    }
+
+  }
+}

core/shared/src/main/scala-3/monocle/internal/focus/features/selectfield/SelectNamedTupleFieldParser.scala

@@ -0,0 +1,32 @@
+package monocle.internal.focus.features.selectfield
+
+import monocle.internal.focus.FocusBase
+import monocle.internal.focus.features.SelectParserBase
+
+private[focus] trait SelectNamedTupleFieldParser {
+  this: FocusBase & SelectParserBase =>
+
+  import this.macroContext.reflect.*
+
+  object SelectNamedTupleField extends FocusParser {
+
+    def unapply(term: Term): Option[FocusResult[(RemainingCode, FocusAction)]] =
+      NamedTuples.Support.flatMap { namedTuples =>
+        term match {
+          // the compiler expands a call like 'someNamedTuple.someField' to a call on NamedTuple.apply[Names, Values](someNamedTuple)(idx) where idx == index of 'someField' in the Names tuple
+          case Apply(
+                Apply(TypeApply(Select(ident, "apply"), _), remainingCode :: Nil),
+                Literal(IntConstant(fieldIndex)) :: Nil
+              ) if ident.symbol == namedTuples.companion =>
+            for {
+              description <- namedTuples.describe(getType(remainingCode))
+              fieldType   <- description.values.lift(fieldIndex)
+              fieldName   <- description.names.lift(fieldIndex)
+              action = FocusAction.SelectNamedTupleField(fieldName, description, fieldType, namedTuples)
+            } yield Right(RemainingCode(remainingCode) -> action)
+          case _ => None
+        }
+      }
+  }
+
+}