Make `step_into({ askForTarget = true })` fall back to normal `step_into()` if no targets are available

[Gaweringo]

Debug adapter definition and debug configuration

Example for rust, but also happens in C++ if there is nothing to step into (and maybe other times aswell).

      dap.adapters.codelldb = {
        type = "executable",
        command = "codelldb",
      }

      dap.configurations.rust = {
        {
          -- If you get an "Operation not permitted" error using this, try disabling YAMA:
          --  echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope
          name = "Attach to process (codelldb)",
          type = 'codelldb',
          request = 'attach',
          pid = require('dap.utils').pick_process,
          args = {},
        },
      }

Debug adapter version

1.11.5

Steps to Reproduce

1. Start a debugging session (in my case with codelldb)
2. Use require('dap').step_into({ askForTarget = true }) to step through your program.
3. You can't step though your program this way, since if there are no targets provided by the debug adapter, step_into does nothing in this case.

See this video for a demonstration, where normal step_into() steps into a function, but step_into({ askForTarget = true }) gets no targets from the debug adapter and thus, does not:

nvim-dap_step_into.mp4

Expected Result

That when the debug adapter does not provide any targets, the fallback is step_into(), which would then fall back to step_over().

Actual Result

If the debug adapter does not provide any targets, the message "No target selected. Not stepping" is printed.

[Gaweringo]

I've made a PR for this, so it can be added directly, if this behavior is desired.
Hope that's ok :)

[mfussenegger]

Is there an upstream issue for this for the debug adapter in question? I'd think that the adapter ought to return a target if it is possible to step without asking for any targets.

[mfussenegger]

I just tried this with:

#include <stdio.h>


int foo() {
  return 4;
}

int main() {
  int x = 0;
  x = x + foo();
  printf("%d",x);
}

And calling require("dap").step_into({ askForTargets = true }) on the x = x + foo() line and it steps into the foo function correctly.

Can you provide a minimal reproduction?

[Gaweringo]

I haven't found a smaller, reproducible example where the issue occurs on a line which has a function call, other than cloning rust_hdl and trying to step into the vhdl_ls::start() function.

But this issue isn't just about that. The problem is, that you can use step_into() to go through all lines of the example you posted, but not when you set askForTargets = true.

Because, if you try to use require("dap").step_into({ askForTargets = true }) on int x = 0; in your example, you get "No target selected. No stepping." as the message. If you instead use askForTargets = false, step_into() falls back to step_over() and moves on to the next line.

Which makes step_into() inconsistent based on the setting of askForTargets.

The issue, where there are no targets returned for the StepInTargets request if there is a function call on the current line, is most likely an issue with the adapter. But for the case where there is actually no target to step into, I still think it would make sense for nvim-dap to fall back to the normal step_into(), which would then fall back to a next/step_over.