dap: properly map source paths to client side paths

Properly map the source paths from the metadata in the solve to the
client side paths. The source path returns is relative to the context
that gets uploaded which is usually a subdirectory. The original code
noticed this when mapping the paths but made the invalid assumption that
the dockerfile would always be in the context path so it combined the
dockerfile name with the context path.

It is possible for the dockerfile to be in a subdirectory of the
context. In which case, we computed the paths incorrectly.

This modifies DAP to instead use the `DockerfileMappingDst` and
`DockerfileMappingSrc` which are special included variables to the
inputs that get filled in during the build for the purpose of mapping
the source path to the client side path.

Tests have also been added for this functionality to ensure it doesn't
break again. This should work with both absolute and relative paths
although absolute paths should probably be preferred for usage just
because they're less likely to result in weird things happening.

The sources are also normalized to always convert the source filenames
to absolute paths and DAP itself will accept relative paths but will
only ever communicate in absolute paths. When you set a breakpoint, it
will convert it to an absolute path and reference it in that way rather
than a relative path.

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

Author: jsternberg

dap/adapter.go

@@ -7,7 +7,6 @@ import (
 	"fmt"
 	"io"
 	"path"
-	"path/filepath"
 	"slices"
 	"sync"
 	"sync/atomic"
@@ -598,22 +597,22 @@ func (b *breakpointMap) Set(fname string, sbps []dap.SourceBreakpoint) (breakpoi
 	return breakpoints
 }
 
-func (b *breakpointMap) Intersect(ctx Context, src *pb.Source, ws string) map[digest.Digest]int {
+func (b *breakpointMap) Intersect(ctx Context, src *pb.Source) map[digest.Digest]int {
 	b.mu.Lock()
 	defer b.mu.Unlock()
 
 	digests := make(map[digest.Digest]int)
 
 	for dgst, locs := range src.Locations {
-		if id := b.intersect(ctx, src, locs, ws); id > 0 {
+		if id := b.intersect(ctx, src, locs); id > 0 {
 			digests[digest.Digest(dgst)] = id
 		}
 	}
 
 	// Mark unverified breakpoints as failed at this point since we couldn't find an area
 	// in the source where they applied.
 	for _, info := range src.Infos {
-		fname := filepath.Join(ws, info.Filename)
+		fname := info.Filename
 
 		bps := b.byPath[fname]
 		for _, bp := range bps {
@@ -633,7 +632,7 @@ func (b *breakpointMap) Intersect(ctx Context, src *pb.Source, ws string) map[di
 	return digests
 }
 
-func (b *breakpointMap) intersect(ctx Context, src *pb.Source, locs *pb.Locations, ws string) int {
+func (b *breakpointMap) intersect(ctx Context, src *pb.Source, locs *pb.Locations) int {
 	overlaps := func(r *pb.Range, bp *dap.Breakpoint) bool {
 		if bp.Line < int(r.Start.Line) || bp.Line > int(r.End.Line) {
 			return false
@@ -654,7 +653,7 @@ func (b *breakpointMap) intersect(ctx Context, src *pb.Source, locs *pb.Location
 		r := loc.Ranges[0]
 
 		info := src.Infos[loc.SourceIndex]
-		fname := filepath.Join(ws, info.Filename)
+		fname := info.Filename
 
 		bps := b.byPath[fname]
 		if len(bps) == 0 {

dap/adapter_test.go

@@ -187,12 +187,12 @@ func TestBreakpointMapIntersectVerified(t *testing.T) {
 	src := &pb.Source{
 		Locations: srcLocs,
 		Infos: []*pb.SourceInfo{
-			{Filename: filename},
+			{Filename: fpath},
 		},
 	}
 
 	ctx := newBreakpointTestContext(t)
-	digests := bm.Intersect(ctx, src, ws)
+	digests := bm.Intersect(ctx, src)
 	wantMatches := 0
 	for _, bc := range breakpointCases {
 		if bc.expectVerified {

dap/thread.go

@@ -2,9 +2,9 @@ package dap
 
 import (
 	"context"
-	"path"
 	"path/filepath"
 	"slices"
+	"strings"
 	"sync"
 
 	"github.com/docker/buildx/build"
@@ -31,10 +31,10 @@ type thread struct {
 	variables *variableReferences
 
 	// Inputs to the evaluate call.
-	c          gateway.Client
-	ref        gateway.Reference
-	meta       map[string][]byte
-	sourcePath string
+	c             gateway.Client
+	ref           gateway.Reference
+	meta          map[string][]byte
+	sourceInfoMap func(*pb.Source) *pb.Source
 
 	// LLB state for the evaluate call.
 	def    *llb.Definition
@@ -107,14 +107,21 @@ func (t *thread) init(ctx Context, c gateway.Client, ref gateway.Reference, meta
 	t.c = c
 	t.ref = ref
 	t.meta = meta
-
-	// Combine the dockerfile directory with the context path to find the
-	// real base path. The frontend will report the base path as the filename.
-	dir := path.Dir(inputs.DockerfilePath)
-	if !path.IsAbs(dir) {
-		dir = path.Join(inputs.ContextPath, dir)
+	t.sourceInfoMap = func(s *pb.Source) *pb.Source {
+		s = s.CloneVT()
+		for _, sinfo := range s.Infos {
+			// Map the filename from the source info from the frontend location to the
+			// client location.
+			fname := strings.Replace(sinfo.Filename, inputs.DockerfileMappingDst, inputs.DockerfileMappingSrc, 1)
+
+			// Convert to an absolute path.
+			if abspath, err := filepath.Abs(fname); err == nil {
+				fname = abspath
+			}
+			sinfo.Filename = fname
+		}
+		return s
 	}
-	t.sourcePath = dir
 
 	if err := t.getLLBState(ctx); err != nil {
 		return err
@@ -252,7 +259,7 @@ func (t *thread) getStackFrame(dgst digest.Digest, next *step) *frame {
 		f.setNameFromMeta(meta)
 	}
 	if loc, ok := t.def.Source.Locations[string(dgst)]; ok {
-		f.fillLocation(t.def, loc, t.sourcePath, next)
+		f.fillLocation(t.def, loc, next)
 	}
 	t.frames[int32(f.Id)] = f
 	return f
@@ -296,7 +303,6 @@ func (t *thread) reset() {
 	t.c = nil
 	t.ref = nil
 	t.meta = nil
-	t.sourcePath = ""
 	t.ops = nil
 }
 
@@ -462,9 +468,12 @@ func (t *thread) getLLBState(ctx Context) error {
 		return err
 	}
 
+	if t.sourceInfoMap != nil {
+		t.def.Source = t.sourceInfoMap(t.def.Source)
+	}
+
 	for _, src := range t.def.Source.Infos {
-		fname := filepath.Join(t.sourcePath, src.Filename)
-		t.sourceMap.Put(ctx, fname, src.Data)
+		t.sourceMap.Put(ctx, src.Filename, src.Data)
 	}
 
 	t.ops = make(map[digest.Digest]*pb.Op, len(t.def.Def))
@@ -483,7 +492,7 @@ func (t *thread) getLLBState(ctx Context) error {
 }
 
 func (t *thread) setBreakpoints(ctx Context) {
-	t.bps = t.breakpointMap.Intersect(ctx, t.def.Source, t.sourcePath)
+	t.bps = t.breakpointMap.Intersect(ctx, t.def.Source)
 }
 
 func (t *thread) seekNext(ctx Context, from *step, action stepType) (string, *step, map[string]gateway.Reference, error) {

dap/variables.go

@@ -38,7 +38,7 @@ func (f *frame) setNameFromMeta(meta llb.OpMetadata) {
 	// TODO: should we infer the name from somewhere else?
 }
 
-func (f *frame) fillLocation(def *llb.Definition, loc *pb.Locations, ws string, next *step) {
+func (f *frame) fillLocation(def *llb.Definition, loc *pb.Locations, next *step) {
 	for _, l := range loc.Locations {
 		for _, r := range l.Ranges {
 			if next != nil && f.Line != 0 {
@@ -57,7 +57,7 @@ func (f *frame) fillLocation(def *llb.Definition, loc *pb.Locations, ws string,
 			info := def.Source.Infos[l.SourceIndex]
 			f.Source = &dap.Source{
 				Name: path.Base(info.Filename),
-				Path: filepath.Join(ws, info.Filename),
+				Path: info.Filename,
 			}
 
 			// If we do not have a next operation, then we don't have