Check all tuple structures

Co-authored-by: Nicolas Stucki <[email protected]>

Author: biboudis

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

@@ -1870,6 +1870,7 @@ class ReflectionCompilerInterface(val rootContext: core.Contexts.Context) extend
   def Definitions_FunctionClass(arity: Int, isImplicit: Boolean, isErased: Boolean): Symbol =
     defn.FunctionClass(arity, isImplicit, isErased).asClass
   def Definitions_TupleClass(arity: Int): Symbol = defn.TupleType(arity).classSymbol.asClass
+  def Definitions_isTupleClass(sym: Symbol): Boolean = defn.isTupleClass(sym)
 
   def Definitions_InternalQuoted_patternHole: Symbol = defn.InternalQuoted_patternHole
   def Definitions_InternalQuoted_patternBindHoleAnnot: Symbol = defn.InternalQuoted_patternBindHoleAnnot

library/src/scala/tasty/reflect/CompilerInterface.scala

@@ -1398,6 +1398,7 @@ trait CompilerInterface {
   def Definitions_FunctionClass(arity: Int, isImplicit: Boolean = false, isErased: Boolean = false): Symbol
 
   def Definitions_TupleClass(arity: Int): Symbol
+  def Definitions_isTupleClass(sym: Symbol): Boolean
 
   /** Symbol of scala.internal.Quoted.patternHole */
   def Definitions_InternalQuoted_patternHole: Symbol

library/src/scala/tasty/reflect/StandardDefinitions.scala

@@ -144,6 +144,10 @@ trait StandardDefinitions extends Core {
     def TupleClass(arity: Int): Symbol =
       internal.Definitions_TupleClass(arity)
 
+    /** Returns `true` if `sym` is a `Tuple1`, `Tuple2`, ... `Tuple22` */
+    def isTupleClass(sym: Symbol): Boolean =
+      internal.Definitions_isTupleClass(sym)
+
     /** Contains Scala primitive value classes:
       *   - Byte
       *   - Short

tests/run-macros/refined-selectable-macro.check

@@ -0,0 +1,5 @@
+((name,Emma),(age,42))
+
+Record()
+Record(field1=1, field2=2, field3=3, field4=4, field5=5, field6=6, field7=7, field8=8, field9=9, field10=10, field11=11, field12=12, field13=13, field14=14, field15=15, field16=16, field17=17, field18=18, field19=19, field20=20, field21=21, field22=22, field23=23, field24=24, field25=25)
+Record(name=Emma, age=42)

tests/run-macros/refined-selectable-macro/Macro_1.scala

@@ -1,37 +1,42 @@
 import scala.quoted._
 
 object Macro {
-  case class Record(elems: (String, Any)*) extends Selectable {
-    def selectDynamic(name: String): Any = elems.find(_._1 == name).get._2
-    def toTuple = {
-      //todo: unnecessary transformation?
-      Tuple.fromArray(elems.toArray)
-    }
-  }
 
-  object Record {
-    def fromTuple(t: Tuple): Record = Record(t.toArray.toSeq.map(e => e.asInstanceOf[(String, Any)]): _*)
+  trait SelectableRecord extends Selectable {
+    inline def toTuple <: Tuple = ${ toTupleImpl('this)}
   }
 
-  inline def toTuple(s: Selectable) <: Tuple = ${ toTupleImpl('s)}
+  trait SelectableRecordCompanion[T] {
+    protected def fromUntypedTuple(elems: (String, Any)*): T
+    inline def fromTuple[T <: Tuple](s: T) <: Any = ${ fromTupleImpl('s, '{ (x: Array[(String, Any)]) => fromUntypedTuple(x: _*) } ) }
+  }
 
-  def toTupleImpl(s: Expr[Selectable])(given qctx:QuoteContext): Expr[Tuple] = {
+  private def toTupleImpl(s: Expr[Selectable])(given qctx:QuoteContext): Expr[Tuple] = {
     import qctx.tasty.{given, _}
 
     val repr = s.unseal.tpe.widenTermRefExpr.dealias
 
     def rec(tpe: Type): List[(String, Type)] = {
       tpe match {
-        case Refinement(parent, name, info: Type) => (name, info) :: rec(parent)
+        case Refinement(parent, name, info) =>
+          info match {
+            case _: TypeBounds =>
+              rec(parent)
+            case _: MethodType | _: PolyType | _: TypeBounds =>
+              qctx.warning(s"Ignored $name as a field of the record", s)
+              rec(parent)
+            case info: Type =>
+              (name, info) :: rec(parent)
+          }
+
         case _ => Nil
       }
     }
 
     def tupleElem(name: String, info: Type): Expr[Any] = {
       val nameExpr = Expr(name)
-      info.seal match {
-        case '[$qType] =>
-          Expr.ofTuple(Seq(nameExpr, '{$s.selectDynamic($nameExpr).asInstanceOf[$qType]}))
+      info.seal match { case '[$qType] =>
+          Expr.ofTuple(Seq(nameExpr, '{ $s.selectDynamic($nameExpr).asInstanceOf[$qType] }))
       }
     }
 
@@ -40,32 +45,51 @@ object Macro {
     Expr.ofTuple(ret)
   }
 
-  // note: T is not used ATM
-  inline def toSelectable[T](s: Tuple) <: Any = ${ toSelectableImpl('s, '[T])}
-
-  def toSelectableImpl[T](s: Expr[Tuple], tpe: Type[T])(given qctx:QuoteContext): Expr[Any] = {
+  private def fromTupleImpl[T: Type](s: Expr[Tuple], newRecord: Expr[Array[(String, Any)] => T])(given qctx:QuoteContext): Expr[Any] = {
     import qctx.tasty.{given, _}
 
     val repr = s.unseal.tpe.widenTermRefExpr.dealias
 
-    def rec(tpe: Type): List[(String, Type)] = {
+    def isTupleCons(sym: Symbol): Boolean = sym.owner == defn.ScalaPackageClass && sym.name == "*:"
+
+    def extractTuple(tpe: TypeOrBounds, seen: Set[String]): (Set[String], (String, Type)) = {
       tpe match {
-        // todo:
-        //  check number based on prefix
-        //  capture the TupleXX variants in recursion
-        case AppliedType(_, args) => args.map{
-          case AppliedType(_, ConstantType(Constant(name: String)) :: (info: Type) :: Nil) => (name, info)
-        }
+        // Tuple2(S, T) where S must be a constant string type
+        case AppliedType(parent, ConstantType(Constant(name: String)) :: (info: Type) :: Nil) if (parent.typeSymbol == defn.TupleClass(2)) =>
+          if seen(name) then
+            qctx.error(s"Repeated record name: $name", s)
+          (seen + name, (name, info))
+        case _ =>
+          qctx.error("Tuple type was not explicit expected `(S, T)` where S is a singleton string", s)
+          (seen, ("<error>", defn.AnyType))
+      }
+    }
+    def rec(tpe: Type, seen: Set[String]): List[(String, Type)] = {
+      if tpe =:= defn.UnitType then Nil
+      else tpe match {
+        // head *: tail
+        case AppliedType(parent, List(head, tail: Type)) if isTupleCons(parent.typeSymbol) =>
+          val (seen2, head2) = extractTuple(head, seen)
+          head2 :: rec(tail, seen2)
+        // Tuple1(...), Tuple2(...), ..., Tuple22(...)
+        case AppliedType(parent, args) if defn.isTupleClass(parent.typeSymbol) =>
+          (args.foldLeft((seen, List.empty[(String, Type)])){ case ((seenAcc, acc), arg) =>
+            val (seen3, arg2) = extractTuple(arg, seenAcc)
+            (seen3, arg2 :: acc)
+          })._2
+        // Tuple
+        case _ =>
+          qctx.error("Tuple type must be of known size", s)
+          Nil
       }
     }
 
-    val r = rec(repr)
+    val r = rec(repr, Set.empty)
 
-    val refinementType = r.foldLeft('[Record].unseal.tpe)((acc, e) => Refinement(acc, e._1, e._2)).seal
+    val refinementType = r.foldLeft('[T].unseal.tpe)((acc, e) => Refinement(acc, e._1, e._2)).seal
 
-    refinementType match {
-      case '[$qType] =>
-        '{ Record.fromTuple(${s}).asInstanceOf[${qType}] }
+    refinementType match { case '[$qType] =>
+        '{ $newRecord($s.toArray.map(e => e.asInstanceOf[(String, Any)])).asInstanceOf[${qType}] }
     }
   }
 }

tests/run-macros/refined-selectable-macro/Test_2.scala

@@ -2,6 +2,18 @@ import Macro._
 
 object Test {
 
+  // TODO should elems of `new Record` and `Record.fromUntypedTuple` be IArray[Object]
+  // This would make it possible to keep the same reference to the elements when transforming a Tuple into a Record (or vice versa)
+
+  case class Record(elems: (String, Any)*) extends SelectableRecord {
+    def selectDynamic(name: String): Any = elems.find(_._1 == name).get._2
+    override def toString(): String = elems.map(x => x._1 + "=" + x._2).mkString("Record(", ", ", ")")
+  }
+
+  object Record extends SelectableRecordCompanion[Record] {
+    def fromUntypedTuple(elems: (String, Any)*): Record = Record(elems: _*)
+  }
+
   type Person = Record {
     val name: String
     val age: Int
@@ -10,13 +22,49 @@ object Test {
   def main(args: Array[String]): Unit = {
     val person: Person = Record("name" -> "Emma", "age" -> 42).asInstanceOf[Person]
 
-    val res: (("name", String), ("age", Int)) = toTuple(person)
+    val res = person.toTuple
+
+    val p0 = person.asInstanceOf[Record {
+      val name: String
+      def age: Int // ignored
+    }]
+    p0.toTuple
+
+    val p2: Record {
+      val age: Int
+      val name: String
+    } = person
+
+    p2.toTuple : (("age", Int), ("name", String))
 
     println(res)
     println()
 
-    val res2: Person = toSelectable(res)
+    res: (("name", String), ("age", Int))
+
+    val res2 = Record.fromTuple(res)
+
+    val emptyTuple = ()
+    println(Record.fromTuple(emptyTuple))
+
+    //  println(Record.fromTuple((1, 2))) // error
+
+    val xxl: (("field1", Int),("field2", Int),("field3", Int),("field4", Int),("field5", Int),("field6", Int),("field7", Int),("field8", Int),("field9", Int),("field10", Int),("field11", Int),("field12", Int),("field13", Int),("field14", Int),("field15", Int),("field16", Int),("field17", Int),("field18", Int),("field19", Int),("field20", Int),("field21", Int),("field22", Int),("field23", Int),("field24", Int),("field25", Int)) = ("field1" -> 1,"field2" -> 2,"field3" -> 3,"field4" -> 4,"field5" -> 5,"field6" -> 6,"field7" -> 7,"field8" -> 8,"field9" -> 9,"field10" -> 10,"field11" -> 11,"field12" -> 12,"field13" -> 13,"field14" -> 14,"field15" -> 15,"field16" -> 16,"field17" -> 17,"field18" -> 18,"field19" -> 19,"field20" -> 20,"field21" -> 21,"field22" -> 22,"field23" -> 23,"field24" -> 24,"field25" -> 25)
+    println(Record.fromTuple(xxl))
+    // println(Record.fromTuple(("field1" -> 1,"field2" -> 2,"field3" -> 3,"field4" -> 4,"field5" -> 5,"field6" -> 6,"field7" -> 7,"field8" -> 8,"field9" -> 9,"field10" -> 10,"field11" -> 11,"field12" -> 12,"field13" -> 13,"field14" -> 14,"field15" -> 15,"field16" -> 16,"field17" -> 17,"field18" -> 18,"field19" -> 19,"field20" -> 20,"field21" -> 21,"field22" -> 22,"field23" -> 23,"field24" -> 24,"field25" -> 25)))
 
     println(res2)
+
+    // Record.fromTuple[(("name", String), ("name", Int))]("name" -> "aa", "name" -> 3) // error
+
+    res2: Record {
+      val name: String
+      val age: Int
+    }
+
+    res2: Record {
+      val age: Int
+      val name: String
+    }
   }
 }