Check all tuple structures

Co-authored-by: Nicolas Stucki <nicolas.stucki@gmail.com>

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
+ }
  }
 }