Can I find out the return value before returning while debugging in Intellij?

With:

Object method(){
    ...
    return /* some complex expression */
}

Is there a way I can see what value will be returned while debugging? Like somehow set a breakpoint that would be hit right after the return, but be开发者_运维知识库fore execution goes to the calling code? I'd like to be able to know what the return value is and also be able to see what values of all of the local variables are.

The way I do it now is by making a temporary variable: Object ret = /* something complex */; return ret;. But thats a hassle and also adds an extra unnecessary line of code.

Note: This is the same question as Can I find out the return value before returning while debugging in Visual Studio, but for intellij.

On IntelliJ IDEA 2016.3: it's hidden inside the cog button of the debug panel. Ensure Show Method Return Values is checked.

Use the debugger to break somewhere inside the function whose return value you'd like to see.

Step out of the function (or step over until you escape):

Observe that the return value appears in your variables:

There is Watch method return values button available in the debugger panel.

Watch method return values: Click this button to watch return values of the last executed method.

IDEA 12 configuration:

There seems to be a couple ways you can do this. The first one involves setting up the breakpoint on the method signature, in your case you would setup a breakpoint on Object method(){ . This will allow you to watch for the entrance and exit of the method. I believe you have to use this in conjunction with "Watch method return values" like stated above, but I haven't been able to completely test this as it takes too long to compute. Beware, this does dramatically decrease the performance of the debugger and it will take longer to debug.

Also you can do the following manually.

1. Setup the breakpoint on the return line.
2. When the return line is hit, click on the return line, specifically put the cursor on the operation that you want to see, then go to Run->Evaluate Expression (or Alt-F8) and it should run the expression at that point and return what it's returning.

Note: If you create a breakpoint, there are a lot of things you can tell IDEA to do with them, such as if you break on a breakpoint, you can tell them to perform an expression and log it. You can look around with what you can do if you right-click on a breakpoint and click properties.

UPDATE: Try this in conjunction with the first way of doing it. Don't use "Watch method return values" as it seems to slow down or freeze up the debugging session. Instead do the following

1. Right-click on the return expression you want to see and click "Add to Watches"
2. Next add a method breakpoint like stated above.
3. Debug your program and your method will break on the method signature.
4. Hit the F9 key for continue and it should break again AFTER the return expression has been computed and your return expression should be in the watch column.

Remember that method breakpoints are slower so it might take more time, a tricky way to improve this if you are noticing too much of a performance hit is by just setting the return statement breakpoint (without having a method breakpoint) and then adding the method breakpoint AFTER the return statement breakpoint hits and then continuing.

Hope this helps,

This was asked a while ago, but I use a different method when I want to handle this situation.

When debugging, you can mark the expression (in your case, the expression right after the "return") and hit CTRL + ALT + F8 (Quick Evaluate Expression). IntelliJ will pop up a little window showing you the value that will be returned.

Since the accepted answer did not exactly answer all my scenarios (or at least I could not get them to work reading the instructions) in which I need this, I felt free to also post an answer that solves it for my specific situation.

I have some additional requirements when trying to inspect the return value.

1. I do not want to leave the scope of the method from which we return.

2. I do not want to call the method in the return statement twice (once for inspecting and once when actually returning) as nicely demonstrated by using Math.random() in the example.

For me the solution was rather unexpected. After fiddling around with Step Over (as opposed to Step Out), I came up with the following construction:

Instead of using

private double rand() {
    return Math.random();
}

I use

private double rand() {
    return 
      Math.random();
}

When your cursor is at Math.random(), select Step Over and it will show the value in the watch window, without leaving the calling scope of the rand().

So it appears the Step Over mentioned in the accepted answer does not solve the issue if the return keyword is on the same line as the expression you are trying to inspect. Which of course makes sense from a syntactic point of view.

I guess this still might pose problems for autoformatters that reduce those two lines to a single one, but for me this finally solved my debugging problem.