From 0b2686135b7e71872c3965153df2606b609dcba9 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Sat, 28 Mar 2026 10:04:45 +0800 Subject: [PATCH 01/44] build: prototype load-time source patches --- internal/build/build.go | 4 + internal/build/source_patch.go | 156 ++++++++++++++++++++++++++++ internal/build/source_patch_test.go | 40 +++++++ runtime/build.go | 21 +++- runtime/internal/lib/iter/iter.go | 1 + 5 files changed, 221 insertions(+), 1 deletion(-) create mode 100644 internal/build/source_patch.go create mode 100644 internal/build/source_patch_test.go diff --git a/internal/build/build.go b/internal/build/build.go index 243dfd8665..6a77bb80be 100644 --- a/internal/build/build.go +++ b/internal/build/build.go @@ -297,6 +297,10 @@ func Do(args []string, conf *Config) ([]Package, error) { if patterns == nil { patterns = []string{"."} } + cfg.Overlay, err = buildSourcePatchOverlay(cfg.Overlay, env.LLGoRuntimeDir()) + if err != nil { + return nil, err + } initial, err := packages.LoadEx(dedup, sizes, cfg, patterns...) if err != nil { return nil, err diff --git a/internal/build/source_patch.go b/internal/build/source_patch.go new file mode 100644 index 0000000000..560f7be649 --- /dev/null +++ b/internal/build/source_patch.go @@ -0,0 +1,156 @@ +package build + +import ( + "bytes" + "fmt" + "os" + "path/filepath" + "runtime" + "slices" + "strings" + + llruntime "github.com/goplus/llgo/runtime" +) + +func cloneOverlay(src map[string][]byte) map[string][]byte { + if len(src) == 0 { + return nil + } + dup := make(map[string][]byte, len(src)) + for k, v := range src { + dup[k] = slices.Clone(v) + } + return dup +} + +func buildSourcePatchOverlay(base map[string][]byte, runtimeDir string) (map[string][]byte, error) { + return buildSourcePatchOverlayForGOROOT(base, runtimeDir, runtime.GOROOT()) +} + +func buildSourcePatchOverlayForGOROOT(base map[string][]byte, runtimeDir, goroot string) (map[string][]byte, error) { + var out map[string][]byte + for _, pkgPath := range llruntime.SourcePatchPkgPaths() { + changed, next, err := applySourcePatchForPkg(base, out, runtimeDir, goroot, pkgPath) + if err != nil { + return nil, err + } + if !changed { + continue + } + out = next + } + if out == nil { + return base, nil + } + return out, nil +} + +func applySourcePatchForPkg(base, current map[string][]byte, runtimeDir, goroot, pkgPath string) (bool, map[string][]byte, error) { + patchDir := filepath.Join(runtimeDir, "internal", "lib", filepath.FromSlash(pkgPath)) + entries, err := os.ReadDir(patchDir) + if err != nil { + if os.IsNotExist(err) { + return false, current, nil + } + return false, nil, fmt.Errorf("read source patch dir %s: %w", pkgPath, err) + } + + srcDir := filepath.Join(goroot, "src", filepath.FromSlash(pkgPath)) + srcEntries, err := os.ReadDir(srcDir) + if err != nil { + return false, nil, fmt.Errorf("read stdlib dir %s: %w", pkgPath, err) + } + + var ( + out = current + changed bool + patchSrcs = make(map[string][]byte) + skipAll bool + ) + readOverlay := func(filename string) ([]byte, error) { + if out != nil { + if src, ok := out[filename]; ok { + return src, nil + } + } + if src, ok := base[filename]; ok { + return src, nil + } + return os.ReadFile(filename) + } + + for _, entry := range entries { + if entry.IsDir() { + continue + } + name := entry.Name() + if !strings.HasSuffix(name, ".go") || strings.HasSuffix(name, "_test.go") { + continue + } + filename := filepath.Join(patchDir, name) + src, err := readOverlay(filename) + if err != nil { + return false, nil, fmt.Errorf("read source patch file %s: %w", filename, err) + } + patchSrcs[name] = slices.Clone(src) + if bytes.Contains(src, []byte("llgo:skipall")) { + skipAll = true + } + } + if len(patchSrcs) == 0 { + return false, current, nil + } + + ensureOverlay := func() { + if out == nil { + out = cloneOverlay(base) + if out == nil { + out = make(map[string][]byte) + } + } + } + + if skipAll { + for _, entry := range srcEntries { + if entry.IsDir() { + continue + } + name := entry.Name() + if !strings.HasSuffix(name, ".go") || strings.HasSuffix(name, "_test.go") { + continue + } + filename := filepath.Join(srcDir, name) + src, err := readOverlay(filename) + if err != nil { + return false, nil, fmt.Errorf("read stdlib source file %s: %w", filename, err) + } + stub, err := packageStubSource(src) + if err != nil { + return false, nil, fmt.Errorf("build stdlib stub %s: %w", filename, err) + } + ensureOverlay() + out[filename] = stub + changed = true + } + } + + for name, src := range patchSrcs { + target := filepath.Join(srcDir, "z_llgo_patch_"+name) + ensureOverlay() + out[target] = src + changed = true + } + return changed, out, nil +} + +func packageStubSource(src []byte) ([]byte, error) { + lines := strings.SplitAfter(string(src), "\n") + var buf strings.Builder + for _, line := range lines { + buf.WriteString(line) + if strings.HasPrefix(strings.TrimSpace(line), "package ") { + return []byte(buf.String()), nil + } + } + return nil, fmt.Errorf("package clause not found") +} diff --git a/internal/build/source_patch_test.go b/internal/build/source_patch_test.go new file mode 100644 index 0000000000..58ae90b196 --- /dev/null +++ b/internal/build/source_patch_test.go @@ -0,0 +1,40 @@ +package build + +import ( + "path/filepath" + "runtime" + "strings" + "testing" + + "github.com/goplus/llgo/internal/env" +) + +func TestBuildSourcePatchOverlayForIter(t *testing.T) { + overlay, err := buildSourcePatchOverlayForGOROOT(nil, env.LLGoRuntimeDir(), runtime.GOROOT()) + if err != nil { + t.Fatal(err) + } + + iterDir := filepath.Join(runtime.GOROOT(), "src", "iter") + patchFile := filepath.Join(iterDir, "z_llgo_patch_iter.go") + patchSrc, ok := overlay[patchFile] + if !ok { + t.Fatalf("missing source patch file %s", patchFile) + } + if !strings.Contains(string(patchSrc), "func Pull[V any]") { + t.Fatalf("source patch file %s does not contain iter replacement", patchFile) + } + + stdFile := filepath.Join(iterDir, "iter.go") + stdSrc, ok := overlay[stdFile] + if !ok { + t.Fatalf("missing stub overlay for %s", stdFile) + } + got := string(stdSrc) + if !strings.Contains(got, "package iter") { + t.Fatalf("stub overlay for %s lost package clause", stdFile) + } + if strings.Contains(got, "func Pull") { + t.Fatalf("stub overlay for %s still contains original declarations", stdFile) + } +} diff --git a/runtime/build.go b/runtime/build.go index c2c6709c97..17e4b606f6 100644 --- a/runtime/build.go +++ b/runtime/build.go @@ -1,5 +1,7 @@ package runtime +import "sort" + type altPkgMode uint8 const ( @@ -23,15 +25,32 @@ func HasAdditiveAltPkg(path string) bool { return altPkgs[path] == altPkgAdditive } +func HasSourcePatchPkg(path string) (b bool) { + _, b = sourcePatchPkgs[path] + return +} + +func SourcePatchPkgPaths() []string { + paths := make([]string, 0, len(sourcePatchPkgs)) + for path := range sourcePatchPkgs { + paths = append(paths, path) + } + sort.Strings(paths) + return paths +} + var altPkgs = map[string]altPkgMode{ "internal/abi": altPkgReplace, "internal/reflectlite": altPkgReplace, "internal/runtime/maps": altPkgReplace, "internal/runtime/sys": altPkgAdditive, - "iter": altPkgReplace, "reflect": altPkgReplace, "runtime": altPkgReplace, "unique": altPkgReplace, "syscall/js": altPkgReplace, "sync/atomic": altPkgReplace, } + +var sourcePatchPkgs = map[string]struct{}{ + "iter": {}, +} diff --git a/runtime/internal/lib/iter/iter.go b/runtime/internal/lib/iter/iter.go index 58b556327e..f36443a993 100644 --- a/runtime/internal/lib/iter/iter.go +++ b/runtime/internal/lib/iter/iter.go @@ -1,3 +1,4 @@ +// llgo:skipall package iter // Seq is an iterator over sequences of individual values. From ce3401ee692236702c2ae0a8da0c4d56ddfdc602 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Sat, 28 Mar 2026 10:11:46 +0800 Subject: [PATCH 02/44] test: lock iter source patch routing --- internal/build/source_patch_test.go | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/internal/build/source_patch_test.go b/internal/build/source_patch_test.go index 58ae90b196..acf6eb7d47 100644 --- a/internal/build/source_patch_test.go +++ b/internal/build/source_patch_test.go @@ -7,6 +7,7 @@ import ( "testing" "github.com/goplus/llgo/internal/env" + llruntime "github.com/goplus/llgo/runtime" ) func TestBuildSourcePatchOverlayForIter(t *testing.T) { @@ -38,3 +39,12 @@ func TestBuildSourcePatchOverlayForIter(t *testing.T) { t.Fatalf("stub overlay for %s still contains original declarations", stdFile) } } + +func TestIterUsesSourcePatchInsteadOfAltPkg(t *testing.T) { + if !llruntime.HasSourcePatchPkg("iter") { + t.Fatal("iter should be registered as a source patch package") + } + if llruntime.HasAltPkg("iter") { + t.Fatal("iter should not remain an alt package") + } +} From 02ec9ee27441a920d386bcb0d3d4ffe20471ff3d Mon Sep 17 00:00:00 2001 From: Li Jie Date: Sat, 28 Mar 2026 10:17:58 +0800 Subject: [PATCH 03/44] build: support skip directives in source patches --- internal/build/source_patch.go | 265 +++++++++++++++++++++++++++- internal/build/source_patch_test.go | 121 +++++++++++++ 2 files changed, 385 insertions(+), 1 deletion(-) diff --git a/internal/build/source_patch.go b/internal/build/source_patch.go index 560f7be649..bfaf40d5fe 100644 --- a/internal/build/source_patch.go +++ b/internal/build/source_patch.go @@ -3,6 +3,10 @@ package build import ( "bytes" "fmt" + "go/ast" + "go/format" + "go/parser" + "go/token" "os" "path/filepath" "runtime" @@ -10,6 +14,7 @@ import ( "strings" llruntime "github.com/goplus/llgo/runtime" + "golang.org/x/tools/go/ast/astutil" ) func cloneOverlay(src map[string][]byte) map[string][]byte { @@ -66,6 +71,7 @@ func applySourcePatchForPkg(base, current map[string][]byte, runtimeDir, goroot, changed bool patchSrcs = make(map[string][]byte) skipAll bool + skips = make(map[string]struct{}) ) readOverlay := func(filename string) ([]byte, error) { if out != nil { @@ -93,9 +99,16 @@ func applySourcePatchForPkg(base, current map[string][]byte, runtimeDir, goroot, return false, nil, fmt.Errorf("read source patch file %s: %w", filename, err) } patchSrcs[name] = slices.Clone(src) - if bytes.Contains(src, []byte("llgo:skipall")) { + directives, err := collectSourcePatchDirectives(src) + if err != nil { + return false, nil, fmt.Errorf("parse source patch directives %s: %w", filename, err) + } + if directives.skipAll { skipAll = true } + for name := range directives.skips { + skips[name] = struct{}{} + } } if len(patchSrcs) == 0 { return false, current, nil @@ -132,6 +145,31 @@ func applySourcePatchForPkg(base, current map[string][]byte, runtimeDir, goroot, out[filename] = stub changed = true } + } else if len(skips) != 0 { + for _, entry := range srcEntries { + if entry.IsDir() { + continue + } + name := entry.Name() + if !strings.HasSuffix(name, ".go") || strings.HasSuffix(name, "_test.go") { + continue + } + filename := filepath.Join(srcDir, name) + src, err := readOverlay(filename) + if err != nil { + return false, nil, fmt.Errorf("read stdlib source file %s: %w", filename, err) + } + filtered, changedFile, err := filterSourcePatchFile(src, skips) + if err != nil { + return false, nil, fmt.Errorf("filter stdlib source file %s: %w", filename, err) + } + if !changedFile { + continue + } + ensureOverlay() + out[filename] = filtered + changed = true + } } for name, src := range patchSrcs { @@ -154,3 +192,228 @@ func packageStubSource(src []byte) ([]byte, error) { } return nil, fmt.Errorf("package clause not found") } + +type sourcePatchDirectives struct { + skipAll bool + skips map[string]struct{} +} + +func collectSourcePatchDirectives(src []byte) (sourcePatchDirectives, error) { + fset := token.NewFileSet() + file, err := parser.ParseFile(fset, "", src, parser.ParseComments) + if err != nil { + return sourcePatchDirectives{}, err + } + d := sourcePatchDirectives{skips: make(map[string]struct{})} + for _, group := range file.Comments { + for _, comment := range group.List { + line := strings.TrimSpace(comment.Text) + skipAll, names, ok := parseSourcePatchDirective(line) + if !ok { + continue + } + if skipAll { + d.skipAll = true + } + for _, name := range names { + d.skips[name] = struct{}{} + } + } + } + for _, decl := range file.Decls { + for _, name := range declPatchKeys(decl) { + d.skips[name] = struct{}{} + } + } + return d, nil +} + +func parseSourcePatchDirective(line string) (skipAll bool, names []string, ok bool) { + const ( + llgo1 = "//llgo:" + llgo2 = "// llgo:" + go1 = "//go:" + ) + if strings.HasPrefix(line, go1) { + return false, nil, false + } + var tail string + switch { + case strings.HasPrefix(line, llgo1): + tail = line[len(llgo1):] + case strings.HasPrefix(line, llgo2): + tail = line[len(llgo2):] + default: + return false, nil, false + } + switch { + case tail == "skipall": + return true, nil, true + case strings.HasPrefix(tail, "skip "): + return false, strings.Fields(tail[len("skip "):]), true + default: + return false, nil, false + } +} + +func filterSourcePatchFile(src []byte, skips map[string]struct{}) ([]byte, bool, error) { + fset := token.NewFileSet() + file, err := parser.ParseFile(fset, "", src, parser.ParseComments) + if err != nil { + return nil, false, err + } + changed := false + decls := file.Decls[:0] + for _, decl := range file.Decls { + filteredDecl, removed, err := filterSourcePatchDecl(decl, skips) + if err != nil { + return nil, false, err + } + if removed { + changed = true + } + if filteredDecl != nil { + decls = append(decls, filteredDecl) + } + } + if !changed { + return src, false, nil + } + file.Decls = decls + for _, imp := range slices.Clone(file.Imports) { + if imp.Name != nil && imp.Name.Name == "_" { + continue + } + if astutil.UsesImport(file, strings.Trim(imp.Path.Value, `"`)) { + continue + } + astutil.DeleteImport(fset, file, strings.Trim(imp.Path.Value, `"`)) + } + var buf bytes.Buffer + if err := format.Node(&buf, fset, file); err != nil { + return nil, false, err + } + return buf.Bytes(), true, nil +} + +func filterSourcePatchDecl(decl ast.Decl, skips map[string]struct{}) (ast.Decl, bool, error) { + switch decl := decl.(type) { + case *ast.FuncDecl: + if _, ok := skips[declPatchKeyFunc(decl)]; ok { + return nil, true, nil + } + return decl, false, nil + case *ast.GenDecl: + switch decl.Tok { + case token.TYPE, token.VAR, token.CONST: + default: + return decl, false, nil + } + specs := decl.Specs[:0] + removedAny := false + for _, spec := range decl.Specs { + filteredSpec, removed := filterSourcePatchSpec(spec, skips) + if removed { + removedAny = true + } + if filteredSpec != nil { + specs = append(specs, filteredSpec) + } + } + if len(specs) == 0 { + return nil, removedAny, nil + } + if !removedAny { + return decl, false, nil + } + out := *decl + out.Specs = specs + return &out, true, nil + default: + return decl, false, nil + } +} + +func filterSourcePatchSpec(spec ast.Spec, skips map[string]struct{}) (ast.Spec, bool) { + switch spec := spec.(type) { + case *ast.TypeSpec: + if _, ok := skips[spec.Name.Name]; ok { + return nil, true + } + return spec, false + case *ast.ValueSpec: + keep := make([]*ast.Ident, 0, len(spec.Names)) + removed := false + for _, name := range spec.Names { + if _, ok := skips[name.Name]; ok { + removed = true + continue + } + keep = append(keep, name) + } + if !removed { + return spec, false + } + if len(keep) == 0 { + return nil, true + } + if len(keep) != len(spec.Names) { + // Keep the transformation simple and deterministic. Mixed multi-name specs + // can be split later if we need them in real patches. + return nil, true + } + out := *spec + out.Names = keep + return &out, true + default: + return spec, false + } +} + +func declPatchKeys(decl ast.Decl) []string { + switch decl := decl.(type) { + case *ast.FuncDecl: + return []string{declPatchKeyFunc(decl)} + case *ast.GenDecl: + var out []string + for _, spec := range decl.Specs { + switch spec := spec.(type) { + case *ast.TypeSpec: + out = append(out, spec.Name.Name) + case *ast.ValueSpec: + for _, name := range spec.Names { + out = append(out, name.Name) + } + } + } + return out + default: + return nil + } +} + +func declPatchKeyFunc(decl *ast.FuncDecl) string { + if decl.Recv == nil || len(decl.Recv.List) == 0 { + return decl.Name.Name + } + return recvPatchKey(decl.Recv.List[0].Type) + "." + decl.Name.Name +} + +func recvPatchKey(expr ast.Expr) string { + switch expr := expr.(type) { + case *ast.Ident: + return expr.Name + case *ast.ParenExpr: + return recvPatchKey(expr.X) + case *ast.StarExpr: + return "(*" + recvPatchKey(expr.X) + ")" + case *ast.IndexExpr: + return recvPatchKey(expr.X) + case *ast.IndexListExpr: + return recvPatchKey(expr.X) + case *ast.SelectorExpr: + return expr.Sel.Name + default: + return "" + } +} diff --git a/internal/build/source_patch_test.go b/internal/build/source_patch_test.go index acf6eb7d47..5bf2eb55df 100644 --- a/internal/build/source_patch_test.go +++ b/internal/build/source_patch_test.go @@ -1,6 +1,7 @@ package build import ( + "os" "path/filepath" "runtime" "strings" @@ -48,3 +49,123 @@ func TestIterUsesSourcePatchInsteadOfAltPkg(t *testing.T) { t.Fatal("iter should not remain an alt package") } } + +func TestApplySourcePatchForPkg_Directives(t *testing.T) { + t.Run("skip-and-override", func(t *testing.T) { + goroot := t.TempDir() + runtimeDir := t.TempDir() + pkgPath := "demo" + srcDir := filepath.Join(goroot, "src", pkgPath) + patchDir := filepath.Join(runtimeDir, "internal", "lib", pkgPath) + mustWriteFile(t, filepath.Join(srcDir, "demo.go"), `package demo + +import "fmt" + +const Keep = "keep" + +var Drop = fmt.Sprint("drop") + +type T struct{} + +func Old() string { return fmt.Sprint("old") } +func KeepFn() string { return Keep } +func (T) M() string { return fmt.Sprint("old method") } +`) + mustWriteFile(t, filepath.Join(patchDir, "patch.go"), `package demo + +//llgo:skip Drop + +import "strings" + +var Added = strings.ToUpper("added") + +func Old() string { return "new" } +func (T) M() string { return "new method" } +`) + + changed, overlay, err := applySourcePatchForPkg(nil, nil, runtimeDir, goroot, pkgPath) + if err != nil { + t.Fatal(err) + } + if !changed { + t.Fatal("expected source patch overlay to change package") + } + + stdFile := filepath.Join(srcDir, "demo.go") + got := string(overlay[stdFile]) + if strings.Contains(got, "fmt") { + t.Fatalf("expected unused fmt import to be removed, got:\n%s", got) + } + if strings.Contains(got, "var Drop") { + t.Fatalf("expected explicit skip to remove Drop, got:\n%s", got) + } + if strings.Contains(got, "func Old") { + t.Fatalf("expected patch declaration to override Old, got:\n%s", got) + } + if strings.Contains(got, "func (T) M") { + t.Fatalf("expected patch declaration to override T.M, got:\n%s", got) + } + for _, want := range []string{"const Keep", "type T struct{}", "func KeepFn"} { + if !strings.Contains(got, want) { + t.Fatalf("expected original declaration %q to remain, got:\n%s", want, got) + } + } + + patchFile := filepath.Join(srcDir, "z_llgo_patch_patch.go") + patchSrc := string(overlay[patchFile]) + for _, want := range []string{"var Added", "func Old", "func (T) M"} { + if !strings.Contains(patchSrc, want) { + t.Fatalf("expected injected patch declaration %q, got:\n%s", want, patchSrc) + } + } + }) + + t.Run("skipall", func(t *testing.T) { + goroot := t.TempDir() + runtimeDir := t.TempDir() + pkgPath := "demo" + srcDir := filepath.Join(goroot, "src", pkgPath) + patchDir := filepath.Join(runtimeDir, "internal", "lib", pkgPath) + mustWriteFile(t, filepath.Join(srcDir, "demo.go"), `package demo + +func Old() string { return "old" } +`) + mustWriteFile(t, filepath.Join(patchDir, "patch.go"), `// llgo:skipall +package demo + +const Only = "patched" +`) + + changed, overlay, err := applySourcePatchForPkg(nil, nil, runtimeDir, goroot, pkgPath) + if err != nil { + t.Fatal(err) + } + if !changed { + t.Fatal("expected source patch overlay to change package") + } + + stdFile := filepath.Join(srcDir, "demo.go") + got := string(overlay[stdFile]) + if strings.Contains(got, "func Old") { + t.Fatalf("expected skipall to stub original file, got:\n%s", got) + } + if !strings.Contains(got, "package demo") { + t.Fatalf("expected package clause to remain, got:\n%s", got) + } + + patchFile := filepath.Join(srcDir, "z_llgo_patch_patch.go") + if patchSrc := string(overlay[patchFile]); !strings.Contains(patchSrc, `const Only = "patched"`) { + t.Fatalf("expected skipall patch file to be injected, got:\n%s", patchSrc) + } + }) +} + +func mustWriteFile(t *testing.T, filename, content string) { + t.Helper() + if err := os.MkdirAll(filepath.Dir(filename), 0755); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(filename, []byte(content), 0644); err != nil { + t.Fatal(err) + } +} From 83c51d8a1c143b627a26834510fbfa0f33d4e291 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Sat, 28 Mar 2026 10:41:46 +0800 Subject: [PATCH 04/44] build: extend source patch directives --- internal/build/source_patch.go | 120 ++++++++++++++++------ internal/build/source_patch_test.go | 85 +++++++++++++++ runtime/build.go | 6 +- runtime/internal/lib/sync/atomic/value.go | 2 + 4 files changed, 181 insertions(+), 32 deletions(-) diff --git a/internal/build/source_patch.go b/internal/build/source_patch.go index bfaf40d5fe..38e92df01b 100644 --- a/internal/build/source_patch.go +++ b/internal/build/source_patch.go @@ -98,11 +98,14 @@ func applySourcePatchForPkg(base, current map[string][]byte, runtimeDir, goroot, if err != nil { return false, nil, fmt.Errorf("read source patch file %s: %w", filename, err) } - patchSrcs[name] = slices.Clone(src) directives, err := collectSourcePatchDirectives(src) if err != nil { return false, nil, fmt.Errorf("parse source patch directives %s: %w", filename, err) } + if !directives.active { + continue + } + patchSrcs[name] = slices.Clone(src) if directives.skipAll { skipAll = true } @@ -194,6 +197,7 @@ func packageStubSource(src []byte) ([]byte, error) { } type sourcePatchDirectives struct { + active bool skipAll bool skips map[string]struct{} } @@ -208,10 +212,11 @@ func collectSourcePatchDirectives(src []byte) (sourcePatchDirectives, error) { for _, group := range file.Comments { for _, comment := range group.List { line := strings.TrimSpace(comment.Text) - skipAll, names, ok := parseSourcePatchDirective(line) + active, skipAll, names, ok := parseSourcePatchDirective(line) if !ok { continue } + d.active = d.active || active if skipAll { d.skipAll = true } @@ -220,22 +225,24 @@ func collectSourcePatchDirectives(src []byte) (sourcePatchDirectives, error) { } } } - for _, decl := range file.Decls { - for _, name := range declPatchKeys(decl) { - d.skips[name] = struct{}{} + if d.active { + for _, decl := range file.Decls { + for _, name := range declPatchKeys(decl) { + d.skips[name] = struct{}{} + } } } return d, nil } -func parseSourcePatchDirective(line string) (skipAll bool, names []string, ok bool) { +func parseSourcePatchDirective(line string) (active, skipAll bool, names []string, ok bool) { const ( llgo1 = "//llgo:" llgo2 = "// llgo:" go1 = "//go:" ) if strings.HasPrefix(line, go1) { - return false, nil, false + return false, false, nil, false } var tail string switch { @@ -244,15 +251,17 @@ func parseSourcePatchDirective(line string) (skipAll bool, names []string, ok bo case strings.HasPrefix(line, llgo2): tail = line[len(llgo2):] default: - return false, nil, false + return false, false, nil, false } switch { + case tail == "patch": + return true, false, nil, true case tail == "skipall": - return true, nil, true + return true, true, nil, true case strings.HasPrefix(tail, "skip "): - return false, strings.Fields(tail[len("skip "):]), true + return true, false, strings.Fields(tail[len("skip "):]), true default: - return false, nil, false + return false, false, nil, false } } @@ -263,15 +272,19 @@ func filterSourcePatchFile(src []byte, skips map[string]struct{}) ([]byte, bool, return nil, false, err } changed := false + removedComments := make(map[*ast.CommentGroup]struct{}) decls := file.Decls[:0] for _, decl := range file.Decls { - filteredDecl, removed, err := filterSourcePatchDecl(decl, skips) + filteredDecl, removed, rmComments, err := filterSourcePatchDecl(decl, skips) if err != nil { return nil, false, err } if removed { changed = true } + for _, group := range rmComments { + removedComments[group] = struct{}{} + } if filteredDecl != nil { decls = append(decls, filteredDecl) } @@ -280,6 +293,16 @@ func filterSourcePatchFile(src []byte, skips map[string]struct{}) ([]byte, bool, return src, false, nil } file.Decls = decls + if len(removedComments) != 0 { + comments := file.Comments[:0] + for _, group := range file.Comments { + if _, drop := removedComments[group]; drop { + continue + } + comments = append(comments, group) + } + file.Comments = comments + } for _, imp := range slices.Clone(file.Imports) { if imp.Name != nil && imp.Name.Name == "_" { continue @@ -296,51 +319,54 @@ func filterSourcePatchFile(src []byte, skips map[string]struct{}) ([]byte, bool, return buf.Bytes(), true, nil } -func filterSourcePatchDecl(decl ast.Decl, skips map[string]struct{}) (ast.Decl, bool, error) { +func filterSourcePatchDecl(decl ast.Decl, skips map[string]struct{}) (ast.Decl, bool, []*ast.CommentGroup, error) { switch decl := decl.(type) { case *ast.FuncDecl: if _, ok := skips[declPatchKeyFunc(decl)]; ok { - return nil, true, nil + return nil, true, collectDeclComments(decl), nil } - return decl, false, nil + return decl, false, nil, nil case *ast.GenDecl: switch decl.Tok { case token.TYPE, token.VAR, token.CONST: default: - return decl, false, nil + return decl, false, nil, nil } specs := decl.Specs[:0] removedAny := false + var removedComments []*ast.CommentGroup for _, spec := range decl.Specs { - filteredSpec, removed := filterSourcePatchSpec(spec, skips) + filteredSpec, removed, comments := filterSourcePatchSpec(spec, skips) if removed { removedAny = true } + removedComments = append(removedComments, comments...) if filteredSpec != nil { specs = append(specs, filteredSpec) } } if len(specs) == 0 { - return nil, removedAny, nil + removedComments = append(removedComments, decl.Doc) + return nil, removedAny, removedComments, nil } if !removedAny { - return decl, false, nil + return decl, false, nil, nil } out := *decl out.Specs = specs - return &out, true, nil + return &out, true, removedComments, nil default: - return decl, false, nil + return decl, false, nil, nil } } -func filterSourcePatchSpec(spec ast.Spec, skips map[string]struct{}) (ast.Spec, bool) { +func filterSourcePatchSpec(spec ast.Spec, skips map[string]struct{}) (ast.Spec, bool, []*ast.CommentGroup) { switch spec := spec.(type) { case *ast.TypeSpec: if _, ok := skips[spec.Name.Name]; ok { - return nil, true + return nil, true, collectSpecComments(spec) } - return spec, false + return spec, false, nil case *ast.ValueSpec: keep := make([]*ast.Ident, 0, len(spec.Names)) removed := false @@ -352,22 +378,58 @@ func filterSourcePatchSpec(spec ast.Spec, skips map[string]struct{}) (ast.Spec, keep = append(keep, name) } if !removed { - return spec, false + return spec, false, nil } if len(keep) == 0 { - return nil, true + return nil, true, collectSpecComments(spec) } if len(keep) != len(spec.Names) { // Keep the transformation simple and deterministic. Mixed multi-name specs // can be split later if we need them in real patches. - return nil, true + return nil, true, collectSpecComments(spec) } out := *spec out.Names = keep - return &out, true + return &out, true, nil default: - return spec, false + return spec, false, nil + } +} + +func collectDeclComments(decl ast.Decl) []*ast.CommentGroup { + switch decl := decl.(type) { + case *ast.FuncDecl: + return compactCommentGroups(decl.Doc) + case *ast.GenDecl: + out := compactCommentGroups(decl.Doc) + for _, spec := range decl.Specs { + out = append(out, collectSpecComments(spec)...) + } + return out + default: + return nil + } +} + +func collectSpecComments(spec ast.Spec) []*ast.CommentGroup { + switch spec := spec.(type) { + case *ast.TypeSpec: + return compactCommentGroups(spec.Doc, spec.Comment) + case *ast.ValueSpec: + return compactCommentGroups(spec.Doc, spec.Comment) + default: + return nil + } +} + +func compactCommentGroups(groups ...*ast.CommentGroup) []*ast.CommentGroup { + var out []*ast.CommentGroup + for _, group := range groups { + if group != nil { + out = append(out, group) + } } + return out } func declPatchKeys(decl ast.Decl) []string { diff --git a/internal/build/source_patch_test.go b/internal/build/source_patch_test.go index 5bf2eb55df..a0857c07c3 100644 --- a/internal/build/source_patch_test.go +++ b/internal/build/source_patch_test.go @@ -50,6 +50,46 @@ func TestIterUsesSourcePatchInsteadOfAltPkg(t *testing.T) { } } +func TestBuildSourcePatchOverlayForSyncAtomic(t *testing.T) { + overlay, err := buildSourcePatchOverlayForGOROOT(nil, env.LLGoRuntimeDir(), runtime.GOROOT()) + if err != nil { + t.Fatal(err) + } + + atomicDir := filepath.Join(runtime.GOROOT(), "src", "sync", "atomic") + stdFile := filepath.Join(atomicDir, "value.go") + stdSrc, ok := overlay[stdFile] + if !ok { + t.Fatalf("missing filtered stdlib file %s", stdFile) + } + got := string(stdSrc) + for _, forbidden := range []string{"func (v *Value) Store", "func (v *Value) Swap", "func (v *Value) CompareAndSwap", "func runtime_procPin()", "func runtime_procUnpin()"} { + if strings.Contains(got, forbidden) { + t.Fatalf("expected source patch filtering to remove %q from %s, got:\n%s", forbidden, stdFile, got) + } + } + + patchFile := filepath.Join(atomicDir, "z_llgo_patch_value.go") + patchSrc, ok := overlay[patchFile] + if !ok { + t.Fatalf("missing source patch file %s", patchFile) + } + for _, want := range []string{"func (v *Value) Store", "func (v *Value) Swap", "func (v *Value) CompareAndSwap"} { + if !strings.Contains(string(patchSrc), want) { + t.Fatalf("expected source patch file %s to contain %q", patchFile, want) + } + } +} + +func TestSyncAtomicUsesSourcePatchInsteadOfAltPkg(t *testing.T) { + if !llruntime.HasSourcePatchPkg("sync/atomic") { + t.Fatal("sync/atomic should be registered as a source patch package") + } + if llruntime.HasAltPkg("sync/atomic") { + t.Fatal("sync/atomic should not remain an alt package") + } +} + func TestApplySourcePatchForPkg_Directives(t *testing.T) { t.Run("skip-and-override", func(t *testing.T) { goroot := t.TempDir() @@ -120,6 +160,51 @@ func (T) M() string { return "new method" } } }) + t.Run("patch-only-override", func(t *testing.T) { + goroot := t.TempDir() + runtimeDir := t.TempDir() + pkgPath := "demo" + srcDir := filepath.Join(goroot, "src", pkgPath) + patchDir := filepath.Join(runtimeDir, "internal", "lib", pkgPath) + mustWriteFile(t, filepath.Join(srcDir, "demo.go"), `package demo + +func Old() string { return "old" } +func Keep() string { return "keep" } +`) + mustWriteFile(t, filepath.Join(patchDir, "patch.go"), `package demo + +//llgo:patch + +func Old() string { return "new" } +func Added() string { return "added" } +`) + + changed, overlay, err := applySourcePatchForPkg(nil, nil, runtimeDir, goroot, pkgPath) + if err != nil { + t.Fatal(err) + } + if !changed { + t.Fatal("expected source patch overlay to change package") + } + + stdFile := filepath.Join(srcDir, "demo.go") + got := string(overlay[stdFile]) + if strings.Contains(got, "func Old") { + t.Fatalf("expected patch declaration to override Old, got:\n%s", got) + } + if !strings.Contains(got, "func Keep") { + t.Fatalf("expected Keep to remain, got:\n%s", got) + } + + patchFile := filepath.Join(srcDir, "z_llgo_patch_patch.go") + patchSrc := string(overlay[patchFile]) + for _, want := range []string{"func Old", "func Added"} { + if !strings.Contains(patchSrc, want) { + t.Fatalf("expected injected patch declaration %q, got:\n%s", want, patchSrc) + } + } + }) + t.Run("skipall", func(t *testing.T) { goroot := t.TempDir() runtimeDir := t.TempDir() diff --git a/runtime/build.go b/runtime/build.go index 17e4b606f6..7363addab3 100644 --- a/runtime/build.go +++ b/runtime/build.go @@ -46,11 +46,11 @@ var altPkgs = map[string]altPkgMode{ "internal/runtime/sys": altPkgAdditive, "reflect": altPkgReplace, "runtime": altPkgReplace, - "unique": altPkgReplace, "syscall/js": altPkgReplace, - "sync/atomic": altPkgReplace, + "unique": altPkgReplace, } var sourcePatchPkgs = map[string]struct{}{ - "iter": {}, + "iter": {}, + "sync/atomic": {}, } diff --git a/runtime/internal/lib/sync/atomic/value.go b/runtime/internal/lib/sync/atomic/value.go index 498b40b4e3..61ba14b550 100644 --- a/runtime/internal/lib/sync/atomic/value.go +++ b/runtime/internal/lib/sync/atomic/value.go @@ -2,6 +2,8 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +// llgo:skip runtime_procPin runtime_procUnpin + package atomic import ( From 21dad23d6febccf34e89fb4f28a17d9f8637652b Mon Sep 17 00:00:00 2001 From: Li Jie Date: Sat, 28 Mar 2026 10:47:35 +0800 Subject: [PATCH 05/44] build: default source patches to active --- internal/build/source_patch.go | 18 +++++++++--------- internal/build/source_patch_test.go | 4 +--- runtime/internal/lib/sync/atomic/atomic.go | 2 ++ runtime/internal/lib/sync/atomic/type.go | 2 ++ 4 files changed, 14 insertions(+), 12 deletions(-) diff --git a/internal/build/source_patch.go b/internal/build/source_patch.go index 38e92df01b..c32fba3d2f 100644 --- a/internal/build/source_patch.go +++ b/internal/build/source_patch.go @@ -102,7 +102,7 @@ func applySourcePatchForPkg(base, current map[string][]byte, runtimeDir, goroot, if err != nil { return false, nil, fmt.Errorf("parse source patch directives %s: %w", filename, err) } - if !directives.active { + if directives.noPatch { continue } patchSrcs[name] = slices.Clone(src) @@ -197,7 +197,7 @@ func packageStubSource(src []byte) ([]byte, error) { } type sourcePatchDirectives struct { - active bool + noPatch bool skipAll bool skips map[string]struct{} } @@ -212,11 +212,11 @@ func collectSourcePatchDirectives(src []byte) (sourcePatchDirectives, error) { for _, group := range file.Comments { for _, comment := range group.List { line := strings.TrimSpace(comment.Text) - active, skipAll, names, ok := parseSourcePatchDirective(line) + noPatch, skipAll, names, ok := parseSourcePatchDirective(line) if !ok { continue } - d.active = d.active || active + d.noPatch = d.noPatch || noPatch if skipAll { d.skipAll = true } @@ -225,7 +225,7 @@ func collectSourcePatchDirectives(src []byte) (sourcePatchDirectives, error) { } } } - if d.active { + if !d.noPatch { for _, decl := range file.Decls { for _, name := range declPatchKeys(decl) { d.skips[name] = struct{}{} @@ -235,7 +235,7 @@ func collectSourcePatchDirectives(src []byte) (sourcePatchDirectives, error) { return d, nil } -func parseSourcePatchDirective(line string) (active, skipAll bool, names []string, ok bool) { +func parseSourcePatchDirective(line string) (noPatch, skipAll bool, names []string, ok bool) { const ( llgo1 = "//llgo:" llgo2 = "// llgo:" @@ -254,12 +254,12 @@ func parseSourcePatchDirective(line string) (active, skipAll bool, names []strin return false, false, nil, false } switch { - case tail == "patch": + case tail == "nopatch": return true, false, nil, true case tail == "skipall": - return true, true, nil, true + return false, true, nil, true case strings.HasPrefix(tail, "skip "): - return true, false, strings.Fields(tail[len("skip "):]), true + return false, false, strings.Fields(tail[len("skip "):]), true default: return false, false, nil, false } diff --git a/internal/build/source_patch_test.go b/internal/build/source_patch_test.go index a0857c07c3..fd4b7f9767 100644 --- a/internal/build/source_patch_test.go +++ b/internal/build/source_patch_test.go @@ -160,7 +160,7 @@ func (T) M() string { return "new method" } } }) - t.Run("patch-only-override", func(t *testing.T) { + t.Run("default-override", func(t *testing.T) { goroot := t.TempDir() runtimeDir := t.TempDir() pkgPath := "demo" @@ -173,8 +173,6 @@ func Keep() string { return "keep" } `) mustWriteFile(t, filepath.Join(patchDir, "patch.go"), `package demo -//llgo:patch - func Old() string { return "new" } func Added() string { return "added" } `) diff --git a/runtime/internal/lib/sync/atomic/atomic.go b/runtime/internal/lib/sync/atomic/atomic.go index 358b51935a..4ca3fc2f10 100644 --- a/runtime/internal/lib/sync/atomic/atomic.go +++ b/runtime/internal/lib/sync/atomic/atomic.go @@ -14,6 +14,8 @@ * limitations under the License. */ +// llgo:nopatch + package atomic import ( diff --git a/runtime/internal/lib/sync/atomic/type.go b/runtime/internal/lib/sync/atomic/type.go index 117de37ec1..19ae8cc785 100644 --- a/runtime/internal/lib/sync/atomic/type.go +++ b/runtime/internal/lib/sync/atomic/type.go @@ -1,3 +1,5 @@ +// llgo:nopatch + package atomic // An Int64 is an atomic int64. The zero value is zero. From 239b023513304a0c8b9d6215b90a2a964655062d Mon Sep 17 00:00:00 2001 From: Li Jie Date: Sat, 28 Mar 2026 11:02:34 +0800 Subject: [PATCH 06/44] build: migrate unique to source patch --- internal/build/source_patch_test.go | 9 + runtime/abi/helpers.go | 54 ++++++ runtime/build.go | 2 +- runtime/internal/lib/unique/clone.go | 2 + runtime/internal/lib/unique/handle.go | 231 ++++++++++++++++++++++++++ runtime/internal/lib/unique/unique.go | 6 - 6 files changed, 297 insertions(+), 7 deletions(-) create mode 100644 runtime/abi/helpers.go create mode 100644 runtime/internal/lib/unique/handle.go delete mode 100644 runtime/internal/lib/unique/unique.go diff --git a/internal/build/source_patch_test.go b/internal/build/source_patch_test.go index fd4b7f9767..182770b167 100644 --- a/internal/build/source_patch_test.go +++ b/internal/build/source_patch_test.go @@ -90,6 +90,15 @@ func TestSyncAtomicUsesSourcePatchInsteadOfAltPkg(t *testing.T) { } } +func TestUniqueUsesSourcePatchInsteadOfAltPkg(t *testing.T) { + if !llruntime.HasSourcePatchPkg("unique") { + t.Fatal("unique should be registered as a source patch package") + } + if llruntime.HasAltPkg("unique") { + t.Fatal("unique should not remain an alt package") + } +} + func TestApplySourcePatchForPkg_Directives(t *testing.T) { t.Run("skip-and-override", func(t *testing.T) { goroot := t.TempDir() diff --git a/runtime/abi/helpers.go b/runtime/abi/helpers.go new file mode 100644 index 0000000000..85fb1a367b --- /dev/null +++ b/runtime/abi/helpers.go @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2024 The XGo Authors (xgo.dev). All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package abi + +import "unsafe" + +func NoEscape(p unsafe.Pointer) unsafe.Pointer { + x := uintptr(p) + return unsafe.Pointer(x ^ 0) +} + +type EmptyInterface struct { + Type *Type + Data unsafe.Pointer +} + +// TypeOf returns the runtime Type of some value. +func TypeOf(a any) *Type { + eface := *(*EmptyInterface)(unsafe.Pointer(&a)) + return (*Type)(NoEscape(unsafe.Pointer(eface.Type))) +} + +// TypeFor returns the runtime Type for a type parameter. +func TypeFor[T any]() *Type { + var v T + if t := TypeOf(v); t != nil { + return t + } + return TypeOf((*T)(nil)).Elem() +} + +// EscapeNonString is modeled by the compiler. +func EscapeNonString[T any](v T) { +} + +// EscapeToResultNonString models a data-flow edge to the result. +func EscapeToResultNonString[T any](v T) T { + EscapeNonString(v) + return *(*T)(NoEscape(unsafe.Pointer(&v))) +} diff --git a/runtime/build.go b/runtime/build.go index 7363addab3..1689505123 100644 --- a/runtime/build.go +++ b/runtime/build.go @@ -47,10 +47,10 @@ var altPkgs = map[string]altPkgMode{ "reflect": altPkgReplace, "runtime": altPkgReplace, "syscall/js": altPkgReplace, - "unique": altPkgReplace, } var sourcePatchPkgs = map[string]struct{}{ "iter": {}, "sync/atomic": {}, + "unique": {}, } diff --git a/runtime/internal/lib/unique/clone.go b/runtime/internal/lib/unique/clone.go index 4211c8dd12..626790dd95 100644 --- a/runtime/internal/lib/unique/clone.go +++ b/runtime/internal/lib/unique/clone.go @@ -2,6 +2,8 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +// llgo:skipall + package unique import ( diff --git a/runtime/internal/lib/unique/handle.go b/runtime/internal/lib/unique/handle.go new file mode 100644 index 0000000000..d7ddabe4c1 --- /dev/null +++ b/runtime/internal/lib/unique/handle.go @@ -0,0 +1,231 @@ +// Copyright 2024 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// llgo:skipall + +package unique + +import ( + "runtime" + "sync" + "unsafe" + "weak" + + "github.com/goplus/llgo/runtime/abi" +) + +var zero uintptr + +// Handle is a globally unique identity for some value of type T. +// +// Two handles compare equal exactly if the two values used to create the handles +// would have also compared equal. The comparison of two handles is trivial and +// typically much more efficient than comparing the values used to create them. +type Handle[T comparable] struct { + value *T +} + +// Value returns a shallow copy of the T value that produced the Handle. +// Value is safe for concurrent use by multiple goroutines. +func (h Handle[T]) Value() T { + return *h.value +} + +// Make returns a globally unique handle for a value of type T. Handles +// are equal if and only if the values used to produce them are equal. +// Make is safe for concurrent use by multiple goroutines. +func Make[T comparable](value T) Handle[T] { + typ := abi.TypeFor[T]() + if typ.Size() == 0 { + return Handle[T]{(*T)(unsafe.Pointer(&zero))} + } + ma, ok := loadUniqueMap(typ) + if !ok { + ensureSetupMake() + ma = addUniqueMap[T](typ) + } + m := ma.(*uniqueMap[T]) + + var ( + toInsert *T + toInsertWeak weak.Pointer[T] + ) + newValue := func() (T, weak.Pointer[T]) { + if toInsert == nil { + toInsert = new(T) + *toInsert = clone(value, &m.cloneSeq) + toInsertWeak = weak.Make(toInsert) + } + return *toInsert, toInsertWeak + } + var ptr *T + for { + wp, ok := m.Load(value) + if !ok { + k, v := newValue() + wp, _ = m.LoadOrStore(k, v) + } + ptr = wp.Value() + if ptr != nil { + break + } + m.CompareAndDelete(value, wp) + } + runtime.KeepAlive(toInsert) + return Handle[T]{ptr} +} + +var ( + uniqueMapsMu sync.Mutex + uniqueMaps map[*abi.Type]any + + cleanupMu sync.Mutex + cleanupFuncsMu sync.Mutex + cleanupFuncs []func() + cleanupNotify []func() +) + +type uniqueMap[T comparable] struct { + mu sync.Mutex + m map[T]weak.Pointer[T] + cloneSeq +} + +type uniqueEntry[T comparable] struct { + key T + value weak.Pointer[T] +} + +func addUniqueMap[T comparable](typ *abi.Type) *uniqueMap[T] { + m := &uniqueMap[T]{ + m: make(map[T]weak.Pointer[T]), + cloneSeq: makeCloneSeq(typ), + } + a, loaded := loadOrStoreUniqueMap(typ, m) + if !loaded { + cleanupFuncsMu.Lock() + cleanupFuncs = append(cleanupFuncs, func() { + m.All()(func(key T, wp weak.Pointer[T]) bool { + if wp.Value() == nil { + m.CompareAndDelete(key, wp) + } + return true + }) + }) + cleanupFuncsMu.Unlock() + } + return a.(*uniqueMap[T]) +} + +var ( + setupMakeMu sync.Mutex + setupMade bool +) + +func ensureSetupMake() { + setupMakeMu.Lock() + if !setupMade { + registerCleanup() + setupMade = true + } + setupMakeMu.Unlock() +} + +func loadUniqueMap(typ *abi.Type) (any, bool) { + uniqueMapsMu.Lock() + if uniqueMaps == nil { + uniqueMapsMu.Unlock() + return nil, false + } + v, ok := uniqueMaps[typ] + uniqueMapsMu.Unlock() + return v, ok +} + +func loadOrStoreUniqueMap(typ *abi.Type, value any) (any, bool) { + uniqueMapsMu.Lock() + if uniqueMaps == nil { + uniqueMaps = make(map[*abi.Type]any) + } + if existing, ok := uniqueMaps[typ]; ok { + uniqueMapsMu.Unlock() + return existing, true + } + uniqueMaps[typ] = value + uniqueMapsMu.Unlock() + return value, false +} + +func (m *uniqueMap[T]) Load(key T) (weak.Pointer[T], bool) { + m.mu.Lock() + v, ok := m.m[key] + m.mu.Unlock() + if !ok { + var zero weak.Pointer[T] + return zero, false + } + return v, true +} + +func (m *uniqueMap[T]) LoadOrStore(key T, value weak.Pointer[T]) (weak.Pointer[T], bool) { + m.mu.Lock() + if existing, ok := m.m[key]; ok { + m.mu.Unlock() + return existing, true + } + m.m[key] = value + m.mu.Unlock() + return value, false +} + +func (m *uniqueMap[T]) CompareAndDelete(key T, old weak.Pointer[T]) bool { + m.mu.Lock() + defer m.mu.Unlock() + v, ok := m.m[key] + if !ok || v != old { + return false + } + delete(m.m, key) + return true +} + +func (m *uniqueMap[T]) All() func(func(T, weak.Pointer[T]) bool) { + return func(yield func(T, weak.Pointer[T]) bool) { + m.mu.Lock() + items := make([]uniqueEntry[T], 0, len(m.m)) + for k, v := range m.m { + items = append(items, uniqueEntry[T]{key: k, value: v}) + } + m.mu.Unlock() + for _, item := range items { + if !yield(item.key, item.value) { + return + } + } + } +} + +func registerCleanup() { + runtime_registerUniqueMapCleanup(func() { + cleanupMu.Lock() + + cleanupFuncsMu.Lock() + cf := cleanupFuncs + cleanupFuncsMu.Unlock() + + for _, f := range cf { + f() + } + + for _, f := range cleanupNotify { + f() + } + cleanupNotify = nil + + cleanupMu.Unlock() + }) +} + +//go:linkname runtime_registerUniqueMapCleanup +func runtime_registerUniqueMapCleanup(cleanup func()) diff --git a/runtime/internal/lib/unique/unique.go b/runtime/internal/lib/unique/unique.go deleted file mode 100644 index faaee1b155..0000000000 --- a/runtime/internal/lib/unique/unique.go +++ /dev/null @@ -1,6 +0,0 @@ -package unique - -import _ "unsafe" - -//go:linkname runtime_registerUniqueMapCleanup -func runtime_registerUniqueMapCleanup(cleanup func()) From 3c10b8487af7c682b1477d39d9a8b1dbb9edad81 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Sat, 28 Mar 2026 11:19:46 +0800 Subject: [PATCH 07/44] build: migrate reflectlite to source patch --- internal/build/source_patch.go | 18 ++++++- internal/build/source_patch_test.go | 49 ++++++++++++++++++- runtime/build.go | 8 +-- .../lib/internal/reflectlite/value.go | 3 +- 4 files changed, 70 insertions(+), 8 deletions(-) diff --git a/internal/build/source_patch.go b/internal/build/source_patch.go index c32fba3d2f..d2be0d0bc0 100644 --- a/internal/build/source_patch.go +++ b/internal/build/source_patch.go @@ -105,7 +105,7 @@ func applySourcePatchForPkg(base, current map[string][]byte, runtimeDir, goroot, if directives.noPatch { continue } - patchSrcs[name] = slices.Clone(src) + patchSrcs[name] = stripSourcePatchDirectiveLines(src) if directives.skipAll { skipAll = true } @@ -265,6 +265,22 @@ func parseSourcePatchDirective(line string) (noPatch, skipAll bool, names []stri } } +func stripSourcePatchDirectiveLines(src []byte) []byte { + lines := bytes.SplitAfter(src, []byte{'\n'}) + out := make([][]byte, 0, len(lines)) + for _, line := range lines { + trimmed := strings.TrimSpace(string(line)) + if _, _, _, ok := parseSourcePatchDirective(trimmed); ok { + continue + } + out = append(out, line) + } + if len(out) == len(lines) { + return slices.Clone(src) + } + return bytes.Join(out, nil) +} + func filterSourcePatchFile(src []byte, skips map[string]struct{}) ([]byte, bool, error) { fset := token.NewFileSet() file, err := parser.ParseFile(fset, "", src, parser.ParseComments) diff --git a/internal/build/source_patch_test.go b/internal/build/source_patch_test.go index 182770b167..63f77e02d9 100644 --- a/internal/build/source_patch_test.go +++ b/internal/build/source_patch_test.go @@ -90,6 +90,45 @@ func TestSyncAtomicUsesSourcePatchInsteadOfAltPkg(t *testing.T) { } } +func TestBuildSourcePatchOverlayForReflectlite(t *testing.T) { + overlay, err := buildSourcePatchOverlayForGOROOT(nil, env.LLGoRuntimeDir(), runtime.GOROOT()) + if err != nil { + t.Fatal(err) + } + + pkgDir := filepath.Join(runtime.GOROOT(), "src", "internal", "reflectlite") + stdFile := filepath.Join(pkgDir, "value.go") + stdSrc, ok := overlay[stdFile] + if !ok { + t.Fatalf("missing stub overlay for %s", stdFile) + } + got := string(stdSrc) + if !strings.Contains(got, "package reflectlite") { + t.Fatalf("stub overlay for %s lost package clause", stdFile) + } + if strings.Contains(got, "type Value struct") { + t.Fatalf("stub overlay for %s still contains original declarations", stdFile) + } + + patchFile := filepath.Join(pkgDir, "z_llgo_patch_value.go") + patchSrc, ok := overlay[patchFile] + if !ok { + t.Fatalf("missing source patch file %s", patchFile) + } + if !strings.Contains(string(patchSrc), "type Value struct") { + t.Fatalf("source patch file %s does not contain reflectlite replacement", patchFile) + } +} + +func TestReflectliteUsesSourcePatchInsteadOfAltPkg(t *testing.T) { + if !llruntime.HasSourcePatchPkg("internal/reflectlite") { + t.Fatal("internal/reflectlite should be registered as a source patch package") + } + if llruntime.HasAltPkg("internal/reflectlite") { + t.Fatal("internal/reflectlite should not remain an alt package") + } +} + func TestUniqueUsesSourcePatchInsteadOfAltPkg(t *testing.T) { if !llruntime.HasSourcePatchPkg("unique") { t.Fatal("unique should be registered as a source patch package") @@ -162,6 +201,9 @@ func (T) M() string { return "new method" } patchFile := filepath.Join(srcDir, "z_llgo_patch_patch.go") patchSrc := string(overlay[patchFile]) + if strings.Contains(patchSrc, "llgo:skip") { + t.Fatalf("expected source patch directives to be stripped, got:\n%s", patchSrc) + } for _, want := range []string{"var Added", "func Old", "func (T) M"} { if !strings.Contains(patchSrc, want) { t.Fatalf("expected injected patch declaration %q, got:\n%s", want, patchSrc) @@ -205,6 +247,9 @@ func Added() string { return "added" } patchFile := filepath.Join(srcDir, "z_llgo_patch_patch.go") patchSrc := string(overlay[patchFile]) + if strings.Contains(patchSrc, "llgo:skipall") { + t.Fatalf("expected source patch directives to be stripped, got:\n%s", patchSrc) + } for _, want := range []string{"func Old", "func Added"} { if !strings.Contains(patchSrc, want) { t.Fatalf("expected injected patch declaration %q, got:\n%s", want, patchSrc) @@ -246,7 +291,9 @@ const Only = "patched" } patchFile := filepath.Join(srcDir, "z_llgo_patch_patch.go") - if patchSrc := string(overlay[patchFile]); !strings.Contains(patchSrc, `const Only = "patched"`) { + if patchSrc := string(overlay[patchFile]); strings.Contains(patchSrc, "llgo:skipall") { + t.Fatalf("expected source patch directives to be stripped, got:\n%s", patchSrc) + } else if !strings.Contains(patchSrc, `const Only = "patched"`) { t.Fatalf("expected skipall patch file to be injected, got:\n%s", patchSrc) } }) diff --git a/runtime/build.go b/runtime/build.go index 1689505123..a65147e717 100644 --- a/runtime/build.go +++ b/runtime/build.go @@ -41,7 +41,6 @@ func SourcePatchPkgPaths() []string { var altPkgs = map[string]altPkgMode{ "internal/abi": altPkgReplace, - "internal/reflectlite": altPkgReplace, "internal/runtime/maps": altPkgReplace, "internal/runtime/sys": altPkgAdditive, "reflect": altPkgReplace, @@ -50,7 +49,8 @@ var altPkgs = map[string]altPkgMode{ } var sourcePatchPkgs = map[string]struct{}{ - "iter": {}, - "sync/atomic": {}, - "unique": {}, + "internal/reflectlite": {}, + "iter": {}, + "sync/atomic": {}, + "unique": {}, } diff --git a/runtime/internal/lib/internal/reflectlite/value.go b/runtime/internal/lib/internal/reflectlite/value.go index 5fa0cf5bc3..c8afe504d3 100644 --- a/runtime/internal/lib/internal/reflectlite/value.go +++ b/runtime/internal/lib/internal/reflectlite/value.go @@ -5,11 +5,10 @@ package reflectlite import ( + "internal/goarch" "unsafe" "github.com/goplus/llgo/runtime/abi" - _ "github.com/goplus/llgo/runtime/internal/runtime" - "github.com/goplus/llgo/runtime/internal/runtime/goarch" ) // Value is the reflection interface to a Go value. From 532e0732f9e89a07d5d937c011de9b1d9358fdb7 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Sat, 28 Mar 2026 11:33:54 +0800 Subject: [PATCH 08/44] build: preserve source patch positions --- internal/build/source_patch.go | 217 +++++++++++++++++++++++++-------- 1 file changed, 167 insertions(+), 50 deletions(-) diff --git a/internal/build/source_patch.go b/internal/build/source_patch.go index d2be0d0bc0..32f96170ef 100644 --- a/internal/build/source_patch.go +++ b/internal/build/source_patch.go @@ -4,7 +4,6 @@ import ( "bytes" "fmt" "go/ast" - "go/format" "go/parser" "go/token" "os" @@ -105,7 +104,7 @@ func applySourcePatchForPkg(base, current map[string][]byte, runtimeDir, goroot, if directives.noPatch { continue } - patchSrcs[name] = stripSourcePatchDirectiveLines(src) + patchSrcs[name] = sanitizeSourcePatchDirectiveLines(src) if directives.skipAll { skipAll = true } @@ -265,20 +264,28 @@ func parseSourcePatchDirective(line string) (noPatch, skipAll bool, names []stri } } -func stripSourcePatchDirectiveLines(src []byte) []byte { - lines := bytes.SplitAfter(src, []byte{'\n'}) - out := make([][]byte, 0, len(lines)) +func sanitizeSourcePatchDirectiveLines(src []byte) []byte { + out := slices.Clone(src) + lines := bytes.SplitAfter(out, []byte{'\n'}) + changed := false for _, line := range lines { trimmed := strings.TrimSpace(string(line)) - if _, _, _, ok := parseSourcePatchDirective(trimmed); ok { + if _, _, _, ok := parseSourcePatchDirective(trimmed); !ok { continue } - out = append(out, line) + switch { + case bytes.Contains(line, []byte("//llgo:")): + copy(line, bytes.Replace(line, []byte("//llgo:"), []byte("//llgo_"), 1)) + changed = true + case bytes.Contains(line, []byte("// llgo:")): + copy(line, bytes.Replace(line, []byte("// llgo:"), []byte("// llgo_"), 1)) + changed = true + } } - if len(out) == len(lines) { - return slices.Clone(src) + if !changed { + return out } - return bytes.Join(out, nil) + return out } func filterSourcePatchFile(src []byte, skips map[string]struct{}) ([]byte, bool, error) { @@ -287,20 +294,22 @@ func filterSourcePatchFile(src []byte, skips map[string]struct{}) ([]byte, bool, if err != nil { return nil, false, err } + tokFile := fset.File(file.Pos()) + if tokFile == nil { + return nil, false, fmt.Errorf("missing file positions") + } changed := false - removedComments := make(map[*ast.CommentGroup]struct{}) + var spans []sourcePatchSpan decls := file.Decls[:0] for _, decl := range file.Decls { - filteredDecl, removed, rmComments, err := filterSourcePatchDecl(decl, skips) + filteredDecl, removed, rmSpans, err := filterSourcePatchDecl(tokFile, decl, skips) if err != nil { return nil, false, err } if removed { changed = true } - for _, group := range rmComments { - removedComments[group] = struct{}{} - } + spans = append(spans, rmSpans...) if filteredDecl != nil { decls = append(decls, filteredDecl) } @@ -309,37 +318,23 @@ func filterSourcePatchFile(src []byte, skips map[string]struct{}) ([]byte, bool, return src, false, nil } file.Decls = decls - if len(removedComments) != 0 { - comments := file.Comments[:0] - for _, group := range file.Comments { - if _, drop := removedComments[group]; drop { - continue - } - comments = append(comments, group) - } - file.Comments = comments - } - for _, imp := range slices.Clone(file.Imports) { - if imp.Name != nil && imp.Name.Name == "_" { - continue - } - if astutil.UsesImport(file, strings.Trim(imp.Path.Value, `"`)) { - continue - } - astutil.DeleteImport(fset, file, strings.Trim(imp.Path.Value, `"`)) - } - var buf bytes.Buffer - if err := format.Node(&buf, fset, file); err != nil { - return nil, false, err + spans = append(spans, collectUnusedImportSpans(tokFile, file)...) + if len(spans) == 0 { + return src, false, nil } - return buf.Bytes(), true, nil + return blankSourcePatchSpans(src, spans), true, nil +} + +type sourcePatchSpan struct { + start int + end int } -func filterSourcePatchDecl(decl ast.Decl, skips map[string]struct{}) (ast.Decl, bool, []*ast.CommentGroup, error) { +func filterSourcePatchDecl(tokFile *token.File, decl ast.Decl, skips map[string]struct{}) (ast.Decl, bool, []sourcePatchSpan, error) { switch decl := decl.(type) { case *ast.FuncDecl: if _, ok := skips[declPatchKeyFunc(decl)]; ok { - return nil, true, collectDeclComments(decl), nil + return nil, true, append(nodeAndCommentsSpans(tokFile, decl), commentGroupsToSpans(tokFile, compactCommentGroups(decl.Doc))...), nil } return decl, false, nil, nil case *ast.GenDecl: @@ -350,37 +345,36 @@ func filterSourcePatchDecl(decl ast.Decl, skips map[string]struct{}) (ast.Decl, } specs := decl.Specs[:0] removedAny := false - var removedComments []*ast.CommentGroup + var removedSpans []sourcePatchSpan for _, spec := range decl.Specs { - filteredSpec, removed, comments := filterSourcePatchSpec(spec, skips) + filteredSpec, removed, spans := filterSourcePatchSpec(tokFile, spec, skips) if removed { removedAny = true } - removedComments = append(removedComments, comments...) + removedSpans = append(removedSpans, spans...) if filteredSpec != nil { specs = append(specs, filteredSpec) } } if len(specs) == 0 { - removedComments = append(removedComments, decl.Doc) - return nil, removedAny, removedComments, nil + return nil, removedAny, nodeAndCommentsSpans(tokFile, decl), nil } if !removedAny { return decl, false, nil, nil } out := *decl out.Specs = specs - return &out, true, removedComments, nil + return &out, true, removedSpans, nil default: return decl, false, nil, nil } } -func filterSourcePatchSpec(spec ast.Spec, skips map[string]struct{}) (ast.Spec, bool, []*ast.CommentGroup) { +func filterSourcePatchSpec(tokFile *token.File, spec ast.Spec, skips map[string]struct{}) (ast.Spec, bool, []sourcePatchSpan) { switch spec := spec.(type) { case *ast.TypeSpec: if _, ok := skips[spec.Name.Name]; ok { - return nil, true, collectSpecComments(spec) + return nil, true, nodeAndCommentsSpans(tokFile, spec) } return spec, false, nil case *ast.ValueSpec: @@ -397,12 +391,12 @@ func filterSourcePatchSpec(spec ast.Spec, skips map[string]struct{}) (ast.Spec, return spec, false, nil } if len(keep) == 0 { - return nil, true, collectSpecComments(spec) + return nil, true, nodeAndCommentsSpans(tokFile, spec) } if len(keep) != len(spec.Names) { // Keep the transformation simple and deterministic. Mixed multi-name specs // can be split later if we need them in real patches. - return nil, true, collectSpecComments(spec) + return nil, true, nodeAndCommentsSpans(tokFile, spec) } out := *spec out.Names = keep @@ -412,6 +406,129 @@ func filterSourcePatchSpec(spec ast.Spec, skips map[string]struct{}) (ast.Spec, } } +func collectUnusedImportSpans(tokFile *token.File, file *ast.File) []sourcePatchSpan { + var spans []sourcePatchSpan + for _, decl := range file.Decls { + gen, ok := decl.(*ast.GenDecl) + if !ok || gen.Tok != token.IMPORT { + continue + } + removable := make([]*ast.ImportSpec, 0, len(gen.Specs)) + keptCount := 0 + for _, spec := range gen.Specs { + imp := spec.(*ast.ImportSpec) + if imp.Name != nil && imp.Name.Name == "_" { + keptCount++ + continue + } + if astutil.UsesImport(file, strings.Trim(imp.Path.Value, `"`)) { + keptCount++ + continue + } + removable = append(removable, imp) + } + if len(removable) == 0 { + continue + } + if keptCount == 0 || !gen.Lparen.IsValid() || len(gen.Specs) == 1 { + spans = append(spans, nodeAndCommentsSpans(tokFile, gen)...) + continue + } + for _, imp := range removable { + spans = append(spans, nodeAndCommentsSpans(tokFile, imp)...) + } + } + return spans +} + +func nodeAndCommentsSpans(tokFile *token.File, node ast.Node) []sourcePatchSpan { + spans := []sourcePatchSpan{nodeSpan(tokFile, node)} + switch node := node.(type) { + case *ast.FuncDecl: + spans = append(spans, commentGroupsToSpans(tokFile, compactCommentGroups(node.Doc))...) + case *ast.GenDecl: + spans = append(spans, commentGroupsToSpans(tokFile, compactCommentGroups(node.Doc))...) + for _, spec := range node.Specs { + spans = append(spans, commentGroupsToSpans(tokFile, collectSpecComments(spec))...) + } + case *ast.ImportSpec: + spans = append(spans, commentGroupsToSpans(tokFile, compactCommentGroups(node.Doc, node.Comment))...) + default: + if spec, ok := node.(ast.Spec); ok { + spans = append(spans, commentGroupsToSpans(tokFile, collectSpecComments(spec))...) + } + } + return spans +} + +func commentGroupsToSpans(tokFile *token.File, groups []*ast.CommentGroup) []sourcePatchSpan { + out := make([]sourcePatchSpan, 0, len(groups)) + for _, group := range groups { + if group == nil { + continue + } + out = append(out, nodeSpan(tokFile, group)) + } + return out +} + +func nodeSpan(tokFile *token.File, node ast.Node) sourcePatchSpan { + return sourcePatchSpan{ + start: tokFile.Offset(node.Pos()), + end: tokFile.Offset(node.End()), + } +} + +func blankSourcePatchSpans(src []byte, spans []sourcePatchSpan) []byte { + out := slices.Clone(src) + if len(spans) == 0 { + return out + } + slices.SortFunc(spans, func(a, b sourcePatchSpan) int { + switch { + case a.start < b.start: + return -1 + case a.start > b.start: + return 1 + case a.end < b.end: + return -1 + case a.end > b.end: + return 1 + default: + return 0 + } + }) + merged := spans[:0] + for _, span := range spans { + if span.start < 0 { + span.start = 0 + } + if span.end > len(out) { + span.end = len(out) + } + if span.start >= span.end { + continue + } + if len(merged) == 0 || span.start > merged[len(merged)-1].end { + merged = append(merged, span) + continue + } + if span.end > merged[len(merged)-1].end { + merged[len(merged)-1].end = span.end + } + } + for _, span := range merged { + for i := span.start; i < span.end; i++ { + switch out[i] { + case '\n', '\r': + default: + out[i] = ' ' + } + } + } + return out +} + func collectDeclComments(decl ast.Decl) []*ast.CommentGroup { switch decl := decl.(type) { case *ast.FuncDecl: From e09fe0054d5f2f58549ce42a5d7fb5fa607eb75d Mon Sep 17 00:00:00 2001 From: Li Jie Date: Sat, 28 Mar 2026 11:50:27 +0800 Subject: [PATCH 09/44] build: migrate runtime internals to source patches --- internal/build/source_patch_test.go | 80 +++++++++++++++++++ runtime/build.go | 20 ++--- .../lib/internal/runtime/maps/maps.go | 22 +---- 3 files changed, 94 insertions(+), 28 deletions(-) diff --git a/internal/build/source_patch_test.go b/internal/build/source_patch_test.go index 63f77e02d9..30d1a79ef5 100644 --- a/internal/build/source_patch_test.go +++ b/internal/build/source_patch_test.go @@ -120,6 +120,68 @@ func TestBuildSourcePatchOverlayForReflectlite(t *testing.T) { } } +func TestBuildSourcePatchOverlayForInternalRuntimeMaps(t *testing.T) { + overlay, err := buildSourcePatchOverlayForGOROOT(nil, env.LLGoRuntimeDir(), runtime.GOROOT()) + if err != nil { + t.Fatal(err) + } + + pkgDir := filepath.Join(runtime.GOROOT(), "src", "internal", "runtime", "maps") + stdFile := filepath.Join(pkgDir, "runtime.go") + stdSrc, ok := overlay[stdFile] + if !ok { + t.Fatalf("missing filtered stdlib file %s", stdFile) + } + got := string(stdSrc) + for _, forbidden := range []string{"func fatal(", "func rand()", "func typedmemmove(", "func typedmemclr(", "func newarray(", "func newobject("} { + if strings.Contains(got, forbidden) { + t.Fatalf("expected source patch filtering to remove %q from %s, got:\n%s", forbidden, stdFile, got) + } + } + + patchFile := filepath.Join(pkgDir, "z_llgo_patch_maps.go") + patchSrc, ok := overlay[patchFile] + if !ok { + t.Fatalf("missing source patch file %s", patchFile) + } + for _, want := range []string{"func fatal(", "func rand()", "func mapKeyError(", "func typeString("} { + if !strings.Contains(string(patchSrc), want) { + t.Fatalf("expected source patch file %s to contain %q", patchFile, want) + } + } +} + +func TestBuildSourcePatchOverlayForInternalRuntimeSys(t *testing.T) { + overlay, err := buildSourcePatchOverlayForGOROOT(nil, env.LLGoRuntimeDir(), runtime.GOROOT()) + if err != nil { + t.Fatal(err) + } + + pkgDir := filepath.Join(runtime.GOROOT(), "src", "internal", "runtime", "sys") + stdFile := filepath.Join(pkgDir, "intrinsics.go") + stdSrc, ok := overlay[stdFile] + if !ok { + t.Fatalf("missing filtered stdlib file %s", stdFile) + } + got := string(stdSrc) + for _, forbidden := range []string{"func GetCallerPC()", "func GetCallerSP()"} { + if strings.Contains(got, forbidden) { + t.Fatalf("expected source patch filtering to remove %q from %s, got:\n%s", forbidden, stdFile, got) + } + } + + patchFile := filepath.Join(pkgDir, "z_llgo_patch_intrinsics.go") + patchSrc, ok := overlay[patchFile] + if !ok { + t.Fatalf("missing source patch file %s", patchFile) + } + for _, want := range []string{"func GetCallerPC() uintptr", "func GetCallerSP() uintptr"} { + if !strings.Contains(string(patchSrc), want) { + t.Fatalf("expected source patch file %s to contain %q", patchFile, want) + } + } +} + func TestReflectliteUsesSourcePatchInsteadOfAltPkg(t *testing.T) { if !llruntime.HasSourcePatchPkg("internal/reflectlite") { t.Fatal("internal/reflectlite should be registered as a source patch package") @@ -129,6 +191,24 @@ func TestReflectliteUsesSourcePatchInsteadOfAltPkg(t *testing.T) { } } +func TestInternalRuntimeMapsUsesSourcePatchInsteadOfAltPkg(t *testing.T) { + if !llruntime.HasSourcePatchPkg("internal/runtime/maps") { + t.Fatal("internal/runtime/maps should be registered as a source patch package") + } + if llruntime.HasAltPkg("internal/runtime/maps") { + t.Fatal("internal/runtime/maps should not remain an alt package") + } +} + +func TestInternalRuntimeSysUsesSourcePatchInsteadOfAltPkg(t *testing.T) { + if !llruntime.HasSourcePatchPkg("internal/runtime/sys") { + t.Fatal("internal/runtime/sys should be registered as a source patch package") + } + if llruntime.HasAltPkg("internal/runtime/sys") { + t.Fatal("internal/runtime/sys should not remain an alt package") + } +} + func TestUniqueUsesSourcePatchInsteadOfAltPkg(t *testing.T) { if !llruntime.HasSourcePatchPkg("unique") { t.Fatal("unique should be registered as a source patch package") diff --git a/runtime/build.go b/runtime/build.go index a65147e717..86f6c65ddb 100644 --- a/runtime/build.go +++ b/runtime/build.go @@ -40,17 +40,17 @@ func SourcePatchPkgPaths() []string { } var altPkgs = map[string]altPkgMode{ - "internal/abi": altPkgReplace, - "internal/runtime/maps": altPkgReplace, - "internal/runtime/sys": altPkgAdditive, - "reflect": altPkgReplace, - "runtime": altPkgReplace, - "syscall/js": altPkgReplace, + "internal/abi": altPkgReplace, + "reflect": altPkgReplace, + "runtime": altPkgReplace, + "syscall/js": altPkgReplace, } var sourcePatchPkgs = map[string]struct{}{ - "internal/reflectlite": {}, - "iter": {}, - "sync/atomic": {}, - "unique": {}, + "internal/runtime/maps": {}, + "internal/runtime/sys": {}, + "internal/reflectlite": {}, + "iter": {}, + "sync/atomic": {}, + "unique": {}, } diff --git a/runtime/internal/lib/internal/runtime/maps/maps.go b/runtime/internal/lib/internal/runtime/maps/maps.go index 382f6bd6f0..e7b874b842 100644 --- a/runtime/internal/lib/internal/runtime/maps/maps.go +++ b/runtime/internal/lib/internal/runtime/maps/maps.go @@ -1,9 +1,10 @@ package maps import ( + "internal/abi" "unsafe" - "github.com/goplus/llgo/runtime/abi" + llabi "github.com/goplus/llgo/runtime/abi" ) //go:linkname runtime_fastrand64 github.com/goplus/llgo/runtime/internal/runtime.fastrand64 @@ -32,22 +33,7 @@ func fatal(s string) { runtime_fatal(s) } -type Type = abi.Type - -type SwissMapType struct { - Type - Key *Type - Elem *Type - Group *Type // internal type representing a slot group - // function for hashing keys (ptr to key, seed) -> hash - Hasher func(unsafe.Pointer, uintptr) uintptr - GroupSize uintptr // == Group.Size_ - SlotSize uintptr // size of key/elem slot - ElemOff uintptr // offset of elem in key/elem slot - Flags uint32 -} - -func mapKeyError(typ *SwissMapType, p unsafe.Pointer) error { +func mapKeyError(typ *abi.SwissMapType, p unsafe.Pointer) error { return nil } @@ -71,5 +57,5 @@ func typeString(typ *abi.Type) string { if typ == nil { return "" } - return typ.String() + return (*llabi.Type)(unsafe.Pointer(typ)).String() } From 1f663fad31f6f64f7a9cbc140f4a21db4f3bcbef Mon Sep 17 00:00:00 2001 From: Li Jie Date: Sat, 28 Mar 2026 12:08:29 +0800 Subject: [PATCH 10/44] build: narrow source patch package coverage --- internal/build/source_patch_test.go | 48 ------------------- runtime/build.go | 12 ++--- .../lib/internal/reflectlite/value.go | 3 +- .../lib/internal/runtime/maps/maps.go | 4 +- 4 files changed, 9 insertions(+), 58 deletions(-) diff --git a/internal/build/source_patch_test.go b/internal/build/source_patch_test.go index 30d1a79ef5..51dba84429 100644 --- a/internal/build/source_patch_test.go +++ b/internal/build/source_patch_test.go @@ -90,36 +90,6 @@ func TestSyncAtomicUsesSourcePatchInsteadOfAltPkg(t *testing.T) { } } -func TestBuildSourcePatchOverlayForReflectlite(t *testing.T) { - overlay, err := buildSourcePatchOverlayForGOROOT(nil, env.LLGoRuntimeDir(), runtime.GOROOT()) - if err != nil { - t.Fatal(err) - } - - pkgDir := filepath.Join(runtime.GOROOT(), "src", "internal", "reflectlite") - stdFile := filepath.Join(pkgDir, "value.go") - stdSrc, ok := overlay[stdFile] - if !ok { - t.Fatalf("missing stub overlay for %s", stdFile) - } - got := string(stdSrc) - if !strings.Contains(got, "package reflectlite") { - t.Fatalf("stub overlay for %s lost package clause", stdFile) - } - if strings.Contains(got, "type Value struct") { - t.Fatalf("stub overlay for %s still contains original declarations", stdFile) - } - - patchFile := filepath.Join(pkgDir, "z_llgo_patch_value.go") - patchSrc, ok := overlay[patchFile] - if !ok { - t.Fatalf("missing source patch file %s", patchFile) - } - if !strings.Contains(string(patchSrc), "type Value struct") { - t.Fatalf("source patch file %s does not contain reflectlite replacement", patchFile) - } -} - func TestBuildSourcePatchOverlayForInternalRuntimeMaps(t *testing.T) { overlay, err := buildSourcePatchOverlayForGOROOT(nil, env.LLGoRuntimeDir(), runtime.GOROOT()) if err != nil { @@ -182,15 +152,6 @@ func TestBuildSourcePatchOverlayForInternalRuntimeSys(t *testing.T) { } } -func TestReflectliteUsesSourcePatchInsteadOfAltPkg(t *testing.T) { - if !llruntime.HasSourcePatchPkg("internal/reflectlite") { - t.Fatal("internal/reflectlite should be registered as a source patch package") - } - if llruntime.HasAltPkg("internal/reflectlite") { - t.Fatal("internal/reflectlite should not remain an alt package") - } -} - func TestInternalRuntimeMapsUsesSourcePatchInsteadOfAltPkg(t *testing.T) { if !llruntime.HasSourcePatchPkg("internal/runtime/maps") { t.Fatal("internal/runtime/maps should be registered as a source patch package") @@ -209,15 +170,6 @@ func TestInternalRuntimeSysUsesSourcePatchInsteadOfAltPkg(t *testing.T) { } } -func TestUniqueUsesSourcePatchInsteadOfAltPkg(t *testing.T) { - if !llruntime.HasSourcePatchPkg("unique") { - t.Fatal("unique should be registered as a source patch package") - } - if llruntime.HasAltPkg("unique") { - t.Fatal("unique should not remain an alt package") - } -} - func TestApplySourcePatchForPkg_Directives(t *testing.T) { t.Run("skip-and-override", func(t *testing.T) { goroot := t.TempDir() diff --git a/runtime/build.go b/runtime/build.go index 86f6c65ddb..7494291b2b 100644 --- a/runtime/build.go +++ b/runtime/build.go @@ -40,17 +40,17 @@ func SourcePatchPkgPaths() []string { } var altPkgs = map[string]altPkgMode{ - "internal/abi": altPkgReplace, - "reflect": altPkgReplace, - "runtime": altPkgReplace, - "syscall/js": altPkgReplace, + "internal/abi": altPkgReplace, + "internal/reflectlite": altPkgReplace, + "reflect": altPkgReplace, + "runtime": altPkgReplace, + "syscall/js": altPkgReplace, + "unique": altPkgReplace, } var sourcePatchPkgs = map[string]struct{}{ "internal/runtime/maps": {}, "internal/runtime/sys": {}, - "internal/reflectlite": {}, "iter": {}, "sync/atomic": {}, - "unique": {}, } diff --git a/runtime/internal/lib/internal/reflectlite/value.go b/runtime/internal/lib/internal/reflectlite/value.go index c8afe504d3..5fa0cf5bc3 100644 --- a/runtime/internal/lib/internal/reflectlite/value.go +++ b/runtime/internal/lib/internal/reflectlite/value.go @@ -5,10 +5,11 @@ package reflectlite import ( - "internal/goarch" "unsafe" "github.com/goplus/llgo/runtime/abi" + _ "github.com/goplus/llgo/runtime/internal/runtime" + "github.com/goplus/llgo/runtime/internal/runtime/goarch" ) // Value is the reflection interface to a Go value. diff --git a/runtime/internal/lib/internal/runtime/maps/maps.go b/runtime/internal/lib/internal/runtime/maps/maps.go index e7b874b842..ce1bb16a80 100644 --- a/runtime/internal/lib/internal/runtime/maps/maps.go +++ b/runtime/internal/lib/internal/runtime/maps/maps.go @@ -3,8 +3,6 @@ package maps import ( "internal/abi" "unsafe" - - llabi "github.com/goplus/llgo/runtime/abi" ) //go:linkname runtime_fastrand64 github.com/goplus/llgo/runtime/internal/runtime.fastrand64 @@ -57,5 +55,5 @@ func typeString(typ *abi.Type) string { if typ == nil { return "" } - return (*llabi.Type)(unsafe.Pointer(typ)).String() + return "" } From 65522dd01b2d273f5ed6d4f96a704fd61b61507f Mon Sep 17 00:00:00 2001 From: Li Jie Date: Sat, 28 Mar 2026 12:14:24 +0800 Subject: [PATCH 11/44] build: tighten source patch helpers --- internal/build/source_patch.go | 30 ++++++++++++------------------ runtime/build.go | 6 +++--- 2 files changed, 15 insertions(+), 21 deletions(-) diff --git a/internal/build/source_patch.go b/internal/build/source_patch.go index 32f96170ef..19c40ce45f 100644 --- a/internal/build/source_patch.go +++ b/internal/build/source_patch.go @@ -234,6 +234,15 @@ func collectSourcePatchDirectives(src []byte) (sourcePatchDirectives, error) { return d, nil } +// parseSourcePatchDirective recognizes build-time source-patch directives. +// +// Supported directives: +// - //llgo:nopatch: ignore this file during source-patch injection +// - //llgo:skipall: blank every stdlib .go file in the patched package +// - //llgo:skip A B: blank the named declarations from the stdlib package view +// +// Unlike cl/import.go directives, these are consumed only while constructing the +// load-time overlay and are rewritten to plain comments before type checking. func parseSourcePatchDirective(line string) (noPatch, skipAll bool, names []string, ok bool) { const ( llgo1 = "//llgo:" @@ -283,7 +292,7 @@ func sanitizeSourcePatchDirectiveLines(src []byte) []byte { } } if !changed { - return out + return src } return out } @@ -334,7 +343,7 @@ func filterSourcePatchDecl(tokFile *token.File, decl ast.Decl, skips map[string] switch decl := decl.(type) { case *ast.FuncDecl: if _, ok := skips[declPatchKeyFunc(decl)]; ok { - return nil, true, append(nodeAndCommentsSpans(tokFile, decl), commentGroupsToSpans(tokFile, compactCommentGroups(decl.Doc))...), nil + return nil, true, nodeAndCommentsSpans(tokFile, decl), nil } return decl, false, nil, nil case *ast.GenDecl: @@ -529,21 +538,6 @@ func blankSourcePatchSpans(src []byte, spans []sourcePatchSpan) []byte { return out } -func collectDeclComments(decl ast.Decl) []*ast.CommentGroup { - switch decl := decl.(type) { - case *ast.FuncDecl: - return compactCommentGroups(decl.Doc) - case *ast.GenDecl: - out := compactCommentGroups(decl.Doc) - for _, spec := range decl.Specs { - out = append(out, collectSpecComments(spec)...) - } - return out - default: - return nil - } -} - func collectSpecComments(spec ast.Spec) []*ast.CommentGroup { switch spec := spec.(type) { case *ast.TypeSpec: @@ -609,6 +603,6 @@ func recvPatchKey(expr ast.Expr) string { case *ast.SelectorExpr: return expr.Sel.Name default: - return "" + panic(fmt.Sprintf("unhandled expression type in recvPatchKey: %T", expr)) } } diff --git a/runtime/build.go b/runtime/build.go index 7494291b2b..748dbfbdca 100644 --- a/runtime/build.go +++ b/runtime/build.go @@ -25,9 +25,9 @@ func HasAdditiveAltPkg(path string) bool { return altPkgs[path] == altPkgAdditive } -func HasSourcePatchPkg(path string) (b bool) { - _, b = sourcePatchPkgs[path] - return +func HasSourcePatchPkg(path string) bool { + _, ok := sourcePatchPkgs[path] + return ok } func SourcePatchPkgPaths() []string { From ab1e850011dbebab1e82ccf46242f55af336ae5c Mon Sep 17 00:00:00 2001 From: Li Jie Date: Sat, 28 Mar 2026 12:26:58 +0800 Subject: [PATCH 12/44] build: narrow source patch package coverage --- internal/build/source_patch_test.go | 83 +++---------------- runtime/build.go | 20 ++--- .../lib/internal/runtime/maps/maps.go | 22 ++++- 3 files changed, 41 insertions(+), 84 deletions(-) diff --git a/internal/build/source_patch_test.go b/internal/build/source_patch_test.go index 51dba84429..84bb773f1a 100644 --- a/internal/build/source_patch_test.go +++ b/internal/build/source_patch_test.go @@ -90,83 +90,24 @@ func TestSyncAtomicUsesSourcePatchInsteadOfAltPkg(t *testing.T) { } } -func TestBuildSourcePatchOverlayForInternalRuntimeMaps(t *testing.T) { - overlay, err := buildSourcePatchOverlayForGOROOT(nil, env.LLGoRuntimeDir(), runtime.GOROOT()) - if err != nil { - t.Fatal(err) +func TestInternalRuntimeMapsRemainsAltPkg(t *testing.T) { + if llruntime.HasSourcePatchPkg("internal/runtime/maps") { + t.Fatal("internal/runtime/maps should not be registered as a source patch package") } - - pkgDir := filepath.Join(runtime.GOROOT(), "src", "internal", "runtime", "maps") - stdFile := filepath.Join(pkgDir, "runtime.go") - stdSrc, ok := overlay[stdFile] - if !ok { - t.Fatalf("missing filtered stdlib file %s", stdFile) - } - got := string(stdSrc) - for _, forbidden := range []string{"func fatal(", "func rand()", "func typedmemmove(", "func typedmemclr(", "func newarray(", "func newobject("} { - if strings.Contains(got, forbidden) { - t.Fatalf("expected source patch filtering to remove %q from %s, got:\n%s", forbidden, stdFile, got) - } - } - - patchFile := filepath.Join(pkgDir, "z_llgo_patch_maps.go") - patchSrc, ok := overlay[patchFile] - if !ok { - t.Fatalf("missing source patch file %s", patchFile) - } - for _, want := range []string{"func fatal(", "func rand()", "func mapKeyError(", "func typeString("} { - if !strings.Contains(string(patchSrc), want) { - t.Fatalf("expected source patch file %s to contain %q", patchFile, want) - } + if !llruntime.HasAltPkg("internal/runtime/maps") { + t.Fatal("internal/runtime/maps should remain an alt package") } } -func TestBuildSourcePatchOverlayForInternalRuntimeSys(t *testing.T) { - overlay, err := buildSourcePatchOverlayForGOROOT(nil, env.LLGoRuntimeDir(), runtime.GOROOT()) - if err != nil { - t.Fatal(err) +func TestInternalRuntimeSysRemainsAltPkg(t *testing.T) { + if llruntime.HasSourcePatchPkg("internal/runtime/sys") { + t.Fatal("internal/runtime/sys should not be registered as a source patch package") } - - pkgDir := filepath.Join(runtime.GOROOT(), "src", "internal", "runtime", "sys") - stdFile := filepath.Join(pkgDir, "intrinsics.go") - stdSrc, ok := overlay[stdFile] - if !ok { - t.Fatalf("missing filtered stdlib file %s", stdFile) - } - got := string(stdSrc) - for _, forbidden := range []string{"func GetCallerPC()", "func GetCallerSP()"} { - if strings.Contains(got, forbidden) { - t.Fatalf("expected source patch filtering to remove %q from %s, got:\n%s", forbidden, stdFile, got) - } - } - - patchFile := filepath.Join(pkgDir, "z_llgo_patch_intrinsics.go") - patchSrc, ok := overlay[patchFile] - if !ok { - t.Fatalf("missing source patch file %s", patchFile) - } - for _, want := range []string{"func GetCallerPC() uintptr", "func GetCallerSP() uintptr"} { - if !strings.Contains(string(patchSrc), want) { - t.Fatalf("expected source patch file %s to contain %q", patchFile, want) - } - } -} - -func TestInternalRuntimeMapsUsesSourcePatchInsteadOfAltPkg(t *testing.T) { - if !llruntime.HasSourcePatchPkg("internal/runtime/maps") { - t.Fatal("internal/runtime/maps should be registered as a source patch package") - } - if llruntime.HasAltPkg("internal/runtime/maps") { - t.Fatal("internal/runtime/maps should not remain an alt package") - } -} - -func TestInternalRuntimeSysUsesSourcePatchInsteadOfAltPkg(t *testing.T) { - if !llruntime.HasSourcePatchPkg("internal/runtime/sys") { - t.Fatal("internal/runtime/sys should be registered as a source patch package") + if !llruntime.HasAltPkg("internal/runtime/sys") { + t.Fatal("internal/runtime/sys should remain an alt package") } - if llruntime.HasAltPkg("internal/runtime/sys") { - t.Fatal("internal/runtime/sys should not remain an alt package") + if !llruntime.HasAdditiveAltPkg("internal/runtime/sys") { + t.Fatal("internal/runtime/sys should remain an additive alt package") } } diff --git a/runtime/build.go b/runtime/build.go index 748dbfbdca..2088d33f68 100644 --- a/runtime/build.go +++ b/runtime/build.go @@ -40,17 +40,17 @@ func SourcePatchPkgPaths() []string { } var altPkgs = map[string]altPkgMode{ - "internal/abi": altPkgReplace, - "internal/reflectlite": altPkgReplace, - "reflect": altPkgReplace, - "runtime": altPkgReplace, - "syscall/js": altPkgReplace, - "unique": altPkgReplace, + "internal/abi": altPkgReplace, + "internal/reflectlite": altPkgReplace, + "internal/runtime/maps": altPkgReplace, + "internal/runtime/sys": altPkgAdditive, + "reflect": altPkgReplace, + "runtime": altPkgReplace, + "syscall/js": altPkgReplace, + "unique": altPkgReplace, } var sourcePatchPkgs = map[string]struct{}{ - "internal/runtime/maps": {}, - "internal/runtime/sys": {}, - "iter": {}, - "sync/atomic": {}, + "iter": {}, + "sync/atomic": {}, } diff --git a/runtime/internal/lib/internal/runtime/maps/maps.go b/runtime/internal/lib/internal/runtime/maps/maps.go index ce1bb16a80..b035f6e5a0 100644 --- a/runtime/internal/lib/internal/runtime/maps/maps.go +++ b/runtime/internal/lib/internal/runtime/maps/maps.go @@ -1,8 +1,9 @@ package maps import ( - "internal/abi" "unsafe" + + "github.com/goplus/llgo/runtime/abi" ) //go:linkname runtime_fastrand64 github.com/goplus/llgo/runtime/internal/runtime.fastrand64 @@ -31,7 +32,22 @@ func fatal(s string) { runtime_fatal(s) } -func mapKeyError(typ *abi.SwissMapType, p unsafe.Pointer) error { +type Type = abi.Type + +type SwissMapType struct { + Type + Key *Type + Elem *Type + Group *Type + Hasher func(unsafe.Pointer, uintptr) uintptr + + GroupSize uintptr + SlotSize uintptr + ElemOff uintptr + Flags uint32 +} + +func mapKeyError(typ *SwissMapType, p unsafe.Pointer) error { return nil } @@ -55,5 +71,5 @@ func typeString(typ *abi.Type) string { if typ == nil { return "" } - return "" + return typ.String() } From 3cfa0aea86b7e489810a813154689eff5ac0f7e1 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Sat, 28 Mar 2026 12:34:26 +0800 Subject: [PATCH 13/44] build: skip source patches for missing stdlib packages --- internal/build/source_patch.go | 3 +++ internal/build/source_patch_test.go | 24 ++++++++++++++++++++++++ 2 files changed, 27 insertions(+) diff --git a/internal/build/source_patch.go b/internal/build/source_patch.go index 19c40ce45f..72711565e2 100644 --- a/internal/build/source_patch.go +++ b/internal/build/source_patch.go @@ -62,6 +62,9 @@ func applySourcePatchForPkg(base, current map[string][]byte, runtimeDir, goroot, srcDir := filepath.Join(goroot, "src", filepath.FromSlash(pkgPath)) srcEntries, err := os.ReadDir(srcDir) if err != nil { + if os.IsNotExist(err) { + return false, current, nil + } return false, nil, fmt.Errorf("read stdlib dir %s: %w", pkgPath, err) } diff --git a/internal/build/source_patch_test.go b/internal/build/source_patch_test.go index 84bb773f1a..811bb196d5 100644 --- a/internal/build/source_patch_test.go +++ b/internal/build/source_patch_test.go @@ -272,6 +272,30 @@ const Only = "patched" }) } +func TestApplySourcePatchForPkg_MissingStdlibPkg(t *testing.T) { + goroot := t.TempDir() + runtimeDir := t.TempDir() + pkgPath := "iter" + patchDir := filepath.Join(runtimeDir, "internal", "lib", pkgPath) + mustWriteFile(t, filepath.Join(patchDir, "iter.go"), `package iter + +//llgo:skipall + +func Pull[V any](seq func(func(V) bool)) {} +`) + + changed, overlay, err := applySourcePatchForPkg(nil, nil, runtimeDir, goroot, pkgPath) + if err != nil { + t.Fatal(err) + } + if changed { + t.Fatal("expected missing stdlib package to skip source patching") + } + if overlay != nil { + t.Fatalf("expected no overlay for missing stdlib package, got %v entries", len(overlay)) + } +} + func mustWriteFile(t *testing.T, filename, content string) { t.Helper() if err := os.MkdirAll(filepath.Dir(filename), 0755); err != nil { From 5c187de3d300d4e5406cf75e6bf73b0467123714 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Sat, 28 Mar 2026 12:53:05 +0800 Subject: [PATCH 14/44] build: resolve source patch goroot from go env --- internal/build/build.go | 6 ++++- internal/build/source_patch.go | 5 +++++ internal/build/source_patch_test.go | 35 +++++++++++++++++++++++++++++ internal/env/env.go | 7 ++++++ 4 files changed, 52 insertions(+), 1 deletion(-) diff --git a/internal/build/build.go b/internal/build/build.go index 6a77bb80be..1bc814dba9 100644 --- a/internal/build/build.go +++ b/internal/build/build.go @@ -297,7 +297,11 @@ func Do(args []string, conf *Config) ([]Package, error) { if patterns == nil { patterns = []string{"."} } - cfg.Overlay, err = buildSourcePatchOverlay(cfg.Overlay, env.LLGoRuntimeDir()) + sourcePatchGOROOT, err := env.GOROOTWithEnv(cfg.Env) + if err != nil { + return nil, err + } + cfg.Overlay, err = buildSourcePatchOverlayForGOROOT(cfg.Overlay, env.LLGoRuntimeDir(), sourcePatchGOROOT) if err != nil { return nil, err } diff --git a/internal/build/source_patch.go b/internal/build/source_patch.go index 72711565e2..64b8cb7799 100644 --- a/internal/build/source_patch.go +++ b/internal/build/source_patch.go @@ -2,6 +2,7 @@ package build import ( "bytes" + "errors" "fmt" "go/ast" "go/parser" @@ -11,6 +12,7 @@ import ( "runtime" "slices" "strings" + "syscall" llruntime "github.com/goplus/llgo/runtime" "golang.org/x/tools/go/ast/astutil" @@ -65,6 +67,9 @@ func applySourcePatchForPkg(base, current map[string][]byte, runtimeDir, goroot, if os.IsNotExist(err) { return false, current, nil } + if errors.Is(err, syscall.EACCES) || errors.Is(err, syscall.EPERM) { + return false, current, nil + } return false, nil, fmt.Errorf("read stdlib dir %s: %w", pkgPath, err) } diff --git a/internal/build/source_patch_test.go b/internal/build/source_patch_test.go index 811bb196d5..f848eeebcf 100644 --- a/internal/build/source_patch_test.go +++ b/internal/build/source_patch_test.go @@ -296,6 +296,41 @@ func Pull[V any](seq func(func(V) bool)) {} } } +func TestApplySourcePatchForPkg_UnreadableStdlibPkg(t *testing.T) { + if runtime.GOOS == "windows" { + t.Skip("chmod-based permission test is Unix-only") + } + goroot := t.TempDir() + runtimeDir := t.TempDir() + pkgPath := "iter" + srcDir := filepath.Join(goroot, "src", pkgPath) + patchDir := filepath.Join(runtimeDir, "internal", "lib", pkgPath) + if err := os.MkdirAll(srcDir, 0755); err != nil { + t.Fatal(err) + } + if err := os.Chmod(srcDir, 0); err != nil { + t.Fatal(err) + } + defer os.Chmod(srcDir, 0755) + mustWriteFile(t, filepath.Join(patchDir, "iter.go"), `package iter + +//llgo:skipall + +func Pull[V any](seq func(func(V) bool)) {} +`) + + changed, overlay, err := applySourcePatchForPkg(nil, nil, runtimeDir, goroot, pkgPath) + if err != nil { + t.Fatal(err) + } + if changed { + t.Fatal("expected unreadable stdlib package to skip source patching") + } + if overlay != nil { + t.Fatalf("expected no overlay for unreadable stdlib package, got %v entries", len(overlay)) + } +} + func mustWriteFile(t *testing.T, filename, content string) { t.Helper() if err := os.MkdirAll(filepath.Dir(filename), 0755); err != nil { diff --git a/internal/env/env.go b/internal/env/env.go index 4da842f7b4..9da5ae4869 100644 --- a/internal/env/env.go +++ b/internal/env/env.go @@ -18,7 +18,14 @@ const ( ) func GOROOT() (string, error) { + return GOROOTWithEnv(nil) +} + +func GOROOTWithEnv(env []string) (string, error) { cmd := exec.Command("go", "env", "GOROOT") + if len(env) != 0 { + cmd.Env = env + } var out bytes.Buffer var buf bytes.Buffer cmd.Stdout = &out From d48e159bf4944dbf74a2e765739135b3d2f19bc5 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Sat, 28 Mar 2026 13:15:47 +0800 Subject: [PATCH 15/44] build: keep sync atomic on alt patches --- internal/build/source_patch_test.go | 41 ++++------------------------- runtime/build.go | 4 +-- 2 files changed, 7 insertions(+), 38 deletions(-) diff --git a/internal/build/source_patch_test.go b/internal/build/source_patch_test.go index f848eeebcf..578e6ade31 100644 --- a/internal/build/source_patch_test.go +++ b/internal/build/source_patch_test.go @@ -50,43 +50,12 @@ func TestIterUsesSourcePatchInsteadOfAltPkg(t *testing.T) { } } -func TestBuildSourcePatchOverlayForSyncAtomic(t *testing.T) { - overlay, err := buildSourcePatchOverlayForGOROOT(nil, env.LLGoRuntimeDir(), runtime.GOROOT()) - if err != nil { - t.Fatal(err) - } - - atomicDir := filepath.Join(runtime.GOROOT(), "src", "sync", "atomic") - stdFile := filepath.Join(atomicDir, "value.go") - stdSrc, ok := overlay[stdFile] - if !ok { - t.Fatalf("missing filtered stdlib file %s", stdFile) - } - got := string(stdSrc) - for _, forbidden := range []string{"func (v *Value) Store", "func (v *Value) Swap", "func (v *Value) CompareAndSwap", "func runtime_procPin()", "func runtime_procUnpin()"} { - if strings.Contains(got, forbidden) { - t.Fatalf("expected source patch filtering to remove %q from %s, got:\n%s", forbidden, stdFile, got) - } - } - - patchFile := filepath.Join(atomicDir, "z_llgo_patch_value.go") - patchSrc, ok := overlay[patchFile] - if !ok { - t.Fatalf("missing source patch file %s", patchFile) - } - for _, want := range []string{"func (v *Value) Store", "func (v *Value) Swap", "func (v *Value) CompareAndSwap"} { - if !strings.Contains(string(patchSrc), want) { - t.Fatalf("expected source patch file %s to contain %q", patchFile, want) - } - } -} - -func TestSyncAtomicUsesSourcePatchInsteadOfAltPkg(t *testing.T) { - if !llruntime.HasSourcePatchPkg("sync/atomic") { - t.Fatal("sync/atomic should be registered as a source patch package") +func TestSyncAtomicRemainsAltPkg(t *testing.T) { + if llruntime.HasSourcePatchPkg("sync/atomic") { + t.Fatal("sync/atomic should not be registered as a source patch package") } - if llruntime.HasAltPkg("sync/atomic") { - t.Fatal("sync/atomic should not remain an alt package") + if !llruntime.HasAltPkg("sync/atomic") { + t.Fatal("sync/atomic should remain an alt package") } } diff --git a/runtime/build.go b/runtime/build.go index 2088d33f68..3838de6ca8 100644 --- a/runtime/build.go +++ b/runtime/build.go @@ -46,11 +46,11 @@ var altPkgs = map[string]altPkgMode{ "internal/runtime/sys": altPkgAdditive, "reflect": altPkgReplace, "runtime": altPkgReplace, + "sync/atomic": altPkgReplace, "syscall/js": altPkgReplace, "unique": altPkgReplace, } var sourcePatchPkgs = map[string]struct{}{ - "iter": {}, - "sync/atomic": {}, + "iter": {}, } From 2242f98e648df444a6a31beea0caab753286b23e Mon Sep 17 00:00:00 2001 From: Li Jie Date: Sat, 28 Mar 2026 19:06:04 +0800 Subject: [PATCH 16/44] build: preserve source patch diagnostics --- internal/build/source_patch.go | 12 +- internal/build/source_patch_test.go | 245 ++++++++++++++++++++-------- 2 files changed, 191 insertions(+), 66 deletions(-) diff --git a/internal/build/source_patch.go b/internal/build/source_patch.go index 64b8cb7799..0ffe08dc92 100644 --- a/internal/build/source_patch.go +++ b/internal/build/source_patch.go @@ -112,7 +112,7 @@ func applySourcePatchForPkg(base, current map[string][]byte, runtimeDir, goroot, if directives.noPatch { continue } - patchSrcs[name] = sanitizeSourcePatchDirectiveLines(src) + patchSrcs[name] = buildInjectedSourcePatchFile(filename, src) if directives.skipAll { skipAll = true } @@ -305,6 +305,16 @@ func sanitizeSourcePatchDirectiveLines(src []byte) []byte { return out } +func buildInjectedSourcePatchFile(filename string, src []byte) []byte { + sanitized := sanitizeSourcePatchDirectiveLines(src) + var out bytes.Buffer + out.WriteString("//line ") + out.WriteString(filepath.ToSlash(filename)) + out.WriteString(":1\n") + out.Write(sanitized) + return out.Bytes() +} + func filterSourcePatchFile(src []byte, skips map[string]struct{}) ([]byte, bool, error) { fset := token.NewFileSet() file, err := parser.ParseFile(fset, "", src, parser.ParseComments) diff --git a/internal/build/source_patch_test.go b/internal/build/source_patch_test.go index 578e6ade31..ab88cb1be7 100644 --- a/internal/build/source_patch_test.go +++ b/internal/build/source_patch_test.go @@ -1,6 +1,9 @@ package build import ( + "go/ast" + "go/parser" + "go/token" "os" "path/filepath" "runtime" @@ -26,6 +29,9 @@ func TestBuildSourcePatchOverlayForIter(t *testing.T) { if !strings.Contains(string(patchSrc), "func Pull[V any]") { t.Fatalf("source patch file %s does not contain iter replacement", patchFile) } + if !strings.HasPrefix(string(patchSrc), sourcePatchLineDirective(filepath.Join(env.LLGoRuntimeDir(), "internal", "lib", "iter", "iter.go"))) { + t.Fatalf("source patch file %s is missing line directive, got:\n%s", patchFile, patchSrc) + } stdFile := filepath.Join(iterDir, "iter.go") stdSrc, ok := overlay[stdFile] @@ -87,7 +93,9 @@ func TestApplySourcePatchForPkg_Directives(t *testing.T) { pkgPath := "demo" srcDir := filepath.Join(goroot, "src", pkgPath) patchDir := filepath.Join(runtimeDir, "internal", "lib", pkgPath) - mustWriteFile(t, filepath.Join(srcDir, "demo.go"), `package demo + stdFile := filepath.Join(srcDir, "demo.go") + patchFile := filepath.Join(patchDir, "patch.go") + mustWriteFile(t, stdFile, `package demo import "fmt" @@ -101,7 +109,7 @@ func Old() string { return fmt.Sprint("old") } func KeepFn() string { return Keep } func (T) M() string { return fmt.Sprint("old method") } `) - mustWriteFile(t, filepath.Join(patchDir, "patch.go"), `package demo + mustWriteFile(t, patchFile, `package demo //llgo:skip Drop @@ -121,36 +129,39 @@ func (T) M() string { return "new method" } t.Fatal("expected source patch overlay to change package") } - stdFile := filepath.Join(srcDir, "demo.go") - got := string(overlay[stdFile]) - if strings.Contains(got, "fmt") { - t.Fatalf("expected unused fmt import to be removed, got:\n%s", got) - } - if strings.Contains(got, "var Drop") { - t.Fatalf("expected explicit skip to remove Drop, got:\n%s", got) - } - if strings.Contains(got, "func Old") { - t.Fatalf("expected patch declaration to override Old, got:\n%s", got) - } - if strings.Contains(got, "func (T) M") { - t.Fatalf("expected patch declaration to override T.M, got:\n%s", got) - } - for _, want := range []string{"const Keep", "type T struct{}", "func KeepFn"} { - if !strings.Contains(got, want) { - t.Fatalf("expected original declaration %q to remain, got:\n%s", want, got) - } - } + assertExactString(t, "filtered stdlib source", string(overlay[stdFile]), ""+ + "package demo\n"+ + "\n"+ + blankNonNewline(`import "fmt"`)+"\n"+ + "\n"+ + `const Keep = "keep"`+"\n"+ + "\n"+ + blankNonNewline(`var Drop = fmt.Sprint("drop")`)+"\n"+ + "\n"+ + `type T struct{}`+"\n"+ + "\n"+ + blankNonNewline(`func Old() string { return fmt.Sprint("old") }`)+"\n"+ + `func KeepFn() string { return Keep }`+"\n"+ + blankNonNewline(`func (T) M() string { return fmt.Sprint("old method") }`)+"\n") + + injectedPatch := filepath.Join(srcDir, "z_llgo_patch_patch.go") + assertExactString(t, "injected patch source", string(overlay[injectedPatch]), + sourcePatchLineDirective(patchFile)+`package demo + +//llgo_skip Drop - patchFile := filepath.Join(srcDir, "z_llgo_patch_patch.go") - patchSrc := string(overlay[patchFile]) - if strings.Contains(patchSrc, "llgo:skip") { - t.Fatalf("expected source patch directives to be stripped, got:\n%s", patchSrc) - } - for _, want := range []string{"var Added", "func Old", "func (T) M"} { - if !strings.Contains(patchSrc, want) { - t.Fatalf("expected injected patch declaration %q, got:\n%s", want, patchSrc) - } - } +import "strings" + +var Added = strings.ToUpper("added") + +func Old() string { return "new" } +func (T) M() string { return "new method" } +`) + + assertPatchedPosition(t, string(overlay[injectedPatch]), injectedPatch, patchFile, "package", 1) + assertPatchedPosition(t, string(overlay[injectedPatch]), injectedPatch, patchFile, "var:Added", 7) + assertPatchedPosition(t, string(overlay[injectedPatch]), injectedPatch, patchFile, "func:Old", 9) + assertPatchedPosition(t, string(overlay[injectedPatch]), injectedPatch, patchFile, "method:T.M", 10) }) t.Run("default-override", func(t *testing.T) { @@ -159,12 +170,14 @@ func (T) M() string { return "new method" } pkgPath := "demo" srcDir := filepath.Join(goroot, "src", pkgPath) patchDir := filepath.Join(runtimeDir, "internal", "lib", pkgPath) - mustWriteFile(t, filepath.Join(srcDir, "demo.go"), `package demo + stdFile := filepath.Join(srcDir, "demo.go") + patchFile := filepath.Join(patchDir, "patch.go") + mustWriteFile(t, stdFile, `package demo func Old() string { return "old" } func Keep() string { return "keep" } `) - mustWriteFile(t, filepath.Join(patchDir, "patch.go"), `package demo + mustWriteFile(t, patchFile, `package demo func Old() string { return "new" } func Added() string { return "added" } @@ -178,25 +191,23 @@ func Added() string { return "added" } t.Fatal("expected source patch overlay to change package") } - stdFile := filepath.Join(srcDir, "demo.go") - got := string(overlay[stdFile]) - if strings.Contains(got, "func Old") { - t.Fatalf("expected patch declaration to override Old, got:\n%s", got) - } - if !strings.Contains(got, "func Keep") { - t.Fatalf("expected Keep to remain, got:\n%s", got) - } + assertExactString(t, "filtered stdlib source", string(overlay[stdFile]), ""+ + "package demo\n"+ + "\n"+ + blankNonNewline(`func Old() string { return "old" }`)+"\n"+ + `func Keep() string { return "keep" }`+"\n") - patchFile := filepath.Join(srcDir, "z_llgo_patch_patch.go") - patchSrc := string(overlay[patchFile]) - if strings.Contains(patchSrc, "llgo:skipall") { - t.Fatalf("expected source patch directives to be stripped, got:\n%s", patchSrc) - } - for _, want := range []string{"func Old", "func Added"} { - if !strings.Contains(patchSrc, want) { - t.Fatalf("expected injected patch declaration %q, got:\n%s", want, patchSrc) - } - } + injectedPatch := filepath.Join(srcDir, "z_llgo_patch_patch.go") + assertExactString(t, "injected patch source", string(overlay[injectedPatch]), + sourcePatchLineDirective(patchFile)+`package demo + +func Old() string { return "new" } +func Added() string { return "added" } +`) + + assertPatchedPosition(t, string(overlay[injectedPatch]), injectedPatch, patchFile, "package", 1) + assertPatchedPosition(t, string(overlay[injectedPatch]), injectedPatch, patchFile, "func:Old", 3) + assertPatchedPosition(t, string(overlay[injectedPatch]), injectedPatch, patchFile, "func:Added", 4) }) t.Run("skipall", func(t *testing.T) { @@ -205,11 +216,13 @@ func Added() string { return "added" } pkgPath := "demo" srcDir := filepath.Join(goroot, "src", pkgPath) patchDir := filepath.Join(runtimeDir, "internal", "lib", pkgPath) - mustWriteFile(t, filepath.Join(srcDir, "demo.go"), `package demo + stdFile := filepath.Join(srcDir, "demo.go") + patchFile := filepath.Join(patchDir, "patch.go") + mustWriteFile(t, stdFile, `package demo func Old() string { return "old" } `) - mustWriteFile(t, filepath.Join(patchDir, "patch.go"), `// llgo:skipall + mustWriteFile(t, patchFile, `// llgo:skipall package demo const Only = "patched" @@ -223,20 +236,45 @@ const Only = "patched" t.Fatal("expected source patch overlay to change package") } - stdFile := filepath.Join(srcDir, "demo.go") - got := string(overlay[stdFile]) - if strings.Contains(got, "func Old") { - t.Fatalf("expected skipall to stub original file, got:\n%s", got) + assertExactString(t, "stubbed stdlib source", string(overlay[stdFile]), "package demo\n") + + injectedPatch := filepath.Join(srcDir, "z_llgo_patch_patch.go") + assertExactString(t, "injected patch source", string(overlay[injectedPatch]), + sourcePatchLineDirective(patchFile)+`// llgo_skipall +package demo + +const Only = "patched" +`) + + assertPatchedPosition(t, string(overlay[injectedPatch]), injectedPatch, patchFile, "package", 2) + assertPatchedPosition(t, string(overlay[injectedPatch]), injectedPatch, patchFile, "const:Only", 4) + }) + + t.Run("nopatch", func(t *testing.T) { + goroot := t.TempDir() + runtimeDir := t.TempDir() + pkgPath := "demo" + srcDir := filepath.Join(goroot, "src", pkgPath) + patchDir := filepath.Join(runtimeDir, "internal", "lib", pkgPath) + mustWriteFile(t, filepath.Join(srcDir, "demo.go"), `package demo + +func Old() string { return "old" } +`) + mustWriteFile(t, filepath.Join(patchDir, "patch.go"), `//llgo:nopatch +package demo + +func Old() string { return "new" } +`) + + changed, overlay, err := applySourcePatchForPkg(nil, nil, runtimeDir, goroot, pkgPath) + if err != nil { + t.Fatal(err) } - if !strings.Contains(got, "package demo") { - t.Fatalf("expected package clause to remain, got:\n%s", got) + if changed { + t.Fatal("expected nopatch file to skip source patching") } - - patchFile := filepath.Join(srcDir, "z_llgo_patch_patch.go") - if patchSrc := string(overlay[patchFile]); strings.Contains(patchSrc, "llgo:skipall") { - t.Fatalf("expected source patch directives to be stripped, got:\n%s", patchSrc) - } else if !strings.Contains(patchSrc, `const Only = "patched"`) { - t.Fatalf("expected skipall patch file to be injected, got:\n%s", patchSrc) + if overlay != nil { + t.Fatalf("expected no overlay for nopatch file, got %v entries", len(overlay)) } }) } @@ -309,3 +347,80 @@ func mustWriteFile(t *testing.T, filename, content string) { t.Fatal(err) } } + +func blankNonNewline(s string) string { + var b strings.Builder + b.Grow(len(s)) + for _, r := range s { + switch r { + case '\n', '\r': + b.WriteRune(r) + default: + b.WriteByte(' ') + } + } + return b.String() +} + +func sourcePatchLineDirective(filename string) string { + return "//line " + filepath.ToSlash(filename) + ":1\n" +} + +func assertExactString(t *testing.T, label, got, want string) { + t.Helper() + if got != want { + t.Fatalf("%s mismatch\nwant:\n%q\n\ngot:\n%q", label, want, got) + } +} + +func assertPatchedPosition(t *testing.T, src, generatedFilename, wantFilename, target string, wantLine int) { + t.Helper() + fset := token.NewFileSet() + file, err := parser.ParseFile(fset, generatedFilename, src, parser.ParseComments) + if err != nil { + t.Fatal(err) + } + pos, ok := findPatchedPosition(file, target) + if !ok { + t.Fatalf("target %q not found", target) + } + got := fset.Position(pos) + if filepath.ToSlash(got.Filename) != filepath.ToSlash(wantFilename) || got.Line != wantLine { + t.Fatalf("target %q position mismatch: want %s:%d, got %s:%d", target, filepath.ToSlash(wantFilename), wantLine, filepath.ToSlash(got.Filename), got.Line) + } +} + +func findPatchedPosition(file *ast.File, target string) (token.Pos, bool) { + if target == "package" { + return file.Package, true + } + for _, decl := range file.Decls { + switch decl := decl.(type) { + case *ast.FuncDecl: + key := "func:" + decl.Name.Name + if decl.Recv != nil && len(decl.Recv.List) != 0 { + key = "method:" + recvPatchKey(decl.Recv.List[0].Type) + "." + decl.Name.Name + } + if key == target { + return decl.Name.Pos(), true + } + case *ast.GenDecl: + for _, spec := range decl.Specs { + switch spec := spec.(type) { + case *ast.TypeSpec: + if "type:"+spec.Name.Name == target { + return spec.Name.Pos(), true + } + case *ast.ValueSpec: + kind := strings.ToLower(decl.Tok.String()) + for _, name := range spec.Names { + if kind+":"+name.Name == target { + return name.Pos(), true + } + } + } + } + } + } + return token.NoPos, false +} From 0de323ef048cbec1b6e70f23f987f2be9c3bd82b Mon Sep 17 00:00:00 2001 From: Li Jie Date: Sat, 28 Mar 2026 20:36:24 +0800 Subject: [PATCH 17/44] build: honor build tags in source patches --- internal/build/build.go | 11 ++- internal/build/source_patch.go | 110 ++++++++++++++++++++++++++-- internal/build/source_patch_test.go | 56 ++++++++++++-- internal/env/env.go | 16 ++++ 4 files changed, 177 insertions(+), 16 deletions(-) diff --git a/internal/build/build.go b/internal/build/build.go index 1bc814dba9..2b2609f28d 100644 --- a/internal/build/build.go +++ b/internal/build/build.go @@ -301,7 +301,16 @@ func Do(args []string, conf *Config) ([]Package, error) { if err != nil { return nil, err } - cfg.Overlay, err = buildSourcePatchOverlayForGOROOT(cfg.Overlay, env.LLGoRuntimeDir(), sourcePatchGOROOT) + sourcePatchGoVersion, err := env.GOVERSIONWithEnv(cfg.Env) + if err != nil { + return nil, err + } + cfg.Overlay, err = buildSourcePatchOverlayForGOROOT(cfg.Overlay, env.LLGoRuntimeDir(), sourcePatchGOROOT, sourcePatchBuildContext{ + goos: conf.Goos, + goarch: conf.Goarch, + goversion: sourcePatchGoVersion, + buildFlags: cfg.BuildFlags, + }) if err != nil { return nil, err } diff --git a/internal/build/source_patch.go b/internal/build/source_patch.go index 0ffe08dc92..4ab102c988 100644 --- a/internal/build/source_patch.go +++ b/internal/build/source_patch.go @@ -5,12 +5,14 @@ import ( "errors" "fmt" "go/ast" + "go/build" "go/parser" "go/token" "os" "path/filepath" "runtime" "slices" + "strconv" "strings" "syscall" @@ -29,14 +31,21 @@ func cloneOverlay(src map[string][]byte) map[string][]byte { return dup } +type sourcePatchBuildContext struct { + goos string + goarch string + goversion string + buildFlags []string +} + func buildSourcePatchOverlay(base map[string][]byte, runtimeDir string) (map[string][]byte, error) { - return buildSourcePatchOverlayForGOROOT(base, runtimeDir, runtime.GOROOT()) + return buildSourcePatchOverlayForGOROOT(base, runtimeDir, runtime.GOROOT(), sourcePatchBuildContext{}) } -func buildSourcePatchOverlayForGOROOT(base map[string][]byte, runtimeDir, goroot string) (map[string][]byte, error) { +func buildSourcePatchOverlayForGOROOT(base map[string][]byte, runtimeDir, goroot string, ctx sourcePatchBuildContext) (map[string][]byte, error) { var out map[string][]byte for _, pkgPath := range llruntime.SourcePatchPkgPaths() { - changed, next, err := applySourcePatchForPkg(base, out, runtimeDir, goroot, pkgPath) + changed, next, err := applySourcePatchForPkg(base, out, runtimeDir, goroot, pkgPath, ctx) if err != nil { return nil, err } @@ -51,7 +60,7 @@ func buildSourcePatchOverlayForGOROOT(base map[string][]byte, runtimeDir, goroot return out, nil } -func applySourcePatchForPkg(base, current map[string][]byte, runtimeDir, goroot, pkgPath string) (bool, map[string][]byte, error) { +func applySourcePatchForPkg(base, current map[string][]byte, runtimeDir, goroot, pkgPath string, ctx sourcePatchBuildContext) (bool, map[string][]byte, error) { patchDir := filepath.Join(runtimeDir, "internal", "lib", filepath.FromSlash(pkgPath)) entries, err := os.ReadDir(patchDir) if err != nil { @@ -91,6 +100,10 @@ func applySourcePatchForPkg(base, current map[string][]byte, runtimeDir, goroot, } return os.ReadFile(filename) } + buildCtx, err := newSourcePatchMatchContext(goroot, ctx) + if err != nil { + return false, nil, err + } for _, entry := range entries { if entry.IsDir() { @@ -100,6 +113,13 @@ func applySourcePatchForPkg(base, current map[string][]byte, runtimeDir, goroot, if !strings.HasSuffix(name, ".go") || strings.HasSuffix(name, "_test.go") { continue } + match, err := buildCtx.MatchFile(patchDir, name) + if err != nil { + return false, nil, fmt.Errorf("match source patch file %s: %w", filepath.Join(patchDir, name), err) + } + if !match { + continue + } filename := filepath.Join(patchDir, name) src, err := readOverlay(filename) if err != nil { @@ -191,6 +211,74 @@ func applySourcePatchForPkg(base, current map[string][]byte, runtimeDir, goroot, return changed, out, nil } +func newSourcePatchMatchContext(goroot string, ctx sourcePatchBuildContext) (build.Context, error) { + buildCtx := build.Default + if goroot != "" { + buildCtx.GOROOT = goroot + } + if ctx.goos != "" { + buildCtx.GOOS = ctx.goos + } + if ctx.goarch != "" { + buildCtx.GOARCH = ctx.goarch + } + buildCtx.BuildTags = parseSourcePatchBuildTags(ctx.buildFlags) + if ctx.goversion != "" { + releaseTags, err := releaseTagsForGoVersion(ctx.goversion) + if err != nil { + return build.Context{}, err + } + buildCtx.ReleaseTags = releaseTags + } + return buildCtx, nil +} + +func parseSourcePatchBuildTags(buildFlags []string) []string { + var tags []string + for i := 0; i < len(buildFlags); i++ { + flag := buildFlags[i] + if flag == "-tags" && i+1 < len(buildFlags) { + tags = append(tags, splitSourcePatchBuildTags(buildFlags[i+1])...) + i++ + continue + } + if strings.HasPrefix(flag, "-tags=") { + tags = append(tags, splitSourcePatchBuildTags(strings.TrimPrefix(flag, "-tags="))...) + } + } + return slices.Compact(tags) +} + +func splitSourcePatchBuildTags(s string) []string { + return strings.FieldsFunc(s, func(r rune) bool { + return r == ',' || r == ' ' + }) +} + +func releaseTagsForGoVersion(goVersion string) ([]string, error) { + goVersion = strings.TrimPrefix(goVersion, "go") + parts := strings.Split(goVersion, ".") + if len(parts) < 2 { + return nil, fmt.Errorf("unsupported Go version %q", goVersion) + } + major, err := strconv.Atoi(parts[0]) + if err != nil { + return nil, fmt.Errorf("parse Go major version %q: %w", goVersion, err) + } + minor, err := strconv.Atoi(parts[1]) + if err != nil { + return nil, fmt.Errorf("parse Go minor version %q: %w", goVersion, err) + } + if major != 1 || minor < 1 { + return nil, fmt.Errorf("unsupported Go version %q", goVersion) + } + tags := make([]string, 0, minor) + for v := 1; v <= minor; v++ { + tags = append(tags, fmt.Sprintf("go1.%d", v)) + } + return tags, nil +} + func packageStubSource(src []byte) ([]byte, error) { lines := strings.SplitAfter(string(src), "\n") var buf strings.Builder @@ -285,17 +373,23 @@ func sanitizeSourcePatchDirectiveLines(src []byte) []byte { out := slices.Clone(src) lines := bytes.SplitAfter(out, []byte{'\n'}) changed := false + markDirective := func(line []byte, prefix []byte) bool { + idx := bytes.Index(line, prefix) + if idx < 0 { + return false + } + line[idx+len(prefix)-1] = '_' + return true + } for _, line := range lines { trimmed := strings.TrimSpace(string(line)) if _, _, _, ok := parseSourcePatchDirective(trimmed); !ok { continue } switch { - case bytes.Contains(line, []byte("//llgo:")): - copy(line, bytes.Replace(line, []byte("//llgo:"), []byte("//llgo_"), 1)) + case markDirective(line, []byte("//llgo:")): changed = true - case bytes.Contains(line, []byte("// llgo:")): - copy(line, bytes.Replace(line, []byte("// llgo:"), []byte("// llgo_"), 1)) + case markDirective(line, []byte("// llgo:")): changed = true } } diff --git a/internal/build/source_patch_test.go b/internal/build/source_patch_test.go index ab88cb1be7..3ab797c0e6 100644 --- a/internal/build/source_patch_test.go +++ b/internal/build/source_patch_test.go @@ -15,7 +15,7 @@ import ( ) func TestBuildSourcePatchOverlayForIter(t *testing.T) { - overlay, err := buildSourcePatchOverlayForGOROOT(nil, env.LLGoRuntimeDir(), runtime.GOROOT()) + overlay, err := buildSourcePatchOverlayForGOROOT(nil, env.LLGoRuntimeDir(), runtime.GOROOT(), sourcePatchBuildContext{}) if err != nil { t.Fatal(err) } @@ -121,7 +121,7 @@ func Old() string { return "new" } func (T) M() string { return "new method" } `) - changed, overlay, err := applySourcePatchForPkg(nil, nil, runtimeDir, goroot, pkgPath) + changed, overlay, err := applySourcePatchForPkg(nil, nil, runtimeDir, goroot, pkgPath, sourcePatchBuildContext{}) if err != nil { t.Fatal(err) } @@ -183,7 +183,7 @@ func Old() string { return "new" } func Added() string { return "added" } `) - changed, overlay, err := applySourcePatchForPkg(nil, nil, runtimeDir, goroot, pkgPath) + changed, overlay, err := applySourcePatchForPkg(nil, nil, runtimeDir, goroot, pkgPath, sourcePatchBuildContext{}) if err != nil { t.Fatal(err) } @@ -228,7 +228,7 @@ package demo const Only = "patched" `) - changed, overlay, err := applySourcePatchForPkg(nil, nil, runtimeDir, goroot, pkgPath) + changed, overlay, err := applySourcePatchForPkg(nil, nil, runtimeDir, goroot, pkgPath, sourcePatchBuildContext{}) if err != nil { t.Fatal(err) } @@ -266,7 +266,7 @@ package demo func Old() string { return "new" } `) - changed, overlay, err := applySourcePatchForPkg(nil, nil, runtimeDir, goroot, pkgPath) + changed, overlay, err := applySourcePatchForPkg(nil, nil, runtimeDir, goroot, pkgPath, sourcePatchBuildContext{}) if err != nil { t.Fatal(err) } @@ -291,7 +291,7 @@ func TestApplySourcePatchForPkg_MissingStdlibPkg(t *testing.T) { func Pull[V any](seq func(func(V) bool)) {} `) - changed, overlay, err := applySourcePatchForPkg(nil, nil, runtimeDir, goroot, pkgPath) + changed, overlay, err := applySourcePatchForPkg(nil, nil, runtimeDir, goroot, pkgPath, sourcePatchBuildContext{}) if err != nil { t.Fatal(err) } @@ -303,6 +303,48 @@ func Pull[V any](seq func(func(V) bool)) {} } } +func TestApplySourcePatchForPkg_BuildTaggedPatch(t *testing.T) { + goroot := t.TempDir() + runtimeDir := t.TempDir() + pkgPath := "demo" + srcDir := filepath.Join(goroot, "src", pkgPath) + patchDir := filepath.Join(runtimeDir, "internal", "lib", pkgPath) + mustWriteFile(t, filepath.Join(srcDir, "demo.go"), `package demo + +func Old() string { return "old" } +`) + mustWriteFile(t, filepath.Join(patchDir, "patch.go"), `//go:build go1.26 +//llgo:skipall +package demo + +const Only = "patched" +`) + + changed, overlay, err := applySourcePatchForPkg(nil, nil, runtimeDir, goroot, pkgPath, sourcePatchBuildContext{ + goos: runtime.GOOS, + goarch: runtime.GOARCH, + goversion: "go1.24.11", + }) + if err != nil { + t.Fatal(err) + } + if changed { + t.Fatalf("expected go1.26-tagged patch to be ignored on go1.24, got overlay: %#v", overlay) + } + + changed, overlay, err = applySourcePatchForPkg(nil, nil, runtimeDir, goroot, pkgPath, sourcePatchBuildContext{ + goos: runtime.GOOS, + goarch: runtime.GOARCH, + goversion: "go1.26.0", + }) + if err != nil { + t.Fatal(err) + } + if !changed { + t.Fatal("expected go1.26-tagged patch to apply on go1.26") + } +} + func TestApplySourcePatchForPkg_UnreadableStdlibPkg(t *testing.T) { if runtime.GOOS == "windows" { t.Skip("chmod-based permission test is Unix-only") @@ -326,7 +368,7 @@ func TestApplySourcePatchForPkg_UnreadableStdlibPkg(t *testing.T) { func Pull[V any](seq func(func(V) bool)) {} `) - changed, overlay, err := applySourcePatchForPkg(nil, nil, runtimeDir, goroot, pkgPath) + changed, overlay, err := applySourcePatchForPkg(nil, nil, runtimeDir, goroot, pkgPath, sourcePatchBuildContext{}) if err != nil { t.Fatal(err) } diff --git a/internal/env/env.go b/internal/env/env.go index 9da5ae4869..8af6da65e1 100644 --- a/internal/env/env.go +++ b/internal/env/env.go @@ -37,6 +37,22 @@ func GOROOTWithEnv(env []string) (string, error) { return strings.TrimSpace(out.String()), nil } +func GOVERSIONWithEnv(env []string) (string, error) { + cmd := exec.Command("go", "env", "GOVERSION") + if len(env) != 0 { + cmd.Env = env + } + var out bytes.Buffer + var buf bytes.Buffer + cmd.Stdout = &out + cmd.Stderr = &buf + err := cmd.Run() + if err != nil { + return "", fmt.Errorf("%s, %w", buf.String(), err) + } + return strings.TrimSpace(out.String()), nil +} + func LLGoCacheDir() string { userCacheDir, err := os.UserCacheDir() if err != nil { From 730a986503d5646d2a7ae66917585fefbd8f5069 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Sat, 28 Mar 2026 21:49:19 +0800 Subject: [PATCH 18/44] runtime: restore maps field comments --- .../internal/lib/internal/runtime/maps/maps.go | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/runtime/internal/lib/internal/runtime/maps/maps.go b/runtime/internal/lib/internal/runtime/maps/maps.go index b035f6e5a0..382f6bd6f0 100644 --- a/runtime/internal/lib/internal/runtime/maps/maps.go +++ b/runtime/internal/lib/internal/runtime/maps/maps.go @@ -36,14 +36,14 @@ type Type = abi.Type type SwissMapType struct { Type - Key *Type - Elem *Type - Group *Type - Hasher func(unsafe.Pointer, uintptr) uintptr - - GroupSize uintptr - SlotSize uintptr - ElemOff uintptr + Key *Type + Elem *Type + Group *Type // internal type representing a slot group + // function for hashing keys (ptr to key, seed) -> hash + Hasher func(unsafe.Pointer, uintptr) uintptr + GroupSize uintptr // == Group.Size_ + SlotSize uintptr // size of key/elem slot + ElemOff uintptr // offset of elem in key/elem slot Flags uint32 } From beda8b0bc57ac15a458ad7db1f188a5062b6a446 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Sat, 28 Mar 2026 21:57:24 +0800 Subject: [PATCH 19/44] build: drop source patch nopatch directive --- internal/build/source_patch.go | 32 ++++++++-------------- internal/build/source_patch_test.go | 27 ------------------ runtime/internal/lib/sync/atomic/atomic.go | 2 -- runtime/internal/lib/sync/atomic/type.go | 2 -- 4 files changed, 11 insertions(+), 52 deletions(-) diff --git a/internal/build/source_patch.go b/internal/build/source_patch.go index 4ab102c988..a48c8d6a5e 100644 --- a/internal/build/source_patch.go +++ b/internal/build/source_patch.go @@ -129,9 +129,6 @@ func applySourcePatchForPkg(base, current map[string][]byte, runtimeDir, goroot, if err != nil { return false, nil, fmt.Errorf("parse source patch directives %s: %w", filename, err) } - if directives.noPatch { - continue - } patchSrcs[name] = buildInjectedSourcePatchFile(filename, src) if directives.skipAll { skipAll = true @@ -292,7 +289,6 @@ func packageStubSource(src []byte) ([]byte, error) { } type sourcePatchDirectives struct { - noPatch bool skipAll bool skips map[string]struct{} } @@ -307,11 +303,10 @@ func collectSourcePatchDirectives(src []byte) (sourcePatchDirectives, error) { for _, group := range file.Comments { for _, comment := range group.List { line := strings.TrimSpace(comment.Text) - noPatch, skipAll, names, ok := parseSourcePatchDirective(line) + skipAll, names, ok := parseSourcePatchDirective(line) if !ok { continue } - d.noPatch = d.noPatch || noPatch if skipAll { d.skipAll = true } @@ -320,11 +315,9 @@ func collectSourcePatchDirectives(src []byte) (sourcePatchDirectives, error) { } } } - if !d.noPatch { - for _, decl := range file.Decls { - for _, name := range declPatchKeys(decl) { - d.skips[name] = struct{}{} - } + for _, decl := range file.Decls { + for _, name := range declPatchKeys(decl) { + d.skips[name] = struct{}{} } } return d, nil @@ -333,20 +326,19 @@ func collectSourcePatchDirectives(src []byte) (sourcePatchDirectives, error) { // parseSourcePatchDirective recognizes build-time source-patch directives. // // Supported directives: -// - //llgo:nopatch: ignore this file during source-patch injection // - //llgo:skipall: blank every stdlib .go file in the patched package // - //llgo:skip A B: blank the named declarations from the stdlib package view // // Unlike cl/import.go directives, these are consumed only while constructing the // load-time overlay and are rewritten to plain comments before type checking. -func parseSourcePatchDirective(line string) (noPatch, skipAll bool, names []string, ok bool) { +func parseSourcePatchDirective(line string) (skipAll bool, names []string, ok bool) { const ( llgo1 = "//llgo:" llgo2 = "// llgo:" go1 = "//go:" ) if strings.HasPrefix(line, go1) { - return false, false, nil, false + return false, nil, false } var tail string switch { @@ -355,17 +347,15 @@ func parseSourcePatchDirective(line string) (noPatch, skipAll bool, names []stri case strings.HasPrefix(line, llgo2): tail = line[len(llgo2):] default: - return false, false, nil, false + return false, nil, false } switch { - case tail == "nopatch": - return true, false, nil, true case tail == "skipall": - return false, true, nil, true + return true, nil, true case strings.HasPrefix(tail, "skip "): - return false, false, strings.Fields(tail[len("skip "):]), true + return false, strings.Fields(tail[len("skip "):]), true default: - return false, false, nil, false + return false, nil, false } } @@ -383,7 +373,7 @@ func sanitizeSourcePatchDirectiveLines(src []byte) []byte { } for _, line := range lines { trimmed := strings.TrimSpace(string(line)) - if _, _, _, ok := parseSourcePatchDirective(trimmed); !ok { + if _, _, ok := parseSourcePatchDirective(trimmed); !ok { continue } switch { diff --git a/internal/build/source_patch_test.go b/internal/build/source_patch_test.go index 3ab797c0e6..ff33da59ad 100644 --- a/internal/build/source_patch_test.go +++ b/internal/build/source_patch_test.go @@ -250,33 +250,6 @@ const Only = "patched" assertPatchedPosition(t, string(overlay[injectedPatch]), injectedPatch, patchFile, "const:Only", 4) }) - t.Run("nopatch", func(t *testing.T) { - goroot := t.TempDir() - runtimeDir := t.TempDir() - pkgPath := "demo" - srcDir := filepath.Join(goroot, "src", pkgPath) - patchDir := filepath.Join(runtimeDir, "internal", "lib", pkgPath) - mustWriteFile(t, filepath.Join(srcDir, "demo.go"), `package demo - -func Old() string { return "old" } -`) - mustWriteFile(t, filepath.Join(patchDir, "patch.go"), `//llgo:nopatch -package demo - -func Old() string { return "new" } -`) - - changed, overlay, err := applySourcePatchForPkg(nil, nil, runtimeDir, goroot, pkgPath, sourcePatchBuildContext{}) - if err != nil { - t.Fatal(err) - } - if changed { - t.Fatal("expected nopatch file to skip source patching") - } - if overlay != nil { - t.Fatalf("expected no overlay for nopatch file, got %v entries", len(overlay)) - } - }) } func TestApplySourcePatchForPkg_MissingStdlibPkg(t *testing.T) { diff --git a/runtime/internal/lib/sync/atomic/atomic.go b/runtime/internal/lib/sync/atomic/atomic.go index 4ca3fc2f10..358b51935a 100644 --- a/runtime/internal/lib/sync/atomic/atomic.go +++ b/runtime/internal/lib/sync/atomic/atomic.go @@ -14,8 +14,6 @@ * limitations under the License. */ -// llgo:nopatch - package atomic import ( diff --git a/runtime/internal/lib/sync/atomic/type.go b/runtime/internal/lib/sync/atomic/type.go index 19ae8cc785..117de37ec1 100644 --- a/runtime/internal/lib/sync/atomic/type.go +++ b/runtime/internal/lib/sync/atomic/type.go @@ -1,5 +1,3 @@ -// llgo:nopatch - package atomic // An Int64 is an atomic int64. The zero value is zero. From 46822e8d5dfbb197aae9148421f2581cfab84524 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Sat, 28 Mar 2026 22:22:07 +0800 Subject: [PATCH 20/44] runtime: keep unique changes off source patch proto --- runtime/abi/helpers.go | 54 ------ runtime/internal/lib/unique/clone.go | 2 - runtime/internal/lib/unique/handle.go | 231 -------------------------- runtime/internal/lib/unique/unique.go | 6 + 4 files changed, 6 insertions(+), 287 deletions(-) delete mode 100644 runtime/abi/helpers.go delete mode 100644 runtime/internal/lib/unique/handle.go create mode 100644 runtime/internal/lib/unique/unique.go diff --git a/runtime/abi/helpers.go b/runtime/abi/helpers.go deleted file mode 100644 index 85fb1a367b..0000000000 --- a/runtime/abi/helpers.go +++ /dev/null @@ -1,54 +0,0 @@ -/* - * Copyright (c) 2024 The XGo Authors (xgo.dev). All rights reserved. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package abi - -import "unsafe" - -func NoEscape(p unsafe.Pointer) unsafe.Pointer { - x := uintptr(p) - return unsafe.Pointer(x ^ 0) -} - -type EmptyInterface struct { - Type *Type - Data unsafe.Pointer -} - -// TypeOf returns the runtime Type of some value. -func TypeOf(a any) *Type { - eface := *(*EmptyInterface)(unsafe.Pointer(&a)) - return (*Type)(NoEscape(unsafe.Pointer(eface.Type))) -} - -// TypeFor returns the runtime Type for a type parameter. -func TypeFor[T any]() *Type { - var v T - if t := TypeOf(v); t != nil { - return t - } - return TypeOf((*T)(nil)).Elem() -} - -// EscapeNonString is modeled by the compiler. -func EscapeNonString[T any](v T) { -} - -// EscapeToResultNonString models a data-flow edge to the result. -func EscapeToResultNonString[T any](v T) T { - EscapeNonString(v) - return *(*T)(NoEscape(unsafe.Pointer(&v))) -} diff --git a/runtime/internal/lib/unique/clone.go b/runtime/internal/lib/unique/clone.go index 626790dd95..4211c8dd12 100644 --- a/runtime/internal/lib/unique/clone.go +++ b/runtime/internal/lib/unique/clone.go @@ -2,8 +2,6 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -// llgo:skipall - package unique import ( diff --git a/runtime/internal/lib/unique/handle.go b/runtime/internal/lib/unique/handle.go deleted file mode 100644 index d7ddabe4c1..0000000000 --- a/runtime/internal/lib/unique/handle.go +++ /dev/null @@ -1,231 +0,0 @@ -// Copyright 2024 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -// llgo:skipall - -package unique - -import ( - "runtime" - "sync" - "unsafe" - "weak" - - "github.com/goplus/llgo/runtime/abi" -) - -var zero uintptr - -// Handle is a globally unique identity for some value of type T. -// -// Two handles compare equal exactly if the two values used to create the handles -// would have also compared equal. The comparison of two handles is trivial and -// typically much more efficient than comparing the values used to create them. -type Handle[T comparable] struct { - value *T -} - -// Value returns a shallow copy of the T value that produced the Handle. -// Value is safe for concurrent use by multiple goroutines. -func (h Handle[T]) Value() T { - return *h.value -} - -// Make returns a globally unique handle for a value of type T. Handles -// are equal if and only if the values used to produce them are equal. -// Make is safe for concurrent use by multiple goroutines. -func Make[T comparable](value T) Handle[T] { - typ := abi.TypeFor[T]() - if typ.Size() == 0 { - return Handle[T]{(*T)(unsafe.Pointer(&zero))} - } - ma, ok := loadUniqueMap(typ) - if !ok { - ensureSetupMake() - ma = addUniqueMap[T](typ) - } - m := ma.(*uniqueMap[T]) - - var ( - toInsert *T - toInsertWeak weak.Pointer[T] - ) - newValue := func() (T, weak.Pointer[T]) { - if toInsert == nil { - toInsert = new(T) - *toInsert = clone(value, &m.cloneSeq) - toInsertWeak = weak.Make(toInsert) - } - return *toInsert, toInsertWeak - } - var ptr *T - for { - wp, ok := m.Load(value) - if !ok { - k, v := newValue() - wp, _ = m.LoadOrStore(k, v) - } - ptr = wp.Value() - if ptr != nil { - break - } - m.CompareAndDelete(value, wp) - } - runtime.KeepAlive(toInsert) - return Handle[T]{ptr} -} - -var ( - uniqueMapsMu sync.Mutex - uniqueMaps map[*abi.Type]any - - cleanupMu sync.Mutex - cleanupFuncsMu sync.Mutex - cleanupFuncs []func() - cleanupNotify []func() -) - -type uniqueMap[T comparable] struct { - mu sync.Mutex - m map[T]weak.Pointer[T] - cloneSeq -} - -type uniqueEntry[T comparable] struct { - key T - value weak.Pointer[T] -} - -func addUniqueMap[T comparable](typ *abi.Type) *uniqueMap[T] { - m := &uniqueMap[T]{ - m: make(map[T]weak.Pointer[T]), - cloneSeq: makeCloneSeq(typ), - } - a, loaded := loadOrStoreUniqueMap(typ, m) - if !loaded { - cleanupFuncsMu.Lock() - cleanupFuncs = append(cleanupFuncs, func() { - m.All()(func(key T, wp weak.Pointer[T]) bool { - if wp.Value() == nil { - m.CompareAndDelete(key, wp) - } - return true - }) - }) - cleanupFuncsMu.Unlock() - } - return a.(*uniqueMap[T]) -} - -var ( - setupMakeMu sync.Mutex - setupMade bool -) - -func ensureSetupMake() { - setupMakeMu.Lock() - if !setupMade { - registerCleanup() - setupMade = true - } - setupMakeMu.Unlock() -} - -func loadUniqueMap(typ *abi.Type) (any, bool) { - uniqueMapsMu.Lock() - if uniqueMaps == nil { - uniqueMapsMu.Unlock() - return nil, false - } - v, ok := uniqueMaps[typ] - uniqueMapsMu.Unlock() - return v, ok -} - -func loadOrStoreUniqueMap(typ *abi.Type, value any) (any, bool) { - uniqueMapsMu.Lock() - if uniqueMaps == nil { - uniqueMaps = make(map[*abi.Type]any) - } - if existing, ok := uniqueMaps[typ]; ok { - uniqueMapsMu.Unlock() - return existing, true - } - uniqueMaps[typ] = value - uniqueMapsMu.Unlock() - return value, false -} - -func (m *uniqueMap[T]) Load(key T) (weak.Pointer[T], bool) { - m.mu.Lock() - v, ok := m.m[key] - m.mu.Unlock() - if !ok { - var zero weak.Pointer[T] - return zero, false - } - return v, true -} - -func (m *uniqueMap[T]) LoadOrStore(key T, value weak.Pointer[T]) (weak.Pointer[T], bool) { - m.mu.Lock() - if existing, ok := m.m[key]; ok { - m.mu.Unlock() - return existing, true - } - m.m[key] = value - m.mu.Unlock() - return value, false -} - -func (m *uniqueMap[T]) CompareAndDelete(key T, old weak.Pointer[T]) bool { - m.mu.Lock() - defer m.mu.Unlock() - v, ok := m.m[key] - if !ok || v != old { - return false - } - delete(m.m, key) - return true -} - -func (m *uniqueMap[T]) All() func(func(T, weak.Pointer[T]) bool) { - return func(yield func(T, weak.Pointer[T]) bool) { - m.mu.Lock() - items := make([]uniqueEntry[T], 0, len(m.m)) - for k, v := range m.m { - items = append(items, uniqueEntry[T]{key: k, value: v}) - } - m.mu.Unlock() - for _, item := range items { - if !yield(item.key, item.value) { - return - } - } - } -} - -func registerCleanup() { - runtime_registerUniqueMapCleanup(func() { - cleanupMu.Lock() - - cleanupFuncsMu.Lock() - cf := cleanupFuncs - cleanupFuncsMu.Unlock() - - for _, f := range cf { - f() - } - - for _, f := range cleanupNotify { - f() - } - cleanupNotify = nil - - cleanupMu.Unlock() - }) -} - -//go:linkname runtime_registerUniqueMapCleanup -func runtime_registerUniqueMapCleanup(cleanup func()) diff --git a/runtime/internal/lib/unique/unique.go b/runtime/internal/lib/unique/unique.go new file mode 100644 index 0000000000..faaee1b155 --- /dev/null +++ b/runtime/internal/lib/unique/unique.go @@ -0,0 +1,6 @@ +package unique + +import _ "unsafe" + +//go:linkname runtime_registerUniqueMapCleanup +func runtime_registerUniqueMapCleanup(cleanup func()) From b4e2d6007e74736143eab952f8cee706df2c5acb Mon Sep 17 00:00:00 2001 From: Li Jie Date: Sat, 28 Mar 2026 22:27:23 +0800 Subject: [PATCH 21/44] runtime: drop sync atomic skip from source patch proto --- runtime/internal/lib/sync/atomic/value.go | 2 -- 1 file changed, 2 deletions(-) diff --git a/runtime/internal/lib/sync/atomic/value.go b/runtime/internal/lib/sync/atomic/value.go index 61ba14b550..498b40b4e3 100644 --- a/runtime/internal/lib/sync/atomic/value.go +++ b/runtime/internal/lib/sync/atomic/value.go @@ -2,8 +2,6 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. -// llgo:skip runtime_procPin runtime_procUnpin - package atomic import ( From f81b1517a5e59b5d9923eac13a92e4707525a60e Mon Sep 17 00:00:00 2001 From: Li Jie Date: Sun, 29 Mar 2026 09:36:10 +0800 Subject: [PATCH 22/44] build: simplify source patch diagnostics --- internal/build/source_patch.go | 59 ++++++++++++++++++++++------- internal/build/source_patch_test.go | 24 +++--------- 2 files changed, 50 insertions(+), 33 deletions(-) diff --git a/internal/build/source_patch.go b/internal/build/source_patch.go index a48c8d6a5e..e8be0eccf6 100644 --- a/internal/build/source_patch.go +++ b/internal/build/source_patch.go @@ -326,8 +326,8 @@ func collectSourcePatchDirectives(src []byte) (sourcePatchDirectives, error) { // parseSourcePatchDirective recognizes build-time source-patch directives. // // Supported directives: -// - //llgo:skipall: blank every stdlib .go file in the patched package -// - //llgo:skip A B: blank the named declarations from the stdlib package view +// - //llgo:skipall: clear every stdlib .go file in the patched package to a package stub +// - //llgo:skip A B: comment the named declarations from the stdlib package view // // Unlike cl/import.go directives, these are consumed only while constructing the // load-time overlay and are rewritten to plain comments before type checking. @@ -433,7 +433,7 @@ func filterSourcePatchFile(src []byte, skips map[string]struct{}) ([]byte, bool, if len(spans) == 0 { return src, false, nil } - return blankSourcePatchSpans(src, spans), true, nil + return commentSourcePatchSpans(src, spans), true, nil } type sourcePatchSpan struct { @@ -590,11 +590,11 @@ func nodeSpan(tokFile *token.File, node ast.Node) sourcePatchSpan { } } -func blankSourcePatchSpans(src []byte, spans []sourcePatchSpan) []byte { - out := slices.Clone(src) +func commentSourcePatchSpans(src []byte, spans []sourcePatchSpan) []byte { if len(spans) == 0 { - return out + return slices.Clone(src) } + out := make([]byte, 0, len(src)+len(spans)*4) slices.SortFunc(spans, func(a, b sourcePatchSpan) int { switch { case a.start < b.start: @@ -614,8 +614,8 @@ func blankSourcePatchSpans(src []byte, spans []sourcePatchSpan) []byte { if span.start < 0 { span.start = 0 } - if span.end > len(out) { - span.end = len(out) + if span.end > len(src) { + span.end = len(src) } if span.start >= span.end { continue @@ -628,18 +628,49 @@ func blankSourcePatchSpans(src []byte, spans []sourcePatchSpan) []byte { merged[len(merged)-1].end = span.end } } + cursor := 0 for _, span := range merged { - for i := span.start; i < span.end; i++ { - switch out[i] { - case '\n', '\r': - default: - out[i] = ' ' - } + if span.start > cursor { + out = append(out, src[cursor:span.start]...) } + out = appendCommentedSourcePatchSpan(out, src[span.start:span.end]) + cursor = span.end } + out = append(out, src[cursor:]...) return out } +func appendCommentedSourcePatchSpan(dst, src []byte) []byte { + lines := bytes.SplitAfter(src, []byte{'\n'}) + for _, line := range lines { + if len(line) == 0 { + continue + } + newline := len(line) + if line[newline-1] == '\n' { + newline-- + } + body := line[:newline] + suffix := line[newline:] + if len(bytes.TrimSpace(body)) == 0 { + dst = append(dst, line...) + continue + } + indent := 0 + for indent < len(body) && (body[indent] == ' ' || body[indent] == '\t') { + indent++ + } + dst = append(dst, body[:indent]...) + dst = append(dst, '/', '/') + if indent < len(body) { + dst = append(dst, ' ') + dst = append(dst, body[indent:]...) + } + dst = append(dst, suffix...) + } + return dst +} + func collectSpecComments(spec ast.Spec) []*ast.CommentGroup { switch spec := spec.(type) { case *ast.TypeSpec: diff --git a/internal/build/source_patch_test.go b/internal/build/source_patch_test.go index ff33da59ad..821760f4d3 100644 --- a/internal/build/source_patch_test.go +++ b/internal/build/source_patch_test.go @@ -132,17 +132,17 @@ func (T) M() string { return "new method" } assertExactString(t, "filtered stdlib source", string(overlay[stdFile]), ""+ "package demo\n"+ "\n"+ - blankNonNewline(`import "fmt"`)+"\n"+ + `// import "fmt"`+"\n"+ "\n"+ `const Keep = "keep"`+"\n"+ "\n"+ - blankNonNewline(`var Drop = fmt.Sprint("drop")`)+"\n"+ + `// var Drop = fmt.Sprint("drop")`+"\n"+ "\n"+ `type T struct{}`+"\n"+ "\n"+ - blankNonNewline(`func Old() string { return fmt.Sprint("old") }`)+"\n"+ + `// func Old() string { return fmt.Sprint("old") }`+"\n"+ `func KeepFn() string { return Keep }`+"\n"+ - blankNonNewline(`func (T) M() string { return fmt.Sprint("old method") }`)+"\n") + `// func (T) M() string { return fmt.Sprint("old method") }`+"\n") injectedPatch := filepath.Join(srcDir, "z_llgo_patch_patch.go") assertExactString(t, "injected patch source", string(overlay[injectedPatch]), @@ -194,7 +194,7 @@ func Added() string { return "added" } assertExactString(t, "filtered stdlib source", string(overlay[stdFile]), ""+ "package demo\n"+ "\n"+ - blankNonNewline(`func Old() string { return "old" }`)+"\n"+ + `// func Old() string { return "old" }`+"\n"+ `func Keep() string { return "keep" }`+"\n") injectedPatch := filepath.Join(srcDir, "z_llgo_patch_patch.go") @@ -363,20 +363,6 @@ func mustWriteFile(t *testing.T, filename, content string) { } } -func blankNonNewline(s string) string { - var b strings.Builder - b.Grow(len(s)) - for _, r := range s { - switch r { - case '\n', '\r': - b.WriteRune(r) - default: - b.WriteByte(' ') - } - } - return b.String() -} - func sourcePatchLineDirective(filename string) string { return "//line " + filepath.ToSlash(filename) + ":1\n" } From ee679ac011ef7e9e7acb0217c977ab818ec580b1 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Sun, 29 Mar 2026 10:39:38 +0800 Subject: [PATCH 23/44] build: add case-based source patch fixtures --- internal/build/source_patch.go | 2 +- internal/build/source_patch_test.go | 378 ++++++++++-------- .../default-override/output/demo/demo.go | 4 + .../output/demo/z_llgo_patch_patch.go | 5 + .../default-override/patch/demo/patch.go | 4 + .../_test/default-override/pkg/demo/demo.go | 4 + .../_test/multi-file-skipall/output/demo/a.go | 1 + .../_test/multi-file-skipall/output/demo/b.go | 1 + .../output/demo/z_llgo_patch_a.go | 5 + .../output/demo/z_llgo_patch_b.go | 4 + .../_test/multi-file-skipall/patch/demo/a.go | 4 + .../_test/multi-file-skipall/patch/demo/b.go | 3 + .../_test/multi-file-skipall/pkg/demo/a.go | 3 + .../_test/multi-file-skipall/pkg/demo/b.go | 3 + .../multi-file-with-asm/output/demo/a.go | 9 + .../multi-file-with-asm/output/demo/b.go | 4 + .../output/demo/z_llgo_patch_a.go | 10 + .../output/demo/z_llgo_patch_b.go | 5 + .../_test/multi-file-with-asm/patch/demo/a.go | 9 + .../_test/multi-file-with-asm/patch/demo/b.go | 4 + .../_test/multi-file-with-asm/pkg/demo/a.go | 9 + .../_test/multi-file-with-asm/pkg/demo/asm.s | 2 + .../_test/multi-file-with-asm/pkg/demo/b.go | 4 + .../skip-and-override/output/demo/demo.go | 13 + .../output/demo/z_llgo_patch_patch.go | 11 + .../skip-and-override/patch/demo/patch.go | 10 + .../_test/skip-and-override/pkg/demo/demo.go | 13 + .../_patch/_test/skipall/output/demo/demo.go | 1 + .../skipall/output/demo/z_llgo_patch_patch.go | 5 + .../_patch/_test/skipall/patch/demo/patch.go | 4 + runtime/_patch/_test/skipall/pkg/demo/demo.go | 3 + runtime/{internal/lib => _patch}/iter/iter.go | 0 32 files changed, 368 insertions(+), 169 deletions(-) create mode 100644 runtime/_patch/_test/default-override/output/demo/demo.go create mode 100644 runtime/_patch/_test/default-override/output/demo/z_llgo_patch_patch.go create mode 100644 runtime/_patch/_test/default-override/patch/demo/patch.go create mode 100644 runtime/_patch/_test/default-override/pkg/demo/demo.go create mode 100644 runtime/_patch/_test/multi-file-skipall/output/demo/a.go create mode 100644 runtime/_patch/_test/multi-file-skipall/output/demo/b.go create mode 100644 runtime/_patch/_test/multi-file-skipall/output/demo/z_llgo_patch_a.go create mode 100644 runtime/_patch/_test/multi-file-skipall/output/demo/z_llgo_patch_b.go create mode 100644 runtime/_patch/_test/multi-file-skipall/patch/demo/a.go create mode 100644 runtime/_patch/_test/multi-file-skipall/patch/demo/b.go create mode 100644 runtime/_patch/_test/multi-file-skipall/pkg/demo/a.go create mode 100644 runtime/_patch/_test/multi-file-skipall/pkg/demo/b.go create mode 100644 runtime/_patch/_test/multi-file-with-asm/output/demo/a.go create mode 100644 runtime/_patch/_test/multi-file-with-asm/output/demo/b.go create mode 100644 runtime/_patch/_test/multi-file-with-asm/output/demo/z_llgo_patch_a.go create mode 100644 runtime/_patch/_test/multi-file-with-asm/output/demo/z_llgo_patch_b.go create mode 100644 runtime/_patch/_test/multi-file-with-asm/patch/demo/a.go create mode 100644 runtime/_patch/_test/multi-file-with-asm/patch/demo/b.go create mode 100644 runtime/_patch/_test/multi-file-with-asm/pkg/demo/a.go create mode 100644 runtime/_patch/_test/multi-file-with-asm/pkg/demo/asm.s create mode 100644 runtime/_patch/_test/multi-file-with-asm/pkg/demo/b.go create mode 100644 runtime/_patch/_test/skip-and-override/output/demo/demo.go create mode 100644 runtime/_patch/_test/skip-and-override/output/demo/z_llgo_patch_patch.go create mode 100644 runtime/_patch/_test/skip-and-override/patch/demo/patch.go create mode 100644 runtime/_patch/_test/skip-and-override/pkg/demo/demo.go create mode 100644 runtime/_patch/_test/skipall/output/demo/demo.go create mode 100644 runtime/_patch/_test/skipall/output/demo/z_llgo_patch_patch.go create mode 100644 runtime/_patch/_test/skipall/patch/demo/patch.go create mode 100644 runtime/_patch/_test/skipall/pkg/demo/demo.go rename runtime/{internal/lib => _patch}/iter/iter.go (100%) diff --git a/internal/build/source_patch.go b/internal/build/source_patch.go index e8be0eccf6..bb04943690 100644 --- a/internal/build/source_patch.go +++ b/internal/build/source_patch.go @@ -61,7 +61,7 @@ func buildSourcePatchOverlayForGOROOT(base map[string][]byte, runtimeDir, goroot } func applySourcePatchForPkg(base, current map[string][]byte, runtimeDir, goroot, pkgPath string, ctx sourcePatchBuildContext) (bool, map[string][]byte, error) { - patchDir := filepath.Join(runtimeDir, "internal", "lib", filepath.FromSlash(pkgPath)) + patchDir := filepath.Join(runtimeDir, "_patch", filepath.FromSlash(pkgPath)) entries, err := os.ReadDir(patchDir) if err != nil { if os.IsNotExist(err) { diff --git a/internal/build/source_patch_test.go b/internal/build/source_patch_test.go index 821760f4d3..e09c3131ac 100644 --- a/internal/build/source_patch_test.go +++ b/internal/build/source_patch_test.go @@ -4,9 +4,11 @@ import ( "go/ast" "go/parser" "go/token" + "io/fs" "os" "path/filepath" "runtime" + "sort" "strings" "testing" @@ -29,7 +31,7 @@ func TestBuildSourcePatchOverlayForIter(t *testing.T) { if !strings.Contains(string(patchSrc), "func Pull[V any]") { t.Fatalf("source patch file %s does not contain iter replacement", patchFile) } - if !strings.HasPrefix(string(patchSrc), sourcePatchLineDirective(filepath.Join(env.LLGoRuntimeDir(), "internal", "lib", "iter", "iter.go"))) { + if !strings.HasPrefix(string(patchSrc), sourcePatchLineDirective(filepath.Join(env.LLGoRuntimeDir(), "_patch", "iter", "iter.go"))) { t.Fatalf("source patch file %s is missing line directive, got:\n%s", patchFile, patchSrc) } @@ -86,177 +88,25 @@ func TestInternalRuntimeSysRemainsAltPkg(t *testing.T) { } } -func TestApplySourcePatchForPkg_Directives(t *testing.T) { - t.Run("skip-and-override", func(t *testing.T) { - goroot := t.TempDir() - runtimeDir := t.TempDir() - pkgPath := "demo" - srcDir := filepath.Join(goroot, "src", pkgPath) - patchDir := filepath.Join(runtimeDir, "internal", "lib", pkgPath) - stdFile := filepath.Join(srcDir, "demo.go") - patchFile := filepath.Join(patchDir, "patch.go") - mustWriteFile(t, stdFile, `package demo - -import "fmt" - -const Keep = "keep" - -var Drop = fmt.Sprint("drop") - -type T struct{} - -func Old() string { return fmt.Sprint("old") } -func KeepFn() string { return Keep } -func (T) M() string { return fmt.Sprint("old method") } -`) - mustWriteFile(t, patchFile, `package demo - -//llgo:skip Drop - -import "strings" - -var Added = strings.ToUpper("added") - -func Old() string { return "new" } -func (T) M() string { return "new method" } -`) - - changed, overlay, err := applySourcePatchForPkg(nil, nil, runtimeDir, goroot, pkgPath, sourcePatchBuildContext{}) - if err != nil { - t.Fatal(err) - } - if !changed { - t.Fatal("expected source patch overlay to change package") - } - - assertExactString(t, "filtered stdlib source", string(overlay[stdFile]), ""+ - "package demo\n"+ - "\n"+ - `// import "fmt"`+"\n"+ - "\n"+ - `const Keep = "keep"`+"\n"+ - "\n"+ - `// var Drop = fmt.Sprint("drop")`+"\n"+ - "\n"+ - `type T struct{}`+"\n"+ - "\n"+ - `// func Old() string { return fmt.Sprint("old") }`+"\n"+ - `func KeepFn() string { return Keep }`+"\n"+ - `// func (T) M() string { return fmt.Sprint("old method") }`+"\n") - - injectedPatch := filepath.Join(srcDir, "z_llgo_patch_patch.go") - assertExactString(t, "injected patch source", string(overlay[injectedPatch]), - sourcePatchLineDirective(patchFile)+`package demo - -//llgo_skip Drop - -import "strings" - -var Added = strings.ToUpper("added") - -func Old() string { return "new" } -func (T) M() string { return "new method" } -`) - - assertPatchedPosition(t, string(overlay[injectedPatch]), injectedPatch, patchFile, "package", 1) - assertPatchedPosition(t, string(overlay[injectedPatch]), injectedPatch, patchFile, "var:Added", 7) - assertPatchedPosition(t, string(overlay[injectedPatch]), injectedPatch, patchFile, "func:Old", 9) - assertPatchedPosition(t, string(overlay[injectedPatch]), injectedPatch, patchFile, "method:T.M", 10) - }) - - t.Run("default-override", func(t *testing.T) { - goroot := t.TempDir() - runtimeDir := t.TempDir() - pkgPath := "demo" - srcDir := filepath.Join(goroot, "src", pkgPath) - patchDir := filepath.Join(runtimeDir, "internal", "lib", pkgPath) - stdFile := filepath.Join(srcDir, "demo.go") - patchFile := filepath.Join(patchDir, "patch.go") - mustWriteFile(t, stdFile, `package demo - -func Old() string { return "old" } -func Keep() string { return "keep" } -`) - mustWriteFile(t, patchFile, `package demo - -func Old() string { return "new" } -func Added() string { return "added" } -`) - - changed, overlay, err := applySourcePatchForPkg(nil, nil, runtimeDir, goroot, pkgPath, sourcePatchBuildContext{}) - if err != nil { - t.Fatal(err) - } - if !changed { - t.Fatal("expected source patch overlay to change package") - } - - assertExactString(t, "filtered stdlib source", string(overlay[stdFile]), ""+ - "package demo\n"+ - "\n"+ - `// func Old() string { return "old" }`+"\n"+ - `func Keep() string { return "keep" }`+"\n") - - injectedPatch := filepath.Join(srcDir, "z_llgo_patch_patch.go") - assertExactString(t, "injected patch source", string(overlay[injectedPatch]), - sourcePatchLineDirective(patchFile)+`package demo - -func Old() string { return "new" } -func Added() string { return "added" } -`) - - assertPatchedPosition(t, string(overlay[injectedPatch]), injectedPatch, patchFile, "package", 1) - assertPatchedPosition(t, string(overlay[injectedPatch]), injectedPatch, patchFile, "func:Old", 3) - assertPatchedPosition(t, string(overlay[injectedPatch]), injectedPatch, patchFile, "func:Added", 4) - }) - - t.Run("skipall", func(t *testing.T) { - goroot := t.TempDir() - runtimeDir := t.TempDir() - pkgPath := "demo" - srcDir := filepath.Join(goroot, "src", pkgPath) - patchDir := filepath.Join(runtimeDir, "internal", "lib", pkgPath) - stdFile := filepath.Join(srcDir, "demo.go") - patchFile := filepath.Join(patchDir, "patch.go") - mustWriteFile(t, stdFile, `package demo - -func Old() string { return "old" } -`) - mustWriteFile(t, patchFile, `// llgo:skipall -package demo - -const Only = "patched" -`) - - changed, overlay, err := applySourcePatchForPkg(nil, nil, runtimeDir, goroot, pkgPath, sourcePatchBuildContext{}) - if err != nil { - t.Fatal(err) - } - if !changed { - t.Fatal("expected source patch overlay to change package") - } - - assertExactString(t, "stubbed stdlib source", string(overlay[stdFile]), "package demo\n") - - injectedPatch := filepath.Join(srcDir, "z_llgo_patch_patch.go") - assertExactString(t, "injected patch source", string(overlay[injectedPatch]), - sourcePatchLineDirective(patchFile)+`// llgo_skipall -package demo - -const Only = "patched" -`) - - assertPatchedPosition(t, string(overlay[injectedPatch]), injectedPatch, patchFile, "package", 2) - assertPatchedPosition(t, string(overlay[injectedPatch]), injectedPatch, patchFile, "const:Only", 4) - }) - +func TestApplySourcePatchForPkg_Cases(t *testing.T) { + for _, caseName := range []string{ + "default-override", + "multi-file-skipall", + "multi-file-with-asm", + "skip-and-override", + "skipall", + } { + t.Run(caseName, func(t *testing.T) { + runSourcePatchCase(t, caseName) + }) + } } func TestApplySourcePatchForPkg_MissingStdlibPkg(t *testing.T) { goroot := t.TempDir() runtimeDir := t.TempDir() pkgPath := "iter" - patchDir := filepath.Join(runtimeDir, "internal", "lib", pkgPath) + patchDir := filepath.Join(runtimeDir, "_patch", pkgPath) mustWriteFile(t, filepath.Join(patchDir, "iter.go"), `package iter //llgo:skipall @@ -281,7 +131,7 @@ func TestApplySourcePatchForPkg_BuildTaggedPatch(t *testing.T) { runtimeDir := t.TempDir() pkgPath := "demo" srcDir := filepath.Join(goroot, "src", pkgPath) - patchDir := filepath.Join(runtimeDir, "internal", "lib", pkgPath) + patchDir := filepath.Join(runtimeDir, "_patch", pkgPath) mustWriteFile(t, filepath.Join(srcDir, "demo.go"), `package demo func Old() string { return "old" } @@ -326,7 +176,7 @@ func TestApplySourcePatchForPkg_UnreadableStdlibPkg(t *testing.T) { runtimeDir := t.TempDir() pkgPath := "iter" srcDir := filepath.Join(goroot, "src", pkgPath) - patchDir := filepath.Join(runtimeDir, "internal", "lib", pkgPath) + patchDir := filepath.Join(runtimeDir, "_patch", pkgPath) if err := os.MkdirAll(srcDir, 0755); err != nil { t.Fatal(err) } @@ -353,6 +203,198 @@ func Pull[V any](seq func(func(V) bool)) {} } } +func runSourcePatchCase(t *testing.T, caseName string) { + t.Helper() + + assetRoot := filepath.Join(env.LLGoRuntimeDir(), "_patch", "_test", caseName) + goroot := t.TempDir() + runtimeDir := t.TempDir() + + copyTree(t, filepath.Join(assetRoot, "pkg"), filepath.Join(goroot, "src")) + copyTree(t, filepath.Join(assetRoot, "patch"), filepath.Join(runtimeDir, "_patch")) + + pkgPath := singlePackagePath(t, filepath.Join(assetRoot, "patch")) + changed, overlay, err := applySourcePatchForPkg(nil, nil, runtimeDir, goroot, pkgPath, sourcePatchBuildContext{}) + if err != nil { + t.Fatal(err) + } + if !changed { + t.Fatal("expected source patch overlay to change package") + } + + srcRoot := filepath.Join(goroot, "src") + assertOverlayMatchesOutput(t, overlay, srcRoot, filepath.Join(assetRoot, "output"), runtimeDir) + assertGeneratedPatchPackagePositions(t, overlay, srcRoot, filepath.Join(runtimeDir, "_patch")) +} + +func copyTree(t *testing.T, srcRoot, dstRoot string) { + t.Helper() + err := filepath.WalkDir(srcRoot, func(path string, d fs.DirEntry, err error) error { + if err != nil { + return err + } + rel, err := filepath.Rel(srcRoot, path) + if err != nil { + return err + } + target := filepath.Join(dstRoot, rel) + if d.IsDir() { + return os.MkdirAll(target, 0755) + } + data, err := os.ReadFile(path) + if err != nil { + return err + } + return os.WriteFile(target, data, 0644) + }) + if err != nil { + t.Fatal(err) + } +} + +func singlePackagePath(t *testing.T, root string) string { + t.Helper() + var pkgPath string + err := filepath.WalkDir(root, func(path string, d fs.DirEntry, err error) error { + if err != nil { + return err + } + if d.IsDir() { + return nil + } + if !strings.HasSuffix(path, ".go") || strings.HasSuffix(path, "_test.go") { + return nil + } + rel, err := filepath.Rel(root, filepath.Dir(path)) + if err != nil { + return err + } + if rel == "." { + rel = "" + } + rel = filepath.ToSlash(rel) + if pkgPath == "" { + pkgPath = rel + return nil + } + if pkgPath != rel { + return &pathMismatchError{want: pkgPath, got: rel} + } + return nil + }) + if err != nil { + t.Fatal(err) + } + if pkgPath == "" { + t.Fatal("no patch package found") + } + return pkgPath +} + +type pathMismatchError struct { + want string + got string +} + +func (e *pathMismatchError) Error() string { + return "multiple patch packages found: " + e.want + " and " + e.got +} + +func assertOverlayMatchesOutput(t *testing.T, overlay map[string][]byte, srcRoot, outputRoot, runtimeDir string) { + t.Helper() + + got := overlayFilesUnderRoot(t, overlay, srcRoot) + want := readTextFiles(t, outputRoot, runtimeDir) + + gotNames := sortedMapKeys(got) + wantNames := sortedMapKeys(want) + assertExactString(t, "overlay file list", strings.Join(gotNames, "\n"), strings.Join(wantNames, "\n")) + + for _, name := range wantNames { + assertExactString(t, "overlay file "+name, got[name], want[name]) + } +} + +func overlayFilesUnderRoot(t *testing.T, overlay map[string][]byte, root string) map[string]string { + t.Helper() + out := make(map[string]string) + for filename, src := range overlay { + rel, err := filepath.Rel(root, filename) + if err != nil { + t.Fatal(err) + } + if rel == "." || strings.HasPrefix(rel, ".."+string(os.PathSeparator)) || rel == ".." { + continue + } + out[filepath.ToSlash(rel)] = string(src) + } + return out +} + +func readTextFiles(t *testing.T, root, runtimeDir string) map[string]string { + t.Helper() + out := make(map[string]string) + err := filepath.WalkDir(root, func(path string, d fs.DirEntry, err error) error { + if err != nil { + return err + } + if d.IsDir() { + return nil + } + rel, err := filepath.Rel(root, path) + if err != nil { + return err + } + data, err := os.ReadFile(path) + if err != nil { + return err + } + out[filepath.ToSlash(rel)] = expandSourcePatchOutputTemplate(string(data), runtimeDir) + return nil + }) + if err != nil { + t.Fatal(err) + } + return out +} + +func expandSourcePatchOutputTemplate(src, runtimeDir string) string { + patchRoot := filepath.ToSlash(filepath.Join(runtimeDir, "_patch")) + return strings.ReplaceAll(src, "{{PATCH_ROOT}}", patchRoot) +} + +func sortedMapKeys(m map[string]string) []string { + keys := make([]string, 0, len(m)) + for key := range m { + keys = append(keys, key) + } + sort.Strings(keys) + return keys +} + +func assertGeneratedPatchPackagePositions(t *testing.T, overlay map[string][]byte, srcRoot, patchRoot string) { + t.Helper() + for rel, src := range overlayFilesUnderRoot(t, overlay, srcRoot) { + base := filepath.Base(rel) + if !strings.HasPrefix(base, "z_llgo_patch_") { + continue + } + original := strings.TrimPrefix(base, "z_llgo_patch_") + patchFile := filepath.Join(patchRoot, filepath.Dir(rel), original) + assertPatchedPosition(t, src, filepath.Join(srcRoot, filepath.FromSlash(rel)), patchFile, "package", packageLineOfFile(t, patchFile)) + } +} + +func packageLineOfFile(t *testing.T, filename string) int { + t.Helper() + fset := token.NewFileSet() + file, err := parser.ParseFile(fset, filename, nil, parser.ParseComments) + if err != nil { + t.Fatal(err) + } + return fset.Position(file.Package).Line +} + func mustWriteFile(t *testing.T, filename, content string) { t.Helper() if err := os.MkdirAll(filepath.Dir(filename), 0755); err != nil { diff --git a/runtime/_patch/_test/default-override/output/demo/demo.go b/runtime/_patch/_test/default-override/output/demo/demo.go new file mode 100644 index 0000000000..d1a3e50122 --- /dev/null +++ b/runtime/_patch/_test/default-override/output/demo/demo.go @@ -0,0 +1,4 @@ +package demo + +// func Old() string { return "old" } +func Keep() string { return "keep" } diff --git a/runtime/_patch/_test/default-override/output/demo/z_llgo_patch_patch.go b/runtime/_patch/_test/default-override/output/demo/z_llgo_patch_patch.go new file mode 100644 index 0000000000..46d02ae8d1 --- /dev/null +++ b/runtime/_patch/_test/default-override/output/demo/z_llgo_patch_patch.go @@ -0,0 +1,5 @@ +//line {{PATCH_ROOT}}/demo/patch.go:1 +package demo + +func Old() string { return "new" } +func Added() string { return "added" } diff --git a/runtime/_patch/_test/default-override/patch/demo/patch.go b/runtime/_patch/_test/default-override/patch/demo/patch.go new file mode 100644 index 0000000000..16d2ea4801 --- /dev/null +++ b/runtime/_patch/_test/default-override/patch/demo/patch.go @@ -0,0 +1,4 @@ +package demo + +func Old() string { return "new" } +func Added() string { return "added" } diff --git a/runtime/_patch/_test/default-override/pkg/demo/demo.go b/runtime/_patch/_test/default-override/pkg/demo/demo.go new file mode 100644 index 0000000000..6a7b132371 --- /dev/null +++ b/runtime/_patch/_test/default-override/pkg/demo/demo.go @@ -0,0 +1,4 @@ +package demo + +func Old() string { return "old" } +func Keep() string { return "keep" } diff --git a/runtime/_patch/_test/multi-file-skipall/output/demo/a.go b/runtime/_patch/_test/multi-file-skipall/output/demo/a.go new file mode 100644 index 0000000000..bed5a16777 --- /dev/null +++ b/runtime/_patch/_test/multi-file-skipall/output/demo/a.go @@ -0,0 +1 @@ +package demo diff --git a/runtime/_patch/_test/multi-file-skipall/output/demo/b.go b/runtime/_patch/_test/multi-file-skipall/output/demo/b.go new file mode 100644 index 0000000000..bed5a16777 --- /dev/null +++ b/runtime/_patch/_test/multi-file-skipall/output/demo/b.go @@ -0,0 +1 @@ +package demo diff --git a/runtime/_patch/_test/multi-file-skipall/output/demo/z_llgo_patch_a.go b/runtime/_patch/_test/multi-file-skipall/output/demo/z_llgo_patch_a.go new file mode 100644 index 0000000000..35ad108d19 --- /dev/null +++ b/runtime/_patch/_test/multi-file-skipall/output/demo/z_llgo_patch_a.go @@ -0,0 +1,5 @@ +//line {{PATCH_ROOT}}/demo/a.go:1 +//llgo_skipall +package demo + +const Only = "patched" diff --git a/runtime/_patch/_test/multi-file-skipall/output/demo/z_llgo_patch_b.go b/runtime/_patch/_test/multi-file-skipall/output/demo/z_llgo_patch_b.go new file mode 100644 index 0000000000..484081b95d --- /dev/null +++ b/runtime/_patch/_test/multi-file-skipall/output/demo/z_llgo_patch_b.go @@ -0,0 +1,4 @@ +//line {{PATCH_ROOT}}/demo/b.go:1 +package demo + +func Added() string { return "added" } diff --git a/runtime/_patch/_test/multi-file-skipall/patch/demo/a.go b/runtime/_patch/_test/multi-file-skipall/patch/demo/a.go new file mode 100644 index 0000000000..95592af1cf --- /dev/null +++ b/runtime/_patch/_test/multi-file-skipall/patch/demo/a.go @@ -0,0 +1,4 @@ +//llgo:skipall +package demo + +const Only = "patched" diff --git a/runtime/_patch/_test/multi-file-skipall/patch/demo/b.go b/runtime/_patch/_test/multi-file-skipall/patch/demo/b.go new file mode 100644 index 0000000000..b93ce6201c --- /dev/null +++ b/runtime/_patch/_test/multi-file-skipall/patch/demo/b.go @@ -0,0 +1,3 @@ +package demo + +func Added() string { return "added" } diff --git a/runtime/_patch/_test/multi-file-skipall/pkg/demo/a.go b/runtime/_patch/_test/multi-file-skipall/pkg/demo/a.go new file mode 100644 index 0000000000..9d0980f3eb --- /dev/null +++ b/runtime/_patch/_test/multi-file-skipall/pkg/demo/a.go @@ -0,0 +1,3 @@ +package demo + +func OldA() string { return "old-a" } diff --git a/runtime/_patch/_test/multi-file-skipall/pkg/demo/b.go b/runtime/_patch/_test/multi-file-skipall/pkg/demo/b.go new file mode 100644 index 0000000000..cdca36d583 --- /dev/null +++ b/runtime/_patch/_test/multi-file-skipall/pkg/demo/b.go @@ -0,0 +1,3 @@ +package demo + +func OldB() string { return "old-b" } diff --git a/runtime/_patch/_test/multi-file-with-asm/output/demo/a.go b/runtime/_patch/_test/multi-file-with-asm/output/demo/a.go new file mode 100644 index 0000000000..4b0b133d73 --- /dev/null +++ b/runtime/_patch/_test/multi-file-with-asm/output/demo/a.go @@ -0,0 +1,9 @@ +package demo + +// import "fmt" + +// var DropA = fmt.Sprint("drop-a") + +func KeepA() string { return "keep-a" } + +// func OldA() string { return fmt.Sprint("old-a") } diff --git a/runtime/_patch/_test/multi-file-with-asm/output/demo/b.go b/runtime/_patch/_test/multi-file-with-asm/output/demo/b.go new file mode 100644 index 0000000000..885031fa5b --- /dev/null +++ b/runtime/_patch/_test/multi-file-with-asm/output/demo/b.go @@ -0,0 +1,4 @@ +package demo + +func KeepB() string { return "keep-b" } +// func OldB() string { return "old-b" } diff --git a/runtime/_patch/_test/multi-file-with-asm/output/demo/z_llgo_patch_a.go b/runtime/_patch/_test/multi-file-with-asm/output/demo/z_llgo_patch_a.go new file mode 100644 index 0000000000..1b00d7ab05 --- /dev/null +++ b/runtime/_patch/_test/multi-file-with-asm/output/demo/z_llgo_patch_a.go @@ -0,0 +1,10 @@ +//line {{PATCH_ROOT}}/demo/a.go:1 +package demo + +//llgo_skip DropA + +import "strings" + +var AddedA = strings.ToUpper("added-a") + +func OldA() string { return "new-a" } diff --git a/runtime/_patch/_test/multi-file-with-asm/output/demo/z_llgo_patch_b.go b/runtime/_patch/_test/multi-file-with-asm/output/demo/z_llgo_patch_b.go new file mode 100644 index 0000000000..d868f2b784 --- /dev/null +++ b/runtime/_patch/_test/multi-file-with-asm/output/demo/z_llgo_patch_b.go @@ -0,0 +1,5 @@ +//line {{PATCH_ROOT}}/demo/b.go:1 +package demo + +func OldB() string { return "new-b" } +func AddedB() string { return "added-b" } diff --git a/runtime/_patch/_test/multi-file-with-asm/patch/demo/a.go b/runtime/_patch/_test/multi-file-with-asm/patch/demo/a.go new file mode 100644 index 0000000000..f862e66bdc --- /dev/null +++ b/runtime/_patch/_test/multi-file-with-asm/patch/demo/a.go @@ -0,0 +1,9 @@ +package demo + +//llgo:skip DropA + +import "strings" + +var AddedA = strings.ToUpper("added-a") + +func OldA() string { return "new-a" } diff --git a/runtime/_patch/_test/multi-file-with-asm/patch/demo/b.go b/runtime/_patch/_test/multi-file-with-asm/patch/demo/b.go new file mode 100644 index 0000000000..2ef8ab6fe5 --- /dev/null +++ b/runtime/_patch/_test/multi-file-with-asm/patch/demo/b.go @@ -0,0 +1,4 @@ +package demo + +func OldB() string { return "new-b" } +func AddedB() string { return "added-b" } diff --git a/runtime/_patch/_test/multi-file-with-asm/pkg/demo/a.go b/runtime/_patch/_test/multi-file-with-asm/pkg/demo/a.go new file mode 100644 index 0000000000..53836221f8 --- /dev/null +++ b/runtime/_patch/_test/multi-file-with-asm/pkg/demo/a.go @@ -0,0 +1,9 @@ +package demo + +import "fmt" + +var DropA = fmt.Sprint("drop-a") + +func KeepA() string { return "keep-a" } + +func OldA() string { return fmt.Sprint("old-a") } diff --git a/runtime/_patch/_test/multi-file-with-asm/pkg/demo/asm.s b/runtime/_patch/_test/multi-file-with-asm/pkg/demo/asm.s new file mode 100644 index 0000000000..36edcf1aa8 --- /dev/null +++ b/runtime/_patch/_test/multi-file-with-asm/pkg/demo/asm.s @@ -0,0 +1,2 @@ +TEXT ·Asm(SB),$0-0 + RET diff --git a/runtime/_patch/_test/multi-file-with-asm/pkg/demo/b.go b/runtime/_patch/_test/multi-file-with-asm/pkg/demo/b.go new file mode 100644 index 0000000000..1b7294f4bc --- /dev/null +++ b/runtime/_patch/_test/multi-file-with-asm/pkg/demo/b.go @@ -0,0 +1,4 @@ +package demo + +func KeepB() string { return "keep-b" } +func OldB() string { return "old-b" } diff --git a/runtime/_patch/_test/skip-and-override/output/demo/demo.go b/runtime/_patch/_test/skip-and-override/output/demo/demo.go new file mode 100644 index 0000000000..4331480877 --- /dev/null +++ b/runtime/_patch/_test/skip-and-override/output/demo/demo.go @@ -0,0 +1,13 @@ +package demo + +// import "fmt" + +const Keep = "keep" + +// var Drop = fmt.Sprint("drop") + +type T struct{} + +// func Old() string { return fmt.Sprint("old") } +func KeepFn() string { return Keep } +// func (T) M() string { return fmt.Sprint("old method") } diff --git a/runtime/_patch/_test/skip-and-override/output/demo/z_llgo_patch_patch.go b/runtime/_patch/_test/skip-and-override/output/demo/z_llgo_patch_patch.go new file mode 100644 index 0000000000..580071c98c --- /dev/null +++ b/runtime/_patch/_test/skip-and-override/output/demo/z_llgo_patch_patch.go @@ -0,0 +1,11 @@ +//line {{PATCH_ROOT}}/demo/patch.go:1 +package demo + +//llgo_skip Drop + +import "strings" + +var Added = strings.ToUpper("added") + +func Old() string { return "new" } +func (T) M() string { return "new method" } diff --git a/runtime/_patch/_test/skip-and-override/patch/demo/patch.go b/runtime/_patch/_test/skip-and-override/patch/demo/patch.go new file mode 100644 index 0000000000..afd13f95fb --- /dev/null +++ b/runtime/_patch/_test/skip-and-override/patch/demo/patch.go @@ -0,0 +1,10 @@ +package demo + +//llgo:skip Drop + +import "strings" + +var Added = strings.ToUpper("added") + +func Old() string { return "new" } +func (T) M() string { return "new method" } diff --git a/runtime/_patch/_test/skip-and-override/pkg/demo/demo.go b/runtime/_patch/_test/skip-and-override/pkg/demo/demo.go new file mode 100644 index 0000000000..f08c3dafd1 --- /dev/null +++ b/runtime/_patch/_test/skip-and-override/pkg/demo/demo.go @@ -0,0 +1,13 @@ +package demo + +import "fmt" + +const Keep = "keep" + +var Drop = fmt.Sprint("drop") + +type T struct{} + +func Old() string { return fmt.Sprint("old") } +func KeepFn() string { return Keep } +func (T) M() string { return fmt.Sprint("old method") } diff --git a/runtime/_patch/_test/skipall/output/demo/demo.go b/runtime/_patch/_test/skipall/output/demo/demo.go new file mode 100644 index 0000000000..bed5a16777 --- /dev/null +++ b/runtime/_patch/_test/skipall/output/demo/demo.go @@ -0,0 +1 @@ +package demo diff --git a/runtime/_patch/_test/skipall/output/demo/z_llgo_patch_patch.go b/runtime/_patch/_test/skipall/output/demo/z_llgo_patch_patch.go new file mode 100644 index 0000000000..5e67d8d20f --- /dev/null +++ b/runtime/_patch/_test/skipall/output/demo/z_llgo_patch_patch.go @@ -0,0 +1,5 @@ +//line {{PATCH_ROOT}}/demo/patch.go:1 +// llgo_skipall +package demo + +const Only = "patched" diff --git a/runtime/_patch/_test/skipall/patch/demo/patch.go b/runtime/_patch/_test/skipall/patch/demo/patch.go new file mode 100644 index 0000000000..b8a4a96457 --- /dev/null +++ b/runtime/_patch/_test/skipall/patch/demo/patch.go @@ -0,0 +1,4 @@ +// llgo:skipall +package demo + +const Only = "patched" diff --git a/runtime/_patch/_test/skipall/pkg/demo/demo.go b/runtime/_patch/_test/skipall/pkg/demo/demo.go new file mode 100644 index 0000000000..1632daea6c --- /dev/null +++ b/runtime/_patch/_test/skipall/pkg/demo/demo.go @@ -0,0 +1,3 @@ +package demo + +func Old() string { return "old" } diff --git a/runtime/internal/lib/iter/iter.go b/runtime/_patch/iter/iter.go similarity index 100% rename from runtime/internal/lib/iter/iter.go rename to runtime/_patch/iter/iter.go From bd685f86c55df5397892340955df8e357f9f6f4b Mon Sep 17 00:00:00 2001 From: Li Jie Date: Sun, 29 Mar 2026 10:58:37 +0800 Subject: [PATCH 24/44] test: flatten source patch fixture cases --- internal/build/source_patch_test.go | 67 ++++--------------- .../output/{demo/demo.go => demo.go.txt} | 2 +- ...tch_patch.go => z_llgo_patch_patch.go.txt} | 2 +- .../patch/{demo => }/patch.go | 2 +- .../default-override/pkg/{demo => }/demo.go | 2 +- .../output/{demo/a.go => a.go.txt} | 0 .../output/{demo/b.go => b.go.txt} | 0 ..._llgo_patch_a.go => z_llgo_patch_a.go.txt} | 0 ..._llgo_patch_b.go => z_llgo_patch_b.go.txt} | 0 .../multi-file-skipall/patch/{demo => }/a.go | 0 .../multi-file-skipall/patch/{demo => }/b.go | 0 .../multi-file-skipall/pkg/{demo => }/a.go | 0 .../multi-file-skipall/pkg/{demo => }/b.go | 0 .../output/{demo/a.go => a.go.txt} | 0 .../output/{demo/b.go => b.go.txt} | 2 +- ..._llgo_patch_a.go => z_llgo_patch_a.go.txt} | 0 ..._llgo_patch_b.go => z_llgo_patch_b.go.txt} | 2 +- .../multi-file-with-asm/patch/{demo => }/a.go | 0 .../multi-file-with-asm/patch/{demo => }/b.go | 2 +- .../multi-file-with-asm/pkg/{demo => }/a.go | 0 .../multi-file-with-asm/pkg/{demo => }/asm.s | 0 .../multi-file-with-asm/pkg/{demo => }/b.go | 2 +- .../output/{demo/demo.go => demo.go.txt} | 4 +- ...tch_patch.go => z_llgo_patch_patch.go.txt} | 2 +- .../patch/{demo => }/patch.go | 2 +- .../skip-and-override/pkg/{demo => }/demo.go | 4 +- .../output/{demo/demo.go => demo.go.txt} | 0 ...tch_patch.go => z_llgo_patch_patch.go.txt} | 0 .../_test/skipall/patch/{demo => }/patch.go | 0 .../_test/skipall/pkg/{demo => }/demo.go | 0 30 files changed, 26 insertions(+), 69 deletions(-) rename runtime/_patch/_test/default-override/output/{demo/demo.go => demo.go.txt} (56%) rename runtime/_patch/_test/default-override/output/{demo/z_llgo_patch_patch.go => z_llgo_patch_patch.go.txt} (71%) rename runtime/_patch/_test/default-override/patch/{demo => }/patch.go (58%) rename runtime/_patch/_test/default-override/pkg/{demo => }/demo.go (58%) rename runtime/_patch/_test/multi-file-skipall/output/{demo/a.go => a.go.txt} (100%) rename runtime/_patch/_test/multi-file-skipall/output/{demo/b.go => b.go.txt} (100%) rename runtime/_patch/_test/multi-file-skipall/output/{demo/z_llgo_patch_a.go => z_llgo_patch_a.go.txt} (100%) rename runtime/_patch/_test/multi-file-skipall/output/{demo/z_llgo_patch_b.go => z_llgo_patch_b.go.txt} (100%) rename runtime/_patch/_test/multi-file-skipall/patch/{demo => }/a.go (100%) rename runtime/_patch/_test/multi-file-skipall/patch/{demo => }/b.go (100%) rename runtime/_patch/_test/multi-file-skipall/pkg/{demo => }/a.go (100%) rename runtime/_patch/_test/multi-file-skipall/pkg/{demo => }/b.go (100%) rename runtime/_patch/_test/multi-file-with-asm/output/{demo/a.go => a.go.txt} (100%) rename runtime/_patch/_test/multi-file-with-asm/output/{demo/b.go => b.go.txt} (56%) rename runtime/_patch/_test/multi-file-with-asm/output/{demo/z_llgo_patch_a.go => z_llgo_patch_a.go.txt} (100%) rename runtime/_patch/_test/multi-file-with-asm/output/{demo/z_llgo_patch_b.go => z_llgo_patch_b.go.txt} (69%) rename runtime/_patch/_test/multi-file-with-asm/patch/{demo => }/a.go (100%) rename runtime/_patch/_test/multi-file-with-asm/patch/{demo => }/b.go (58%) rename runtime/_patch/_test/multi-file-with-asm/pkg/{demo => }/a.go (100%) rename runtime/_patch/_test/multi-file-with-asm/pkg/{demo => }/asm.s (100%) rename runtime/_patch/_test/multi-file-with-asm/pkg/{demo => }/b.go (58%) rename runtime/_patch/_test/skip-and-override/output/{demo/demo.go => demo.go.txt} (55%) rename runtime/_patch/_test/skip-and-override/output/{demo/z_llgo_patch_patch.go => z_llgo_patch_patch.go.txt} (82%) rename runtime/_patch/_test/skip-and-override/patch/{demo => }/patch.go (78%) rename runtime/_patch/_test/skip-and-override/pkg/{demo => }/demo.go (55%) rename runtime/_patch/_test/skipall/output/{demo/demo.go => demo.go.txt} (100%) rename runtime/_patch/_test/skipall/output/{demo/z_llgo_patch_patch.go => z_llgo_patch_patch.go.txt} (100%) rename runtime/_patch/_test/skipall/patch/{demo => }/patch.go (100%) rename runtime/_patch/_test/skipall/pkg/{demo => }/demo.go (100%) diff --git a/internal/build/source_patch_test.go b/internal/build/source_patch_test.go index e09c3131ac..448803a423 100644 --- a/internal/build/source_patch_test.go +++ b/internal/build/source_patch_test.go @@ -209,11 +209,13 @@ func runSourcePatchCase(t *testing.T, caseName string) { assetRoot := filepath.Join(env.LLGoRuntimeDir(), "_patch", "_test", caseName) goroot := t.TempDir() runtimeDir := t.TempDir() + const pkgPath = "demo" + srcDir := filepath.Join(goroot, "src", pkgPath) + patchDir := filepath.Join(runtimeDir, "_patch", pkgPath) - copyTree(t, filepath.Join(assetRoot, "pkg"), filepath.Join(goroot, "src")) - copyTree(t, filepath.Join(assetRoot, "patch"), filepath.Join(runtimeDir, "_patch")) + copyTree(t, filepath.Join(assetRoot, "pkg"), srcDir) + copyTree(t, filepath.Join(assetRoot, "patch"), patchDir) - pkgPath := singlePackagePath(t, filepath.Join(assetRoot, "patch")) changed, overlay, err := applySourcePatchForPkg(nil, nil, runtimeDir, goroot, pkgPath, sourcePatchBuildContext{}) if err != nil { t.Fatal(err) @@ -222,9 +224,8 @@ func runSourcePatchCase(t *testing.T, caseName string) { t.Fatal("expected source patch overlay to change package") } - srcRoot := filepath.Join(goroot, "src") - assertOverlayMatchesOutput(t, overlay, srcRoot, filepath.Join(assetRoot, "output"), runtimeDir) - assertGeneratedPatchPackagePositions(t, overlay, srcRoot, filepath.Join(runtimeDir, "_patch")) + assertOverlayMatchesOutput(t, overlay, srcDir, filepath.Join(assetRoot, "output"), runtimeDir) + assertGeneratedPatchPackagePositions(t, overlay, srcDir, patchDir) } func copyTree(t *testing.T, srcRoot, dstRoot string) { @@ -252,54 +253,6 @@ func copyTree(t *testing.T, srcRoot, dstRoot string) { } } -func singlePackagePath(t *testing.T, root string) string { - t.Helper() - var pkgPath string - err := filepath.WalkDir(root, func(path string, d fs.DirEntry, err error) error { - if err != nil { - return err - } - if d.IsDir() { - return nil - } - if !strings.HasSuffix(path, ".go") || strings.HasSuffix(path, "_test.go") { - return nil - } - rel, err := filepath.Rel(root, filepath.Dir(path)) - if err != nil { - return err - } - if rel == "." { - rel = "" - } - rel = filepath.ToSlash(rel) - if pkgPath == "" { - pkgPath = rel - return nil - } - if pkgPath != rel { - return &pathMismatchError{want: pkgPath, got: rel} - } - return nil - }) - if err != nil { - t.Fatal(err) - } - if pkgPath == "" { - t.Fatal("no patch package found") - } - return pkgPath -} - -type pathMismatchError struct { - want string - got string -} - -func (e *pathMismatchError) Error() string { - return "multiple patch packages found: " + e.want + " and " + e.got -} - func assertOverlayMatchesOutput(t *testing.T, overlay map[string][]byte, srcRoot, outputRoot, runtimeDir string) { t.Helper() @@ -349,7 +302,11 @@ func readTextFiles(t *testing.T, root, runtimeDir string) map[string]string { if err != nil { return err } - out[filepath.ToSlash(rel)] = expandSourcePatchOutputTemplate(string(data), runtimeDir) + key := filepath.ToSlash(rel) + if strings.HasSuffix(key, ".txt") { + key = strings.TrimSuffix(key, ".txt") + } + out[key] = expandSourcePatchOutputTemplate(string(data), runtimeDir) return nil }) if err != nil { diff --git a/runtime/_patch/_test/default-override/output/demo/demo.go b/runtime/_patch/_test/default-override/output/demo.go.txt similarity index 56% rename from runtime/_patch/_test/default-override/output/demo/demo.go rename to runtime/_patch/_test/default-override/output/demo.go.txt index d1a3e50122..c1892cc226 100644 --- a/runtime/_patch/_test/default-override/output/demo/demo.go +++ b/runtime/_patch/_test/default-override/output/demo.go.txt @@ -1,4 +1,4 @@ package demo -// func Old() string { return "old" } +// func Old() string { return "old" } func Keep() string { return "keep" } diff --git a/runtime/_patch/_test/default-override/output/demo/z_llgo_patch_patch.go b/runtime/_patch/_test/default-override/output/z_llgo_patch_patch.go.txt similarity index 71% rename from runtime/_patch/_test/default-override/output/demo/z_llgo_patch_patch.go rename to runtime/_patch/_test/default-override/output/z_llgo_patch_patch.go.txt index 46d02ae8d1..3376cfb845 100644 --- a/runtime/_patch/_test/default-override/output/demo/z_llgo_patch_patch.go +++ b/runtime/_patch/_test/default-override/output/z_llgo_patch_patch.go.txt @@ -1,5 +1,5 @@ //line {{PATCH_ROOT}}/demo/patch.go:1 package demo -func Old() string { return "new" } +func Old() string { return "new" } func Added() string { return "added" } diff --git a/runtime/_patch/_test/default-override/patch/demo/patch.go b/runtime/_patch/_test/default-override/patch/patch.go similarity index 58% rename from runtime/_patch/_test/default-override/patch/demo/patch.go rename to runtime/_patch/_test/default-override/patch/patch.go index 16d2ea4801..fc5951b856 100644 --- a/runtime/_patch/_test/default-override/patch/demo/patch.go +++ b/runtime/_patch/_test/default-override/patch/patch.go @@ -1,4 +1,4 @@ package demo -func Old() string { return "new" } +func Old() string { return "new" } func Added() string { return "added" } diff --git a/runtime/_patch/_test/default-override/pkg/demo/demo.go b/runtime/_patch/_test/default-override/pkg/demo.go similarity index 58% rename from runtime/_patch/_test/default-override/pkg/demo/demo.go rename to runtime/_patch/_test/default-override/pkg/demo.go index 6a7b132371..6a9652a579 100644 --- a/runtime/_patch/_test/default-override/pkg/demo/demo.go +++ b/runtime/_patch/_test/default-override/pkg/demo.go @@ -1,4 +1,4 @@ package demo -func Old() string { return "old" } +func Old() string { return "old" } func Keep() string { return "keep" } diff --git a/runtime/_patch/_test/multi-file-skipall/output/demo/a.go b/runtime/_patch/_test/multi-file-skipall/output/a.go.txt similarity index 100% rename from runtime/_patch/_test/multi-file-skipall/output/demo/a.go rename to runtime/_patch/_test/multi-file-skipall/output/a.go.txt diff --git a/runtime/_patch/_test/multi-file-skipall/output/demo/b.go b/runtime/_patch/_test/multi-file-skipall/output/b.go.txt similarity index 100% rename from runtime/_patch/_test/multi-file-skipall/output/demo/b.go rename to runtime/_patch/_test/multi-file-skipall/output/b.go.txt diff --git a/runtime/_patch/_test/multi-file-skipall/output/demo/z_llgo_patch_a.go b/runtime/_patch/_test/multi-file-skipall/output/z_llgo_patch_a.go.txt similarity index 100% rename from runtime/_patch/_test/multi-file-skipall/output/demo/z_llgo_patch_a.go rename to runtime/_patch/_test/multi-file-skipall/output/z_llgo_patch_a.go.txt diff --git a/runtime/_patch/_test/multi-file-skipall/output/demo/z_llgo_patch_b.go b/runtime/_patch/_test/multi-file-skipall/output/z_llgo_patch_b.go.txt similarity index 100% rename from runtime/_patch/_test/multi-file-skipall/output/demo/z_llgo_patch_b.go rename to runtime/_patch/_test/multi-file-skipall/output/z_llgo_patch_b.go.txt diff --git a/runtime/_patch/_test/multi-file-skipall/patch/demo/a.go b/runtime/_patch/_test/multi-file-skipall/patch/a.go similarity index 100% rename from runtime/_patch/_test/multi-file-skipall/patch/demo/a.go rename to runtime/_patch/_test/multi-file-skipall/patch/a.go diff --git a/runtime/_patch/_test/multi-file-skipall/patch/demo/b.go b/runtime/_patch/_test/multi-file-skipall/patch/b.go similarity index 100% rename from runtime/_patch/_test/multi-file-skipall/patch/demo/b.go rename to runtime/_patch/_test/multi-file-skipall/patch/b.go diff --git a/runtime/_patch/_test/multi-file-skipall/pkg/demo/a.go b/runtime/_patch/_test/multi-file-skipall/pkg/a.go similarity index 100% rename from runtime/_patch/_test/multi-file-skipall/pkg/demo/a.go rename to runtime/_patch/_test/multi-file-skipall/pkg/a.go diff --git a/runtime/_patch/_test/multi-file-skipall/pkg/demo/b.go b/runtime/_patch/_test/multi-file-skipall/pkg/b.go similarity index 100% rename from runtime/_patch/_test/multi-file-skipall/pkg/demo/b.go rename to runtime/_patch/_test/multi-file-skipall/pkg/b.go diff --git a/runtime/_patch/_test/multi-file-with-asm/output/demo/a.go b/runtime/_patch/_test/multi-file-with-asm/output/a.go.txt similarity index 100% rename from runtime/_patch/_test/multi-file-with-asm/output/demo/a.go rename to runtime/_patch/_test/multi-file-with-asm/output/a.go.txt diff --git a/runtime/_patch/_test/multi-file-with-asm/output/demo/b.go b/runtime/_patch/_test/multi-file-with-asm/output/b.go.txt similarity index 56% rename from runtime/_patch/_test/multi-file-with-asm/output/demo/b.go rename to runtime/_patch/_test/multi-file-with-asm/output/b.go.txt index 885031fa5b..7f19b093c6 100644 --- a/runtime/_patch/_test/multi-file-with-asm/output/demo/b.go +++ b/runtime/_patch/_test/multi-file-with-asm/output/b.go.txt @@ -1,4 +1,4 @@ package demo func KeepB() string { return "keep-b" } -// func OldB() string { return "old-b" } +// func OldB() string { return "old-b" } diff --git a/runtime/_patch/_test/multi-file-with-asm/output/demo/z_llgo_patch_a.go b/runtime/_patch/_test/multi-file-with-asm/output/z_llgo_patch_a.go.txt similarity index 100% rename from runtime/_patch/_test/multi-file-with-asm/output/demo/z_llgo_patch_a.go rename to runtime/_patch/_test/multi-file-with-asm/output/z_llgo_patch_a.go.txt diff --git a/runtime/_patch/_test/multi-file-with-asm/output/demo/z_llgo_patch_b.go b/runtime/_patch/_test/multi-file-with-asm/output/z_llgo_patch_b.go.txt similarity index 69% rename from runtime/_patch/_test/multi-file-with-asm/output/demo/z_llgo_patch_b.go rename to runtime/_patch/_test/multi-file-with-asm/output/z_llgo_patch_b.go.txt index d868f2b784..b4a55d47e5 100644 --- a/runtime/_patch/_test/multi-file-with-asm/output/demo/z_llgo_patch_b.go +++ b/runtime/_patch/_test/multi-file-with-asm/output/z_llgo_patch_b.go.txt @@ -1,5 +1,5 @@ //line {{PATCH_ROOT}}/demo/b.go:1 package demo -func OldB() string { return "new-b" } +func OldB() string { return "new-b" } func AddedB() string { return "added-b" } diff --git a/runtime/_patch/_test/multi-file-with-asm/patch/demo/a.go b/runtime/_patch/_test/multi-file-with-asm/patch/a.go similarity index 100% rename from runtime/_patch/_test/multi-file-with-asm/patch/demo/a.go rename to runtime/_patch/_test/multi-file-with-asm/patch/a.go diff --git a/runtime/_patch/_test/multi-file-with-asm/patch/demo/b.go b/runtime/_patch/_test/multi-file-with-asm/patch/b.go similarity index 58% rename from runtime/_patch/_test/multi-file-with-asm/patch/demo/b.go rename to runtime/_patch/_test/multi-file-with-asm/patch/b.go index 2ef8ab6fe5..e855ede358 100644 --- a/runtime/_patch/_test/multi-file-with-asm/patch/demo/b.go +++ b/runtime/_patch/_test/multi-file-with-asm/patch/b.go @@ -1,4 +1,4 @@ package demo -func OldB() string { return "new-b" } +func OldB() string { return "new-b" } func AddedB() string { return "added-b" } diff --git a/runtime/_patch/_test/multi-file-with-asm/pkg/demo/a.go b/runtime/_patch/_test/multi-file-with-asm/pkg/a.go similarity index 100% rename from runtime/_patch/_test/multi-file-with-asm/pkg/demo/a.go rename to runtime/_patch/_test/multi-file-with-asm/pkg/a.go diff --git a/runtime/_patch/_test/multi-file-with-asm/pkg/demo/asm.s b/runtime/_patch/_test/multi-file-with-asm/pkg/asm.s similarity index 100% rename from runtime/_patch/_test/multi-file-with-asm/pkg/demo/asm.s rename to runtime/_patch/_test/multi-file-with-asm/pkg/asm.s diff --git a/runtime/_patch/_test/multi-file-with-asm/pkg/demo/b.go b/runtime/_patch/_test/multi-file-with-asm/pkg/b.go similarity index 58% rename from runtime/_patch/_test/multi-file-with-asm/pkg/demo/b.go rename to runtime/_patch/_test/multi-file-with-asm/pkg/b.go index 1b7294f4bc..929842775d 100644 --- a/runtime/_patch/_test/multi-file-with-asm/pkg/demo/b.go +++ b/runtime/_patch/_test/multi-file-with-asm/pkg/b.go @@ -1,4 +1,4 @@ package demo func KeepB() string { return "keep-b" } -func OldB() string { return "old-b" } +func OldB() string { return "old-b" } diff --git a/runtime/_patch/_test/skip-and-override/output/demo/demo.go b/runtime/_patch/_test/skip-and-override/output/demo.go.txt similarity index 55% rename from runtime/_patch/_test/skip-and-override/output/demo/demo.go rename to runtime/_patch/_test/skip-and-override/output/demo.go.txt index 4331480877..dfdcf7df52 100644 --- a/runtime/_patch/_test/skip-and-override/output/demo/demo.go +++ b/runtime/_patch/_test/skip-and-override/output/demo.go.txt @@ -8,6 +8,6 @@ const Keep = "keep" type T struct{} -// func Old() string { return fmt.Sprint("old") } +// func Old() string { return fmt.Sprint("old") } func KeepFn() string { return Keep } -// func (T) M() string { return fmt.Sprint("old method") } +// func (T) M() string { return fmt.Sprint("old method") } diff --git a/runtime/_patch/_test/skip-and-override/output/demo/z_llgo_patch_patch.go b/runtime/_patch/_test/skip-and-override/output/z_llgo_patch_patch.go.txt similarity index 82% rename from runtime/_patch/_test/skip-and-override/output/demo/z_llgo_patch_patch.go rename to runtime/_patch/_test/skip-and-override/output/z_llgo_patch_patch.go.txt index 580071c98c..102cd5cdfa 100644 --- a/runtime/_patch/_test/skip-and-override/output/demo/z_llgo_patch_patch.go +++ b/runtime/_patch/_test/skip-and-override/output/z_llgo_patch_patch.go.txt @@ -7,5 +7,5 @@ import "strings" var Added = strings.ToUpper("added") -func Old() string { return "new" } +func Old() string { return "new" } func (T) M() string { return "new method" } diff --git a/runtime/_patch/_test/skip-and-override/patch/demo/patch.go b/runtime/_patch/_test/skip-and-override/patch/patch.go similarity index 78% rename from runtime/_patch/_test/skip-and-override/patch/demo/patch.go rename to runtime/_patch/_test/skip-and-override/patch/patch.go index afd13f95fb..2a4175bc2a 100644 --- a/runtime/_patch/_test/skip-and-override/patch/demo/patch.go +++ b/runtime/_patch/_test/skip-and-override/patch/patch.go @@ -6,5 +6,5 @@ import "strings" var Added = strings.ToUpper("added") -func Old() string { return "new" } +func Old() string { return "new" } func (T) M() string { return "new method" } diff --git a/runtime/_patch/_test/skip-and-override/pkg/demo/demo.go b/runtime/_patch/_test/skip-and-override/pkg/demo.go similarity index 55% rename from runtime/_patch/_test/skip-and-override/pkg/demo/demo.go rename to runtime/_patch/_test/skip-and-override/pkg/demo.go index f08c3dafd1..ca7c281777 100644 --- a/runtime/_patch/_test/skip-and-override/pkg/demo/demo.go +++ b/runtime/_patch/_test/skip-and-override/pkg/demo.go @@ -8,6 +8,6 @@ var Drop = fmt.Sprint("drop") type T struct{} -func Old() string { return fmt.Sprint("old") } +func Old() string { return fmt.Sprint("old") } func KeepFn() string { return Keep } -func (T) M() string { return fmt.Sprint("old method") } +func (T) M() string { return fmt.Sprint("old method") } diff --git a/runtime/_patch/_test/skipall/output/demo/demo.go b/runtime/_patch/_test/skipall/output/demo.go.txt similarity index 100% rename from runtime/_patch/_test/skipall/output/demo/demo.go rename to runtime/_patch/_test/skipall/output/demo.go.txt diff --git a/runtime/_patch/_test/skipall/output/demo/z_llgo_patch_patch.go b/runtime/_patch/_test/skipall/output/z_llgo_patch_patch.go.txt similarity index 100% rename from runtime/_patch/_test/skipall/output/demo/z_llgo_patch_patch.go rename to runtime/_patch/_test/skipall/output/z_llgo_patch_patch.go.txt diff --git a/runtime/_patch/_test/skipall/patch/demo/patch.go b/runtime/_patch/_test/skipall/patch/patch.go similarity index 100% rename from runtime/_patch/_test/skipall/patch/demo/patch.go rename to runtime/_patch/_test/skipall/patch/patch.go diff --git a/runtime/_patch/_test/skipall/pkg/demo/demo.go b/runtime/_patch/_test/skipall/pkg/demo.go similarity index 100% rename from runtime/_patch/_test/skipall/pkg/demo/demo.go rename to runtime/_patch/_test/skipall/pkg/demo.go From 7424944d1a04b213bf928e60522a08d08795d7b0 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Mon, 30 Mar 2026 09:15:46 +0800 Subject: [PATCH 25/44] test: cover generic source patch declarations --- internal/build/source_patch_test.go | 55 +++++++++++++++++-- .../output/demo.go.txt | 11 ++++ .../output/z_llgo_patch_patch.go.txt | 13 +++++ .../patch/patch.go | 12 ++++ .../pkg/demo.go | 11 ++++ .../output/demo.go.txt | 7 +++ .../output/z_llgo_patch_patch.go.txt | 8 +++ .../generic-type-and-method/patch/patch.go | 7 +++ .../_test/generic-type-and-method/pkg/demo.go | 7 +++ .../output/demo.go.txt | 13 +++++ .../output/z_llgo_patch_patch.go.txt | 14 +++++ .../patch/patch.go | 13 +++++ .../type-alias-and-grouped-values/pkg/demo.go | 13 +++++ 13 files changed, 179 insertions(+), 5 deletions(-) create mode 100644 runtime/_patch/_test/generic-constraints-and-interface/output/demo.go.txt create mode 100644 runtime/_patch/_test/generic-constraints-and-interface/output/z_llgo_patch_patch.go.txt create mode 100644 runtime/_patch/_test/generic-constraints-and-interface/patch/patch.go create mode 100644 runtime/_patch/_test/generic-constraints-and-interface/pkg/demo.go create mode 100644 runtime/_patch/_test/generic-type-and-method/output/demo.go.txt create mode 100644 runtime/_patch/_test/generic-type-and-method/output/z_llgo_patch_patch.go.txt create mode 100644 runtime/_patch/_test/generic-type-and-method/patch/patch.go create mode 100644 runtime/_patch/_test/generic-type-and-method/pkg/demo.go create mode 100644 runtime/_patch/_test/type-alias-and-grouped-values/output/demo.go.txt create mode 100644 runtime/_patch/_test/type-alias-and-grouped-values/output/z_llgo_patch_patch.go.txt create mode 100644 runtime/_patch/_test/type-alias-and-grouped-values/patch/patch.go create mode 100644 runtime/_patch/_test/type-alias-and-grouped-values/pkg/demo.go diff --git a/internal/build/source_patch_test.go b/internal/build/source_patch_test.go index 448803a423..65ac611d30 100644 --- a/internal/build/source_patch_test.go +++ b/internal/build/source_patch_test.go @@ -91,10 +91,13 @@ func TestInternalRuntimeSysRemainsAltPkg(t *testing.T) { func TestApplySourcePatchForPkg_Cases(t *testing.T) { for _, caseName := range []string{ "default-override", + "generic-constraints-and-interface", + "generic-type-and-method", "multi-file-skipall", "multi-file-with-asm", "skip-and-override", "skipall", + "type-alias-and-grouped-values", } { t.Run(caseName, func(t *testing.T) { runSourcePatchCase(t, caseName) @@ -225,7 +228,7 @@ func runSourcePatchCase(t *testing.T, caseName string) { } assertOverlayMatchesOutput(t, overlay, srcDir, filepath.Join(assetRoot, "output"), runtimeDir) - assertGeneratedPatchPackagePositions(t, overlay, srcDir, patchDir) + assertGeneratedPatchPositions(t, overlay, srcDir, patchDir) } func copyTree(t *testing.T, srcRoot, dstRoot string) { @@ -329,7 +332,7 @@ func sortedMapKeys(m map[string]string) []string { return keys } -func assertGeneratedPatchPackagePositions(t *testing.T, overlay map[string][]byte, srcRoot, patchRoot string) { +func assertGeneratedPatchPositions(t *testing.T, overlay map[string][]byte, srcRoot, patchRoot string) { t.Helper() for rel, src := range overlayFilesUnderRoot(t, overlay, srcRoot) { base := filepath.Base(rel) @@ -338,18 +341,60 @@ func assertGeneratedPatchPackagePositions(t *testing.T, overlay map[string][]byt } original := strings.TrimPrefix(base, "z_llgo_patch_") patchFile := filepath.Join(patchRoot, filepath.Dir(rel), original) - assertPatchedPosition(t, src, filepath.Join(srcRoot, filepath.FromSlash(rel)), patchFile, "package", packageLineOfFile(t, patchFile)) + for _, target := range patchedTargetsOfFile(t, patchFile) { + assertPatchedPosition(t, src, filepath.Join(srcRoot, filepath.FromSlash(rel)), patchFile, target.key, target.line) + } } } -func packageLineOfFile(t *testing.T, filename string) int { +type patchedTarget struct { + key string + line int +} + +func patchedTargetsOfFile(t *testing.T, filename string) []patchedTarget { t.Helper() fset := token.NewFileSet() file, err := parser.ParseFile(fset, filename, nil, parser.ParseComments) if err != nil { t.Fatal(err) } - return fset.Position(file.Package).Line + targets := []patchedTarget{{ + key: "package", + line: fset.Position(file.Package).Line, + }} + for _, decl := range file.Decls { + switch decl := decl.(type) { + case *ast.FuncDecl: + key := "func:" + decl.Name.Name + if decl.Recv != nil && len(decl.Recv.List) != 0 { + key = "method:" + recvPatchKey(decl.Recv.List[0].Type) + "." + decl.Name.Name + } + targets = append(targets, patchedTarget{ + key: key, + line: fset.Position(decl.Name.Pos()).Line, + }) + case *ast.GenDecl: + kind := strings.ToLower(decl.Tok.String()) + for _, spec := range decl.Specs { + switch spec := spec.(type) { + case *ast.TypeSpec: + targets = append(targets, patchedTarget{ + key: "type:" + spec.Name.Name, + line: fset.Position(spec.Name.Pos()).Line, + }) + case *ast.ValueSpec: + for _, name := range spec.Names { + targets = append(targets, patchedTarget{ + key: kind + ":" + name.Name, + line: fset.Position(name.Pos()).Line, + }) + } + } + } + } + } + return targets } func mustWriteFile(t *testing.T, filename, content string) { diff --git a/runtime/_patch/_test/generic-constraints-and-interface/output/demo.go.txt b/runtime/_patch/_test/generic-constraints-and-interface/output/demo.go.txt new file mode 100644 index 0000000000..18996bd934 --- /dev/null +++ b/runtime/_patch/_test/generic-constraints-and-interface/output/demo.go.txt @@ -0,0 +1,11 @@ +package demo + +// type Number interface { + // ~int | ~int64 +// } + +// type Set[T comparable] interface { + // Has(T) bool +// } + +// func Sum[T Number](a, b T) T { return a + b } diff --git a/runtime/_patch/_test/generic-constraints-and-interface/output/z_llgo_patch_patch.go.txt b/runtime/_patch/_test/generic-constraints-and-interface/output/z_llgo_patch_patch.go.txt new file mode 100644 index 0000000000..37c500a684 --- /dev/null +++ b/runtime/_patch/_test/generic-constraints-and-interface/output/z_llgo_patch_patch.go.txt @@ -0,0 +1,13 @@ +//line {{PATCH_ROOT}}/demo/patch.go:1 +package demo + +type Number interface { + ~int | ~int32 | ~int64 +} + +type Set[T comparable] interface { + Has(T) bool + Len() int +} + +func Sum[T Number](a, b T) T { return a } diff --git a/runtime/_patch/_test/generic-constraints-and-interface/patch/patch.go b/runtime/_patch/_test/generic-constraints-and-interface/patch/patch.go new file mode 100644 index 0000000000..8ce6fd6691 --- /dev/null +++ b/runtime/_patch/_test/generic-constraints-and-interface/patch/patch.go @@ -0,0 +1,12 @@ +package demo + +type Number interface { + ~int | ~int32 | ~int64 +} + +type Set[T comparable] interface { + Has(T) bool + Len() int +} + +func Sum[T Number](a, b T) T { return a } diff --git a/runtime/_patch/_test/generic-constraints-and-interface/pkg/demo.go b/runtime/_patch/_test/generic-constraints-and-interface/pkg/demo.go new file mode 100644 index 0000000000..aa117ba443 --- /dev/null +++ b/runtime/_patch/_test/generic-constraints-and-interface/pkg/demo.go @@ -0,0 +1,11 @@ +package demo + +type Number interface { + ~int | ~int64 +} + +type Set[T comparable] interface { + Has(T) bool +} + +func Sum[T Number](a, b T) T { return a + b } diff --git a/runtime/_patch/_test/generic-type-and-method/output/demo.go.txt b/runtime/_patch/_test/generic-type-and-method/output/demo.go.txt new file mode 100644 index 0000000000..76ca83b2be --- /dev/null +++ b/runtime/_patch/_test/generic-type-and-method/output/demo.go.txt @@ -0,0 +1,7 @@ +package demo + +// type Box[T any] struct{ V T } + +// func (b Box[T]) Old() T { return b.V } + +func Keep[T any](v T) T { return v } diff --git a/runtime/_patch/_test/generic-type-and-method/output/z_llgo_patch_patch.go.txt b/runtime/_patch/_test/generic-type-and-method/output/z_llgo_patch_patch.go.txt new file mode 100644 index 0000000000..abced97d39 --- /dev/null +++ b/runtime/_patch/_test/generic-type-and-method/output/z_llgo_patch_patch.go.txt @@ -0,0 +1,8 @@ +//line {{PATCH_ROOT}}/demo/patch.go:1 +package demo + +type Box[T any] struct{ Value T } + +func (b Box[T]) Old() T { return b.Value } + +func Added[T any](v T) T { return v } diff --git a/runtime/_patch/_test/generic-type-and-method/patch/patch.go b/runtime/_patch/_test/generic-type-and-method/patch/patch.go new file mode 100644 index 0000000000..2b3234965c --- /dev/null +++ b/runtime/_patch/_test/generic-type-and-method/patch/patch.go @@ -0,0 +1,7 @@ +package demo + +type Box[T any] struct{ Value T } + +func (b Box[T]) Old() T { return b.Value } + +func Added[T any](v T) T { return v } diff --git a/runtime/_patch/_test/generic-type-and-method/pkg/demo.go b/runtime/_patch/_test/generic-type-and-method/pkg/demo.go new file mode 100644 index 0000000000..f2191f8991 --- /dev/null +++ b/runtime/_patch/_test/generic-type-and-method/pkg/demo.go @@ -0,0 +1,7 @@ +package demo + +type Box[T any] struct{ V T } + +func (b Box[T]) Old() T { return b.V } + +func Keep[T any](v T) T { return v } diff --git a/runtime/_patch/_test/type-alias-and-grouped-values/output/demo.go.txt b/runtime/_patch/_test/type-alias-and-grouped-values/output/demo.go.txt new file mode 100644 index 0000000000..4a65916cdb --- /dev/null +++ b/runtime/_patch/_test/type-alias-and-grouped-values/output/demo.go.txt @@ -0,0 +1,13 @@ +package demo + +// type Text = string + +const ( + // ReplaceConst = "old" + KeepConst = "keep" +) + +var ( + // ReplaceVar = "old" + KeepVar = "keep" +) diff --git a/runtime/_patch/_test/type-alias-and-grouped-values/output/z_llgo_patch_patch.go.txt b/runtime/_patch/_test/type-alias-and-grouped-values/output/z_llgo_patch_patch.go.txt new file mode 100644 index 0000000000..43b94f97f8 --- /dev/null +++ b/runtime/_patch/_test/type-alias-and-grouped-values/output/z_llgo_patch_patch.go.txt @@ -0,0 +1,14 @@ +//line {{PATCH_ROOT}}/demo/patch.go:1 +package demo + +type Text = []byte + +const ( + ReplaceConst = "new" + AddedConst = "added" +) + +var ( + ReplaceVar = "new" + AddedVar = "added" +) diff --git a/runtime/_patch/_test/type-alias-and-grouped-values/patch/patch.go b/runtime/_patch/_test/type-alias-and-grouped-values/patch/patch.go new file mode 100644 index 0000000000..f39a26517f --- /dev/null +++ b/runtime/_patch/_test/type-alias-and-grouped-values/patch/patch.go @@ -0,0 +1,13 @@ +package demo + +type Text = []byte + +const ( + ReplaceConst = "new" + AddedConst = "added" +) + +var ( + ReplaceVar = "new" + AddedVar = "added" +) diff --git a/runtime/_patch/_test/type-alias-and-grouped-values/pkg/demo.go b/runtime/_patch/_test/type-alias-and-grouped-values/pkg/demo.go new file mode 100644 index 0000000000..8ccda75fe3 --- /dev/null +++ b/runtime/_patch/_test/type-alias-and-grouped-values/pkg/demo.go @@ -0,0 +1,13 @@ +package demo + +type Text = string + +const ( + ReplaceConst = "old" + KeepConst = "keep" +) + +var ( + ReplaceVar = "old" + KeepVar = "keep" +) From e0c2ea23327d85b24b7069bde3cab3b6696462b9 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Sun, 29 Mar 2026 13:06:15 +0800 Subject: [PATCH 26/44] cl: add boolToUint8 intrinsic --- cl/compile_test.go | 37 +++++++++++++++++++++++++++++++++++++ cl/import.go | 1 + cl/instr.go | 16 ++++++++++++++++ 3 files changed, 54 insertions(+) diff --git a/cl/compile_test.go b/cl/compile_test.go index 657fe3b923..454f2a8bd1 100644 --- a/cl/compile_test.go +++ b/cl/compile_test.go @@ -384,3 +384,40 @@ _llgo_2: ; preds = %_llgo_1, %_llgo_0 } `) } + +func TestIntrinsicBoolToUint8(t *testing.T) { + testCompile(t, `package foo + +import _ "unsafe" + +//go:linkname boolToUint8 llgo.boolToUint8 +func boolToUint8(b bool) uint8 + +func use(b bool) uint8 { + return boolToUint8(b) +} +`, `; ModuleID = 'foo' +source_filename = "foo" + +@"foo.init$guard" = global i1 false, align 1 + +define void @foo.init() { +_llgo_0: + %0 = load i1, ptr @"foo.init$guard", align 1 + br i1 %0, label %_llgo_2, label %_llgo_1 + +_llgo_1: ; preds = %_llgo_0 + store i1 true, ptr @"foo.init$guard", align 1 + br label %_llgo_2 + +_llgo_2: ; preds = %_llgo_1, %_llgo_0 + ret void +} + +define i8 @foo.use(i1 %0) { +_llgo_0: + %1 = select i1 %0, i8 1, i8 0 + ret i8 %1 +} +`) +} diff --git a/cl/import.go b/cl/import.go index 2af85a1a73..fa15f5605a 100644 --- a/cl/import.go +++ b/cl/import.go @@ -552,6 +552,7 @@ const ( llgoSyscall = llgoInstrBase + 0x44 llgoAtomicCmpXchgOK = llgoInstrBase + 0x45 llgoAtomicAddReturnNew = llgoInstrBase + 0x46 + llgoBoolToUint8 = llgoInstrBase + 0x47 llgoAtomicOpLast = llgoAtomicOpBase + int(llssa.OpUMin) ) diff --git a/cl/instr.go b/cl/instr.go index c1d9933a50..f699831622 100644 --- a/cl/instr.go +++ b/cl/instr.go @@ -551,6 +551,16 @@ func (p *context) atomicCmpXchgOK(b llssa.Builder, args []llssa.Expr) llssa.Expr return b.Extract(ret, 1) } +func (p *context) boolToUint8(b llssa.Builder, args []llssa.Expr) llssa.Expr { + if len(args) == 1 { + retType := p.type_(types.Typ[types.Uint8], llssa.InGo) + one := p.prog.IntVal(1, retType) + zero := p.prog.Zero(retType) + return b.SelectValue(args[0], one, zero) + } + panic("boolToUint8(b bool) uint8: invalid arguments") +} + // ----------------------------------------------------------------------------- var llgoInstrs = map[string]int{ @@ -567,6 +577,7 @@ var llgoInstrs = map[string]int{ "funcPCABI0": llgoFuncPCABI0, "skip": llgoSkip, "syscall": llgoSyscall, + "boolToUint8": llgoBoolToUint8, "pystr": llgoPyStr, "pyList": llgoPyList, "pyTuple": llgoPyTuple, @@ -790,6 +801,11 @@ func (p *context) call(b llssa.Builder, act llssa.DoAction, call *ssa.CallCommon } case llgoSyscall: ret = p.syscallIntrinsic(b, args, call.Signature().Results()) + case llgoBoolToUint8: + args := p.compileValues(b, args, kind) + ret = b.Do(act, llssa.Nil, func(b llssa.Builder, _ llssa.Expr, args ...llssa.Expr) llssa.Expr { + return p.boolToUint8(b, args) + }, args...) case llgoUnreachable: // func unreachable() b.Unreachable() case llgoAtomicLoad: From 9a5e5bb3052d377fbfdb70bb829894ab4ad24b81 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Sat, 28 Mar 2026 14:33:41 +0800 Subject: [PATCH 27/44] runtime: add incremental go1.26 compat --- go.mod | 2 +- go.sum | 2 + internal/build/source_patch_test.go | 43 ++++ internal/plan9asm/translate.go | 16 ++ runtime/build.go | 22 +- .../internal/constanttime/constant_time.go | 39 ++++ .../internal/lib/internal/sync/hashtriemap.go | 201 ++++++++++++++++ runtime/internal/lib/internal/sync/mutex.go | 151 ++++++++++++ runtime/internal/lib/internal/sync/runtime.go | 26 +++ runtime/internal/lib/reflect/type_go123.go | 4 +- runtime/internal/lib/reflect/type_go126.go | 215 ++++++++++++++++++ runtime/internal/lib/reflect/value.go | 38 ++-- .../internal/lib/runtime/dit_linkname_llgo.go | 17 ++ .../internal/lib/runtime/fipsbypass_llgo.go | 37 +++ .../lib/runtime/pprof_linkname_llgo.go | 13 ++ .../lib/runtime/runtime_clearenv_llgo.go | 12 + .../lib/runtime/syscall_darwin_go126_llgo.go | 63 +++++ .../lib/runtime/syscall_darwin_llgo.go | 2 +- 18 files changed, 873 insertions(+), 30 deletions(-) create mode 100644 runtime/internal/lib/crypto/internal/constanttime/constant_time.go create mode 100644 runtime/internal/lib/internal/sync/hashtriemap.go create mode 100644 runtime/internal/lib/internal/sync/mutex.go create mode 100644 runtime/internal/lib/internal/sync/runtime.go create mode 100644 runtime/internal/lib/reflect/type_go126.go create mode 100644 runtime/internal/lib/runtime/dit_linkname_llgo.go create mode 100644 runtime/internal/lib/runtime/fipsbypass_llgo.go create mode 100644 runtime/internal/lib/runtime/runtime_clearenv_llgo.go create mode 100644 runtime/internal/lib/runtime/syscall_darwin_go126_llgo.go diff --git a/go.mod b/go.mod index e5162166fb..ae896f8285 100644 --- a/go.mod +++ b/go.mod @@ -17,7 +17,7 @@ require ( ) require ( - github.com/goplus/plan9asm v0.0.0-20260307134905-822503d6bf44 + github.com/goplus/plan9asm v0.1.1-0.20260327232615-ec1a30b9181f github.com/marcinbor85/gohex v0.0.0-20210308104911-55fb1c624d84 github.com/mattn/go-tty v0.0.7 github.com/sigurn/crc16 v0.0.0-20240131213347-83fcde1e29d1 diff --git a/go.sum b/go.sum index 25b6036285..9c260e8abc 100644 --- a/go.sum +++ b/go.sum @@ -22,6 +22,8 @@ github.com/goplus/plan9asm v0.0.0-20260307044640-a5f1e3b27fc1 h1:hlVAtc3x34x6CQo github.com/goplus/plan9asm v0.0.0-20260307044640-a5f1e3b27fc1/go.mod h1:nnr49+IlbnOI5c0yb1fkbilBRcr50RPX0JAreDdYTUI= github.com/goplus/plan9asm v0.0.0-20260307134905-822503d6bf44 h1:zZXTz5CBO1uZIJGZSGWov5gE1CbulJ1QH6ruTMv3UdY= github.com/goplus/plan9asm v0.0.0-20260307134905-822503d6bf44/go.mod h1:gpS4VVNoRykYTtc8kPFBowraN5SrBj8lIjW8/lNjaG4= +github.com/goplus/plan9asm v0.1.1-0.20260327232615-ec1a30b9181f h1:DICfzr9FWlZPnKJcS0tMnIRQ1oWk1sFU4S1uYJ0jOTo= +github.com/goplus/plan9asm v0.1.1-0.20260327232615-ec1a30b9181f/go.mod h1:gpS4VVNoRykYTtc8kPFBowraN5SrBj8lIjW8/lNjaG4= github.com/marcinbor85/gohex v0.0.0-20210308104911-55fb1c624d84 h1:hyAgCuG5nqTMDeUD8KZs7HSPs6KprPgPP8QmGV8nyvk= github.com/marcinbor85/gohex v0.0.0-20210308104911-55fb1c624d84/go.mod h1:Pb6XcsXyropB9LNHhnqaknG/vEwYztLkQzVCHv8sQ3M= github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= diff --git a/internal/build/source_patch_test.go b/internal/build/source_patch_test.go index 65ac611d30..8e049192aa 100644 --- a/internal/build/source_patch_test.go +++ b/internal/build/source_patch_test.go @@ -58,6 +58,49 @@ func TestIterUsesSourcePatchInsteadOfAltPkg(t *testing.T) { } } +func TestBuildSourcePatchOverlayForInternalSync(t *testing.T) { + overlay, err := buildSourcePatchOverlayForGOROOT(nil, env.LLGoRuntimeDir(), runtime.GOROOT(), sourcePatchBuildContext{ + goos: runtime.GOOS, + goarch: runtime.GOARCH, + goversion: "go1.26.0", + }) + if err != nil { + t.Fatal(err) + } + + syncDir := filepath.Join(runtime.GOROOT(), "src", "internal", "sync") + patchFile := filepath.Join(syncDir, "z_llgo_patch_hashtriemap.go") + patchSrc, ok := overlay[patchFile] + if !ok { + t.Fatalf("missing source patch file %s", patchFile) + } + if !strings.Contains(string(patchSrc), "type HashTrieMap") { + t.Fatalf("source patch file %s does not contain HashTrieMap replacement", patchFile) + } + + stdFile := filepath.Join(syncDir, "hashtriemap.go") + stdSrc, ok := overlay[stdFile] + if !ok { + t.Fatalf("missing stub overlay for %s", stdFile) + } + got := string(stdSrc) + if !strings.Contains(got, "package sync") { + t.Fatalf("stub overlay for %s lost package clause", stdFile) + } + if strings.Contains(got, "type HashTrieMap") { + t.Fatalf("stub overlay for %s still contains original declarations", stdFile) + } +} + +func TestInternalSyncUsesSourcePatchInsteadOfAltPkg(t *testing.T) { + if !llruntime.HasSourcePatchPkg("internal/sync") { + t.Fatal("internal/sync should be registered as a source patch package") + } + if llruntime.HasAltPkg("internal/sync") { + t.Fatal("internal/sync should not remain an alt package") + } +} + func TestSyncAtomicRemainsAltPkg(t *testing.T) { if llruntime.HasSourcePatchPkg("sync/atomic") { t.Fatal("sync/atomic should not be registered as a source patch package") diff --git a/internal/plan9asm/translate.go b/internal/plan9asm/translate.go index dcc674c99e..f988f09016 100644 --- a/internal/plan9asm/translate.go +++ b/internal/plan9asm/translate.go @@ -209,5 +209,21 @@ func extraAsmSigsAndDeclMap(pkgPath string, goarch string) map[string]extplan9as manual["internal/bytealg.memeqbody"] = extplan9asm.FuncSig{Args: []extplan9asm.LLVMType{extplan9asm.Ptr, extplan9asm.Ptr, extplan9asm.I64}, Ret: extplan9asm.I1, ArgRegs: []extplan9asm.Reg{extplan9asm.SI, extplan9asm.DI, extplan9asm.BX}} } } + if pkgPath == "internal/runtime/gc/scan" && goarch == "amd64" { + // Go 1.26 emits local AVX512 scan expanders with no Go declarations. + // They still need signatures so the translator can keep the asm entry + // points and wire the packed mask argument through AX. + for _, n := range []int{ + 1, 2, 3, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, + 36, 40, 44, 48, 52, 56, 60, 64, + } { + name := fmt.Sprintf("internal/runtime/gc/scan.expandAVX512_%d", n) + manual[name] = extplan9asm.FuncSig{ + Args: []extplan9asm.LLVMType{extplan9asm.Ptr}, + Ret: extplan9asm.Void, + ArgRegs: []extplan9asm.Reg{extplan9asm.AX}, + } + } + } return manual } diff --git a/runtime/build.go b/runtime/build.go index 3838de6ca8..37a176cf41 100644 --- a/runtime/build.go +++ b/runtime/build.go @@ -40,17 +40,19 @@ func SourcePatchPkgPaths() []string { } var altPkgs = map[string]altPkgMode{ - "internal/abi": altPkgReplace, - "internal/reflectlite": altPkgReplace, - "internal/runtime/maps": altPkgReplace, - "internal/runtime/sys": altPkgAdditive, - "reflect": altPkgReplace, - "runtime": altPkgReplace, - "sync/atomic": altPkgReplace, - "syscall/js": altPkgReplace, - "unique": altPkgReplace, + "crypto/internal/constanttime": altPkgReplace, + "internal/abi": altPkgReplace, + "internal/reflectlite": altPkgReplace, + "internal/runtime/maps": altPkgReplace, + "internal/runtime/sys": altPkgAdditive, + "reflect": altPkgReplace, + "runtime": altPkgReplace, + "sync/atomic": altPkgReplace, + "syscall/js": altPkgReplace, + "unique": altPkgReplace, } var sourcePatchPkgs = map[string]struct{}{ - "iter": {}, + "internal/sync": {}, + "iter": {}, } diff --git a/runtime/internal/lib/crypto/internal/constanttime/constant_time.go b/runtime/internal/lib/crypto/internal/constanttime/constant_time.go new file mode 100644 index 0000000000..30c0de8aa4 --- /dev/null +++ b/runtime/internal/lib/crypto/internal/constanttime/constant_time.go @@ -0,0 +1,39 @@ +// Copyright 2025 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package constanttime + +// The stdlib version uses a compiler intrinsic for boolToUint8. +// llgo doesn't lower that intrinsic yet, so keep the same API surface with +// a direct implementation for now. + +// Select returns x if v == 1 and y if v == 0. +// Its behavior is undefined if v takes any other value. +func Select(v, x, y int) int { + v = int(boolToUint8(v != 0)) + return ^(v-1)&x | (v-1)&y +} + +// ByteEq returns 1 if x == y and 0 otherwise. +func ByteEq(x, y uint8) int { + return int(boolToUint8(x == y)) +} + +// Eq returns 1 if x == y and 0 otherwise. +func Eq(x, y int32) int { + return int(boolToUint8(x == y)) +} + +// LessOrEq returns 1 if x <= y and 0 otherwise. +// Its behavior is undefined if x or y are negative or > 2**31 - 1. +func LessOrEq(x, y int) int { + return int(boolToUint8(x <= y)) +} + +func boolToUint8(b bool) uint8 { + if b { + return 1 + } + return 0 +} diff --git a/runtime/internal/lib/internal/sync/hashtriemap.go b/runtime/internal/lib/internal/sync/hashtriemap.go new file mode 100644 index 0000000000..7b3fda63d6 --- /dev/null +++ b/runtime/internal/lib/internal/sync/hashtriemap.go @@ -0,0 +1,201 @@ +//go:build go1.26 + +//llgo:skipall +package sync + +import ( + "sync/atomic" + "unsafe" +) + +type hashFunc func(unsafe.Pointer, uintptr) uintptr +type equalFunc func(unsafe.Pointer, unsafe.Pointer) bool + +const ( + nChildrenLog2 = 4 + nChildren = 1 << nChildrenLog2 +) + +type node[K comparable, V any] struct { + isEntry bool +} + +type indirect[K comparable, V any] struct { + node[K, V] + dead atomic.Bool + mu Mutex + parent *indirect[K, V] + children [nChildren]atomic.Pointer[node[K, V]] +} + +type entry[K comparable, V any] struct { + node[K, V] + overflow atomic.Pointer[entry[K, V]] + key K + value V +} + +// HashTrieMap is a compatibility implementation for llgo. +// It preserves the zero-value and concurrency semantics expected by sync.Map, +// but uses a simple mutex-protected Go map instead of the runtime hash trie. +type HashTrieMap[K comparable, V any] struct { + // Keep the leading field layout compatible with the upstream type so + // imported stdlib code that still selects these fields by index can build. + inited atomic.Uint32 + initMu Mutex + root atomic.Pointer[indirect[K, V]] + keyHash hashFunc + valEqual equalFunc + seed uintptr + + mu Mutex + m []hashTrieEntry[K, V] +} + +type hashTrieEntry[K comparable, V any] struct { + key K + value V +} + +func (ht *HashTrieMap[K, V]) ensureMap() { + if ht.m == nil { + ht.m = make([]hashTrieEntry[K, V], 0) + } +} + +func (ht *HashTrieMap[K, V]) Load(key K) (value V, ok bool) { + ht.mu.Lock() + if i := ht.findIndex(key); i >= 0 { + value, ok = ht.m[i].value, true + } + ht.mu.Unlock() + return +} + +func (ht *HashTrieMap[K, V]) LoadOrStore(key K, value V) (result V, loaded bool) { + ht.mu.Lock() + ht.ensureMap() + if i := ht.findIndex(key); i >= 0 { + existing := ht.m[i].value + ht.mu.Unlock() + return existing, true + } + ht.m = append(ht.m, hashTrieEntry[K, V]{key: key, value: value}) + ht.mu.Unlock() + return value, false +} + +func (ht *HashTrieMap[K, V]) Store(key K, value V) { + _, _ = ht.Swap(key, value) +} + +func (ht *HashTrieMap[K, V]) Swap(key K, new V) (previous V, loaded bool) { + ht.mu.Lock() + ht.ensureMap() + if i := ht.findIndex(key); i >= 0 { + previous = ht.m[i].value + ht.m[i].value = new + loaded = true + } else { + ht.m = append(ht.m, hashTrieEntry[K, V]{key: key, value: new}) + } + ht.mu.Unlock() + return +} + +func (ht *HashTrieMap[K, V]) CompareAndSwap(key K, old, new V) bool { + ht.mu.Lock() + defer ht.mu.Unlock() + if i := ht.findIndex(key); i < 0 { + return false + } else if !hashTrieValueEqual(ht.m[i].value, old) { + return false + } else { + ht.m[i].value = new + return true + } +} + +func (ht *HashTrieMap[K, V]) LoadAndDelete(key K) (value V, loaded bool) { + ht.mu.Lock() + if i := ht.findIndex(key); i >= 0 { + value, loaded = ht.m[i].value, true + ht.deleteIndex(i) + } + ht.mu.Unlock() + return +} + +func (ht *HashTrieMap[K, V]) Delete(key K) { + _, _ = ht.LoadAndDelete(key) +} + +func (ht *HashTrieMap[K, V]) CompareAndDelete(key K, old V) bool { + ht.mu.Lock() + defer ht.mu.Unlock() + if i := ht.findIndex(key); i < 0 { + return false + } else if !hashTrieValueEqual(ht.m[i].value, old) { + return false + } else { + ht.deleteIndex(i) + return true + } +} + +func (ht *HashTrieMap[K, V]) All() func(yield func(K, V) bool) { + return func(yield func(K, V) bool) { + entries := ht.snapshot() + for _, entry := range entries { + if !yield(entry.key, entry.value) { + return + } + } + } +} + +func (ht *HashTrieMap[K, V]) Range(yield func(K, V) bool) { + ht.All()(yield) +} + +func (ht *HashTrieMap[K, V]) Clear() { + ht.mu.Lock() + ht.m = nil + ht.mu.Unlock() +} + +func (ht *HashTrieMap[K, V]) snapshot() []hashTrieEntry[K, V] { + ht.mu.Lock() + defer ht.mu.Unlock() + if len(ht.m) == 0 { + return nil + } + entries := make([]hashTrieEntry[K, V], len(ht.m)) + copy(entries, ht.m) + return entries +} + +func hashTrieValueEqual[V any](a, b V) bool { + return any(a) == any(b) +} + +func hashTrieKeyEqual[K comparable](a, b K) bool { + return any(a) == any(b) +} + +func (ht *HashTrieMap[K, V]) findIndex(key K) int { + for i := range ht.m { + if hashTrieKeyEqual(ht.m[i].key, key) { + return i + } + } + return -1 +} + +func (ht *HashTrieMap[K, V]) deleteIndex(i int) { + last := len(ht.m) - 1 + ht.m[i] = ht.m[last] + var zero hashTrieEntry[K, V] + ht.m[last] = zero + ht.m = ht.m[:last] +} diff --git a/runtime/internal/lib/internal/sync/mutex.go b/runtime/internal/lib/internal/sync/mutex.go new file mode 100644 index 0000000000..ff6f23104f --- /dev/null +++ b/runtime/internal/lib/internal/sync/mutex.go @@ -0,0 +1,151 @@ +//go:build go1.26 + +package sync + +import ( + "internal/race" + "sync/atomic" + "unsafe" +) + +// A Mutex is a mutual exclusion lock. +// +// See package [sync.Mutex] documentation. +type Mutex struct { + state int32 + sema uint32 +} + +const ( + mutexLocked = 1 << iota + mutexWoken + mutexStarving + mutexWaiterShift = iota + + starvationThresholdNs = 1e6 +) + +func (m *Mutex) Lock() { + if atomic.CompareAndSwapInt32(&m.state, 0, mutexLocked) { + if race.Enabled { + race.Acquire(unsafe.Pointer(m)) + } + return + } + m.lockSlow() +} + +func (m *Mutex) TryLock() bool { + old := m.state + if old&(mutexLocked|mutexStarving) != 0 { + return false + } + if !atomic.CompareAndSwapInt32(&m.state, old, old|mutexLocked) { + return false + } + if race.Enabled { + race.Acquire(unsafe.Pointer(m)) + } + return true +} + +func (m *Mutex) lockSlow() { + var waitStartTime int64 + starving := false + awoke := false + iter := 0 + old := m.state + for { + if old&(mutexLocked|mutexStarving) == mutexLocked && runtime_canSpin(iter) { + if !awoke && old&mutexWoken == 0 && old>>mutexWaiterShift != 0 && + atomic.CompareAndSwapInt32(&m.state, old, old|mutexWoken) { + awoke = true + } + runtime_doSpin() + iter++ + old = m.state + continue + } + new := old + if old&mutexStarving == 0 { + new |= mutexLocked + } + if old&(mutexLocked|mutexStarving) != 0 { + new += 1 << mutexWaiterShift + } + if starving && old&mutexLocked != 0 { + new |= mutexStarving + } + if awoke { + if new&mutexWoken == 0 { + throw("sync: inconsistent mutex state") + } + new &^= mutexWoken + } + if atomic.CompareAndSwapInt32(&m.state, old, new) { + if old&(mutexLocked|mutexStarving) == 0 { + break + } + queueLifo := waitStartTime != 0 + if waitStartTime == 0 { + waitStartTime = runtime_nanotime() + } + runtime_SemacquireMutex(&m.sema, queueLifo, 2) + starving = starving || runtime_nanotime()-waitStartTime > starvationThresholdNs + old = m.state + if old&mutexStarving != 0 { + if old&(mutexLocked|mutexWoken) != 0 || old>>mutexWaiterShift == 0 { + throw("sync: inconsistent mutex state") + } + delta := int32(mutexLocked - 1<>mutexWaiterShift == 1 { + delta -= mutexStarving + } + atomic.AddInt32(&m.state, delta) + break + } + awoke = true + iter = 0 + } else { + old = m.state + } + } + + if race.Enabled { + race.Acquire(unsafe.Pointer(m)) + } +} + +func (m *Mutex) Unlock() { + if race.Enabled { + _ = m.state + race.Release(unsafe.Pointer(m)) + } + + new := atomic.AddInt32(&m.state, -mutexLocked) + if new != 0 { + m.unlockSlow(new) + } +} + +func (m *Mutex) unlockSlow(new int32) { + if (new+mutexLocked)&mutexLocked == 0 { + fatal("sync: unlock of unlocked mutex") + } + if new&mutexStarving == 0 { + old := new + for { + if old>>mutexWaiterShift == 0 || old&(mutexLocked|mutexWoken|mutexStarving) != 0 { + return + } + new = (old - 1<> (64 - bitSize) + return x != trunc + } + panic("reflect: OverflowInt of non-int type " + t.String()) +} + +func (t *rtype) OverflowUint(x uint64) bool { + k := t.Kind() + switch k { + case Uint, Uintptr, Uint8, Uint16, Uint32, Uint64: + bitSize := t.Size() * 8 + trunc := (x << (64 - bitSize)) >> (64 - bitSize) + return x != trunc + } + panic("reflect: OverflowUint of non-uint type " + t.String()) +} + +func (t *rtype) Methods() iter.Seq[Method] { + return func(yield func(Method) bool) { + for i := 0; i < t.NumMethod(); i++ { + if !yield(t.Method(i)) { + return + } + } + } +} + +func (t *rtype) Fields() iter.Seq[StructField] { + if t.Kind() != Struct { + panic("reflect: Fields of non-struct type " + t.String()) + } + return func(yield func(StructField) bool) { + for i := 0; i < t.NumField(); i++ { + if !yield(t.Field(i)) { + return + } + } + } +} + +func (t *rtype) Ins() iter.Seq[Type] { + if t.Kind() != Func { + panic("reflect: Ins of non-func type " + t.String()) + } + return func(yield func(Type) bool) { + for i := 0; i < t.NumIn(); i++ { + if !yield(t.In(i)) { + return + } + } + } +} + +func (t *rtype) Outs() iter.Seq[Type] { + if t.Kind() != Func { + panic("reflect: Outs of non-func type " + t.String()) + } + return func(yield func(Type) bool) { + for i := 0; i < t.NumOut(); i++ { + if !yield(t.Out(i)) { + return + } + } + } +} + +func (t *rtype) CanSeq() bool { + switch t.Kind() { + case Int8, Int16, Int32, Int64, Int, Uint8, Uint16, Uint32, Uint64, Uint, Uintptr, Array, Slice, Chan, String, Map: + return true + case Func: + return canRangeFunc(&t.t) + case Pointer: + return t.Elem().Kind() == Array + } + return false +} + +func canRangeFunc(t *abi.Type) bool { + if t.Kind() != abi.Func { + return false + } + f := t.FuncType() + if len(f.In) != 1 || len(f.Out) != 0 { + return false + } + y := f.In[0] + if y.Kind() != abi.Func { + return false + } + yield := y.FuncType() + return len(yield.In) == 1 && len(yield.Out) == 1 && yield.Out[0].Kind() == abi.Bool +} + +func (t *rtype) CanSeq2() bool { + switch t.Kind() { + case Array, Slice, String, Map: + return true + case Func: + return canRangeFunc2(&t.t) + case Pointer: + return t.Elem().Kind() == Array + } + return false +} + +func canRangeFunc2(t *abi.Type) bool { + if t.Kind() != abi.Func { + return false + } + f := t.FuncType() + if len(f.In) != 1 || len(f.Out) != 0 { + return false + } + y := f.In[0] + if y.Kind() != abi.Func { + return false + } + yield := y.FuncType() + return len(yield.In) == 2 && len(yield.Out) == 1 && yield.Out[0].Kind() == abi.Bool +} diff --git a/runtime/internal/lib/reflect/value.go b/runtime/internal/lib/reflect/value.go index 61b9d4489a..a093605239 100644 --- a/runtime/internal/lib/reflect/value.go +++ b/runtime/internal/lib/reflect/value.go @@ -140,36 +140,42 @@ func packEface(v Value) any { t := v.typ() var i any e := (*emptyInterface)(unsafe.Pointer(&i)) - // First, fill in the data portion of the interface. + e.word = packEfaceData(v) + // Now, fill in the type portion. We're very careful here not + // to have any operation between the e.word and e.typ assignments + // that would let the garbage collector observe the partially-built + // interface value. + e.typ = t + return i +} + +// packEfaceData is a helper that packs the data word as if v were stored in +// an empty interface. Go 1.26's reflect.TypeAssert refers to it directly. +func packEfaceData(v Value) unsafe.Pointer { + t := v.typ() switch { case t.IfaceIndir(): if v.flag&flagIndir == 0 { panic("bad indir") } - // Value is indirect, and so is the interface we're making. ptr := v.ptr if v.flag&flagAddr != 0 { - // TODO: pass safe boolean from valueInterface so - // we don't need to copy if safe==true? c := unsafe_New(t) typedmemmove(t, c, ptr) ptr = c } - e.word = ptr + return ptr case v.flag&flagIndir != 0: - // Value is indirect, but interface is direct. We need - // to load the data at v.ptr into the interface data word. - e.word = *(*unsafe.Pointer)(v.ptr) + return *(*unsafe.Pointer)(v.ptr) default: - // Value is direct, and so is the interface. - e.word = v.ptr + return v.ptr } - // Now, fill in the type portion. We're very careful here not - // to have any operation between the e.word and e.typ assignments - // that would let the garbage collector observe the partially-built - // interface value. - e.typ = t - return i +} + +// packIfaceValueIntoEmptyIface is used by Go 1.26's reflect.TypeAssert helpers +// when reboxing a non-empty interface value into an empty interface. +func packIfaceValueIntoEmptyIface(v Value) any { + return packEface(v) } // unpackEface converts the empty interface i to a Value. diff --git a/runtime/internal/lib/runtime/dit_linkname_llgo.go b/runtime/internal/lib/runtime/dit_linkname_llgo.go new file mode 100644 index 0000000000..b0807fe6ba --- /dev/null +++ b/runtime/internal/lib/runtime/dit_linkname_llgo.go @@ -0,0 +1,17 @@ +//go:build go1.26 + +package runtime + +import _ "unsafe" + +// llgo does not currently model per-goroutine DIT state. +// Provide minimal linkname shims so crypto/subtle can build and +// fall back to its existing non-DIT behavior when unsupported. + +//go:linkname dit_setEnabled crypto/subtle.setDITEnabled +func dit_setEnabled() bool { + return false +} + +//go:linkname dit_setDisabled crypto/subtle.setDITDisabled +func dit_setDisabled() {} diff --git a/runtime/internal/lib/runtime/fipsbypass_llgo.go b/runtime/internal/lib/runtime/fipsbypass_llgo.go new file mode 100644 index 0000000000..c4f21c462b --- /dev/null +++ b/runtime/internal/lib/runtime/fipsbypass_llgo.go @@ -0,0 +1,37 @@ +//go:build go1.26 + +package runtime + +import ( + _ "unsafe" + + latomic "github.com/goplus/llgo/runtime/internal/lib/sync/atomic" +) + +// llgo does not currently expose runtime.getg in this compatibility layer. +// Keep a minimal process-wide nesting count so crypto/fips140 can link and +// enforce bypass scopes without pulling more runtime internals into this tree. +var fipsBypassCount uint32 + +//go:linkname fips140_setBypass crypto/fips140.setBypass +func fips140_setBypass() { + latomic.AddUint32(&fipsBypassCount, 1) +} + +//go:linkname fips140_unsetBypass crypto/fips140.unsetBypass +func fips140_unsetBypass() { + for { + n := latomic.LoadUint32(&fipsBypassCount) + if n == 0 { + return + } + if latomic.CompareAndSwapUint32(&fipsBypassCount, n, n-1) { + return + } + } +} + +//go:linkname fips140_isBypassed crypto/fips140.isBypassed +func fips140_isBypassed() bool { + return latomic.LoadUint32(&fipsBypassCount) != 0 +} diff --git a/runtime/internal/lib/runtime/pprof_linkname_llgo.go b/runtime/internal/lib/runtime/pprof_linkname_llgo.go index 16c0138370..e7222ac61e 100644 --- a/runtime/internal/lib/runtime/pprof_linkname_llgo.go +++ b/runtime/internal/lib/runtime/pprof_linkname_llgo.go @@ -60,6 +60,19 @@ func pprof_goroutineProfileWithLabels(p []StackRecord, labels []unsafe.Pointer) return 0, true } +//go:linkname runtime_goroutineLeakGC runtime/pprof.runtime_goroutineLeakGC +func runtime_goroutineLeakGC() {} + +//go:linkname runtime_goroutineleakcount runtime/pprof.runtime_goroutineleakcount +func runtime_goroutineleakcount() int { + return 0 +} + +//go:linkname pprof_goroutineLeakProfileWithLabels runtime.pprof_goroutineLeakProfileWithLabels +func pprof_goroutineLeakProfileWithLabels(p []StackRecord, labels []unsafe.Pointer) (n int, ok bool) { + return 0, true +} + //go:linkname pprof_memProfileInternal runtime.pprof_memProfileInternal func pprof_memProfileInternal(p []MemProfileRecord, inuseZero bool) (n int, ok bool) { return 0, true diff --git a/runtime/internal/lib/runtime/runtime_clearenv_llgo.go b/runtime/internal/lib/runtime/runtime_clearenv_llgo.go new file mode 100644 index 0000000000..5a425953b8 --- /dev/null +++ b/runtime/internal/lib/runtime/runtime_clearenv_llgo.go @@ -0,0 +1,12 @@ +//go:build go1.26 && (linux || darwin) + +package runtime + +import _ "unsafe" + +//go:linkname syscall_runtimeClearenv syscall.runtimeClearenv +func syscall_runtimeClearenv(env map[string]int) { + for k := range env { + syscall_runtimeUnsetenv(k) + } +} diff --git a/runtime/internal/lib/runtime/syscall_darwin_go126_llgo.go b/runtime/internal/lib/runtime/syscall_darwin_go126_llgo.go new file mode 100644 index 0000000000..a9eee3feba --- /dev/null +++ b/runtime/internal/lib/runtime/syscall_darwin_go126_llgo.go @@ -0,0 +1,63 @@ +//go:build darwin && go1.26 + +package runtime + +import _ "unsafe" + +//go:linkname llgo_syscall5f64 llgo.syscall +func llgo_syscall5f64(fn, a1, a2, a3, a4, a5 uintptr, f1 float64) (r1, r2, err uintptr) + +//go:linkname llgo_rawSyscall llgo.syscall +func llgo_rawSyscall(fn, a1, a2, a3 uintptr) (r1, r2, err uintptr) + +//go:linkname llgo_rawSyscall6 llgo.syscall +func llgo_rawSyscall6(fn, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr) + +//go:linkname llgo_rawSyscall9 llgo.syscall +func llgo_rawSyscall9(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2, err uintptr) + +// Go 1.26 moves errno normalization into syscall/syscall_darwin.go wrappers +// such as syscall9/rawSyscall9/syscallPtr, so runtime mirrors the raw runtime +// entry points and returns the libc errno unchanged here. + +//go:linkname syscall_syscalln syscall.syscalln +func syscall_syscalln(fn uintptr, args ...uintptr) (r1, r2, err uintptr) { + entersyscall() + r1, r2, err = syscall_rawsyscalln(fn, args...) + exitsyscall() + return r1, r2, err +} + +//go:linkname syscall_rawsyscalln syscall.rawsyscalln +func syscall_rawsyscalln(fn uintptr, args ...uintptr) (r1, r2, err uintptr) { + switch len(args) { + case 0: + return llgo_rawSyscall(fn, 0, 0, 0) + case 1: + return llgo_rawSyscall(fn, args[0], 0, 0) + case 2: + return llgo_rawSyscall(fn, args[0], args[1], 0) + case 3: + return llgo_rawSyscall(fn, args[0], args[1], args[2]) + case 4: + return llgo_rawSyscall6(fn, args[0], args[1], args[2], args[3], 0, 0) + case 5: + return llgo_rawSyscall6(fn, args[0], args[1], args[2], args[3], args[4], 0) + case 6: + return llgo_rawSyscall6(fn, args[0], args[1], args[2], args[3], args[4], args[5]) + case 7: + return llgo_rawSyscall9(fn, args[0], args[1], args[2], args[3], args[4], args[5], args[6], 0, 0) + case 8: + return llgo_rawSyscall9(fn, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], 0) + case 9: + return llgo_rawSyscall9(fn, args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8]) + default: + panic("runtime: unsupported darwin syscall arg count") + } +} + +//go:linkname crypto_x509_syscall crypto/x509/internal/macos.syscall +func crypto_x509_syscall(fn, a1, a2, a3, a4, a5 uintptr, f1 float64) uintptr { + r1, _, _ := llgo_syscall5f64(fn, a1, a2, a3, a4, a5, f1) + return r1 +} diff --git a/runtime/internal/lib/runtime/syscall_darwin_llgo.go b/runtime/internal/lib/runtime/syscall_darwin_llgo.go index 9ac2a258aa..12eb29a559 100644 --- a/runtime/internal/lib/runtime/syscall_darwin_llgo.go +++ b/runtime/internal/lib/runtime/syscall_darwin_llgo.go @@ -1,4 +1,4 @@ -//go:build darwin +//go:build darwin && !go1.26 package runtime From 0d55b193c57e1973abcc046665edf2e6f0a24fef Mon Sep 17 00:00:00 2001 From: Li Jie Date: Sat, 28 Mar 2026 14:33:53 +0800 Subject: [PATCH 28/44] ci: extend llgo coverage to go1.26 --- .github/workflows/llgo.yml | 34 ++++++++++++++++++++++++++-------- 1 file changed, 26 insertions(+), 8 deletions(-) diff --git a/.github/workflows/llgo.yml b/.github/workflows/llgo.yml index 90cea762ca..731147b722 100644 --- a/.github/workflows/llgo.yml +++ b/.github/workflows/llgo.yml @@ -47,7 +47,7 @@ jobs: - macos-15-intel - ubuntu-latest llvm: [19] - go: ["1.21.13", "1.24.2"] + go: ["1.21.13", "1.24.2", "1.26.0"] runs-on: ${{matrix.os}} steps: - uses: actions/checkout@v6 @@ -97,9 +97,15 @@ jobs: pip3.12 install --break-system-packages "${py_deps[@]}" - name: Set up Go for build + if: ${{ !startsWith(matrix.go, '1.26') }} uses: ./.github/actions/setup-go with: go-version: "1.24.2" + - name: Set up Go 1.26 for build + if: ${{ startsWith(matrix.go, '1.26') }} + uses: ./.github/actions/setup-go + with: + go-version: "1.26.0" - name: Install run: | @@ -192,7 +198,7 @@ jobs: - macos-latest - ubuntu-latest llvm: [19] - go: ["1.24.2"] + go: ["1.24.2", "1.26.0"] shard: ["0", "1", "2", "3"] runs-on: ${{matrix.os}} steps: @@ -210,9 +216,15 @@ jobs: pip3.12 install --break-system-packages "${py_deps[@]}" - name: Set up Go for build + if: ${{ !startsWith(matrix.go, '1.26') }} uses: ./.github/actions/setup-go with: go-version: "1.24.2" + - name: Set up Go 1.26 for build + if: ${{ startsWith(matrix.go, '1.26') }} + uses: ./.github/actions/setup-go + with: + go-version: "1.26.0" - name: Install run: | @@ -268,7 +280,7 @@ jobs: matrix: os: [ubuntu-latest, macos-latest] llvm: [19] - go: ["1.21.13", "1.24.2"] + go: ["1.21.13", "1.24.2", "1.26.0"] runs-on: ${{matrix.os}} steps: - uses: actions/checkout@v6 @@ -277,10 +289,16 @@ jobs: with: llvm-version: ${{matrix.llvm}} - - name: Set up Go 1.23 for building llgo + - name: Set up Go for build + if: ${{ !startsWith(matrix.go, '1.26') }} uses: ./.github/actions/setup-go with: go-version: "1.24.2" + - name: Set up Go 1.26 for build + if: ${{ startsWith(matrix.go, '1.26') }} + uses: ./.github/actions/setup-go + with: + go-version: "1.26.0" - name: Install llgo run: | @@ -293,28 +311,28 @@ jobs: go-version: ${{matrix.go}} - name: Test Hello World with go.mod 1.21 - if: startsWith(matrix.go, '1.21') || startsWith(matrix.go, '1.22') || startsWith(matrix.go, '1.23') || startsWith(matrix.go, '1.24') + if: startsWith(matrix.go, '1.21') || startsWith(matrix.go, '1.22') || startsWith(matrix.go, '1.23') || startsWith(matrix.go, '1.24') || startsWith(matrix.go, '1.25') || startsWith(matrix.go, '1.26') uses: ./.github/actions/test-helloworld with: go-version: ${{matrix.go}} mod-version: "1.21" - name: Test Hello World with go.mod 1.22 - if: startsWith(matrix.go, '1.22') || startsWith(matrix.go, '1.23') || startsWith(matrix.go, '1.24') + if: startsWith(matrix.go, '1.22') || startsWith(matrix.go, '1.23') || startsWith(matrix.go, '1.24') || startsWith(matrix.go, '1.25') || startsWith(matrix.go, '1.26') uses: ./.github/actions/test-helloworld with: go-version: ${{matrix.go}} mod-version: "1.22" - name: Test Hello World with go.mod 1.23 - if: startsWith(matrix.go, '1.23') || startsWith(matrix.go, '1.24') + if: startsWith(matrix.go, '1.23') || startsWith(matrix.go, '1.24') || startsWith(matrix.go, '1.25') || startsWith(matrix.go, '1.26') uses: ./.github/actions/test-helloworld with: go-version: ${{matrix.go}} mod-version: "1.23" - name: Test Hello World with go.mod 1.24 - if: startsWith(matrix.go, '1.24') + if: startsWith(matrix.go, '1.24') || startsWith(matrix.go, '1.25') || startsWith(matrix.go, '1.26') uses: ./.github/actions/test-helloworld with: go-version: ${{matrix.go}} From 919a4e887d329706169de7241e70be3347fc0038 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Sat, 28 Mar 2026 14:52:28 +0800 Subject: [PATCH 29/44] runtime: enable synctest compat on linux --- runtime/internal/lib/runtime/synctest_llgo.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/runtime/internal/lib/runtime/synctest_llgo.go b/runtime/internal/lib/runtime/synctest_llgo.go index b7c3e679bd..3707509f61 100644 --- a/runtime/internal/lib/runtime/synctest_llgo.go +++ b/runtime/internal/lib/runtime/synctest_llgo.go @@ -1,4 +1,4 @@ -//go:build darwin +//go:build darwin || linux package runtime From 43f9242938f2eab88d5c0254423ab27dbdca412f Mon Sep 17 00:00:00 2001 From: Li Jie Date: Sat, 28 Mar 2026 20:49:59 +0800 Subject: [PATCH 30/44] test: isolate go1.26 source patch coverage --- internal/build/source_patch_go126_test.go | 57 +++++++++++++++++++++++ internal/build/source_patch_test.go | 43 ----------------- 2 files changed, 57 insertions(+), 43 deletions(-) create mode 100644 internal/build/source_patch_go126_test.go diff --git a/internal/build/source_patch_go126_test.go b/internal/build/source_patch_go126_test.go new file mode 100644 index 0000000000..dbd2b6d2dc --- /dev/null +++ b/internal/build/source_patch_go126_test.go @@ -0,0 +1,57 @@ +//go:build go1.26 +// +build go1.26 + +package build + +import ( + "path/filepath" + "runtime" + "strings" + "testing" + + "github.com/goplus/llgo/internal/env" + llruntime "github.com/goplus/llgo/runtime" +) + +func TestBuildSourcePatchOverlayForInternalSync(t *testing.T) { + overlay, err := buildSourcePatchOverlayForGOROOT(nil, env.LLGoRuntimeDir(), runtime.GOROOT(), sourcePatchBuildContext{ + goos: runtime.GOOS, + goarch: runtime.GOARCH, + goversion: "go1.26.0", + }) + if err != nil { + t.Fatal(err) + } + + syncDir := filepath.Join(runtime.GOROOT(), "src", "internal", "sync") + patchFile := filepath.Join(syncDir, "z_llgo_patch_hashtriemap.go") + patchSrc, ok := overlay[patchFile] + if !ok { + t.Fatalf("missing source patch file %s", patchFile) + } + if !strings.Contains(string(patchSrc), "type HashTrieMap") { + t.Fatalf("source patch file %s does not contain HashTrieMap replacement", patchFile) + } + + stdFile := filepath.Join(syncDir, "hashtriemap.go") + stdSrc, ok := overlay[stdFile] + if !ok { + t.Fatalf("missing stub overlay for %s", stdFile) + } + got := string(stdSrc) + if !strings.Contains(got, "package sync") { + t.Fatalf("stub overlay for %s lost package clause", stdFile) + } + if strings.Contains(got, "type HashTrieMap") { + t.Fatalf("stub overlay for %s still contains original declarations", stdFile) + } +} + +func TestInternalSyncUsesSourcePatchInsteadOfAltPkg(t *testing.T) { + if !llruntime.HasSourcePatchPkg("internal/sync") { + t.Fatal("internal/sync should be registered as a source patch package") + } + if llruntime.HasAltPkg("internal/sync") { + t.Fatal("internal/sync should not remain an alt package") + } +} diff --git a/internal/build/source_patch_test.go b/internal/build/source_patch_test.go index 8e049192aa..65ac611d30 100644 --- a/internal/build/source_patch_test.go +++ b/internal/build/source_patch_test.go @@ -58,49 +58,6 @@ func TestIterUsesSourcePatchInsteadOfAltPkg(t *testing.T) { } } -func TestBuildSourcePatchOverlayForInternalSync(t *testing.T) { - overlay, err := buildSourcePatchOverlayForGOROOT(nil, env.LLGoRuntimeDir(), runtime.GOROOT(), sourcePatchBuildContext{ - goos: runtime.GOOS, - goarch: runtime.GOARCH, - goversion: "go1.26.0", - }) - if err != nil { - t.Fatal(err) - } - - syncDir := filepath.Join(runtime.GOROOT(), "src", "internal", "sync") - patchFile := filepath.Join(syncDir, "z_llgo_patch_hashtriemap.go") - patchSrc, ok := overlay[patchFile] - if !ok { - t.Fatalf("missing source patch file %s", patchFile) - } - if !strings.Contains(string(patchSrc), "type HashTrieMap") { - t.Fatalf("source patch file %s does not contain HashTrieMap replacement", patchFile) - } - - stdFile := filepath.Join(syncDir, "hashtriemap.go") - stdSrc, ok := overlay[stdFile] - if !ok { - t.Fatalf("missing stub overlay for %s", stdFile) - } - got := string(stdSrc) - if !strings.Contains(got, "package sync") { - t.Fatalf("stub overlay for %s lost package clause", stdFile) - } - if strings.Contains(got, "type HashTrieMap") { - t.Fatalf("stub overlay for %s still contains original declarations", stdFile) - } -} - -func TestInternalSyncUsesSourcePatchInsteadOfAltPkg(t *testing.T) { - if !llruntime.HasSourcePatchPkg("internal/sync") { - t.Fatal("internal/sync should be registered as a source patch package") - } - if llruntime.HasAltPkg("internal/sync") { - t.Fatal("internal/sync should not remain an alt package") - } -} - func TestSyncAtomicRemainsAltPkg(t *testing.T) { if llruntime.HasSourcePatchPkg("sync/atomic") { t.Fatal("sync/atomic should not be registered as a source patch package") From c3ccf9c119513470e81e0119d9dfaaa8bf653991 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Sat, 28 Mar 2026 22:30:07 +0800 Subject: [PATCH 31/44] runtime: keep unique compat on go1.26 branch --- runtime/abi/helpers.go | 54 ++++++ runtime/internal/lib/unique/clone.go | 2 + runtime/internal/lib/unique/handle.go | 231 ++++++++++++++++++++++++++ runtime/internal/lib/unique/unique.go | 6 - 4 files changed, 287 insertions(+), 6 deletions(-) create mode 100644 runtime/abi/helpers.go create mode 100644 runtime/internal/lib/unique/handle.go delete mode 100644 runtime/internal/lib/unique/unique.go diff --git a/runtime/abi/helpers.go b/runtime/abi/helpers.go new file mode 100644 index 0000000000..85fb1a367b --- /dev/null +++ b/runtime/abi/helpers.go @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2024 The XGo Authors (xgo.dev). All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package abi + +import "unsafe" + +func NoEscape(p unsafe.Pointer) unsafe.Pointer { + x := uintptr(p) + return unsafe.Pointer(x ^ 0) +} + +type EmptyInterface struct { + Type *Type + Data unsafe.Pointer +} + +// TypeOf returns the runtime Type of some value. +func TypeOf(a any) *Type { + eface := *(*EmptyInterface)(unsafe.Pointer(&a)) + return (*Type)(NoEscape(unsafe.Pointer(eface.Type))) +} + +// TypeFor returns the runtime Type for a type parameter. +func TypeFor[T any]() *Type { + var v T + if t := TypeOf(v); t != nil { + return t + } + return TypeOf((*T)(nil)).Elem() +} + +// EscapeNonString is modeled by the compiler. +func EscapeNonString[T any](v T) { +} + +// EscapeToResultNonString models a data-flow edge to the result. +func EscapeToResultNonString[T any](v T) T { + EscapeNonString(v) + return *(*T)(NoEscape(unsafe.Pointer(&v))) +} diff --git a/runtime/internal/lib/unique/clone.go b/runtime/internal/lib/unique/clone.go index 4211c8dd12..626790dd95 100644 --- a/runtime/internal/lib/unique/clone.go +++ b/runtime/internal/lib/unique/clone.go @@ -2,6 +2,8 @@ // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. +// llgo:skipall + package unique import ( diff --git a/runtime/internal/lib/unique/handle.go b/runtime/internal/lib/unique/handle.go new file mode 100644 index 0000000000..d7ddabe4c1 --- /dev/null +++ b/runtime/internal/lib/unique/handle.go @@ -0,0 +1,231 @@ +// Copyright 2024 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// llgo:skipall + +package unique + +import ( + "runtime" + "sync" + "unsafe" + "weak" + + "github.com/goplus/llgo/runtime/abi" +) + +var zero uintptr + +// Handle is a globally unique identity for some value of type T. +// +// Two handles compare equal exactly if the two values used to create the handles +// would have also compared equal. The comparison of two handles is trivial and +// typically much more efficient than comparing the values used to create them. +type Handle[T comparable] struct { + value *T +} + +// Value returns a shallow copy of the T value that produced the Handle. +// Value is safe for concurrent use by multiple goroutines. +func (h Handle[T]) Value() T { + return *h.value +} + +// Make returns a globally unique handle for a value of type T. Handles +// are equal if and only if the values used to produce them are equal. +// Make is safe for concurrent use by multiple goroutines. +func Make[T comparable](value T) Handle[T] { + typ := abi.TypeFor[T]() + if typ.Size() == 0 { + return Handle[T]{(*T)(unsafe.Pointer(&zero))} + } + ma, ok := loadUniqueMap(typ) + if !ok { + ensureSetupMake() + ma = addUniqueMap[T](typ) + } + m := ma.(*uniqueMap[T]) + + var ( + toInsert *T + toInsertWeak weak.Pointer[T] + ) + newValue := func() (T, weak.Pointer[T]) { + if toInsert == nil { + toInsert = new(T) + *toInsert = clone(value, &m.cloneSeq) + toInsertWeak = weak.Make(toInsert) + } + return *toInsert, toInsertWeak + } + var ptr *T + for { + wp, ok := m.Load(value) + if !ok { + k, v := newValue() + wp, _ = m.LoadOrStore(k, v) + } + ptr = wp.Value() + if ptr != nil { + break + } + m.CompareAndDelete(value, wp) + } + runtime.KeepAlive(toInsert) + return Handle[T]{ptr} +} + +var ( + uniqueMapsMu sync.Mutex + uniqueMaps map[*abi.Type]any + + cleanupMu sync.Mutex + cleanupFuncsMu sync.Mutex + cleanupFuncs []func() + cleanupNotify []func() +) + +type uniqueMap[T comparable] struct { + mu sync.Mutex + m map[T]weak.Pointer[T] + cloneSeq +} + +type uniqueEntry[T comparable] struct { + key T + value weak.Pointer[T] +} + +func addUniqueMap[T comparable](typ *abi.Type) *uniqueMap[T] { + m := &uniqueMap[T]{ + m: make(map[T]weak.Pointer[T]), + cloneSeq: makeCloneSeq(typ), + } + a, loaded := loadOrStoreUniqueMap(typ, m) + if !loaded { + cleanupFuncsMu.Lock() + cleanupFuncs = append(cleanupFuncs, func() { + m.All()(func(key T, wp weak.Pointer[T]) bool { + if wp.Value() == nil { + m.CompareAndDelete(key, wp) + } + return true + }) + }) + cleanupFuncsMu.Unlock() + } + return a.(*uniqueMap[T]) +} + +var ( + setupMakeMu sync.Mutex + setupMade bool +) + +func ensureSetupMake() { + setupMakeMu.Lock() + if !setupMade { + registerCleanup() + setupMade = true + } + setupMakeMu.Unlock() +} + +func loadUniqueMap(typ *abi.Type) (any, bool) { + uniqueMapsMu.Lock() + if uniqueMaps == nil { + uniqueMapsMu.Unlock() + return nil, false + } + v, ok := uniqueMaps[typ] + uniqueMapsMu.Unlock() + return v, ok +} + +func loadOrStoreUniqueMap(typ *abi.Type, value any) (any, bool) { + uniqueMapsMu.Lock() + if uniqueMaps == nil { + uniqueMaps = make(map[*abi.Type]any) + } + if existing, ok := uniqueMaps[typ]; ok { + uniqueMapsMu.Unlock() + return existing, true + } + uniqueMaps[typ] = value + uniqueMapsMu.Unlock() + return value, false +} + +func (m *uniqueMap[T]) Load(key T) (weak.Pointer[T], bool) { + m.mu.Lock() + v, ok := m.m[key] + m.mu.Unlock() + if !ok { + var zero weak.Pointer[T] + return zero, false + } + return v, true +} + +func (m *uniqueMap[T]) LoadOrStore(key T, value weak.Pointer[T]) (weak.Pointer[T], bool) { + m.mu.Lock() + if existing, ok := m.m[key]; ok { + m.mu.Unlock() + return existing, true + } + m.m[key] = value + m.mu.Unlock() + return value, false +} + +func (m *uniqueMap[T]) CompareAndDelete(key T, old weak.Pointer[T]) bool { + m.mu.Lock() + defer m.mu.Unlock() + v, ok := m.m[key] + if !ok || v != old { + return false + } + delete(m.m, key) + return true +} + +func (m *uniqueMap[T]) All() func(func(T, weak.Pointer[T]) bool) { + return func(yield func(T, weak.Pointer[T]) bool) { + m.mu.Lock() + items := make([]uniqueEntry[T], 0, len(m.m)) + for k, v := range m.m { + items = append(items, uniqueEntry[T]{key: k, value: v}) + } + m.mu.Unlock() + for _, item := range items { + if !yield(item.key, item.value) { + return + } + } + } +} + +func registerCleanup() { + runtime_registerUniqueMapCleanup(func() { + cleanupMu.Lock() + + cleanupFuncsMu.Lock() + cf := cleanupFuncs + cleanupFuncsMu.Unlock() + + for _, f := range cf { + f() + } + + for _, f := range cleanupNotify { + f() + } + cleanupNotify = nil + + cleanupMu.Unlock() + }) +} + +//go:linkname runtime_registerUniqueMapCleanup +func runtime_registerUniqueMapCleanup(cleanup func()) diff --git a/runtime/internal/lib/unique/unique.go b/runtime/internal/lib/unique/unique.go deleted file mode 100644 index faaee1b155..0000000000 --- a/runtime/internal/lib/unique/unique.go +++ /dev/null @@ -1,6 +0,0 @@ -package unique - -import _ "unsafe" - -//go:linkname runtime_registerUniqueMapCleanup -func runtime_registerUniqueMapCleanup(cleanup func()) From ac44259622a70f3aab58fb1095cf4529c7cd7642 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Sun, 29 Mar 2026 12:17:13 +0800 Subject: [PATCH 32/44] runtime: move go1.26 sync source patch files --- internal/build/source_patch_go126_test.go | 3 +++ runtime/{internal/lib => _patch}/internal/sync/hashtriemap.go | 0 runtime/{internal/lib => _patch}/internal/sync/mutex.go | 0 runtime/{internal/lib => _patch}/internal/sync/runtime.go | 0 4 files changed, 3 insertions(+) rename runtime/{internal/lib => _patch}/internal/sync/hashtriemap.go (100%) rename runtime/{internal/lib => _patch}/internal/sync/mutex.go (100%) rename runtime/{internal/lib => _patch}/internal/sync/runtime.go (100%) diff --git a/internal/build/source_patch_go126_test.go b/internal/build/source_patch_go126_test.go index dbd2b6d2dc..6366d00c62 100644 --- a/internal/build/source_patch_go126_test.go +++ b/internal/build/source_patch_go126_test.go @@ -32,6 +32,9 @@ func TestBuildSourcePatchOverlayForInternalSync(t *testing.T) { if !strings.Contains(string(patchSrc), "type HashTrieMap") { t.Fatalf("source patch file %s does not contain HashTrieMap replacement", patchFile) } + if !strings.HasPrefix(string(patchSrc), sourcePatchLineDirective(filepath.Join(env.LLGoRuntimeDir(), "_patch", "internal", "sync", "hashtriemap.go"))) { + t.Fatalf("source patch file %s is missing line directive, got:\n%s", patchFile, patchSrc) + } stdFile := filepath.Join(syncDir, "hashtriemap.go") stdSrc, ok := overlay[stdFile] diff --git a/runtime/internal/lib/internal/sync/hashtriemap.go b/runtime/_patch/internal/sync/hashtriemap.go similarity index 100% rename from runtime/internal/lib/internal/sync/hashtriemap.go rename to runtime/_patch/internal/sync/hashtriemap.go diff --git a/runtime/internal/lib/internal/sync/mutex.go b/runtime/_patch/internal/sync/mutex.go similarity index 100% rename from runtime/internal/lib/internal/sync/mutex.go rename to runtime/_patch/internal/sync/mutex.go diff --git a/runtime/internal/lib/internal/sync/runtime.go b/runtime/_patch/internal/sync/runtime.go similarity index 100% rename from runtime/internal/lib/internal/sync/runtime.go rename to runtime/_patch/internal/sync/runtime.go From 6b1e842a7824a4d2c076d1db5f7264a17e439b2e Mon Sep 17 00:00:00 2001 From: Li Jie Date: Sun, 29 Mar 2026 13:08:07 +0800 Subject: [PATCH 33/44] runtime: source patch crypto internal constanttime --- internal/build/source_patch_go126_test.go | 33 ++++++++++++++++ .../internal/constanttime/constant_time.go | 12 ++++++ runtime/build.go | 24 ++++++------ .../internal/constanttime/constant_time.go | 39 ------------------- 4 files changed, 57 insertions(+), 51 deletions(-) create mode 100644 runtime/_patch/crypto/internal/constanttime/constant_time.go delete mode 100644 runtime/internal/lib/crypto/internal/constanttime/constant_time.go diff --git a/internal/build/source_patch_go126_test.go b/internal/build/source_patch_go126_test.go index 6366d00c62..e43e67c73c 100644 --- a/internal/build/source_patch_go126_test.go +++ b/internal/build/source_patch_go126_test.go @@ -58,3 +58,36 @@ func TestInternalSyncUsesSourcePatchInsteadOfAltPkg(t *testing.T) { t.Fatal("internal/sync should not remain an alt package") } } + +func TestBuildSourcePatchOverlayForCryptoInternalConstanttime(t *testing.T) { + overlay, err := buildSourcePatchOverlayForGOROOT(nil, env.LLGoRuntimeDir(), runtime.GOROOT(), sourcePatchBuildContext{ + goos: runtime.GOOS, + goarch: runtime.GOARCH, + goversion: "go1.26.0", + }) + if err != nil { + t.Fatal(err) + } + + pkgDir := filepath.Join(runtime.GOROOT(), "src", "crypto", "internal", "constanttime") + patchFile := filepath.Join(pkgDir, "z_llgo_patch_constant_time.go") + patchSrc, ok := overlay[patchFile] + if !ok { + t.Fatalf("missing source patch file %s", patchFile) + } + if !strings.Contains(string(patchSrc), "//go:linkname boolToUint8 llgo.boolToUint8") { + t.Fatalf("source patch file %s does not contain boolToUint8 linkname", patchFile) + } + if !strings.HasPrefix(string(patchSrc), sourcePatchLineDirective(filepath.Join(env.LLGoRuntimeDir(), "_patch", "crypto", "internal", "constanttime", "constant_time.go"))) { + t.Fatalf("source patch file %s is missing line directive, got:\n%s", patchFile, patchSrc) + } +} + +func TestCryptoInternalConstanttimeUsesSourcePatchInsteadOfAltPkg(t *testing.T) { + if !llruntime.HasSourcePatchPkg("crypto/internal/constanttime") { + t.Fatal("crypto/internal/constanttime should be registered as a source patch package") + } + if llruntime.HasAltPkg("crypto/internal/constanttime") { + t.Fatal("crypto/internal/constanttime should not remain an alt package") + } +} diff --git a/runtime/_patch/crypto/internal/constanttime/constant_time.go b/runtime/_patch/crypto/internal/constanttime/constant_time.go new file mode 100644 index 0000000000..05b1911ced --- /dev/null +++ b/runtime/_patch/crypto/internal/constanttime/constant_time.go @@ -0,0 +1,12 @@ +// Copyright 2025 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +//go:build go1.26 + +package constanttime + +import _ "unsafe" + +//go:linkname boolToUint8 llgo.boolToUint8 +func boolToUint8(b bool) uint8 diff --git a/runtime/build.go b/runtime/build.go index 37a176cf41..7ea0ae60f5 100644 --- a/runtime/build.go +++ b/runtime/build.go @@ -40,19 +40,19 @@ func SourcePatchPkgPaths() []string { } var altPkgs = map[string]altPkgMode{ - "crypto/internal/constanttime": altPkgReplace, - "internal/abi": altPkgReplace, - "internal/reflectlite": altPkgReplace, - "internal/runtime/maps": altPkgReplace, - "internal/runtime/sys": altPkgAdditive, - "reflect": altPkgReplace, - "runtime": altPkgReplace, - "sync/atomic": altPkgReplace, - "syscall/js": altPkgReplace, - "unique": altPkgReplace, + "internal/abi": altPkgReplace, + "internal/reflectlite": altPkgReplace, + "internal/runtime/maps": altPkgReplace, + "internal/runtime/sys": altPkgAdditive, + "reflect": altPkgReplace, + "runtime": altPkgReplace, + "sync/atomic": altPkgReplace, + "syscall/js": altPkgReplace, + "unique": altPkgReplace, } var sourcePatchPkgs = map[string]struct{}{ - "internal/sync": {}, - "iter": {}, + "crypto/internal/constanttime": {}, + "internal/sync": {}, + "iter": {}, } diff --git a/runtime/internal/lib/crypto/internal/constanttime/constant_time.go b/runtime/internal/lib/crypto/internal/constanttime/constant_time.go deleted file mode 100644 index 30c0de8aa4..0000000000 --- a/runtime/internal/lib/crypto/internal/constanttime/constant_time.go +++ /dev/null @@ -1,39 +0,0 @@ -// Copyright 2025 The Go Authors. All rights reserved. -// Use of this source code is governed by a BSD-style -// license that can be found in the LICENSE file. - -package constanttime - -// The stdlib version uses a compiler intrinsic for boolToUint8. -// llgo doesn't lower that intrinsic yet, so keep the same API surface with -// a direct implementation for now. - -// Select returns x if v == 1 and y if v == 0. -// Its behavior is undefined if v takes any other value. -func Select(v, x, y int) int { - v = int(boolToUint8(v != 0)) - return ^(v-1)&x | (v-1)&y -} - -// ByteEq returns 1 if x == y and 0 otherwise. -func ByteEq(x, y uint8) int { - return int(boolToUint8(x == y)) -} - -// Eq returns 1 if x == y and 0 otherwise. -func Eq(x, y int32) int { - return int(boolToUint8(x == y)) -} - -// LessOrEq returns 1 if x <= y and 0 otherwise. -// Its behavior is undefined if x or y are negative or > 2**31 - 1. -func LessOrEq(x, y int) int { - return int(boolToUint8(x <= y)) -} - -func boolToUint8(b bool) uint8 { - if b { - return 1 - } - return 0 -} From 3ce72bb7ce7eae77386d8765576010a259c7b7e2 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Thu, 26 Mar 2026 08:17:12 +0800 Subject: [PATCH 34/44] test: add goroot runner baseline and sharded CI --- .github/workflows/goroot.yml | 50 +++ dev/test_goroot.sh | 41 ++ test/goroot/README.md | 37 ++ test/goroot/proc_other.go | 14 + test/goroot/proc_unix.go | 19 + test/goroot/runner_test.go | 664 ++++++++++++++++++++++++++++++++ test/goroot/runner_unit_test.go | 179 +++++++++ test/goroot/xfail.yaml | 554 ++++++++++++++++++++++++++ 8 files changed, 1558 insertions(+) create mode 100644 .github/workflows/goroot.yml create mode 100755 dev/test_goroot.sh create mode 100644 test/goroot/README.md create mode 100644 test/goroot/proc_other.go create mode 100644 test/goroot/proc_unix.go create mode 100644 test/goroot/runner_test.go create mode 100644 test/goroot/runner_unit_test.go create mode 100644 test/goroot/xfail.yaml diff --git a/.github/workflows/goroot.yml b/.github/workflows/goroot.yml new file mode 100644 index 0000000000..da3a00e1bb --- /dev/null +++ b/.github/workflows/goroot.yml @@ -0,0 +1,50 @@ +name: GOROOT + +on: + push: + branches: + - "**" + - "!dependabot/**" + - "!xgopilot/**" + pull_request: + branches: ["**"] + +concurrency: + group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }} + cancel-in-progress: true + +jobs: + goroot: + timeout-minutes: 90 + strategy: + fail-fast: false + matrix: + os: + - macos-latest + - ubuntu-latest + llvm: [19] + shard: ["0", "1", "2", "3"] + runs-on: ${{ matrix.os }} + steps: + - uses: actions/checkout@v6 + + - name: Install dependencies + uses: ./.github/actions/setup-deps + with: + llvm-version: ${{ matrix.llvm }} + + - name: Set up Go + uses: ./.github/actions/setup-go + with: + go-version: "1.25.0" + + - name: Show toolchain versions + run: | + go version + clang --version + + - name: Run GOROOT runner shard + run: | + bash dev/test_goroot.sh -- \ + -shard-index "${{ matrix.shard }}" \ + -shard-total 4 diff --git a/dev/test_goroot.sh b/dev/test_goroot.sh new file mode 100755 index 0000000000..e3c8201f72 --- /dev/null +++ b/dev/test_goroot.sh @@ -0,0 +1,41 @@ +#!/usr/bin/env bash +set -euo pipefail + +repo_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)" + +runner_args=() +goroots=() +after_delim=0 +for arg in "$@"; do + if [[ "$arg" == "--" ]]; then + after_delim=1 + continue + fi + if [[ $after_delim -eq 1 ]]; then + runner_args+=("$arg") + else + goroots+=("$arg") + fi +done + +if [[ ${#goroots[@]} -eq 0 ]]; then + if [[ -n "${LLGO_GOROOT_MATRIX:-}" ]]; then + IFS=':' read -r -a goroots <<<"${LLGO_GOROOT_MATRIX}" + else + goroots=("$(go env GOROOT)") + fi +fi + +for goroot in "${goroots[@]}"; do + go_bin="$goroot/bin/go" + if [[ ! -x "$go_bin" ]]; then + echo "error: missing go binary: $go_bin" >&2 + exit 2 + fi + version="$("$go_bin" env GOVERSION)" + echo "==== $version ($goroot) ====" + ( + cd "$repo_root" + go test ./test/goroot -count=1 -args -goroot "$goroot" "${runner_args[@]}" + ) +done diff --git a/test/goroot/README.md b/test/goroot/README.md new file mode 100644 index 0000000000..d3568011ef --- /dev/null +++ b/test/goroot/README.md @@ -0,0 +1,37 @@ +# GOROOT Runner + +This package runs selected upstream `GOROOT/test` cases against `llgo` without +copying the upstream source files into this repository. + +Current scope: + +- Source of truth is an external `GOROOT` +- Only `// run` cases are executed +- Cases are compared as `go run ` vs `llgo run ` +- Upstream files stay read-only; the runner uses a temporary symlinked work tree + +Basic usage: + +```bash +go test ./test/goroot -count=1 -args \ + -goroot "$(go env GOROOT)" \ + -dirs . \ + -case '^helloworld\.go$' +``` + +Multiple toolchains: + +```bash +bash ./dev/test_goroot.sh /path/to/go1.23 /path/to/go1.24 -- -dirs . -case '^helloworld\.go$' +``` + +Useful flags: + +- `-goroot`: upstream Go toolchain root to read tests from +- `-go`: baseline `go` binary; defaults to `/bin/go` +- `-llgo`: existing `llgo` binary to use; otherwise one is built from the current checkout +- `-dirs`: comma-separated `GOROOT/test` subdirectories to scan +- `-case`: regexp filter on the relative case path +- `-limit`: stop after N matching cases +- `-keepwork`: keep the temporary symlink work tree for debugging +- `-xfail`: xfail YAML file, relative to repo root by default diff --git a/test/goroot/proc_other.go b/test/goroot/proc_other.go new file mode 100644 index 0000000000..d942ec62ea --- /dev/null +++ b/test/goroot/proc_other.go @@ -0,0 +1,14 @@ +//go:build !unix + +package goroot + +import "os/exec" + +func configureProcessGroup(cmd *exec.Cmd) {} + +func killProcessTree(cmd *exec.Cmd) { + if cmd.Process == nil { + return + } + _ = cmd.Process.Kill() +} diff --git a/test/goroot/proc_unix.go b/test/goroot/proc_unix.go new file mode 100644 index 0000000000..c16b444b69 --- /dev/null +++ b/test/goroot/proc_unix.go @@ -0,0 +1,19 @@ +//go:build unix + +package goroot + +import ( + "os/exec" + "syscall" +) + +func configureProcessGroup(cmd *exec.Cmd) { + cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true} +} + +func killProcessTree(cmd *exec.Cmd) { + if cmd.Process == nil { + return + } + _ = syscall.Kill(-cmd.Process.Pid, syscall.SIGKILL) +} diff --git a/test/goroot/runner_test.go b/test/goroot/runner_test.go new file mode 100644 index 0000000000..17bfb47270 --- /dev/null +++ b/test/goroot/runner_test.go @@ -0,0 +1,664 @@ +package goroot + +import ( + "bufio" + "bytes" + "encoding/json" + "errors" + "flag" + "fmt" + "go/build" + "os" + "os/exec" + "path" + "path/filepath" + "regexp" + "runtime" + "strconv" + "strings" + "testing" + "time" + + "gopkg.in/yaml.v3" +) + +var ( + flagGOROOT = flag.String("goroot", os.Getenv("LLGO_GOROOT"), "Go toolchain root whose GOROOT/test sources should be used") + flagGoCmd = flag.String("go", os.Getenv("LLGO_GO"), "go binary used as baseline (default: /bin/go)") + flagLLGO = flag.String("llgo", os.Getenv("LLGO_TEST_LLGO"), "llgo binary used for comparisons (default: build from current checkout)") + flagDirs = flag.String("dirs", strings.Join(defaultGoRootTestDirs, ","), "comma-separated GOROOT/test subdirectories to scan") + flagCase = flag.String("case", os.Getenv("LLGO_GOROOT_CASE"), "regexp selecting cases by relative path") + flagLimit = flag.Int("limit", 0, "maximum number of matching cases to run") + flagShardI = flag.Int("shard-index", 0, "0-based shard index used to partition matching cases") + flagShardN = flag.Int("shard-total", 1, "number of shards used to partition matching cases") + flagKeep = flag.Bool("keepwork", false, "keep temporary work directories for debugging") + flagXFail = flag.String("xfail", filepath.Join("test", "goroot", "xfail.yaml"), "xfail configuration path relative to repo root") + flagRunTO = flag.Duration("run-timeout", 20*time.Second, "timeout for each go/llgo child process; 0 disables the timeout") +) + +var defaultGoRootTestDirs = []string{ + ".", + "ken", + "chan", + "interface", + "internal/runtime/sys", + "syntax", + "dwarf", + "fixedbugs", + "codegen", + "abi", + "typeparam", + "typeparam/mdempsky", + "arenas", +} + +type toolchainEnv struct { + GOOS string + GOARCH string + GOVERSION string + CGOEnabled string `json:"CGO_ENABLED"` + ReleaseTags []string +} + +type testCase struct { + RelPath string + Dir string + FileName string + Directive string + DirectiveArg []string +} + +type xfailConfig struct { + Entries []xfailEntry `yaml:"xfails"` + HostSkips []xfailEntry `yaml:"host_skips"` + Timeouts []timeoutEntry `yaml:"timeouts"` +} + +type xfailEntry struct { + Version string `yaml:"version"` + Platform string `yaml:"platform"` + Directive string `yaml:"directive"` + Case string `yaml:"case"` + Reason string `yaml:"reason"` +} + +type timeoutEntry struct { + Version string `yaml:"version"` + Platform string `yaml:"platform"` + Directive string `yaml:"directive"` + Case string `yaml:"case"` + Timeout string `yaml:"timeout"` + Reason string `yaml:"reason"` +} + +func TestGoRootRunCases(t *testing.T) { + if *flagGOROOT == "" { + t.Skip("set -goroot or LLGO_GOROOT to run external GOROOT/test cases") + } + + repoRoot := repoRoot(t) + goroot, err := filepath.Abs(*flagGOROOT) + if err != nil { + t.Fatalf("resolve goroot: %v", err) + } + goCmd := *flagGoCmd + if goCmd == "" { + goCmd = filepath.Join(goroot, "bin", "go") + } + if _, err := os.Stat(goCmd); err != nil { + t.Fatalf("stat go command %q: %v", goCmd, err) + } + + envInfo := loadToolchainEnv(t, goCmd) + testRoot := filepath.Join(goroot, "test") + if info, err := os.Stat(testRoot); err != nil || !info.IsDir() { + t.Fatalf("invalid GOROOT/test root %q: %v", testRoot, err) + } + + llgoBin := *flagLLGO + if llgoBin == "" { + llgoBin = buildLLGOBinary(t, repoRoot) + } + xfails := loadXFailConfig(t, repoRoot, *flagXFail) + caseFilter := compileCaseFilter(t, *flagCase) + cases := discoverCases(t, testRoot, envInfo, parseDirs(*flagDirs), caseFilter, *flagLimit) + if len(cases) == 0 { + t.Fatalf("no matching // run cases found under %s", testRoot) + } + cases = shardCases(t, cases, *flagShardI, *flagShardN) + if len(cases) == 0 { + t.Skipf("no matching cases selected for shard %d/%d", *flagShardI, *flagShardN) + } + + t.Logf("goroot=%s goversion=%s goos=%s goarch=%s shard=%d/%d cases=%d", goroot, envInfo.GOVERSION, envInfo.GOOS, envInfo.GOARCH, *flagShardI, *flagShardN, len(cases)) + for _, tc := range cases { + tc := tc + t.Run(tc.RelPath, func(t *testing.T) { + if match, reason := xfails.MatchHostSkip(envInfo.GOVERSION, runtime.GOOS+"/"+runtime.GOARCH, tc); match { + t.Skipf("skipping host-unsafe case: %s", reason) + } + runTimeout := *flagRunTO + if timeout, reason, ok := xfails.MatchTimeout(envInfo.GOVERSION, envInfo.GOOS+"/"+envInfo.GOARCH, tc); ok { + runTimeout = timeout + t.Logf("using timeout override %s: %s", timeout, reason) + } + err := runCase(t, repoRoot, goroot, goCmd, llgoBin, tc, runTimeout) + match, reason := xfails.Match(envInfo.GOVERSION, envInfo.GOOS+"/"+envInfo.GOARCH, tc) + switch { + case err == nil && match: + t.Fatalf("unexpected success for xfail case: %s", reason) + case err != nil && match: + t.Logf("expected failure: %s", reason) + case err != nil: + t.Fatal(err) + } + }) + } +} + +func repoRoot(t *testing.T) string { + t.Helper() + wd, err := os.Getwd() + if err != nil { + t.Fatalf("getwd: %v", err) + } + root, err := filepath.Abs(filepath.Join(wd, "..", "..")) + if err != nil { + t.Fatalf("resolve repo root: %v", err) + } + return root +} + +func loadToolchainEnv(t *testing.T, goCmd string) toolchainEnv { + t.Helper() + cmd := exec.Command(goCmd, "env", "-json", "GOOS", "GOARCH", "GOVERSION", "CGO_ENABLED") + cmd.Env = append(os.Environ(), "GOENV=off", "GOFLAGS=") + var out bytes.Buffer + cmd.Stdout = &out + cmd.Stderr = &out + if err := cmd.Run(); err != nil { + t.Fatalf("%s env failed: %v\n%s", goCmd, err, out.Bytes()) + } + var info toolchainEnv + if err := json.Unmarshal(out.Bytes(), &info); err != nil { + t.Fatalf("decode %s env output: %v", goCmd, err) + } + info.ReleaseTags = releaseTagsFor(info.GOVERSION) + return info +} + +func buildLLGOBinary(t *testing.T, repoRoot string) string { + t.Helper() + outDir := t.TempDir() + outPath := filepath.Join(outDir, "llgo") + if runtime.GOOS == "windows" { + outPath += ".exe" + } + cmd := exec.Command("go", "build", "-tags=dev", "-o", outPath, "./cmd/llgo") + cmd.Dir = repoRoot + var out bytes.Buffer + cmd.Stdout = &out + cmd.Stderr = &out + if err := cmd.Run(); err != nil { + t.Fatalf("build llgo failed: %v\n%s", err, out.Bytes()) + } + return outPath +} + +func loadXFailConfig(t *testing.T, repoRoot, relPath string) xfailConfig { + t.Helper() + path := relPath + if !filepath.IsAbs(path) { + path = filepath.Join(repoRoot, relPath) + } + data, err := os.ReadFile(path) + if errors.Is(err, os.ErrNotExist) { + return xfailConfig{} + } + if err != nil { + t.Fatalf("read xfail file %q: %v", path, err) + } + var cfg xfailConfig + if err := yaml.Unmarshal(data, &cfg); err != nil { + t.Fatalf("parse xfail file %q: %v", path, err) + } + return cfg +} + +func compileCaseFilter(t *testing.T, expr string) *regexp.Regexp { + t.Helper() + if expr == "" { + return nil + } + re, err := regexp.Compile(expr) + if err != nil { + t.Fatalf("compile case regexp %q: %v", expr, err) + } + return re +} + +func parseDirs(csv string) []string { + parts := strings.Split(csv, ",") + out := make([]string, 0, len(parts)) + for _, part := range parts { + part = strings.TrimSpace(part) + if part == "" { + continue + } + out = append(out, part) + } + return out +} + +func discoverCases(t *testing.T, testRoot string, envInfo toolchainEnv, dirs []string, filter *regexp.Regexp, limit int) []testCase { + t.Helper() + ctx := build.Default + ctx.GOOS = envInfo.GOOS + ctx.GOARCH = envInfo.GOARCH + ctx.CgoEnabled = envInfo.CGOEnabled == "1" + ctx.GOROOT = filepath.Dir(testRoot) + ctx.ReleaseTags = envInfo.ReleaseTags + + var cases []testCase + for _, relDir := range dirs { + absDir := filepath.Join(testRoot, filepath.FromSlash(relDir)) + entries, err := os.ReadDir(absDir) + if err != nil { + t.Fatalf("read %s: %v", absDir, err) + } + for _, entry := range entries { + name := entry.Name() + if entry.IsDir() || strings.HasPrefix(name, ".") || !strings.HasSuffix(name, ".go") { + continue + } + match, err := ctx.MatchFile(absDir, name) + if err != nil || !match { + continue + } + pathInTest := name + if relDir != "." { + pathInTest = path.Join(relDir, name) + } + if filter != nil && !filter.MatchString(pathInTest) { + continue + } + directive, args, ok := parseDirective(filepath.Join(absDir, name)) + if !ok || directive != "run" || len(args) != 0 { + continue + } + cases = append(cases, testCase{ + RelPath: pathInTest, + Dir: absDir, + FileName: name, + Directive: directive, + DirectiveArg: args, + }) + if limit > 0 && len(cases) >= limit { + return cases + } + } + } + return cases +} + +func shardCases(t *testing.T, cases []testCase, shardIndex, shardTotal int) []testCase { + t.Helper() + if shardTotal < 1 { + t.Fatalf("invalid -shard-total=%d; want >= 1", shardTotal) + } + if shardIndex < 0 || shardIndex >= shardTotal { + t.Fatalf("invalid -shard-index=%d for -shard-total=%d", shardIndex, shardTotal) + } + if shardTotal == 1 { + return cases + } + selected := make([]testCase, 0, len(cases)/shardTotal+1) + for i, tc := range cases { + if i%shardTotal == shardIndex { + selected = append(selected, tc) + } + } + return selected +} + +func parseDirective(filePath string) (string, []string, bool) { + f, err := os.Open(filePath) + if err != nil { + return "", nil, false + } + defer f.Close() + + scanner := bufio.NewScanner(f) + for scanner.Scan() { + line := strings.TrimSpace(scanner.Text()) + if strings.HasPrefix(line, "package ") { + break + } + if !strings.HasPrefix(line, "//") { + continue + } + text := strings.TrimSpace(strings.TrimPrefix(line, "//")) + fields := strings.Fields(text) + if len(fields) == 0 { + continue + } + switch fields[0] { + case "run", "runoutput", "compile", "errorcheck", "errorcheckandrundir": + return fields[0], fields[1:], true + } + } + return "", nil, false +} + +func runCase(t *testing.T, repoRoot, goroot, goCmd, llgoBin string, tc testCase, runTimeout time.Duration) error { + t.Helper() + workRoot, cleanup, err := prepareWorkTree(tc.Dir) + if err != nil { + return err + } + if !*flagKeep { + defer cleanup() + } + + goStdout, goStderr, goExit, err := runProgram(workRoot, goCmd, runnerEnv(repoRoot, goroot), runTimeout, "run", tc.FileName) + if err != nil { + return commandFailure("baseline go run", err, goStdout, goStderr, goExit) + } + llgoStdout, llgoStderr, llgoExit, err := runProgram(workRoot, llgoBin, runnerEnv(repoRoot, goroot), runTimeout, "run", tc.FileName) + if err != nil { + return commandFailure("llgo run", err, llgoStdout, llgoStderr, llgoExit) + } + + goStdout = normalizeOutput(goStdout) + goStderr = normalizeOutput(goStderr) + llgoStdout = normalizeOutput(filterNoise(llgoStdout)) + llgoStderr = normalizeOutput(filterNoise(llgoStderr)) + + if !bytes.Equal(llgoStdout, goStdout) { + return fmt.Errorf("stdout mismatch\nllgo:\n%s\n\ngo:\n%s", llgoStdout, goStdout) + } + if !bytes.Equal(llgoStderr, goStderr) { + return fmt.Errorf("stderr mismatch\nllgo:\n%s\n\ngo:\n%s", llgoStderr, goStderr) + } + if llgoExit != goExit { + return fmt.Errorf("exit code mismatch: llgo=%d go=%d", llgoExit, goExit) + } + return nil +} + +func prepareWorkTree(srcDir string) (string, func(), error) { + root, err := os.MkdirTemp("", "llgo-goroot-*") + if err != nil { + return "", nil, err + } + linkPath := filepath.Join(root, "src") + if err := os.Symlink(srcDir, linkPath); err != nil { + _ = os.RemoveAll(root) + return "", nil, fmt.Errorf("symlink %q -> %q: %w", linkPath, srcDir, err) + } + return linkPath, func() { + _ = os.RemoveAll(root) + }, nil +} + +func runnerEnv(repoRoot, goroot string) []string { + env := append([]string{}, os.Environ()...) + pathFound := false + for i, item := range env { + switch { + case strings.HasPrefix(item, "GOROOT="): + env[i] = "GOROOT=" + goroot + case strings.HasPrefix(item, "GOENV="): + env[i] = "GOENV=off" + case strings.HasPrefix(item, "GOFLAGS="): + env[i] = "GOFLAGS=" + case strings.HasPrefix(item, "LLGO_ROOT="): + env[i] = "LLGO_ROOT=" + repoRoot + case strings.HasPrefix(item, "PATH="): + pathFound = true + env[i] = "PATH=" + filepath.Join(goroot, "bin") + string(os.PathListSeparator) + strings.TrimPrefix(item, "PATH=") + } + } + if !pathFound { + env = append(env, "PATH="+filepath.Join(goroot, "bin")) + } + env = appendIfMissing(env, "GOROOT="+goroot) + env = appendIfMissing(env, "GOENV=off") + env = appendIfMissing(env, "GOFLAGS=") + env = appendIfMissing(env, "LLGO_ROOT="+repoRoot) + return env +} + +func appendIfMissing(env []string, kv string) []string { + key := strings.SplitN(kv, "=", 2)[0] + "=" + for _, item := range env { + if strings.HasPrefix(item, key) { + return env + } + } + return append(env, kv) +} + +func runProgram(dir, app string, env []string, timeout time.Duration, args ...string) ([]byte, []byte, int, error) { + cmd := exec.Command(app, args...) + configureProcessGroup(cmd) + cmd.Dir = dir + cmd.Env = env + var stdout bytes.Buffer + var stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr + if err := cmd.Start(); err != nil { + return nil, nil, 0, err + } + + waitCh := make(chan error, 1) + go func() { + waitCh <- cmd.Wait() + }() + + var err error + timedOut := false + if timeout > 0 { + select { + case err = <-waitCh: + case <-time.After(timeout): + timedOut = true + killProcessTree(cmd) + err = <-waitCh + } + } else { + err = <-waitCh + } + exitCode := 0 + if err != nil { + var exitErr *exec.ExitError + switch { + case errors.As(err, &exitErr): + exitCode = exitErr.ExitCode() + default: + return nil, nil, 0, err + } + } + if timedOut { + return stdout.Bytes(), stderr.Bytes(), exitCode, fmt.Errorf("timed out after %s", timeout) + } + return stdout.Bytes(), stderr.Bytes(), exitCode, nil +} + +func commandFailure(prefix string, err error, stdout, stderr []byte, exitCode int) error { + var msg strings.Builder + fmt.Fprintf(&msg, "%s failed: %v", prefix, err) + if exitCode != 0 { + fmt.Fprintf(&msg, "\nexit code: %d", exitCode) + } + if len(stdout) != 0 { + fmt.Fprintf(&msg, "\nstdout:\n%s", normalizeOutput(stdout)) + } + if len(stderr) != 0 { + fmt.Fprintf(&msg, "\nstderr:\n%s", normalizeOutput(stderr)) + } + return errors.New(msg.String()) +} + +func normalizeOutput(in []byte) []byte { + in = bytes.ReplaceAll(in, []byte("\r\n"), []byte("\n")) + in = bytes.ReplaceAll(in, []byte("\r"), []byte("\n")) + lines := bytes.SplitAfter(in, []byte{'\n'}) + if len(lines) == 0 { + return in + } + var out bytes.Buffer + for _, line := range lines { + out.WriteString(trimLogTimestampPrefix(string(line))) + } + return out.Bytes() +} + +func filterNoise(in []byte) []byte { + lines := bytes.SplitAfter(in, []byte{'\n'}) + if len(lines) == 0 { + return in + } + var out bytes.Buffer + for _, line := range lines { + trimmed := strings.TrimSpace(string(line)) + switch { + case strings.HasPrefix(trimmed, "WARNING: Using LLGO root for devel:"): + continue + case strings.HasPrefix(trimmed, "WARNING: LLGO_ROOT is not a valid LLGO root:"): + continue + case strings.HasPrefix(trimmed, "ld64.lld: warning:"): + continue + case strings.HasPrefix(trimmed, "ld.lld: warning:"): + continue + case strings.HasPrefix(trimmed, "ld: warning:"): + continue + } + out.Write(line) + } + return out.Bytes() +} + +func trimLogTimestampPrefix(line string) string { + if len(line) < 20 { + return line + } + if line[4] != '/' || line[7] != '/' || line[10] != ' ' || line[13] != ':' || line[16] != ':' || line[19] != ' ' { + return line + } + for _, pos := range []int{0, 1, 2, 3, 5, 6, 8, 9, 11, 12, 14, 15, 17, 18} { + if line[pos] < '0' || line[pos] > '9' { + return line + } + } + return line[20:] +} + +func releaseTagsFor(goVersion string) []string { + major, minor, ok := parseGoVersion(goVersion) + if !ok || major != 1 || minor < 1 { + return nil + } + tags := make([]string, 0, minor) + for i := 1; i <= minor; i++ { + tags = append(tags, fmt.Sprintf("go1.%d", i)) + } + return tags +} + +func parseGoVersion(goVersion string) (int, int, bool) { + if !strings.HasPrefix(goVersion, "go") { + return 0, 0, false + } + body := strings.TrimPrefix(goVersion, "go") + parts := strings.SplitN(body, ".", 3) + if len(parts) < 2 { + return 0, 0, false + } + major, err := strconv.Atoi(parts[0]) + if err != nil { + return 0, 0, false + } + minorPart := parts[1] + var digits strings.Builder + for _, r := range minorPart { + if r < '0' || r > '9' { + break + } + digits.WriteRune(r) + } + if digits.Len() == 0 { + return 0, 0, false + } + minor, err := strconv.Atoi(digits.String()) + if err != nil { + return 0, 0, false + } + return major, minor, true +} + +func (cfg xfailConfig) Match(goVersion, platform string, tc testCase) (bool, string) { + return matchEntries(cfg.Entries, goVersion, platform, tc) +} + +func (cfg xfailConfig) MatchHostSkip(goVersion, platform string, tc testCase) (bool, string) { + return matchEntries(cfg.HostSkips, goVersion, platform, tc) +} + +func (cfg xfailConfig) MatchTimeout(goVersion, platform string, tc testCase) (time.Duration, string, bool) { + for _, entry := range cfg.Timeouts { + if !entry.matches(goVersion, platform, tc) { + continue + } + timeout, err := time.ParseDuration(entry.Timeout) + if err != nil { + return 0, fmt.Sprintf("invalid timeout override %q for %s: %v", entry.Timeout, entry.Case, err), false + } + reason := entry.Reason + if reason == "" { + reason = entry.Case + } + return timeout, reason, true + } + return 0, "", false +} + +func matchEntries(entries []xfailEntry, goVersion, platform string, tc testCase) (bool, string) { + for _, entry := range entries { + if !entry.matches(goVersion, platform, tc) { + continue + } + reason := entry.Reason + if reason == "" { + reason = entry.Case + } + return true, reason + } + return false, "" +} + +func (entry xfailEntry) matches(goVersion, platform string, tc testCase) bool { + return matchEntry(entry.Version, entry.Platform, entry.Directive, entry.Case, goVersion, platform, tc) +} + +func (entry timeoutEntry) matches(goVersion, platform string, tc testCase) bool { + return matchEntry(entry.Version, entry.Platform, entry.Directive, entry.Case, goVersion, platform, tc) +} + +func matchEntry(version, platform, directive, casePattern, goVersion, goPlatform string, tc testCase) bool { + if version != "" && !strings.HasPrefix(goVersion, version) { + return false + } + if platform != "" && platform != goPlatform { + return false + } + if directive != "" && directive != tc.Directive { + return false + } + if casePattern == "" { + return true + } + ok, err := path.Match(casePattern, tc.RelPath) + return err == nil && ok +} diff --git a/test/goroot/runner_unit_test.go b/test/goroot/runner_unit_test.go new file mode 100644 index 0000000000..15830c093c --- /dev/null +++ b/test/goroot/runner_unit_test.go @@ -0,0 +1,179 @@ +package goroot + +import ( + "os" + "path/filepath" + "reflect" + "strings" + "testing" + "time" +) + +func TestParseDirective(t *testing.T) { + dir := t.TempDir() + file := filepath.Join(dir, "case.go") + if err := os.WriteFile(file, []byte("// run\n\npackage main\n"), 0644); err != nil { + t.Fatal(err) + } + directive, args, ok := parseDirective(file) + if !ok { + t.Fatal("expected directive to be found") + } + if directive != "run" { + t.Fatalf("directive=%q, want run", directive) + } + if len(args) != 0 { + t.Fatalf("args=%v, want none", args) + } +} + +func TestParseDirectiveWithArgs(t *testing.T) { + dir := t.TempDir() + file := filepath.Join(dir, "case.go") + if err := os.WriteFile(file, []byte("// errorcheckandrundir -1\n\npackage ignored\n"), 0644); err != nil { + t.Fatal(err) + } + directive, args, ok := parseDirective(file) + if !ok { + t.Fatal("expected directive to be found") + } + if directive != "errorcheckandrundir" { + t.Fatalf("directive=%q, want errorcheckandrundir", directive) + } + if !reflect.DeepEqual(args, []string{"-1"}) { + t.Fatalf("args=%v, want [-1]", args) + } +} + +func TestReleaseTagsFor(t *testing.T) { + got := releaseTagsFor("go1.24.11") + want := []string{ + "go1.1", "go1.2", "go1.3", "go1.4", "go1.5", "go1.6", "go1.7", "go1.8", + "go1.9", "go1.10", "go1.11", "go1.12", "go1.13", "go1.14", "go1.15", "go1.16", + "go1.17", "go1.18", "go1.19", "go1.20", "go1.21", "go1.22", "go1.23", "go1.24", + } + if !reflect.DeepEqual(got, want) { + t.Fatalf("releaseTagsFor()=%v, want %v", got, want) + } +} + +func TestXFailMatch(t *testing.T) { + cfg := xfailConfig{ + Entries: []xfailEntry{{ + Version: "go1.24", + Platform: "darwin/arm64", + Directive: "run", + Case: "fixedbugs/*", + Reason: "known issue", + }}, + } + tc := testCase{RelPath: "fixedbugs/bug123.go", Directive: "run"} + match, reason := cfg.Match("go1.24.11", "darwin/arm64", tc) + if !match { + t.Fatal("expected xfail match") + } + if reason != "known issue" { + t.Fatalf("reason=%q, want known issue", reason) + } +} + +func TestHostSkipMatch(t *testing.T) { + cfg := xfailConfig{ + HostSkips: []xfailEntry{{ + Version: "go1.24", + Platform: "darwin/arm64", + Directive: "run", + Case: "fixedbugs/*", + Reason: "host-unsafe", + }}, + } + tc := testCase{RelPath: "fixedbugs/bug123.go", Directive: "run"} + match, reason := cfg.MatchHostSkip("go1.24.11", "darwin/arm64", tc) + if !match { + t.Fatal("expected host skip match") + } + if reason != "host-unsafe" { + t.Fatalf("reason=%q, want host-unsafe", reason) + } +} + +func TestTimeoutMatch(t *testing.T) { + cfg := xfailConfig{ + Timeouts: []timeoutEntry{{ + Version: "go1.24", + Platform: "darwin/arm64", + Directive: "run", + Case: "fixedbugs/*", + Timeout: "90s", + Reason: "slow case", + }}, + } + tc := testCase{RelPath: "fixedbugs/bug123.go", Directive: "run"} + timeout, reason, ok := cfg.MatchTimeout("go1.24.11", "darwin/arm64", tc) + if !ok { + t.Fatal("expected timeout match") + } + if timeout != 90*time.Second { + t.Fatalf("timeout=%s, want 90s", timeout) + } + if reason != "slow case" { + t.Fatalf("reason=%q, want slow case", reason) + } +} + +func TestRunProgramTimeout(t *testing.T) { + if os.Getenv("LLGO_GOROOT_HELPER") == "sleep" { + time.Sleep(200 * time.Millisecond) + return + } + + stdout, stderr, exitCode, err := runProgram( + t.TempDir(), + os.Args[0], + append(os.Environ(), "LLGO_GOROOT_HELPER=sleep"), + 50*time.Millisecond, + "-test.run=TestRunProgramTimeout", + ) + if err == nil { + t.Fatal("expected timeout") + } + if exitCode == 0 { + t.Fatalf("exitCode=%d, want non-zero on timeout", exitCode) + } + if len(stdout) != 0 { + t.Fatalf("stdout=%q, want empty", stdout) + } + if len(stderr) != 0 { + t.Fatalf("stderr=%q, want empty", stderr) + } + if !strings.Contains(err.Error(), "timed out after") { + t.Fatalf("err=%v, want timeout", err) + } +} + +func TestNormalizeOutputStripsLogTimestamp(t *testing.T) { + in := []byte("2026/03/13 00:56:11 listing stdlib export files: open : no such file or directory\n") + got := string(normalizeOutput(in)) + want := "listing stdlib export files: open : no such file or directory\n" + if got != want { + t.Fatalf("normalizeOutput()=%q, want %q", got, want) + } +} + +func TestShardCases(t *testing.T) { + cases := []testCase{ + {RelPath: "a.go"}, + {RelPath: "b.go"}, + {RelPath: "c.go"}, + {RelPath: "d.go"}, + {RelPath: "e.go"}, + } + got := shardCases(t, cases, 1, 3) + want := []testCase{ + {RelPath: "b.go"}, + {RelPath: "e.go"}, + } + if !reflect.DeepEqual(got, want) { + t.Fatalf("shardCases()=%v, want %v", got, want) + } +} diff --git a/test/goroot/xfail.yaml b/test/goroot/xfail.yaml new file mode 100644 index 0000000000..6a074a8521 --- /dev/null +++ b/test/goroot/xfail.yaml @@ -0,0 +1,554 @@ +host_skips: + - platform: darwin/arm64 + directive: run + case: ddd.go + reason: host-unsafe concurrency case can destabilize the host + - platform: darwin/arm64 + directive: run + case: gcgort.go + reason: host-unsafe concurrency case can destabilize the host + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue25897b.go + reason: host-unsafe concurrency case can destabilize the host + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue27695.go + reason: host-unsafe concurrency case can destabilize the host + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue39541.go + reason: host-unsafe concurrency case can destabilize the host +xfails: + - platform: darwin/arm64 + directive: run + case: append.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: blank.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: chancap.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: chanlinear.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: closedchan.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: convert4.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: deferfin.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: deferprint.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: finprofiled.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: goprint.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: heapsampling.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: init1.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: inline_literal.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: mallocfin.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: method.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: method5.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: nil.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: nilptr2.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: noinit.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: peano.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: print.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: range.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: recover.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: recover1.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: recover2.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: recover3.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: recover4.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: reflectmethod1.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: reflectmethod2.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: reflectmethod3.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: reflectmethod5.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: reflectmethod6.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: slicecap.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: stack.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: stackobj.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: stackobj3.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: switch.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: tinyfin.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: unsafebuiltins.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: zerodivide.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: zerosize.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: ken/chan.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: ken/cplx0.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: chan/doubleselect.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: chan/select2.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: chan/select3.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: interface/fake.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: interface/noeq.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/bug273.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/bug336.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/bug347.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/bug348.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/bug409.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue10332.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue12133.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue13169.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue14646.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue15039.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue15175.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue15281.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue16037_run.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue16130.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue17381.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue18149.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue19040.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue19246.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue21879.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue22083.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue22662.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue22881.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue23017.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue23837.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue24491b.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue25897a.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue26094.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue26335.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue27201.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue27518b.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue28748.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue29190.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue29504.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue29735.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue30116.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue30116u.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue31546.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue32187.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue32477.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue33724.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue35576.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue37975.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue38496.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue4316.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue43835.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue43942.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue44830.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue45045.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue4562.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue4585.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue46725.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue48898.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue52788.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue52788a.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue53137.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue53635.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue54343.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue5493.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue5704.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue57823.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue58300.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue58300b.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue5856.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue59411.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue5963.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue60601.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue63657.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue65417.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue6899.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue71675.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue7550.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue7690.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue8048.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue8132.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: fixedbugs/issue8606b.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: typeparam/chans.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: typeparam/issue48645a.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: typeparam/issue49547.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: typeparam/issue51521.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: typeparam/nested.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: typeparam/orderedmap.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: typeparam/typeswitch5.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: typeparam/typeswitch6.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: typeparam/mdempsky/16.go + reason: latest main goroot run failure on darwin/arm64 + - platform: darwin/arm64 + directive: run + case: typeparam/mdempsky/17.go + reason: latest main goroot run failure on darwin/arm64 From fd5f75f5f0956a70128c51e03f0a72948256d57f Mon Sep 17 00:00:00 2001 From: Li Jie Date: Thu, 26 Mar 2026 09:09:59 +0800 Subject: [PATCH 35/44] test: record go1.25 goroot xfails for ci --- test/goroot/xfail.yaml | 183 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 183 insertions(+) diff --git a/test/goroot/xfail.yaml b/test/goroot/xfail.yaml index 6a074a8521..e889f4a1e6 100644 --- a/test/goroot/xfail.yaml +++ b/test/goroot/xfail.yaml @@ -552,3 +552,186 @@ xfails: directive: run case: typeparam/mdempsky/17.go reason: latest main goroot run failure on darwin/arm64 + - {version: go1.25, platform: darwin/arm64, directive: run, case: chan/goroutines.go, reason: go1.25 goroot run failure on darwin/arm64} + - {version: go1.25, platform: darwin/arm64, directive: run, case: const7.go, reason: go1.25 goroot run failure on darwin/arm64} + - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/bug206.go, reason: go1.25 goroot run failure on darwin/arm64} + - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/bug295.go, reason: go1.25 goroot run failure on darwin/arm64} + - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/bug369.go, reason: go1.25 goroot run failure on darwin/arm64} + - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue11771.go, reason: go1.25 goroot run failure on darwin/arm64} + - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue13268.go, reason: go1.25 goroot run failure on darwin/arm64} + - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue14636.go, reason: go1.25 goroot run failure on darwin/arm64} + - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue19658.go, reason: go1.25 goroot run failure on darwin/arm64} + - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue21317.go, reason: go1.25 goroot run failure on darwin/arm64} + - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue21576.go, reason: go1.25 goroot run failure on darwin/arm64} + - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue22660.go, reason: go1.25 goroot run failure on darwin/arm64} + - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue22662b.go, reason: go1.25 goroot run failure on darwin/arm64} + - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue26411.go, reason: go1.25 goroot run failure on darwin/arm64} + - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue33275_run.go, reason: go1.25 goroot run failure on darwin/arm64} + - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue33555.go, reason: go1.25 goroot run failure on darwin/arm64} + - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue36437.go, reason: go1.25 goroot run failure on darwin/arm64} + - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue4618.go, reason: go1.25 goroot run failure on darwin/arm64} + - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue4667.go, reason: go1.25 goroot run failure on darwin/arm64} + - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue52127.go, reason: go1.25 goroot run failure on darwin/arm64} + - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue54542.go, reason: go1.25 goroot run failure on darwin/arm64} + - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue56990.go, reason: go1.25 goroot run failure on darwin/arm64} + - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue72844.go, reason: go1.25 goroot run failure on darwin/arm64} + - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue9355.go, reason: go1.25 goroot run failure on darwin/arm64} + - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue9862_run.go, reason: go1.25 goroot run failure on darwin/arm64} + - {version: go1.25, platform: darwin/arm64, directive: run, case: linkmain_run.go, reason: go1.25 goroot run failure on darwin/arm64} + - {version: go1.25, platform: darwin/arm64, directive: run, case: linkobj.go, reason: go1.25 goroot run failure on darwin/arm64} + - {version: go1.25, platform: darwin/arm64, directive: run, case: linkx_run.go, reason: go1.25 goroot run failure on darwin/arm64} + - {version: go1.25, platform: darwin/arm64, directive: run, case: nosplit.go, reason: go1.25 goroot run failure on darwin/arm64} + - {version: go1.25, platform: darwin/arm64, directive: run, case: typeparam/issue48317.go, reason: go1.25 goroot run failure on darwin/arm64} + - {version: go1.25, platform: darwin/arm64, directive: run, case: typeparam/issue48318.go, reason: go1.25 goroot run failure on darwin/arm64} + - {version: go1.25, platform: darwin/arm64, directive: run, case: winbatch.go, reason: go1.25 goroot run failure on darwin/arm64} + - {version: go1.25, platform: linux/amd64, directive: run, case: append.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: blank.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: chan/select3.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: chancap.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: closedchan.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: convert4.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: deferfin.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: deferprint.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: divide.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: divmod.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: finprofiled.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/bug273.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/bug336.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/bug347.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/bug348.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/bug409.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/bug512.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue10332.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue12133.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue13169.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue14646.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue15002.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue15039.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue15175.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue15277.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue15281.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue16037_run.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue16130.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue16331.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue17381.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue18149.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue19040.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue19246.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue21879.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue22083.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue22605.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue22662.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue22881.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue23017.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue23837.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue24491b.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue25897a.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue25897b.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue26094.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue26335.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue27201.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue27518b.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue27695.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue27695b.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue27695c.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue28748.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue29190.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue29504.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue29735.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue30116.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue30116u.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue30606.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue30606b.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue31546.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue32187.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue32477.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue33724.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue35576.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue37716.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue37975.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue38496.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue4316.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue43835.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue43942.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue44830.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue45045.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue4562.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue4585.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue46725.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue48898.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue49110.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue52788.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue52788a.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue53137.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue53635.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue54343.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue5493.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue5704.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue57823.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue58300.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue58300b.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue5856.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue59411.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue5963.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue59680.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue60601.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue63657.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue65417.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue6899.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue71675.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue72844.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue7550.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue7690.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue8048.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue8132.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue8606b.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue9321.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: gcgort.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: goprint.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: heapsampling.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: init1.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: inline_literal.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: interface/fake.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: interface/noeq.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: ken/chan.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: ken/cplx0.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: mallocfin.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: method.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: method5.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: nil.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: nilptr.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: nilptr2.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: noinit.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: peano.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: print.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: range.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: recover.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: recover1.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: recover2.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: recover3.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: reflectmethod1.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: reflectmethod2.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: reflectmethod3.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: reflectmethod4.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: reflectmethod5.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: reflectmethod6.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: reflectmethod7.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: slicecap.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: stackobj.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: stackobj3.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: switch.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: tinyfin.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: typeparam/chans.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: typeparam/issue48317.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: typeparam/issue48645a.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: typeparam/issue49547.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: typeparam/issue51521.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: typeparam/mdempsky/16.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: typeparam/mdempsky/17.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: typeparam/nested.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: typeparam/orderedmap.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: typeparam/typeswitch5.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: typeparam/typeswitch6.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: unsafebuiltins.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: zerodivide.go, reason: go1.25 goroot run failure on linux/amd64} + - {version: go1.25, platform: linux/amd64, directive: run, case: zerosize.go, reason: go1.25 goroot run failure on linux/amd64} From 4b0819af2bf77efbd10beb76a241c00e32326c1b Mon Sep 17 00:00:00 2001 From: Li Jie Date: Thu, 26 Mar 2026 09:47:57 +0800 Subject: [PATCH 36/44] test: expand goroot xfail entries --- test/goroot/xfail.yaml | 1098 +++++++++++++++++++++++++++++++++------- 1 file changed, 915 insertions(+), 183 deletions(-) diff --git a/test/goroot/xfail.yaml b/test/goroot/xfail.yaml index e889f4a1e6..7cf3038cac 100644 --- a/test/goroot/xfail.yaml +++ b/test/goroot/xfail.yaml @@ -552,186 +552,918 @@ xfails: directive: run case: typeparam/mdempsky/17.go reason: latest main goroot run failure on darwin/arm64 - - {version: go1.25, platform: darwin/arm64, directive: run, case: chan/goroutines.go, reason: go1.25 goroot run failure on darwin/arm64} - - {version: go1.25, platform: darwin/arm64, directive: run, case: const7.go, reason: go1.25 goroot run failure on darwin/arm64} - - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/bug206.go, reason: go1.25 goroot run failure on darwin/arm64} - - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/bug295.go, reason: go1.25 goroot run failure on darwin/arm64} - - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/bug369.go, reason: go1.25 goroot run failure on darwin/arm64} - - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue11771.go, reason: go1.25 goroot run failure on darwin/arm64} - - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue13268.go, reason: go1.25 goroot run failure on darwin/arm64} - - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue14636.go, reason: go1.25 goroot run failure on darwin/arm64} - - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue19658.go, reason: go1.25 goroot run failure on darwin/arm64} - - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue21317.go, reason: go1.25 goroot run failure on darwin/arm64} - - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue21576.go, reason: go1.25 goroot run failure on darwin/arm64} - - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue22660.go, reason: go1.25 goroot run failure on darwin/arm64} - - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue22662b.go, reason: go1.25 goroot run failure on darwin/arm64} - - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue26411.go, reason: go1.25 goroot run failure on darwin/arm64} - - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue33275_run.go, reason: go1.25 goroot run failure on darwin/arm64} - - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue33555.go, reason: go1.25 goroot run failure on darwin/arm64} - - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue36437.go, reason: go1.25 goroot run failure on darwin/arm64} - - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue4618.go, reason: go1.25 goroot run failure on darwin/arm64} - - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue4667.go, reason: go1.25 goroot run failure on darwin/arm64} - - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue52127.go, reason: go1.25 goroot run failure on darwin/arm64} - - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue54542.go, reason: go1.25 goroot run failure on darwin/arm64} - - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue56990.go, reason: go1.25 goroot run failure on darwin/arm64} - - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue72844.go, reason: go1.25 goroot run failure on darwin/arm64} - - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue9355.go, reason: go1.25 goroot run failure on darwin/arm64} - - {version: go1.25, platform: darwin/arm64, directive: run, case: fixedbugs/issue9862_run.go, reason: go1.25 goroot run failure on darwin/arm64} - - {version: go1.25, platform: darwin/arm64, directive: run, case: linkmain_run.go, reason: go1.25 goroot run failure on darwin/arm64} - - {version: go1.25, platform: darwin/arm64, directive: run, case: linkobj.go, reason: go1.25 goroot run failure on darwin/arm64} - - {version: go1.25, platform: darwin/arm64, directive: run, case: linkx_run.go, reason: go1.25 goroot run failure on darwin/arm64} - - {version: go1.25, platform: darwin/arm64, directive: run, case: nosplit.go, reason: go1.25 goroot run failure on darwin/arm64} - - {version: go1.25, platform: darwin/arm64, directive: run, case: typeparam/issue48317.go, reason: go1.25 goroot run failure on darwin/arm64} - - {version: go1.25, platform: darwin/arm64, directive: run, case: typeparam/issue48318.go, reason: go1.25 goroot run failure on darwin/arm64} - - {version: go1.25, platform: darwin/arm64, directive: run, case: winbatch.go, reason: go1.25 goroot run failure on darwin/arm64} - - {version: go1.25, platform: linux/amd64, directive: run, case: append.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: blank.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: chan/select3.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: chancap.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: closedchan.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: convert4.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: deferfin.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: deferprint.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: divide.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: divmod.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: finprofiled.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/bug273.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/bug336.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/bug347.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/bug348.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/bug409.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/bug512.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue10332.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue12133.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue13169.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue14646.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue15002.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue15039.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue15175.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue15277.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue15281.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue16037_run.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue16130.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue16331.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue17381.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue18149.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue19040.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue19246.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue21879.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue22083.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue22605.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue22662.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue22881.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue23017.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue23837.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue24491b.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue25897a.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue25897b.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue26094.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue26335.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue27201.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue27518b.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue27695.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue27695b.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue27695c.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue28748.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue29190.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue29504.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue29735.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue30116.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue30116u.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue30606.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue30606b.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue31546.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue32187.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue32477.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue33724.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue35576.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue37716.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue37975.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue38496.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue4316.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue43835.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue43942.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue44830.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue45045.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue4562.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue4585.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue46725.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue48898.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue49110.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue52788.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue52788a.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue53137.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue53635.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue54343.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue5493.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue5704.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue57823.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue58300.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue58300b.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue5856.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue59411.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue5963.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue59680.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue60601.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue63657.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue65417.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue6899.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue71675.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue72844.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue7550.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue7690.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue8048.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue8132.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue8606b.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: fixedbugs/issue9321.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: gcgort.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: goprint.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: heapsampling.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: init1.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: inline_literal.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: interface/fake.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: interface/noeq.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: ken/chan.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: ken/cplx0.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: mallocfin.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: method.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: method5.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: nil.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: nilptr.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: nilptr2.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: noinit.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: peano.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: print.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: range.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: recover.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: recover1.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: recover2.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: recover3.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: reflectmethod1.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: reflectmethod2.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: reflectmethod3.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: reflectmethod4.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: reflectmethod5.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: reflectmethod6.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: reflectmethod7.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: slicecap.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: stackobj.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: stackobj3.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: switch.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: tinyfin.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: typeparam/chans.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: typeparam/issue48317.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: typeparam/issue48645a.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: typeparam/issue49547.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: typeparam/issue51521.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: typeparam/mdempsky/16.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: typeparam/mdempsky/17.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: typeparam/nested.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: typeparam/orderedmap.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: typeparam/typeswitch5.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: typeparam/typeswitch6.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: unsafebuiltins.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: zerodivide.go, reason: go1.25 goroot run failure on linux/amd64} - - {version: go1.25, platform: linux/amd64, directive: run, case: zerosize.go, reason: go1.25 goroot run failure on linux/amd64} + - version: go1.25 + platform: darwin/arm64 + directive: run + case: chan/goroutines.go + reason: go1.25 goroot run failure on darwin/arm64 + - version: go1.25 + platform: darwin/arm64 + directive: run + case: const7.go + reason: go1.25 goroot run failure on darwin/arm64 + - version: go1.25 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug206.go + reason: go1.25 goroot run failure on darwin/arm64 + - version: go1.25 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug295.go + reason: go1.25 goroot run failure on darwin/arm64 + - version: go1.25 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug369.go + reason: go1.25 goroot run failure on darwin/arm64 + - version: go1.25 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue11771.go + reason: go1.25 goroot run failure on darwin/arm64 + - version: go1.25 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue13268.go + reason: go1.25 goroot run failure on darwin/arm64 + - version: go1.25 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue14636.go + reason: go1.25 goroot run failure on darwin/arm64 + - version: go1.25 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue19658.go + reason: go1.25 goroot run failure on darwin/arm64 + - version: go1.25 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue21317.go + reason: go1.25 goroot run failure on darwin/arm64 + - version: go1.25 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue21576.go + reason: go1.25 goroot run failure on darwin/arm64 + - version: go1.25 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue22660.go + reason: go1.25 goroot run failure on darwin/arm64 + - version: go1.25 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue22662b.go + reason: go1.25 goroot run failure on darwin/arm64 + - version: go1.25 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue26411.go + reason: go1.25 goroot run failure on darwin/arm64 + - version: go1.25 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue33275_run.go + reason: go1.25 goroot run failure on darwin/arm64 + - version: go1.25 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue33555.go + reason: go1.25 goroot run failure on darwin/arm64 + - version: go1.25 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue36437.go + reason: go1.25 goroot run failure on darwin/arm64 + - version: go1.25 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue4618.go + reason: go1.25 goroot run failure on darwin/arm64 + - version: go1.25 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue4667.go + reason: go1.25 goroot run failure on darwin/arm64 + - version: go1.25 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue52127.go + reason: go1.25 goroot run failure on darwin/arm64 + - version: go1.25 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue54542.go + reason: go1.25 goroot run failure on darwin/arm64 + - version: go1.25 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue56990.go + reason: go1.25 goroot run failure on darwin/arm64 + - version: go1.25 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue72844.go + reason: go1.25 goroot run failure on darwin/arm64 + - version: go1.25 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue9355.go + reason: go1.25 goroot run failure on darwin/arm64 + - version: go1.25 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue9862_run.go + reason: go1.25 goroot run failure on darwin/arm64 + - version: go1.25 + platform: darwin/arm64 + directive: run + case: linkmain_run.go + reason: go1.25 goroot run failure on darwin/arm64 + - version: go1.25 + platform: darwin/arm64 + directive: run + case: linkobj.go + reason: go1.25 goroot run failure on darwin/arm64 + - version: go1.25 + platform: darwin/arm64 + directive: run + case: linkx_run.go + reason: go1.25 goroot run failure on darwin/arm64 + - version: go1.25 + platform: darwin/arm64 + directive: run + case: nosplit.go + reason: go1.25 goroot run failure on darwin/arm64 + - version: go1.25 + platform: darwin/arm64 + directive: run + case: typeparam/issue48317.go + reason: go1.25 goroot run failure on darwin/arm64 + - version: go1.25 + platform: darwin/arm64 + directive: run + case: typeparam/issue48318.go + reason: go1.25 goroot run failure on darwin/arm64 + - version: go1.25 + platform: darwin/arm64 + directive: run + case: winbatch.go + reason: go1.25 goroot run failure on darwin/arm64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: append.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: blank.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: chan/select3.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: chancap.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: closedchan.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: convert4.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: deferfin.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: deferprint.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: divide.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: divmod.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: finprofiled.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/bug273.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/bug336.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/bug347.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/bug348.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/bug409.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/bug512.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue10332.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue12133.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue13169.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue14646.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue15002.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue15039.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue15175.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue15277.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue15281.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue16037_run.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue16130.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue16331.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue17381.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue18149.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue19040.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue19246.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue21879.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue22083.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue22605.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue22662.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue22881.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue23017.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue23837.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue24491b.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue25897a.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue25897b.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue26094.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue26335.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue27201.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue27518b.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue27695.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue27695b.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue27695c.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue28748.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue29190.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue29504.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue29735.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue30116.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue30116u.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue30606.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue30606b.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue31546.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue32187.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue32477.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue33724.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue35576.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue37716.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue37975.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue38496.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue4316.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue43835.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue43942.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue44830.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue45045.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue4562.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue4585.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue46725.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue48898.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue49110.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue52788.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue52788a.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue53137.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue53635.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue54343.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue5493.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue5704.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue57823.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue58300.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue58300b.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue5856.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue59411.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue5963.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue59680.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue60601.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue63657.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue65417.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue6899.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue71675.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue72844.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue7550.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue7690.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue8048.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue8132.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue8606b.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: fixedbugs/issue9321.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: gcgort.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: goprint.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: heapsampling.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: init1.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: inline_literal.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: interface/fake.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: interface/noeq.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: ken/chan.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: ken/cplx0.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: mallocfin.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: method.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: method5.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: nil.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: nilptr.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: nilptr2.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: noinit.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: peano.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: print.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: range.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: recover.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: recover1.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: recover2.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: recover3.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: reflectmethod1.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: reflectmethod2.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: reflectmethod3.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: reflectmethod4.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: reflectmethod5.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: reflectmethod6.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: reflectmethod7.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: slicecap.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: stackobj.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: stackobj3.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: switch.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: tinyfin.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: typeparam/chans.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: typeparam/issue48317.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: typeparam/issue48645a.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: typeparam/issue49547.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: typeparam/issue51521.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: typeparam/mdempsky/16.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: typeparam/mdempsky/17.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: typeparam/nested.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: typeparam/orderedmap.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: typeparam/typeswitch5.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: typeparam/typeswitch6.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: unsafebuiltins.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: zerodivide.go + reason: go1.25 goroot run failure on linux/amd64 + - version: go1.25 + platform: linux/amd64 + directive: run + case: zerosize.go + reason: go1.25 goroot run failure on linux/amd64 From 07089150ed8727d383dd3dd320f85f95f0c1cf1f Mon Sep 17 00:00:00 2001 From: Li Jie Date: Thu, 26 Mar 2026 10:30:03 +0800 Subject: [PATCH 37/44] test: address goroot runner review feedback --- .github/workflows/goroot.yml | 4 ++-- dev/test_goroot.sh | 2 +- test/goroot/README.md | 3 +++ test/goroot/runner_test.go | 34 ++++++++++++++++++++++++--------- test/goroot/runner_unit_test.go | 20 +++++++++++++++++++ 5 files changed, 51 insertions(+), 12 deletions(-) diff --git a/.github/workflows/goroot.yml b/.github/workflows/goroot.yml index da3a00e1bb..a374ac16ef 100644 --- a/.github/workflows/goroot.yml +++ b/.github/workflows/goroot.yml @@ -23,7 +23,7 @@ jobs: - macos-latest - ubuntu-latest llvm: [19] - shard: ["0", "1", "2", "3"] + shard: ["0", "1"] runs-on: ${{ matrix.os }} steps: - uses: actions/checkout@v6 @@ -47,4 +47,4 @@ jobs: run: | bash dev/test_goroot.sh -- \ -shard-index "${{ matrix.shard }}" \ - -shard-total 4 + -shard-total 2 diff --git a/dev/test_goroot.sh b/dev/test_goroot.sh index e3c8201f72..5d9b5a2b8b 100755 --- a/dev/test_goroot.sh +++ b/dev/test_goroot.sh @@ -36,6 +36,6 @@ for goroot in "${goroots[@]}"; do echo "==== $version ($goroot) ====" ( cd "$repo_root" - go test ./test/goroot -count=1 -args -goroot "$goroot" "${runner_args[@]}" + go test ./test/goroot -count=1 -timeout 90m -args -goroot "$goroot" "${runner_args[@]}" ) done diff --git a/test/goroot/README.md b/test/goroot/README.md index d3568011ef..5993339dc1 100644 --- a/test/goroot/README.md +++ b/test/goroot/README.md @@ -33,5 +33,8 @@ Useful flags: - `-dirs`: comma-separated `GOROOT/test` subdirectories to scan - `-case`: regexp filter on the relative case path - `-limit`: stop after N matching cases +- `-shard-index`: 0-based shard index used to partition matching cases +- `-shard-total`: total number of shards used to partition matching cases - `-keepwork`: keep the temporary symlink work tree for debugging +- `-run-timeout`: timeout for each child `go`/`llgo` process; `0` disables the timeout - `-xfail`: xfail YAML file, relative to repo root by default diff --git a/test/goroot/runner_test.go b/test/goroot/runner_test.go index 17bfb47270..065a29c455 100644 --- a/test/goroot/runner_test.go +++ b/test/goroot/runner_test.go @@ -111,8 +111,12 @@ func TestGoRootRunCases(t *testing.T) { envInfo := loadToolchainEnv(t, goCmd) testRoot := filepath.Join(goroot, "test") - if info, err := os.Stat(testRoot); err != nil || !info.IsDir() { - t.Fatalf("invalid GOROOT/test root %q: %v", testRoot, err) + info, err := os.Stat(testRoot) + if err != nil { + t.Fatalf("stat GOROOT/test root %q: %v", testRoot, err) + } + if !info.IsDir() { + t.Fatalf("GOROOT/test root %q is not a directory", testRoot) } llgoBin := *flagLLGO @@ -173,15 +177,16 @@ func loadToolchainEnv(t *testing.T, goCmd string) toolchainEnv { t.Helper() cmd := exec.Command(goCmd, "env", "-json", "GOOS", "GOARCH", "GOVERSION", "CGO_ENABLED") cmd.Env = append(os.Environ(), "GOENV=off", "GOFLAGS=") - var out bytes.Buffer - cmd.Stdout = &out - cmd.Stderr = &out + var stdout bytes.Buffer + var stderr bytes.Buffer + cmd.Stdout = &stdout + cmd.Stderr = &stderr if err := cmd.Run(); err != nil { - t.Fatalf("%s env failed: %v\n%s", goCmd, err, out.Bytes()) + t.Fatalf("%s env failed: %v\nstdout:\n%s\nstderr:\n%s", goCmd, err, stdout.Bytes(), stderr.Bytes()) } var info toolchainEnv - if err := json.Unmarshal(out.Bytes(), &info); err != nil { - t.Fatalf("decode %s env output: %v", goCmd, err) + if err := json.Unmarshal(stdout.Bytes(), &info); err != nil { + t.Fatalf("decode %s env output: %v\nstdout:\n%s\nstderr:\n%s", goCmd, err, stdout.Bytes(), stderr.Bytes()) } info.ReleaseTags = releaseTagsFor(info.GOVERSION) return info @@ -647,7 +652,7 @@ func (entry timeoutEntry) matches(goVersion, platform string, tc testCase) bool } func matchEntry(version, platform, directive, casePattern, goVersion, goPlatform string, tc testCase) bool { - if version != "" && !strings.HasPrefix(goVersion, version) { + if version != "" && !matchGoVersion(version, goVersion) { return false } if platform != "" && platform != goPlatform { @@ -662,3 +667,14 @@ func matchEntry(version, platform, directive, casePattern, goVersion, goPlatform ok, err := path.Match(casePattern, tc.RelPath) return err == nil && ok } + +func matchGoVersion(version, goVersion string) bool { + if goVersion == version { + return true + } + suffix, ok := strings.CutPrefix(goVersion, version) + if !ok { + return false + } + return strings.HasPrefix(suffix, ".") || strings.HasPrefix(suffix, "rc") || strings.HasPrefix(suffix, "beta") +} diff --git a/test/goroot/runner_unit_test.go b/test/goroot/runner_unit_test.go index 15830c093c..947c62bf3c 100644 --- a/test/goroot/runner_unit_test.go +++ b/test/goroot/runner_unit_test.go @@ -77,6 +77,26 @@ func TestXFailMatch(t *testing.T) { } } +func TestMatchGoVersion(t *testing.T) { + tests := []struct { + version string + goVersion string + want bool + }{ + {version: "go1.24", goVersion: "go1.24", want: true}, + {version: "go1.24", goVersion: "go1.24.11", want: true}, + {version: "go1.24", goVersion: "go1.24rc1", want: true}, + {version: "go1.24", goVersion: "go1.24beta1", want: true}, + {version: "go1.2", goVersion: "go1.24.11", want: false}, + {version: "go1.25", goVersion: "go1.24.11", want: false}, + } + for _, tt := range tests { + if got := matchGoVersion(tt.version, tt.goVersion); got != tt.want { + t.Fatalf("matchGoVersion(%q, %q)=%v, want %v", tt.version, tt.goVersion, got, tt.want) + } + } +} + func TestHostSkipMatch(t *testing.T) { cfg := xfailConfig{ HostSkips: []xfailEntry{{ From ab5a05319cd255997df61a81f0c7e55faecab9a3 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Thu, 26 Mar 2026 17:43:53 +0800 Subject: [PATCH 38/44] test: tolerate missing goroot test dirs --- test/goroot/runner_test.go | 4 ++++ test/goroot/runner_unit_test.go | 29 +++++++++++++++++++++++++++++ 2 files changed, 33 insertions(+) diff --git a/test/goroot/runner_test.go b/test/goroot/runner_test.go index 065a29c455..0501a5123e 100644 --- a/test/goroot/runner_test.go +++ b/test/goroot/runner_test.go @@ -269,6 +269,10 @@ func discoverCases(t *testing.T, testRoot string, envInfo toolchainEnv, dirs []s absDir := filepath.Join(testRoot, filepath.FromSlash(relDir)) entries, err := os.ReadDir(absDir) if err != nil { + if errors.Is(err, os.ErrNotExist) { + t.Logf("skipping missing GOROOT/test dir %s", absDir) + continue + } t.Fatalf("read %s: %v", absDir, err) } for _, entry := range entries { diff --git a/test/goroot/runner_unit_test.go b/test/goroot/runner_unit_test.go index 947c62bf3c..8bc72c1b55 100644 --- a/test/goroot/runner_unit_test.go +++ b/test/goroot/runner_unit_test.go @@ -4,6 +4,7 @@ import ( "os" "path/filepath" "reflect" + "runtime" "strings" "testing" "time" @@ -197,3 +198,31 @@ func TestShardCases(t *testing.T) { t.Fatalf("shardCases()=%v, want %v", got, want) } } + +func TestDiscoverCasesSkipsMissingDir(t *testing.T) { + testRoot := t.TempDir() + existingDir := filepath.Join(testRoot, "fixedbugs") + if err := os.MkdirAll(existingDir, 0o755); err != nil { + t.Fatal(err) + } + file := filepath.Join(existingDir, "case.go") + if err := os.WriteFile(file, []byte("// run\n\npackage main\n"), 0o644); err != nil { + t.Fatal(err) + } + + got := discoverCases(t, testRoot, toolchainEnv{ + GOOS: runtime.GOOS, + GOARCH: runtime.GOARCH, + CGOEnabled: "1", + }, []string{"fixedbugs", "internal/runtime/sys"}, nil, 0) + want := []testCase{{ + RelPath: "fixedbugs/case.go", + Dir: existingDir, + FileName: "case.go", + Directive: "run", + DirectiveArg: []string{}, + }} + if !reflect.DeepEqual(got, want) { + t.Fatalf("discoverCases()=%v, want %v", got, want) + } +} From 0cb9a52d76a00e99947a9cf41608b6ca7d8eb877 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Thu, 26 Mar 2026 17:49:06 +0800 Subject: [PATCH 39/44] ci: expand goroot matrix across go versions --- .github/workflows/goroot.yml | 156 +++++++++++++++++++++++++++++++++-- 1 file changed, 147 insertions(+), 9 deletions(-) diff --git a/.github/workflows/goroot.yml b/.github/workflows/goroot.yml index a374ac16ef..ef83c46717 100644 --- a/.github/workflows/goroot.yml +++ b/.github/workflows/goroot.yml @@ -15,15 +15,153 @@ concurrency: jobs: goroot: + name: GOROOT (${{ matrix.os }}, Go ${{ matrix.go-version }}, shard ${{ matrix.shard-label }}) + continue-on-error: ${{ matrix.required != 'true' }} timeout-minutes: 90 strategy: fail-fast: false matrix: - os: - - macos-latest - - ubuntu-latest - llvm: [19] - shard: ["0", "1"] + include: + - os: macos-latest + llvm: 19 + go-version: "1.21.13" + shard-index: "0" + shard-total: "1" + shard-label: "all" + required: "false" + - os: ubuntu-latest + llvm: 19 + go-version: "1.21.13" + shard-index: "0" + shard-total: "1" + shard-label: "all" + required: "false" + - os: macos-latest + llvm: 19 + go-version: "1.22.12" + shard-index: "0" + shard-total: "1" + shard-label: "all" + required: "false" + - os: ubuntu-latest + llvm: 19 + go-version: "1.22.12" + shard-index: "0" + shard-total: "1" + shard-label: "all" + required: "false" + - os: macos-latest + llvm: 19 + go-version: "1.23.12" + shard-index: "0" + shard-total: "2" + shard-label: "0/2" + required: "false" + - os: macos-latest + llvm: 19 + go-version: "1.23.12" + shard-index: "1" + shard-total: "2" + shard-label: "1/2" + required: "false" + - os: ubuntu-latest + llvm: 19 + go-version: "1.23.12" + shard-index: "0" + shard-total: "2" + shard-label: "0/2" + required: "false" + - os: ubuntu-latest + llvm: 19 + go-version: "1.23.12" + shard-index: "1" + shard-total: "2" + shard-label: "1/2" + required: "false" + - os: macos-latest + llvm: 19 + go-version: "1.24.11" + shard-index: "0" + shard-total: "2" + shard-label: "0/2" + required: "false" + - os: macos-latest + llvm: 19 + go-version: "1.24.11" + shard-index: "1" + shard-total: "2" + shard-label: "1/2" + required: "false" + - os: ubuntu-latest + llvm: 19 + go-version: "1.24.11" + shard-index: "0" + shard-total: "2" + shard-label: "0/2" + required: "false" + - os: ubuntu-latest + llvm: 19 + go-version: "1.24.11" + shard-index: "1" + shard-total: "2" + shard-label: "1/2" + required: "false" + - os: macos-latest + llvm: 19 + go-version: "1.25.0" + shard-index: "0" + shard-total: "2" + shard-label: "0/2" + required: "true" + - os: macos-latest + llvm: 19 + go-version: "1.25.0" + shard-index: "1" + shard-total: "2" + shard-label: "1/2" + required: "true" + - os: ubuntu-latest + llvm: 19 + go-version: "1.25.0" + shard-index: "0" + shard-total: "2" + shard-label: "0/2" + required: "true" + - os: ubuntu-latest + llvm: 19 + go-version: "1.25.0" + shard-index: "1" + shard-total: "2" + shard-label: "1/2" + required: "true" + - os: macos-latest + llvm: 19 + go-version: "1.26.0" + shard-index: "0" + shard-total: "2" + shard-label: "0/2" + required: "false" + - os: macos-latest + llvm: 19 + go-version: "1.26.0" + shard-index: "1" + shard-total: "2" + shard-label: "1/2" + required: "false" + - os: ubuntu-latest + llvm: 19 + go-version: "1.26.0" + shard-index: "0" + shard-total: "2" + shard-label: "0/2" + required: "false" + - os: ubuntu-latest + llvm: 19 + go-version: "1.26.0" + shard-index: "1" + shard-total: "2" + shard-label: "1/2" + required: "false" runs-on: ${{ matrix.os }} steps: - uses: actions/checkout@v6 @@ -36,15 +174,15 @@ jobs: - name: Set up Go uses: ./.github/actions/setup-go with: - go-version: "1.25.0" + go-version: ${{ matrix.go-version }} - name: Show toolchain versions run: | go version clang --version - - name: Run GOROOT runner shard + - name: Run GOROOT runner run: | bash dev/test_goroot.sh -- \ - -shard-index "${{ matrix.shard }}" \ - -shard-total 2 + -shard-index "${{ matrix.shard-index }}" \ + -shard-total "${{ matrix.shard-total }}" From 4ab39959cca85b733e85ce625026116609c97634 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Thu, 26 Mar 2026 18:10:07 +0800 Subject: [PATCH 40/44] ci: drop unsupported low go versions from goroot matrix --- .github/workflows/goroot.yml | 28 ---------------------------- 1 file changed, 28 deletions(-) diff --git a/.github/workflows/goroot.yml b/.github/workflows/goroot.yml index ef83c46717..78664447df 100644 --- a/.github/workflows/goroot.yml +++ b/.github/workflows/goroot.yml @@ -22,34 +22,6 @@ jobs: fail-fast: false matrix: include: - - os: macos-latest - llvm: 19 - go-version: "1.21.13" - shard-index: "0" - shard-total: "1" - shard-label: "all" - required: "false" - - os: ubuntu-latest - llvm: 19 - go-version: "1.21.13" - shard-index: "0" - shard-total: "1" - shard-label: "all" - required: "false" - - os: macos-latest - llvm: 19 - go-version: "1.22.12" - shard-index: "0" - shard-total: "1" - shard-label: "all" - required: "false" - - os: ubuntu-latest - llvm: 19 - go-version: "1.22.12" - shard-index: "0" - shard-total: "1" - shard-label: "all" - required: "false" - os: macos-latest llvm: 19 go-version: "1.23.12" From d774ece7e7fea00447185605081834f1cca534f8 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Thu, 26 Mar 2026 18:13:11 +0800 Subject: [PATCH 41/44] ci: drop go1.23 from goroot matrix --- .github/workflows/goroot.yml | 28 ---------------------------- 1 file changed, 28 deletions(-) diff --git a/.github/workflows/goroot.yml b/.github/workflows/goroot.yml index 78664447df..41fd756df2 100644 --- a/.github/workflows/goroot.yml +++ b/.github/workflows/goroot.yml @@ -22,34 +22,6 @@ jobs: fail-fast: false matrix: include: - - os: macos-latest - llvm: 19 - go-version: "1.23.12" - shard-index: "0" - shard-total: "2" - shard-label: "0/2" - required: "false" - - os: macos-latest - llvm: 19 - go-version: "1.23.12" - shard-index: "1" - shard-total: "2" - shard-label: "1/2" - required: "false" - - os: ubuntu-latest - llvm: 19 - go-version: "1.23.12" - shard-index: "0" - shard-total: "2" - shard-label: "0/2" - required: "false" - - os: ubuntu-latest - llvm: 19 - go-version: "1.23.12" - shard-index: "1" - shard-total: "2" - shard-label: "1/2" - required: "false" - os: macos-latest llvm: 19 go-version: "1.24.11" From e434045bda66b5c700d1bf33ee58c5a28aa62328 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Thu, 26 Mar 2026 19:12:58 +0800 Subject: [PATCH 42/44] test: record go1.24 and go1.26 goroot xfails --- test/goroot/xfail.yaml | 4681 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 4681 insertions(+) diff --git a/test/goroot/xfail.yaml b/test/goroot/xfail.yaml index 7cf3038cac..b4a9329c30 100644 --- a/test/goroot/xfail.yaml +++ b/test/goroot/xfail.yaml @@ -1467,3 +1467,4684 @@ xfails: directive: run case: zerosize.go reason: go1.25 goroot run failure on linux/amd64 + + - version: go1.24 + platform: darwin/arm64 + directive: run + case: chan/goroutines.go + reason: go1.24 goroot run failure on darwin/arm64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: blank.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: deferfin.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: deferprint.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: divmod.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: finprofiled.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: heapsampling.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: init1.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: nil.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: nilptr2.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: print.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: range.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: recover.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: recover2.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: reflectmethod2.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: reflectmethod6.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: switch.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: zerosize.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: ken/chan.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: ken/cplx0.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: interface/fake.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/bug273.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/bug347.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue10332.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue14646.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue15039.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue15175.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue15277.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue17381.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue19040.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue22083.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue22662.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue22881.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue24491b.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue29504.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue30116.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue31546.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue32187.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue32477.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue35576.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue37975.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue43835.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue43942.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue4585.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue46725.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue52788.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue54343.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue5704.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue57823.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue58300.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue5856.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue59411.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue5963.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue65417.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue71675.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue8048.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: typeparam/chans.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: typeparam/issue48645a.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: typeparam/issue51521.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: typeparam/nested.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: typeparam/orderedmap.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: typeparam/typeswitch5.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: typeparam/mdempsky/16.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: append.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: chancap.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: closedchan.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: convert4.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: divide.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: goprint.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: inline_literal.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: mallocfin.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: method.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: method5.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: nilptr.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: noinit.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: peano.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: recover1.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: recover3.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: reflectmethod1.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: reflectmethod3.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: reflectmethod5.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: slicecap.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: stackobj.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: stackobj3.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: tinyfin.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: unsafebuiltins.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: zerodivide.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: chan/select3.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: interface/noeq.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/bug336.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/bug348.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/bug409.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue12133.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue13169.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue15002.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue15281.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue16037_run.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue16130.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue18149.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue19246.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue21879.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue23017.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue23837.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue25897a.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue26094.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue26335.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue27201.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue27518b.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue28748.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue29190.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue29735.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue30116u.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue33724.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue38496.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue4316.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue44830.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue45045.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue4562.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue48898.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue52788a.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue53137.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue53635.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue5493.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue58300b.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue60601.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue63657.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue6899.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue7550.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue7690.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue8132.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: fixedbugs/issue8606b.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: typeparam/issue49547.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: typeparam/typeswitch6.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.24 + platform: linux/amd64 + directive: run + case: typeparam/mdempsky/17.go + reason: go1.24 goroot run failure on linux/amd64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: armimm.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: const.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: convert.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: copy.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: divide.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: env.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: linkmain_run.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: linkx_run.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: literal2.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: mapclear.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: reflectmethod4.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: rename.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: sigchld.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: stackobj2.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: strcopy.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: stringrange.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeswitch1.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: unsafe_slice_data.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: unsafe_string_data.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: winbatch.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: ken/cplx4.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: ken/divconst.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: ken/modconst.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: chan/fifo.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: chan/nonblock.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: chan/powser2.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: interface/embed.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: interface/struct.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug027.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug059.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug141.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug147.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug154.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug184.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug187.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug207.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug260.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug271.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug369.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug402.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug461.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug483.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/gcc65755.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue11256.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue11771.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue11987.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue13160.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue13268.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue14553.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue14636.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue14651.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue15329.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue15528.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue15992.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue16331.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue17640.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue18661.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue19182.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue19359.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue19911.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue21317.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue21963.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue22660.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue22662b.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue22781.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue23812.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue24817.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue25322.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue26411.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue27695b.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue30041.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue30566b.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue30606b.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue30956.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue33275_run.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue36437.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue40629.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue41239.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue43619.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue43908.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue45851.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue4620.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue4667.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue48357.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue48476.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue49665.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue51733.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue54542.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue56990.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue57184.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue59680.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue62360.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue70156.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue7044.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue7050.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue72063.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue73748a.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue73916.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue73917.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue7419.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue74379b.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue74935.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue76008.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue7863.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue7995.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue9110.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue9355.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue9862_run.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: abi/convT64_criteria.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: abi/double_nested_struct.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: abi/fibish.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: abi/leaf.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: abi/many_int_input.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: abi/named_return_stuff.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: abi/return_stuff.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: abi/spills3.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: abi/struct_lower_1.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: abi/uglyfib.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/absdiff2.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/adder.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/boundmethod.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/combine.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/dictionaryCapture.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/double.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/genembed.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/graph.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/index.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/issue45817.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/issue47272.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/issue47713.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/issue47740b.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/issue48013.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/issue48253.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/issue48318.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/issue50002.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/issue50642.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/issue50690b.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/issue51303.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/issue54456.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/list.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/maps.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/min.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/ordered.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/pair.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/settable.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/slices.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/stringable.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/struct.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/sum.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/typeswitch2.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/value.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: char_lit.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: cmp.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: const3.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: const7.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: defer.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: devirtualization_nil_panics.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: float_lit2.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: gc2.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: gcstring.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: initialize.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: int_lit.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: linkobj.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: map.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: maplinear.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: newexpr.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: nosplit.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: range4.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: reflectmethod7.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: reorder.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: shift3.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: string_lit.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeswitch.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: uintptrescapes3.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: ken/cplx3.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: ken/rob2.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: chan/goroutines.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: chan/powser1.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug006.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug060.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug070.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug120.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug130.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug159.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug177.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug206.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug237.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug257.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug259.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug265.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug295.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug321.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug346.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug364.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug444.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/bug470.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue10925.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue11945.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue12226.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue13162.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue13171.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue14591.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue14725.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue15303.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue15439.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue16016.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue16095.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue16870.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue18636.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue18725.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue19113.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue19201.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue19275.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue19658.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue19799.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue21576.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue21808.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue22605.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue22683.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue24547.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue24799.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue27695c.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue27829.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue28390.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue28797.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue29264.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue29312.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue30243.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue30566a.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue30606.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue31987.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue33555.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue34123.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue37716.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue42076.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue43570.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue44823.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue45242.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue4618.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue48289.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue48473.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue49110.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue52127.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue5373.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue54467.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue5809.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue62203.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue66066.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue68227.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue6902.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue70189.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue7083.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue72844.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue73748b.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue73916b.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue73920.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue74379.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue74379c.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue75327.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue76709.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue7740.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue8004.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue8139.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue8158.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue8606.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: fixedbugs/issue9321.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: abi/convF_criteria.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: abi/double_nested_addressed_struct.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: abi/f_ret_z_not.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: abi/fibish_closure.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: abi/idata.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: abi/leaf2.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: abi/many_intstar_input.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: abi/named_results.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: abi/s_sif_sif.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: abi/spills4.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: abi/struct_3_string_input.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: abi/too_big_to_ssa.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/absdiff3.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/cons.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/fact.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/genembed2.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/ifaceconv.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/index2.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/issue45722.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/issue47258.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/issue47716.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/issue47740.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/issue48016.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/issue48042.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/issue48225.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/issue48276a.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/issue48317.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/issue50109.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/issue50193.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/issue50419.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/issue50690a.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/issue50690c.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/issue53087.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/list2.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/map.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/metrics.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/sets.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/smallest.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/stringer.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/subdict.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: darwin/arm64 + directive: run + case: typeparam/mdempsky/18.go + reason: go1.26 goroot run failure on darwin/arm64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: armimm.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: blank.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: chanlinear.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: closure.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: const.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: convert.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: copy.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: deferfin.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: deferprint.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: divide.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: env.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: gcgort.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: goprint.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: inline_literal.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: linkmain_run.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: linkx_run.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: literal2.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: mallocfin.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: mapclear.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: method.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: method5.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: nil.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: nilptr2.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: nosplit.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: print.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: range.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: range4.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: recover1.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: recover3.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: reflectmethod1.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: reflectmethod3.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: reflectmethod5.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: reflectmethod7.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: reorder.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: shift3.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: slicecap.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: stackobj.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: stackobj3.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: string_lit.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: tinyfin.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeswitch.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: uintptrescapes3.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: unsafebuiltins.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: zerodivide.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: ken/chan1.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: ken/cplx3.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: ken/rob2.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: chan/doubleselect.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: chan/goroutines.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: chan/powser1.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: chan/select3.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: interface/noeq.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug006.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug060.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug070.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug120.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug130.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug159.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug177.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug206.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug237.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug243.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug257.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug259.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug265.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug295.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug303.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug321.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug331.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug336.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug346.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug348.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug364.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug370.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug409.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug444.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug470.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug474.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug484.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug514.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue10607.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue11256.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue11771.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue11987.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue12133.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue13160.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue13169.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue13268.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue14553.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue14636.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue14651.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue15002.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue15281.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue15329.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue15528.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue15992.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue16037_run.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue16130.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue16331.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue17640.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue18149.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue18661.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue19182.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue19246.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue19359.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue19911.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue21317.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue21879.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue21963.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue22660.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue22662b.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue22781.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue23017.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue23812.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue23837.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue24491a.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue24817.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue25322.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue25897a.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue26094.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue26335.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue26411.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue27201.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue27518b.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue27695b.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue28748.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue29190.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue29304.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue29735.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue30041.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue30116u.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue30476.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue30566b.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue30606b.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue30956.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue33275_run.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue33724.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue36437.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue38496.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue39541.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue40629.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue4085b.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue41239.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue42032.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue4316.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue43619.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue43908.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue44830.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue45045.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue4562.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue45851.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue4620.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue4667.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue46903.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue48357.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue48476.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue48898.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue49665.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue51733.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue52788a.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue53137.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue53635.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue54220.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue54542.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue5493.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue56990.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue57184.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue58300b.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue59680.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue60601.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue62360.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue63657.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue6899.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue69434.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue70156.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue7044.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue7050.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue71675.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue72063.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue73748a.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue73916.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue73917.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue7419.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue74379b.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue74935.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue7550.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue76008.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue7690.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue7863.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue7995.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue8132.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue8155.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue8606b.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue9110.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue9355.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue9862_run.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: abi/convT64_criteria.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: abi/double_nested_struct.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: abi/fibish.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: abi/leaf.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: abi/many_int_input.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: abi/map.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: abi/named_return_stuff.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: abi/part_live.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: abi/return_stuff.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: abi/spills3.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: abi/struct_lower_1.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: abi/uglyfib.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/absdiff2.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/adder.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/boundmethod.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/combine.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/dictionaryCapture.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/double.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/genembed.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/graph.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/index.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/issue45817.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/issue47272.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/issue47713.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/issue47740b.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/issue48013.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/issue48253.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/issue48318.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/issue49547.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/issue50002.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/issue50642.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/issue50690b.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/issue51303.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/issue54456.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/list.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/lockable.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/maps.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/min.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/ordered.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/pair.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/settable.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/slices.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/stringable.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/struct.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/sum.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/typeswitch2.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/typeswitch6.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/value.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/mdempsky/17.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: append.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: chancap.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: char_lit.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: closedchan.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: cmp.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: const3.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: const7.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: convert4.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: defer.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: devirtualization_nil_panics.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: divmod.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: finprofiled.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: float_lit2.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: gc.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: gc2.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: gcstring.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: heapsampling.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: init1.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: initialize.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: int_lit.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: linkobj.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: makeslice.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: map.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: maplinear.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: newexpr.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: nilptr.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: noinit.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: peano.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: recover.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: recover2.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: recover4.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: reflectmethod2.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: reflectmethod4.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: reflectmethod6.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: rename.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: sigchld.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: stackobj2.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: strcopy.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: stringrange.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: switch.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeswitch1.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: unsafe_slice_data.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: unsafe_string_data.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: winbatch.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: zerosize.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: ken/chan.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: ken/cplx0.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: ken/cplx4.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: ken/divconst.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: ken/modconst.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: chan/fifo.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: chan/nonblock.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: chan/powser2.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: chan/select2.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: chan/select7.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: chan/sieve2.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: interface/embed.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: interface/fake.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: interface/struct.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug027.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug059.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug141.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug147.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug154.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug184.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug187.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug207.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug260.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug262.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug271.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug273.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug347.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug369.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug402.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug461.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug483.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug500.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/bug512.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/gcc65755.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue10332.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue10486.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue10925.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue11286.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue11945.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue12226.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue13162.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue13171.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue14591.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue14646.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue14725.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue15039.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue15175.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue15277.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue15303.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue15439.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue16016.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue16095.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue16249.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue16515.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue16870.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue17381.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue18636.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue18725.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue19040.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue19113.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue19201.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue19275.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue19658.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue19799.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue20029.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue21576.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue21808.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue21887.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue22083.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue22605.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue22662.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue22683.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue22881.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue24419.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue24488.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue24491b.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue24547.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue24799.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue25897b.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue27518a.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue27695.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue27695c.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue27829.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue28390.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue28797.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue29264.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue29312.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue29504.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue30116.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue30243.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue30566a.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue30606.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue30977.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue31546.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue31987.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue32187.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue32477.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue33555.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue34123.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue35576.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue37716.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue37975.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue40954.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue42076.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue43570.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue43835.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue43942.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue44823.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue45242.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue4585.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue4618.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue46725.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue48289.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue48473.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue49110.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue51401.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue52127.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue52788.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue5373.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue54343.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue54467.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue5704.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue57823.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue5809.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue58300.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue5856.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue59411.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue5963.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue6055.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue62203.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue65417.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue66066.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue68227.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue6902.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue70189.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue7083.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue71932.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue72844.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue73748b.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue73916b.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue73920.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue74379.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue74379c.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue75327.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue76709.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue7740.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue7944.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue8004.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue8036.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue8048.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue8139.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue8158.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue8606.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: fixedbugs/issue9321.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: abi/convF_criteria.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: abi/double_nested_addressed_struct.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: abi/f_ret_z_not.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: abi/fibish_closure.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: abi/idata.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: abi/leaf2.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: abi/many_intstar_input.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: abi/named_results.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: abi/part_live_2.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: abi/s_sif_sif.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: abi/spills4.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: abi/struct_3_string_input.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: abi/too_big_to_ssa.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/absdiff3.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/chans.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/cons.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/fact.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/genembed2.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/ifaceconv.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/index2.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/issue45722.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/issue47258.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/issue47716.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/issue47740.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/issue48016.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/issue48042.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/issue48225.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/issue48276a.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/issue48317.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/issue48645a.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/issue49295.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/issue50109.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/issue50193.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/issue50419.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/issue50690a.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/issue50690c.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/issue51521.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/issue53087.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/issue58513.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/list2.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/map.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/metrics.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/nested.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/orderedmap.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/sets.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/smallest.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/stringer.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/subdict.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/typeswitch5.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/mdempsky/16.go + reason: go1.26 goroot run failure on linux/amd64 + - version: go1.26 + platform: linux/amd64 + directive: run + case: typeparam/mdempsky/18.go + reason: go1.26 goroot run failure on linux/amd64 From 0e375b3aa3f5a85e7848a8383b5165ca9f935b9e Mon Sep 17 00:00:00 2001 From: Li Jie Date: Tue, 31 Mar 2026 11:02:48 +0800 Subject: [PATCH 43/44] goroot: drop stale linux xfails for go1.25 and go1.26 --- test/goroot/xfail.yaml | 2114 +++------------------------------------- 1 file changed, 137 insertions(+), 1977 deletions(-) diff --git a/test/goroot/xfail.yaml b/test/goroot/xfail.yaml index b4a9329c30..d753658dbc 100644 --- a/test/goroot/xfail.yaml +++ b/test/goroot/xfail.yaml @@ -792,11 +792,6 @@ xfails: directive: run case: fixedbugs/bug409.go reason: go1.25 goroot run failure on linux/amd64 - - version: go1.25 - platform: linux/amd64 - directive: run - case: fixedbugs/bug512.go - reason: go1.25 goroot run failure on linux/amd64 - version: go1.25 platform: linux/amd64 directive: run @@ -852,11 +847,6 @@ xfails: directive: run case: fixedbugs/issue16130.go reason: go1.25 goroot run failure on linux/amd64 - - version: go1.25 - platform: linux/amd64 - directive: run - case: fixedbugs/issue16331.go - reason: go1.25 goroot run failure on linux/amd64 - version: go1.25 platform: linux/amd64 directive: run @@ -887,11 +877,6 @@ xfails: directive: run case: fixedbugs/issue22083.go reason: go1.25 goroot run failure on linux/amd64 - - version: go1.25 - platform: linux/amd64 - directive: run - case: fixedbugs/issue22605.go - reason: go1.25 goroot run failure on linux/amd64 - version: go1.25 platform: linux/amd64 directive: run @@ -922,11 +907,6 @@ xfails: directive: run case: fixedbugs/issue25897a.go reason: go1.25 goroot run failure on linux/amd64 - - version: go1.25 - platform: linux/amd64 - directive: run - case: fixedbugs/issue25897b.go - reason: go1.25 goroot run failure on linux/amd64 - version: go1.25 platform: linux/amd64 directive: run @@ -947,21 +927,6 @@ xfails: directive: run case: fixedbugs/issue27518b.go reason: go1.25 goroot run failure on linux/amd64 - - version: go1.25 - platform: linux/amd64 - directive: run - case: fixedbugs/issue27695.go - reason: go1.25 goroot run failure on linux/amd64 - - version: go1.25 - platform: linux/amd64 - directive: run - case: fixedbugs/issue27695b.go - reason: go1.25 goroot run failure on linux/amd64 - - version: go1.25 - platform: linux/amd64 - directive: run - case: fixedbugs/issue27695c.go - reason: go1.25 goroot run failure on linux/amd64 - version: go1.25 platform: linux/amd64 directive: run @@ -992,16 +957,6 @@ xfails: directive: run case: fixedbugs/issue30116u.go reason: go1.25 goroot run failure on linux/amd64 - - version: go1.25 - platform: linux/amd64 - directive: run - case: fixedbugs/issue30606.go - reason: go1.25 goroot run failure on linux/amd64 - - version: go1.25 - platform: linux/amd64 - directive: run - case: fixedbugs/issue30606b.go - reason: go1.25 goroot run failure on linux/amd64 - version: go1.25 platform: linux/amd64 directive: run @@ -1027,11 +982,6 @@ xfails: directive: run case: fixedbugs/issue35576.go reason: go1.25 goroot run failure on linux/amd64 - - version: go1.25 - platform: linux/amd64 - directive: run - case: fixedbugs/issue37716.go - reason: go1.25 goroot run failure on linux/amd64 - version: go1.25 platform: linux/amd64 directive: run @@ -1087,11 +1037,6 @@ xfails: directive: run case: fixedbugs/issue48898.go reason: go1.25 goroot run failure on linux/amd64 - - version: go1.25 - platform: linux/amd64 - directive: run - case: fixedbugs/issue49110.go - reason: go1.25 goroot run failure on linux/amd64 - version: go1.25 platform: linux/amd64 directive: run @@ -1157,11 +1102,6 @@ xfails: directive: run case: fixedbugs/issue5963.go reason: go1.25 goroot run failure on linux/amd64 - - version: go1.25 - platform: linux/amd64 - directive: run - case: fixedbugs/issue59680.go - reason: go1.25 goroot run failure on linux/amd64 - version: go1.25 platform: linux/amd64 directive: run @@ -1217,16 +1157,6 @@ xfails: directive: run case: fixedbugs/issue8606b.go reason: go1.25 goroot run failure on linux/amd64 - - version: go1.25 - platform: linux/amd64 - directive: run - case: fixedbugs/issue9321.go - reason: go1.25 goroot run failure on linux/amd64 - - version: go1.25 - platform: linux/amd64 - directive: run - case: gcgort.go - reason: go1.25 goroot run failure on linux/amd64 - version: go1.25 platform: linux/amd64 directive: run @@ -1352,11 +1282,6 @@ xfails: directive: run case: reflectmethod3.go reason: go1.25 goroot run failure on linux/amd64 - - version: go1.25 - platform: linux/amd64 - directive: run - case: reflectmethod4.go - reason: go1.25 goroot run failure on linux/amd64 - version: go1.25 platform: linux/amd64 directive: run @@ -1367,11 +1292,6 @@ xfails: directive: run case: reflectmethod6.go reason: go1.25 goroot run failure on linux/amd64 - - version: go1.25 - platform: linux/amd64 - directive: run - case: reflectmethod7.go - reason: go1.25 goroot run failure on linux/amd64 - version: go1.25 platform: linux/amd64 directive: run @@ -1402,11 +1322,6 @@ xfails: directive: run case: typeparam/chans.go reason: go1.25 goroot run failure on linux/amd64 - - version: go1.25 - platform: linux/amd64 - directive: run - case: typeparam/issue48317.go - reason: go1.25 goroot run failure on linux/amd64 - version: go1.25 platform: linux/amd64 directive: run @@ -3676,2433 +3591,703 @@ xfails: - version: go1.26 platform: linux/amd64 directive: run - case: armimm.go + case: blank.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: blank.go + case: deferfin.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: chanlinear.go + case: deferprint.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: closure.go + case: divide.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: const.go + case: goprint.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: convert.go + case: inline_literal.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: copy.go + case: mallocfin.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: deferfin.go + case: method.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: deferprint.go + case: method5.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: divide.go + case: nil.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: env.go + case: nilptr2.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: gcgort.go + case: print.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: goprint.go + case: range.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: inline_literal.go + case: range4.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: linkmain_run.go + case: recover1.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: linkx_run.go + case: recover3.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: literal2.go + case: reflectmethod1.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: mallocfin.go + case: reflectmethod3.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: mapclear.go + case: reflectmethod5.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: method.go + case: slicecap.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: method5.go + case: stackobj.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: nil.go + case: stackobj3.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: nilptr2.go + case: tinyfin.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: nosplit.go + case: unsafebuiltins.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: print.go + case: zerodivide.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: range.go + case: chan/select3.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: range4.go + case: interface/noeq.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: recover1.go + case: fixedbugs/bug336.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: recover3.go + case: fixedbugs/bug348.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: reflectmethod1.go + case: fixedbugs/bug409.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: reflectmethod3.go + case: fixedbugs/issue12133.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: reflectmethod5.go + case: fixedbugs/issue13169.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: reflectmethod7.go + case: fixedbugs/issue15002.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: reorder.go + case: fixedbugs/issue15281.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: shift3.go + case: fixedbugs/issue16037_run.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: slicecap.go + case: fixedbugs/issue16130.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: stackobj.go + case: fixedbugs/issue18149.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: stackobj3.go + case: fixedbugs/issue19246.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: string_lit.go + case: fixedbugs/issue21879.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: tinyfin.go + case: fixedbugs/issue23017.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: typeswitch.go + case: fixedbugs/issue23837.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: uintptrescapes3.go + case: fixedbugs/issue25897a.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: unsafebuiltins.go + case: fixedbugs/issue26094.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: zerodivide.go + case: fixedbugs/issue26335.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: ken/chan1.go + case: fixedbugs/issue27201.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: ken/cplx3.go + case: fixedbugs/issue27518b.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: ken/rob2.go + case: fixedbugs/issue28748.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: chan/doubleselect.go + case: fixedbugs/issue29190.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: chan/goroutines.go + case: fixedbugs/issue29735.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: chan/powser1.go + case: fixedbugs/issue30116u.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: chan/select3.go + case: fixedbugs/issue33724.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: interface/noeq.go + case: fixedbugs/issue38496.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/bug006.go + case: fixedbugs/issue4316.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/bug060.go + case: fixedbugs/issue44830.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/bug070.go + case: fixedbugs/issue45045.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/bug120.go + case: fixedbugs/issue4562.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/bug130.go + case: fixedbugs/issue48898.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/bug159.go + case: fixedbugs/issue52788a.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/bug177.go + case: fixedbugs/issue53137.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/bug206.go + case: fixedbugs/issue53635.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/bug237.go + case: fixedbugs/issue5493.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/bug243.go + case: fixedbugs/issue58300b.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/bug257.go + case: fixedbugs/issue60601.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/bug259.go + case: fixedbugs/issue63657.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/bug265.go + case: fixedbugs/issue6899.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/bug295.go + case: fixedbugs/issue71675.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/bug303.go + case: fixedbugs/issue73916.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/bug321.go + case: fixedbugs/issue73917.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/bug331.go + case: fixedbugs/issue7550.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/bug336.go + case: fixedbugs/issue76008.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/bug346.go + case: fixedbugs/issue7690.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/bug348.go + case: fixedbugs/issue8132.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/bug364.go + case: fixedbugs/issue8606b.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/bug370.go + case: typeparam/issue49547.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/bug409.go + case: typeparam/typeswitch6.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/bug444.go + case: typeparam/mdempsky/17.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/bug470.go + case: append.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/bug474.go + case: chancap.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/bug484.go + case: closedchan.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/bug514.go + case: convert4.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue10607.go + case: devirtualization_nil_panics.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue11256.go + case: divmod.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue11771.go + case: finprofiled.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue11987.go + case: heapsampling.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue12133.go + case: init1.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue13160.go + case: newexpr.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue13169.go + case: nilptr.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue13268.go + case: noinit.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue14553.go + case: peano.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue14636.go + case: recover.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue14651.go + case: recover2.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue15002.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue15281.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue15329.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue15528.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue15992.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue16037_run.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue16130.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue16331.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue17640.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue18149.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue18661.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue19182.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue19246.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue19359.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue19911.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue21317.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue21879.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue21963.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue22660.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue22662b.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue22781.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue23017.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue23812.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue23837.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue24491a.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue24817.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue25322.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue25897a.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue26094.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue26335.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue26411.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue27201.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue27518b.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue27695b.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue28748.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue29190.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue29304.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue29735.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue30041.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue30116u.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue30476.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue30566b.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue30606b.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue30956.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue33275_run.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue33724.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue36437.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue38496.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue39541.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue40629.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue4085b.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue41239.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue42032.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue4316.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue43619.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue43908.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue44830.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue45045.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue4562.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue45851.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue4620.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue4667.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue46903.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue48357.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue48476.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue48898.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue49665.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue51733.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue52788a.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue53137.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue53635.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue54220.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue54542.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue5493.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue56990.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue57184.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue58300b.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue59680.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue60601.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue62360.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue63657.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue6899.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue69434.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue70156.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue7044.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue7050.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue71675.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue72063.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue73748a.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue73916.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue73917.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue7419.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue74379b.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue74935.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue7550.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue76008.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue7690.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue7863.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue7995.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue8132.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue8155.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue8606b.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue9110.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue9355.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue9862_run.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: abi/convT64_criteria.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: abi/double_nested_struct.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: abi/fibish.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: abi/leaf.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: abi/many_int_input.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: abi/map.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: abi/named_return_stuff.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: abi/part_live.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: abi/return_stuff.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: abi/spills3.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: abi/struct_lower_1.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: abi/uglyfib.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/absdiff2.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/adder.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/boundmethod.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/combine.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/dictionaryCapture.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/double.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/genembed.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/graph.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/index.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/issue45817.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/issue47272.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/issue47713.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/issue47740b.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/issue48013.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/issue48253.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/issue48318.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/issue49547.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/issue50002.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/issue50642.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/issue50690b.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/issue51303.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/issue54456.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/list.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/lockable.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/maps.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/min.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/ordered.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/pair.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/settable.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/slices.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/stringable.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/struct.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/sum.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/typeswitch2.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/typeswitch6.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/value.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/mdempsky/17.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: append.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: chancap.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: char_lit.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: closedchan.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: cmp.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: const3.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: const7.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: convert4.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: defer.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: devirtualization_nil_panics.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: divmod.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: finprofiled.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: float_lit2.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: gc.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: gc2.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: gcstring.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: heapsampling.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: init1.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: initialize.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: int_lit.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: linkobj.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: makeslice.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: map.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: maplinear.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: newexpr.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: nilptr.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: noinit.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: peano.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: recover.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: recover2.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: recover4.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: reflectmethod2.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: reflectmethod4.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: reflectmethod6.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: rename.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: sigchld.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: stackobj2.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: strcopy.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: stringrange.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: switch.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeswitch1.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: unsafe_slice_data.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: unsafe_string_data.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: winbatch.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: zerosize.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: ken/chan.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: ken/cplx0.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: ken/cplx4.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: ken/divconst.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: ken/modconst.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: chan/fifo.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: chan/nonblock.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: chan/powser2.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: chan/select2.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: chan/select7.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: chan/sieve2.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: interface/embed.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: interface/fake.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: interface/struct.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/bug027.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/bug059.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/bug141.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/bug147.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/bug154.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/bug184.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/bug187.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/bug207.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/bug260.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/bug262.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/bug271.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/bug273.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/bug347.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/bug369.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/bug402.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/bug461.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/bug483.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/bug500.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/bug512.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/gcc65755.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue10332.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue10486.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue10925.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue11286.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue11945.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue12226.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue13162.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue13171.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue14591.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue14646.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue14725.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue15039.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue15175.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue15277.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue15303.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue15439.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue16016.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue16095.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue16249.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue16515.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue16870.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue17381.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue18636.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue18725.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue19040.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue19113.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue19201.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue19275.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue19658.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue19799.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue20029.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue21576.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue21808.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue21887.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue22083.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue22605.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue22662.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue22683.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue22881.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue24419.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue24488.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue24491b.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue24547.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue24799.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue25897b.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue27518a.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue27695.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue27695c.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue27829.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue28390.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue28797.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue29264.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue29312.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue29504.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue30116.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue30243.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue30566a.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue30606.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue30977.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue31546.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue31987.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue32187.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue32477.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue33555.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue34123.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue35576.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue37716.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue37975.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue40954.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue42076.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue43570.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue43835.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue43942.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue44823.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue45242.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue4585.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue4618.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue46725.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue48289.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue48473.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue49110.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue51401.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue52127.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue52788.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue5373.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue54343.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue54467.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue5704.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: fixedbugs/issue57823.go + case: reflectmethod2.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue5809.go + case: reflectmethod6.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue58300.go + case: switch.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue5856.go + case: zerosize.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue59411.go + case: ken/chan.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue5963.go + case: ken/cplx0.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue6055.go + case: interface/fake.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue62203.go + case: fixedbugs/bug273.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue65417.go + case: fixedbugs/bug347.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue66066.go + case: fixedbugs/issue10332.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue68227.go + case: fixedbugs/issue14646.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue6902.go + case: fixedbugs/issue15039.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue70189.go + case: fixedbugs/issue15175.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue7083.go + case: fixedbugs/issue15277.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue71932.go + case: fixedbugs/issue17381.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue72844.go + case: fixedbugs/issue19040.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue73748b.go + case: fixedbugs/issue22083.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue73916b.go + case: fixedbugs/issue22662.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue73920.go + case: fixedbugs/issue22881.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue74379.go + case: fixedbugs/issue24491b.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue74379c.go + case: fixedbugs/issue29504.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue75327.go + case: fixedbugs/issue30116.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue76709.go + case: fixedbugs/issue31546.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue7740.go + case: fixedbugs/issue32187.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue7944.go + case: fixedbugs/issue32477.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue8004.go + case: fixedbugs/issue35576.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue8036.go + case: fixedbugs/issue37975.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue8048.go + case: fixedbugs/issue43835.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue8139.go + case: fixedbugs/issue43942.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue8158.go + case: fixedbugs/issue4585.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue8606.go + case: fixedbugs/issue46725.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: fixedbugs/issue9321.go + case: fixedbugs/issue52788.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: abi/convF_criteria.go + case: fixedbugs/issue54343.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: abi/double_nested_addressed_struct.go + case: fixedbugs/issue5704.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: abi/f_ret_z_not.go + case: fixedbugs/issue57823.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: abi/fibish_closure.go + case: fixedbugs/issue58300.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: abi/idata.go + case: fixedbugs/issue5856.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: abi/leaf2.go + case: fixedbugs/issue59411.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: abi/many_intstar_input.go + case: fixedbugs/issue5963.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: abi/named_results.go + case: fixedbugs/issue65417.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: abi/part_live_2.go + case: fixedbugs/issue70189.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: abi/s_sif_sif.go + case: fixedbugs/issue72844.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: abi/spills4.go + case: fixedbugs/issue73916b.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: abi/struct_3_string_input.go + case: fixedbugs/issue73920.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: abi/too_big_to_ssa.go + case: fixedbugs/issue75327.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run - case: typeparam/absdiff3.go + case: fixedbugs/issue8048.go reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run case: typeparam/chans.go reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/cons.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/fact.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/genembed2.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/ifaceconv.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/index2.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/issue45722.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/issue47258.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/issue47716.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/issue47740.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/issue48016.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/issue48042.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/issue48225.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/issue48276a.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/issue48317.go - reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run case: typeparam/issue48645a.go reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/issue49295.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/issue50109.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/issue50193.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/issue50419.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/issue50690a.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/issue50690c.go - reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run case: typeparam/issue51521.go reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/issue53087.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/issue58513.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/list2.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/map.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/metrics.go - reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run @@ -6113,26 +4298,6 @@ xfails: directive: run case: typeparam/orderedmap.go reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/sets.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/smallest.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/stringer.go - reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/subdict.go - reason: go1.26 goroot run failure on linux/amd64 - version: go1.26 platform: linux/amd64 directive: run @@ -6143,8 +4308,3 @@ xfails: directive: run case: typeparam/mdempsky/16.go reason: go1.26 goroot run failure on linux/amd64 - - version: go1.26 - platform: linux/amd64 - directive: run - case: typeparam/mdempsky/18.go - reason: go1.26 goroot run failure on linux/amd64 From 0187bbcde72e3add9b2e69d1b1ca7a424995e1c9 Mon Sep 17 00:00:00 2001 From: Li Jie Date: Tue, 31 Mar 2026 16:43:29 +0800 Subject: [PATCH 44/44] goroot: drop stale darwin xfails for go1.25 and go1.26 --- test/goroot/xfail.yaml | 1647 +--------------------------------------- 1 file changed, 11 insertions(+), 1636 deletions(-) diff --git a/test/goroot/xfail.yaml b/test/goroot/xfail.yaml index d753658dbc..80db998aa8 100644 --- a/test/goroot/xfail.yaml +++ b/test/goroot/xfail.yaml @@ -557,161 +557,11 @@ xfails: directive: run case: chan/goroutines.go reason: go1.25 goroot run failure on darwin/arm64 - - version: go1.25 - platform: darwin/arm64 - directive: run - case: const7.go - reason: go1.25 goroot run failure on darwin/arm64 - - version: go1.25 - platform: darwin/arm64 - directive: run - case: fixedbugs/bug206.go - reason: go1.25 goroot run failure on darwin/arm64 - - version: go1.25 - platform: darwin/arm64 - directive: run - case: fixedbugs/bug295.go - reason: go1.25 goroot run failure on darwin/arm64 - - version: go1.25 - platform: darwin/arm64 - directive: run - case: fixedbugs/bug369.go - reason: go1.25 goroot run failure on darwin/arm64 - - version: go1.25 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue11771.go - reason: go1.25 goroot run failure on darwin/arm64 - - version: go1.25 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue13268.go - reason: go1.25 goroot run failure on darwin/arm64 - - version: go1.25 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue14636.go - reason: go1.25 goroot run failure on darwin/arm64 - - version: go1.25 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue19658.go - reason: go1.25 goroot run failure on darwin/arm64 - - version: go1.25 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue21317.go - reason: go1.25 goroot run failure on darwin/arm64 - - version: go1.25 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue21576.go - reason: go1.25 goroot run failure on darwin/arm64 - - version: go1.25 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue22660.go - reason: go1.25 goroot run failure on darwin/arm64 - - version: go1.25 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue22662b.go - reason: go1.25 goroot run failure on darwin/arm64 - - version: go1.25 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue26411.go - reason: go1.25 goroot run failure on darwin/arm64 - - version: go1.25 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue33275_run.go - reason: go1.25 goroot run failure on darwin/arm64 - - version: go1.25 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue33555.go - reason: go1.25 goroot run failure on darwin/arm64 - - version: go1.25 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue36437.go - reason: go1.25 goroot run failure on darwin/arm64 - - version: go1.25 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue4618.go - reason: go1.25 goroot run failure on darwin/arm64 - - version: go1.25 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue4667.go - reason: go1.25 goroot run failure on darwin/arm64 - - version: go1.25 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue52127.go - reason: go1.25 goroot run failure on darwin/arm64 - - version: go1.25 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue54542.go - reason: go1.25 goroot run failure on darwin/arm64 - - version: go1.25 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue56990.go - reason: go1.25 goroot run failure on darwin/arm64 - version: go1.25 platform: darwin/arm64 directive: run case: fixedbugs/issue72844.go reason: go1.25 goroot run failure on darwin/arm64 - - version: go1.25 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue9355.go - reason: go1.25 goroot run failure on darwin/arm64 - - version: go1.25 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue9862_run.go - reason: go1.25 goroot run failure on darwin/arm64 - - version: go1.25 - platform: darwin/arm64 - directive: run - case: linkmain_run.go - reason: go1.25 goroot run failure on darwin/arm64 - - version: go1.25 - platform: darwin/arm64 - directive: run - case: linkobj.go - reason: go1.25 goroot run failure on darwin/arm64 - - version: go1.25 - platform: darwin/arm64 - directive: run - case: linkx_run.go - reason: go1.25 goroot run failure on darwin/arm64 - - version: go1.25 - platform: darwin/arm64 - directive: run - case: nosplit.go - reason: go1.25 goroot run failure on darwin/arm64 - - version: go1.25 - platform: darwin/arm64 - directive: run - case: typeparam/issue48317.go - reason: go1.25 goroot run failure on darwin/arm64 - - version: go1.25 - platform: darwin/arm64 - directive: run - case: typeparam/issue48318.go - reason: go1.25 goroot run failure on darwin/arm64 - - version: go1.25 - platform: darwin/arm64 - directive: run - case: winbatch.go - reason: go1.25 goroot run failure on darwin/arm64 - version: go1.25 platform: linux/amd64 directive: run @@ -2056,1538 +1906,63 @@ xfails: - version: go1.26 platform: darwin/arm64 directive: run - case: armimm.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: const.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: convert.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: copy.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: divide.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: env.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: linkmain_run.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: linkx_run.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: literal2.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: mapclear.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: reflectmethod4.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: rename.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: sigchld.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: stackobj2.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: strcopy.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: stringrange.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeswitch1.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: unsafe_slice_data.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: unsafe_string_data.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: winbatch.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: ken/cplx4.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: ken/divconst.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: ken/modconst.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: chan/fifo.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: chan/nonblock.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: chan/powser2.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: interface/embed.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: interface/struct.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/bug027.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/bug059.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/bug141.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/bug147.go + case: fixedbugs/issue73916.go reason: go1.26 goroot run failure on darwin/arm64 - version: go1.26 platform: darwin/arm64 directive: run - case: fixedbugs/bug154.go + case: fixedbugs/issue73917.go reason: go1.26 goroot run failure on darwin/arm64 - version: go1.26 platform: darwin/arm64 directive: run - case: fixedbugs/bug184.go + case: fixedbugs/issue76008.go reason: go1.26 goroot run failure on darwin/arm64 - version: go1.26 platform: darwin/arm64 directive: run - case: fixedbugs/bug187.go + case: devirtualization_nil_panics.go reason: go1.26 goroot run failure on darwin/arm64 - version: go1.26 platform: darwin/arm64 directive: run - case: fixedbugs/bug207.go + case: newexpr.go reason: go1.26 goroot run failure on darwin/arm64 - version: go1.26 platform: darwin/arm64 directive: run - case: fixedbugs/bug260.go + case: range4.go reason: go1.26 goroot run failure on darwin/arm64 - version: go1.26 platform: darwin/arm64 directive: run - case: fixedbugs/bug271.go + case: chan/goroutines.go reason: go1.26 goroot run failure on darwin/arm64 - version: go1.26 platform: darwin/arm64 directive: run - case: fixedbugs/bug369.go + case: fixedbugs/issue70189.go reason: go1.26 goroot run failure on darwin/arm64 - version: go1.26 platform: darwin/arm64 directive: run - case: fixedbugs/bug402.go + case: fixedbugs/issue72844.go reason: go1.26 goroot run failure on darwin/arm64 - version: go1.26 platform: darwin/arm64 directive: run - case: fixedbugs/bug461.go + case: fixedbugs/issue73916b.go reason: go1.26 goroot run failure on darwin/arm64 - version: go1.26 platform: darwin/arm64 directive: run - case: fixedbugs/bug483.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/gcc65755.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue11256.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue11771.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue11987.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue13160.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue13268.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue14553.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue14636.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue14651.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue15329.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue15528.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue15992.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue16331.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue17640.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue18661.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue19182.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue19359.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue19911.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue21317.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue21963.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue22660.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue22662b.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue22781.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue23812.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue24817.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue25322.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue26411.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue27695b.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue30041.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue30566b.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue30606b.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue30956.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue33275_run.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue36437.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue40629.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue41239.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue43619.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue43908.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue45851.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue4620.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue4667.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue48357.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue48476.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue49665.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue51733.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue54542.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue56990.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue57184.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue59680.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue62360.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue70156.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue7044.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue7050.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue72063.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue73748a.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue73916.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue73917.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue7419.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue74379b.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue74935.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue76008.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue7863.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue7995.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue9110.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue9355.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue9862_run.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: abi/convT64_criteria.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: abi/double_nested_struct.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: abi/fibish.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: abi/leaf.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: abi/many_int_input.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: abi/named_return_stuff.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: abi/return_stuff.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: abi/spills3.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: abi/struct_lower_1.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: abi/uglyfib.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/absdiff2.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/adder.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/boundmethod.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/combine.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/dictionaryCapture.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/double.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/genembed.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/graph.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/index.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/issue45817.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/issue47272.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/issue47713.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/issue47740b.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/issue48013.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/issue48253.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/issue48318.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/issue50002.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/issue50642.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/issue50690b.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/issue51303.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/issue54456.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/list.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/maps.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/min.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/ordered.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/pair.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/settable.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/slices.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/stringable.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/struct.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/sum.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/typeswitch2.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/value.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: char_lit.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: cmp.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: const3.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: const7.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: defer.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: devirtualization_nil_panics.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: float_lit2.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: gc2.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: gcstring.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: initialize.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: int_lit.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: linkobj.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: map.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: maplinear.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: newexpr.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: nosplit.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: range4.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: reflectmethod7.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: reorder.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: shift3.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: string_lit.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeswitch.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: uintptrescapes3.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: ken/cplx3.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: ken/rob2.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: chan/goroutines.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: chan/powser1.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/bug006.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/bug060.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/bug070.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/bug120.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/bug130.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/bug159.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/bug177.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/bug206.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/bug237.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/bug257.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/bug259.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/bug265.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/bug295.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/bug321.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/bug346.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/bug364.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/bug444.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/bug470.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue10925.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue11945.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue12226.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue13162.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue13171.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue14591.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue14725.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue15303.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue15439.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue16016.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue16095.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue16870.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue18636.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue18725.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue19113.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue19201.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue19275.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue19658.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue19799.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue21576.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue21808.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue22605.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue22683.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue24547.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue24799.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue27695c.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue27829.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue28390.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue28797.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue29264.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue29312.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue30243.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue30566a.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue30606.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue31987.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue33555.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue34123.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue37716.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue42076.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue43570.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue44823.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue45242.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue4618.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue48289.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue48473.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue49110.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue52127.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue5373.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue54467.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue5809.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue62203.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue66066.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue68227.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue6902.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue70189.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue7083.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue72844.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue73748b.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue73916b.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue73920.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue74379.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue74379c.go + case: fixedbugs/issue73920.go reason: go1.26 goroot run failure on darwin/arm64 - version: go1.26 platform: darwin/arm64 directive: run case: fixedbugs/issue75327.go reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue76709.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue7740.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue8004.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue8139.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue8158.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue8606.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: fixedbugs/issue9321.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: abi/convF_criteria.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: abi/double_nested_addressed_struct.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: abi/f_ret_z_not.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: abi/fibish_closure.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: abi/idata.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: abi/leaf2.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: abi/many_intstar_input.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: abi/named_results.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: abi/s_sif_sif.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: abi/spills4.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: abi/struct_3_string_input.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: abi/too_big_to_ssa.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/absdiff3.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/cons.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/fact.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/genembed2.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/ifaceconv.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/index2.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/issue45722.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/issue47258.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/issue47716.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/issue47740.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/issue48016.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/issue48042.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/issue48225.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/issue48276a.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/issue48317.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/issue50109.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/issue50193.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/issue50419.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/issue50690a.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/issue50690c.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/issue53087.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/list2.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/map.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/metrics.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/sets.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/smallest.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/stringer.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/subdict.go - reason: go1.26 goroot run failure on darwin/arm64 - - version: go1.26 - platform: darwin/arm64 - directive: run - case: typeparam/mdempsky/18.go - reason: go1.26 goroot run failure on darwin/arm64 - version: go1.26 platform: linux/amd64 directive: run