When should I (and should I not) use Scala's @inline annotation?

Question

I believe I understand the basics of inline functions: instead of a function call resulting in parameters being placed on the stack and an invoke operation occurring, the definition of the function is copied at compile time to where the invocation was made, saving the invocation overhead at runtime.

So I want to know:

• Does scalac use smarts to inline some functions (e.g. private def) without the hints from annotations?

• How do I judge when it be a good idea to hint to scalac that it inlines a function?

• Can anyone share examples of functions or invocations that should or shouldn't be inlined?

Answer 1

Never @inline anything whose implementation might reasonably change and which is going to be a public part of a library.

When I say "implementation change" I mean that the logic actually might change. For example:

object TradeComparator extends java.lang.Comparator[Trade] {
  @inline def compare(t1 : Trade, t2 : Trade) Int = t1.time compare t2.time
}

Let's say the "natural comparison" then changed to be based on an atomic counter. You may find that an application ends up with 2 components, each built and inlined against different versions of the comparison code.

Answer 2

Personally, I use @inline for alias:

class A(param: Param){
  @inline def a = param.a
  def a2() = a * a
}

Now, I couldn't find a way to know if it does anything (I tried to jad the generated .class, but couldn't conclude anything).

My goal is to explicit what I want the compiler to do. But let it decide what's best, or simply do what it's capable of. If it doesn't do it, maybe later compiler version will.