Are stack traces less navigable when using method references vs lambdas?

Question

I just performed a quick experiment in Eclipse.

public class StackTractTest {

  static class Nasty {
    public Integer toInt() {
      if (1 == 1) throw new RuntimeException();
      return 1;
    }
  }

  @Test
  public void methodReference() {
    Stream.of(new Nasty())
      .map(Nasty::toInt)
      .findFirst();
  }

  @Test
  public void lambda() {
    Stream.of(new Nasty())
      .map(n -> n.toInt())
      .findFirst();
  }

}

When the method-reference test fails, the trace begins

java.lang.RuntimeException
    at com.example.StackTractTest$Nasty.toInt(StackTractTest.java:11)
    at com.example.StackTractTest$$Lambda$1/1681433494.apply(Unknown Source)
    at java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:193)

There is no reference back to the line on which the method reference is used although the end of the trace (not shown) does link back to line with findFirst on.

While the lamdba stacktrace begins

java.lang.RuntimeException
    at com.example.StackTractTest$Nasty.toInt(StackTractTest.java:11)
    at com.example.StackTractTest.lambda$0(StackTractTest.java:26)
    at com.example.StackTractTest$$Lambda$1/1681433494.apply(Unknown Source)
    at java.util.stream.ReferencePipeline$3$1.accept(ReferencePipeline.java:193)

Which correctly identifies the lambda was used on line 26.

Is this a peculiarity of the Eclipse compiler or is this a general disadvantage of using method references that should be considered when choosing between them and a lambda?

Answer 1

No, this is how it is currently implemented.

Quoting a paper written by Brian Goetz about the translation of lambda expressions:

When the compiler encounters a lambda expression, it first lowers (desugars) the lambda body into a method whose argument list and return type match that of the lambda expression

...

Method references are treated the same way as lambda expressions, except that most method references do not need to be desugared into a new method; we can simply load a constant method handle for the referenced method and pass that to the metafactory.

The only difference between your two stacktraces is that the one with the explicit lambda has this line added:

at com.example.StackTractTest.lambda$0(StackTractTest.java:26)

It is because the lambda was translated by javac into a newly generated method, and you can actually see in the stacktrace that this new method was lambda$0.

With a method-reference, it is not necessary to generate a new method because it directly references an existing method.

Answer 2

No - in fact you get more clarity.

The fact that the at com.example.StackTractTest.lambda$0(StackTractTest.java:26) line appears in the lambda version is reminding you that a lambda is created for this technique while using a method reference does not create anything extra.

The lambda is created at run-time, the method-reference can be constructed at compile time.