test: hold the edits mutation testing found in the reference ports

mutate without Docker over this branch's diff left edits no test
refused. A win32 basename keeps `{:foo` whole, as node's
path.win32.basename does ('{' lowercases past 'z'); oracletest names
the JSON error of a bad recorded or Go result; a case's subtest name
takes the first of its name and fn#index. Dockerfile drops the escape
token nothing reads since base images resolve as TS does, finalStageName
leans on instructions.Parse returning no stages with its error, and the
two index edits that cannot change a match are exempt. stageLabel loses
a check that could not fail: on every FROM line BuildKit accepts, its
continuations joined, the FROM-line expression reads BuildKit's label.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: aledbf

internal/config/varsub_test.go

@@ -137,9 +137,10 @@ func TestComputeDevContainerIDIsPaddedTo52Digits(t *testing.T) {
 	}
 }
 
-// Only a letter followed by a colon is a drive (node path.win32.basename).
+// Only a letter followed by a colon is a drive (node path.win32.basename):
+// '{' lowercases past 'z', so `{:foo` keeps its colon.
 func TestWinBasenameDrive(t *testing.T) {
-	for in, want := range map[string]string{`C:foo`: "foo", `c:\a\b\`: "b", `1:foo`: "1:foo", `C:`: ""} {
+	for in, want := range map[string]string{`C:foo`: "foo", `c:\a\b\`: "b", `1:foo`: "1:foo", `C:`: "", `{:foo`: "{:foo", "@:foo": "@:foo"} {
 		if got := winBasename(in); got != want {
 			t.Errorf("winBasename(%q) = %q, want %q", in, got, want)
 		}

internal/docker/dockerfile.go

@@ -15,7 +15,6 @@ type Dockerfile struct {
 	Preamble      Preamble
 	Stages        []Stage
 	StagesByLabel map[string]*Stage
-	escapeToken   rune
 }
 
 // Preamble is the content before any FROM statement.
@@ -53,14 +52,12 @@ func ExtractDockerfile(content string) *Dockerfile {
 	df := &Dockerfile{
 		Preamble:      Preamble{Directives: map[string]string{}},
 		StagesByLabel: map[string]*Stage{},
-		escapeToken:   '\\',
 	}
 
 	res, err := parser.Parse(strings.NewReader(content))
 	if err != nil {
 		return df
 	}
-	df.escapeToken = res.EscapeToken
 	if syntax, _, _, ok := parser.DetectSyntax([]byte(content)); ok {
 		df.Preamble.Directives["syntax"] = syntax
 		df.Preamble.Version = syntaxVersion(syntax)
@@ -111,9 +108,11 @@ func ExtractDockerfile(content string) *Dockerfile {
 }
 
 // stageLabel is the stage's name as the FROM line spells it: BuildKit
-// lowercases it, TS extractDockerfile keeps it, and looks stages up by it.
+// lowercases it, TS extractDockerfile keeps it, and looks stages up by it. On
+// a FROM line BuildKit accepts (continuations joined), the FROM-line
+// expression reads the label BuildKit names.
 func stageLabel(s *instructions.Stage) string {
-	if m := fromLineLabel.FindStringSubmatch(s.SourceCode); m != nil && strings.EqualFold(m[1], s.Name) {
+	if m := fromLineLabel.FindStringSubmatch(s.SourceCode); m != nil {
 		return m[1]
 	}
 	return s.Name
@@ -202,7 +201,7 @@ var (
 // backslash, which no builder accepts; this reads the stage's name with
 // BuildKit instead when it has one.
 func EnsureFinalStageName(content, defaultName string) (stageName string, modifiedContent string, err error) {
-	lines := findFromLines.FindAllStringIndex(content, -1)
+	lines := findFromLines.FindAllStringIndex(content, -1) // mutate-exempt: any n < 0 is every match
 	if len(lines) == 0 {
 		return "", "", errors.New("Error parsing Dockerfile: Dockerfile contains no FROM instructions")
 	}
@@ -216,7 +215,7 @@ func EnsureFinalStageName(content, defaultName string) (stageName string, modifi
 	if m == nil {
 		return "", "", errors.New("Error parsing Dockerfile: failed to parse final FROM line")
 	}
-	if m[2] != -1 { // the label group, when it matched, is never empty
+	if m[2] != -1 { // mutate-exempt: m[2] and m[3] are both -1 exactly when the label group is unmatched, and a matched label is never empty
 		return content[lineStart+m[2] : lineStart+m[3]], "", nil
 	}
 	pos := lineStart + m[1]
@@ -230,9 +229,9 @@ func finalStageName(content string) string {
 	if err != nil {
 		return ""
 	}
-	stages, _, err := instructions.Parse(res.AST, nil)
-	if err != nil || len(stages) == 0 {
-		return ""
+	// instructions.Parse returns no stages with its error.
+	if stages, _, _ := instructions.Parse(res.AST, nil); len(stages) > 0 {
+		return stages[len(stages)-1].Name
 	}
-	return stages[len(stages)-1].Name
+	return ""
 }

internal/docker/dockerfile_held_test.go

@@ -50,3 +50,12 @@ func TestStageLabelsReadsTheNamedStage(t *testing.T) {
 		t.Errorf("StageLabels(\"\")[k] = %q, want final", got)
 	}
 }
+
+// BuildKit joins a FROM continued onto the next line before the FROM-line
+// expression reads its label, so the stage keeps its name.
+func TestExtractDockerfileLabelsAContinuedFrom(t *testing.T) {
+	df := ExtractDockerfile("FROM alpine \\\n    AS base\nRUN true\n")
+	if len(df.Stages) != 1 || df.Stages[0].From.Label != "base" || df.StagesByLabel["base"] == nil {
+		t.Errorf("stages = %+v, want one labelled base", df.Stages)
+	}
+}

internal/tsoracle/oracletest/oracletest.go

@@ -4,6 +4,7 @@ package oracletest
 
 import (
 	"bytes"
+	"cmp"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -68,11 +69,7 @@ func Run(t *testing.T, path string, impls map[string]Func) {
 		if impl == nil {
 			continue
 		}
-		name := c.Name
-		if name == "" {
-			name = c.Fn + "#" + strconv.Itoa(i)
-		}
-		t.Run(name, func(t *testing.T) {
+		t.Run(cmp.Or(c.Name, c.Fn+"#"+strconv.Itoa(i)), func(t *testing.T) {
 			if c.Result == nil && c.Error == "" {
 				t.Fatal("no recorded result: run `go tool task testdata:ts-oracle`")
 			}

internal/tsoracle/oracletest/oracletest_test.go

@@ -48,6 +48,8 @@ func TestCheck(t *testing.T) {
 		{"falsy false", returns(Truthiness(false), nil), call("f", `false`, ""), ""},
 		{"truthiness differs", returns(Truthiness(true), nil), call("f", `0`, ""), "truthy: false"},
 		{"truthy object", returns(Truthiness(true), nil), call("f", `{}`, ""), ""},
+		{"bad recorded result", returns(1, nil), call("f", `{`, ""), "bad recorded result: unexpected end of JSON input"},
+		{"Go result is no JSON", returns(func() {}, nil), call("f", `1`, ""), "Go result is no JSON: invalid character"},
 	}
 	for _, tc := range tests {
 		t.Run(tc.name, func(t *testing.T) {