used Scala 3.6.x Selectable.Fields for DFStruct/DFTuple with workaround for scala/scala3#22036

Author: Oron Port

core/src/main/scala/dfhdl/core/DFStruct.scala

@@ -217,47 +217,5 @@ object DFStruct:
           sf.check(dfType, value.dfType)
           value.asValTP[DFStruct[F], RP]
     end Compare
-
-    trait Refiner[T <: FieldsOrTuple, A, I, P]:
-      type Out <: DFVal[DFStruct[T], Modifier[A, Any, I, P]]
-    object Refiner:
-      transparent inline given [T <: FieldsOrTuple, A, I, P]: Refiner[T, A, I, P] = ${
-        refineMacro[T, A, I, P]
-      }
-      def refineMacro[T <: FieldsOrTuple, A, I, P](using
-          Quotes,
-          Type[T],
-          Type[A],
-          Type[I],
-          Type[P]
-      ): Expr[Refiner[T, A, I, P]] =
-        import quotes.reflect.*
-        val dfValTpe = TypeRepr.of[DFVal[DFStruct[T], Modifier[A, Any, I, P]]]
-        val tTpe = TypeRepr.of[T]
-        val fields: List[(String, TypeRepr)] = tTpe.asTypeOf[Any] match
-          case '[NonEmptyTuple] =>
-            tTpe.getTupleArgs.zipWithIndex.map((f, i) =>
-              f.asTypeOf[Any] match
-                case '[DFValOf[t]] =>
-                  (s"_${i + 1}", TypeRepr.of[DFVal[t, Modifier[A, Any, I, P]]])
-            )
-          case _ =>
-            val clsSym = tTpe.classSymbol.get
-            clsSym.caseFields.map(m =>
-              tTpe.memberType(m).asTypeOf[Any] match
-                case '[DFValOf[t]] =>
-                  (m.name.toString, TypeRepr.of[DFVal[t, Modifier[A, Any, I, P]]])
-            )
-
-        val refined = fields.foldLeft(dfValTpe) { case (r, (n, t)) =>
-          Refinement(r, n, t)
-        }
-        val refinedType = refined.asTypeOf[DFVal[DFStruct[T], Modifier[A, Any, I, P]]]
-        '{
-          new Refiner[T, A, I, P]:
-            type Out = refinedType.Underlying
-        }
-      end refineMacro
-    end Refiner
   end Val
 end DFStruct

core/src/main/scala/dfhdl/core/DFVal.scala

@@ -18,6 +18,7 @@ final class DFVal[+T <: DFTypeAny, +M <: ModifierAny](val irValue: ir.DFVal | DF
     extends AnyVal
     with DFMember[ir.DFVal]
     with Selectable:
+  type Fields = DFVal.Fields[T @uncheckedVariance, M @uncheckedVariance]
 
   def selectDynamic(name: String)(using DFC): Any = trydf {
     val ir.DFStruct(structName, fieldMap) = this.asIR.dfType: @unchecked
@@ -269,6 +270,23 @@ sealed protected trait DFValLP:
     from => from.asValTP[T, NOTCONST]
 end DFValLP
 object DFVal extends DFValLP:
+  protected type FieldWithModifier[V, M <: ModifierAny] = V match
+    case DFVal[t, _] =>
+      M match
+        case Modifier[a, Any, i, p] => DFVal[t, Modifier[a, Any, i, p]]
+  protected type FieldsWithModifier[V <: NamedTuple.AnyNamedTuple, M <: ModifierAny] =
+    NamedTuple.Map[V, [t] =>> FieldWithModifier[t, M]]
+  protected[core] type Fields[T <: DFTypeAny, M <: ModifierAny] = T match
+    case DFType[t, Args1[a]] =>
+      t match
+        case ir.DFStruct =>
+          // TODO: NamedTuple.From should suffice when https://github.com/scala/scala3/issues/22036 is fixed
+          a match
+            case DFStruct.Fields => FieldsWithModifier[NamedTuple.From[a], M]
+            case NonEmptyTuple   => FieldsWithModifier[TupleToNamedTuple[a], M]
+        case _ => Any
+    case _ => Any
+
   // constructing a front-end DFVal value class object. if it's a global value, then
   // we need to save the DFC, instead of the actual member IR object
   inline def apply[T <: DFTypeAny, M <: ModifierAny, IR <: ir.DFVal | DFError](
@@ -321,10 +339,6 @@ object DFVal extends DFValLP:
   given [T <: DFTypeAny, M <: ModifierAny]: CanEqual[DFEncoding, DFVal[T, M]] =
     CanEqual.derived
 
-  given __refined_dfVal[T <: FieldsOrTuple, A, I, P](using
-      r: DFStruct.Val.Refiner[T, A, I, P]
-  ): Conversion[DFVal[DFStruct[T], Modifier[A, Any, I, P]], r.Out] = _.asInstanceOf[r.Out]
-
   trait ConstCheck[P]
   given [P](using
       AssertGiven[

internals/src/main/scala/dfhdl/internals/helpers.scala

@@ -173,6 +173,15 @@ object ValueOfTuple:
 end ValueOfTuple
 
 type <:![T <: UB, UB] = T & UB
+/*
+  TODO: not required when https://github.com/scala/scala3/issues/22036 is fixed
+ */
+import compiletime.ops.string.+ as ++
+protected type TupleNamesRecur[X <: Tuple, N <: Int, I <: Int] <: Tuple = I match
+  case 0    => X
+  case S[i] => ("_" ++ ToString[N - i]) *: TupleNamesRecur[X, N, i]
+protected type TupleNames[N <: Int] = TupleNamesRecur[EmptyTuple, N, N]
+type TupleToNamedTuple[T <: Tuple] = NamedTuple.NamedTuple[TupleNames[Tuple.Size[T]], T]
 
 //evidence of class T which has no arguments and no type arguments
 trait ClassEv[T]: