Support for NamedTuple in focus macros

.github/workflows/ci.yml

@@ -103,6 +103,18 @@ jobs:
         if: matrix.scala == '2.13' && matrix.project == 'rootJVM'
         run: sbt 'project ${{ matrix.project }}' '++ ${{ matrix.scala }}' docs/mdoc
 
+      - name: Run Scala Next Tests (jvm)
+        if: matrix.java == 'temurin@25' && matrix.scala == '3'
+        run: sbt 'project ${{ matrix.project }}' '++ ${{ matrix.scala }}' scalaNextTestJVM/test
+
+      - name: Run Scala Next Tests (js)
+        if: matrix.java == 'temurin@25' && matrix.scala == '3'
+        run: sbt 'project ${{ matrix.project }}' '++ ${{ matrix.scala }}' scalaNextTestJS/test
+
+      - name: Run Scala Next Tests (native)
+        if: matrix.java == 'temurin@25' && matrix.scala == '3'
+        run: sbt 'project ${{ matrix.project }}' '++ ${{ matrix.scala }}' scalaNextTestNative/test
+
       - name: Make target directories
         if: github.event_name != 'pull_request' && (startsWith(github.ref, 'refs/tags/v'))
         run: mkdir -p unsafe/.js/target generic/.jvm/target law/.js/target macro/.jvm/target unsafe/.native/target state/.jvm/target core/native/target unsafe/.jvm/target macro/.native/target core/js/target macro/.js/target law/.jvm/target generic/.js/target core/jvm/target refined/.native/target law/.native/target refined/.js/target refined/.jvm/target state/.native/target state/.js/target generic/.native/target project/target
@@ -297,7 +309,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

@@ -22,11 +22,20 @@ inThisBuild(
     scalaVersion       := scala2Version,
     crossScalaVersions := Seq(scala2Version, scala3Version),
     tlCiScalafmtCheck  := true,
-    githubWorkflowBuild += WorkflowStep.Sbt(
-      List("docs/mdoc"),
-      name = Some("Run documentation"),
-      cond = Some(s"matrix.scala == '2.13' && matrix.project == 'rootJVM'")
-    ),
+    githubWorkflowBuild ++=
+      Vector(
+        WorkflowStep.Sbt(
+          List("docs/mdoc"),
+          name = Some("Run documentation"),
+          cond = Some(s"matrix.scala == '2.13' && matrix.project == 'rootJVM'")
+        )
+      ) ++ scalaNextTest.projects.map { case (platform, project) =>
+        WorkflowStep.Sbt(
+          List(s"${project.id}/test"),
+          name = Some(s"Run Scala Next Tests (${platform.identifier})"),
+          cond = Some(s"matrix.java == 'temurin@25' && matrix.scala == '3'")
+        )
+      },
     githubWorkflowJavaVersions := Seq(
       JavaSpec.temurin("11"),
       JavaSpec.temurin("25")
@@ -38,7 +47,6 @@ inThisBuild(
     )
   )
 )
-
 lazy val kindProjector = "org.typelevel" % "kind-projector" % "0.13.4" cross CrossVersion.full
 
 lazy val buildSettings = Seq(
@@ -105,9 +113,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)
@@ -303,6 +312,18 @@ lazy val test = crossProject(JVMPlatform, JSPlatform, NativePlatform)
     )
   )
 
+lazy val scalaNextTest = crossProject(JVMPlatform, JSPlatform, NativePlatform)
+  .dependsOn(test % "test->test")
+  .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,14 @@ private[focus] trait FocusBase {
       fromCompanion: Term,
       toType: TypeRepr
     )
+    case SelectNamedTupleField(
+      fieldName: String,
+      fromDescription: NamedTuples.Description,
+      toType: TypeRepr,
+      // storing the whole NamedTuples helper class might feel weird but it's the best way one can describe that this focus action is only possible
+      // when named tuples are actually supported (i.e. on Scala > 3.7.x)
+      namedTuples: NamedTuples
+    )
     case KeywordSome(toType: TypeRepr)
     case KeywordAs(fromType: TypeRepr, toType: TypeRepr)
     case KeywordEach(fromType: TypeRepr, toType: TypeRepr, eachInstance: Term)
@@ -34,6 +45,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 +71,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

@@ -15,7 +15,9 @@ private[focus] trait ParserBase {
     def unapply(term: Term): Option[FocusResult[(RemainingCode, FocusAction)]]
   }
 
+  // the '.simplified' call here is needed because otherwise if an unreduced match type arrives at this call site we're greeted with a compiler barf, like:
+  // 'Cannot get type of value [...]' (note that this is especially important for terms that describe a named tuple field access which is typed as 'Elem[NamedTuple[N, V], n.type]' which IS a match type).
   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
+        }
+    }
+
+  }
+}