Module *Module
Go *Go
Toolchain *Toolchain
+ Godebug []*Godebug
Require []*Require
Exclude []*Exclude
Replace []*Replace
Syntax *Line
}
+// A Godebug is a single godebug key=value statement.
+type Godebug struct {
+ Key string
+ Value string
+ Syntax *Line
+}
+
// An Exclude is a single exclude statement.
type Exclude struct {
Mod module.Version
})
}
continue
- case "module", "require", "exclude", "replace", "retract":
+ case "module", "godebug", "require", "exclude", "replace", "retract":
for _, l := range x.Line {
f.add(&errs, x, l, x.Token[0], l.Token, fix, strict)
}
// Toolchains must be named beginning with `go1`,
// like "go1.20.3" or "go1.20.3-gccgo". As a special case, "default" is also permitted.
-// TODO(samthanawalla): Replace regex with https://pkg.go.dev/go/version#IsValid in 1.23+
+// Note that this regexp is a much looser condition than go/version.IsValid,
+// for forward compatibility.
+// (This code has to be work to identify new toolchains even if we tweak the syntax in the future.)
var ToolchainRE = lazyregexp.New(`^default$|^go1($|\.)`)
func (f *File) add(errs *ErrorList, block *LineBlock, line *Line, verb string, args []string, fix VersionFixer, strict bool) {
if len(args) != 1 {
errorf("toolchain directive expects exactly one argument")
return
- } else if strict && !ToolchainRE.MatchString(args[0]) {
+ } else if !ToolchainRE.MatchString(args[0]) {
errorf("invalid toolchain version '%s': must match format go1.23.0 or default", args[0])
return
}
}
f.Module.Mod = module.Version{Path: s}
+ case "godebug":
+ if len(args) != 1 || strings.ContainsAny(args[0], "\"`',") {
+ errorf("usage: godebug key=value")
+ return
+ }
+ key, value, ok := strings.Cut(args[0], "=")
+ if !ok {
+ errorf("usage: godebug key=value")
+ return
+ }
+ f.Godebug = append(f.Godebug, &Godebug{
+ Key: key,
+ Value: value,
+ Syntax: line,
+ })
+
case "require", "exclude":
if len(args) != 2 {
errorf("usage: %s module/path v1.2.3", verb)
f.Toolchain = &Toolchain{Syntax: line}
f.Toolchain.Name = args[0]
+ case "godebug":
+ if len(args) != 1 || strings.ContainsAny(args[0], "\"`',") {
+ errorf("usage: godebug key=value")
+ return
+ }
+ key, value, ok := strings.Cut(args[0], "=")
+ if !ok {
+ errorf("usage: godebug key=value")
+ return
+ }
+ f.Godebug = append(f.Godebug, &Godebug{
+ Key: key,
+ Value: value,
+ Syntax: line,
+ })
+
case "use":
if len(args) != 1 {
errorf("usage: %s local/dir", verb)
// Cleanup cleans out all the cleared entries.
func (f *File) Cleanup() {
w := 0
+ for _, g := range f.Godebug {
+ if g.Key != "" {
+ f.Godebug[w] = g
+ w++
+ }
+ }
+ f.Godebug = f.Godebug[:w]
+
+ w = 0
for _, r := range f.Require {
if r.Mod.Path != "" {
f.Require[w] = r
return nil
}
+// AddGodebug sets the first godebug line for key to value,
+// preserving any existing comments for that line and removing all
+// other godebug lines for key.
+//
+// If no line currently exists for key, AddGodebug adds a new line
+// at the end of the last godebug block.
+func (f *File) AddGodebug(key, value string) error {
+ need := true
+ for _, g := range f.Godebug {
+ if g.Key == key {
+ if need {
+ g.Value = value
+ f.Syntax.updateLine(g.Syntax, "godebug", key+"="+value)
+ need = false
+ } else {
+ g.Syntax.markRemoved()
+ *g = Godebug{}
+ }
+ }
+ }
+
+ if need {
+ f.addNewGodebug(key, value)
+ }
+ return nil
+}
+
+// addNewGodebug adds a new godebug key=value line at the end
+// of the last godebug block, regardless of any existing godebug lines for key.
+func (f *File) addNewGodebug(key, value string) {
+ line := f.Syntax.addLine(nil, "godebug", key+"="+value)
+ g := &Godebug{
+ Key: key,
+ Value: value,
+ Syntax: line,
+ }
+ f.Godebug = append(f.Godebug, g)
+}
+
// AddRequire sets the first require line for path to version vers,
// preserving any existing comments for that line and removing all
// other lines for path.
f.SortBlocks()
}
+func (f *File) DropGodebug(key string) error {
+ for _, g := range f.Godebug {
+ if g.Key == key {
+ g.Syntax.markRemoved()
+ *g = Godebug{}
+ }
+ }
+ return nil
+}
+
func (f *File) DropRequire(path string) error {
for _, r := range f.Require {
if r.Mod.Path == path {
type WorkFile struct {
Go *Go
Toolchain *Toolchain
+ Godebug []*Godebug
Use []*Use
Replace []*Replace
Err: fmt.Errorf("unknown block type: %s", strings.Join(x.Token, " ")),
})
continue
- case "use", "replace":
+ case "godebug", "use", "replace":
for _, l := range x.Line {
f.add(&errs, l, x.Token[0], l.Token, fix)
}
}
}
+// AddGodebug sets the first godebug line for key to value,
+// preserving any existing comments for that line and removing all
+// other godebug lines for key.
+//
+// If no line currently exists for key, AddGodebug adds a new line
+// at the end of the last godebug block.
+func (f *WorkFile) AddGodebug(key, value string) error {
+ need := true
+ for _, g := range f.Godebug {
+ if g.Key == key {
+ if need {
+ g.Value = value
+ f.Syntax.updateLine(g.Syntax, "godebug", key+"="+value)
+ need = false
+ } else {
+ g.Syntax.markRemoved()
+ *g = Godebug{}
+ }
+ }
+ }
+
+ if need {
+ f.addNewGodebug(key, value)
+ }
+ return nil
+}
+
+// addNewGodebug adds a new godebug key=value line at the end
+// of the last godebug block, regardless of any existing godebug lines for key.
+func (f *WorkFile) addNewGodebug(key, value string) {
+ line := f.Syntax.addLine(nil, "godebug", key+"="+value)
+ g := &Godebug{
+ Key: key,
+ Value: value,
+ Syntax: line,
+ }
+ f.Godebug = append(f.Godebug, g)
+}
+
+func (f *WorkFile) DropGodebug(key string) error {
+ for _, g := range f.Godebug {
+ if g.Key == key {
+ g.Syntax.markRemoved()
+ *g = Godebug{}
+ }
+ }
+ return nil
+}
+
func (f *WorkFile) AddUse(diskPath, modulePath string) error {
need := true
for _, d := range f.Use {