Add refined tupled records prototype

[biboudis]

This PR adds two macros, toTuple and fromTuple that transform a refinement type into a tuple and vice-versa:

  type Person = Record {
    val name: String
    val age: Int
  }

  val person: Person = Record("name" -> "Emma", "age" -> 42).asInstanceOf[Person]
  val res: (("name", String), ("age", Int)) = person.toTuple
  val res2: Person = Record.fromTuple(res)

To enable this functionality the user would need to SelectableRecord instead of Selectable, e.g., :

  case class Record(elems: (String, Any)*) extends SelectableRecord {
    def selectDynamic(name: String): Any = elems.find(_._1 == name).get._2
  }

  object Record extends SelectableRecordCompanion[Record] {
    def fromUntypedTuple(elems: (String, Any)*): Record = Record(elems: _*)
  }

[milessabin]

I'm not super-keen on the aesthetics of the asInstanceOf[Person] in,

val person: Person = Record("name" -> "Emma", "age" -> 42).asInstanceOf[Person]

I appreciate that we need to mention Person somewhere, but can't we drop the asInstanceOf?

Could,

val person: Person = Record("name" -> "Emma", "age" -> 42).as[Person]

be made to work?

[nicolasstucki]

Probably a record should have a better constructor. One that could figure out the refined type.

[biboudis]

@nicolasstucki do you mean a smarter implementation of the constructor or something like Record[Person]. In that case I think the as reveals the intent nicely.

[nicolasstucki]

I meant Record("name" -> "Emma", "age" -> 42) would return Record{val name: String; val age: Int which is a person

[biboudis]

After a quick brainstorming with @liufengyun we propose some functionality on tasty-reflect like the following where qctx.expected is something that the macro system provides. WDYT?

  object Record extends SelectableRecordCompanion[Record] {
    def fromUntypedTuple(elems: (String, Any)*): Record = Record(elems: _*)

    inline def apply(elems: (String, Any)*) <: Record = ${ applyImpl('elem)) }

    def applyImpl(elems: Expr[Seq[(String, Any)]])(given qctx: QuoteContext) = {
      type TT

      implicit val ttype: quoted.Type[TT] = qctx.expected.seal.asInstanceOf[quoted.Type[TT]]
      
      '{ new Record(elems).asInstanceOf[TT] }
    }
  }

😃 😃

[nicolasstucki]

That is horribly unsound

[nicolasstucki]

You probably want something in the lines of

inline def apply[R <: Record](elems: (String, Any)*) <: R = ${ applyImpl('elem, '[R])) }

[biboudis]

I assumed we wanted to avoid the type parameter 😛! apply[R] sounds good!

[julienrf]

I appreciate that we need to mention Person somewhere, but can't we drop the asInstanceOf?

Why can’t the following work?

val person: Person = Record("name" -> "Emma", "age" -> 42)

[biboudis]

Hmm the compiler cannot infer this ATM 🤷‍♂ I guess it would need some tweaking in the Typer.

[nicolasstucki]

No, the apply method would just be another macro

[nicolasstucki]

We are getting off-topic. This PR is about prototyping the core macro logic for refinement types. Any API design concerns are for later.

[biboudis]

After the last commit I have two observations to share:

1. @anatoliykmetyuk typeCheckErrors seems to include the same error many times on the returned list. I don't know if this is by design because in the check file we have the same error twice as well typeCheckErrors.check. WDYT?
2. @nicolasstucki the inlined apply works when I pass Person explicitly as the type argument of the constructor call Record[Person]("name" -> "Emma", "age" -> 42)

If I don't, the compiler infers Nothing (which later splices in the asInstanceOf). This may be an inference problem instead of a macro problem.

[anatoliykmetyuk]

Yes, typeCheckErrors may have the same error many times. That's because it takes raw error list from the reporters of the parser and typer phases and that's what the reporters have. I don't know why precisely they may have duplicates so I didn't do any filtering.

[anatoliykmetyuk]

The only filtering done in typeCheckErrors is to exclude parser errors from typer errors:

https://github.com/lampepfl/dotty/blob/d3a2d61d531aa88532bd9d37392f960c5477b705/compiler/src/dotty/tools/dotc/typer/Inliner.scala#L222

[biboudis]

If I don't, the compiler infers Nothing (which later splices in the asInstanceOf). This may be an inference problem instead of a macro problem.

Opened #7798

//edit: seems that after #7798 is solved (related to inlining), the same type inference problem arises even without inline #7805