Fallback approach if the direct approach does not work: Place the accessor method
in the same class as the inline method, and let it take the receiver as parameter.
This is tricky, since we have to find a suitable type for the parameter, which might
require additional type parameters for the inline accessor. An example is in the
TestPassing class in test run/inline/inlines_1:
class C[T](x: T) {
private[inlines] def next[U](y: U): (T, U) = (x, y)
}
class TestPassing {
inline def foo[A](x: A): (A, Int) = {
val c = new CA
c.next(1)
}
inline def bar[A](x: A): (A, String) = {
val c = new CA
c.next("")
}
C could be compiled separately, so we cannot place the inline accessor in it.
Instead, the inline accessor goes into TestPassing and takes the actual receiver
type as argument:
A definition needs an accessor if it is private, protected, or qualified private
and it is not part of the tree that gets inlined. The latter test is implemented
by excluding all symbols properly contained in the inline method.
A definition needs an accessor if it is private, protected, or qualified private
and it is not part of the tree that gets inlined. The latter test is implemented
by excluding all symbols properly contained in the inline method.
Constant vals don't need accessors since they are inlined in FirstTransform.
Inline methods don't need accessors since they are inlined in Typer.
When creating accessors for staged/quoted code we only need to create accessors
for the code that is staged. This excludes code at level 0 (except if it is inlined).
