let me state first that I am really glad this - long requested (see http://www.jetbrains.net/jira/browse/IDEABKL-6) - feature is finally being implemented.
However, I think it would be worth to consider a few alternatives to the current (build 6667) implementation.
What I had in mind when this was originally discussed was that during debugging, the method into which F7 would step would somehow be highlighted (e.g. by underlining the method name or displaying it in a different color) and that you would have an additional stepping mode which would execute this but not necessarily the complete statement. (Basically, this would be more something like a "Smart Step Over" than a "Smart Step Into").
Example: You debug the line foo(bar(1), baz(2));
When you first reach it, it is displayed as foo(_bar(_1_)_, baz(2)); after doing a "Smart Step Over" (during which bar(1) is executed), it changes to foo(bar(1), baz(2_)_); (after which a "standard" F7 would directly step into baz(2)) and after another "Smart Step Over", it will be foo(bar(1), baz(2)_)_;
Of course, for very complex method calls within one statement, the current "Smart Step Into" implementation could be a quicker way to the call you are interested in, but (though this may be my personal taste), I think even in that case I would prefer the "Smart Step Over" functionality described above (perhaps because the popup somehow disrupts the editor-centric debugging flow).
Finally, a minor bug report to the current implementation: If you have a statement with two calls to the same method, only one invocation is listed in the popup: "Smart stepping" into foo(bar(1), bar(2)); will only offer the methods "foo(int, int)" and "bar(int)"; selecting the latter will step into the first invocation; there is no way of directly getting to the second one.