Optimize access to members of structure types when inlining

[Glavo]

When the argument containing the inline function is a struct type, we should convert access to its members to direct access when inline.
For this code

import scala.reflect.Selectable.reflectiveSelectable 

class C {
  def f: Int = 100
}

object C {
  inline def f(a: {def f: Int}): Int = a.f

  def main(args: Array[String]): Unit = {
    val i = f(new C)
  }
}

We have now generated the following code:

public void main(java.lang.String[]);
    Code:
       0: new           #45                 // class C
       3: dup
       4: invokespecial #46                 // Method C."<init>":()V
       7: astore_3
       8: getstatic     #23                 // Field scala/reflect/Selectable$.MODULE$:Lscala/reflect/Selectable$;
      11: aload_3
      12: invokevirtual #27                 // Method scala/reflect/Selectable$.reflectiveSelectable:(Ljava/lang/Object;)Lscala/Selectable;
      15: ldc           #28                 // String f
      17: invokeinterface #34,  2           // InterfaceMethod scala/Selectable.selectDynamic:(Ljava/lang/String;)Ljava/lang/Object;
      22: checkcast     #4                  // class java/lang/Object
      25: invokestatic  #39                 // Method scala/runtime/BoxesRunTime.unboxToInt:(Ljava/lang/Object;)I
      28: istore_2
      29: return

Here we introduce too much extra overhead, and this should be avoided by compiler optimization.

[Glavo]

We might be able to add another access method called inlineSelectable to Selectable to achieve this effect.

[allanrenucci]

This may be solved by transparent methods. Can you try on this branch #4616 replacing inline by transparent? I.e.

import scala.reflect.Selectable.reflectiveSelectable 

class C {
  def f: Int = 100
}

object C {
  transparent def f(a: {def f: Int}): Int = a.f

  def main(args: Array[String]): Unit = {
    val i = f(new C)
  }
}

[Glavo]

It seems that Dotty currently only has the inline method and removes the transparent method? But I tried to compile this code and the result is the same as before.

[abgruszecki]

Closing b/c of inactivity.

[Glavo]

Two years later, I tried to compile this code:

import scala.reflect.Selectable.reflectiveSelectable 

class C {
  def f: Int = 100
}

object C {
  inline def f(a: {def f: Int}): Int = a.f

  def main(args: Array[String]): Unit = {
    val i = f(new C)
  }
}

The result:

 public void main(java.lang.String[]);
    Code:
       0: new           #29                 // class org/glavo/C
       3: dup
       4: invokespecial #30                 // Method org/glavo/C."<init>":()V
       7: astore_3
       8: getstatic     #35                 // Field scala/reflect/Selectable$.MODULE$:Lscala/reflect/Selectable$;
      11: aload_3
      12: invokevirtual #39                 // Method scala/reflect/Selectable$.reflectiveSelectable:(Ljava/lang/Object;)Lscala/Selectable;
      15: ldc           #41                 // String f
      17: invokeinterface #47,  2           // InterfaceMethod scala/Selectable.selectDynamic:(Ljava/lang/String;)Ljava/lang/Object;
      22: invokestatic  #53                 // Method scala/runtime/BoxesRunTime.unboxToInt:(Ljava/lang/Object;)I
      25: istore_2
      26: return

It seems that inline can't remove redundant code. Can this issue be opened again?

[abgruszecki]

@nicolasstucki can you take a look at the above?

[nicolasstucki]

If we use scala.reflect.Selectable.reflectiveSelectable there is not optimization possible. The question is if inline def f(a: {def f: Int}): Int = a.f should be treated specially and not use reflectiveSelectable. Once inlined we would identify the actual invocation target. Not sure if we can do this in all cases. I will investigate further.