Transparent inline method call doesn't expand inside another inline method

[Iltotore]

Compiler version

3.0.0

Minimized code

First sample

transparent inline def transform(inline a: Any): Any = inline a match {
  case x: Byte   => x
  case x: Short  => x
  case x: Int    => x
  case x: Long   => x
  case x: Float  => x
  case x: Double => x
  case _         => a
}

@main def test = {
  println(transform(0) < 5)
}

Second sample

transparent inline def transform(inline a: Any): Any = inline a match {
  case x: Byte   => x
  case x: Short  => x
  case x: Int    => x
  case x: Long   => x
  case x: Float  => x
  case x: Double => x
  case _         => a
}

inline def lt(inline a: Any, inline b: Double): Boolean = transform(a) < b

@main def test = {
  println(lt(0, 5))
}

Expectation

The first sample compiles as expected.

The second sample doesn't compile but should. In lt, the transform call is fully inlined so I assume the compiler should be able to find the right return type.

[odersky]

Calls are never inlined in inline methods, so this does not work.

But I agree that the different phases of inlining can be confusing. The question is whether we can and should do all of inlining in typer again to avoid these surprises.

[nicolasstucki]

But I agree that the different phases of inlining can be confusing. The question is whether we can and should do all of inlining in typer again to avoid these surprises.

This has nothing to do with inlining at different times. The same will happen if lt is transparent.

[nicolasstucki]

The compiler error is correct. When compiling

inline def lt(inline a: Any, inline b: Double): Boolean = transform(a) < b

we only know that a is an Any and the same for transform(a). Hence it is impossible to type check the body of lt.
This is a restriction that comes from the semantic inline definition.

What this method is trying to achieve is to do is syntactic inlining where the body is only type-checked after inlining.

[Iltotore]

we only know that a is an Any and the same for transform(a). Hence it is impossible to type check the body of lt.
This is a restriction that comes from the semantic inline definition.

Doesn't the compiler check the type when inlining transform ? I don't really see why it requires the type make transform(a) returning the right type.

[nicolasstucki]

Doesn't the compiler check the type when inlining transform ?

Yes. But that is later when inlining the call lt(0, 5).

The failure happens at the definition site of lt, there you don't have any information about the type of a. Furthermore, we do not inline inside of the body of another inline. So at that time transform has no chance to act.

[nicolasstucki]

We describe the semantics of inlining in more detail in http://biboudis.github.io/papers/inlining-scala20.pdf