Apparently intersecting structural types compile, but throw at runtime on field access.

[Quafadas]

Compiler version

3.3.1

Minimized code

import reflect.Selectable.reflectiveSelectable

class Record(elems: (String, Any)*) extends Selectable:
  private val fields = elems.toMap
  def selectDynamic(name: String): Any = fields(name)

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

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

  type Named = { val name: String }
  def typeTest(x: Named) =
    println(x.name)

  typeTest(person)
}

yields

Output

Exception in thread "main" java.lang.NoSuchMethodException: Record.name()
        at java.base/java.lang.Class.getMethod(Class.java:2395)
        at scala.reflect.Selectable.applyDynamic(Selectable.scala:38)
        at scala.reflect.Selectable.applyDynamic$(Selectable.scala:11)
        at scala.reflect.Selectable$DefaultSelectable.applyDynamic(Selectable.scala:51)
        at scala.reflect.Selectable.selectDynamic(Selectable.scala:28)
        at scala.reflect.Selectable.selectDynamic$(Selectable.scala:11)
        at scala.reflect.Selectable$DefaultSelectable.selectDynamic(Selectable.scala:51)
        at plotnetwork$package$.typeTest$1(plotnetwork.scala:38)
        at plotnetwork$package$.plotNetwork(plotnetwork.scala:40)
        at plotNetwork.main(plotnetwork.scala:32)

Expectation

My intuition would be that this would be either a compile error, or print "Emma"... but I can see that with the "asInstanceOf" and "reflection", that intuition may not be the right thing here.

Referenced / discovered in this discussion
tarao/record4s#45

[mbovel]

I can see that with the "asInstanceOf" and "reflection", that intuition may not be the right thing here.

The x. name selection in typeTest is compiled to:

scala.reflect.Selectable.reflectiveSelectable(x).selectDynamic("name").$asInstanceOf[(obj.name : String)]

I think this is expected. By having a value x: { val name: String } and importing reflect.Selectable.reflectiveSelectable your are telling the compiler: trust me, x has a field name: String, and you can access it using reflection.

If instead you want:

x.selectDynamic("name").$asInstanceOf[(person.name : String)]

then the type of x should be a child type of Selectable.

What is your use-case? Do you need to provide different implementations of selectDynamic for different types? If yes, then that could be achieved, using a common parent trait:

package structIntersect2

trait Record extends Selectable:
  def selectDynamic(name: String): Any

class RecordMap(elems: (String, Any)*) extends Record:
  private val fields = elems.toMap
  def selectDynamic(name: String): Any = fields(name)

class RecordList(elems: (String, Any)*) extends Record:
  private val fields = elems.toList
  def selectDynamic(name: String): Any = fields.find(_._1 == name).get._2

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

@main def main(): Unit =
  def typeTest(x: Record {val name: String}) = println(x.name)
  val person = RecordMap("name" -> "Emma", "age" -> 42).asInstanceOf[Person]
  val person2 = RecordList("name" -> "Emma", "age" -> 42).asInstanceOf[Person]
  typeTest(person)
  typeTest(person2)

[mbovel]

Maybe the debatable part is Record { val name: String } <:< Object {val name: String} as this effectively drops the information of "how to select name", but I don't see how this could not be the case, as we of course have Record <:< Object.

Maybe this could be warning material? Is upcasting a Selectable to an Object generally undesirable?

[Quafadas]

@mbovel I wanted to write back for the sake of acknowledging your work and saying thankyou for your anaylsis - I am, sadly not in a position to provide substantive commentary and would trust your judgement :-).

What is your use-case?

It stems from playing with a library that I liked the look of. I am mostly parroting the suggestion, of that library author.
tarao/record4s#45 (comment)

My motivating example, was this;

import com.github.tarao.record4s.%
import reflect.Selectable.reflectiveSelectable

@main def playdoh =

  type BarPlottable = {
    val x: Int
    val y: Int
    val label: String
  }

  val t = %(x = 1, y = 2, label = "String")

  def typeTest(r: BarPlottable) =
    println(r.x)
    r.y
    r.label

  typeTest(t)

Which compilesa but throws. I'm unclear if that's helpful for this issue. I think the real action here happens inside records4s, which I am not qualified to comment on. The library author minimised to the code I think placed in this issue...