dap: filter inputs for a step to prevent overeager evaluation

When the debug thread was updated to always solve inputs from the
operation that it was tied to it became a bit overeager to evaluate
them. The intention of the steps is to have a single direct parent and
then potentially multiple "function calls" that can be evaluated with
step into and step out to leave.

With the change, that logic stayed in, but the inputs were always being
evaluated before they were stepped into or over. Now, when we construct
the steps, we also attach a list of inputs that we should defer
evaluation on to ensure we don't execute inputs that haven't been
executed yet.

Signed-off-by: Jonathan A. Sternberg <jonathan.sternberg@docker.com>

Author: jsternberg

dap/thread.go

@@ -2,6 +2,7 @@ package dap
 
 import (
 	"context"
+	"maps"
 	"path"
 	"path/filepath"
 	"slices"
@@ -127,6 +128,10 @@ type step struct {
 	// breakpoint resolution.
 	dgst digest.Digest
 
+	// filtered holds the inputs that should be filtered out of the
+	// solved inputs.
+	filtered map[int]bool
+
 	// in holds the next target when step in is used.
 	in *step
 
@@ -221,7 +226,17 @@ func (t *thread) createBranch(dgst digest.Digest, exitpoint *step) (entrypoint *
 			// Create the routine associated with this input.
 			// Associate it with the entrypoint in step.
 			head.in = t.createBranch(digest.Digest(inp.Digest), entrypoint)
+
 			entrypoint = &head
+
+			// Filter this input from the target so it doesn't get solved
+			// when moving to this step.
+			if entrypoint.filtered != nil {
+				entrypoint.filtered = maps.Clone(entrypoint.filtered)
+			} else {
+				entrypoint.filtered = make(map[int]bool)
+			}
+			entrypoint.filtered[i] = true
 		}
 
 		// If we have no direct parent, return the current entrypoint
@@ -232,11 +247,12 @@ func (t *thread) createBranch(dgst digest.Digest, exitpoint *step) (entrypoint *
 
 		// Create a new step that refers to the direct parent.
 		head := &step{
-			dgst:   digest.Digest(op.Inputs[entrypoint.parent].Digest),
-			in:     entrypoint,
-			next:   entrypoint,
-			out:    entrypoint.out,
-			parent: -1,
+			dgst:     digest.Digest(op.Inputs[entrypoint.parent].Digest),
+			filtered: entrypoint.filtered,
+			in:       entrypoint,
+			next:     entrypoint,
+			out:      entrypoint.out,
+			parent:   -1,
 		}
 		head.frame = t.getStackFrame(head.dgst, entrypoint)
 		entrypoint = head
@@ -561,6 +577,10 @@ func (t *thread) solveInputs(ctx context.Context, target *step) (string, map[str
 	var root string
 	refs := make(map[string]gateway.Reference)
 	for i, input := range op.Inputs {
+		if target.filtered[i] {
+			continue
+		}
+
 		k := t.determineInputName(op, i, input)
 		if _, ok := refs[k]; ok || k == "" {
 			continue