From 7de3214d39e659ecb54aba11faabff7d354f760f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Michael=20Mur=C3=A9?= Date: Fri, 9 Oct 2026 13:34:03 +0200 Subject: [PATCH 01/10] first implementation --- config.go | 156 ++++++++++++++-- discover.go | 202 ++++++++++++++++++++ edit.go | 529 ++++++++++++++++++++++++++++++++++++++++++++++++++++ env.go | 208 ++++++++++++++++++++- file.go | 145 ++++++++++++-- glob.go | 236 +++++++++++++++++++++++ key.go | 111 ++++++++++- load.go | 383 +++++++++++++++++++++++++++++++++++++ parse.go | 418 +++++++++++++++++++++++++++++++++++++++++ platform.go | 54 ++++++ update.go | 123 ++++++++++++ value.go | 154 +++++++++++++++ 12 files changed, 2682 insertions(+), 37 deletions(-) create mode 100644 discover.go create mode 100644 edit.go create mode 100644 glob.go create mode 100644 load.go create mode 100644 parse.go create mode 100644 platform.go create mode 100644 update.go create mode 100644 value.go diff --git a/config.go b/config.go index 49bcb0f..e41a291 100644 --- a/config.go +++ b/config.go @@ -2,6 +2,7 @@ package gitconfig import ( "iter" + "slices" ) // Config is an immutable, ordered set of entries, from a single file or from @@ -18,36 +19,106 @@ import ( // Subsections); methods walking the configuration return an iterator (All, // Section, Subsection). type Config struct { - // unexported + entries []Entry + index map[Key][]int // positions in entries, by key + + // subsections lists the distinct subsections of each section, in order + // of first appearance. + subsections map[string][]string +} + +// newConfig returns a Config of entries, which it keeps. +func newConfig(entries []Entry) *Config { + c := &Config{ + entries: entries, + index: make(map[Key][]int), + subsections: make(map[string][]string), + } + seen := make(map[sectionKey]bool) + for i, e := range entries { + c.index[e.Key] = append(c.index[e.Key], i) + if sk := e.Key.sectionKey(); sk.hasSub && !seen[sk] { + seen[sk] = true + c.subsections[sk.section] = append(c.subsections[sk.section], sk.subsection) + } + } + return c +} + +// lookup returns the positions of the entries of key. +func (c *Config) lookup(key string) []int { + if c == nil { + return nil + } + k, ok := parseKey(key) + if !ok { + return nil + } + return c.index[k] +} + +// filter returns the entries of one section or subsection. +func (c *Config) filter(sk sectionKey) iter.Seq[Entry] { + return func(yield func(Entry) bool) { + if c == nil { + return + } + for _, e := range c.entries { + if e.Key.sectionKey() == sk && !yield(e) { + return + } + } + } } // Get returns the last entry for key, as `git config --get` does. func (c *Config) Get(key string) (Entry, bool) { - panic("not implemented") + idx := c.lookup(key) + if len(idx) == 0 { + return Entry{}, false + } + return c.entries[idx[len(idx)-1]], true } // GetAll returns every entry for key, in order. The returned slice is owned // by the caller. func (c *Config) GetAll(key string) []Entry { - panic("not implemented") + idx := c.lookup(key) + if len(idx) == 0 { + return nil + } + out := make([]Entry, len(idx)) + for i, j := range idx { + out[i] = c.entries[j] + } + return out } // All returns every entry, in order. func (c *Config) All() iter.Seq[Entry] { - panic("not implemented") + return func(yield func(Entry) bool) { + if c == nil { + return + } + for _, e := range c.entries { + if !yield(e) { + return + } + } + } } // Section returns every entry of section [section] itself, in order; entries // of its subsections are not included. section is case-insensitive. func (c *Config) Section(section string) iter.Seq[Entry] { - panic("not implemented") + return c.filter(sectionKey{section: lowerASCII(section)}) } // Subsection returns every entry of subsection [section "sub"], in order. // section is case-insensitive, sub is case-sensitive. sub "" is the empty // subsection [section ""], distinct from [section]. func (c *Config) Subsection(section, sub string) iter.Seq[Entry] { - panic("not implemented") + return c.filter(sectionKey{lowerASCII(section), sub, true}) } // Subsections returns the distinct subsections of section, in order of first @@ -55,26 +126,48 @@ func (c *Config) Subsection(section, sub string) iter.Seq[Entry] { // Entries of [section] itself have no subsection and are not listed; "" // stands for [section ""]. func (c *Config) Subsections(section string) []string { - panic("not implemented") + if c == nil { + return nil + } + return slices.Clone(c.subsections[lowerASCII(section)]) } // Value returns the last value for key, or def if key is absent. func (c *Config) Value(key string, def string) string { - panic("not implemented") + if e, ok := c.Get(key); ok { + return e.Value + } + return def } // Bool returns the last value for key as a boolean, or def if key is absent. // A value that is not a valid boolean is a *ValueError; the result is then // def. To tell an absent key from one set to def, use Get and Entry.Bool. func (c *Config) Bool(key string, def bool) (bool, error) { - panic("not implemented") + e, ok := c.Get(key) + if !ok { + return def, nil + } + b, err := e.Bool() + if err != nil { + return def, err + } + return b, nil } // Int returns the last value for key as an integer, or def if key is absent. // A value that is not a valid integer is a *ValueError; the result is then // def. func (c *Config) Int(key string, def int64) (int64, error) { - panic("not implemented") + e, ok := c.Get(key) + if !ok { + return def, nil + } + n, err := e.Int() + if err != nil { + return def, err + } + return n, nil } // Path returns the last value for key as a path, as Entry.Path does with @@ -82,7 +175,21 @@ func (c *Config) Int(key string, def int64) (int64, error) { // value or a def that cannot be expanded is a *ValueError (for def, its Entry // has the key, Value def and a zero Origin); the result is then def as given. func (c *Config) Path(key, home, def string) (string, error) { - panic("not implemented") + e, ok := c.Get(key) + if !ok { + k, _ := parseKey(key) + e = Entry{Key: k, Value: def} + } + p, err := e.Path(home) + if err != nil { + return def, err + } + return p, nil +} + +// error returns a *ValueError for e read as typ. +func (e Entry) error(typ string, err error) error { + return &ValueError{Entry: e, Type: typ, Err: err} } // Entry is one occurrence of a key in a configuration file. It is plain @@ -125,14 +232,28 @@ type Origin struct { // are true; false, no, off, 0 and "" are false; an implicit value is true. // Case is ignored. Anything else is a *ValueError. func (e Entry) Bool() (bool, error) { - panic("not implemented") + if e.Implicit { + return true, nil + } + b, err := parseBool(e.Value) + if err != nil { + return false, e.error("bool", err) + } + return b, nil } // Int interprets the value as git does, including the k, m and g suffixes. // An invalid unit, an out-of-range value or an implicit value is a // *ValueError. func (e Entry) Int() (int64, error) { - panic("not implemented") + if e.Implicit { + return 0, e.error("int", nil) + } + n, err := parseInt(e.Value) + if err != nil { + return 0, e.error("int", err) + } + return n, nil } // Path interprets the value as a path, as git does for `--type=path` and for @@ -142,7 +263,14 @@ func (e Entry) Int() (int64, error) { // *ValueError. Config.Path // does the same for a key. func (e Entry) Path(home string) (string, error) { - panic("not implemented") + if e.Implicit { + return "", e.error("path", nil) + } + p, err := expandPath(e.Value, home) + if err != nil { + return "", e.error("path", err) + } + return p, nil } // Key is the canonical form of a key, as printed by `git config --list`: diff --git a/discover.go b/discover.go new file mode 100644 index 0000000..3fefce6 --- /dev/null +++ b/discover.go @@ -0,0 +1,202 @@ +package gitconfig + +import ( + "errors" + "fmt" + "os" + "path/filepath" + "runtime" + "strconv" + "strings" +) + +// environ is the process environment, as Discover reads it. +type environ interface { + Lookup(key string) (string, bool) +} + +type osEnviron struct{} + +func (osEnviron) Lookup(key string) (string, bool) { return os.LookupEnv(key) } + +func get(env environ, key string) string { + v, _ := env.Lookup(key) + return v +} + +func discover(gitDir string, env environ) (Env, error) { + var e Env + + e.Home = get(env, "HOME") + if e.Home == "" && runtime.GOOS == "windows" { + e.Home = get(env, "USERPROFILE") + } + + if g, ok := env.Lookup("GIT_CONFIG_GLOBAL"); ok { + if g != "" { + e.GlobalConfig = []string{g} + } + } else { + if xdg := get(env, "XDG_CONFIG_HOME"); xdg != "" { + e.GlobalConfig = append(e.GlobalConfig, filepath.Join(xdg, "git", "config")) + } else if e.Home != "" { + e.GlobalConfig = append(e.GlobalConfig, filepath.Join(e.Home, ".config", "git", "config")) + } + if e.Home != "" { + e.GlobalConfig = append(e.GlobalConfig, filepath.Join(e.Home, ".gitconfig")) + } + } + + noSystem := false + if v, ok := env.Lookup("GIT_CONFIG_NOSYSTEM"); ok { + b, err := parseBool(v) + if err != nil { + return Env{}, fmt.Errorf("gitconfig: bad boolean environment value %q for GIT_CONFIG_NOSYSTEM", v) + } + noSystem = b + } + switch s, ok := env.Lookup("GIT_CONFIG_SYSTEM"); { + case noSystem: + case ok: + e.SystemConfig = s + case runtime.GOOS != "windows": + e.SystemConfig = "/etc/gitconfig" + } + + cmd, err := countEntries(env) + if err != nil { + return Env{}, err + } + params, err := parseParameters(get(env, "GIT_CONFIG_PARAMETERS")) + if err != nil { + return Env{}, err + } + e.Command = append(cmd, params...) + + if gitDir != "" { + e.GitDir, err = resolveGitDir(gitDir) + if err != nil { + return Env{}, err + } + } + return e, nil +} + +// resolveGitDir makes gitDir absolute and follows a "gitdir: " file. +func resolveGitDir(gitDir string) (string, error) { + gitDir, err := filepath.Abs(gitDir) + if err != nil { + return "", err + } + fi, err := os.Stat(gitDir) + if err != nil || !fi.Mode().IsRegular() { + return gitDir, nil + } + data, err := readSmall(gitDir) + if err != nil { + return "", &FileError{Path: gitDir, Err: err} + } + path, ok := strings.CutPrefix(strings.TrimRight(string(data), "\r\n"), "gitdir: ") + if !ok || path == "" { + return "", &FileError{Path: gitDir, Err: errors.New("invalid gitfile format")} + } + if !filepath.IsAbs(path) { + path = filepath.Join(filepath.Dir(gitDir), path) + } + return path, nil +} + +// countEntries reads GIT_CONFIG_COUNT, GIT_CONFIG_KEY_ and +// GIT_CONFIG_VALUE_. The count is digits only, where git also accepts a +// sign and leading whitespace. +func countEntries(env environ) ([]CommandEntry, error) { + count := get(env, "GIT_CONFIG_COUNT") + if count == "" { + return nil, nil + } + n, err := strconv.ParseInt(count, 10, 32) + if err != nil || count[0] < '0' || count[0] > '9' { + return nil, fmt.Errorf("gitconfig: bogus count in GIT_CONFIG_COUNT: %q", count) + } + var entries []CommandEntry + for i := range int(n) { + key, ok := env.Lookup("GIT_CONFIG_KEY_" + strconv.Itoa(i)) + if !ok { + return nil, fmt.Errorf("gitconfig: missing config key GIT_CONFIG_KEY_%d", i) + } + value, ok := env.Lookup("GIT_CONFIG_VALUE_" + strconv.Itoa(i)) + if !ok { + return nil, fmt.Errorf("gitconfig: missing config value GIT_CONFIG_VALUE_%d", i) + } + entries = append(entries, CommandEntry{Key: key, Value: value}) + } + return entries, nil +} + +var errBogusParameters = errors.New("gitconfig: bogus format in GIT_CONFIG_PARAMETERS") + +// parseParameters parses GIT_CONFIG_PARAMETERS, where git passes its -c +// options to the commands it runs: items separated by whitespace, each a +// single-quoted key, then "=" and a single-quoted value, or "=" alone for +// an option without a value. A quote inside quotes is written '\” and an +// exclamation mark may be written '\!'. The older form of an item, a +// single-quoted "key=value", is accepted too. +func parseParameters(s string) ([]CommandEntry, error) { + var entries []CommandEntry + for s != "" { + key, rest, ok := unquote(s) + if !ok { + return nil, errBogusParameters + } + var c CommandEntry + if v, ok := strings.CutPrefix(rest, "="); ok { + c.Key = key + if v == "" || isParamSpace(v[0]) { + c.Implicit = true + rest = v + } else { + c.Value, rest, ok = unquote(v) + if !ok { + return nil, errBogusParameters + } + } + } else if k, v, ok := strings.Cut(key, "="); ok { + c.Key, c.Value = k, v + } else { + c.Key, c.Implicit = key, true + } + if rest != "" && !isParamSpace(rest[0]) { + return nil, errBogusParameters + } + entries = append(entries, c) + s = strings.TrimLeft(rest, " \t\n\v\f\r") + } + return entries, nil +} + +func isParamSpace(c byte) bool { + return strings.IndexByte(" \t\n\v\f\r", c) >= 0 +} + +// unquote reads a single-quoted string at the start of s. +func unquote(s string) (value, rest string, ok bool) { + if s == "" || s[0] != '\'' { + return "", "", false + } + var sb strings.Builder + s = s[1:] + for { + i := strings.IndexByte(s, '\'') + if i < 0 { + return "", "", false + } + sb.WriteString(s[:i]) + s = s[i+1:] + if len(s) >= 3 && s[0] == '\\' && (s[1] == '\'' || s[1] == '!') && s[2] == '\'' { + sb.WriteByte(s[1]) + s = s[3:] + continue + } + return sb.String(), s, true + } +} diff --git a/edit.go b/edit.go new file mode 100644 index 0000000..20455ef --- /dev/null +++ b/edit.go @@ -0,0 +1,529 @@ +package gitconfig + +import ( + "errors" + "slices" + "strings" +) + +// Edits are computed on the items of the file as splices of its bytes, in +// the places and the format git's own edits use. The result is parsed again +// and checked against the expected entries before it replaces the file, so +// that no edit can change anything but what it was asked to. + +// errUnsafeEdit is returned, wrapped in a *KeyError, if an edit would have +// changed other entries than its own. It is a bug of this package if it +// ever happens. +var errUnsafeEdit = errors.New("gitconfig: internal error: the edit would change other entries") + +// splice replaces data[start:end] with text. +type splice struct { + start, end int + text string +} + +// editKey validates key for an edit and returns it in canonical form, with +// its section, subsection and name as the caller spelled them, for new +// lines and headers. +func editKey(key string) (k Key, section, sub, name string, err error) { + k, ok := parseKey(key) + if !ok || k.Section == "" { + return Key{}, "", "", "", &KeyError{Key: key, Err: ErrInvalidKey} + } + first := strings.IndexByte(key, '.') + last := strings.LastIndexByte(key, '.') + section, name = key[:first], key[last+1:] + if k.HasSubsection { + sub = key[first+1 : last] + } + return k, section, sub, name, nil +} + +// prepare validates the key and, if value is not nil, the value of an edit. +func (f *File) prepare(key string, value *string) (k Key, section, sub, name string, err error) { + if err := f.checkOpen(key); err != nil { + return Key{}, "", "", "", err + } + k, section, sub, name, err = editKey(key) + if err != nil { + return Key{}, "", "", "", err + } + if value != nil { + if err := checkValue(key, *value); err != nil { + return Key{}, "", "", "", err + } + } + return k, section, sub, name, nil +} + +func checkValue(key, value string) error { + if strings.IndexByte(value, 0) >= 0 { + return &KeyError{Key: key, Err: ErrInvalidValue} + } + return nil +} + +func (f *File) checkOpen(key string) error { + if f.closed { + return &KeyError{Key: key, Err: ErrClosed} + } + return nil +} + +// entriesOf returns the indexes of the entries of key. +func (f *File) entriesOf(k Key) []int { + var idx []int + sk := k.sectionKey() + for i, it := range f.items { + if it.kind == itemEntry && it.inSection && f.secOf(it) == sk && f.nameOf(it) == k.Name { + idx = append(idx, i) + } + } + return idx +} + +// flatEntry is an entry as the checks of an edit compare them: entries +// before any header included, origins left out. +type flatEntry struct { + inSection bool + sec sectionKey + name string + value string + implicit bool +} + +func flatten(p parsed) []flatEntry { + var out []flatEntry + for _, it := range p.items { + if it.kind == itemEntry { + out = append(out, flatEntry{it.inSection, p.secOf(it), p.nameOf(it), p.valueOf(it), it.implicit}) + } + } + return out +} + +func (e flatEntry) is(k Key) bool { + return e.inSection && e.sec == k.sectionKey() && e.name == k.Name +} + +// apply splices the bytes of the file, parses the result, and keeps it if +// check accepts the entries before and after the edit. +func (f *File) apply(key string, splices []splice, check func(before, after []flatEntry) bool) error { + slices.SortFunc(splices, func(a, b splice) int { return a.start - b.start }) + data := make([]byte, 0, len(f.data)+64) + at := 0 + for _, s := range splices { + data = append(data, f.data[at:s.start]...) + data = append(data, s.text...) + at = s.end + } + data = append(data, f.data[at:]...) + p, err := parse(f.name, data) + if err != nil || !check(flatten(f.parsed), flatten(p)) { + return &KeyError{Key: key, Err: errUnsafeEdit} + } + f.data = data + f.parsed = p + f.snap = nil + return nil +} + +// checkKey returns a check that the entries of other keys are unchanged and +// that k has the values want after the edit. +func checkKey(k Key, want []string, implicitAllowed bool) func(before, after []flatEntry) bool { + return func(before, after []flatEntry) bool { + other := func(e flatEntry) bool { return !e.is(k) } + if !slices.Equal(filter(before, other), filter(after, other)) { + return false + } + got := filter(after, func(e flatEntry) bool { return e.is(k) }) + if len(got) != len(want) { + return false + } + for i, e := range got { + if e.value != want[i] || e.implicit && !implicitAllowed { + return false + } + } + return true + } +} + +func filter(entries []flatEntry, keep func(flatEntry) bool) []flatEntry { + var out []flatEntry + for _, e := range entries { + if keep(e) { + out = append(out, e) + } + } + return out +} + +// Layout helpers. A token is a header or an entry; the whitespace before a +// token on its line is its own. + +// ownStart returns where the token at i starts, its whitespace included. +func (f *File) ownStart(i int) int { + if i > 0 && f.items[i-1].kind == itemSpace { + return f.items[i-1].start + } + return f.items[i].start +} + +// firstOnLine reports whether the token at i is the first of its line. +func (f *File) firstOnLine(i int) bool { + j := i - 1 + if j >= 0 && f.items[j].kind == itemSpace { + j-- + } + return j < 0 || f.items[j].kind == itemNewline || f.items[j].kind == itemBOM +} + +// newlineAfter returns the index of the first newline after item i, or -1 +// if the file ends first. +func (f *File) newlineAfter(i int) int { + for j := i + 1; j < len(f.items); j++ { + if f.items[j].kind == itemNewline { + return j + } + } + return -1 +} + +// lineEnd returns the end of the line of item i, its newline included. +func (f *File) lineEnd(i int) int { + if n := f.newlineAfter(i); n >= 0 { + return f.items[n].end + } + return len(f.data) +} + +// terminator returns what must be written at the end of the file before a +// new line can start there. +func (f *File) terminator() string { + if len(f.items) == 0 { + return "" + } + last := f.items[len(f.items)-1] + switch { + case last.kind == itemNewline || last.kind == itemBOM: + return "" + case last.kind == itemEntry && last.open == continued: + // A blank line ends the value. + return "\n" + case last.kind == itemEntry && last.open == backslashEOF: + return "\n\n" + } + return "\n" +} + +// formatEntry returns the line git writes for an entry. +func formatEntry(name, value string) string { + return "\t" + name + " = " + quoteValue(value) + "\n" +} + +// quoteValue quotes and escapes a value as git writes it: in quotes if it +// starts or ends with a space or contains '#', ';' or a CR; backslash, +// double quote, tab and newline escaped. +func quoteValue(v string) string { + var sb strings.Builder + quote := strings.HasPrefix(v, " ") || strings.HasSuffix(v, " ") || strings.ContainsAny(v, "#;\r") + if quote { + sb.WriteByte('"') + } + for i := 0; i < len(v); i++ { + switch c := v[i]; c { + case '\\', '"': + sb.WriteByte('\\') + sb.WriteByte(c) + case '\t': + sb.WriteString(`\t`) + case '\n': + sb.WriteString(`\n`) + default: + sb.WriteByte(c) + } + } + if quote { + sb.WriteByte('"') + } + return sb.String() +} + +// formatHeader returns a section header as git writes it. +func formatHeader(section, sub string, hasSub bool) string { + if !hasSub { + return "[" + section + "]" + } + r := strings.NewReplacer(`\`, `\\`, `"`, `\"`) + return "[" + section + " \"" + r.Replace(sub) + "\"]" +} + +// replaceEntry returns the splice that rewrites the entry at i. +func (f *File) replaceEntry(i int, name, value string) splice { + line := formatEntry(name, value) + if !f.firstOnLine(i) { + // After a header on the same line: the line is split. + line = "\n" + line + } + return splice{f.ownStart(i), f.entryLineEnd(i), line} +} + +// removeEntry returns the splice that removes the entry at i: its line, or +// the rest of the line after a header, which then ends with a newline. +func (f *File) removeEntry(i int) splice { + if f.firstOnLine(i) { + return splice{f.ownStart(i), f.entryLineEnd(i), ""} + } + return splice{f.ownStart(i), f.entryLineEnd(i), "\n"} +} + +// entryLineEnd returns where the line of the entry at i ends for git when it +// removes or rewrites it: after its newline, and after the CR of the next +// line if that line is a blank CRLF line (git turns it into a blank LF line). +func (f *File) entryLineEnd(i int) int { + n := f.newlineAfter(i) + if n < 0 { + return len(f.data) + } + end := f.items[n].end + if n+1 < len(f.items) && f.items[n+1].kind == itemNewline && f.items[n+1].end-f.items[n+1].start == 2 { + end++ + } + return end +} + +// unsetEntries returns the splices that remove the entries at idx, all of +// the same key, with the headers of their section where nothing remains in +// them, as git does. git decides for each entry on the file as it is before +// the edit: +// +// - Headers of the same section that follow each other count as one. +// - Looking back from the entry, the headers go only if one of them is +// reached before any other entry or a header of another section. +// - Looking forward, past the other removed entries, an entry before the +// next header of another section keeps them. +// - A comment between the previous entry or header of another section and +// that next header keeps them too, except the comments at the end of the +// removed entries' lines. +// +// The region removed then starts after the previous entry's line, or right +// after the previous header (the rest of its line becomes a newline), and +// ends at the next header, its indentation included. +func (f *File) unsetEntries(idx []int) []splice { + removed := make(map[int]bool, len(idx)) + for _, i := range idx { + removed[i] = true + } + // Comments at the end of a removed entry's line play no part. + trailing := make(map[int]bool) + for _, i := range idx { + for j := i + 1; j < len(f.items) && f.items[j].kind != itemNewline; j++ { + if f.items[j].kind == itemComment { + trailing[j] = true + } + } + } + + var splices []splice + for _, i := range idx { + splices = append(splices, f.unsetEntry(i, removed, trailing)) + } + + // Merge the regions that overlap: a region may hold other entries. + slices.SortFunc(splices, func(a, b splice) int { return a.start - b.start }) + var merged []splice + for _, sp := range splices { + if n := len(merged); n > 0 && sp.start < merged[n-1].end { + merged[n-1].end = max(merged[n-1].end, sp.end) + continue + } + merged = append(merged, sp) + } + return merged +} + +func (f *File) unsetEntry(i int, removed, trailing map[int]bool) splice { + sec := f.items[i].sec + sameHeader := func(it item) bool { return it.kind == itemHeader && f.secOf(it) == f.secs[sec] } + + headers := false + b := i - 1 + for ; b >= 0; b-- { + it := f.items[b] + if it.kind == itemEntry || it.kind == itemHeader && !sameHeader(it) { + break + } + if sameHeader(it) { + headers = true + } + } + fw := i + 1 + for ; fw < len(f.items); fw++ { + it := f.items[fw] + if it.kind == itemEntry && !removed[fw] || it.kind == itemHeader && !sameHeader(it) { + break + } + } + if !headers || fw < len(f.items) && f.items[fw].kind == itemEntry { + return f.removeEntry(i) + } + + start, text := 0, "" + switch { + case b < 0: + if len(f.items) > 0 && f.items[0].kind == itemBOM { + start = f.items[0].end + } + case f.items[b].kind == itemEntry: + start = f.lineEnd(b) + default: + start, text = f.items[b].end, "\n" + } + end := len(f.data) + if fw < len(f.items) { + end = f.items[fw].start + } + for j, it := range f.items { + if it.kind == itemComment && it.start >= start && it.end <= end && !trailing[j] { + return f.removeEntry(i) + } + } + return splice{start, end, text} +} + +// insert returns the splice that adds a new entry for k, at the end of the +// last section that matches, or in a new section at the end of the file. +func (f *File) insert(k Key, section, sub, name, value string) splice { + sk := k.sectionKey() + h := -1 + for i, it := range f.items { + if it.kind == itemHeader && f.secOf(it) == sk { + h = i + } + } + line := formatEntry(name, value) + if h < 0 { + return splice{len(f.data), len(f.data), f.terminator() + formatHeader(section, sub, k.HasSubsection) + "\n" + line} + } + + last := h + for i := h + 1; i < len(f.items) && f.items[i].kind != itemHeader; i++ { + if f.items[i].kind == itemEntry { + last = i + } + } + if f.items[last].kind == itemEntry { + if n := f.newlineAfter(last); n >= 0 { + end := f.items[n].end + if f.entryLineEnd(last) != end { + // git's end of the entry takes the CR of a blank CRLF + // line: the new line goes after that blank line. + end = f.items[n+1].end + } + return splice{end, end, line} + } + return splice{len(f.data), len(f.data), f.terminator() + line} + } + // After a header: right after its newline, or splitting its line. + if last+1 < len(f.items) && f.items[last+1].kind == itemNewline { + end := f.items[last+1].end + return splice{end, end, line} + } + end := f.items[last].end + return splice{end, end, "\n" + line} +} + +// sectionArg validates the name of a section given to a section edit. +func sectionArg(section string) error { + if section == "" || !validSection(section) { + return &KeyError{Key: section, Err: ErrInvalidKey} + } + return nil +} + +// headersOf returns the indexes of the headers of sk. +func (f *File) headersOf(sk sectionKey) []int { + var idx []int + for i, it := range f.items { + if it.kind == itemHeader && f.secOf(it) == sk { + idx = append(idx, i) + } + } + return idx +} + +// removeSection removes every header of sk and what follows it up to the +// next header, whose own whitespace is kept. +func (f *File) removeSection(name string, sk sectionKey) (bool, error) { + headers := f.headersOf(sk) + if len(headers) == 0 { + return false, nil + } + var splices []splice + for _, h := range headers { + end := len(f.data) + for j := h + 1; j < len(f.items); j++ { + if f.items[j].kind == itemHeader { + end = f.ownStart(j) + break + } + } + splices = append(splices, splice{f.ownStart(h), end, ""}) + } + err := f.apply(name, splices, func(before, after []flatEntry) bool { + return slices.Equal(filter(before, func(e flatEntry) bool { return !e.inSection || e.sec != sk }), after) + }) + return err == nil, err +} + +// renameSection rewrites every header of sk as header, and checks that the +// entries of sk now have section to. +func (f *File) renameSection(name string, sk, to sectionKey, header string) error { + headers := f.headersOf(sk) + if len(headers) == 0 { + return &KeyError{Key: name, Err: ErrNotFound} + } + var splices []splice + done := -1 // headers up to this index are rewritten with their line + for _, h := range headers { + if h <= done { + continue + } + if !f.firstOnLine(h) { + splices = append(splices, splice{f.items[h].start, f.items[h].end, header}) + continue + } + // git rewrites the line: the header alone, then the rest of the + // line, if any, on a line of its own. + rest := h + 1 + for rest < len(f.items) && f.items[rest].kind == itemSpace { + rest++ + } + end := len(f.items) + if n := f.newlineAfter(h); n >= 0 { + end = n + 1 + } + text := header + "\n" + if rest < end && f.items[rest].kind != itemNewline { + text += "\t" + for _, it := range f.items[rest:end] { + if it.kind == itemHeader && f.secOf(it) == sk { + text += header + } else { + text += string(f.data[it.start:it.end]) + } + } + } + splices = append(splices, splice{f.ownStart(h), f.lineEnd(h), text}) + done = end - 1 + } + return f.apply(name, splices, func(before, after []flatEntry) bool { + for i := range before { + if before[i].inSection && before[i].sec == sk { + before[i].sec = to + } + } + return slices.Equal(before, after) + }) +} diff --git a/env.go b/env.go index 76e0ddf..109c543 100644 --- a/env.go +++ b/env.go @@ -1,7 +1,10 @@ package gitconfig import ( + "os" + "path/filepath" "strconv" + "strings" ) // Scope is one layer of git's configuration. Values from later scopes take @@ -115,7 +118,7 @@ type CommandEntry struct { // It is the only function of this package that reads the process // environment. func Discover(gitDir string) (Env, error) { - panic("not implemented") + return discover(gitDir, osEnviron{}) } // Load returns the effective configuration: every scope, in git's order of @@ -132,7 +135,39 @@ func Discover(gitDir string) (Env, error) { // A global file that cannot be read for lack of permission is skipped, as // git does; LoadProtected skips such a system file too. func (e Env) Load() (*Config, error) { - panic("not implemented") + l, err := e.newLoader() + if err != nil { + return nil, err + } + if e.SystemConfig != "" { + if err := l.loadFile(e.SystemConfig, ScopeSystem, false); err != nil { + return nil, err + } + } + for _, path := range e.GlobalConfig { + if err := l.loadFile(path, ScopeGlobal, true); err != nil { + return nil, err + } + } + if l.repo != nil { + start := len(l.entries) + if err := l.loadFile(l.repo.localConfig(), ScopeLocal, false); err != nil { + return nil, err + } + ok, err := worktreeConfigIn(l.entries[start:], l.repo.localConfig()) + if err != nil { + return nil, err + } + if ok { + if err := l.loadFile(l.repo.worktreeConfig(), ScopeWorktree, false); err != nil { + return nil, err + } + } + } + if err := l.command(); err != nil { + return nil, err + } + return l.config(), nil } // LoadProtected returns the configuration of the protected scopes only, with @@ -141,7 +176,24 @@ func (e Env) Load() (*Config, error) { // safe.directory or safe.bareRepository. The repository's configuration is // not read, so this is safe to call before SafeDirectory. func (e Env) LoadProtected() (*Config, error) { - panic("not implemented") + l, err := e.newLoader() + if err != nil { + return nil, err + } + if e.SystemConfig != "" { + if err := l.loadFile(e.SystemConfig, ScopeSystem, true); err != nil { + return nil, err + } + } + for _, path := range e.GlobalConfig { + if err := l.loadFile(path, ScopeGlobal, true); err != nil { + return nil, err + } + } + if err := l.command(); err != nil { + return nil, err + } + return l.config(), nil } // SafeDirectory reports whether dir is allowed by the safe.directory values @@ -154,7 +206,49 @@ func (e Env) LoadProtected() (*Config, error) { // safe.directory, and that check is platform specific and left to the // caller. A false result therefore means "not listed", not "unsafe". func (e Env) SafeDirectory(dir string) (bool, error) { - panic("not implemented") + c, err := e.LoadProtected() + if err != nil { + return false, err + } + dir = realPath(dir) + safe := false + for _, entry := range c.GetAll("safe.directory") { + switch v := entry.Value; { + case v == "": + safe = false + case v == "*": + safe = true + case strings.HasSuffix(v, "/*"): + prefix, err := Entry{Value: strings.TrimSuffix(v, "*")}.Path(e.Home) + if err != nil { + continue + } + if p, err := filepath.EvalSymlinks(prefix); err == nil { + if strings.HasPrefix(dir, strings.TrimSuffix(p, string(filepath.Separator))+string(filepath.Separator)) { + safe = true + } + } + default: + p, err := entry.Path(e.Home) + if err != nil || !filepath.IsAbs(p) { + // "." and unexpandable values are skipped. + continue + } + if p, err := filepath.EvalSymlinks(p); err == nil && p == dir { + safe = true + } + } + } + return safe, nil +} + +// realPath returns path with symbolic links resolved, or cleaned if it +// cannot be resolved. +func realPath(path string) string { + if p, err := filepath.EvalSymlinks(path); err == nil { + return p + } + return filepath.Clean(path) } // LoadScope returns the configuration of exactly one scope, with includes @@ -173,7 +267,37 @@ func (e Env) SafeDirectory(dir string) (bool, error) { // It fails with ErrNoScope for ScopeFile, and for ScopeLocal and // ScopeWorktree where WritePath does. func (e Env) LoadScope(s Scope) (*Config, error) { - panic("not implemented") + l, err := e.newLoader() + if err != nil { + return nil, err + } + switch s { + case ScopeSystem: + if e.SystemConfig != "" { + err = l.loadFile(e.SystemConfig, ScopeSystem, false) + } + case ScopeGlobal: + for _, path := range e.GlobalConfig { + if err = l.loadFile(path, ScopeGlobal, true); err != nil { + break + } + } + case ScopeLocal, ScopeWorktree: + var path string + var scope Scope + path, scope, err = e.scopeFile(s) + if err == nil { + err = l.loadFile(path, scope, false) + } + case ScopeCommand: + err = l.command() + default: + return nil, ErrNoScope + } + if err != nil { + return nil, err + } + return l.config(), nil } // LoadFile returns the configuration of the file at path, with includes @@ -181,7 +305,14 @@ func (e Env) LoadScope(s Scope) (*Config, error) { // includes there only with --includes). Its entries have ScopeFile. A // missing file is empty. func (e Env) LoadFile(path string) (*Config, error) { - panic("not implemented") + l, err := e.newLoader() + if err != nil { + return nil, err + } + if err := l.loadFile(path, ScopeFile, false); err != nil { + return nil, err + } + return l.config(), nil } // WritePath returns the file that `git config --` writes to. For @@ -193,14 +324,73 @@ func (e Env) LoadFile(path string) (*Config, error) { // ScopeLocal and ScopeWorktree outside a repository, ScopeWorktree in a // repository with several worktrees and no extensions.worktreeConfig. func (e Env) WritePath(s Scope) (string, error) { - panic("not implemented") + switch s { + case ScopeSystem: + if e.SystemConfig == "" { + return "", ErrNoScope + } + return e.SystemConfig, nil + case ScopeGlobal: + if len(e.GlobalConfig) == 0 { + return "", ErrNoScope + } + for i := len(e.GlobalConfig) - 1; i >= 0; i-- { + if _, err := os.Lstat(e.GlobalConfig[i]); err == nil { + return e.GlobalConfig[i], nil + } + } + return e.GlobalConfig[len(e.GlobalConfig)-1], nil + case ScopeLocal, ScopeWorktree: + path, _, err := e.scopeFile(s) + return path, err + } + return "", ErrNoScope +} + +// scopeFile returns the file of the local or worktree scope, and the scope +// its entries have: without extensions.worktreeConfig, the worktree scope +// is the local config, if the repository has a single worktree. +func (e Env) scopeFile(s Scope) (string, Scope, error) { + r, err := e.repo() + if err != nil { + return "", 0, err + } + if r == nil { + return "", 0, ErrNoScope + } + if s == ScopeLocal { + return r.localConfig(), ScopeLocal, nil + } + ok, err := r.worktreeConfigEnabled() + switch { + case err != nil: + return "", 0, err + case ok: + return r.worktreeConfig(), ScopeWorktree, nil + case r.severalWorktrees(): + return "", 0, ErrNoScope + } + return r.localConfig(), ScopeLocal, nil } // UpdateScope edits the file of scope s, as UpdateFile does; the File's // entries have the scope LoadScope gives them. Writes never go into an // included file. func (e Env) UpdateScope(s Scope, fn func(*File) error) error { - panic("not implemented") + var path string + var scope Scope + var err error + switch s { + case ScopeLocal, ScopeWorktree: + path, scope, err = e.scopeFile(s) + default: + path, err = e.WritePath(s) + scope = s + } + if err != nil { + return err + } + return updateFile(path, scope, fn) } // UpdateFile edits the file at path with git's lock protocol, like @@ -232,5 +422,5 @@ func (e Env) UpdateScope(s Scope, fn func(*File) error) error { // path controls which file is written: do not edit the configuration of a // repository you have not checked with SafeDirectory and an ownership check. func (e Env) UpdateFile(path string, fn func(*File) error) error { - panic("not implemented") + return updateFile(path, ScopeFile, fn) } diff --git a/file.go b/file.go index 373e157..19d352d 100644 --- a/file.go +++ b/file.go @@ -1,5 +1,9 @@ package gitconfig +import ( + "bytes" +) + // File is the lossless, editable form of one configuration file. Edits // change only the lines `git config` would change, and produce the same // bytes; everything else is kept byte for byte. @@ -31,7 +35,13 @@ package gitconfig // one change. Values are quoted and escaped as git does, and a subsection // that cannot be written in a header (newline, NUL) is ErrInvalidKey. type File struct { - // unexported + name string + scope Scope + data []byte + parsed + + closed bool // edits fail with ErrClosed + snap *Config // Config of data, nil until asked for } // Parse parses a configuration file. name is used in errors and in the @@ -43,13 +53,18 @@ type File struct { // data may come from anyone (a .gitmodules blob from a remote): Parse never // panics, and its time and memory are linear in len(data). func Parse(name string, data []byte) (*File, error) { - panic("not implemented") + data = bytes.Clone(data) + p, err := parse(name, data) + if err != nil { + return nil, err + } + return &File{name: name, data: data, parsed: p}, nil } // Bytes returns the content of the file. It is identical to the parsed data // if the file was not edited. func (f *File) Bytes() []byte { - panic("not implemented") + return bytes.Clone(f.data) } // Config returns an immutable snapshot of the entries of this file. Include @@ -61,7 +76,10 @@ func (f *File) Bytes() []byte { // The snapshot is kept until the next edit, so calling Config repeatedly, // for example to read values inside an Env.UpdateFile callback, is cheap. func (f *File) Config() *Config { - panic("not implemented") + if f.snap == nil { + f.snap = newConfig(f.entries(f.scope, f.name, nil)) + } + return f.snap } // Set sets the value of key, like `git config `, adding it if @@ -72,45 +90,124 @@ func (f *File) Config() *Config { // difference with git's edits. An implicit entry ("[a]\n\tk") is never // already set, even for value "": it reads as true, and "k = " as false. func (f *File) Set(key, value string) error { - panic("not implemented") + k, section, sub, name, err := f.prepare(key, &value) + if err != nil { + return err + } + idx := f.entriesOf(k) + switch { + case len(idx) > 1: + return &KeyError{Key: key, Err: ErrMultipleValues} + case len(idx) == 1: + if it := f.items[idx[0]]; !it.implicit && f.valueOf(it) == value { + return nil + } + return f.apply(key, []splice{f.replaceEntry(idx[0], name, value)}, checkKey(k, []string{value}, false)) + } + return f.apply(key, []splice{f.insert(k, section, sub, name, value)}, checkKey(k, []string{value}, false)) } // ReplaceAll replaces all values of key with a single value, or adds it if // key is absent, like `git config --replace-all `. func (f *File) ReplaceAll(key, value string) error { - panic("not implemented") + k, section, sub, name, err := f.prepare(key, &value) + if err != nil { + return err + } + idx := f.entriesOf(k) + if len(idx) == 0 { + return f.apply(key, []splice{f.insert(k, section, sub, name, value)}, checkKey(k, []string{value}, false)) + } + // The values collapse into one, at the place of the last. + var splices []splice + for _, i := range idx[:len(idx)-1] { + splices = append(splices, f.removeEntry(i)) + } + splices = append(splices, f.replaceEntry(idx[len(idx)-1], name, value)) + return f.apply(key, splices, checkKey(k, []string{value}, false)) } // Add adds a value to key, keeping existing ones, like `git config --add`. func (f *File) Add(key, value string) error { - panic("not implemented") + k, section, sub, name, err := f.prepare(key, &value) + if err != nil { + return err + } + var want []string + for _, i := range f.entriesOf(k) { + want = append(want, f.valueOf(f.items[i])) + } + want = append(want, value) + return f.apply(key, []splice{f.insert(k, section, sub, name, value)}, func(before, after []flatEntry) bool { + // Implicit values are kept: only the new one must not be. + got := filter(after, func(e flatEntry) bool { return e.is(k) }) + return checkKey(k, want, true)(before, after) && !got[len(got)-1].implicit + }) } // Unset removes the value of key, like `git config --unset `, and // reports whether there was one. It fails with ErrMultipleValues if key has // several values. func (f *File) Unset(key string) (removed bool, err error) { - panic("not implemented") + k, _, _, _, err := f.prepare(key, nil) + if err != nil { + return false, err + } + idx := f.entriesOf(k) + switch len(idx) { + case 0: + return false, nil + case 1: + err := f.apply(key, f.unsetEntries(idx), checkKey(k, nil, false)) + return err == nil, err + } + return false, &KeyError{Key: key, Err: ErrMultipleValues} } // UnsetAll removes all values of key, like `git config --unset-all `, // and returns how many were removed. func (f *File) UnsetAll(key string) (removed int, err error) { - panic("not implemented") + k, _, _, _, err := f.prepare(key, nil) + if err != nil { + return 0, err + } + idx := f.entriesOf(k) + if len(idx) == 0 { + return 0, nil + } + if err := f.apply(key, f.unsetEntries(idx), checkKey(k, nil, false)); err != nil { + return 0, err + } + return len(idx), nil } // RemoveSection removes section [section] and all its entries, like // `git config --remove-section
`, and reports whether it was // present. Its subsections are kept. func (f *File) RemoveSection(section string) (removed bool, err error) { - panic("not implemented") + if err := f.checkOpen(section); err != nil { + return false, err + } + if err := sectionArg(section); err != nil { + return false, err + } + return f.removeSection(section, sectionKey{section: lowerASCII(section)}) } // RemoveSubsection removes subsection [section "sub"] and all its entries, // like `git config --remove-section
.`, and reports whether // it was present. sub "" is the empty subsection [section ""]. func (f *File) RemoveSubsection(section, sub string) (removed bool, err error) { - panic("not implemented") + if err := f.checkOpen(section); err != nil { + return false, err + } + if err := sectionArg(section); err != nil { + return false, err + } + if !validSubsection(sub) { + return false, &KeyError{Key: sub, Err: ErrInvalidKey} + } + return f.removeSection(section, sectionKey{lowerASCII(section), sub, true}) } // RenameSection renames section [oldName] to [newName], like @@ -121,7 +218,17 @@ func (f *File) RemoveSubsection(section, sub string) (removed bool, err error) { // it does, both sections remain and read as one, as with git. To refuse // instead, check f.Config() first, in the same Env.UpdateFile callback. func (f *File) RenameSection(oldName, newName string) error { - panic("not implemented") + if err := f.checkOpen(oldName); err != nil { + return err + } + if err := sectionArg(oldName); err != nil { + return err + } + if err := sectionArg(newName); err != nil { + return err + } + to := sectionKey{section: lowerASCII(newName)} + return f.renameSection(oldName, sectionKey{section: lowerASCII(oldName)}, to, formatHeader(newName, "", false)) } // RenameSubsection renames subsection [section "oldSub"] to @@ -131,5 +238,17 @@ func (f *File) RenameSection(oldName, newName string) error { // rename` refuses one, and a caller doing the same checks // f.Config().Subsections first. func (f *File) RenameSubsection(section, oldSub, newSub string) error { - panic("not implemented") + if err := f.checkOpen(section); err != nil { + return err + } + if err := sectionArg(section); err != nil { + return err + } + for _, sub := range []string{oldSub, newSub} { + if !validSubsection(sub) { + return &KeyError{Key: sub, Err: ErrInvalidKey} + } + } + sec := lowerASCII(section) + return f.renameSection(section, sectionKey{sec, oldSub, true}, sectionKey{sec, newSub, true}, formatHeader(section, newSub, true)) } diff --git a/glob.go b/glob.go new file mode 100644 index 0000000..b92b626 --- /dev/null +++ b/glob.go @@ -0,0 +1,236 @@ +package gitconfig + +// The patterns of includeIf "gitdir:" and "onbranch:" are matched as paths: +// '*' and '?' do not match '/', "**/" at the start of a segment matches any +// number of directories, "**" ending the pattern after a '/' (or alone) +// matches anything, "[...]" is a class of characters ("[!...]" or "[^...]" +// negated, "a-z" a range) and '\' quotes the next character. +// +// The pattern is compiled into tokens and matched by simulating every +// possible position in the pattern at once, so that the time is linear in +// the length of the name for a given pattern: patterns come from +// configuration files someone else may have written. + +type globKind uint8 + +const ( + globLit globKind = iota // one given character + globAny // '?': any character but '/' + globClass // "[...]": a character of the class, never '/' + globStar // '*': any run of characters without '/' + globDirs // "**/": nothing, or anything ending with '/' + globAll // final "**": anything +) + +type globToken struct { + kind globKind + c byte // globLit + ranges [][2]byte // globClass: inclusive ranges + negate bool // globClass +} + +func compileGlob(p string) []globToken { + var toks []globToken + segStart := true + for i := 0; i < len(p); { + c := p[i] + switch { + case c == '*' && segStart && i+1 < len(p) && p[i+1] == '*' && (i+2 == len(p) || p[i+2] == '/'): + if i+2 == len(p) { + toks = append(toks, globToken{kind: globAll}) + i += 2 + continue + } + if len(toks) == 0 || toks[len(toks)-1].kind != globDirs { + // "**/**/" is "**/". + toks = append(toks, globToken{kind: globDirs}) + } + i += 3 + continue // still at the start of a segment + case c == '*': + for i < len(p) && p[i] == '*' { + i++ + } + toks = append(toks, globToken{kind: globStar}) + case c == '?': + toks = append(toks, globToken{kind: globAny}) + i++ + case c == '[': + if tok, n, ok := compileClass(p[i:]); ok { + toks = append(toks, tok) + i += n + } else { + toks = append(toks, globToken{kind: globLit, c: c}) + i++ + } + case c == '\\' && i+1 < len(p): + toks = append(toks, globToken{kind: globLit, c: p[i+1]}) + i += 2 + default: + toks = append(toks, globToken{kind: globLit, c: c}) + i++ + } + segStart = toks[len(toks)-1].kind == globLit && toks[len(toks)-1].c == '/' + } + return toks +} + +// compileClass compiles the class at the start of p, and returns its length, +// or false if it is not terminated. +func compileClass(p string) (globToken, int, bool) { + tok := globToken{kind: globClass} + i := 1 + if i < len(p) && (p[i] == '!' || p[i] == '^') { + tok.negate = true + i++ + } + first := true + for i < len(p) { + c := p[i] + if c == ']' && !first { + return tok, i + 1, true + } + first = false + if c == '\\' && i+1 < len(p) { + i++ + c = p[i] + } + lo, hi := c, c + if i+2 < len(p) && p[i+1] == '-' && p[i+2] != ']' { + hi = p[i+2] + if hi == '\\' && i+3 < len(p) { + hi = p[i+3] + i++ + } + i += 2 + } + tok.ranges = append(tok.ranges, [2]byte{lo, hi}) + i++ + } + return globToken{}, 0, false +} + +func (t globToken) inClass(c byte, fold bool) bool { + in := false + for _, r := range t.ranges { + if r[0] <= c && c <= r[1] || fold && r[0] <= swapCase(c) && swapCase(c) <= r[1] { + in = true + break + } + } + return in != t.negate +} + +func swapCase(c byte) byte { + if isAlpha(c) { + return c ^ 0x20 + } + return c +} + +func sameByte(a, b byte, fold bool) bool { + return a == b || fold && isAlpha(a) && a^0x20 == b +} + +// globMatch reports whether name matches pattern. With fold, the case of +// ASCII letters is ignored. +func globMatch(pattern, name string, fold bool) bool { + toks := compileGlob(pattern) + n := int32(len(toks)) + // A state is a position in the pattern, 2*s for token s, or 2*s+1 for + // the inside of the directories matched by the globDirs token s. Only + // the states reached are visited. + cur := newStateSet(2*n + 2) + next := newStateSet(2*n + 2) + + // enter adds the state of token s and those reachable without a + // character: past a '*', "**/" or final "**". + enter := func(set *stateSet, s int32) { + for set.add(2*s) && s < n { + if k := toks[s].kind; k != globStar && k != globDirs && k != globAll { + break + } + s++ + } + } + + enter(cur, 0) + for i := 0; i < len(name); i++ { + c := name[i] + next.reset() + for _, id := range cur.list { + s := id / 2 + if id%2 == 1 { + // Inside "**/": anything, and a '/' may end it. + next.add(id) + if c == '/' { + enter(next, s+1) + } + continue + } + if s == n { + continue + } + switch t := toks[s]; t.kind { + case globLit: + if sameByte(c, t.c, fold) { + enter(next, s+1) + } + case globAny: + if c != '/' { + enter(next, s+1) + } + case globClass: + if c != '/' && t.inClass(c, fold) { + enter(next, s+1) + } + case globStar: + if c != '/' { + enter(next, s) + } + case globDirs: + next.add(id + 1) + if c == '/' { + enter(next, s+1) + } + case globAll: + enter(next, s) + } + } + if len(next.list) == 0 { + return false + } + cur, next = next, cur + } + return cur.has(2 * n) +} + +// stateSet is a set of states, listed in the order they were added. +type stateSet struct { + list []int32 + mark []uint32 // mark[id] == gen if id is in the set + gen uint32 +} + +func newStateSet(size int32) *stateSet { + return &stateSet{mark: make([]uint32, size), gen: 1} +} + +func (ss *stateSet) reset() { + ss.list = ss.list[:0] + ss.gen++ +} + +// add adds id and reports whether it was absent. +func (ss *stateSet) add(id int32) bool { + if ss.mark[id] == ss.gen { + return false + } + ss.mark[id] = ss.gen + ss.list = append(ss.list, id) + return true +} + +func (ss *stateSet) has(id int32) bool { + return ss.mark[id] == ss.gen +} diff --git a/key.go b/key.go index 84b019c..12c10a7 100644 --- a/key.go +++ b/key.go @@ -1,12 +1,52 @@ package gitconfig +import ( + "strings" +) + // ParseKey parses "section.name" or "section.subsection.name" as git does: // the subsection is everything between the first and the last dot, section // and name are lowered. A key git rejects is ErrInvalidKey, including a // subsection containing a newline or a NUL byte. Reads treat an invalid key // as absent; only ParseKey and edits report it. func ParseKey(s string) (Key, error) { - panic("not implemented") + k, ok := parseKey(s) + if !ok { + return Key{}, &KeyError{Key: s, Err: ErrInvalidKey} + } + return k, nil +} + +// parseKey is ParseKey without the error value, for reads. +// +// A key with an empty section is valid when it has a subsection +// (".sub.name", "..name"): git reads it from a header [ "sub"] or [.], and +// every entry read must have a key ParseKey accepts. Edits refuse it. +func parseKey(s string) (Key, bool) { + first := strings.IndexByte(s, '.') + last := strings.LastIndexByte(s, '.') + if first < 0 { + return Key{}, false + } + name := s[last+1:] + if !validName(name) { + return Key{}, false + } + k := Key{Name: lowerASCII(name)} + if first == last { + if !validSection(s[:first]) || first == 0 { + return Key{}, false + } + k.Section = lowerASCII(s[:first]) + return k, true + } + if !validSection(s[:first]) || !validSubsection(s[first+1:last]) { + return Key{}, false + } + k.Section = lowerASCII(s[:first]) + k.Subsection = s[first+1 : last] + k.HasSubsection = true + return k, true } // String returns the key as "section.name" or "section.subsection.name" @@ -17,3 +57,72 @@ func (k Key) String() string { } return k.Section + "." + k.Name } + +// sectionKey identifies a section or subsection in canonical form: the part +// of a Key before its name. +type sectionKey struct { + section string + subsection string + hasSub bool +} + +func (k Key) sectionKey() sectionKey { + return sectionKey{k.Section, k.Subsection, k.HasSubsection} +} + +// isKeyChar reports whether c may appear in a section or key name. +func isKeyChar(c byte) bool { + return isAlpha(c) || '0' <= c && c <= '9' || c == '-' +} + +func isAlpha(c byte) bool { + return 'a' <= c|0x20 && c|0x20 <= 'z' +} + +// validName reports whether s is a valid key name: a letter, then letters, +// digits and dashes. +func validName(s string) bool { + if s == "" || !isAlpha(s[0]) { + return false + } + for i := 1; i < len(s); i++ { + if !isKeyChar(s[i]) { + return false + } + } + return true +} + +// validSection reports whether s holds only the characters of a section +// name. It may be empty. +func validSection(s string) bool { + for i := 0; i < len(s); i++ { + if !isKeyChar(s[i]) { + return false + } + } + return true +} + +// validSubsection reports whether s can be written in a header: anything +// but a newline or a NUL byte. +func validSubsection(s string) bool { + return !strings.ContainsAny(s, "\n\x00") +} + +// lowerASCII lowers ASCII letters only: the format is ASCII, and Unicode +// folding would accept names git rejects. +func lowerASCII(s string) string { + for i := 0; i < len(s); i++ { + if 'A' <= s[i] && s[i] <= 'Z' { + b := []byte(s) + for j := i; j < len(b); j++ { + if 'A' <= b[j] && b[j] <= 'Z' { + b[j] += 'a' - 'A' + } + } + return string(b) + } + } + return s +} diff --git a/load.go b/load.go new file mode 100644 index 0000000..d08a281 --- /dev/null +++ b/load.go @@ -0,0 +1,383 @@ +package gitconfig + +import ( + "errors" + "fmt" + "io" + "io/fs" + "os" + "path/filepath" + "runtime" + "slices" + "strings" +) + +// Limits of one load (X3): git's include depth, and bounds on the work a +// set of files built to multiply it can cause. +const ( + maxIncludeDepth = 10 + maxLoadFiles = 1000 + maxLoadBytes = 64 << 20 +) + +// repo is the repository of an Env. +type repo struct { + gitDir string // as given: the worktree's git directory + commonDir string // the repository's git directory +} + +// repo returns the repository of the Env, or nil outside a repository. +func (e Env) repo() (*repo, error) { + if e.GitDir == "" { + return nil, nil + } + if !filepath.IsAbs(e.GitDir) { + return nil, &FileError{Path: e.GitDir, Err: ErrNotAbsolute} + } + r := &repo{gitDir: e.GitDir, commonDir: e.GitDir} + data, err := readSmall(filepath.Join(e.GitDir, "commondir")) + switch { + case err == nil: + dir := strings.TrimRight(string(data), "\r\n") + if !filepath.IsAbs(dir) { + dir = filepath.Join(e.GitDir, dir) + } + r.commonDir = filepath.Clean(dir) + case !errors.Is(err, fs.ErrNotExist): + return nil, &FileError{Path: filepath.Join(e.GitDir, "commondir"), Err: err} + } + return r, nil +} + +func (r *repo) localConfig() string { + return filepath.Join(r.commonDir, "config") +} + +func (r *repo) worktreeConfig() string { + return filepath.Join(r.gitDir, "config.worktree") +} + +// worktreeConfigEnabled reports whether extensions.worktreeConfig is set +// in the repository's config. +func (r *repo) worktreeConfigEnabled() (bool, error) { + data, err := readConfigFile(r.localConfig(), maxLoadBytes) + if errors.Is(err, fs.ErrNotExist) { + return false, nil + } + if err != nil { + return false, &FileError{Path: r.localConfig(), Err: err} + } + p, err := parse(r.localConfig(), data) + if err != nil { + return false, &FileError{Path: r.localConfig(), Err: err} + } + return worktreeConfigIn(p.entries(ScopeLocal, r.localConfig(), nil), r.localConfig()) +} + +// worktreeConfigIn returns the last value of extensions.worktreeConfig in +// the entries of file path: git does not take it from included files. +func worktreeConfigIn(entries []Entry, path string) (bool, error) { + k := Key{Section: "extensions", Name: "worktreeconfig"} + enabled := false + for _, e := range entries { + if e.Key != k || e.Origin.File != path { + continue + } + b, err := e.Bool() + if err != nil { + return false, &FileError{Path: path, Err: err} + } + enabled = b + } + return enabled, nil +} + +// severalWorktrees reports whether the repository has linked worktrees. +func (r *repo) severalWorktrees() bool { + entries, err := os.ReadDir(filepath.Join(r.commonDir, "worktrees")) + return err == nil && len(entries) > 0 +} + +// branch returns the branch HEAD points to, or "" if it is detached or +// cannot be read. +func (r *repo) branch() string { + data, err := readSmall(filepath.Join(r.gitDir, "HEAD")) + if err != nil { + return "" + } + s, ok := strings.CutPrefix(string(data), "ref:") + if !ok { + return "" + } + s = strings.TrimSpace(s) + name, ok := strings.CutPrefix(s, "refs/heads/") + if !ok { + return "" + } + return name +} + +// readSmall reads a small file of the repository, such as HEAD. +func readSmall(path string) ([]byte, error) { + return readConfigFile(path, 4096) +} + +// readConfigFile reads a regular file, at most limit bytes. A file that is +// not regular is ErrNotRegular, read without blocking: a FIFO would block +// until someone writes to it. os.DevNull, which git documents to skip a +// scope, reads as empty. +func readConfigFile(path string, limit int64) ([]byte, error) { + if path == os.DevNull { + return nil, nil + } + var data []byte + err := retryTransient(func() error { + f, err := openRegular(path) + if err != nil { + return err + } + defer f.Close() + fi, err := f.Stat() + if err != nil { + return err + } + if !fi.Mode().IsRegular() { + return ErrNotRegular + } + if fi.Size() > limit { + return ErrLoadLimit + } + data, err = io.ReadAll(io.LimitReader(f, limit+1)) + if err == nil && int64(len(data)) > limit { + err = ErrLoadLimit + } + return err + }) + return data, err +} + +// loader loads files into a list of entries, following includes, within +// the limits of one load. +type loader struct { + env Env + repo *repo + + files int + bytes int64 + entries []Entry + + branch string + branchRead bool +} + +func (e Env) newLoader() (*loader, error) { + r, err := e.repo() + if err != nil { + return nil, err + } + return &loader{env: e, repo: r}, nil +} + +func (l *loader) config() *Config { + return newConfig(l.entries) +} + +// loadFile loads the file at path for scope. A missing file is empty. If +// skipUnreadable, a file that cannot be read for lack of permission is +// skipped, as git does for global files. +func (l *loader) loadFile(path string, scope Scope, skipUnreadable bool) error { + err := l.load(path, scope, 0) + if skipUnreadable { + var fe *FileError + if errors.As(err, &fe) && fe.Path == path && errors.Is(fe.Err, fs.ErrPermission) { + return nil + } + } + return err +} + +func (l *loader) load(path string, scope Scope, depth int) error { + l.files++ + if l.files > maxLoadFiles { + return &FileError{Path: path, Err: ErrLoadLimit} + } + data, err := readConfigFile(path, maxLoadBytes-l.bytes) + if errors.Is(err, fs.ErrNotExist) { + return nil + } + if err != nil { + return &FileError{Path: path, Err: err} + } + l.bytes += int64(len(data)) + + pf, err := parse(path, data) + if err != nil { + return &FileError{Path: path, Err: err} + } + start := len(l.entries) + l.entries = pf.entries(scope, path, l.entries) + // Includes are spliced in place: take the entries of this file out + // and put them back one by one. + own := slices.Clone(l.entries[start:]) + l.entries = l.entries[:start] + for _, e := range own { + l.entries = append(l.entries, e) + if err := l.include(e, path, scope, depth); err != nil { + return err + } + } + return nil +} + +// include follows e if it is an include directive. from is the file that +// holds it, "" for the command line. +func (l *loader) include(e Entry, from string, scope Scope, depth int) error { + if e.Key.Name != "path" { + return nil + } + switch { + case e.Key.Section == "include" && !e.Key.HasSubsection: + case e.Key.Section == "includeif" && e.Key.HasSubsection: + ok, err := l.condition(e.Key.Subsection, from) + if err != nil || !ok { + return err + } + default: + return nil + } + + if e.Implicit { + return l.fail(from, e, "missing value for include.path") + } + if e.Value == "" { + return nil + } + path, err := e.Path(l.env.Home) + if err != nil { + return &FileError{Path: from, Err: err} + } + if !filepath.IsAbs(path) { + if from == "" { + return &FileError{Path: path, Err: ErrNotAbsolute} + } + path = dirPrefix(from) + path + } + if depth+1 > maxIncludeDepth { + return &FileError{Path: path, Err: fmt.Errorf("%w while including %s from %s; this might be due to circular includes", ErrIncludeDepth, path, from)} + } + return l.load(path, scope, depth+1) +} + +// fail reports an invalid include directive, as git does: a bad line of +// the file, or a bad command-line entry. +func (l *loader) fail(from string, e Entry, msg string) error { + if from == "" { + return &KeyError{Key: e.Key.String(), Err: errors.New("gitconfig: " + msg)} + } + return &FileError{Path: from, Err: &SyntaxError{File: from, Line: e.Origin.Line, Msg: msg}} +} + +// dirPrefix returns path up to and including its last separator: an +// include's relative path is appended to it as is, not cleaned, as git +// does. +func dirPrefix(path string) string { + i := strings.LastIndexByte(path, '/') + if runtime.GOOS == "windows" { + i = max(i, strings.LastIndexByte(path, '\\')) + } + return path[:i+1] +} + +// condition evaluates the condition of an includeIf. Unknown conditions, +// and those this package does not support (hasconfig:), are false. +func (l *loader) condition(cond, from string) (bool, error) { + switch { + case strings.HasPrefix(cond, "gitdir:"): + return l.gitdir(cond[len("gitdir:"):], from, false) + case strings.HasPrefix(cond, "gitdir/i:"): + return l.gitdir(cond[len("gitdir/i:"):], from, true) + case strings.HasPrefix(cond, "onbranch:"): + if l.repo == nil { + return false, nil + } + if !l.branchRead { + l.branch, l.branchRead = l.repo.branch(), true + } + if l.branch == "" { + return false, nil + } + pattern := cond[len("onbranch:"):] + if strings.HasSuffix(pattern, "/") { + pattern += "**" + } + return globMatch(pattern, l.branch, false), nil + } + return false, nil +} + +// gitdir evaluates includeIf "gitdir:": "~/" is the home +// directory, "./" the directory of the including file, a relative pattern +// matches at any depth ("**/" prepended) and a trailing '/' matches +// everything below ("**" appended). The pattern is matched against the git +// directory as given and its real path. +func (l *loader) gitdir(pattern, from string, fold bool) (bool, error) { + switch { + case strings.HasPrefix(pattern, "./"): + if from == "" { + return false, &FileError{Path: pattern, Err: ErrNotAbsolute} + } + pattern = filepath.ToSlash(dirPrefix(from)) + pattern[2:] + case strings.HasPrefix(pattern, "~/"): + if l.env.Home == "" { + return false, nil + } + pattern = strings.TrimSuffix(filepath.ToSlash(l.env.Home), "/") + pattern[1:] + } + if l.repo == nil { + return false, nil + } + if !isAbsPattern(pattern) { + pattern = "**/" + pattern + } + if strings.HasSuffix(pattern, "/") { + pattern += "**" + } + dir := filepath.ToSlash(l.repo.gitDir) + if globMatch(pattern, dir, fold) { + return true, nil + } + if real, err := filepath.EvalSymlinks(l.repo.gitDir); err == nil { + if real := filepath.ToSlash(real); real != dir { + return globMatch(pattern, real, fold), nil + } + } + return false, nil +} + +// isAbsPattern reports whether a gitdir pattern, written with '/', is +// absolute. +func isAbsPattern(p string) bool { + if strings.HasPrefix(p, "/") { + return true + } + return runtime.GOOS == "windows" && filepath.IsAbs(filepath.FromSlash(p)) +} + +// command loads the entries of the command line. +func (l *loader) command() error { + for _, c := range l.env.Command { + k, err := ParseKey(c.Key) + if err != nil { + return err + } + e := Entry{Key: k, Value: c.Value, Implicit: c.Implicit, Origin: Origin{Scope: ScopeCommand}} + if c.Implicit { + e.Value = "" + } + l.entries = append(l.entries, e) + if err := l.include(e, "", ScopeCommand, 0); err != nil { + return err + } + } + return nil +} diff --git a/parse.go b/parse.go new file mode 100644 index 0000000..0ddcfba --- /dev/null +++ b/parse.go @@ -0,0 +1,418 @@ +package gitconfig + +import ( + "bytes" + "strings" +) + +// A file is kept as its bytes plus a list of items covering them exactly, +// in order: parsing never drops a byte, and edits splice the bytes, then +// parse them again. + +type itemKind uint8 + +const ( + itemBOM itemKind = iota // the UTF-8 byte order mark, first in the file + itemSpace // spaces, tabs and lone CRs + itemNewline // "\n" or "\r\n" + itemComment // from '#' or ';' to the end of the line, newline excluded + itemHeader // from '[' to ']' + itemEntry // from the key to the end of the value, continuation lines included +) + +// item is one piece of the file. It holds no pointer, so that a large file +// costs the garbage collector nothing to scan: the decoded data of headers +// and entries is in the tables of parsed. +type item struct { + kind itemKind + inSection bool // false for an entry before any header + implicit bool // entries only: no '=' + open openEnd // entries only + sec int32 // the section a header opens or an entry is in: index in parsed.secs + text int32 // entries only: index in parsed.texts + start int // bytes of the item: data[start:end] + end int + line int // line of start, 1-based +} + +// entryText is the key name and the value of an entry. +type entryText struct { + name string // lowered + value string // decoded +} + +// parsed is a parsed file: its items, and the data they refer to. +type parsed struct { + items []item + secs []sectionKey // secs[0] is the zero sectionKey, for entries before any header + texts []entryText +} + +func (p *parsed) secOf(it item) sectionKey { return p.secs[it.sec] } + +// entries appends the entries of the file, those before any header left +// out, to out. +func (p *parsed) entries(scope Scope, file string, out []Entry) []Entry { + for _, it := range p.items { + if it.kind != itemEntry || !it.inSection { + continue + } + sec := p.secs[it.sec] + t := p.texts[it.text] + out = append(out, Entry{ + Key: Key{Section: sec.section, Subsection: sec.subsection, HasSubsection: sec.hasSub, Name: t.name}, + Value: t.value, + Implicit: it.implicit, + Origin: Origin{Scope: scope, File: file, Line: it.line}, + }) + } + return out +} +func (p *parsed) nameOf(it item) string { return p.texts[it.text].name } +func (p *parsed) valueOf(it item) string { return p.texts[it.text].value } + +// openEnd tells how an entry at the end of the file ends, for an edit that +// adds a line after it. +type openEnd uint8 + +const ( + closed openEnd = iota // the next line is not part of the value + continued // a backslash-newline ends the file: the next line would continue the value + backslashEOF // a backslash ends the file: a newline would continue the value +) + +var bom = []byte("\xef\xbb\xbf") + +type parser struct { + parsed + name string + data []byte + pos int + line int + + sec int32 // current section + inSection bool + secIndex map[sectionKey]int32 + names map[string]string // key names, interned + buf []byte // scratch for values +} + +// parse splits data into items, or returns the *SyntaxError git would +// report. +func parse(name string, data []byte) (parsed, error) { + p := &parser{name: name, data: data, line: 1, secIndex: make(map[sectionKey]int32), names: make(map[string]string)} + p.items = make([]item, 0, 2*bytes.Count(data, []byte{'\n'})+4) + p.secs = []sectionKey{{}} + if err := p.run(); err != nil { + return parsed{}, err + } + return p.parsed, nil +} + +func (p *parser) errorAt(line int, msg string) error { + return &SyntaxError{File: p.name, Line: line, Msg: msg} +} + +func (p *parser) add(kind itemKind, start, end int) *item { + p.items = append(p.items, item{kind: kind, start: start, end: end, line: p.line, sec: p.sec, inSection: p.inSection}) + return &p.items[len(p.items)-1] +} + +// addEntry adds an entry item. +func (p *parser) addEntry(start, end int, name []byte, value string) *item { + it := p.add(itemEntry, start, end) + n, ok := p.names[string(name)] + if !ok { + n = lowerASCII(string(name)) + p.names[string(name)] = n + } + it.text = int32(len(p.texts)) + p.texts = append(p.texts, entryText{n, value}) + return it +} + +// setSection makes sec the current section. +func (p *parser) setSection(sec sectionKey) { + i, ok := p.secIndex[sec] + if !ok { + i = int32(len(p.secs)) + p.secs = append(p.secs, sec) + p.secIndex[sec] = i + } + p.sec = i + p.inSection = true +} + +// isSpace reports whether data[i] is whitespace between tokens: a space, a +// tab, or a CR that does not start a CRLF. +func isSpace(data []byte, i int) bool { + switch data[i] { + case ' ', '\t': + return true + case '\r': + return !isNewline(data, i) + } + return false +} + +// isNewline reports whether a newline, "\n" or "\r\n", starts at data[i]. +func isNewline(data []byte, i int) bool { + return data[i] == '\n' || data[i] == '\r' && i+1 < len(data) && data[i+1] == '\n' +} + +// newlineLen returns the length of the newline at data[i]. +func newlineLen(data []byte, i int) int { + if data[i] == '\r' { + return 2 + } + return 1 +} + +func (p *parser) run() error { + d := p.data + if bytes.HasPrefix(d, bom) { + p.add(itemBOM, 0, len(bom)) + p.pos = len(bom) + } + for p.pos < len(d) { + start := p.pos + c := d[start] + switch { + case isSpace(d, start): + for p.pos < len(d) && isSpace(d, p.pos) { + p.pos++ + } + p.add(itemSpace, start, p.pos) + case isNewline(d, start): + p.pos += newlineLen(d, start) + p.add(itemNewline, start, p.pos) + p.line++ + case c == '#' || c == ';': + end := len(d) + if i := bytes.IndexByte(d[start:], '\n'); i >= 0 { + end = start + i + if d[end-1] == '\r' { + end-- + } + } + p.pos = end + p.add(itemComment, start, end) + case c == '[': + if err := p.header(); err != nil { + return err + } + case isAlpha(c): + if err := p.entry(); err != nil { + return err + } + default: + return p.errorAt(p.line, "invalid line") + } + } + return nil +} + +func (p *parser) header() error { + d := p.data + start := p.pos + i := start + 1 + for i < len(d) && (isKeyChar(d[i]) || d[i] == '.') { + i++ + } + name := lowerASCII(string(d[start+1 : i])) + if i == len(d) { + return p.errorAt(p.line+1, "unterminated section header") + } + + var sec sectionKey + switch { + case d[i] == ']': + if name == "" { + return p.errorAt(p.line, "empty section name") + } + sec.section = name + if dot := strings.IndexByte(name, '.'); dot >= 0 { + // Legacy header [a.B]: subsection "b". + sec = sectionKey{name[:dot], name[dot+1:], true} + } + i++ + + case isSpace(d, i): + for i < len(d) && isSpace(d, i) { + i++ + } + if i == len(d) || d[i] != '"' { + return p.errorAt(p.line, "invalid section header") + } + i++ + var sub []byte + for { + if i == len(d) || d[i] == '\n' { + return p.errorAt(p.line, "unterminated subsection") + } + c := d[i] + if c == '"' { + break + } + if c == '\\' { + i++ + if i == len(d) || d[i] == '\n' { + return p.errorAt(p.line, "unterminated subsection") + } + c = d[i] + } + if c == 0 { + // git cuts the subsection at the NUL, reading a key the + // file does not spell. + return p.errorAt(p.line, "NUL byte in subsection") + } + sub = append(sub, c) + i++ + } + i++ + if i == len(d) || isNewline(d, i) { + return p.errorAt(p.line+1, "unterminated section header") + } + if d[i] != ']' { + return p.errorAt(p.line, "invalid section header") + } + i++ + sec = sectionKey{name, string(sub), true} + if dot := strings.IndexByte(name, '.'); dot >= 0 { + // [a.b "x"]: git reads the keys as a.b.x.. + sec = sectionKey{name[:dot], name[dot+1:] + "." + string(sub), true} + } + + default: + return p.errorAt(p.line, "invalid section header") + } + + p.setSection(sec) + p.pos = i + p.add(itemHeader, start, i) + return nil +} + +func (p *parser) entry() error { + d := p.data + start := p.pos + i := start + for i < len(d) && isKeyChar(d[i]) { + i++ + } + name := d[start:i] + j := i + for j < len(d) && (d[j] == ' ' || d[j] == '\t') { + j++ + } + if j == len(d) || isNewline(d, j) { + p.pos = i + p.addEntry(start, i, name, "").implicit = true + return nil + } + if d[j] != '=' { + return p.errorAt(p.line, "invalid key") + } + + value, end, lines, open, err := p.value(j + 1) + if err != nil { + return err + } + p.pos = end + p.addEntry(start, end, name, value).open = open + p.line += lines + return nil +} + +// value decodes the value starting at data[i], up to a comment, the end of +// the line or the end of the file. It returns the value, where it ends and +// how many continuation lines it spans, and how it ends if it ends the file. +// +// Whitespace outside quotes is skipped before the value, and held back +// inside it: an escape, a quote or any other character writes it out first, +// and the end of the value drops it. +func (p *parser) value(i int) (string, int, int, openEnd, error) { + d := p.data + buf := p.buf[:0] + defer func() { p.buf = buf[:0] }() + pending := -1 // start of held-back whitespace, -1 if none + inQuote := false + lines := 0 + open := closed + flush := func(at int) { + if pending >= 0 { + buf = append(buf, d[pending:at]...) + pending = -1 + } + } + for i < len(d) { + c := d[i] + if isNewline(d, i) { + if inQuote { + return "", 0, 0, 0, p.errorAt(p.line+lines, "unterminated quote") + } + break + } + switch { + case c == '\\': + if i+1 == len(d) { + if inQuote { + return "", 0, 0, 0, p.errorAt(p.line+lines+1, "unterminated quote") + } + flush(i) + i++ + open = backslashEOF + continue + } + flush(i) + if isNewline(d, i+1) { + i += 1 + newlineLen(d, i+1) + lines++ + if i == len(d) { + open = continued + } + continue + } + switch d[i+1] { + case 't': + buf = append(buf, '\t') + case 'n': + buf = append(buf, '\n') + case 'b': + buf = append(buf, '\b') + case '"', '\\': + buf = append(buf, d[i+1]) + default: + return "", 0, 0, 0, p.errorAt(p.line+lines, "invalid escape") + } + i += 2 + case c == '"': + flush(i) + inQuote = !inQuote + i++ + case inQuote: + buf = append(buf, c) + i++ + case c == ' ' || c == '\t' || c == '\r': + if len(buf) > 0 && pending < 0 { + pending = i + } + i++ + case c == '#' || c == ';': + goto end + default: + flush(i) + buf = append(buf, c) + i++ + } + } + if inQuote { + return "", 0, 0, 0, p.errorAt(p.line+lines, "unterminated quote") + } +end: + if n := bytes.IndexByte(buf, 0); n >= 0 { + // git stops reading the value at a NUL byte. + buf = buf[:n] + } + return string(buf), i, lines, open, nil +} diff --git a/platform.go b/platform.go new file mode 100644 index 0000000..2a26e15 --- /dev/null +++ b/platform.go @@ -0,0 +1,54 @@ +package gitconfig + +import ( + "errors" + "os" + "runtime" + "syscall" + "time" +) + +// openRegular opens a file for reading without blocking on a FIFO; the +// caller checks that it is a regular file. Windows has no FIFO to open by +// name. +func openRegular(path string) (*os.File, error) { + flag := os.O_RDONLY + if runtime.GOOS != "windows" { + flag |= syscall.O_NONBLOCK + } + return os.OpenFile(path, flag, 0) +} + +// Another process holding a file for a moment, as a concurrent writer or a +// reader (an editor, an antivirus) does, makes opening or replacing it fail +// on Windows. Such failures are retried for up to a second. +const retryFor = time.Second + +// Windows error codes for a file another process holds. +const ( + errorAccessDenied syscall.Errno = 5 + errorSharingViolation syscall.Errno = 32 + errorLockViolation syscall.Errno = 33 +) + +// transient reports whether err is a Windows failure to retry. +func transient(err error) bool { + return runtime.GOOS == "windows" && + (errors.Is(err, errorAccessDenied) || errors.Is(err, errorSharingViolation) || errors.Is(err, errorLockViolation)) +} + +// retryTransient calls fn until it succeeds, fails for another reason, or +// a second has passed. Only Windows refuses to open or replace a file +// another process holds: elsewhere fn is called once. +func retryTransient(fn func() error) error { + deadline := time.Now().Add(retryFor) + delay := time.Millisecond + for { + err := fn() + if err == nil || !transient(err) || time.Now().After(deadline) { + return err + } + time.Sleep(delay) + delay = min(2*delay, 50*time.Millisecond) + } +} diff --git a/update.go b/update.go new file mode 100644 index 0000000..6776545 --- /dev/null +++ b/update.go @@ -0,0 +1,123 @@ +package gitconfig + +import ( + "bytes" + "errors" + "io/fs" + "os" + "path/filepath" + "runtime" +) + +// maxSymlinks is how many symbolic links an update follows to the file it +// edits. +const maxSymlinks = 5 + +var errTooManyLinks = errors.New("too many levels of symbolic links") + +// updateFile edits the file at path under git's lock: see Env.UpdateFile. +func updateFile(path string, scope Scope, fn func(*File) error) (err error) { + target, err := followLinks(path) + if err != nil { + return err + } + + lockPath := target + ".lock" + lock, err := os.OpenFile(lockPath, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o666) + if err != nil { + if errors.Is(err, fs.ErrExist) { + return &FileError{Path: lockPath, Err: ErrLocked} + } + return &FileError{Path: lockPath, Err: err} + } + committed := false + defer func() { + if !committed { + lock.Close() + os.Remove(lockPath) + } + }() + + // Read under the lock: no update made since can be lost. + data, err := readConfigFile(target, maxLoadBytes) + exists := err == nil + switch { + case errors.Is(err, fs.ErrNotExist): + data = nil + case err != nil: + return &FileError{Path: path, Err: err} + } + p, err := parse(path, data) + if err != nil { + return &FileError{Path: path, Err: err} + } + f := &File{name: path, scope: scope, data: data, parsed: p} + + if err := callClosing(f, fn); err != nil { + return err + } + if bytes.Equal(f.data, data) { + return nil + } + + if _, err := lock.Write(f.data); err != nil { + return &FileError{Path: lockPath, Err: err} + } + if exists && runtime.GOOS != "windows" { + fi, err := os.Stat(target) + if err != nil { + return &FileError{Path: target, Err: err} + } + // Exactly the target's bits: chmod is not subject to the umask. + if err := lock.Chmod(fi.Mode().Perm()); err != nil { + return &FileError{Path: lockPath, Err: err} + } + } + if err := lock.Close(); err != nil { + return &FileError{Path: lockPath, Err: err} + } + if err := retryTransient(func() error { return os.Rename(lockPath, target) }); err != nil { + return &FileError{Path: target, Err: err} + } + committed = true + return nil +} + +// callClosing calls fn and closes f when fn returns or panics. +func callClosing(f *File, fn func(*File) error) error { + defer func() { f.closed = true }() + return fn(f) +} + +// followLinks returns the file path names once symbolic links are followed, +// as git does: up to maxSymlinks of them, a relative target resolved +// against the directory of the link. The file may not exist; if it does, it +// must be a regular file. +func followLinks(path string) (string, error) { + p := path + for n := 0; ; n++ { + fi, err := os.Lstat(p) + if errors.Is(err, fs.ErrNotExist) { + return p, nil + } + if err != nil { + return "", &FileError{Path: p, Err: err} + } + switch { + case fi.Mode().IsRegular(): + return p, nil + case fi.Mode()&fs.ModeSymlink == 0: + return "", &FileError{Path: p, Err: ErrNotRegular} + case n == maxSymlinks: + return "", &FileError{Path: path, Err: errTooManyLinks} + } + link, err := os.Readlink(p) + if err != nil { + return "", &FileError{Path: p, Err: err} + } + if !filepath.IsAbs(link) { + link = filepath.Join(filepath.Dir(p), link) + } + p = link + } +} diff --git a/value.go b/value.go new file mode 100644 index 0000000..222bc53 --- /dev/null +++ b/value.go @@ -0,0 +1,154 @@ +package gitconfig + +import ( + "errors" + "math" + "strconv" + "strings" +) + +// errInvalidUnit is the reason of a *ValueError for an integer that is not a +// number followed by an optional unit. +var errInvalidUnit = errors.New("invalid unit") + +// parseBool interprets a non-implicit value as a boolean. +func parseBool(v string) (bool, error) { + switch { + case v == "", equalFoldASCII(v, "false"), equalFoldASCII(v, "no"), equalFoldASCII(v, "off"): + return false, nil + case equalFoldASCII(v, "true"), equalFoldASCII(v, "yes"), equalFoldASCII(v, "on"): + return true, nil + } + n, err := parseInt(v) + if err != nil { + return false, err + } + if n < math.MinInt32 || n > math.MaxInt32 { + return false, strconv.ErrRange + } + return n != 0, nil +} + +// parseInt interprets a value as an integer: leading whitespace, an +// optional sign, a decimal, octal ("0" prefix) or hexadecimal ("0x" prefix) +// number, then an optional unit k, m or g, case-insensitive. +func parseInt(v string) (int64, error) { + s := strings.TrimLeft(v, " \t\n\v\f\r") + neg := false + if s != "" && (s[0] == '+' || s[0] == '-') { + neg = s[0] == '-' + s = s[1:] + } + + base := uint64(10) + switch { + case len(s) > 2 && s[0] == '0' && s[1]|0x20 == 'x' && digitValue(s[2]) < 16: + base = 16 + s = s[2:] + case len(s) > 0 && s[0] == '0': + base = 8 + } + + var mag uint64 + overflow := false + n := 0 + for ; n < len(s); n++ { + d := uint64(digitValue(s[n])) + if d >= base { + break + } + if mag > (math.MaxUint64-d)/base { + overflow = true + } else { + mag = mag*base + d + } + } + if n == 0 { + return 0, errInvalidUnit + } + + var unit uint64 = 1 + switch rest := s[n:]; { + case rest == "": + case len(rest) == 1 && rest[0]|0x20 == 'k': + unit = 1 << 10 + case len(rest) == 1 && rest[0]|0x20 == 'm': + unit = 1 << 20 + case len(rest) == 1 && rest[0]|0x20 == 'g': + unit = 1 << 30 + default: + return 0, errInvalidUnit + } + + // The magnitude of the number and of the result may reach 1<<63 for a + // negative value. + limit := uint64(math.MaxInt64) + if neg { + limit++ + } + if overflow || mag > limit || mag > limit/unit { + return 0, strconv.ErrRange + } + mag *= unit + if neg { + return int64(-mag), nil + } + return int64(mag), nil +} + +// digitValue returns the value of c as a digit up to base 36, or 36. +func digitValue(c byte) int { + switch { + case '0' <= c && c <= '9': + return int(c - '0') + case 'a' <= c|0x20 && c|0x20 <= 'z': + return int(c|0x20-'a') + 10 + } + return 36 +} + +// errPrefix and errUserHome are the reasons of a *ValueError for paths this +// package cannot expand. +var ( + errPrefix = errors.New("%(prefix)/ is not supported") + errNoHome = errors.New("home directory unknown") + errUserHome = errors.New("~user/ is not supported") +) + +// expandPath interprets a value as a path: "~" and "~/" are replaced by +// home. +func expandPath(v, home string) (string, error) { + switch { + case strings.HasPrefix(v, "%(prefix)/"): + return "", errPrefix + case v == "~" || strings.HasPrefix(v, "~/"): + if home == "" { + return "", errNoHome + } + return home + v[1:], nil + case strings.HasPrefix(v, "~"): + return "", errUserHome + } + return v, nil +} + +// equalFoldASCII reports whether s and t are equal, ignoring the case of +// ASCII letters only. +func equalFoldASCII(s, t string) bool { + if len(s) != len(t) { + return false + } + for i := 0; i < len(s); i++ { + a, b := s[i], t[i] + if 'A' <= a && a <= 'Z' { + a += 'a' - 'A' + } + if 'A' <= b && b <= 'Z' { + b += 'a' - 'A' + } + if a != b { + return false + } + } + return true +} From 74c4f677f7d380f117dd4e27dccad1b7bc042184 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Michael=20Mur=C3=A9?= Date: Fri, 9 Oct 2026 13:51:11 +0200 Subject: [PATCH 02/10] fix minor edge cases --- discover.go | 10 +++++++--- edit.go | 7 ++++--- env_test.go | 12 +++++++++++- file_test.go | 6 ++++++ load.go | 11 +++++++++-- update.go | 2 +- 6 files changed, 38 insertions(+), 10 deletions(-) diff --git a/discover.go b/discover.go index 3fefce6..d3c9a37 100644 --- a/discover.go +++ b/discover.go @@ -138,9 +138,13 @@ var errBogusParameters = errors.New("gitconfig: bogus format in GIT_CONFIG_PARAM // parseParameters parses GIT_CONFIG_PARAMETERS, where git passes its -c // options to the commands it runs: items separated by whitespace, each a // single-quoted key, then "=" and a single-quoted value, or "=" alone for -// an option without a value. A quote inside quotes is written '\” and an -// exclamation mark may be written '\!'. The older form of an item, a -// single-quoted "key=value", is accepted too. +// an option without a value. Inside a quoted string, a quote is written as +// a backslash and a quote between two quoted strings, and so may be an +// exclamation mark: +// +// 'e.f'='x'\''y' 'g.h'=''\!'z' +// +// The older form of an item, a single-quoted "key=value", is accepted too. func parseParameters(s string) ([]CommandEntry, error) { var entries []CommandEntry for s != "" { diff --git a/edit.go b/edit.go index 20455ef..75c1521 100644 --- a/edit.go +++ b/edit.go @@ -308,8 +308,8 @@ func (f *File) entryLineEnd(i int) int { // removed entries' lines. // // The region removed then starts after the previous entry's line, or right -// after the previous header (the rest of its line becomes a newline), and -// ends at the next header, its indentation included. +// after the previous header or a BOM (the rest of its line becomes a +// newline), and ends at the next header, its indentation included. func (f *File) unsetEntries(idx []int) []splice { removed := make(map[int]bool, len(idx)) for _, i := range idx { @@ -373,7 +373,8 @@ func (f *File) unsetEntry(i int, removed, trailing map[int]bool) splice { switch { case b < 0: if len(f.items) > 0 && f.items[0].kind == itemBOM { - start = f.items[0].end + // git ends the line after a BOM as after a header. + start, text = f.items[0].end, "\n" } case f.items[b].kind == itemEntry: start = f.lineEnd(b) diff --git a/env_test.go b/env_test.go index 37f397d..c4f3ce1 100644 --- a/env_test.go +++ b/env_test.go @@ -158,6 +158,16 @@ func TestEnvLoad(t *testing.T) { assert.Empty(t, slices.Collect(c.All())) }) + t.Run("file in place of a directory is missing", func(t *testing.T) { + // A file ~/.config/git hides the XDG file, as for git. + dir := tempDir(t) + writeFile(t, filepath.Join(dir, "git"), "") + env := gitconfig.Env{GlobalConfig: []string{filepath.Join(dir, "git", "config")}} + c, err := env.Load() + require.NoError(t, err) + assert.Empty(t, slices.Collect(c.All())) + }) + t.Run("outside a repository", func(t *testing.T) { env := fullEnv(t) env.GitDir = "" @@ -297,7 +307,7 @@ func TestEnvIncludes(t *testing.T) { t.Run("missing file ignored", func(t *testing.T) { _, c, err := load(t, map[string]string{ - "main": "[include]\n\tpath = missing\n\tpath = ~/missing\n[a]\n\tk = v\n", + "main": "[include]\n\tpath = missing\n\tpath = ~/missing\n\tpath = main/missing\n[a]\n\tk = v\n", }) require.NoError(t, err) assert.Equal(t, "v", c.Value("a.k", "")) diff --git a/file_test.go b/file_test.go index 1599747..1415a54 100644 --- a/file_test.go +++ b/file_test.go @@ -491,6 +491,12 @@ var unsetCases = []editCase{ {"entry before any header kept", "k = v\n[a]\n\tj = w\n", edits(unset("a.j")), "k = v\n"}, + {"only key after a BOM", + "\xef\xbb\xbf[a]\n\tk = v\n", edits(unset("a.k")), + "\xef\xbb\xbf\n"}, + {"section after a BOM removed", + "\xef\xbb\xbf [a]\r\n\tk = v\r\n[b]\r\n\tx = y\r\n", edits(unset("a.k")), + "\xef\xbb\xbf\n[b]\r\n\tx = y\r\n"}, // E5: the emptied section is removed unless a comment lies between // the previous entry or header and the next section. diff --git a/load.go b/load.go index d08a281..ac7a002 100644 --- a/load.go +++ b/load.go @@ -10,6 +10,7 @@ import ( "runtime" "slices" "strings" + "syscall" ) // Limits of one load (X3): git's include depth, and bounds on the work a @@ -61,7 +62,7 @@ func (r *repo) worktreeConfig() string { // in the repository's config. func (r *repo) worktreeConfigEnabled() (bool, error) { data, err := readConfigFile(r.localConfig(), maxLoadBytes) - if errors.Is(err, fs.ErrNotExist) { + if isMissing(err) { return false, nil } if err != nil { @@ -156,6 +157,12 @@ func readConfigFile(path string, limit int64) ([]byte, error) { return data, err } +// isMissing reports whether err means that a file does not exist: also +// when a directory of its path is a file, as git takes it. +func isMissing(err error) bool { + return errors.Is(err, fs.ErrNotExist) || errors.Is(err, syscall.ENOTDIR) +} + // loader loads files into a list of entries, following includes, within // the limits of one load. type loader struct { @@ -202,7 +209,7 @@ func (l *loader) load(path string, scope Scope, depth int) error { return &FileError{Path: path, Err: ErrLoadLimit} } data, err := readConfigFile(path, maxLoadBytes-l.bytes) - if errors.Is(err, fs.ErrNotExist) { + if isMissing(err) { return nil } if err != nil { diff --git a/update.go b/update.go index 6776545..9954819 100644 --- a/update.go +++ b/update.go @@ -42,7 +42,7 @@ func updateFile(path string, scope Scope, fn func(*File) error) (err error) { data, err := readConfigFile(target, maxLoadBytes) exists := err == nil switch { - case errors.Is(err, fs.ErrNotExist): + case isMissing(err): data = nil case err != nil: return &FileError{Path: path, Err: err} From 9f097cd6b40f09dd20e5e00b92bd6ded3ca0f281 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Michael=20Mur=C3=A9?= Date: Fri, 9 Oct 2026 14:32:06 +0200 Subject: [PATCH 03/10] performance optimisation with benchspotter as backend --- .benchspotter/.gitignore | 1 + ...32\227\341\232\227BenchmarkConfig.profile" | Bin 0 -> 26586 bytes ...2\227BenchmarkEnv\341\232\213Load.profile" | Bin 0 -> 15082 bytes ...hmarkEnv\341\232\213LoadProtected.profile" | Bin 0 -> 13363 bytes ...enchmarkEnv\341\232\213UpdateFile.profile" | Bin 0 -> 14578 bytes ...nv\341\232\213UpdateFileUnchanged.profile" | Bin 0 -> 14184 bytes ...\232\227\341\232\227BenchmarkFile.profile" | Bin 0 -> 37358 bytes ...232\227\341\232\227BenchmarkParse.profile" | Bin 0 -> 50087 bytes .../escape.txt | 4511 +++++++++++++++++ .../inline.txt | 777 +++ ...32\227\341\232\227BenchmarkConfig.profile" | Bin 0 -> 3211 bytes ...2\227BenchmarkEnv\341\232\213Load.profile" | Bin 0 -> 6471 bytes ...hmarkEnv\341\232\213LoadProtected.profile" | Bin 0 -> 6338 bytes ...enchmarkEnv\341\232\213UpdateFile.profile" | Bin 0 -> 5739 bytes ...nv\341\232\213UpdateFileUnchanged.profile" | Bin 0 -> 3951 bytes ...\232\227\341\232\227BenchmarkFile.profile" | Bin 0 -> 9901 bytes ...232\227\341\232\227BenchmarkParse.profile" | Bin 0 -> 6255 bytes .../meta.json | 25 + .../results.bench | 515 ++ ...232\227\341\232\227BenchmarkProbe.profile" | Bin 0 -> 48904 bytes .../meta.json | 19 + .../results.bench | 59 + ...232\227\341\232\227BenchmarkProbe.profile" | Bin 0 -> 61142 bytes .../git.diff | 144 + .../meta.json | 19 + .../results.bench | 59 + edit.go | 54 +- load.go | 13 +- 28 files changed, 6175 insertions(+), 21 deletions(-) create mode 100644 .benchspotter/.gitignore create mode 100644 ".benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/cpu/\341\232\227\341\232\227BenchmarkConfig.profile" create mode 100644 ".benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/cpu/\341\232\227\341\232\227BenchmarkEnv\341\232\213Load.profile" create mode 100644 ".benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/cpu/\341\232\227\341\232\227BenchmarkEnv\341\232\213LoadProtected.profile" create mode 100644 ".benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/cpu/\341\232\227\341\232\227BenchmarkEnv\341\232\213UpdateFile.profile" create mode 100644 ".benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/cpu/\341\232\227\341\232\227BenchmarkEnv\341\232\213UpdateFileUnchanged.profile" create mode 100644 ".benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/cpu/\341\232\227\341\232\227BenchmarkFile.profile" create mode 100644 ".benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/cpu/\341\232\227\341\232\227BenchmarkParse.profile" create mode 100644 .benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/escape.txt create mode 100644 .benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/inline.txt create mode 100644 ".benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/mem/\341\232\227\341\232\227BenchmarkConfig.profile" create mode 100644 ".benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/mem/\341\232\227\341\232\227BenchmarkEnv\341\232\213Load.profile" create mode 100644 ".benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/mem/\341\232\227\341\232\227BenchmarkEnv\341\232\213LoadProtected.profile" create mode 100644 ".benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/mem/\341\232\227\341\232\227BenchmarkEnv\341\232\213UpdateFile.profile" create mode 100644 ".benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/mem/\341\232\227\341\232\227BenchmarkEnv\341\232\213UpdateFileUnchanged.profile" create mode 100644 ".benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/mem/\341\232\227\341\232\227BenchmarkFile.profile" create mode 100644 ".benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/mem/\341\232\227\341\232\227BenchmarkParse.profile" create mode 100644 .benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/meta.json create mode 100644 .benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/results.bench create mode 100644 ".benchspotter/sessions/01a12097-6c1b-7531-9b08-41118f50760f/cpu/\341\232\227\341\232\227BenchmarkProbe.profile" create mode 100644 .benchspotter/sessions/01a12097-6c1b-7531-9b08-41118f50760f/meta.json create mode 100644 .benchspotter/sessions/01a12097-6c1b-7531-9b08-41118f50760f/results.bench create mode 100644 ".benchspotter/sessions/01a120a2-f2e8-7ce8-a8ac-b6a8bebf1cbb/cpu/\341\232\227\341\232\227BenchmarkProbe.profile" create mode 100644 .benchspotter/sessions/01a120a2-f2e8-7ce8-a8ac-b6a8bebf1cbb/git.diff create mode 100644 .benchspotter/sessions/01a120a2-f2e8-7ce8-a8ac-b6a8bebf1cbb/meta.json create mode 100644 .benchspotter/sessions/01a120a2-f2e8-7ce8-a8ac-b6a8bebf1cbb/results.bench diff --git a/.benchspotter/.gitignore b/.benchspotter/.gitignore new file mode 100644 index 0000000..371b39b --- /dev/null +++ b/.benchspotter/.gitignore @@ -0,0 +1 @@ +/recall/ \ No newline at end of file diff --git "a/.benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/cpu/\341\232\227\341\232\227BenchmarkConfig.profile" "b/.benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/cpu/\341\232\227\341\232\227BenchmarkConfig.profile" new file mode 100644 index 0000000000000000000000000000000000000000..0901a3affc954f1c5f162952f230e9df75f4f33d GIT binary patch literal 26586 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 Y`>UCgsBhfUGYS#`H|Q+W9tr7x0REr+`2YX_ literal 0 HcmV?d00001 diff --git "a/.benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/cpu/\341\232\227\341\232\227BenchmarkEnv\341\232\213UpdateFile.profile" "b/.benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/cpu/\341\232\227\341\232\227BenchmarkEnv\341\232\213UpdateFile.profile" new file mode 100644 index 0000000000000000000000000000000000000000..b9f641ed85eb4fd60cb2d6dde680b5d3621053b0 GIT binary patch literal 14578 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 literal 0 HcmV?d00001 diff --git "a/.benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/cpu/\341\232\227\341\232\227BenchmarkEnv\341\232\213UpdateFileUnchanged.profile" "b/.benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/cpu/\341\232\227\341\232\227BenchmarkEnv\341\232\213UpdateFileUnchanged.profile" new file mode 100644 index 0000000000000000000000000000000000000000..78d1b1d2316f4add347263b74969347d9af8ec71 GIT binary patch literal 14184 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

?0Qp4pk*XJHmzeJ$3Fm;QQ@ z#iso4i}iKkdxy&K<(W3UG@o(tssMM^5BJ8UWd~}4%&uQ%S&j~ZQwF_Un8%dZ4~{Ms z+rp>i4Q|e7`z{m!L3(lx-~yxRq|G_~UM%K}7I-a8avkQsq+jwA;#xBULHfY!g=^~I zJ+$L6NR!MVOl@oXErXeh1goS!ZY{(yAZ3t(v@T(L`fH_yl8PCP>Y{xUiuokGAuIWI)pVuTVuk+NTjhitnjDB3RU1@!eO-QGHdX}$);h<(C!uL zcQ*GC&&Y=WN5LH#sitqv*W?dbz=E>pIz*2dy%x)|GqTpUF_ zPs?bol#g_P(xrHx%gp9SRJT9q2~Pdj_;apJ^lQ1+uOpQ!eU>+r({O{b%&ZlJp2dki zJytQJSI?cbjVMWd0w&f)qyaOv<+Ya6Oa*o!?c3SGW7tby&Wx>bkHOxIZ-!Z;?Yap$ z0n;HB?|cBRDXofu8QH%gFT+U*mQ9G)1n~ z%KZfj{5~~9Av(79y)n#3?cOrS3g1dTnc9&u6N)u}g>sjFnkcfK+Luwd`g#f#sIY1u zo^=5{b`U55rej!wgs#5!-ikGq(eI+vcvabd5d!`VgA_&k&geQujnQEs$p`GB;*>}` zvcTG7ofzde$V#~#XsI&yeX7s5R`(ln!Bc^Xe9J4lDr#Teg<5JAki&w-c znl=p7SQp>6)bCf^$oMDwl@zY8+jxL_F1Sd|@UXKNyz6&iXl$^1fHPiKTYHY_9Flgy zb=dE^YrJc!=kpZlo3gSHqNEtaXhw*yuaDbRztrn$I*u2`cqKo9r*y#4Ur-s!LwMzL zK|SZIG0(j+-ZVk*=Ni1LKli7l$4Q_3Sure@yBr&>-Q>?zV29J(?eECo`8*6mmco$p z`(Pz!pZ9~4I2}1lHL<`hw~tESeO4n)#}B8!AKvPlwtJr}wt3~lS~~P|)=Jpj`yz!} ao(nS%YUgq~(4L-=k*HrgTI#zXA^jgNW}F=W literal 0 HcmV?d00001 diff --git "a/.benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/cpu/\341\232\227\341\232\227BenchmarkFile.profile" "b/.benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/cpu/\341\232\227\341\232\227BenchmarkFile.profile" new file mode 100644 index 0000000000000000000000000000000000000000..86bbd5d595adaeb9cab684d4b01262a9f0412a66 GIT binary patch literal 37358 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±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 O{{{dy$ND9ZHUR)4G#Y^b literal 0 HcmV?d00001 diff --git "a/.benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/cpu/\341\232\227\341\232\227BenchmarkParse.profile" "b/.benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/cpu/\341\232\227\341\232\227BenchmarkParse.profile" new file mode 100644 index 0000000000000000000000000000000000000000..1b9a9be65b03fa3d899cfb178546f77658c0ba16 GIT binary patch literal 50087 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ɏY2Bb-N44sP)|Rx;p|T^Mh~Lx$MKt|rSheLxOO?^f+UdpmbT5g z7$3T=cSp{wW!kZbL@kh6;lLqny3wh}maAv@*BBq(B@dc^D$ARouJG%JYSNC-bpUBQ zNYNOQ9FYE%QZGD15<1NlUpp93)-B>HN%IkTTp4dg|D=Ntkgzf(`Je7{0HW05n0L4G zKltcAGU@iRx!?KB-c4XqLQI)$?adECGa=R|PLec{Ko>pq@0Wt8B9i|kvD}R{&Q5O1 zDBwwldE;r?F3WBMw_ir;UbJ6V&Qqi%qkn9uQ=NWNL8@0;@;n)T59d;Gh|D^zBs>}a zKzbGc;T*Q|46kadSbT9q^?CLax8(j+SYOJvi=p3LGtp+R-&hSdu=UJ$ z6TQFRLWUnXuiHXQOEZQ8yd81Ujoa+@AvW3=r~0phtPjNe0p@WQt2 zh~LbbLl*fWzHF8cAUIfz5@Pa8nQ%w&3u%Q<@s%2W3jeyTAG-qmXaD@{QI90F|M|uzMd^G&K(N@2GFC9@ z6lC^W-o|>OFVjZVgY4q!K8b%g^EUj<71l+P71>=N%8qZ(#0P2hSa88{)P;z>gxu_q z0xC%}9sEM^_Rf;x{nXOR(N$ULD#@Vy8kc6K`tf z!qYL9$$GIalh~>=InpAV1wyXA7)*N(50+X`Txn6IAMgA$&4G4~-n9+RmNYzR4>9uD zCnTd;Im6EL+UF?>K5-*T+Abq`8qh`nfz-%p2oiux`FW;fUFHg-JPEx{&$Wb2HXh!S z)GDN*thPGauNh{v-?ynwj`(=3S%F;2(%$ymt@9@_B3Xu*5Fv2iWCOe29(Z{^;2*Hg zEg??UQvO?lLuOB8G(q$Q)>I2qOUi(5NbVZ<$Amg|9qBC!+^mINcu-!P-0|G=W2)fy zV&&u|YpO`GJWil1ee*7|*l4)oPE!Q=_q2S0Ppvr6GIx_n2c{<`BWy2vOikmv9K(7( z(2z#Z`yOqdlcmDA67BmD<58A1;6<#UT|>=i`55nw!$F-{ohYs(@~Aj(#pjOatxxwT z2-xWj878V{F@r05A;f=`snv7}5ov8$#ccb;>j6(l1#bMeH=MQxh371D7k1A2w}ppV z%M+aR7i>2Ug<6G3zZ=In*O~f|X)9UdFEIMQsXX3|d~5h6^{|_a{1bbr745~v&fe@* z;KSX*+I)X`nW?7sM#xSs${^YzUw`9fpjzYFr*R8(2oPgKtL1o)f2-QyZ%HlfGkAt{2M6OK zerNbe4kZtqZ>aKQVCduQM+uNu$_DRCBb`(AC-rtg-rvdyv?DcZ`?@|6~%g0Yz~ zS$f5Fy27t$ZHoK|6m%>*j?_ug=;>KnR;lk@Y-!Z;9pduI=}h z0x}XA*mBKs$by>+@D9lal>gMx;m?4}>Aac*&t211!rRGLjS7ou)0D&ZK=;Qkwq&;jki@PY5M}4w^x#h`E zxQ?wQPUpucS_NZEYHgLzC~U9d>CPWv!_RpUA1okRL!!mtUp+^sMz0dbGSX);UG^;a zX)tqcN{}XyOnAx?4Qhy<=Ljliy1ZA~Ovu=9+%kV7blP34_Fp`!Cj&{BzESGlW)fOl z=eNPoU+WCrIWkfyRsQ1XHMZj66~<)xQT9oJaYuk3FPO#krLCp3%FMq#&~=)R`2}Qu z;cXpmL;s@I^owEg62QnQFV_ynYY%w$&(r;hwS4MNBN)%x%i|n$@w4qksT+3g`qCXJ zJ>V%sbMLLvGq!bxoo85-nu=h;J3A!(!7+)NdEaSI@w1hFwISGsV`r53({pSM;5`%j zh(9AHuw;BJ)UQndj>XSM0vE`Tq^mCHa{2A;)X#dQ;1})u5k+>-R|V6e-QQ^?S;cYP ziV>0mvPedEx@uy>d$jr#4E^HBBil{}+G|w? zAM$@t-1QvR+~!1nvz{Nj%4!2+L*zN>nQDvOEphle!PIw0oj%cRaZC6L%E?~mco#p7 z()UCR?rJ3bH@FOK!Q>DWN&?7Bzj73aKp#ALedzU}ge$pLc^#XTCGFU3^t=C{C1+Q9 zLAXvA6!gn1B1LUGp|a;-@y2W2|6J-~Y&PWLQT@dFn!L1-;PUM0#ncE{A-79v6N{-u zaYIOk1{_j1cm3`75dNM|S_Wyi$th zFm9C2h11u%^+XG16;mEOkeZxgv z;}{!)?Wb1s*||GDmy1-pT;q4{f)KtE?&R_77l$UK*X)GL-gJKT?VL)(fip=kUcay~ z%FbmZnB2Q-2YO8-#2(3)cmNKmXc@`AuKWx^YFJcMbGId z5!$g5jzZqZAgY2lBc~>4fHD&lmPd z0c@2WQSYe=z&Mf8a27ilsC8i(>FWV|#~RSYpi$aMx#3<@nA)IN;wA!*GaI zkE?2&i1187)06J)aApp8*Nn$-({!h*?+@L=sMXt*ox@hll8YMRkC24f)eNCT9v;YIO$>9a=3}23bK0px8`nTDyxokst`UWKbY%AP z^7q8WO9_4E;1}c%D@gbMY!+fwiSMHC@|e?^^+SN^*UZ!5Ag?ca<9;O2K_%K#33V7ZDq0p~d=TqN5mmC}--`s{iw#L*??W`0QXN)h5xHs}Eh|=LT zLHhiHZ#-*4=$_FzC}C#v;x#~~v;LXDX{tl{v#Ldg23pf#;jZS=1}RG8Zm{?PIv1sk z5)9}fvX!A>C67TFIYIEyNyx;UX$}#a-ANl0HkQWDP8tuQaB6K}h+0Crn==bKuavmN zTlxtF=S^ThSAu>jZ$Q3*@Whev^1&%%-6o8bbRWTlrAr$1M>=%zbr9#1?=$<1q;b@i zt#0*%8-R}7Jk&A~SlEPvzVS||F&(e}zV^@O`~B#@_O4WHWT(oxd7PTL;yOi~gvlf# zoOv}dNDgQt9cZ!Y4S)W`%euJ|J*3uoy+TykwzR`$cmTvxI=*~agYxqsIk|zKcs$wegmFcPoq zHbXNxVdgyuv)Y5Sw{CAn$4rkyvkv0E_XR)A=XJ6AZx&(ly%kE%{g$njX}}UU#2f%u zugjlaVfJqs>5mqncaOFCEyl#M$+ip-gQht)m&pdxuZwsBlWEP8FFYE?9(1!}*DU(T zZ`OwW;?$ewH3d}NcrdH|hh6d?8Uvn|FM?42aS{yndQgE5L`?7dfS>m1~Ix4+y9;FwPwNC?>)LUDhbb zC-Sd3-b;fJZV|0%34*R6Vj9v4^H{1uxdRyoywIu0R>%`luQFN@JLL#pyOI7nTae&mdBS(+F?Q)%?EP6f`tt5#m*_QENG#nj+}n#aD1_%u@y0S~#T0(%o&kg_A(P+N z`|fv^!#7{YczNcH`FduJM2G3o-GBlKK$zv~{|O_ut%iu*=m`IAi3sWl6v`^^Wdw!% z6nk^>k+fo^uP;#E%4&Nf2rk;6{=N}5-hHWn~fj)iaLX^CR%h}=&b@ha|S6|eP~NqxYg+#Y8x3d{fV zFcIYEz#8PntZmgb9dMV{=N@S9b^IB~$GGI(^D@9~m)jg8T4!i6decYhJ)4m`;-?#d zd|JqPEI3~d$AYDuOk;0$mqYM45R>gPjNx)Mzvs>L7FsiRRMPuwYHE9V?~lsRKi^#! zX5b2KfQSb%=@wX<)77*<*6e7hs97B&fXQmTmdPi|JxoA%$Bi9-VG$YhE`gHQ(d82v zZibKHh1q`K_jhXTZSy;l!3Vv+7a({tj1i5?=GL{%_-`$fygYNqGT>Kj`P2PjB$Z9$ z<7^8~j;R?-6U;U(utV3AkQyCMVzWw&?h0k8<-_Ae*y#sqmo;zWmCgPuXWIg`(8+5X zpC8xgovvV?5k#Db`-rXfwJ2sP6zp~J(S~}j0^z(?UORm523EYA6Mb%5dAIw~VyHdjBgWe+G z>xo(qAJ8zVzF;?3v}^3{Uvv6eZHfd=kv80e76Q^}4o8!C`Q?FXqns=+exJ$N%so~Q zrZ3~X{l_A;;uRUMb*34C#W=pKi$ZFXbN}Pk%jr<|@W^P1;$xAX+(Zq00T@co6*0j{ z?!Sm^a;^iO`@w0Zx$@0XLd+hODbn$>=KqiWVV*3=z1CgpzV^r%bM}g(bef@Fw^btR z@bYXOvyWc@hLvRO2Xs_@lWSl3a|g9D_V7#?tJ;`7Kv}B$){e22>m9yyEZQ8)7&@(& zd*WEzt=RX5<9o1(s8lm5kT7js>YjtGaUvdi(t7vpQP2GrV%a9fI6L~s;WO-|OHDR; zRv1(7kX+D@mm4MqbaYL39+kWX?ckvu6SXR!Ss{L)pQ&mO`aHHh<^_wD?SUTQ+ik9> zeGW^~E`~+$o25Y50{j+thCQ7+LOR7m4WRj6z;CIC%#Pmnr>pJ%5VwMA_2GW}hecr0 zHA6<@K2`ix%3^o41RH68;q{)4k3Pv9Tj0F^H@zp~zdk`vCz$`TnB7t&TST8rjBz`~OvqLoV>ePkf&E8wroo7Vuj_%FB+ zXm+p1CgOo?p~XZe!}88}5$K9kPbVdjKhB!Q`~@n^$LR7J?@+(Q zBz>H2jeuO;;BmsV92DBVPuNYG-#D=nef4g8;{_bQyiM%X(OmiLHA(?KVfMdiZH45z z=o<=e7L*m*!NWU};YDvOQhP4d&T|97OFL(T~?QoR6O5$6khiFR62!Od)%oXCnhs=?zbx+KcexQH9{OJi4F3OYnOc6$>0mF=2W6IbNEMF z8Z(F2TH~4azXS;h+uOj19pQRkKepVTK};>UR zVmm`km?e{b%L9*u^ReTfE+KtwwQ_Bk9Q8B1-x%w(f8UN;rw+>kbVutuDZ(8qlgtHl zjufZy!3#b1>#d!zUb+oxPeNTxsk-)q0Os|O+*Eh@Z4(m-@vN6gYaZu?V`*lLcYahD zL~qCB9x8VCQA}`Wue%UAhJLq%qoAI36JtlImb>#FDcLMA$(6|=aLa#2$M!QDk0CdG zgBZTB74Z3ydtHtP^-{9_hT`Sew$(=mU852Zw}0E|IE6rs*5RqwZZ3w&;s}eWxjjHZ zCvI@hpBF z)1$r<;cd0K?FQG&X&Kl*33?4Dek@%?pfq@L0dXxLTSuU!A{0jgPEpL>Do(U+=0xum z%coOXKP_)<@y?5bHj@1$nKjf;OL$vX^YEk{D#%CV6%v?bdex5iyMV}Z-5M%NaW&kM z=AC4jyl;2PQ8xi2T{q2IW}vvuhm?(9=HuWg4ZRr7B%eGIOLr)JbwZPxGHH^d_T(Ea z(wMpggs^q-^|R2b`qsVsF)2;<$Oj1!KXAoPo=*;@rF82=dk{wknH(auCSfCeP6f5j z&pEQk_jkAGI;ZwW5RslL_@s_96*IUyJLw4gA7s*3we#qiddr=g=6Jf@qG;)?Sasu2A6!VpP0itsMk;}zxezEP}()k>9D0{cj?#ko7Wp2A-%6u9P;g* zQW^kj&YR!270V(UsiPijrYe*o;$4BK1clsRQkpo6xoMajLl^PcaUL}|c(PPdAx%l0BN;oC+T{-%VQ;mR-l6~s^m%S&77S&=RJ?F|R$U=Qp;NWxBVdxHYX zx6TVJN&9aV&@hFCft&{v^PoO_<8K8sFDsFr&jK2VWOV8i%^9-jA$ry0*+rnC+YNK(cK;v#RY;Z90cLGBra*hQp2*<==`8tFYxCWESj zgd?5~svKB(kRxuwdK6nQ2GtInJPd&!6c`IX*o(PddD%$>Rdv}bN48GuiOp~*OSeyw zSao6=h_PN=8H6>`tOXuB(kaR>WW8r_WEJa4aG_6$fi=i4ADSeQ*Cf0z)X;@b>D8A0zezumD(f5e~hi0c?SMpVk~dk-1EGrvt#V%OBx& z)NuWjTty%}UoM!H~SNPvPZjXGE=-f&{G zsb=r8W3xTU#nsNoOzxmWjsgA$PJWYEVitWWQ^#8XM>%0;Ue_s4yE6*=K_dlWa~#<9!-H)8o#s zqLcPrKMJq~67F?VU<;a~x7wOEY@hv}gQ$Oa;u}hIdA0d1Dq%<@o>a6?x4Z8V zBp!UIqA~x|6sa^{);;3L^=~|R0HNUuhTIYdK=Q+O3F zAcvp_yB0leI=%dt^%y`sSZW@SsH~PWoTV0!>O4QzWuBujwZ5&ApVa5XUyum$3ddvP zCJ<^%d_{Qve$%vWUZP#GTD&wjL#xBr1>Vc3A9F}^64dt3Es!?*Z)~q7DP=dZBDsSa zxq7A+Hr~q>y~}63TXGc%JEWB|E_U79b*xq<1%L4`TYhQ7_@AgQZwAm$Ws8!9BS;SAe zC;(+w(t)&%p+3TY6@-WJMw2}2A#M3?U=Jtmd6}l9l;S%8G)6i5kMU|J7>MJ}gz|#| zo80mJ#e%NG$OMDYawkgE2WXca97`2;mcsw@h(HjZ_}pG-@X-EwTU%1&QZ9(es^om( z0ZfR(bJmx_aL}b%31y^5@UorA<&opjt|Y{y?{Bz4Cw95Jd~n?S%?W{gx)_MjAZd4o z(@X0!gKyopcY)KtHJJRf_=^=B5M_qcW8LV}1& zUcAi7-^~=vxAzkN-Z;`9j+e0a`wAiX*>I~lLD(No#q@Uut% z7Y99tXj+0It??C7)xe7=;rf_RRu(iowi1PxppCN}-FA-kitu=5pGj?KRj*J%^IPu} zOm0X6=%CMa(-gFGmh4L^o29Hr-cdUBQDQI$j2lgKBct8zPM37bWb%Hj@;RM9xc_hS z#^!kpajT?CSyF$WbYzc5-i97#o(FhWH}2~v5<#|{`95)W&-_XpEeRx_zfM&$TiW`H z%5G-vp9WYt%^JT@L#gqL&szP@M85M5#`$Y{E~9uv8R4#;#(DX86-@l!jqb*Ub3AX2 zX;AP?k#FOD=tdlQzHJKvJe2m&S2bsKw^OnvBnbI;y$kWFI*Eb))r9!(&-!l}C9EHE zi0h$%PzT|RP|YDL&^J((%JZk|{Udgr^_Ksj-|fv{)5st;o>pyjs4B}rprhvP-g^pW z#LP23G0e5~C%axGz`XfK?sT$0chr)V72K4&zs`yfmr93>MQ(4^W{Mt*8YwOq#}I0G z6WA3yxwBps!p+P91f%oo8U#9+=6-G470fhl)5E5CjxxUAxbU>3iM0cX*5dg90fz`< z*Y9=BXe0J^@El5byTdn5Lv%)ByOJz$q~961l2A;ghKO^!dz--=M-Yd23HdraX^}q| zFDBM|eeE@56IMOIE1kDAqFzDCf1@;^IEG#`s2y-~wa`zE?&S!fJTkUT-)|;(>!I2G z)P&K&KcZ`=`d9E0qMOIFe6IFdQhM0QPsO@K4J7=h$3C8lL8jh?`O}7Y@UeZ)XM8x7 zh@yOEbwg7VOn&>zJV+wutOt>?@#-;Om*OgT(3u*S>-$T*iT3n+k5qMnW68^Jn0$34 z^b(*36(!O#wR>Q$hF(Fi4)xd!%N&)d^Q}HXSN1m-dI{VxHH3Tn?GP$&p=juP*gLQS zZK7a8j>kJnDZg9!6gP;d+_aBt(Q{htxB<%K1Du+f{47?YtII`40#heoj^W(jgcec! zl%gSW1q(X^!kY zP>ZwJ`mW!7y@>C&5Z&x@iYKCQ$RpoH@8g}oZ{KHpp`Rfv8|fhWJ!{)y+16!ppUSD|61kvhZuTk$nDp!$#`lO zYU|4E_ck`)Y)D<-$ly;6bJ8!qG%YQHm-~4J-SV5#sbFSb;@1=%QU-sU<6NGa>wl~{ zH^O4{XkN~+bj^tA$(twrzGvj~EE^rI8Z3AS?(QDkA-KD{ySv*4*WeC;#ob+lySr^5z@ouj-hS`Lo|)O6 zIj3j3s_wnj_QAaZ@I=Z@6KhiQe0ok3%!jL09Vl*w8sNk}-xN~iRs-#lDJ)$ps{{4k zA0y&>O*&(Qvp1+W=tUxoB}`1=^OevXEc#KfnLqxVAox&0_e)Qk0Ld~dihvIA*0f&V z)Xx*p-};%b1Lr975RIC2?G$n&M2U z&R6FkI@TqDy3j?6Q;TL)amVOL__QS#`|>CVZ7&O9MXKdgCJpYgD^1Lnk2E!p?My8C zTNpMxP*tmfP!eT|&tWYYL3(L3nNT+x&7OYRu!HpD#53jsQz1_b*?a{FdU)|>4{QaA zdcTTlP_nG4q?tiLoJ#OO6v#R07xJ*hU3euz@4HD-OskQ6`kM|QFrLBXI{*%d^onOh zn*yUs7b+R>e5%o$JN#@TM!sz~?RgTWA$Z}3E#&%3ox8H%5AHrf4fth+(ZvgCT50*M zw|8VLgiz!5uckUS5UCrJ3-7RptxnrnC4=tO>N#YXL64_|_VYkg5Lh@NCa>0!9MXYRpyYDV3F~X*foS$jGew6NiB?Xi) z_*t=x8wnu4b0BJ{^sd`iOyD0*Gw5xeU(O(pR6JWIC&5)|+#chwgF|IxZO%|hR6s5C9?bZ+KP_(I z+A3_^5~1_q_q8gkmNu6%rMGH}x-b)+Z>pa*mrJ3fL|h_czA#aDSLE!F;~{&y1ld^h z=P^992N4_^V+fZDEb~=F$!S-CE9(R-fk=Yo{iLE54LFdaFFhx#=0lc70s2m>ZjF-$ zIPezAyTZma(Jj*z&_$PpkMGhJL(>!{p|&zb8MoNKZAU@wnzGe*fvY*cvr-NQGsWP$ zCucT9Oz*&N0gJMPFa$Tpg&Z72Tske5;ey<%k-RGucE z)TK09v(eP-el^l4A0*NMEL63jsNBYz63cd2CU*= zhQx3yQYJ~0I%ySBrJ4%=@|qOG`u9&1+tGYHVLM;|t#YepH4*CDP04NAQXZO6agpTe z0ws$a#en!()K|gkB34}vpxE!#w|cq7d+u`ZFiDH(h$DCXaia+^hD2BH(jp%Afx6Dw zeD9e=b)L9t&3?kz77-*|)XRuvbEN?AuXM^7hNajuo(z%JNwQ=cc~L@WMt&>z=ZKS`Izv!`hNg{fr3MlkC{!Liobi@HzFHXYZU&{G~aAA`jPB9|K9u+7q=n1{dyJ3J+pX+bwTbiE${c2Is@w@b*rU z@{dUDc1`vLlM)OeiFHE3>V7!-<`Al2K?Z#M%iHYi_*sso@7pTVgK+nYv z-_doX=+cdS*BsN?X$o%%cwR*0qDOA61jo)=Pe>6ssDMy=el4vLLQZ~T>19^tP%h8@ zv$W{v#-0|E^WSvR#Kh~++%8Q%1kRS*93rj+NDawQ!sKht^K3uzZIk$<1IEWfjx?Gr zzYudNE9q3tHgx?%%h#UojAG9HPHCy}Cip^#V5Bl%rGUnP>9>X~frk07nAJyBay08$Kl8ZuLM}ZCYE!d0T6eUo2!HLObrC-f#Ya}MP7q?amHldn zzr*$qsktih?x0w!!22oeO&P~S(8|G5evK!*!^%E4ajA6Q>%}Giu>f0-oiRHi1fm>c z`WYEI*~A`fF;JqJ#o|prXF_J=NEz3wOR`GjBYl>luI$?Xa-N6PF>LXD;QLxhk#^?K z7jDE}Ll5Fm(djDTY$XfbdzdcGW}3=tGxUKHq;6)rs)x#${7zRW+f%xMlDDXQc~)r= zhI1`rP3`f&e7xl5Kf8NnWJHjS)K!l(shHaJBidx5U+Y$v{1;&2nAU(r(>!dpjU34| z9;lv)zYK2S>Z)u$(1vOTL+;EUeXqyr7AXmJFC${SYVuhKZR=G-U&vAk><6UaSmX*N zD>{YmHVc!W{56{&xSn0Wf#VzTJQ{&@&-K^UMDzyG7|vR~$ryOF{SU$3FBTR9IShVw z7iP(dlmq9V3&nO2{f#B_N4FTa zXq{I#XqwIKgs0ZxB4;DdB5Ly^_H?MEvJ02euP&rj;K)G@m?Gi{a9EG9maRSKKwqoG z4jJNfw%Lc?XCjq(idLdP{xs83s8$2x%jlS$I9*KC5pQ$F0*PvfK`U$Co*`yFmN`r? zJt{~l3yCJ17W@RAk2hw|YHY+0j)lx>-qLqTEi7h9^9Wn7+E@(WGIYL8;x{IJPGq1O z+txuQ(FEPmdjwXp==UWLF>837aiqt2V9OYsrgGF5G?R8WPbxPc1p@wIOI96G2g>UYjFB=qrXjc1?58d zg~dmJ^s%?6z3!Z&4Fd`P#ZX?yU)@>tt73c3b^44OVer zzXa+uuTP`TyaaO*SlA>v;sV^Dl-3w?B1-`Eqkm<0|4TngW_4kX`C2MQ_MpYNeRPWA zXM>W$#IA~Osd)XGdb=8$Ls+#db5vfFm=x0w()I4EO~KVr+Bd3(1f5)=zqcxy%e6m5 zJg$<|IXR!mEXy8fFmK9i3{!B7X1{c=SshvKU1td z^}__A>I`vDaTs(l<55N>L9Ny!XD{LEGqx-LBtUXB#YpVTcMcm83PIIh|= zsv{S-2P=Hu`c;UlJV$x(*)bH0kGavLA!211F;G7RTR*nt0mz8kzPw{3MoCVI?6fpj zv{tH%BShIPA^yP9D+PfUULQmDtaB;H=n;|vinacdHO@-|1NkXiTjk0RQamYqPY?}i zjc~I9ghC<0&1l6jd^3!AL!h{b%T^aI?5C!0rqX;U)esR!=ZwxVD3O+#3HW_N zO3}B_D^fh{m)mUU8|6MTEzXJFV@%#+Vda1i;lS%?((hko+5qzNuc) zAu>&i_|jDKRqcq-XqY>$-;u!2Mrd5N^o@ZK^kBEAd%D@YzX7!BKPNa53?=KzGyfFa z(p^?AR_tp%KuqB04{smh%gZiF7uHWqaNa)iw4R@RZTu{ikq+l=XLJ4%HXlSeXkCSw z6erN4x$F+bCFP{4MMuG-Q&VV(!hc)Dxz^!x_0O)~t}_rOw2RZ@a*SP<>eHUf-o(Bk z!6pi|hE-(Pp9X1?~=p0n9?foWYPbiV$RuiAG-yZC!j7!-ty`MC?Ywh1XD3)4U` z&mL)WMGp>;5o%2|jO<5zw}W3nL;`VlcsC)iKMg%ixS~Ht4P2_REm{&33PDFb)a{o8 zW=Q1D!S?wMP&0R~*A10dx3R6f_@(yI0J(u5wWiM#K;&7tn(Bdo?lx^Aob6wQJuin4 zZns50kdt!m!)+65vC;Ki5G;kd-Qfm+xZDRJi42aR^U~vDZr}hVf!_^0;Czz$G4yhW z<;XhGW(w`TJc6VnxDukE;4!x51pe6gY51$4Q?({R<#65(HdImi{rckW$83^KGH7_+^Ev^*OUOz1|?UeruHL7PSi(1AhPEx}BSUo$uC!!7lbI&(FW8W*i_y)E;!M zrE?e&#l1<)Y_b-1kSuCXQ)chmwNWGe-xR&YPn0m+_TZ8VPKQgD&OOZb@3curg z^)L%l;PkmXZ0IrLN0W?%of z1px5tHS$wpzBek0w@Jyia#poQsL`&KA}+jN=~&?5U&ciok``x*$4v2_21^k=R7aF{ zbE!gtN8iAyB^_c=gms1Qnwe74C7)=-x8 z{6?>Mvi`6i{}K?PwVQjEF=p}x7-5{_07;?}n+xS@Nu(nH8*p3j*?o1x+y`}`y^yE< zcheGw|IyRtxDB;EQ{vcGKaHtnY!VwNVbTExR}Bq&+B0{-?H z%~vOOHhz$o1w{KajnAZnIZ7gbDHMrNs-p)O+cpLxoUmAMfD{wuiq(Q?9;L@KC9hFQIkU7Aj66 zx*4zz>f6O}Lc#)v-7l)|V9%P!xDX~EadDnHYSE1{Y#$&}$;b}K7LG-}(6XYFSnVyo z5<<(lZm)@vEr3YPgAc*UDtkL~_jW^cSS|rhT++gnFgr_g*Pge_(cUSQk2#}NdvE>1 zsN3C<#Z?MwAVHJj0ecMJgo!ag8)viGGZ!Q*)u~l zD80R1`vec(#JZF+zD$UqQ7|U!Vae2SX?IQ`b=m42C;2L~hnb^ji3cB}}%xux!`P;j_%c3l+7Ac-YQc{N}jW zmY}4S-JyDmx~{p_^Nt`w<7@;8p$awUW;u)|(`@=LSxf>RxI7+B7Z#nXpbMgRf;TGr z59pf(H6KC@`j{;(2H*)c+M`kUnFgHIqiZSu*^}D1ii<5o1Ii($Ul>7RYLJ2VgTnp! zCjgR%O62r-@RG}SmM+D!Gy_q_W4Pi3R2Qx{Az(YGgJS1}+vqP>usXRk+r%qHe&Ol5 zd>8L>ru^ZQ3~K#LDMe}z-z>f)iY^Y>e)>E)T>l(icz&+XIRg?41%dst|792%T=cQ8 zN`-*^*!0a5nr-ZwBC3!SNWLbh5=&1qrl3s=U-z;if}}5IZj=pCNuE|`hIXTDBL_+G zs0i;nSvp*St<9|c-`Pyf8|654`~ug7^?bX|k{FRYV$ulxs8e+gi-n()5P86Li({|V z#6#aFyy}BcPWmV&KI=%vbixOxL{k%o{iu|R^NX|iTuS548nna#>L{L?<~N@@{vZ`7A2^0)Q&^pEiM$FP2$hvZvVxQRCpKer6N#_ z$hJRfQTQ?g6SG#RqN21bf1XsA;S|-a`x(~Q&gLzY1p=7Jpjk{q`@SWkbnmgGCileR zRRZ11w1{+Ks@7>5M5BUg(1#o_BHZK)W>3ni<7c9kIWsL=-*)ZaYrNH-r?)OCzst|< zQ5Ac=N+GBai_}doR)&l1V~w;eTkm5%F&5&?+5AWRI`funZJjZxv7`3c{+#d}Bb2a* znU?AX9fA@5whHnj$1(v_PSgQvO|2)7YaoLIhX_q6oPerAc?cZTRT#>CJugaf?iy(hf|l1TNw>d{fZ_*&i6B4;~Ziu3gW9f%?8{HCb200s+4Yl0;N5g z)SQOYg0->NtOFlyn&n+H08&nmK_n|`p<=4`e`stE=S%aL$j%T6oJlr7`AP0GET%{E z2Qfys+`vkh+-8OHTy$Hmd}!^-&=088g8FTI-EXSW0{d-=Br=_$v?u@6e~$xX`Td^1 z{PyRbbn(B<+_WIB+2NOlpoKirE60D5ULL8NG5kVq`CQ|Km7@{FKrAHqfwM02BLlmg zDyFl$y1z>ue4$}j@I0KI1f_jybJ#M}3fY6E1@>8C;XzArrEZ~arNTA^&XC`a{XV?! zlga}DD2g2rEwL{~SUhd_+?U-Zu! zLMsG~AOhm;uFT?uE!KgjH;iVV_}&;Wj_x-_Y0?p>XH>EQ^Ri>t%WW`xDWnGZ|LI%- ztaeZVP-$Bp@`Ieygs&8zu+$Vh%>L$IyespUJkPfV+r01dOh{q-NQS1#5Rk^}h4vNo z`>TQTHMafT0_o^5IBxr*+g8iW8KuC1%`GwJ?w_ZY=H1mx$E2_y`CPx@zYQ=ED+YOv zxcX*5`UXs|(YLamnF7`HLar2L&COa9v_?`J$z|!A?)WOeg&36>6Bd_y=V5qb z06u;{7N^S{=4*E8L~$YAZ`#smLkT7X_r>y|9nYUjdyT7rJxK$DJEpl5gVw-l%=c8`1&N}bYgC9D<PYJo>wZdH5sdR4npw< z0vikc%6VcmXuNuX-6aQdCv9inz=596|`0g{w(1rmU}3YI-zv6s)Hn zDBj&P%&*t(A3=mYGcAK0#9yxipRyqJd8-^K-DiR7@PR1z8Cu@MgURjl;!Gsc78bSs zyupVN&x!or;%+f;)$DU8;dlDYeih&aO`!8~j%MN*t?Zt0C6F4k0_N|NkqU;5PsPr* zyv(+ju1iyblYgGe`5^l%FMGe!{5<3A3^}`Gs5Uifea@Z!Em~DHk0cmRLC{$WhiP%1 zL)K|j^WO5Afln@q<2mGjKih{6%1kQUnUgpf-Z5q8Uu*G8)e+rJY%$LZD&_E~Mm412lb<40>0B+sP4oDE-eM-D{KJ z7(H*VxmUccYxCFMkOE6cdL&G5p{hKZi{OX;oZN6MRD$*3dYd>}7_}--`yKh8eb8+O z+jRkniwR=LRFrTd0}Y6~+m3!kWMXv39l%c8kp4rF1q$L;)^CzuFi+*B$KbOUx7*)6h7kruTH(z=P@bF#A5=sT9|2}`D z{0#Pv`Q47DQv;+$dyp_sg|5_=#&xt9FyzCwO@L0=VxVT+{{3S~mF5s34yLoC{^|*<3=n zTC`Jh(!!RxatyxXRdqH~6E!a5fXmxA>nl*V!;Q-ie(8Is6U-@qI`wQ05t8W;JpO51 zr<}??j>Q`|@W$_F4#(EdJyCB_Jm3UZTO0A8w9*f?SGQqi6L+eD)D4Qbr#VVPXz4er zU3fovyD>Z(_;-*Ny%}0NijRu)rp{tTnFSrb2t3-c&CwFvc5^s`3rROF_2oa&w?dr{ z40Z>fNK`uu!D=At)gq*!=n&8CNLDiD1dfrp!8R|9Lrn30>6%c4B$aZhQx0?1GS3RO z>74r6l=!;!s?w24#nX;h%^fH{64Hb^U4K#0Zvr)>S4GAsOg8;#FZR&iRE3n3!%b2W zw0b0M7~%55n7gBGo}@@GGZR|x`zw5WKg`*Tgld8Q!Ul3%PDrn{pXK6PK$>v1@`axN zWoV6;AX*_T;Y*+-%4FeXY<8IGQ+usQ;m0usC361K{GUjxF;)E|=M;xq*}&kKQg4^t z_qu-0M-FOs?#a3<|_f)jc1|PL4|An0)l4^*d!QmYklK&~~5HpBJBn zj-epwZ%yeJVOshJrd5uM;_u#iJ!vtVy$^Y|k z5`j`1rL1PwzEaZaBvvXS*W zs&S-3(xI79v!~z1H?gW}T^o9pg(K<#l0VE1sQT+$b(yBtW% zjS;~w8NnEgM*Sz<=uNlXbVAO`jywJ=cVg92UHftaOtO_se^+ z^(l1^Z9E@Chd-184l&MK|0Ms$2Xs=~d~B8N{S|dRw95x!! zpEDV-@*$CLUb0;!$SmCr&lL=B$CdJpf%s7%bW7Q3qbEf^76H)PC2mQbyhxQ`8G>+> zvf695H`r!3lqLBa#efurwDJ7>kGd&{T4`5~FlJC`mh=MGfo~Sjv{gyhl!ybpEdHZQ zByhbHkiI>hHDEuy8W<{>rCpJo-6SKy$n594N_g^|f}@>ZS+D$&N&T%J5N!<-3HoHd z)jA>VUEo0(FV7Q2l;ltt7C^T@Ys$G95C~H$rm11|7%$Gh^GGi2Ma z#-XeMfz;JBPde-;?MJY3ZJ_Ud8nLmcjUZ3rKq4-pZY{tr)ndExsxjq>a#*V~82nXy z6GpZD6lkeX^^zq5a6X5$dE8$A zNx`>r9?tk^O)#>o`Pr-Br@Fh+75+#nQz7yA0P_!QGjlX_(xDf+DlbLgLGMzS{5{nB z7TbjSagn;=H)`v0$hmFkpdjT{;MwYYVY`T@^Y19SshIg67>KzJgrs7gGLzSBGI}flPzm)*4}VZ9lv^SahKQ6sU^!7II|-6N=_}JG}g#vU_EH^l^q9 z1Of`tuyi*fJJ(cp#sG;PoVKVpxXvk<7I#VcAoHP&jT+{mfbVYt5RzLBoSw8AlOm{2 z`STf7P6~%;Zk|{h9nP{9_9z7QOn3!NMV+#!McKmx+ChChV=hjGwts7R~z#Tb88#-QpQJ*)MR9ewm5482F})d1qULLMxT18B_t}QV?nHqZ#l) zJ2pP?r*iW&KDPNYLio3Qn$0vy5ciC+N8ZYfL-ubKxW;0@lz2NZ>@RAgl83=H$;!i+ z^rFLOFx$MQ}R2y zF)g(VE!cmaP21yg`pwNlCvP?uSOpZIus*=T7tXg}*^QYR2E!+u*j(=%5AA7zpoV3B zoKimm#HJ#9kOFwaNtBlJG(VCkKw~>bqs74ImjyF=H~HW)p#N?rBV@csDRd&_Ge5#~ z%R*9z%s%R&glab8l^46GeQ8ZC4l$MgZi7D(p~PZO0yRg&b;|#qAos4$ch6!T)Vqd~ z2nF6fu&od+&O3JDKt$@9Iw*;zF**=wD^rY6-7{lFWCb!Z2aR8^H%~b6xhH>Y&o9|3 zo^&yI?j!PD1Ofv|aCt4@`6kshGzJ)N0jE6(Kzxp7^3sW(oQCG6=K)50x#)oP z|4t+widOZXse|Tal)8caiuBFV)i=Kw$hI|GCd&(`U}|e6Pt8A$MKBQMoXb|1TjarS z7T>j*^#)f%}>~dUzNUqY2CKB%K%qYQt20?DXHX60c=~!Z@z_|N@L_=y$KnXuQorn zBPi5K?vhZ@=q!Yz;8SZT*HPQ!<9`F<7_Qb_k!`Ep#cgP4Lb9=e15QdM?kf8z;xYo->;k&ab5ZYDOZ%YqQdcl6wK@v)@>}r0OA07j&x7Zvpu0nWdfLtv9 zGk~wfW=3Gqf)cVL-XEs%a_Ao*_~qzyF%J7+(y7WkLxHmU!E03*429}i`eXBOVs{y^ zX|B5UeA>*?>69~ANyv87X`GjJ%v z+2TvRrQvqQjf|Uf?c)Hs+i}*>6G_p+rWW+J?QX_%D=;WVHGaK0iWLyI{Z$`MK>KoP z=hnT}q~M=^f_;AQ2;*O*eA_wA^=3+@zQE?AHuH~wTyF=)A>W&_pkdTJj2Y~+LO9`& z+#Sx37yNTd$m669Pd^gKhDykq&%AB`iz4~hsUtciuOQKm{#Vyo|Bo))p^2mEAcurx z%~l6O_)xymWu)I^x6>l|{BC?sQGu%r-19YDY1M9X600VdM@aeWw-5iWpv4|VN>cvH zwOio6O?JmNXp$T!!NJ_@Ek@dK8lxQP*Efy&r;^laF9j33?BJu?QN3ZvE=pPko1E|u2)zb@`v_HAKN&$T z&6useX_v+>@O(?*T3@*%d!O9>@;bO3(sEpRD}ix2@>&f(uCU1*rrOL(I*k(@0PFjI zK@N=)O^zM7=8TDfGc=4&^G%zI?vKafUEuX|b3o&ME3auS$khmAT4)1tv$lTA%l)we z8LxA)w8*;cC4EzP#NKflTd*lT=$E|9%G!zfmcdA?IrePWiku@aw8a#|3E>Y{ybRX6 zGp}6dF}VG2ECq-+%-9a>($KR16$s(x^x$u_Vil$NrMVz}lnhULXHqH?$FbG6dW5Yp z;ACGKGib3Lst2yw#mPwVIZ5AqTO@LQ=D|_qDh)9_(yDI>>b4^t zXfI;7b)g0r^}A2qaQgdyagnI+btFOV&V7hU*?=azsOeallLfhNQ ze|M;4CMN&lHW-s1t1Qjoc#Pos^^GS~qxQfL;)d1$4T&E29<3^3+CvtBCkhtO&t0LH zl8&?X+I^h%wOA()tb6$c`|yOLLp{dYz=ZV-n4-;3H+@93b2W2}d|tJ^S8}7MvuuQJ z;@3|fSdxs{?eu4K(x4aV)~aWzO?Mbtga$&RxEeQin{ZL_nNdjxxJQLd3wnf_Z)At~ z#?@;CVd>jDKN+Mit#i=Gl`HA(Y8 z#xA4v+><=I;L2cbTW>W`TG`i&(9&aN(gL)GT2lbz z_Vx4_YB~U;PZ$MRbD-}tT#vX)wRiFVzbkr=_a|WvbDG(U%H#v_S>o-L%`T#Ale6&! zj=&TO;r^bhk%c_vJ!S{WX5;21URMs}VJB;xohh zgNKa=BXd;(2~dy_^^@_>!m!pH_g{dO`)$Qw+bCa-T>Fw0oMQttp81zPebP4mVT!in zC)`p4*XWZy*Ytn-#D}x~1_{Ccf`9+ReKIN`%1v^btPgERMC#S1hq#jN?oINP(oK&m zu=@}alCm@M`0wv|y)jz`%ycpBNL%b%u9E+_gidKX;iB%yFf&s*a4BERotw=sH4d8WD2n39nwS};H&&t5jVLNcE z*MhS8EaGZLTM+c|Y~JIX>W@&fKKhSL)L*6xvG*c!_xZ`QhOlUlg(vFTb0gcZ*4`7E zzD8o#klBoBPWUonO+}CmX}Lnc!JV;W+4V+S!(i2p9%%?`&5_rb-t5nY!=xj*)y2Al zKlP;ZgAgl`To6t!(fsVzg4?R%Ct@4`vmwOF0unJGL$akQEgBK}@=D+udZW{}78e31_ zj>wrzpPZ*}RIL#8$y#;LcXFR6PdcARu1vC7uH&$GD@Mc;4CG7aAM zBToq0Lz?+mRBm9d)T3YpzvQW8^jE`9UX@+BA(;n4Gcbl%C zCMl<{6u`A6@P(Fbv|^onVM)9i(Zsaar{B2r!j zabj)S*djmp89~OGd4SR;HwxY(;wW})su744uqAqT>ce=e%(9=MTOSD>Gn<}Y;$LC{#6)$4X3w#St91KB%=ka&48coZH@odiNCNMM#56F#P1o;(mi8o z=>ZG|_I*zFKSe^h_qYh&v9Y9yQ(Tytq@6ctH2@%i2Ce!R5KE6an%8E1M!!(9h+S|` zbr&z}yrx(4_fWRe7v`?OFi)voKW@|C{kSNC(1>3$wMIPw+U;czcRlDVE(uR) zZ0vf>N?6)&9e04 zEEu#pINZk`6^n)w{ZSGZ5OYZ2_arWSaZpUi8Qs_C7prBtb%LM`8I!vkvEx_kSueuY z&B&wJ$0E}VUrN5(R?{lMq0w4TU&c{QL6Xh1uQ>!Sr({ExO|2%0_jzB{y-_mcwXn$O zvT$>s3+cnzKl6NpeEr}U@_}BAR!A7R?2&sy+KLH0+h`|WO%Qlwf!=hBX22C_Id6^G z6yBQNzdDpG3nISSu&fG+{#}5;NQ1(5{e(2hY*ITAuC1)+L&f0-YD5vt+N&N-8ZBiHL`H42RPs|mr1asnX5j`9xAU}Y-vh<t7SbQjtRzGAS9z$!Y!yK>;raftVRYecNZFK~wty!(S*RvncxUi(w_GglJaegYZ)>5n)gIKwp|d&r77= zu)8E_5u~NLCt258f#KyDA(_fk-xC8NRD%4BF7fTq^eEepX$LS9#eJ}4GlPK;;D&pg@LY#Vl?MUJA|d*ZSA z+e)%O=FA`12Dgj$%?=A=h}3dVS9#JQEhQyF8%e{9Kz$rd#u$<*CIft8d=EY?Ed>9lT*;(b!)IpSU%mN?M*fKPZOS;;+`1HD9*>;D zv7cr7tGv+QZ}C!-W_BgVgBLkTu5HASq=kX(*|+yz0@7zT@VsKYFpl!hVT6GrO2D&P zcgzG9LpU?l`Dp8efzqSV@U-?s=zlikL% zX6fjnE_Bcl6i34FR(I2Oc&uSC#jPF2B25$ zO-aVDW8D@l`^lOlm_OT>@OklUs4DXniClLtay7@?_&X%Ibc)6N#Aw-cDddQ*b}-`E z48Tu=+kzys;Sq^7uR4?72BH5DY2Lm!h1TIPyB~azR`a!mqUWw<=O!cb zcH68WFxvEO36W+n@dVSzDw#^-W8zO=PwuS`+XMS?wnZ}9jE*t7aE_)!&k_-7PcG6i z_Z4ta%}*4oIp_Km+hJ=_T=GeI)wX2f3Qio^@`v=z>AmNP3ry}OFWZsj4(iRrG!N|x z>0pUh5hKHjl4s$HA&doWKTqP|x#r27JLZ#3s`~FBmn@zIqJHv?A1{qz^7*^273wjm z;jw~MHt&bUNalpC6S%%wuDn9byGDt~VZG{fCI!xQCW$dY6XCpHe-mK05p|r5VgQc< z7%K`Tp1wrSqIMKnA4o1o4zrGjOUU%&);dGRuM71FAqB-CA-?n&AhJ3?aU2B~?yB~i z+L!43RftRc@|FQv%y{>(qQAy>K^hBEDdh)%Ve&un3>A*M=GKpVu)lFBu?qXDXh0 zz#JoK##|&`HP9jRMu=xYUvVH*CekHi_>vCUN=DfEJ$aWYx=SJ`lCl2$=_$e>lvicC zKw>@QE?%6mre@7~EFOXYJdqF$r$if?@_3vLq3<(L-4dqnyF7GinhoF>UuA)#O zEa9xf5cM|!(Fn{V6zdYUe#)HQ4z;4CvFNg}H)y8>B6waMC#ewt~aKh#?rA*bo0V@7Ecej)e!L z5V^GnLs)pVxwpXt!az-;5)EUgl#)${Q1CDG==FoZI>U#q?L_Z23a#!_`|Rt_SH!wr z;J9H4I-bAvjJz{)5CNI!v22=8XqJ(BXt7=(HS#B1c;s+)&3O+;pHZ^2kL3HJ88-9k zh!EJ<*Sb1oR9t|CZcnZ0W;LuVwvyFovLKps&+M8?E#T{};kezX1Y|Z>9bdDYCC8{R zrtaqUE0WkG8Y=ll{(0eo(}7j2zFg5kN%ac9Xu9{W&hfV^zm*z_}o4O zd-hY^+gSAzH(a{~^(oQ5ZTPLODf7j3Y#A8AEyIlQUwgQS*)H;DGmQ{nVUVV<^WY3&yP0@|^nfv;}N&8cw zlFU!@OS1VQgN|y@0X0hbgAxEbwFxD1C`>|y3-NjQI#N7ThCH7*I%V2*|1GACqRl_=J zV8?g{{Ye2^Bj;iCt|5xmf%K^{mabo4v)WTP*DU_aDE-I%zBkh4#3sZ~H+81C4?K+I z(FmbobSQvR>q$BPj_98Iq^k2%CMYx6&p!>EM25N5;LI{+ClI=YsyA-PYQ#OxPC<>j z+Q(2*wG|p5=ENFh(hbDtt+S9w&v`?L4b2Ju>V`to9|;|wEu^jLa%U!uOn(1}130W( znhvYy#4*%Z@teMSQVLTM!9Ve_;-0VX6KUy1<|)Z^>EmDRr}p)ve9W)1s3ubNiq4{( zFc#Xjy0tsEX3Yy2tcX-NGkv;&>4BgkZaV!72;XUv_DprH#R|uVjpv2@)2HPE$MYBP zRbNu|3B%*#@T>l?QwN5Y3W6A8HEb@e$~af)&{a6BWrV~NiFLA|+@Y!eX@eB`_2pa) zju|FbWPajw)0*)U_5Hl9`~I$0B<15|qOY}u#N z)M_o_j}Ydj!L|c%(kiEt=Q%nE9rfaLD=02L^YuxNS|NPcExJxS_KsZf`Sjhxh%iKl zdc-0K%DLi_a*AQyL#3ziY|Sd_ZzA?^S(azIHK?Y?GB9x=u$jKSu(9W&O+j zC0$;w$(I|~kkJi3<=EGB!8OZhN!p`(M9Rm7sl=U{v3Zk)yTdw+k{A^e8E z9dSkYPL_e^&ix|aAUDSu{5$BPP_915bxVlCi>9sY}Wy8;zIJeulV}pzbbGtx^UyX#q9W_b7I5X zIsJFs8=jP3_0f)4hkdW75pC`Rk|iY542RP7>DAGRMfVg^QTdJA>^Lb@VH=sWe710+(iMstEid%(!X-CyyTyoW9+;W(ntJ&pXYo{ z0g}e@W=-+T-!OOJd6!-4c-B+Em3AaQAX%9&Xvk}+jS{aEU244ja<7594{`sT<2y-^ z`Ekzo6i{Vr?mowt?zsbUuZHTg=Q|SI0>EeYIaI<1sn6Tm5(Mvn*nYsjm4e&TuKMWP z(@KjL&5od1dDg0D_gCEEQAt8(8`wy`{VKtRtT&o2did{b_pNof6+X}Vg70xF-M#u| z>h=RK2d!Hqt0P4rr_4T1#QD:1: cannot inline type..eq.SI: marked go:noinline +:1: cannot inline type..eq.SM8S: marked go:noinline +:1: cannot inline type..eq.SSM1K7SSM1K7M8SM8SI: marked go:noinline +:1: cannot inline type..eq.SSM1K7SSM1K7M8SM8: marked go:noinline +:1: cannot inline type..eq.SSM1K7S: marked go:noinline +:1: cannot inline type..eq.SSM1: marked go:noinline +:1: cannot inline type..eq.M8SM8: marked go:noinline +:1: inlining call to Key.String +:1: inlining call to Key.sectionKey +:1: inlining call to Entry.error +:1: inlining call to osEnviron.Lookup +:1: inlining call to Env.UpdateFile +:1: inlining call to (*parsed).entries +:1: inlining call to (*parsed).nameOf +:1: inlining call to (*parsed).secOf +:1: inlining call to (*parsed).valueOf +:1: inlining call to flatEntry.is +:1: inlining call to Key.sectionKey +:1: inlining call to (*parsed).entries +:1: inlining call to (*parsed).nameOf +:1: inlining call to (*parsed).secOf +:1: inlining call to (*parsed).valueOf +./config.go:39:26: append(c.index[e.Key], i) escapes to heap in newConfig: +./config.go:39:26: flow: {heap} ← &{storage for append(c.index[e.Key], i)}: +./config.go:39:26: from append(c.index[e.Key], i) (spill) at ./config.go:39:26 +./config.go:39:26: from c.index[e.Key] = append(c.index[e.Key], i) (assign) at ./config.go:39:18 +./config.go:42:38: append(c.subsections[sk.section], sk.subsection) escapes to heap in newConfig: +./config.go:42:38: flow: {heap} ← &{storage for append(c.subsections[sk.section], sk.subsection)}: +./config.go:42:38: from append(c.subsections[sk.section], sk.subsection) (spill) at ./config.go:42:38 +./config.go:42:38: from c.subsections[sk.section] = append(c.subsections[sk.section], sk.subsection) (assign) at ./config.go:42:30 +./config.go:31:16: parameter entries leaks to {heap} for newConfig with derefs=1: +./config.go:31:16: flow: {temp} ← entries: +./config.go:31:16: flow: e ← *{temp}: +./config.go:31:16: from for loop (range-deref) at ./config.go:38:14 +./config.go:31:16: flow: {heap} ← e: +./config.go:31:16: from e.Key (dot) at ./config.go:39:12 +./config.go:31:16: from c.index[e.Key] (key of map put) at ./config.go:39:10 +./config.go:32:7: &Config{...} escapes to heap in newConfig: +./config.go:32:7: flow: c ← &{storage for &Config{...}}: +./config.go:32:7: from &Config{...} (spill) at ./config.go:32:7 +./config.go:32:7: from c := &Config{...} (assign) at ./config.go:32:4 +./config.go:32:7: flow: ~r0 ← c: +./config.go:32:7: from return c (return) at ./config.go:45:2 +./config.go:31:16: parameter entries leaks to {storage for &Config{...}} for newConfig with derefs=0: +./config.go:31:16: flow: {storage for &Config{...}} ← entries: +./config.go:31:16: from Config{...} (struct literal element) at ./config.go:32:14 +./config.go:34:20: make(map[Key][]int) escapes to heap in newConfig: +./config.go:34:20: flow: {storage for &Config{...}} ← &{storage for make(map[Key][]int)}: +./config.go:34:20: from make(map[Key][]int) (spill) at ./config.go:34:20 +./config.go:34:20: from Config{...} (struct literal element) at ./config.go:32:14 +./config.go:35:20: make(map[string][]string) escapes to heap in newConfig: +./config.go:35:20: flow: {storage for &Config{...}} ← &{storage for make(map[string][]string)}: +./config.go:35:20: from make(map[string][]string) (spill) at ./config.go:35:20 +./config.go:35:20: from Config{...} (struct literal element) at ./config.go:32:14 +./config.go:31:16: leaking param: entries +./config.go:32:7: &Config{...} escapes to heap +./config.go:34:20: make(map[Key][]int) escapes to heap +./config.go:35:20: make(map[string][]string) escapes to heap +./config.go:37:14: make(map[sectionKey]bool) does not escape +./config.go:39:26: append escapes to heap +./config.go:42:38: append escapes to heap +./key.go:46:24: string(b) escapes to heap in parseKey: +./key.go:46:24: flow: ~r0 ← &{storage for string(b)}: +./key.go:46:24: from string(b) (spill) at ./key.go:46:24 +./key.go:46:24: from ~r0 = string(b) (assign-pair) at ./key.go:46:24 +./key.go:40:25: string(b) escapes to heap in parseKey: +./key.go:40:25: flow: ~r0 ← &{storage for string(b)}: +./key.go:40:25: from string(b) (spill) at ./key.go:40:25 +./key.go:40:25: from ~r0 = string(b) (assign-pair) at ./key.go:40:25 +./key.go:35:27: string(b) escapes to heap in parseKey: +./key.go:35:27: flow: ~r0 ← &{storage for string(b)}: +./key.go:35:27: from string(b) (spill) at ./key.go:35:27 +./key.go:35:27: from ~r0 = string(b) (assign-pair) at ./key.go:35:27 +./key.go:25:15: parameter s leaks to ~r0 for parseKey with derefs=0: +./key.go:25:15: flow: k ← s: +./key.go:25:15: from s[first + 1:last] (slice) at ./key.go:47:18 +./key.go:25:15: from k.Subsection = s[first + 1:last] (assign) at ./key.go:47:15 +./key.go:25:15: flow: ~r0 ← k: +./key.go:25:15: from return k, true (return) at ./key.go:41:3 +./key.go:25:15: leaking param: s to result ~r0 level=0 +./key.go:35:27: ([]byte)(s) does not escape +./key.go:35:27: string(b) escapes to heap +./key.go:40:25: ([]byte)(s) does not escape +./key.go:40:25: string(b) escapes to heap +./key.go:46:24: ([]byte)(s) does not escape +./key.go:46:24: string(b) escapes to heap +./config.go:49:7: c does not escape +./config.go:49:25: key does not escape +./config.go:61:7: (*Config).filter capturing by value: c (addr=false assign=false width=8) +./config.go:61:25: (*Config).filter capturing by value: sk (addr=false assign=false width=40) +./config.go:61:7: parameter c leaks to {heap} for (*Config).filter with derefs=2: +./config.go:61:7: flow: {temp} ← *c: +./config.go:61:7: from c.entries (dot of pointer) at ./config.go:66:22 +./config.go:61:7: flow: e ← *{temp}: +./config.go:61:7: from for loop (range-deref) at ./config.go:66:15 +./config.go:61:7: flow: {heap} ← e: +./config.go:61:7: from yield(e) (call parameter) at ./config.go:67:41 +./config.go:62:9: func literal escapes to heap in (*Config).filter: +./config.go:62:9: flow: ~r0 ← &{storage for func literal}: +./config.go:62:9: from func literal (spill) at ./config.go:62:9 +./config.go:62:9: from return func literal (return) at ./config.go:62:2 +./config.go:61:7: parameter c leaks to {storage for func literal} for (*Config).filter with derefs=0: +./config.go:61:7: flow: {storage for func literal} ← c: +./config.go:61:7: from c (captured by a closure) at ./config.go:63:6 +./config.go:61:25: parameter sk leaks to {storage for func literal} for (*Config).filter with derefs=0: +./config.go:61:25: flow: {storage for func literal} ← sk: +./config.go:61:25: from sk (captured by a closure) at ./config.go:67:29 +./config.go:61:7: leaking param: c +./config.go:61:25: leaking param: sk +./config.go:62:14: yield does not escape +./config.go:62:9: func literal escapes to heap +./config.go:75:7: parameter c leaks to ~r0 for (*Config).Get with derefs=2: +./config.go:75:7: flow: ~r0 ← **c: +./config.go:75:7: from c.entries (dot of pointer) at ./config.go:80:10 +./config.go:75:7: from c.entries[idx[len(idx) - 1]] (dot of pointer) at ./config.go:80:18 +./config.go:75:7: from return c.entries[idx[len(idx) - 1]], true (return) at ./config.go:80:2 +./config.go:75:7: leaking param: c to result ~r0 level=2 +./config.go:75:22: key does not escape +./config.go:85:7: parameter c leaks to {heap} for (*Config).GetAll with derefs=2: +./config.go:85:7: flow: {heap} ← **c: +./config.go:85:7: from c.entries (dot of pointer) at ./config.go:92:13 +./config.go:85:7: from c.entries[j] (dot of pointer) at ./config.go:92:21 +./config.go:85:7: from out[i] = c.entries[j] (assign) at ./config.go:92:10 +./config.go:90:13: make([]Entry, len(idx)) escapes to heap in (*Config).GetAll: +./config.go:90:13: flow: out ← &{storage for make([]Entry, len(idx))}: +./config.go:90:13: from make([]Entry, len(idx)) (spill) at ./config.go:90:13 +./config.go:90:13: from out := make([]Entry, len(idx)) (assign) at ./config.go:90:6 +./config.go:90:13: flow: ~r0 ← out: +./config.go:90:13: from return out (return) at ./config.go:94:2 +./config.go:85:7: leaking param content: c +./config.go:85:25: key does not escape +./config.go:90:13: make([]Entry, len(idx)) escapes to heap +./config.go:98:7: (*Config).All capturing by value: c (addr=false assign=false width=8) +./config.go:98:7: parameter c leaks to {heap} for (*Config).All with derefs=2: +./config.go:98:7: flow: {temp} ← *c: +./config.go:98:7: from c.entries (dot of pointer) at ./config.go:103:22 +./config.go:98:7: flow: e ← *{temp}: +./config.go:98:7: from for loop (range-deref) at ./config.go:103:15 +./config.go:98:7: flow: {heap} ← e: +./config.go:98:7: from yield(e) (call parameter) at ./config.go:104:13 +./config.go:99:9: func literal escapes to heap in (*Config).All: +./config.go:99:9: flow: ~r0 ← &{storage for func literal}: +./config.go:99:9: from func literal (spill) at ./config.go:99:9 +./config.go:99:9: from return func literal (return) at ./config.go:99:2 +./config.go:98:7: parameter c leaks to {storage for func literal} for (*Config).All with derefs=0: +./config.go:98:7: flow: {storage for func literal} ← c: +./config.go:98:7: from c (captured by a closure) at ./config.go:100:6 +./config.go:98:7: leaking param: c +./config.go:99:14: yield does not escape +./config.go:99:9: func literal escapes to heap +./key.go:69:7: parameter k leaks to ~r0 for Key.sectionKey with derefs=0: +./key.go:69:7: flow: ~r0 ← k: +./key.go:69:7: from k.Section (dot) at ./key.go:70:21 +./key.go:69:7: from sectionKey{...} (struct literal element) at ./key.go:70:19 +./key.go:69:7: from return sectionKey{...} (return) at ./key.go:70:2 +./key.go:69:7: leaking param: k to result ~r0 level=0 +./config.go:114:17: (*Config).Section capturing by value: c (addr=false assign=false width=8) +./config.go:114:17: (*Config).Section capturing by value: sk (addr=false assign=false width=40) +./config.go:113:7: parameter c leaks to {heap} for (*Config).Section with derefs=2: +./config.go:113:7: flow: c ← c: +./config.go:113:7: from c, sk := c, sectionKey{...} (assign-pair) at ./config.go:114:17 +./config.go:113:7: flow: {temp} ← *c: +./config.go:113:7: from c.entries (dot of pointer) at ./config.go:66:22 +./config.go:113:7: flow: e ← *{temp}: +./config.go:113:7: from for loop (range-deref) at ./config.go:66:15 +./config.go:113:7: flow: {heap} ← e: +./config.go:113:7: from yield(e) (call parameter) at ./config.go:67:41 +./config.go:114:48: string(b) escapes to heap in (*Config).Section: +./config.go:114:48: flow: ~r0 ← &{storage for string(b)}: +./config.go:114:48: from string(b) (spill) at ./config.go:114:48 +./config.go:114:48: from ~r0 = string(b) (assign-pair) at ./config.go:114:48 +./config.go:114:48: flow: sk ← ~r0: +./config.go:114:48: from sectionKey{...} (struct literal element) at ./config.go:114:28 +./config.go:114:48: from c, sk := c, sectionKey{...} (assign-pair) at ./config.go:114:17 +./config.go:114:48: flow: {storage for func literal} ← sk: +./config.go:114:48: from sk (captured by a closure) at ./config.go:114:17 +./config.go:114:17: func literal escapes to heap in (*Config).Section: +./config.go:114:17: flow: ~r0 ← &{storage for func literal}: +./config.go:114:17: from func literal (spill) at ./config.go:114:17 +./config.go:114:17: from ~r0 = func literal (assign-pair) at ./config.go:114:17 +./config.go:114:17: flow: ~r0 ← ~r0: +./config.go:114:17: from return ~r0 (return) at ./config.go:114:2 +./config.go:113:7: parameter c leaks to {storage for func literal} for (*Config).Section with derefs=0: +./config.go:113:7: flow: c ← c: +./config.go:113:7: from c, sk := c, sectionKey{...} (assign-pair) at ./config.go:114:17 +./config.go:113:7: flow: {storage for func literal} ← c: +./config.go:113:7: from c (captured by a closure) at ./config.go:114:17 +./config.go:113:26: parameter section leaks to {storage for func literal} for (*Config).Section with derefs=0: +./config.go:113:26: flow: s ← section: +./config.go:113:26: from s := section (assign-pair) at ./config.go:114:48 +./config.go:113:26: flow: ~r0 ← s: +./config.go:113:26: from ~r0 = s (assign-pair) at ./config.go:114:48 +./config.go:113:26: flow: sk ← ~r0: +./config.go:113:26: from sectionKey{...} (struct literal element) at ./config.go:114:28 +./config.go:113:26: from c, sk := c, sectionKey{...} (assign-pair) at ./config.go:114:17 +./config.go:113:26: flow: {storage for func literal} ← sk: +./config.go:113:26: from sk (captured by a closure) at ./config.go:114:17 +./config.go:113:7: leaking param: c +./config.go:113:26: leaking param: section +./config.go:62:14: yield does not escape +./config.go:114:48: ([]byte)(s) does not escape +./config.go:114:48: string(b) escapes to heap +./config.go:114:17: func literal escapes to heap +./config.go:121:17: (*Config).Subsection capturing by value: c (addr=false assign=false width=8) +./config.go:121:17: (*Config).Subsection capturing by value: sk (addr=false assign=false width=40) +./config.go:120:7: parameter c leaks to {heap} for (*Config).Subsection with derefs=2: +./config.go:120:7: flow: c ← c: +./config.go:120:7: from c, sk := c, sectionKey{...} (assign-pair) at ./config.go:121:17 +./config.go:120:7: flow: {temp} ← *c: +./config.go:120:7: from c.entries (dot of pointer) at ./config.go:66:22 +./config.go:120:7: flow: e ← *{temp}: +./config.go:120:7: from for loop (range-deref) at ./config.go:66:15 +./config.go:120:7: flow: {heap} ← e: +./config.go:120:7: from yield(e) (call parameter) at ./config.go:67:41 +./config.go:121:39: string(b) escapes to heap in (*Config).Subsection: +./config.go:121:39: flow: ~r0 ← &{storage for string(b)}: +./config.go:121:39: from string(b) (spill) at ./config.go:121:39 +./config.go:121:39: from ~r0 = string(b) (assign-pair) at ./config.go:121:39 +./config.go:121:39: flow: sk ← ~r0: +./config.go:121:39: from sectionKey{...} (struct literal element) at ./config.go:121:28 +./config.go:121:39: from c, sk := c, sectionKey{...} (assign-pair) at ./config.go:121:17 +./config.go:121:39: flow: {storage for func literal} ← sk: +./config.go:121:39: from sk (captured by a closure) at ./config.go:121:17 +./config.go:121:17: func literal escapes to heap in (*Config).Subsection: +./config.go:121:17: flow: ~r0 ← &{storage for func literal}: +./config.go:121:17: from func literal (spill) at ./config.go:121:17 +./config.go:121:17: from ~r0 = func literal (assign-pair) at ./config.go:121:17 +./config.go:121:17: flow: ~r0 ← ~r0: +./config.go:121:17: from return ~r0 (return) at ./config.go:121:2 +./config.go:120:7: parameter c leaks to {storage for func literal} for (*Config).Subsection with derefs=0: +./config.go:120:7: flow: c ← c: +./config.go:120:7: from c, sk := c, sectionKey{...} (assign-pair) at ./config.go:121:17 +./config.go:120:7: flow: {storage for func literal} ← c: +./config.go:120:7: from c (captured by a closure) at ./config.go:121:17 +./config.go:120:38: parameter sub leaks to {storage for func literal} for (*Config).Subsection with derefs=0: +./config.go:120:38: flow: sk ← sub: +./config.go:120:38: from sectionKey{...} (struct literal element) at ./config.go:121:28 +./config.go:120:38: from c, sk := c, sectionKey{...} (assign-pair) at ./config.go:121:17 +./config.go:120:38: flow: {storage for func literal} ← sk: +./config.go:120:38: from sk (captured by a closure) at ./config.go:121:17 +./config.go:120:29: parameter section leaks to {storage for func literal} for (*Config).Subsection with derefs=0: +./config.go:120:29: flow: s ← section: +./config.go:120:29: from s := section (assign-pair) at ./config.go:121:39 +./config.go:120:29: flow: ~r0 ← s: +./config.go:120:29: from ~r0 = s (assign-pair) at ./config.go:121:39 +./config.go:120:29: flow: sk ← ~r0: +./config.go:120:29: from sectionKey{...} (struct literal element) at ./config.go:121:28 +./config.go:120:29: from c, sk := c, sectionKey{...} (assign-pair) at ./config.go:121:17 +./config.go:120:29: flow: {storage for func literal} ← sk: +./config.go:120:29: from sk (captured by a closure) at ./config.go:121:17 +./config.go:120:7: leaking param: c +./config.go:120:29: leaking param: section +./config.go:120:38: leaking param: sub +./config.go:62:14: yield does not escape +./config.go:121:39: ([]byte)(s) does not escape +./config.go:121:39: string(b) escapes to heap +./config.go:121:17: func literal escapes to heap +./config.go:132:46: string(b) escapes to heap in (*Config).Subsections: +./config.go:132:46: flow: ~r0 ← &{storage for string(b)}: +./config.go:132:46: from string(b) (spill) at ./config.go:132:46 +./config.go:132:46: from ~r0 = string(b) (assign-pair) at ./config.go:132:46 +./config.go:132:21: append(go.shape.[]string{}, slices.s...) escapes to heap in (*Config).Subsections: +./config.go:132:21: flow: ~r0 ← &{storage for append(go.shape.[]string{}, slices.s...)}: +./config.go:132:21: from append(go.shape.[]string{}, slices.s...) (spill) at ./config.go:132:21 +./config.go:132:21: from ~r0 = append(go.shape.[]string{}, slices.s...) (assign-pair) at ./config.go:132:21 +./config.go:132:21: flow: ~r0 ← ~r0: +./config.go:132:21: from return ~r0 (return) at ./config.go:132:2 +./config.go:132:21: go.shape.[]string{} escapes to heap in (*Config).Subsections: +./config.go:132:21: flow: {temp} ← &{storage for go.shape.[]string{}}: +./config.go:132:21: from go.shape.[]string{} (spill) at ./config.go:132:21 +./config.go:132:21: from append(go.shape.[]string{}, slices.s...) (call parameter) at ./config.go:132:21 +./config.go:132:21: flow: {temp} ← {temp}: +./config.go:132:21: flow: ~r0 ← {temp}: +./config.go:132:21: from ~r0 = append(go.shape.[]string{}, slices.s...) (assign-pair) at ./config.go:132:21 +./config.go:132:21: flow: ~r0 ← ~r0: +./config.go:132:21: from return ~r0 (return) at ./config.go:132:2 +./config.go:128:7: c does not escape +./config.go:128:30: section does not escape +./config.go:132:46: ([]byte)(s) does not escape +./config.go:132:46: string(b) escapes to heap +./config.go:132:21: go.shape.[]string{} escapes to heap +./config.go:132:21: append escapes to heap +./config.go:136:36: parameter def leaks to ~r0 for (*Config).Value with derefs=0: +./config.go:136:36: flow: ~r0 ← def: +./config.go:136:36: from return def (return) at ./config.go:140:2 +./config.go:136:7: parameter c leaks to ~r0 for (*Config).Value with derefs=2: +./config.go:136:7: flow: .autotmp_6 ← **c: +./config.go:136:7: from (*Config).Get(c, key) (call parameter) at ./config.go:137:19 +./config.go:136:7: flow: e ← .autotmp_6: +./config.go:136:7: from e, ok := Entry(.autotmp_6), .autotmp_7 (assign-pair) at ./config.go:137:11 +./config.go:136:7: flow: ~r0 ← e: +./config.go:136:7: from e.Value (dot) at ./config.go:138:11 +./config.go:136:7: from return e.Value (return) at ./config.go:138:3 +./config.go:136:7: leaking param: c to result ~r0 level=2 +./config.go:136:24: key does not escape +./config.go:136:36: leaking param: def to result ~r0 level=0 +./value.go:35:15: v does not escape +./value.go:15:16: v does not escape +./config.go:240:24: &ValueError{...} escapes to heap in Entry.Bool: +./config.go:240:24: flow: ~r0 ← &{storage for &ValueError{...}}: +./config.go:240:24: from &ValueError{...} (spill) at ./config.go:240:24 +./config.go:240:24: from &ValueError{...} (interface-converted) at ./config.go:240:24 +./config.go:240:24: from ~r0 = &ValueError{...} (assign-pair) at ./config.go:240:24 +./config.go:240:24: flow: ~r1 ← ~r0: +./config.go:240:24: from return false, ~r0 (return) at ./config.go:240:3 +./config.go:234:7: parameter e leaks to {storage for &ValueError{...}} for Entry.Bool with derefs=0: +./config.go:234:7: flow: e ← e: +./config.go:234:7: from e, typ, err := e, "bool", err (assign-pair) at ./config.go:240:24 +./config.go:234:7: flow: {storage for &ValueError{...}} ← e: +./config.go:234:7: from ValueError{...} (struct literal element) at ./config.go:240:24 +./config.go:234:7: leaking param: e +./config.go:240:24: &ValueError{...} escapes to heap +./config.go:146:7: parameter c leaks to {heap} for (*Config).Bool with derefs=2: +./config.go:146:7: flow: .autotmp_7 ← **c: +./config.go:146:7: from (*Config).Get(c, key) (call parameter) at ./config.go:147:16 +./config.go:146:7: flow: e ← .autotmp_7: +./config.go:146:7: from e, ok := Entry(.autotmp_7), .autotmp_8 (assign-pair) at ./config.go:147:8 +./config.go:146:7: flow: {heap} ← e: +./config.go:146:7: from Entry.Bool(e) (call parameter) at ./config.go:151:18 +./config.go:146:7: leaking param content: c +./config.go:146:23: key does not escape +./config.go:250:20: &ValueError{...} escapes to heap in Entry.Int: +./config.go:250:20: flow: ~r0 ← &{storage for &ValueError{...}}: +./config.go:250:20: from &ValueError{...} (spill) at ./config.go:250:20 +./config.go:250:20: from &ValueError{...} (interface-converted) at ./config.go:250:20 +./config.go:250:20: from ~r0 = &ValueError{...} (assign-pair) at ./config.go:250:20 +./config.go:250:20: flow: ~r1 ← ~r0: +./config.go:250:20: from return int64(0), ~r0 (return) at ./config.go:250:3 +./config.go:254:20: &ValueError{...} escapes to heap in Entry.Int: +./config.go:254:20: flow: ~r0 ← &{storage for &ValueError{...}}: +./config.go:254:20: from &ValueError{...} (spill) at ./config.go:254:20 +./config.go:254:20: from &ValueError{...} (interface-converted) at ./config.go:254:20 +./config.go:254:20: from ~r0 = &ValueError{...} (assign-pair) at ./config.go:254:20 +./config.go:254:20: flow: ~r1 ← ~r0: +./config.go:254:20: from return int64(0), ~r0 (return) at ./config.go:254:3 +./config.go:248:7: parameter e leaks to {storage for &ValueError{...}} for Entry.Int with derefs=0: +./config.go:248:7: flow: e ← e: +./config.go:248:7: from e, typ, err := e, "int", err (assign-pair) at ./config.go:254:20 +./config.go:248:7: flow: {storage for &ValueError{...}} ← e: +./config.go:248:7: from ValueError{...} (struct literal element) at ./config.go:254:20 +./config.go:248:7: parameter e leaks to {storage for &ValueError{...}} for Entry.Int with derefs=0: +./config.go:248:7: flow: e ← e: +./config.go:248:7: from e, typ, err := e, "int", nil (assign-pair) at ./config.go:250:20 +./config.go:248:7: flow: {storage for &ValueError{...}} ← e: +./config.go:248:7: from ValueError{...} (struct literal element) at ./config.go:250:20 +./config.go:248:7: leaking param: e +./config.go:250:20: &ValueError{...} escapes to heap +./config.go:254:20: &ValueError{...} escapes to heap +./config.go:161:7: parameter c leaks to {heap} for (*Config).Int with derefs=2: +./config.go:161:7: flow: .autotmp_7 ← **c: +./config.go:161:7: from (*Config).Get(c, key) (call parameter) at ./config.go:162:16 +./config.go:161:7: flow: e ← .autotmp_7: +./config.go:161:7: from e, ok := Entry(.autotmp_7), .autotmp_8 (assign-pair) at ./config.go:162:8 +./config.go:161:7: flow: {heap} ← e: +./config.go:161:7: from Entry.Int(e) (call parameter) at ./config.go:166:17 +./config.go:161:7: leaking param content: c +./config.go:161:22: key does not escape +./value.go:128:15: home + v[1:] escapes to heap in expandPath: +./value.go:128:15: flow: ~r0 ← &{storage for home + v[1:]}: +./value.go:128:15: from home + v[1:] (spill) at ./value.go:128:15 +./value.go:128:15: from return home + v[1:], nil (return) at ./value.go:128:3 +./value.go:120:17: parameter v leaks to ~r0 for expandPath with derefs=0: +./value.go:120:17: flow: ~r0 ← v: +./value.go:120:17: from return v, nil (return) at ./value.go:132:2 +./value.go:120:17: leaking param: v to result ~r0 level=0 +./value.go:120:20: home does not escape +./value.go:128:15: home + v[1:] escapes to heap +./config.go:267:21: &ValueError{...} escapes to heap in Entry.Path: +./config.go:267:21: flow: ~r0 ← &{storage for &ValueError{...}}: +./config.go:267:21: from &ValueError{...} (spill) at ./config.go:267:21 +./config.go:267:21: from &ValueError{...} (interface-converted) at ./config.go:267:21 +./config.go:267:21: from ~r0 = &ValueError{...} (assign-pair) at ./config.go:267:21 +./config.go:267:21: flow: ~r1 ← ~r0: +./config.go:267:21: from return "", ~r0 (return) at ./config.go:267:3 +./config.go:271:21: &ValueError{...} escapes to heap in Entry.Path: +./config.go:271:21: flow: ~r0 ← &{storage for &ValueError{...}}: +./config.go:271:21: from &ValueError{...} (spill) at ./config.go:271:21 +./config.go:271:21: from &ValueError{...} (interface-converted) at ./config.go:271:21 +./config.go:271:21: from ~r0 = &ValueError{...} (assign-pair) at ./config.go:271:21 +./config.go:271:21: flow: ~r1 ← ~r0: +./config.go:271:21: from return "", ~r0 (return) at ./config.go:271:3 +./config.go:265:7: parameter e leaks to ~r0 for Entry.Path with derefs=0: +./config.go:265:7: flow: .autotmp_6 ← e: +./config.go:265:7: from e.Value (dot) at ./config.go:269:24 +./config.go:265:7: from expandPath(e.Value, home) (call parameter) at ./config.go:269:22 +./config.go:265:7: flow: p ← .autotmp_6: +./config.go:265:7: from p, err := string(.autotmp_6), .autotmp_7 (assign-pair) at ./config.go:269:9 +./config.go:265:7: flow: ~r0 ← p: +./config.go:265:7: from return p, nil (return) at ./config.go:273:2 +./config.go:265:7: parameter e leaks to {storage for &ValueError{...}} for Entry.Path with derefs=0: +./config.go:265:7: flow: e ← e: +./config.go:265:7: from e, typ, err := e, "path", err (assign-pair) at ./config.go:271:21 +./config.go:265:7: flow: {storage for &ValueError{...}} ← e: +./config.go:265:7: from ValueError{...} (struct literal element) at ./config.go:271:21 +./config.go:265:7: parameter e leaks to {storage for &ValueError{...}} for Entry.Path with derefs=0: +./config.go:265:7: flow: e ← e: +./config.go:265:7: from e, typ, err := e, "path", nil (assign-pair) at ./config.go:267:21 +./config.go:265:7: flow: {storage for &ValueError{...}} ← e: +./config.go:265:7: from ValueError{...} (struct literal element) at ./config.go:267:21 +./config.go:265:7: leaking param: e +./config.go:265:21: home does not escape +./config.go:267:21: &ValueError{...} escapes to heap +./config.go:271:21: &ValueError{...} escapes to heap +./config.go:177:34: parameter def leaks to {heap} for (*Config).Path with derefs=0: +./config.go:177:34: flow: e ← def: +./config.go:177:34: from Entry{...} (struct literal element) at ./config.go:181:12 +./config.go:177:34: from e = Entry{...} (assign) at ./config.go:181:5 +./config.go:177:34: flow: {heap} ← e: +./config.go:177:34: from Entry.Path(e, home) (call parameter) at ./config.go:183:18 +./config.go:177:7: parameter c leaks to {heap} for (*Config).Path with derefs=2: +./config.go:177:7: flow: .autotmp_8 ← **c: +./config.go:177:7: from (*Config).Get(c, key) (call parameter) at ./config.go:178:16 +./config.go:177:7: flow: e ← .autotmp_8: +./config.go:177:7: from e, ok := Entry(.autotmp_8), .autotmp_9 (assign-pair) at ./config.go:178:8 +./config.go:177:7: flow: {heap} ← e: +./config.go:177:7: from Entry.Path(e, home) (call parameter) at ./config.go:183:18 +./config.go:177:23: parameter key leaks to {heap} for (*Config).Path with derefs=0: +./config.go:177:23: flow: {temp} ← key: +./config.go:177:23: from parseKey(key) (call parameter) at ./config.go:180:19 +./config.go:177:23: flow: .autotmp_11 ← {temp}: +./config.go:177:23: flow: k ← .autotmp_11: +./config.go:177:23: from k, _ := Key(.autotmp_11), 0 (assign-pair) at ./config.go:180:8 +./config.go:177:23: flow: e ← k: +./config.go:177:23: from Entry{...} (struct literal element) at ./config.go:181:12 +./config.go:177:23: from e = Entry{...} (assign) at ./config.go:181:5 +./config.go:177:23: flow: {heap} ← e: +./config.go:177:23: from Entry.Path(e, home) (call parameter) at ./config.go:183:18 +./config.go:177:34: parameter def leaks to ~r0 for (*Config).Path with derefs=0: +./config.go:177:34: flow: ~r0 ← def: +./config.go:177:34: from return def, err (return) at ./config.go:185:3 +./config.go:177:7: leaking param content: c +./config.go:177:23: leaking param: key +./config.go:177:28: home does not escape +./config.go:177:34: leaking param: def +./config.go:192:9: &ValueError{...} escapes to heap in Entry.error: +./config.go:192:9: flow: ~r0 ← &{storage for &ValueError{...}}: +./config.go:192:9: from &ValueError{...} (spill) at ./config.go:192:9 +./config.go:192:9: from &ValueError{...} (interface-converted) at ./config.go:192:9 +./config.go:192:9: from return &ValueError{...} (return) at ./config.go:192:2 +./config.go:191:7: parameter e leaks to {storage for &ValueError{...}} for Entry.error with derefs=0: +./config.go:191:7: flow: {storage for &ValueError{...}} ← e: +./config.go:191:7: from ValueError{...} (struct literal element) at ./config.go:192:20 +./config.go:191:22: parameter typ leaks to {storage for &ValueError{...}} for Entry.error with derefs=0: +./config.go:191:22: flow: {storage for &ValueError{...}} ← typ: +./config.go:191:22: from ValueError{...} (struct literal element) at ./config.go:192:20 +./config.go:191:34: parameter err leaks to {storage for &ValueError{...}} for Entry.error with derefs=0: +./config.go:191:34: flow: {storage for &ValueError{...}} ← err: +./config.go:191:34: from ValueError{...} (struct literal element) at ./config.go:192:20 +./config.go:191:7: leaking param: e +./config.go:191:22: leaking param: typ +./config.go:191:34: leaking param: err +./config.go:192:9: &ValueError{...} escapes to heap +./discover.go:20:25: parameter key leaks to {heap} for osEnviron.Lookup with derefs=0: +./discover.go:20:25: flow: {heap} ← key: +./discover.go:20:25: from os.LookupEnv(key) (call parameter) at ./discover.go:20:73 +./discover.go:20:25: leaking param: key +./discover.go:22:10: parameter env leaks to {heap} for get with derefs=0: +./discover.go:22:10: flow: {heap} ← env: +./discover.go:22:10: from env.Lookup(key) (call parameter) at ./discover.go:23:20 +./discover.go:22:23: parameter key leaks to {heap} for get with derefs=0: +./discover.go:22:23: flow: {heap} ← key: +./discover.go:22:23: from env.Lookup(key) (call parameter) at ./discover.go:23:20 +./discover.go:22:10: leaking param: env +./discover.go:22:23: leaking param: key +./discover.go:123:43: "GIT_CONFIG_KEY_" + ~r0 escapes to heap in countEntries: +./discover.go:123:43: flow: {heap} ← &{storage for "GIT_CONFIG_KEY_" + ~r0}: +./discover.go:123:43: from "GIT_CONFIG_KEY_" + ~r0 (spill) at ./discover.go:123:43 +./discover.go:123:43: from env.Lookup("GIT_CONFIG_KEY_" + ~r0) (call parameter) at ./discover.go:123:24 +./discover.go:127:47: "GIT_CONFIG_VALUE_" + ~r0 escapes to heap in countEntries: +./discover.go:127:47: flow: {heap} ← &{storage for "GIT_CONFIG_VALUE_" + ~r0}: +./discover.go:127:47: from "GIT_CONFIG_VALUE_" + ~r0 (spill) at ./discover.go:127:47 +./discover.go:127:47: from env.Lookup("GIT_CONFIG_VALUE_" + ~r0) (call parameter) at ./discover.go:127:26 +./discover.go:112:19: parameter env leaks to {heap} for countEntries with derefs=0: +./discover.go:112:19: flow: {heap} ← env: +./discover.go:112:19: from env.Lookup("GIT_CONFIG_KEY_" + ~r0) (call parameter) at ./discover.go:123:24 +./discover.go:119:76: count escapes to heap in countEntries: +./discover.go:119:76: flow: {storage for ... argument} ← &{storage for count}: +./discover.go:119:76: from count (spill) at ./discover.go:119:76 +./discover.go:119:76: from ... argument (slice-literal-element) at ./discover.go:119:25 +./discover.go:119:76: flow: fmt.a ← &{storage for ... argument}: +./discover.go:119:76: from ... argument (spill) at ./discover.go:119:25 +./discover.go:119:76: from fmt.format, fmt.a := "gitconfig: bogus count in GIT_CONFIG_COUNT: %q", ... argument (assign-pair) at ./discover.go:119:25 +./discover.go:119:76: flow: {heap} ← *fmt.a: +./discover.go:119:76: from fmt.errorf(fmt.format, fmt.a...) (call parameter) at ./discover.go:119:25 +./discover.go:125:78: i escapes to heap in countEntries: +./discover.go:125:78: flow: {storage for ... argument} ← &{storage for i}: +./discover.go:125:78: from i (spill) at ./discover.go:125:78 +./discover.go:125:78: from ... argument (slice-literal-element) at ./discover.go:125:26 +./discover.go:125:78: flow: fmt.a ← &{storage for ... argument}: +./discover.go:125:78: from ... argument (spill) at ./discover.go:125:26 +./discover.go:125:78: from fmt.format, fmt.a := "gitconfig: missing config key GIT_CONFIG_KEY_%d", ... argument (assign-pair) at ./discover.go:125:26 +./discover.go:125:78: flow: {heap} ← *fmt.a: +./discover.go:125:78: from fmt.errorf(fmt.format, fmt.a...) (call parameter) at ./discover.go:125:26 +./discover.go:129:82: i escapes to heap in countEntries: +./discover.go:129:82: flow: {storage for ... argument} ← &{storage for i}: +./discover.go:129:82: from i (spill) at ./discover.go:129:82 +./discover.go:129:82: from ... argument (slice-literal-element) at ./discover.go:129:26 +./discover.go:129:82: flow: fmt.a ← &{storage for ... argument}: +./discover.go:129:82: from ... argument (spill) at ./discover.go:129:26 +./discover.go:129:82: from fmt.format, fmt.a := "gitconfig: missing config value GIT_CONFIG_VALUE_%d", ... argument (assign-pair) at ./discover.go:129:26 +./discover.go:129:82: flow: {heap} ← *fmt.a: +./discover.go:129:82: from fmt.errorf(fmt.format, fmt.a...) (call parameter) at ./discover.go:129:26 +./discover.go:119:25: &errors.errorString{...} escapes to heap in countEntries: +./discover.go:119:25: flow: ~r0 ← &{storage for &errors.errorString{...}}: +./discover.go:119:25: from &errors.errorString{...} (spill) at ./discover.go:119:25 +./discover.go:119:25: from &errors.errorString{...} (interface-converted) at ./discover.go:119:25 +./discover.go:119:25: from ~r0 = &errors.errorString{...} (assign-pair) at ./discover.go:119:25 +./discover.go:119:25: flow: fmt.err ← ~r0: +./discover.go:119:25: from fmt.err = ~r0 (assign-pair) at ./discover.go:119:25 +./discover.go:119:25: flow: ~r1 ← fmt.err: +./discover.go:119:25: from return nil, fmt.err (return) at ./discover.go:119:3 +./discover.go:125:26: &errors.errorString{...} escapes to heap in countEntries: +./discover.go:125:26: flow: ~r0 ← &{storage for &errors.errorString{...}}: +./discover.go:125:26: from &errors.errorString{...} (spill) at ./discover.go:125:26 +./discover.go:125:26: from &errors.errorString{...} (interface-converted) at ./discover.go:125:26 +./discover.go:125:26: from ~r0 = &errors.errorString{...} (assign-pair) at ./discover.go:125:26 +./discover.go:125:26: flow: fmt.err ← ~r0: +./discover.go:125:26: from fmt.err = ~r0 (assign-pair) at ./discover.go:125:26 +./discover.go:125:26: flow: ~r1 ← fmt.err: +./discover.go:125:26: from return nil, fmt.err (return) at ./discover.go:125:4 +./discover.go:129:26: &errors.errorString{...} escapes to heap in countEntries: +./discover.go:129:26: flow: ~r0 ← &{storage for &errors.errorString{...}}: +./discover.go:129:26: from &errors.errorString{...} (spill) at ./discover.go:129:26 +./discover.go:129:26: from &errors.errorString{...} (interface-converted) at ./discover.go:129:26 +./discover.go:129:26: from ~r0 = &errors.errorString{...} (assign-pair) at ./discover.go:129:26 +./discover.go:129:26: flow: fmt.err ← ~r0: +./discover.go:129:26: from fmt.err = ~r0 (assign-pair) at ./discover.go:129:26 +./discover.go:129:26: flow: ~r1 ← fmt.err: +./discover.go:129:26: from return nil, fmt.err (return) at ./discover.go:129:4 +./discover.go:131:19: append(entries, CommandEntry{...}) escapes to heap in countEntries: +./discover.go:131:19: flow: entries ← &{storage for append(entries, CommandEntry{...})}: +./discover.go:131:19: from append(entries, CommandEntry{...}) (spill) at ./discover.go:131:19 +./discover.go:131:19: from entries = append(entries, CommandEntry{...}) (assign) at ./discover.go:131:11 +./discover.go:131:19: flow: ~r0 ← entries: +./discover.go:131:19: from return entries, nil (return) at ./discover.go:133:2 +./discover.go:112:19: leaking param: env +./discover.go:119:25: ... argument does not escape +./discover.go:119:76: count escapes to heap +./discover.go:119:25: &errors.errorString{...} escapes to heap +./discover.go:123:43: "GIT_CONFIG_KEY_" + ~r0 escapes to heap +./discover.go:125:26: ... argument does not escape +./discover.go:125:78: i escapes to heap +./discover.go:125:26: &errors.errorString{...} escapes to heap +./discover.go:127:47: "GIT_CONFIG_VALUE_" + ~r0 escapes to heap +./discover.go:129:26: ... argument does not escape +./discover.go:129:82: i escapes to heap +./discover.go:129:26: &errors.errorString{...} escapes to heap +./discover.go:131:19: append escapes to heap +./discover.go:197:17: "strings: illegal use of non-zero Builder copied by value" escapes to heap in unquote: +./discover.go:197:17: flow: {heap} ← &{storage for "strings: illegal use of non-zero Builder copied by value"}: +./discover.go:197:17: from "strings: illegal use of non-zero Builder copied by value" (spill) at ./discover.go:197:17 +./discover.go:197:17: from panic("strings: illegal use of non-zero Builder copied by value") (call parameter) at ./discover.go:197:17 +./discover.go:197:17: append(strings.b.buf, strings.s...) escapes to heap in unquote: +./discover.go:197:17: flow: {heap} ← &{storage for append(strings.b.buf, strings.s...)}: +./discover.go:197:17: from append(strings.b.buf, strings.s...) (spill) at ./discover.go:197:17 +./discover.go:197:17: from strings.b.buf = append(strings.b.buf, strings.s...) (assign) at ./discover.go:197:17 +./discover.go:200:16: "strings: illegal use of non-zero Builder copied by value" escapes to heap in unquote: +./discover.go:200:16: flow: {heap} ← &{storage for "strings: illegal use of non-zero Builder copied by value"}: +./discover.go:200:16: from "strings: illegal use of non-zero Builder copied by value" (spill) at ./discover.go:200:16 +./discover.go:200:16: from panic("strings: illegal use of non-zero Builder copied by value") (call parameter) at ./discover.go:200:16 +./discover.go:200:16: append(strings.b.buf, strings.c) escapes to heap in unquote: +./discover.go:200:16: flow: {heap} ← &{storage for append(strings.b.buf, strings.c)}: +./discover.go:200:16: from append(strings.b.buf, strings.c) (spill) at ./discover.go:200:16 +./discover.go:200:16: from strings.b.buf = append(strings.b.buf, strings.c) (assign) at ./discover.go:200:16 +./discover.go:186:14: parameter s leaks to rest for unquote with derefs=0: +./discover.go:186:14: flow: rest ← s: +./discover.go:186:14: from return ~r0, s, true (return) at ./discover.go:204:3 +./discover.go:186:14: leaking param: s to result rest level=0 +./discover.go:197:17: "strings: illegal use of non-zero Builder copied by value" escapes to heap +./discover.go:197:17: append escapes to heap +./discover.go:200:16: "strings: illegal use of non-zero Builder copied by value" escapes to heap +./discover.go:200:16: append escapes to heap +./discover.go:175:19: append(entries, c) escapes to heap in parseParameters: +./discover.go:175:19: flow: entries ← &{storage for append(entries, c)}: +./discover.go:175:19: from append(entries, c) (spill) at ./discover.go:175:19 +./discover.go:175:19: from entries = append(entries, c) (assign) at ./discover.go:175:11 +./discover.go:175:19: flow: ~r0 ← entries: +./discover.go:175:19: from return entries, nil (return) at ./discover.go:178:2 +./discover.go:148:22: s does not escape +./discover.go:175:19: append escapes to heap +./platform.go:37:19: syscall.Errno(5) escapes to heap in transient: +./platform.go:37:19: flow: {heap} ← &{storage for syscall.Errno(5)}: +./platform.go:37:19: from syscall.Errno(5) (spill) at ./platform.go:37:19 +./platform.go:37:19: from errors.Is(err, syscall.Errno(5)) (call parameter) at ./platform.go:37:13 +./platform.go:37:56: syscall.Errno(32) escapes to heap in transient: +./platform.go:37:56: flow: {heap} ← &{storage for syscall.Errno(32)}: +./platform.go:37:56: from syscall.Errno(32) (spill) at ./platform.go:37:56 +./platform.go:37:56: from errors.Is(err, syscall.Errno(32)) (call parameter) at ./platform.go:37:50 +./platform.go:37:97: syscall.Errno(33) escapes to heap in transient: +./platform.go:37:97: flow: {heap} ← &{storage for syscall.Errno(33)}: +./platform.go:37:97: from syscall.Errno(33) (spill) at ./platform.go:37:97 +./platform.go:37:97: from errors.Is(err, syscall.Errno(33)) (call parameter) at ./platform.go:37:91 +./platform.go:35:16: parameter err leaks to {heap} for transient with derefs=0: +./platform.go:35:16: flow: {heap} ← err: +./platform.go:35:16: from errors.Is(err, syscall.Errno(5)) (call parameter) at ./platform.go:37:13 +./platform.go:35:16: leaking param: err +./platform.go:37:19: syscall.Errno(5) escapes to heap +./platform.go:37:56: syscall.Errno(32) escapes to heap +./platform.go:37:97: syscall.Errno(33) escapes to heap +./platform.go:43:21: fn does not escape +./load.go:130:21: readConfigFile capturing by value: path (addr=false assign=false width=16) +./load.go:130:34: readConfigFile capturing by value: limit (addr=false assign=false width=8) +./load.go:134:6: readConfigFile capturing by ref: data (addr=false assign=true width=24) +./load.go:140:3: readConfigFile.func1 capturing by value: .autotmp_5 (addr=false assign=false width=8) +./load.go:130:21: parameter path leaks to {heap} for readConfigFile with derefs=0: +./load.go:130:21: flow: path ← path: +./load.go:130:21: from path := path (assign-pair) at ./load.go:136:24 +./load.go:130:21: flow: {heap} ← path: +./load.go:130:21: from os.OpenFile(path, flag, fs.FileMode(0)) (call parameter) at ./load.go:136:24 +./load.go:151:40: &io.LimitedReader{...} escapes to heap in readConfigFile.func1: +./load.go:151:40: flow: ~r0 ← &{storage for &io.LimitedReader{...}}: +./load.go:151:40: from &io.LimitedReader{...} (spill) at ./load.go:151:40 +./load.go:151:40: from &io.LimitedReader{...} (interface-converted) at ./load.go:151:40 +./load.go:151:40: from ~r0 = &io.LimitedReader{...} (assign-pair) at ./load.go:151:40 +./load.go:151:40: flow: {heap} ← ~r0: +./load.go:151:40: from io.ReadAll(~r0) (call parameter) at ./load.go:151:25 +./load.go:130:21: leaking param: path +./load.go:135:24: func literal does not escape +./load.go:151:40: &io.LimitedReader{...} escapes to heap +./discover.go:86:20: parameter gitDir leaks to {heap} for resolveGitDir with derefs=0: +./discover.go:86:20: flow: {heap} ← gitDir: +./discover.go:86:20: from os.Stat(gitDir) (call parameter) at ./discover.go:91:20 +./discover.go:97:14: &FileError{...} escapes to heap in resolveGitDir: +./discover.go:97:14: flow: ~r1 ← &{storage for &FileError{...}}: +./discover.go:97:14: from &FileError{...} (spill) at ./discover.go:97:14 +./discover.go:97:14: from &FileError{...} (interface-converted) at ./discover.go:97:14 +./discover.go:97:14: from return "", &FileError{...} (return) at ./discover.go:97:3 +./discover.go:101:14: &FileError{...} escapes to heap in resolveGitDir: +./discover.go:101:14: flow: ~r1 ← &{storage for &FileError{...}}: +./discover.go:101:14: from &FileError{...} (spill) at ./discover.go:101:14 +./discover.go:101:14: from &FileError{...} (interface-converted) at ./discover.go:101:14 +./discover.go:101:14: from return "", &FileError{...} (return) at ./discover.go:101:3 +./discover.go:86:20: parameter gitDir leaks to {storage for &FileError{...}} for resolveGitDir with derefs=0: +./discover.go:86:20: flow: {storage for &FileError{...}} ← gitDir: +./discover.go:86:20: from FileError{...} (struct literal element) at ./discover.go:101:24 +./discover.go:101:54: &errors.errorString{...} escapes to heap in resolveGitDir: +./discover.go:101:54: flow: ~r0 ← &{storage for &errors.errorString{...}}: +./discover.go:101:54: from &errors.errorString{...} (spill) at ./discover.go:101:54 +./discover.go:101:54: from &errors.errorString{...} (interface-converted) at ./discover.go:101:54 +./discover.go:101:54: from ~r0 = &errors.errorString{...} (assign-pair) at ./discover.go:101:54 +./discover.go:101:54: flow: {storage for &FileError{...}} ← ~r0: +./discover.go:101:54: from FileError{...} (struct literal element) at ./discover.go:101:24 +./discover.go:86:20: parameter gitDir leaks to {storage for &FileError{...}} for resolveGitDir with derefs=0: +./discover.go:86:20: flow: {storage for &FileError{...}} ← gitDir: +./discover.go:86:20: from FileError{...} (struct literal element) at ./discover.go:97:24 +./discover.go:86:20: parameter gitDir leaks to ~r0 for resolveGitDir with derefs=0: +./discover.go:86:20: flow: ~r0 ← gitDir: +./discover.go:86:20: from return gitDir, nil (return) at ./discover.go:93:3 +./discover.go:99:57: string(data) escapes to heap in resolveGitDir: +./discover.go:99:57: flow: strings.s ← &{storage for string(data)}: +./discover.go:99:57: from string(data) (spill) at ./discover.go:99:57 +./discover.go:99:57: from strings.TrimRight(string(data), "\r\n") (call parameter) at ./discover.go:99:49 +./discover.go:99:57: from strings.s, strings.prefix := strings.TrimRight(string(data), "\r\n"), "gitdir: " (assign-pair) at ./discover.go:99:31 +./discover.go:99:57: flow: stringslite.s ← strings.s: +./discover.go:99:57: from stringslite.s, stringslite.prefix := strings.s, strings.prefix (assign-pair) at ./discover.go:99:31 +./discover.go:99:57: flow: stringslite.after ← stringslite.s: +./discover.go:99:57: from stringslite.after, stringslite.found = stringslite.s, false (assign-pair) at ./discover.go:99:31 +./discover.go:99:57: flow: .autotmp_4 ← stringslite.after: +./discover.go:99:57: flow: strings.after ← .autotmp_4: +./discover.go:99:57: from strings.after, strings.found = string(.autotmp_4), .autotmp_5 (assign-pair) at ./discover.go:99:31 +./discover.go:99:57: flow: .autotmp_14 ← strings.after: +./discover.go:99:57: flow: path ← .autotmp_14: +./discover.go:99:57: from path, ok := string(.autotmp_14), .autotmp_15 (assign-pair) at ./discover.go:99:11 +./discover.go:99:57: flow: ~r0 ← path: +./discover.go:99:57: from return path, nil (return) at ./discover.go:106:2 +./discover.go:86:20: leaking param: gitDir +./discover.go:97:14: &FileError{...} escapes to heap +./discover.go:99:57: string(data) escapes to heap +./discover.go:101:14: &FileError{...} escapes to heap +./discover.go:101:54: &errors.errorString{...} escapes to heap +./discover.go:104:23: ... argument does not escape +./discover.go:27:30: parameter env leaks to {heap} for discover with derefs=0: +./discover.go:27:30: flow: {heap} ← env: +./discover.go:27:30: from env.Lookup("GIT_CONFIG_GLOBAL") (call parameter) at ./discover.go:35:24 +./discover.go:27:15: parameter gitDir leaks to {heap} for discover with derefs=0: +./discover.go:27:15: flow: {heap} ← gitDir: +./discover.go:27:15: from resolveGitDir(gitDir) (call parameter) at ./discover.go:77:32 +./discover.go:54:100: v escapes to heap in discover: +./discover.go:54:100: flow: {storage for ... argument} ← &{storage for v}: +./discover.go:54:100: from v (spill) at ./discover.go:54:100 +./discover.go:54:100: from ... argument (slice-literal-element) at ./discover.go:54:28 +./discover.go:54:100: flow: fmt.a ← &{storage for ... argument}: +./discover.go:54:100: from ... argument (spill) at ./discover.go:54:28 +./discover.go:54:100: from fmt.format, fmt.a := "gitconfig: bad boolean environment value %q for GIT_CONFIG_NOSYSTEM", ... argument (assign-pair) at ./discover.go:54:28 +./discover.go:54:100: flow: {heap} ← *fmt.a: +./discover.go:54:100: from fmt.errorf(fmt.format, fmt.a...) (call parameter) at ./discover.go:54:28 +./discover.go:37:29: []string{...} escapes to heap in discover: +./discover.go:37:29: flow: e ← &{storage for []string{...}}: +./discover.go:37:29: from []string{...} (spill) at ./discover.go:37:29 +./discover.go:37:29: from e.GlobalConfig = []string{...} (assign) at ./discover.go:37:19 +./discover.go:37:29: flow: {storage for ... argument} ← e: +./discover.go:37:29: from e.Home (dot) at ./discover.go:43:59 +./discover.go:37:29: from ... argument (slice-literal-element) at ./discover.go:43:57 +./discover.go:37:29: flow: filepath.elem ← &{storage for ... argument}: +./discover.go:37:29: from ... argument (spill) at ./discover.go:43:57 +./discover.go:37:29: from filepath.elem := ... argument (assign-pair) at ./discover.go:43:57 +./discover.go:37:29: flow: {temp} ← filepath.elem: +./discover.go:37:29: from filepath.join(filepath.elem) (call parameter) at ./discover.go:43:57 +./discover.go:37:29: flow: ~r0 ← *{temp}: +./discover.go:37:29: from ~r0 = filepath.join(filepath.elem) (assign-pair) at ./discover.go:43:57 +./discover.go:37:29: flow: {heap} ← ~r0: +./discover.go:37:29: from append(e.GlobalConfig, ~r0) (call parameter) at ./discover.go:43:27 +./discover.go:41:27: append(e.GlobalConfig, ~r0) escapes to heap in discover: +./discover.go:41:27: flow: e ← &{storage for append(e.GlobalConfig, ~r0)}: +./discover.go:41:27: from append(e.GlobalConfig, ~r0) (spill) at ./discover.go:41:27 +./discover.go:41:27: from e.GlobalConfig = append(e.GlobalConfig, ~r0) (assign) at ./discover.go:41:19 +./discover.go:41:27: flow: {storage for ... argument} ← e: +./discover.go:41:27: from e.Home (dot) at ./discover.go:43:59 +./discover.go:41:27: from ... argument (slice-literal-element) at ./discover.go:43:57 +./discover.go:41:27: flow: filepath.elem ← &{storage for ... argument}: +./discover.go:41:27: from ... argument (spill) at ./discover.go:43:57 +./discover.go:41:27: from filepath.elem := ... argument (assign-pair) at ./discover.go:43:57 +./discover.go:41:27: flow: {temp} ← filepath.elem: +./discover.go:41:27: from filepath.join(filepath.elem) (call parameter) at ./discover.go:43:57 +./discover.go:41:27: flow: ~r0 ← *{temp}: +./discover.go:41:27: from ~r0 = filepath.join(filepath.elem) (assign-pair) at ./discover.go:43:57 +./discover.go:41:27: flow: {heap} ← ~r0: +./discover.go:41:27: from append(e.GlobalConfig, ~r0) (call parameter) at ./discover.go:43:27 +./discover.go:43:27: append(e.GlobalConfig, ~r0) escapes to heap in discover: +./discover.go:43:27: flow: e ← &{storage for append(e.GlobalConfig, ~r0)}: +./discover.go:43:27: from append(e.GlobalConfig, ~r0) (spill) at ./discover.go:43:27 +./discover.go:43:27: from e.GlobalConfig = append(e.GlobalConfig, ~r0) (assign) at ./discover.go:43:19 +./discover.go:43:27: flow: {storage for ... argument} ← e: +./discover.go:43:27: from e.Home (dot) at ./discover.go:43:59 +./discover.go:43:27: from ... argument (slice-literal-element) at ./discover.go:43:57 +./discover.go:43:27: flow: filepath.elem ← &{storage for ... argument}: +./discover.go:43:27: from ... argument (spill) at ./discover.go:43:57 +./discover.go:43:27: from filepath.elem := ... argument (assign-pair) at ./discover.go:43:57 +./discover.go:43:27: flow: {temp} ← filepath.elem: +./discover.go:43:27: from filepath.join(filepath.elem) (call parameter) at ./discover.go:43:57 +./discover.go:43:27: flow: ~r0 ← *{temp}: +./discover.go:43:27: from ~r0 = filepath.join(filepath.elem) (assign-pair) at ./discover.go:43:57 +./discover.go:43:27: flow: {heap} ← ~r0: +./discover.go:43:27: from append(e.GlobalConfig, ~r0) (call parameter) at ./discover.go:43:27 +./discover.go:46:27: append(e.GlobalConfig, ~r0) escapes to heap in discover: +./discover.go:46:27: flow: e ← &{storage for append(e.GlobalConfig, ~r0)}: +./discover.go:46:27: from append(e.GlobalConfig, ~r0) (spill) at ./discover.go:46:27 +./discover.go:46:27: from e.GlobalConfig = append(e.GlobalConfig, ~r0) (assign) at ./discover.go:46:19 +./discover.go:46:27: flow: {storage for ... argument} ← e: +./discover.go:46:27: from e.Home (dot) at ./discover.go:43:59 +./discover.go:46:27: from ... argument (slice-literal-element) at ./discover.go:43:57 +./discover.go:46:27: flow: filepath.elem ← &{storage for ... argument}: +./discover.go:46:27: from ... argument (spill) at ./discover.go:43:57 +./discover.go:46:27: from filepath.elem := ... argument (assign-pair) at ./discover.go:43:57 +./discover.go:46:27: flow: {temp} ← filepath.elem: +./discover.go:46:27: from filepath.join(filepath.elem) (call parameter) at ./discover.go:43:57 +./discover.go:46:27: flow: ~r0 ← *{temp}: +./discover.go:46:27: from ~r0 = filepath.join(filepath.elem) (assign-pair) at ./discover.go:43:57 +./discover.go:46:27: flow: {heap} ← ~r0: +./discover.go:46:27: from append(e.GlobalConfig, ~r0) (call parameter) at ./discover.go:43:27 +./discover.go:74:20: append(cmd, params...) escapes to heap in discover: +./discover.go:74:20: flow: e ← &{storage for append(cmd, params...)}: +./discover.go:74:20: from append(cmd, params...) (spill) at ./discover.go:74:20 +./discover.go:74:20: from e.Command = append(cmd, params...) (assign) at ./discover.go:74:12 +./discover.go:74:20: flow: {storage for ... argument} ← e: +./discover.go:74:20: from e.Home (dot) at ./discover.go:43:59 +./discover.go:74:20: from ... argument (slice-literal-element) at ./discover.go:43:57 +./discover.go:74:20: flow: filepath.elem ← &{storage for ... argument}: +./discover.go:74:20: from ... argument (spill) at ./discover.go:43:57 +./discover.go:74:20: from filepath.elem := ... argument (assign-pair) at ./discover.go:43:57 +./discover.go:74:20: flow: {temp} ← filepath.elem: +./discover.go:74:20: from filepath.join(filepath.elem) (call parameter) at ./discover.go:43:57 +./discover.go:74:20: flow: ~r0 ← *{temp}: +./discover.go:74:20: from ~r0 = filepath.join(filepath.elem) (assign-pair) at ./discover.go:43:57 +./discover.go:74:20: flow: {heap} ← ~r0: +./discover.go:74:20: from append(e.GlobalConfig, ~r0) (call parameter) at ./discover.go:43:27 +./discover.go:54:28: &errors.errorString{...} escapes to heap in discover: +./discover.go:54:28: flow: ~r0 ← &{storage for &errors.errorString{...}}: +./discover.go:54:28: from &errors.errorString{...} (spill) at ./discover.go:54:28 +./discover.go:54:28: from &errors.errorString{...} (interface-converted) at ./discover.go:54:28 +./discover.go:54:28: from ~r0 = &errors.errorString{...} (assign-pair) at ./discover.go:54:28 +./discover.go:54:28: flow: fmt.err ← ~r0: +./discover.go:54:28: from fmt.err = ~r0 (assign-pair) at ./discover.go:54:28 +./discover.go:54:28: flow: ~r1 ← fmt.err: +./discover.go:54:28: from return Env{}, fmt.err (return) at ./discover.go:54:4 +./discover.go:27:15: leaking param: gitDir +./discover.go:27:30: leaking param: env +./discover.go:37:29: []string{...} escapes to heap +./discover.go:41:57: ... argument does not escape +./discover.go:41:27: append escapes to heap +./discover.go:43:57: ... argument does not escape +./discover.go:43:27: append escapes to heap +./discover.go:46:57: ... argument does not escape +./discover.go:46:27: append escapes to heap +./discover.go:54:28: ... argument does not escape +./discover.go:54:100: v escapes to heap +./discover.go:54:28: &errors.errorString{...} escapes to heap +./discover.go:74:20: append escapes to heap +./edit.go:31:29: &KeyError{...} escapes to heap in editKey: +./edit.go:31:29: flow: err ← &{storage for &KeyError{...}}: +./edit.go:31:29: from &KeyError{...} (spill) at ./edit.go:31:29 +./edit.go:31:29: from &KeyError{...} (interface-converted) at ./edit.go:31:29 +./edit.go:31:29: from return Key{}, "", "", "", &KeyError{...} (return) at ./edit.go:31:3 +./edit.go:28:14: parameter key leaks to {storage for &KeyError{...}} for editKey with derefs=0: +./edit.go:28:14: flow: {storage for &KeyError{...}} ← key: +./edit.go:28:14: from KeyError{...} (struct literal element) at ./edit.go:31:38 +./edit.go:28:14: parameter key leaks to name for editKey with derefs=0: +./edit.go:28:14: flow: name ← key: +./edit.go:28:14: from key[last + 1:] (slice) at ./edit.go:35:34 +./edit.go:28:14: from section, name = key[:first], key[last + 1:] (assign-pair) at ./edit.go:35:16 +./edit.go:28:14: parameter key leaks to sub for editKey with derefs=0: +./edit.go:28:14: flow: sub ← key: +./edit.go:28:14: from key[first + 1:last] (slice) at ./edit.go:37:12 +./edit.go:28:14: from sub = key[first + 1:last] (assign) at ./edit.go:37:7 +./edit.go:28:14: parameter key leaks to section for editKey with derefs=0: +./edit.go:28:14: flow: section ← key: +./edit.go:28:14: from key[:first] (slice) at ./edit.go:35:21 +./edit.go:28:14: from section, name = key[:first], key[last + 1:] (assign-pair) at ./edit.go:35:16 +./edit.go:28:14: parameter key leaks to k for editKey with derefs=0: +./edit.go:28:14: flow: {temp} ← key: +./edit.go:28:14: from parseKey(key) (call parameter) at ./edit.go:29:19 +./edit.go:28:14: flow: .autotmp_7 ← {temp}: +./edit.go:28:14: flow: k ← .autotmp_7: +./edit.go:28:14: from k, ok := Key(.autotmp_7), .autotmp_8 (assign-pair) at ./edit.go:29:8 +./edit.go:28:14: leaking param: key +./edit.go:31:29: &KeyError{...} escapes to heap +./edit.go:61:10: &KeyError{...} escapes to heap in checkValue: +./edit.go:61:10: flow: ~r0 ← &{storage for &KeyError{...}}: +./edit.go:61:10: from &KeyError{...} (spill) at ./edit.go:61:10 +./edit.go:61:10: from &KeyError{...} (interface-converted) at ./edit.go:61:10 +./edit.go:61:10: from return &KeyError{...} (return) at ./edit.go:61:3 +./edit.go:59:17: parameter key leaks to {storage for &KeyError{...}} for checkValue with derefs=0: +./edit.go:59:17: flow: {storage for &KeyError{...}} ← key: +./edit.go:59:17: from KeyError{...} (struct literal element) at ./edit.go:61:19 +./edit.go:59:17: leaking param: key +./edit.go:59:22: value does not escape +./edit.go:61:10: &KeyError{...} escapes to heap +./edit.go:43:24: parameter key leaks to {heap} for (*File).prepare with derefs=0: +./edit.go:43:24: flow: {heap} ← key: +./edit.go:43:24: from editKey(key) (call parameter) at ./edit.go:47:38 +./edit.go:44:23: &KeyError{...} escapes to heap in (*File).prepare: +./edit.go:44:23: flow: ~r0 ← &{storage for &KeyError{...}}: +./edit.go:44:23: from &KeyError{...} (spill) at ./edit.go:44:23 +./edit.go:44:23: from &KeyError{...} (interface-converted) at ./edit.go:44:23 +./edit.go:44:23: from ~r0 = &KeyError{...} (assign-pair) at ./edit.go:44:23 +./edit.go:44:23: flow: err ← ~r0: +./edit.go:44:23: from err := ~r0 (assign) at ./edit.go:44:9 +./edit.go:44:23: flow: err ← err: +./edit.go:44:23: from return Key{}, "", "", "", err (return) at ./edit.go:45:3 +./edit.go:43:24: parameter key leaks to {storage for &KeyError{...}} for (*File).prepare with derefs=0: +./edit.go:43:24: flow: key ← key: +./edit.go:43:24: from f, key := f, key (assign-pair) at ./edit.go:44:23 +./edit.go:43:24: flow: {storage for &KeyError{...}} ← key: +./edit.go:43:24: from KeyError{...} (struct literal element) at ./edit.go:44:23 +./edit.go:43:7: f does not escape +./edit.go:43:24: leaking param: key +./edit.go:43:36: value does not escape +./edit.go:44:23: &KeyError{...} escapes to heap +./edit.go:68:10: &KeyError{...} escapes to heap in (*File).checkOpen: +./edit.go:68:10: flow: ~r0 ← &{storage for &KeyError{...}}: +./edit.go:68:10: from &KeyError{...} (spill) at ./edit.go:68:10 +./edit.go:68:10: from &KeyError{...} (interface-converted) at ./edit.go:68:10 +./edit.go:68:10: from return &KeyError{...} (return) at ./edit.go:68:3 +./edit.go:66:26: parameter key leaks to {storage for &KeyError{...}} for (*File).checkOpen with derefs=0: +./edit.go:66:26: flow: {storage for &KeyError{...}} ← key: +./edit.go:66:26: from KeyError{...} (struct literal element) at ./edit.go:68:19 +./edit.go:66:7: f does not escape +./edit.go:66:26: leaking param: key +./edit.go:68:10: &KeyError{...} escapes to heap +./edit.go:79:16: append(idx, i) escapes to heap in (*File).entriesOf: +./edit.go:79:16: flow: idx ← &{storage for append(idx, i)}: +./edit.go:79:16: from append(idx, i) (spill) at ./edit.go:79:16 +./edit.go:79:16: from idx = append(idx, i) (assign) at ./edit.go:79:8 +./edit.go:79:16: flow: ~r0 ← idx: +./edit.go:79:16: from return idx (return) at ./edit.go:82:2 +./edit.go:74:7: f does not escape +./edit.go:74:26: k does not escape +./edit.go:79:16: append escapes to heap +./edit.go:95:14: parameter p leaks to {heap} for flatten with derefs=1: +./edit.go:95:14: flow: p ← &p: +./edit.go:95:14: from p (address-of) at ./edit.go:99:47 +./edit.go:95:14: from p, it := p, it (assign-pair) at ./edit.go:99:53 +./edit.go:95:14: flow: ~r0 ← **p: +./edit.go:95:14: from p.secs (dot of pointer) at ./edit.go:99:53 +./edit.go:95:14: from p.secs[it.sec] (dot of pointer) at ./edit.go:99:53 +./edit.go:95:14: from ~r0 = p.secs[it.sec] (assign-pair) at ./edit.go:99:53 +./edit.go:95:14: flow: {heap} ← ~r0: +./edit.go:95:14: from flatEntry{...} (struct literal element) at ./edit.go:99:31 +./edit.go:95:14: from append(out, flatEntry{...}) (call parameter) at ./edit.go:99:16 +./edit.go:99:16: append(out, flatEntry{...}) escapes to heap in flatten: +./edit.go:99:16: flow: out ← &{storage for append(out, flatEntry{...})}: +./edit.go:99:16: from append(out, flatEntry{...}) (spill) at ./edit.go:99:16 +./edit.go:99:16: from out = append(out, flatEntry{...}) (assign) at ./edit.go:99:8 +./edit.go:99:16: flow: ~r0 ← out: +./edit.go:99:16: from return out (return) at ./edit.go:102:2 +./edit.go:95:14: leaking param content: p +./edit.go:99:16: append escapes to heap +./edit.go:105:7: e does not escape +./edit.go:105:23: k does not escape +./edit.go:112:32: a does not escape +./edit.go:112:35: b does not escape +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:33:39: slices.siftDownCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] ignoring self-assignment in slices.data[slices.first + slices.root], slices.data[slices.first + slices.child] = slices.data[slices.first + slices.child], slices.data[slices.first + slices.root] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:33:39: slices.siftDownCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] ignoring self-assignment in slices.data[slices.first + slices.root], slices.data[slices.first + slices.child] = slices.data[slices.first + slices.child], slices.data[slices.first + slices.root] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:20:29: parameter slices.data leaks to {heap} for siftDownCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] with derefs=1: +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:20:29: flow: {heap} ← *slices.data: +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:20:29: from slices.data[slices.first + slices.child] (dot of pointer) at ../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:27:31 +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:20:29: from slices.cmp(slices.data[slices.first + slices.child], slices.data[slices.first + slices.child + 1]) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:27:26 +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:50:30: slices.heapSortCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] ignoring self-assignment in slices.data[slices.first], slices.data[slices.first + slices.i] = slices.data[slices.first + slices.i], slices.data[slices.first] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:50:30: slices.heapSortCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] ignoring self-assignment in slices.data[slices.first], slices.data[slices.first + slices.i] = slices.data[slices.first + slices.i], slices.data[slices.first] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:38:29: parameter slices.data leaks to {heap} for heapSortCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] with derefs=1: +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:38:29: flow: {temp} ← slices.data: +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:38:29: from slices.siftDownCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }]((*[2]uintptr)(slices..dict[0]), slices.data, slices.i, slices.hi, slices.first, slices.cmp) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:45:18 +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:38:29: flow: {heap} ← *{temp}: +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:251:29: slices.breakPatternsCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] ignoring self-assignment in slices.data[slices.idx], slices.data[slices.a + slices.other] = slices.data[slices.a + slices.other], slices.data[slices.idx] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:251:29: slices.breakPatternsCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] ignoring self-assignment in slices.data[slices.idx], slices.data[slices.a + slices.other] = slices.data[slices.a + slices.other], slices.data[slices.idx] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:307:27: parameter slices.data leaks to {heap} for medianCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] with derefs=1: +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:307:27: flow: slices.data ← slices.data: +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:307:27: from slices..dict, slices.data, slices.a, slices.b, slices.swaps, slices.cmp := (*[2]uintptr)(slices..dict[0]), slices.data, slices.a, slices.b, slices.swaps, slices.cmp (assign-pair) at ../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:308:22 +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:307:27: flow: {heap} ← *slices.data: +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:307:27: from slices.data[slices.b] (dot of pointer) at ../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:308:22 +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:307:27: from slices.cmp(slices.data[slices.b], slices.data[slices.a]) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:308:22 +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:261:32: parameter slices.data leaks to {heap} for choosePivotCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] with derefs=1: +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:261:32: flow: {heap} ← *slices.data: +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:261:32: from slices.medianCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }]((*[3]uintptr)(slices..dict[1]), slices.data, slices.i, slices.j, slices.k, &slices.swaps, slices.cmp) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:284:20 +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:214:22: slices.partialInsertionSortCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] ignoring self-assignment in slices.data[slices.i], slices.data[slices.i - 1] = slices.data[slices.i - 1], slices.data[slices.i] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:214:22: slices.partialInsertionSortCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] ignoring self-assignment in slices.data[slices.i], slices.data[slices.i - 1] = slices.data[slices.i - 1], slices.data[slices.i] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:222:24: slices.partialInsertionSortCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] ignoring self-assignment in slices.data[slices.j], slices.data[slices.j - 1] = slices.data[slices.j - 1], slices.data[slices.j] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:222:24: slices.partialInsertionSortCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] ignoring self-assignment in slices.data[slices.j], slices.data[slices.j - 1] = slices.data[slices.j - 1], slices.data[slices.j] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:231:24: slices.partialInsertionSortCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] ignoring self-assignment in slices.data[slices.j], slices.data[slices.j - 1] = slices.data[slices.j - 1], slices.data[slices.j] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:231:24: slices.partialInsertionSortCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] ignoring self-assignment in slices.data[slices.j], slices.data[slices.j - 1] = slices.data[slices.j - 1], slices.data[slices.j] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:195:41: parameter slices.data leaks to {heap} for partialInsertionSortCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] with derefs=1: +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:195:41: flow: {heap} ← *slices.data: +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:195:41: from slices.data[slices.i] (dot of pointer) at ../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:202:26 +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:195:41: from slices.cmp(slices.data[slices.i], slices.data[slices.i - 1]) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:202:21 +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:174:23: slices.partitionEqualCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] ignoring self-assignment in slices.data[slices.a], slices.data[slices.pivot] = slices.data[slices.pivot], slices.data[slices.a] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:174:23: slices.partitionEqualCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] ignoring self-assignment in slices.data[slices.a], slices.data[slices.pivot] = slices.data[slices.pivot], slices.data[slices.a] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:187:20: slices.partitionEqualCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] ignoring self-assignment in slices.data[slices.i], slices.data[slices.j] = slices.data[slices.j], slices.data[slices.i] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:187:20: slices.partitionEqualCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] ignoring self-assignment in slices.data[slices.i], slices.data[slices.j] = slices.data[slices.j], slices.data[slices.i] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:173:35: parameter slices.data leaks to {heap} for partitionEqualCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] with derefs=1: +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:173:35: flow: {heap} ← *slices.data: +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:173:35: from slices.data[slices.a] (dot of pointer) at ../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:178:27 +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:173:35: from slices.cmp(slices.data[slices.a], slices.data[slices.i]) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:178:22 +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:136:23: slices.partitionCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] ignoring self-assignment in slices.data[slices.a], slices.data[slices.pivot] = slices.data[slices.pivot], slices.data[slices.a] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:136:23: slices.partitionCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] ignoring self-assignment in slices.data[slices.a], slices.data[slices.pivot] = slices.data[slices.pivot], slices.data[slices.a] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:146:20: slices.partitionCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] ignoring self-assignment in slices.data[slices.j], slices.data[slices.a] = slices.data[slices.a], slices.data[slices.j] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:146:20: slices.partitionCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] ignoring self-assignment in slices.data[slices.j], slices.data[slices.a] = slices.data[slices.a], slices.data[slices.j] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:149:19: slices.partitionCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] ignoring self-assignment in slices.data[slices.i], slices.data[slices.j] = slices.data[slices.j], slices.data[slices.i] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:149:19: slices.partitionCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] ignoring self-assignment in slices.data[slices.i], slices.data[slices.j] = slices.data[slices.j], slices.data[slices.i] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:163:20: slices.partitionCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] ignoring self-assignment in slices.data[slices.i], slices.data[slices.j] = slices.data[slices.j], slices.data[slices.i] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:163:20: slices.partitionCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] ignoring self-assignment in slices.data[slices.i], slices.data[slices.j] = slices.data[slices.j], slices.data[slices.i] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:167:19: slices.partitionCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] ignoring self-assignment in slices.data[slices.j], slices.data[slices.a] = slices.data[slices.a], slices.data[slices.j] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:167:19: slices.partitionCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] ignoring self-assignment in slices.data[slices.j], slices.data[slices.a] = slices.data[slices.a], slices.data[slices.j] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:135:30: parameter slices.data leaks to {heap} for partitionCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] with derefs=1: +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:135:30: flow: {heap} ← *slices.data: +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:135:30: from slices.data[slices.i] (dot of pointer) at ../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:139:25 +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:135:30: from slices.cmp(slices.data[slices.i], slices.data[slices.a]) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:139:20 +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:73:24: slices.pdqsortCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] ignoring self-assignment in slices.data[slices.j], slices.data[slices.j - 1] = slices.data[slices.j - 1], slices.data[slices.j] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:73:24: slices.pdqsortCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] ignoring self-assignment in slices.data[slices.j], slices.data[slices.j - 1] = slices.data[slices.j - 1], slices.data[slices.j] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:91:23: slices.pdqsortCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] ignoring self-assignment in slices.data[slices.i], slices.data[slices.j] = slices.data[slices.j], slices.data[slices.i] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:91:23: slices.pdqsortCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] ignoring self-assignment in slices.data[slices.i], slices.data[slices.j] = slices.data[slices.j], slices.data[slices.i] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:61:28: parameter slices.data leaks to {heap} for pdqsortCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] with derefs=1: +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:61:28: flow: {heap} ← *slices.data: +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:61:28: from slices.choosePivotCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }]((*[4]uintptr)(slices..dict[3]), slices.data, slices.a, slices.b, slices.cmp) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:89:36 +./parse.go:290:14: append(p.parsed.secs, sec) escapes to heap in (*parser).header: +./parse.go:290:14: flow: {heap} ← &{storage for append(p.parsed.secs, sec)}: +./parse.go:290:14: from append(p.parsed.secs, sec) (spill) at ./parse.go:290:14 +./parse.go:290:14: from p.parsed.secs = append(p.parsed.secs, sec) (assign) at ./parse.go:290:14 +./parse.go:292:7: append(p.parsed.items, item{...}) escapes to heap in (*parser).header: +./parse.go:292:7: flow: {heap} ← &{storage for append(p.parsed.items, item{...})}: +./parse.go:292:7: from append(p.parsed.items, item{...}) (spill) at ./parse.go:292:7 +./parse.go:292:7: from p.parsed.items = append(p.parsed.items, item{...}) (assign) at ./parse.go:292:7 +./parse.go:215:7: parameter p leaks to {heap} for (*parser).header with derefs=1: +./parse.go:215:7: flow: p ← p: +./parse.go:215:7: from p, sec := p, sec (assign-pair) at ./parse.go:290:14 +./parse.go:215:7: flow: {temp} ← *p: +./parse.go:215:7: from p.parsed (dot of pointer) at ./parse.go:290:14 +./parse.go:215:7: from p.parsed.secs (dot) at ./parse.go:290:14 +./parse.go:215:7: from append(p.parsed.secs, sec) (call parameter) at ./parse.go:290:14 +./parse.go:215:7: flow: {temp} ← {temp}: +./parse.go:215:7: flow: {heap} ← {temp}: +./parse.go:215:7: from p.parsed.secs = append(p.parsed.secs, sec) (assign) at ./parse.go:290:14 +./parse.go:280:33: string(sub) escapes to heap in (*parser).header: +./parse.go:280:33: flow: sec ← &{storage for string(sub)}: +./parse.go:280:33: from string(sub) (spill) at ./parse.go:280:33 +./parse.go:280:33: from sectionKey{...} (struct literal element) at ./parse.go:280:19 +./parse.go:280:33: from sec = sectionKey{...} (assign) at ./parse.go:280:7 +./parse.go:280:33: flow: sec ← sec: +./parse.go:280:33: from p, sec := p, sec (assign-pair) at ./parse.go:290:14 +./parse.go:280:33: flow: {heap} ← sec: +./parse.go:280:33: from append(p.parsed.secs, sec) (call parameter) at ./parse.go:290:14 +./parse.go:283:52: name[dot + 1:] + "." + string(sub) escapes to heap in (*parser).header: +./parse.go:283:52: flow: sec ← &{storage for name[dot + 1:] + "." + string(sub)}: +./parse.go:283:52: from name[dot + 1:] + "." + string(sub) (spill) at ./parse.go:283:52 +./parse.go:283:52: from sectionKey{...} (struct literal element) at ./parse.go:283:20 +./parse.go:283:52: from sec = sectionKey{...} (assign) at ./parse.go:283:8 +./parse.go:283:52: flow: sec ← sec: +./parse.go:283:52: from p, sec := p, sec (assign-pair) at ./parse.go:290:14 +./parse.go:283:52: flow: {heap} ← sec: +./parse.go:283:52: from append(p.parsed.secs, sec) (call parameter) at ./parse.go:290:14 +./parse.go:222:20: string(b) escapes to heap in (*parser).header: +./parse.go:222:20: flow: ~r0 ← &{storage for string(b)}: +./parse.go:222:20: from string(b) (spill) at ./parse.go:222:20 +./parse.go:222:20: from ~r0 = string(b) (assign-pair) at ./parse.go:222:20 +./parse.go:222:20: flow: name ← ~r0: +./parse.go:222:20: from name := ~r0 (assign) at ./parse.go:222:7 +./parse.go:222:20: flow: sec ← name: +./parse.go:222:20: from sec.section = name (assign) at ./parse.go:233:15 +./parse.go:222:20: flow: sec ← sec: +./parse.go:222:20: from p, sec := p, sec (assign-pair) at ./parse.go:290:14 +./parse.go:222:20: flow: {heap} ← sec: +./parse.go:222:20: from append(p.parsed.secs, sec) (call parameter) at ./parse.go:290:14 +./parse.go:222:29: string(d[start + 1:i]) escapes to heap in (*parser).header: +./parse.go:222:29: flow: s ← &{storage for string(d[start + 1:i])}: +./parse.go:222:29: from string(d[start + 1:i]) (spill) at ./parse.go:222:29 +./parse.go:222:29: from s := string(d[start + 1:i]) (assign-pair) at ./parse.go:222:20 +./parse.go:222:29: flow: ~r0 ← s: +./parse.go:222:29: from ~r0 = s (assign-pair) at ./parse.go:222:20 +./parse.go:222:29: flow: name ← ~r0: +./parse.go:222:29: from name := ~r0 (assign) at ./parse.go:222:7 +./parse.go:222:29: flow: sec ← name: +./parse.go:222:29: from sec.section = name (assign) at ./parse.go:233:15 +./parse.go:222:29: flow: sec ← sec: +./parse.go:222:29: from p, sec := p, sec (assign-pair) at ./parse.go:290:14 +./parse.go:222:29: flow: {heap} ← sec: +./parse.go:222:29: from append(p.parsed.secs, sec) (call parameter) at ./parse.go:290:14 +./parse.go:224:19: &SyntaxError{...} escapes to heap in (*parser).header: +./parse.go:224:19: flow: ~r0 ← &{storage for &SyntaxError{...}}: +./parse.go:224:19: from &SyntaxError{...} (spill) at ./parse.go:224:19 +./parse.go:224:19: from &SyntaxError{...} (interface-converted) at ./parse.go:224:19 +./parse.go:224:19: from ~r0 = &SyntaxError{...} (assign-pair) at ./parse.go:224:19 +./parse.go:224:19: flow: ~r0 ← ~r0: +./parse.go:224:19: from return ~r0 (return) at ./parse.go:224:3 +./parse.go:231:20: &SyntaxError{...} escapes to heap in (*parser).header: +./parse.go:231:20: flow: ~r0 ← &{storage for &SyntaxError{...}}: +./parse.go:231:20: from &SyntaxError{...} (spill) at ./parse.go:231:20 +./parse.go:231:20: from &SyntaxError{...} (interface-converted) at ./parse.go:231:20 +./parse.go:231:20: from ~r0 = &SyntaxError{...} (assign-pair) at ./parse.go:231:20 +./parse.go:231:20: flow: ~r0 ← ~r0: +./parse.go:231:20: from return ~r0 (return) at ./parse.go:231:4 +./parse.go:245:20: &SyntaxError{...} escapes to heap in (*parser).header: +./parse.go:245:20: flow: ~r0 ← &{storage for &SyntaxError{...}}: +./parse.go:245:20: from &SyntaxError{...} (spill) at ./parse.go:245:20 +./parse.go:245:20: from &SyntaxError{...} (interface-converted) at ./parse.go:245:20 +./parse.go:245:20: from ~r0 = &SyntaxError{...} (assign-pair) at ./parse.go:245:20 +./parse.go:245:20: flow: ~r0 ← ~r0: +./parse.go:245:20: from return ~r0 (return) at ./parse.go:245:4 +./parse.go:251:21: &SyntaxError{...} escapes to heap in (*parser).header: +./parse.go:251:21: flow: ~r0 ← &{storage for &SyntaxError{...}}: +./parse.go:251:21: from &SyntaxError{...} (spill) at ./parse.go:251:21 +./parse.go:251:21: from &SyntaxError{...} (interface-converted) at ./parse.go:251:21 +./parse.go:251:21: from ~r0 = &SyntaxError{...} (assign-pair) at ./parse.go:251:21 +./parse.go:251:21: flow: ~r0 ← ~r0: +./parse.go:251:21: from return ~r0 (return) at ./parse.go:251:5 +./parse.go:260:22: &SyntaxError{...} escapes to heap in (*parser).header: +./parse.go:260:22: flow: ~r0 ← &{storage for &SyntaxError{...}}: +./parse.go:260:22: from &SyntaxError{...} (spill) at ./parse.go:260:22 +./parse.go:260:22: from &SyntaxError{...} (interface-converted) at ./parse.go:260:22 +./parse.go:260:22: from ~r0 = &SyntaxError{...} (assign-pair) at ./parse.go:260:22 +./parse.go:260:22: flow: ~r0 ← ~r0: +./parse.go:260:22: from return ~r0 (return) at ./parse.go:260:6 +./parse.go:267:21: &SyntaxError{...} escapes to heap in (*parser).header: +./parse.go:267:21: flow: ~r0 ← &{storage for &SyntaxError{...}}: +./parse.go:267:21: from &SyntaxError{...} (spill) at ./parse.go:267:21 +./parse.go:267:21: from &SyntaxError{...} (interface-converted) at ./parse.go:267:21 +./parse.go:267:21: from ~r0 = &SyntaxError{...} (assign-pair) at ./parse.go:267:21 +./parse.go:267:21: flow: ~r0 ← ~r0: +./parse.go:267:21: from return ~r0 (return) at ./parse.go:267:5 +./parse.go:274:20: &SyntaxError{...} escapes to heap in (*parser).header: +./parse.go:274:20: flow: ~r0 ← &{storage for &SyntaxError{...}}: +./parse.go:274:20: from &SyntaxError{...} (spill) at ./parse.go:274:20 +./parse.go:274:20: from &SyntaxError{...} (interface-converted) at ./parse.go:274:20 +./parse.go:274:20: from ~r0 = &SyntaxError{...} (assign-pair) at ./parse.go:274:20 +./parse.go:274:20: flow: ~r0 ← ~r0: +./parse.go:274:20: from return ~r0 (return) at ./parse.go:274:4 +./parse.go:277:20: &SyntaxError{...} escapes to heap in (*parser).header: +./parse.go:277:20: flow: ~r0 ← &{storage for &SyntaxError{...}}: +./parse.go:277:20: from &SyntaxError{...} (spill) at ./parse.go:277:20 +./parse.go:277:20: from &SyntaxError{...} (interface-converted) at ./parse.go:277:20 +./parse.go:277:20: from ~r0 = &SyntaxError{...} (assign-pair) at ./parse.go:277:20 +./parse.go:277:20: flow: ~r0 ← ~r0: +./parse.go:277:20: from return ~r0 (return) at ./parse.go:277:4 +./parse.go:287:19: &SyntaxError{...} escapes to heap in (*parser).header: +./parse.go:287:19: flow: ~r0 ← &{storage for &SyntaxError{...}}: +./parse.go:287:19: from &SyntaxError{...} (spill) at ./parse.go:287:19 +./parse.go:287:19: from &SyntaxError{...} (interface-converted) at ./parse.go:287:19 +./parse.go:287:19: from ~r0 = &SyntaxError{...} (assign-pair) at ./parse.go:287:19 +./parse.go:287:19: flow: ~r0 ← ~r0: +./parse.go:287:19: from return ~r0 (return) at ./parse.go:287:3 +./parse.go:215:7: parameter p leaks to {storage for &SyntaxError{...}} for (*parser).header with derefs=1: +./parse.go:215:7: flow: p ← p: +./parse.go:215:7: from p, line, msg := p, p.line, "invalid section header" (assign-pair) at ./parse.go:287:19 +./parse.go:215:7: flow: {storage for &SyntaxError{...}} ← *p: +./parse.go:215:7: from p.name (dot of pointer) at ./parse.go:287:19 +./parse.go:215:7: from SyntaxError{...} (struct literal element) at ./parse.go:287:19 +./parse.go:215:7: parameter p leaks to {storage for &SyntaxError{...}} for (*parser).header with derefs=1: +./parse.go:215:7: flow: p ← p: +./parse.go:215:7: from p, line, msg := p, p.line, "invalid section header" (assign-pair) at ./parse.go:277:20 +./parse.go:215:7: flow: {storage for &SyntaxError{...}} ← *p: +./parse.go:215:7: from p.name (dot of pointer) at ./parse.go:277:20 +./parse.go:215:7: from SyntaxError{...} (struct literal element) at ./parse.go:277:20 +./parse.go:215:7: parameter p leaks to {storage for &SyntaxError{...}} for (*parser).header with derefs=1: +./parse.go:215:7: flow: p ← p: +./parse.go:215:7: from p, line, msg := p, p.line + 1, "unterminated section header" (assign-pair) at ./parse.go:274:20 +./parse.go:215:7: flow: {storage for &SyntaxError{...}} ← *p: +./parse.go:215:7: from p.name (dot of pointer) at ./parse.go:274:20 +./parse.go:215:7: from SyntaxError{...} (struct literal element) at ./parse.go:274:20 +./parse.go:215:7: parameter p leaks to {storage for &SyntaxError{...}} for (*parser).header with derefs=1: +./parse.go:215:7: flow: p ← p: +./parse.go:215:7: from p, line, msg := p, p.line, "NUL byte in subsection" (assign-pair) at ./parse.go:267:21 +./parse.go:215:7: flow: {storage for &SyntaxError{...}} ← *p: +./parse.go:215:7: from p.name (dot of pointer) at ./parse.go:267:21 +./parse.go:215:7: from SyntaxError{...} (struct literal element) at ./parse.go:267:21 +./parse.go:215:7: parameter p leaks to {storage for &SyntaxError{...}} for (*parser).header with derefs=1: +./parse.go:215:7: flow: p ← p: +./parse.go:215:7: from p, line, msg := p, p.line, "unterminated subsection" (assign-pair) at ./parse.go:260:22 +./parse.go:215:7: flow: {storage for &SyntaxError{...}} ← *p: +./parse.go:215:7: from p.name (dot of pointer) at ./parse.go:260:22 +./parse.go:215:7: from SyntaxError{...} (struct literal element) at ./parse.go:260:22 +./parse.go:215:7: parameter p leaks to {storage for &SyntaxError{...}} for (*parser).header with derefs=1: +./parse.go:215:7: flow: p ← p: +./parse.go:215:7: from p, line, msg := p, p.line, "unterminated subsection" (assign-pair) at ./parse.go:251:21 +./parse.go:215:7: flow: {storage for &SyntaxError{...}} ← *p: +./parse.go:215:7: from p.name (dot of pointer) at ./parse.go:251:21 +./parse.go:215:7: from SyntaxError{...} (struct literal element) at ./parse.go:251:21 +./parse.go:215:7: parameter p leaks to {storage for &SyntaxError{...}} for (*parser).header with derefs=1: +./parse.go:215:7: flow: p ← p: +./parse.go:215:7: from p, line, msg := p, p.line, "invalid section header" (assign-pair) at ./parse.go:245:20 +./parse.go:215:7: flow: {storage for &SyntaxError{...}} ← *p: +./parse.go:215:7: from p.name (dot of pointer) at ./parse.go:245:20 +./parse.go:215:7: from SyntaxError{...} (struct literal element) at ./parse.go:245:20 +./parse.go:215:7: parameter p leaks to {storage for &SyntaxError{...}} for (*parser).header with derefs=1: +./parse.go:215:7: flow: p ← p: +./parse.go:215:7: from p, line, msg := p, p.line, "empty section name" (assign-pair) at ./parse.go:231:20 +./parse.go:215:7: flow: {storage for &SyntaxError{...}} ← *p: +./parse.go:215:7: from p.name (dot of pointer) at ./parse.go:231:20 +./parse.go:215:7: from SyntaxError{...} (struct literal element) at ./parse.go:231:20 +./parse.go:215:7: parameter p leaks to {storage for &SyntaxError{...}} for (*parser).header with derefs=1: +./parse.go:215:7: flow: p ← p: +./parse.go:215:7: from p, line, msg := p, p.line + 1, "unterminated section header" (assign-pair) at ./parse.go:224:19 +./parse.go:215:7: flow: {storage for &SyntaxError{...}} ← *p: +./parse.go:215:7: from p.name (dot of pointer) at ./parse.go:224:19 +./parse.go:215:7: from SyntaxError{...} (struct literal element) at ./parse.go:224:19 +./parse.go:215:7: leaking param content: p +./parse.go:222:29: string(d[start + 1:i]) escapes to heap +./parse.go:222:20: ([]byte)(s) does not escape +./parse.go:222:20: string(b) escapes to heap +./parse.go:224:19: &SyntaxError{...} escapes to heap +./parse.go:231:20: &SyntaxError{...} escapes to heap +./parse.go:245:20: &SyntaxError{...} escapes to heap +./parse.go:251:21: &SyntaxError{...} escapes to heap +./parse.go:260:22: &SyntaxError{...} escapes to heap +./parse.go:267:21: &SyntaxError{...} escapes to heap +./parse.go:269:16: append does not escape +./parse.go:274:20: &SyntaxError{...} escapes to heap +./parse.go:277:20: &SyntaxError{...} escapes to heap +./parse.go:280:33: string(sub) escapes to heap +./parse.go:283:52: name[dot + 1:] + "." + string(sub) escapes to heap +./parse.go:283:61: string(sub) does not escape +./parse.go:287:19: &SyntaxError{...} escapes to heap +./parse.go:290:14: append escapes to heap +./parse.go:292:7: append escapes to heap +./parse.go:123:13: append(p.parsed.items, item{...}) escapes to heap in (*parser).addEntry: +./parse.go:123:13: flow: {heap} ← &{storage for append(p.parsed.items, item{...})}: +./parse.go:123:13: from append(p.parsed.items, item{...}) (spill) at ./parse.go:123:13 +./parse.go:123:13: from p.parsed.items = append(p.parsed.items, item{...}) (assign) at ./parse.go:123:13 +./parse.go:127:18: string(name) escapes to heap in (*parser).addEntry: +./parse.go:127:18: flow: {heap} ← &{storage for string(name)}: +./parse.go:127:18: from string(name) (spill) at ./parse.go:127:18 +./parse.go:127:18: from p.names[string(name)] (key of map put) at ./parse.go:127:10 +./parse.go:130:18: append(p.parsed.texts, entryText{...}) escapes to heap in (*parser).addEntry: +./parse.go:130:18: flow: {heap} ← &{storage for append(p.parsed.texts, entryText{...})}: +./parse.go:130:18: from append(p.parsed.texts, entryText{...}) (spill) at ./parse.go:130:18 +./parse.go:130:18: from p.parsed.texts = append(p.parsed.texts, entryText{...}) (assign) at ./parse.go:130:10 +./parse.go:122:56: parameter value leaks to {heap} for (*parser).addEntry with derefs=0: +./parse.go:122:56: flow: {heap} ← value: +./parse.go:122:56: from entryText{...} (struct literal element) at ./parse.go:130:37 +./parse.go:122:56: from append(p.parsed.texts, entryText{...}) (call parameter) at ./parse.go:130:18 +./parse.go:122:7: parameter p leaks to {heap} for (*parser).addEntry with derefs=1: +./parse.go:122:7: flow: {temp} ← *p: +./parse.go:122:7: from p.parsed (dot of pointer) at ./parse.go:130:20 +./parse.go:122:7: from p.parsed.texts (dot) at ./parse.go:130:20 +./parse.go:122:7: from append(p.parsed.texts, entryText{...}) (call parameter) at ./parse.go:130:18 +./parse.go:122:7: flow: {temp} ← {temp}: +./parse.go:122:7: flow: {heap} ← {temp}: +./parse.go:122:7: from p.parsed.texts = append(p.parsed.texts, entryText{...}) (assign) at ./parse.go:130:10 +./parse.go:126:17: string(b) escapes to heap in (*parser).addEntry: +./parse.go:126:17: flow: ~r0 ← &{storage for string(b)}: +./parse.go:126:17: from string(b) (spill) at ./parse.go:126:17 +./parse.go:126:17: from ~r0 = string(b) (assign-pair) at ./parse.go:126:17 +./parse.go:126:17: flow: n ← ~r0: +./parse.go:126:17: from n = ~r0 (assign) at ./parse.go:126:5 +./parse.go:126:17: flow: {heap} ← n: +./parse.go:126:17: from p.names[string(name)] = n (assign) at ./parse.go:127:25 +./parse.go:126:25: string(name) escapes to heap in (*parser).addEntry: +./parse.go:126:25: flow: s ← &{storage for string(name)}: +./parse.go:126:25: from string(name) (spill) at ./parse.go:126:25 +./parse.go:126:25: from s := string(name) (assign-pair) at ./parse.go:126:17 +./parse.go:126:25: flow: ~r0 ← s: +./parse.go:126:25: from ~r0 = s (assign-pair) at ./parse.go:126:17 +./parse.go:126:25: flow: n ← ~r0: +./parse.go:126:25: from n = ~r0 (assign) at ./parse.go:126:5 +./parse.go:126:25: flow: {heap} ← n: +./parse.go:126:25: from p.names[string(name)] = n (assign) at ./parse.go:127:25 +./parse.go:122:7: parameter p leaks to ~r0 for (*parser).addEntry with derefs=1: +./parse.go:122:7: flow: p ← p: +./parse.go:122:7: from p, kind, start, end := p, itemKind(5), start, end (assign-pair) at ./parse.go:123:13 +./parse.go:122:7: flow: ~r0 ← *p: +./parse.go:122:7: from p.parsed (dot of pointer) at ./parse.go:123:13 +./parse.go:122:7: from p.parsed.items (dot) at ./parse.go:123:13 +./parse.go:122:7: from p.parsed.items[len(p.parsed.items) - 1] (dot of pointer) at ./parse.go:123:13 +./parse.go:122:7: from &p.parsed.items[len(p.parsed.items) - 1] (address-of) at ./parse.go:123:13 +./parse.go:122:7: from ~r0 = &p.parsed.items[len(p.parsed.items) - 1] (assign-pair) at ./parse.go:123:13 +./parse.go:122:7: flow: it ← ~r0: +./parse.go:122:7: from it := ~r0 (assign) at ./parse.go:123:5 +./parse.go:122:7: flow: ~r0 ← it: +./parse.go:122:7: from return it (return) at ./parse.go:131:2 +./parse.go:122:7: leaking param content: p +./parse.go:122:43: name does not escape +./parse.go:122:56: leaking param: value +./parse.go:123:13: append escapes to heap +./parse.go:124:26: string(name) does not escape +./parse.go:126:25: string(name) escapes to heap +./parse.go:126:17: ([]byte)(s) does not escape +./parse.go:126:17: string(b) escapes to heap +./parse.go:127:18: string(name) escapes to heap +./parse.go:130:18: append escapes to heap +./parse.go:334:7: (*parser).value capturing by value: p (addr=false assign=false width=8) +./parse.go:336:2: (*parser).value capturing by ref: buf (addr=false assign=true width=24) +./parse.go:334:7: parameter p leaks to {heap} for (*parser).value with derefs=1: +./parse.go:334:7: flow: buf ← *p: +./parse.go:334:7: from p.buf (dot of pointer) at ./parse.go:336:10 +./parse.go:334:7: from p.buf[:0] (slice) at ./parse.go:336:14 +./parse.go:334:7: from buf := p.buf[:0] (assign) at ./parse.go:336:6 +./parse.go:334:7: flow: {heap} ← buf: +./parse.go:334:7: from buf[:0] (slice) at ./parse.go:337:28 +./parse.go:334:7: from p.buf = buf[:0] (assign) at ./parse.go:337:23 +./parse.go:362:10: append(buf, d[pending:at]...) escapes to heap in (*parser).value: +./parse.go:362:10: flow: buf ← &{storage for append(buf, d[pending:at]...)}: +./parse.go:362:10: from append(buf, d[pending:at]...) (spill) at ./parse.go:362:10 +./parse.go:362:10: from buf = append(buf, d[pending:at]...) (assign) at ./parse.go:362:10 +./parse.go:362:10: flow: {heap} ← buf: +./parse.go:362:10: from buf[:0] (slice) at ./parse.go:337:28 +./parse.go:362:10: from p.buf = buf[:0] (assign) at ./parse.go:337:23 +./parse.go:367:9: append(buf, d[pending:at]...) escapes to heap in (*parser).value: +./parse.go:367:9: flow: buf ← &{storage for append(buf, d[pending:at]...)}: +./parse.go:367:9: from append(buf, d[pending:at]...) (spill) at ./parse.go:367:9 +./parse.go:367:9: from buf = append(buf, d[pending:at]...) (assign) at ./parse.go:367:9 +./parse.go:367:9: flow: {heap} ← buf: +./parse.go:367:9: from buf[:0] (slice) at ./parse.go:337:28 +./parse.go:367:9: from p.buf = buf[:0] (assign) at ./parse.go:337:23 +./parse.go:378:17: append(buf, byte(9)) escapes to heap in (*parser).value: +./parse.go:378:17: flow: buf ← &{storage for append(buf, byte(9))}: +./parse.go:378:17: from append(buf, byte(9)) (spill) at ./parse.go:378:17 +./parse.go:378:17: from buf = append(buf, byte(9)) (assign) at ./parse.go:378:9 +./parse.go:378:17: flow: {heap} ← buf: +./parse.go:378:17: from buf[:0] (slice) at ./parse.go:337:28 +./parse.go:378:17: from p.buf = buf[:0] (assign) at ./parse.go:337:23 +./parse.go:380:17: append(buf, byte(10)) escapes to heap in (*parser).value: +./parse.go:380:17: flow: buf ← &{storage for append(buf, byte(10))}: +./parse.go:380:17: from append(buf, byte(10)) (spill) at ./parse.go:380:17 +./parse.go:380:17: from buf = append(buf, byte(10)) (assign) at ./parse.go:380:9 +./parse.go:380:17: flow: {heap} ← buf: +./parse.go:380:17: from buf[:0] (slice) at ./parse.go:337:28 +./parse.go:380:17: from p.buf = buf[:0] (assign) at ./parse.go:337:23 +./parse.go:382:17: append(buf, byte(8)) escapes to heap in (*parser).value: +./parse.go:382:17: flow: buf ← &{storage for append(buf, byte(8))}: +./parse.go:382:17: from append(buf, byte(8)) (spill) at ./parse.go:382:17 +./parse.go:382:17: from buf = append(buf, byte(8)) (assign) at ./parse.go:382:9 +./parse.go:382:17: flow: {heap} ← buf: +./parse.go:382:17: from buf[:0] (slice) at ./parse.go:337:28 +./parse.go:382:17: from p.buf = buf[:0] (assign) at ./parse.go:337:23 +./parse.go:384:17: append(buf, d[i + 1]) escapes to heap in (*parser).value: +./parse.go:384:17: flow: buf ← &{storage for append(buf, d[i + 1])}: +./parse.go:384:17: from append(buf, d[i + 1]) (spill) at ./parse.go:384:17 +./parse.go:384:17: from buf = append(buf, d[i + 1]) (assign) at ./parse.go:384:9 +./parse.go:384:17: flow: {heap} ← buf: +./parse.go:384:17: from buf[:0] (slice) at ./parse.go:337:28 +./parse.go:384:17: from p.buf = buf[:0] (assign) at ./parse.go:337:23 +./parse.go:390:9: append(buf, d[pending:at]...) escapes to heap in (*parser).value: +./parse.go:390:9: flow: buf ← &{storage for append(buf, d[pending:at]...)}: +./parse.go:390:9: from append(buf, d[pending:at]...) (spill) at ./parse.go:390:9 +./parse.go:390:9: from buf = append(buf, d[pending:at]...) (assign) at ./parse.go:390:9 +./parse.go:390:9: flow: {heap} ← buf: +./parse.go:390:9: from buf[:0] (slice) at ./parse.go:337:28 +./parse.go:390:9: from p.buf = buf[:0] (assign) at ./parse.go:337:23 +./parse.go:394:16: append(buf, c) escapes to heap in (*parser).value: +./parse.go:394:16: flow: buf ← &{storage for append(buf, c)}: +./parse.go:394:16: from append(buf, c) (spill) at ./parse.go:394:16 +./parse.go:394:16: from buf = append(buf, c) (assign) at ./parse.go:394:8 +./parse.go:394:16: flow: {heap} ← buf: +./parse.go:394:16: from buf[:0] (slice) at ./parse.go:337:28 +./parse.go:394:16: from p.buf = buf[:0] (assign) at ./parse.go:337:23 +./parse.go:404:9: append(buf, d[pending:at]...) escapes to heap in (*parser).value: +./parse.go:404:9: flow: buf ← &{storage for append(buf, d[pending:at]...)}: +./parse.go:404:9: from append(buf, d[pending:at]...) (spill) at ./parse.go:404:9 +./parse.go:404:9: from buf = append(buf, d[pending:at]...) (assign) at ./parse.go:404:9 +./parse.go:404:9: flow: {heap} ← buf: +./parse.go:404:9: from buf[:0] (slice) at ./parse.go:337:28 +./parse.go:404:9: from p.buf = buf[:0] (assign) at ./parse.go:337:23 +./parse.go:405:16: append(buf, c) escapes to heap in (*parser).value: +./parse.go:405:16: flow: buf ← &{storage for append(buf, c)}: +./parse.go:405:16: from append(buf, c) (spill) at ./parse.go:405:16 +./parse.go:405:16: from buf = append(buf, c) (assign) at ./parse.go:405:8 +./parse.go:405:16: flow: {heap} ← buf: +./parse.go:405:16: from buf[:0] (slice) at ./parse.go:337:28 +./parse.go:405:16: from p.buf = buf[:0] (assign) at ./parse.go:337:23 +./parse.go:352:34: &SyntaxError{...} escapes to heap in (*parser).value: +./parse.go:352:34: flow: ~r0 ← &{storage for &SyntaxError{...}}: +./parse.go:352:34: from &SyntaxError{...} (spill) at ./parse.go:352:34 +./parse.go:352:34: from &SyntaxError{...} (interface-converted) at ./parse.go:352:34 +./parse.go:352:34: from ~r0 = &SyntaxError{...} (assign-pair) at ./parse.go:352:34 +./parse.go:352:34: flow: ~r4 ← ~r0: +./parse.go:352:34: from return "", 0, 0, openEnd(0), ~r0 (return) at ./parse.go:352:5 +./parse.go:360:35: &SyntaxError{...} escapes to heap in (*parser).value: +./parse.go:360:35: flow: ~r0 ← &{storage for &SyntaxError{...}}: +./parse.go:360:35: from &SyntaxError{...} (spill) at ./parse.go:360:35 +./parse.go:360:35: from &SyntaxError{...} (interface-converted) at ./parse.go:360:35 +./parse.go:360:35: from ~r0 = &SyntaxError{...} (assign-pair) at ./parse.go:360:35 +./parse.go:360:35: flow: ~r4 ← ~r0: +./parse.go:360:35: from return "", 0, 0, openEnd(0), ~r0 (return) at ./parse.go:360:6 +./parse.go:386:34: &SyntaxError{...} escapes to heap in (*parser).value: +./parse.go:386:34: flow: ~r0 ← &{storage for &SyntaxError{...}}: +./parse.go:386:34: from &SyntaxError{...} (spill) at ./parse.go:386:34 +./parse.go:386:34: from &SyntaxError{...} (interface-converted) at ./parse.go:386:34 +./parse.go:386:34: from ~r0 = &SyntaxError{...} (assign-pair) at ./parse.go:386:34 +./parse.go:386:34: flow: ~r4 ← ~r0: +./parse.go:386:34: from return "", 0, 0, openEnd(0), ~r0 (return) at ./parse.go:386:5 +./parse.go:410:32: &SyntaxError{...} escapes to heap in (*parser).value: +./parse.go:410:32: flow: ~r0 ← &{storage for &SyntaxError{...}}: +./parse.go:410:32: from &SyntaxError{...} (spill) at ./parse.go:410:32 +./parse.go:410:32: from &SyntaxError{...} (interface-converted) at ./parse.go:410:32 +./parse.go:410:32: from ~r0 = &SyntaxError{...} (assign-pair) at ./parse.go:410:32 +./parse.go:410:32: flow: ~r4 ← ~r0: +./parse.go:410:32: from return "", 0, 0, openEnd(0), ~r0 (return) at ./parse.go:410:3 +./parse.go:417:16: string(buf) escapes to heap in (*parser).value: +./parse.go:417:16: flow: ~r0 ← &{storage for string(buf)}: +./parse.go:417:16: from string(buf) (spill) at ./parse.go:417:16 +./parse.go:417:16: from return string(buf), i, lines, open, nil (return) at ./parse.go:417:2 +./parse.go:334:7: parameter p leaks to {storage for &SyntaxError{...}} for (*parser).value with derefs=1: +./parse.go:334:7: flow: p ← p: +./parse.go:334:7: from p, line, msg := p, p.line + lines, "unterminated quote" (assign-pair) at ./parse.go:410:32 +./parse.go:334:7: flow: {storage for &SyntaxError{...}} ← *p: +./parse.go:334:7: from p.name (dot of pointer) at ./parse.go:410:32 +./parse.go:334:7: from SyntaxError{...} (struct literal element) at ./parse.go:410:32 +./parse.go:334:7: parameter p leaks to {storage for &SyntaxError{...}} for (*parser).value with derefs=1: +./parse.go:334:7: flow: p ← p: +./parse.go:334:7: from p, line, msg := p, p.line + lines, "invalid escape" (assign-pair) at ./parse.go:386:34 +./parse.go:334:7: flow: {storage for &SyntaxError{...}} ← *p: +./parse.go:334:7: from p.name (dot of pointer) at ./parse.go:386:34 +./parse.go:334:7: from SyntaxError{...} (struct literal element) at ./parse.go:386:34 +./parse.go:334:7: parameter p leaks to {storage for &SyntaxError{...}} for (*parser).value with derefs=1: +./parse.go:334:7: flow: p ← p: +./parse.go:334:7: from p, line, msg := p, p.line + lines + 1, "unterminated quote" (assign-pair) at ./parse.go:360:35 +./parse.go:334:7: flow: {storage for &SyntaxError{...}} ← *p: +./parse.go:334:7: from p.name (dot of pointer) at ./parse.go:360:35 +./parse.go:334:7: from SyntaxError{...} (struct literal element) at ./parse.go:360:35 +./parse.go:334:7: parameter p leaks to {storage for &SyntaxError{...}} for (*parser).value with derefs=1: +./parse.go:334:7: flow: p ← p: +./parse.go:334:7: from p, line, msg := p, p.line + lines, "unterminated quote" (assign-pair) at ./parse.go:352:34 +./parse.go:334:7: flow: {storage for &SyntaxError{...}} ← *p: +./parse.go:334:7: from p.name (dot of pointer) at ./parse.go:352:34 +./parse.go:334:7: from SyntaxError{...} (struct literal element) at ./parse.go:352:34 +./parse.go:334:7: leaking param content: p +./parse.go:337:8: func literal does not escape +./parse.go:352:34: &SyntaxError{...} escapes to heap +./parse.go:360:35: &SyntaxError{...} escapes to heap +./parse.go:362:10: append escapes to heap +./parse.go:367:9: append escapes to heap +./parse.go:378:17: append escapes to heap +./parse.go:380:17: append escapes to heap +./parse.go:382:17: append escapes to heap +./parse.go:384:17: append escapes to heap +./parse.go:386:34: &SyntaxError{...} escapes to heap +./parse.go:390:9: append escapes to heap +./parse.go:394:16: append escapes to heap +./parse.go:404:9: append escapes to heap +./parse.go:405:16: append escapes to heap +./parse.go:410:32: &SyntaxError{...} escapes to heap +./parse.go:417:16: string(buf) escapes to heap +./parse.go:296:7: parameter p leaks to {heap} for (*parser).entry with derefs=1: +./parse.go:296:7: flow: {temp} ← p: +./parse.go:296:7: from (*parser).addEntry(p, start, i, name, "") (call parameter) at ./parse.go:310:13 +./parse.go:296:7: flow: {heap} ← *{temp}: +./parse.go:314:19: &SyntaxError{...} escapes to heap in (*parser).entry: +./parse.go:314:19: flow: ~r0 ← &{storage for &SyntaxError{...}}: +./parse.go:314:19: from &SyntaxError{...} (spill) at ./parse.go:314:19 +./parse.go:314:19: from &SyntaxError{...} (interface-converted) at ./parse.go:314:19 +./parse.go:314:19: from ~r0 = &SyntaxError{...} (assign-pair) at ./parse.go:314:19 +./parse.go:314:19: flow: ~r0 ← ~r0: +./parse.go:314:19: from return ~r0 (return) at ./parse.go:314:3 +./parse.go:296:7: parameter p leaks to {storage for &SyntaxError{...}} for (*parser).entry with derefs=1: +./parse.go:296:7: flow: p ← p: +./parse.go:296:7: from p, line, msg := p, p.line, "invalid key" (assign-pair) at ./parse.go:314:19 +./parse.go:296:7: flow: {storage for &SyntaxError{...}} ← *p: +./parse.go:296:7: from p.name (dot of pointer) at ./parse.go:314:19 +./parse.go:296:7: from SyntaxError{...} (struct literal element) at ./parse.go:314:19 +./parse.go:296:7: leaking param content: p +./parse.go:314:19: &SyntaxError{...} escapes to heap +./parse.go:174:8: append(p.parsed.items, item{...}) escapes to heap in (*parser).run: +./parse.go:174:8: flow: {heap} ← &{storage for append(p.parsed.items, item{...})}: +./parse.go:174:8: from append(p.parsed.items, item{...}) (spill) at ./parse.go:174:8 +./parse.go:174:8: from p.parsed.items = append(p.parsed.items, item{...}) (assign) at ./parse.go:174:8 +./parse.go:185:9: append(p.parsed.items, item{...}) escapes to heap in (*parser).run: +./parse.go:185:9: flow: {heap} ← &{storage for append(p.parsed.items, item{...})}: +./parse.go:185:9: from append(p.parsed.items, item{...}) (spill) at ./parse.go:185:9 +./parse.go:185:9: from p.parsed.items = append(p.parsed.items, item{...}) (assign) at ./parse.go:185:9 +./parse.go:188:9: append(p.parsed.items, item{...}) escapes to heap in (*parser).run: +./parse.go:188:9: flow: {heap} ← &{storage for append(p.parsed.items, item{...})}: +./parse.go:188:9: from append(p.parsed.items, item{...}) (spill) at ./parse.go:188:9 +./parse.go:188:9: from p.parsed.items = append(p.parsed.items, item{...}) (assign) at ./parse.go:188:9 +./parse.go:199:9: append(p.parsed.items, item{...}) escapes to heap in (*parser).run: +./parse.go:199:9: flow: {heap} ← &{storage for append(p.parsed.items, item{...})}: +./parse.go:199:9: from append(p.parsed.items, item{...}) (spill) at ./parse.go:199:9 +./parse.go:199:9: from p.parsed.items = append(p.parsed.items, item{...}) (assign) at ./parse.go:199:9 +./parse.go:171:7: parameter p leaks to {heap} for (*parser).run with derefs=1: +./parse.go:171:7: flow: {temp} ← p: +./parse.go:171:7: from (*parser).header(p) (call parameter) at ./parse.go:201:22 +./parse.go:171:7: flow: {heap} ← *{temp}: +./parse.go:209:20: &SyntaxError{...} escapes to heap in (*parser).run: +./parse.go:209:20: flow: ~r0 ← &{storage for &SyntaxError{...}}: +./parse.go:209:20: from &SyntaxError{...} (spill) at ./parse.go:209:20 +./parse.go:209:20: from &SyntaxError{...} (interface-converted) at ./parse.go:209:20 +./parse.go:209:20: from ~r0 = &SyntaxError{...} (assign-pair) at ./parse.go:209:20 +./parse.go:209:20: flow: ~r0 ← ~r0: +./parse.go:209:20: from return ~r0 (return) at ./parse.go:209:4 +./parse.go:171:7: parameter p leaks to {storage for &SyntaxError{...}} for (*parser).run with derefs=1: +./parse.go:171:7: flow: p ← p: +./parse.go:171:7: from p, line, msg := p, p.line, "invalid line" (assign-pair) at ./parse.go:209:20 +./parse.go:171:7: flow: {storage for &SyntaxError{...}} ← *p: +./parse.go:171:7: from p.name (dot of pointer) at ./parse.go:209:20 +./parse.go:171:7: from SyntaxError{...} (struct literal element) at ./parse.go:209:20 +./parse.go:171:7: leaking param content: p +./parse.go:173:20: string(bytes.a) does not escape +./parse.go:173:20: string(bytes.b) does not escape +./parse.go:174:8: append escapes to heap +./parse.go:185:9: append escapes to heap +./parse.go:188:9: append escapes to heap +./parse.go:199:9: append escapes to heap +./parse.go:209:20: &SyntaxError{...} escapes to heap +./parse.go:104:16: make([]item, 0, 2 * bytes.Count(data, []byte{...}) + 4) escapes to heap in parse: +./parse.go:104:16: flow: {heap} ← &{storage for make([]item, 0, 2 * bytes.Count(data, []byte{...}) + 4)}: +./parse.go:104:16: from make([]item, 0, 2 * bytes.Count(data, []byte{...}) + 4) (spill) at ./parse.go:104:16 +./parse.go:104:16: from p.parsed.items = make([]item, 0, 2 * bytes.Count(data, []byte{...}) + 4) (assign) at ./parse.go:104:10 +./parse.go:105:23: []sectionKey{...} escapes to heap in parse: +./parse.go:105:23: flow: {heap} ← &{storage for []sectionKey{...}}: +./parse.go:105:23: from []sectionKey{...} (spill) at ./parse.go:105:23 +./parse.go:105:23: from p.parsed.secs = []sectionKey{...} (assign) at ./parse.go:105:9 +./parse.go:102:12: parameter name leaks to {heap} for parse with derefs=0: +./parse.go:102:12: flow: {storage for &parser{...}} ← name: +./parse.go:102:12: from parser{...} (struct literal element) at ./parse.go:103:14 +./parse.go:102:12: flow: p ← &{storage for &parser{...}}: +./parse.go:102:12: from &parser{...} (spill) at ./parse.go:103:7 +./parse.go:102:12: from p := &parser{...} (assign) at ./parse.go:103:4 +./parse.go:102:12: flow: {temp} ← p: +./parse.go:102:12: from (*parser).run(p) (call parameter) at ./parse.go:106:17 +./parse.go:102:12: flow: {heap} ← *{temp}: +./parse.go:102:25: parameter data leaks to {heap} for parse with derefs=0: +./parse.go:102:25: flow: {storage for &parser{...}} ← data: +./parse.go:102:25: from parser{...} (struct literal element) at ./parse.go:103:14 +./parse.go:102:25: flow: p ← &{storage for &parser{...}}: +./parse.go:102:25: from &parser{...} (spill) at ./parse.go:103:7 +./parse.go:102:25: from p := &parser{...} (assign) at ./parse.go:103:4 +./parse.go:102:25: flow: {temp} ← p: +./parse.go:102:25: from (*parser).run(p) (call parameter) at ./parse.go:106:17 +./parse.go:102:25: flow: {heap} ← *{temp}: +./parse.go:103:62: make(map[sectionKey]int32) escapes to heap in parse: +./parse.go:103:62: flow: {storage for &parser{...}} ← &{storage for make(map[sectionKey]int32)}: +./parse.go:103:62: from make(map[sectionKey]int32) (spill) at ./parse.go:103:62 +./parse.go:103:62: from parser{...} (struct literal element) at ./parse.go:103:14 +./parse.go:103:62: flow: p ← &{storage for &parser{...}}: +./parse.go:103:62: from &parser{...} (spill) at ./parse.go:103:7 +./parse.go:103:62: from p := &parser{...} (assign) at ./parse.go:103:4 +./parse.go:103:62: flow: {temp} ← p: +./parse.go:103:62: from (*parser).run(p) (call parameter) at ./parse.go:106:17 +./parse.go:103:62: flow: {heap} ← *{temp}: +./parse.go:103:97: make(map[string]string) escapes to heap in parse: +./parse.go:103:97: flow: {storage for &parser{...}} ← &{storage for make(map[string]string)}: +./parse.go:103:97: from make(map[string]string) (spill) at ./parse.go:103:97 +./parse.go:103:97: from parser{...} (struct literal element) at ./parse.go:103:14 +./parse.go:103:97: flow: p ← &{storage for &parser{...}}: +./parse.go:103:97: from &parser{...} (spill) at ./parse.go:103:7 +./parse.go:103:97: from p := &parser{...} (assign) at ./parse.go:103:4 +./parse.go:103:97: flow: {temp} ← p: +./parse.go:103:97: from (*parser).run(p) (call parameter) at ./parse.go:106:17 +./parse.go:103:97: flow: {heap} ← *{temp}: +./parse.go:102:12: parameter name leaks to ~r0 for parse with derefs=0: +./parse.go:102:12: flow: {storage for &parser{...}} ← name: +./parse.go:102:12: from parser{...} (struct literal element) at ./parse.go:103:14 +./parse.go:102:12: flow: p ← &{storage for &parser{...}}: +./parse.go:102:12: from &parser{...} (spill) at ./parse.go:103:7 +./parse.go:102:12: from p := &parser{...} (assign) at ./parse.go:103:4 +./parse.go:102:12: flow: ~r0 ← *p: +./parse.go:102:12: from p.parsed (dot of pointer) at ./parse.go:109:10 +./parse.go:102:12: from return p.parsed, nil (return) at ./parse.go:109:2 +./parse.go:102:25: parameter data leaks to ~r0 for parse with derefs=0: +./parse.go:102:25: flow: {storage for &parser{...}} ← data: +./parse.go:102:25: from parser{...} (struct literal element) at ./parse.go:103:14 +./parse.go:102:25: flow: p ← &{storage for &parser{...}}: +./parse.go:102:25: from &parser{...} (spill) at ./parse.go:103:7 +./parse.go:102:25: from p := &parser{...} (assign) at ./parse.go:103:4 +./parse.go:102:25: flow: ~r0 ← *p: +./parse.go:102:25: from p.parsed (dot of pointer) at ./parse.go:109:10 +./parse.go:102:25: from return p.parsed, nil (return) at ./parse.go:109:2 +./parse.go:102:12: leaking param: name +./parse.go:102:25: leaking param: data +./parse.go:103:7: &parser{...} does not escape +./parse.go:103:62: make(map[sectionKey]int32) escapes to heap +./parse.go:103:97: make(map[string]string) escapes to heap +./parse.go:104:16: make([]item, 0, 2 * bytes.Count(data, []byte{...}) + 4) escapes to heap +./parse.go:104:54: []byte{...} does not escape +./parse.go:105:23: []sectionKey{...} escapes to heap +./edit.go:111:7: parameter f leaks to {heap} for (*File).apply with derefs=1: +./edit.go:111:7: flow: {heap} ← *f: +./edit.go:111:7: from f.name (dot of pointer) at ./edit.go:121:19 +./edit.go:111:7: from parse(f.name, data) (call parameter) at ./edit.go:121:17 +./edit.go:113:14: make([]byte, 0, len(f.data) + 64) escapes to heap in (*File).apply: +./edit.go:113:14: flow: data ← &{storage for make([]byte, 0, len(f.data) + 64)}: +./edit.go:113:14: from make([]byte, 0, len(f.data) + 64) (spill) at ./edit.go:113:14 +./edit.go:113:14: from data := make([]byte, 0, len(f.data) + 64) (assign) at ./edit.go:113:7 +./edit.go:113:14: flow: {heap} ← data: +./edit.go:113:14: from parse(f.name, data) (call parameter) at ./edit.go:121:17 +./edit.go:116:16: append(data, f.data[at:s.start]...) escapes to heap in (*File).apply: +./edit.go:116:16: flow: data ← &{storage for append(data, f.data[at:s.start]...)}: +./edit.go:116:16: from append(data, f.data[at:s.start]...) (spill) at ./edit.go:116:16 +./edit.go:116:16: from data = append(data, f.data[at:s.start]...) (assign) at ./edit.go:116:8 +./edit.go:116:16: flow: {heap} ← data: +./edit.go:116:16: from parse(f.name, data) (call parameter) at ./edit.go:121:17 +./edit.go:117:16: append(data, s.text...) escapes to heap in (*File).apply: +./edit.go:117:16: flow: data ← &{storage for append(data, s.text...)}: +./edit.go:117:16: from append(data, s.text...) (spill) at ./edit.go:117:16 +./edit.go:117:16: from data = append(data, s.text...) (assign) at ./edit.go:117:8 +./edit.go:117:16: flow: {heap} ← data: +./edit.go:117:16: from parse(f.name, data) (call parameter) at ./edit.go:121:17 +./edit.go:120:15: append(data, f.data[at:]...) escapes to heap in (*File).apply: +./edit.go:120:15: flow: data ← &{storage for append(data, f.data[at:]...)}: +./edit.go:120:15: from append(data, f.data[at:]...) (spill) at ./edit.go:120:15 +./edit.go:120:15: from data = append(data, f.data[at:]...) (assign) at ./edit.go:120:7 +./edit.go:120:15: flow: {heap} ← data: +./edit.go:120:15: from parse(f.name, data) (call parameter) at ./edit.go:121:17 +./edit.go:111:34: parameter splices leaks to {heap} for (*File).apply with derefs=1: +./edit.go:111:34: flow: slices.x ← splices: +./edit.go:111:34: from slices..dict, slices.x, slices.cmp := &slices..dict.SortFunc[[]github.com/git-bug/gitconfig.splice,github.com/git-bug/gitconfig.splice], splices, func literal (assign-pair) at ./edit.go:112:17 +./edit.go:111:34: flow: {temp} ← slices.x: +./edit.go:111:34: from slices.pdqsortCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }]((*[11]uintptr)(slices..dict[0]), slices.x, 0, slices.n, bits.Len(uint(slices.n)), slices.cmp) (call parameter) at ./edit.go:112:17 +./edit.go:111:34: flow: {heap} ← *{temp}: +./edit.go:122:33: append(out, flatEntry{...}) escapes to heap in (*File).apply: +./edit.go:122:33: flow: out ← &{storage for append(out, flatEntry{...})}: +./edit.go:122:33: from append(out, flatEntry{...}) (spill) at ./edit.go:122:33 +./edit.go:122:33: from out = append(out, flatEntry{...}) (assign) at ./edit.go:122:33 +./edit.go:122:33: flow: ~r0 ← out: +./edit.go:122:33: from ~r0 = out (assign-pair) at ./edit.go:122:33 +./edit.go:122:33: flow: {heap} ← ~r0: +./edit.go:122:33: from check(~r0, ~r0) (call parameter) at ./edit.go:122:25 +./edit.go:122:52: append(out, flatEntry{...}) escapes to heap in (*File).apply: +./edit.go:122:52: flow: out ← &{storage for append(out, flatEntry{...})}: +./edit.go:122:52: from append(out, flatEntry{...}) (spill) at ./edit.go:122:52 +./edit.go:122:52: from out = append(out, flatEntry{...}) (assign) at ./edit.go:122:52 +./edit.go:122:52: flow: ~r0 ← out: +./edit.go:122:52: from ~r0 = out (assign-pair) at ./edit.go:122:52 +./edit.go:122:52: flow: {heap} ← ~r0: +./edit.go:122:52: from check(~r0, ~r0) (call parameter) at ./edit.go:122:25 +./edit.go:123:10: &KeyError{...} escapes to heap in (*File).apply: +./edit.go:123:10: flow: ~r0 ← &{storage for &KeyError{...}}: +./edit.go:123:10: from &KeyError{...} (spill) at ./edit.go:123:10 +./edit.go:123:10: from &KeyError{...} (interface-converted) at ./edit.go:123:10 +./edit.go:123:10: from return &KeyError{...} (return) at ./edit.go:123:3 +./edit.go:111:22: parameter key leaks to {storage for &KeyError{...}} for (*File).apply with derefs=0: +./edit.go:111:22: flow: {storage for &KeyError{...}} ← key: +./edit.go:111:22: from KeyError{...} (struct literal element) at ./edit.go:123:19 +./edit.go:111:7: leaking param content: f +./edit.go:111:22: leaking param: key +./edit.go:111:34: leaking param content: splices +./edit.go:111:52: check does not escape +./edit.go:112:27: func literal does not escape +./edit.go:113:14: make([]byte, 0, len(f.data) + 64) escapes to heap +./edit.go:116:16: append escapes to heap +./edit.go:117:16: append escapes to heap +./edit.go:120:15: append escapes to heap +./edit.go:122:33: append escapes to heap +./edit.go:122:52: append escapes to heap +./edit.go:123:10: &KeyError{...} escapes to heap +./edit.go:133:15: checkKey capturing by value: k (addr=false assign=false width=56) +./edit.go:133:22: checkKey capturing by value: want (addr=false assign=false width=24) +./edit.go:133:37: checkKey capturing by value: implicitAllowed (addr=false assign=false width=1) +./edit.go:134:14: parameter before leaks to {heap} for checkKey.func1 with derefs=1: +./edit.go:134:14: flow: entries ← before: +./edit.go:134:14: from entries, _ := before, 0 (assign-pair) at ./edit.go:136:26 +./edit.go:134:14: flow: {temp} ← entries: +./edit.go:134:14: flow: e ← *{temp}: +./edit.go:134:14: from for loop (range-deref) at ./edit.go:136:26 +./edit.go:134:14: flow: {heap} ← e: +./edit.go:134:14: from append(out, e) (call parameter) at ./edit.go:136:26 +./edit.go:134:22: parameter after leaks to {heap} for checkKey.func1 with derefs=1: +./edit.go:134:22: flow: entries ← after: +./edit.go:134:22: from entries, _ := after, 0 (assign-pair) at ./edit.go:136:49 +./edit.go:134:22: flow: {temp} ← entries: +./edit.go:134:22: flow: e ← *{temp}: +./edit.go:134:22: from for loop (range-deref) at ./edit.go:136:49 +./edit.go:134:22: flow: {heap} ← e: +./edit.go:134:22: from append(out, e) (call parameter) at ./edit.go:136:49 +./edit.go:134:9: func literal escapes to heap in checkKey: +./edit.go:134:9: flow: ~r0 ← &{storage for func literal}: +./edit.go:134:9: from func literal (spill) at ./edit.go:134:9 +./edit.go:134:9: from return func literal (return) at ./edit.go:134:2 +./edit.go:133:15: parameter k leaks to {storage for func literal} for checkKey with derefs=0: +./edit.go:133:15: flow: {storage for func literal} ← k: +./edit.go:133:15: from k (captured by a closure) at ./edit.go:135:50 +./edit.go:133:22: parameter want leaks to {storage for func literal} for checkKey with derefs=0: +./edit.go:133:22: flow: {storage for func literal} ← want: +./edit.go:133:22: from want (captured by a closure) at ./edit.go:140:22 +./edit.go:133:37: parameter implicitAllowed leaks to {storage for func literal} for checkKey with derefs=0: +./edit.go:133:37: flow: {storage for func literal} ← implicitAllowed: +./edit.go:133:37: from implicitAllowed (captured by a closure) at ./edit.go:144:44 +./edit.go:133:15: leaking param: k +./edit.go:133:22: leaking param: want +./edit.go:134:14: leaking param content: before +./edit.go:134:22: leaking param content: after +./edit.go:134:9: func literal escapes to heap +./edit.go:136:26: append does not escape +./edit.go:136:49: append does not escape +./edit.go:139:16: append does not escape +./edit.go:152:13: parameter entries leaks to {heap} for filter with derefs=1: +./edit.go:152:13: flow: {temp} ← entries: +./edit.go:152:13: flow: e ← *{temp}: +./edit.go:152:13: from for loop (range-deref) at ./edit.go:154:14 +./edit.go:152:13: flow: {heap} ← e: +./edit.go:152:13: from keep(e) (call parameter) at ./edit.go:155:10 +./edit.go:156:16: append(out, e) escapes to heap in filter: +./edit.go:156:16: flow: out ← &{storage for append(out, e)}: +./edit.go:156:16: from append(out, e) (spill) at ./edit.go:156:16 +./edit.go:156:16: from out = append(out, e) (assign) at ./edit.go:156:8 +./edit.go:156:16: flow: ~r0 ← out: +./edit.go:156:16: from return out (return) at ./edit.go:159:2 +./edit.go:152:13: leaking param content: entries +./edit.go:152:34: keep does not escape +./edit.go:156:16: append escapes to heap +./edit.go:166:7: f does not escape +./edit.go:174:7: f does not escape +./edit.go:184:7: f does not escape +./edit.go:194:7: f does not escape +./edit.go:203:7: f does not escape +./edit.go:232:15: "strings: illegal use of non-zero Builder copied by value" escapes to heap in quoteValue: +./edit.go:232:15: flow: {heap} ← &{storage for "strings: illegal use of non-zero Builder copied by value"}: +./edit.go:232:15: from "strings: illegal use of non-zero Builder copied by value" (spill) at ./edit.go:232:15 +./edit.go:232:15: from panic("strings: illegal use of non-zero Builder copied by value") (call parameter) at ./edit.go:232:15 +./edit.go:232:15: append(strings.b.buf, strings.c) escapes to heap in quoteValue: +./edit.go:232:15: flow: {heap} ← &{storage for append(strings.b.buf, strings.c)}: +./edit.go:232:15: from append(strings.b.buf, strings.c) (spill) at ./edit.go:232:15 +./edit.go:232:15: from strings.b.buf = append(strings.b.buf, strings.c) (assign) at ./edit.go:232:15 +./edit.go:237:16: "strings: illegal use of non-zero Builder copied by value" escapes to heap in quoteValue: +./edit.go:237:16: flow: {heap} ← &{storage for "strings: illegal use of non-zero Builder copied by value"}: +./edit.go:237:16: from "strings: illegal use of non-zero Builder copied by value" (spill) at ./edit.go:237:16 +./edit.go:237:16: from panic("strings: illegal use of non-zero Builder copied by value") (call parameter) at ./edit.go:237:16 +./edit.go:237:16: append(strings.b.buf, strings.c) escapes to heap in quoteValue: +./edit.go:237:16: flow: {heap} ← &{storage for append(strings.b.buf, strings.c)}: +./edit.go:237:16: from append(strings.b.buf, strings.c) (spill) at ./edit.go:237:16 +./edit.go:237:16: from strings.b.buf = append(strings.b.buf, strings.c) (assign) at ./edit.go:237:16 +./edit.go:238:16: "strings: illegal use of non-zero Builder copied by value" escapes to heap in quoteValue: +./edit.go:238:16: flow: {heap} ← &{storage for "strings: illegal use of non-zero Builder copied by value"}: +./edit.go:238:16: from "strings: illegal use of non-zero Builder copied by value" (spill) at ./edit.go:238:16 +./edit.go:238:16: from panic("strings: illegal use of non-zero Builder copied by value") (call parameter) at ./edit.go:238:16 +./edit.go:238:16: append(strings.b.buf, strings.c) escapes to heap in quoteValue: +./edit.go:238:16: flow: {heap} ← &{storage for append(strings.b.buf, strings.c)}: +./edit.go:238:16: from append(strings.b.buf, strings.c) (spill) at ./edit.go:238:16 +./edit.go:238:16: from strings.b.buf = append(strings.b.buf, strings.c) (assign) at ./edit.go:238:16 +./edit.go:240:18: "strings: illegal use of non-zero Builder copied by value" escapes to heap in quoteValue: +./edit.go:240:18: flow: {heap} ← &{storage for "strings: illegal use of non-zero Builder copied by value"}: +./edit.go:240:18: from "strings: illegal use of non-zero Builder copied by value" (spill) at ./edit.go:240:18 +./edit.go:240:18: from panic("strings: illegal use of non-zero Builder copied by value") (call parameter) at ./edit.go:240:18 +./edit.go:240:18: append(strings.b.buf, strings.s...) escapes to heap in quoteValue: +./edit.go:240:18: flow: {heap} ← &{storage for append(strings.b.buf, strings.s...)}: +./edit.go:240:18: from append(strings.b.buf, strings.s...) (spill) at ./edit.go:240:18 +./edit.go:240:18: from strings.b.buf = append(strings.b.buf, strings.s...) (assign) at ./edit.go:240:18 +./edit.go:242:18: "strings: illegal use of non-zero Builder copied by value" escapes to heap in quoteValue: +./edit.go:242:18: flow: {heap} ← &{storage for "strings: illegal use of non-zero Builder copied by value"}: +./edit.go:242:18: from "strings: illegal use of non-zero Builder copied by value" (spill) at ./edit.go:242:18 +./edit.go:242:18: from panic("strings: illegal use of non-zero Builder copied by value") (call parameter) at ./edit.go:242:18 +./edit.go:242:18: append(strings.b.buf, strings.s...) escapes to heap in quoteValue: +./edit.go:242:18: flow: {heap} ← &{storage for append(strings.b.buf, strings.s...)}: +./edit.go:242:18: from append(strings.b.buf, strings.s...) (spill) at ./edit.go:242:18 +./edit.go:242:18: from strings.b.buf = append(strings.b.buf, strings.s...) (assign) at ./edit.go:242:18 +./edit.go:244:16: "strings: illegal use of non-zero Builder copied by value" escapes to heap in quoteValue: +./edit.go:244:16: flow: {heap} ← &{storage for "strings: illegal use of non-zero Builder copied by value"}: +./edit.go:244:16: from "strings: illegal use of non-zero Builder copied by value" (spill) at ./edit.go:244:16 +./edit.go:244:16: from panic("strings: illegal use of non-zero Builder copied by value") (call parameter) at ./edit.go:244:16 +./edit.go:244:16: append(strings.b.buf, strings.c) escapes to heap in quoteValue: +./edit.go:244:16: flow: {heap} ← &{storage for append(strings.b.buf, strings.c)}: +./edit.go:244:16: from append(strings.b.buf, strings.c) (spill) at ./edit.go:244:16 +./edit.go:244:16: from strings.b.buf = append(strings.b.buf, strings.c) (assign) at ./edit.go:244:16 +./edit.go:248:15: "strings: illegal use of non-zero Builder copied by value" escapes to heap in quoteValue: +./edit.go:248:15: flow: {heap} ← &{storage for "strings: illegal use of non-zero Builder copied by value"}: +./edit.go:248:15: from "strings: illegal use of non-zero Builder copied by value" (spill) at ./edit.go:248:15 +./edit.go:248:15: from panic("strings: illegal use of non-zero Builder copied by value") (call parameter) at ./edit.go:248:15 +./edit.go:248:15: append(strings.b.buf, strings.c) escapes to heap in quoteValue: +./edit.go:248:15: flow: {heap} ← &{storage for append(strings.b.buf, strings.c)}: +./edit.go:248:15: from append(strings.b.buf, strings.c) (spill) at ./edit.go:248:15 +./edit.go:248:15: from strings.b.buf = append(strings.b.buf, strings.c) (assign) at ./edit.go:248:15 +./edit.go:228:17: v does not escape +./edit.go:232:15: "strings: illegal use of non-zero Builder copied by value" escapes to heap +./edit.go:232:15: append escapes to heap +./edit.go:237:16: "strings: illegal use of non-zero Builder copied by value" escapes to heap +./edit.go:237:16: append escapes to heap +./edit.go:238:16: "strings: illegal use of non-zero Builder copied by value" escapes to heap +./edit.go:238:16: append escapes to heap +./edit.go:240:18: "strings: illegal use of non-zero Builder copied by value" escapes to heap +./edit.go:240:18: append escapes to heap +./edit.go:242:18: "strings: illegal use of non-zero Builder copied by value" escapes to heap +./edit.go:242:18: append escapes to heap +./edit.go:244:16: "strings: illegal use of non-zero Builder copied by value" escapes to heap +./edit.go:244:16: append escapes to heap +./edit.go:248:15: "strings: illegal use of non-zero Builder copied by value" escapes to heap +./edit.go:248:15: append escapes to heap +./edit.go:222:49: "\t" + name + " = " + quoteValue(value) + "\n" escapes to heap in formatEntry: +./edit.go:222:49: flow: ~r0 ← &{storage for "\t" + name + " = " + quoteValue(value) + "\n"}: +./edit.go:222:49: from "\t" + name + " = " + quoteValue(value) + "\n" (spill) at ./edit.go:222:49 +./edit.go:222:49: from return "\t" + name + " = " + quoteValue(value) + "\n" (return) at ./edit.go:222:2 +./edit.go:221:18: name does not escape +./edit.go:221:24: value does not escape +./edit.go:222:49: "\t" + name + " = " + quoteValue(value) + "\n" escapes to heap +./edit.go:258:26: "strings.NewReplacer: odd argument count" escapes to heap in formatHeader: +./edit.go:258:26: flow: {heap} ← &{storage for "strings.NewReplacer: odd argument count"}: +./edit.go:258:26: from "strings.NewReplacer: odd argument count" (spill) at ./edit.go:258:26 +./edit.go:258:26: from panic("strings.NewReplacer: odd argument count") (call parameter) at ./edit.go:258:26 +./edit.go:254:28: parameter sub leaks to {heap} for formatHeader with derefs=0: +./edit.go:254:28: flow: {heap} ← sub: +./edit.go:254:28: from (*strings.Replacer).Replace(r, sub) (call parameter) at ./edit.go:259:42 +./edit.go:258:26: &strings.Replacer{...} escapes to heap in formatHeader: +./edit.go:258:26: flow: ~r0 ← &{storage for &strings.Replacer{...}}: +./edit.go:258:26: from &strings.Replacer{...} (spill) at ./edit.go:258:26 +./edit.go:258:26: from ~r0 = &strings.Replacer{...} (assign-pair) at ./edit.go:258:26 +./edit.go:258:26: flow: r ← ~r0: +./edit.go:258:26: from r := ~r0 (assign) at ./edit.go:258:4 +./edit.go:258:26: flow: {heap} ← r: +./edit.go:258:26: from (*strings.Replacer).Replace(r, sub) (call parameter) at ./edit.go:259:42 +./edit.go:258:26: append(([]string)(nil), strings.oldnew...) escapes to heap in formatHeader: +./edit.go:258:26: flow: {storage for &strings.Replacer{...}} ← &{storage for append(([]string)(nil), strings.oldnew...)}: +./edit.go:258:26: from append(([]string)(nil), strings.oldnew...) (spill) at ./edit.go:258:26 +./edit.go:258:26: from strings.Replacer{...} (struct literal element) at ./edit.go:258:26 +./edit.go:256:24: "[" + section + "]" escapes to heap in formatHeader: +./edit.go:256:24: flow: ~r0 ← &{storage for "[" + section + "]"}: +./edit.go:256:24: from "[" + section + "]" (spill) at ./edit.go:256:24 +./edit.go:256:24: from return "[" + section + "]" (return) at ./edit.go:256:3 +./edit.go:259:48: "[" + section + " \"" + (*strings.Replacer).Replace(r, sub) + "\"]" escapes to heap in formatHeader: +./edit.go:259:48: flow: ~r0 ← &{storage for "[" + section + " \"" + (*strings.Replacer).Replace(r, sub) + "\"]"}: +./edit.go:259:48: from "[" + section + " \"" + (*strings.Replacer).Replace(r, sub) + "\"]" (spill) at ./edit.go:259:48 +./edit.go:259:48: from return "[" + section + " \"" + (*strings.Replacer).Replace(r, sub) + "\"]" (return) at ./edit.go:259:2 +./edit.go:254:19: section does not escape +./edit.go:254:28: leaking param: sub +./edit.go:256:24: "[" + section + "]" escapes to heap +./edit.go:258:26: ... argument does not escape +./edit.go:258:26: "strings.NewReplacer: odd argument count" escapes to heap +./edit.go:258:26: &strings.Replacer{...} escapes to heap +./edit.go:258:26: append escapes to heap +./edit.go:259:48: "[" + section + " \"" + (*strings.Replacer).Replace(r, sub) + "\"]" escapes to heap +./edit.go:284:7: f does not escape +./edit.go:267:15: "\n" + line escapes to heap in (*File).replaceEntry: +./edit.go:267:15: flow: line ← &{storage for "\n" + line}: +./edit.go:267:15: from "\n" + line (spill) at ./edit.go:267:15 +./edit.go:267:15: from line = "\n" + line (assign) at ./edit.go:267:8 +./edit.go:267:15: flow: ~r0 ← line: +./edit.go:267:15: from splice{...} (struct literal element) at ./edit.go:269:15 +./edit.go:267:15: from return splice{...} (return) at ./edit.go:269:2 +./edit.go:264:21: "\t" + name + " = " + quoteValue(value) + "\n" escapes to heap in (*File).replaceEntry: +./edit.go:264:21: flow: ~r0 ← &{storage for "\t" + name + " = " + quoteValue(value) + "\n"}: +./edit.go:264:21: from "\t" + name + " = " + quoteValue(value) + "\n" (spill) at ./edit.go:264:21 +./edit.go:264:21: from ~r0 = "\t" + name + " = " + quoteValue(value) + "\n" (assign-pair) at ./edit.go:264:21 +./edit.go:264:21: flow: line ← ~r0: +./edit.go:264:21: from line := ~r0 (assign) at ./edit.go:264:7 +./edit.go:264:21: flow: ~r0 ← line: +./edit.go:264:21: from splice{...} (struct literal element) at ./edit.go:269:15 +./edit.go:264:21: from return splice{...} (return) at ./edit.go:269:2 +./edit.go:263:7: f does not escape +./edit.go:263:36: name does not escape +./edit.go:263:42: value does not escape +./edit.go:264:21: "\t" + name + " = " + quoteValue(value) + "\n" escapes to heap +./edit.go:267:15: "\n" + line escapes to heap +./edit.go:274:7: f does not escape +./edit.go:346:7: f does not escape +./edit.go:346:34: removed does not escape +./edit.go:346:43: trailing does not escape +./edit.go:334:32: a does not escape +./edit.go:334:35: b does not escape +./edit.go:341:18: append(merged, sp) escapes to heap in (*File).unsetEntries: +./edit.go:341:18: flow: merged ← &{storage for append(merged, sp)}: +./edit.go:341:18: from append(merged, sp) (spill) at ./edit.go:341:18 +./edit.go:341:18: from merged = append(merged, sp) (assign) at ./edit.go:341:10 +./edit.go:341:18: flow: ~r0 ← merged: +./edit.go:341:18: from return merged (return) at ./edit.go:343:2 +./edit.go:313:7: f does not escape +./edit.go:313:29: idx does not escape +./edit.go:314:17: make(map[int]bool, len(idx)) does not escape +./edit.go:319:18: make(map[int]bool) does not escape +./edit.go:330:19: append does not escape +./edit.go:334:27: func literal does not escape +./edit.go:341:18: append escapes to heap +./edit.go:398:39: parameter sub leaks to {heap} for (*File).insert with derefs=0: +./edit.go:398:39: flow: {heap} ← sub: +./edit.go:398:39: from formatHeader(section, sub, k.HasSubsection) (call parameter) at ./edit.go:408:72 +./edit.go:408:111: ~r0 + formatHeader(section, sub, k.HasSubsection) + "\n" + line escapes to heap in (*File).insert: +./edit.go:408:111: flow: ~r0 ← &{storage for ~r0 + formatHeader(section, sub, k.HasSubsection) + "\n" + line}: +./edit.go:408:111: from ~r0 + formatHeader(section, sub, k.HasSubsection) + "\n" + line (spill) at ./edit.go:408:111 +./edit.go:408:111: from splice{...} (struct literal element) at ./edit.go:408:16 +./edit.go:408:111: from return splice{...} (return) at ./edit.go:408:3 +./edit.go:427:58: ~r0 + line escapes to heap in (*File).insert: +./edit.go:427:58: flow: ~r0 ← &{storage for ~r0 + line}: +./edit.go:427:58: from ~r0 + line (spill) at ./edit.go:427:58 +./edit.go:427:58: from splice{...} (struct literal element) at ./edit.go:427:16 +./edit.go:427:58: from return splice{...} (return) at ./edit.go:427:3 +./edit.go:435:31: "\n" + line escapes to heap in (*File).insert: +./edit.go:435:31: flow: ~r0 ← &{storage for "\n" + line}: +./edit.go:435:31: from "\n" + line (spill) at ./edit.go:435:31 +./edit.go:435:31: from splice{...} (struct literal element) at ./edit.go:435:15 +./edit.go:435:31: from return splice{...} (return) at ./edit.go:435:2 +./edit.go:406:21: "\t" + name + " = " + quoteValue(value) + "\n" escapes to heap in (*File).insert: +./edit.go:406:21: flow: ~r0 ← &{storage for "\t" + name + " = " + quoteValue(value) + "\n"}: +./edit.go:406:21: from "\t" + name + " = " + quoteValue(value) + "\n" (spill) at ./edit.go:406:21 +./edit.go:406:21: from ~r0 = "\t" + name + " = " + quoteValue(value) + "\n" (assign-pair) at ./edit.go:406:21 +./edit.go:406:21: flow: line ← ~r0: +./edit.go:406:21: from line := ~r0 (assign) at ./edit.go:406:7 +./edit.go:406:21: flow: ~r0 ← line: +./edit.go:406:21: from splice{...} (struct literal element) at ./edit.go:425:17 +./edit.go:406:21: from return splice{...} (return) at ./edit.go:425:4 +./edit.go:398:7: f does not escape +./edit.go:398:23: k does not escape +./edit.go:398:30: section does not escape +./edit.go:398:39: leaking param: sub +./edit.go:398:44: name does not escape +./edit.go:398:50: value does not escape +./edit.go:406:21: "\t" + name + " = " + quoteValue(value) + "\n" escapes to heap +./edit.go:408:111: ~r0 + formatHeader(section, sub, k.HasSubsection) + "\n" + line escapes to heap +./edit.go:427:58: ~r0 + line escapes to heap +./edit.go:435:31: "\n" + line escapes to heap +./edit.go:441:10: &KeyError{...} escapes to heap in sectionArg: +./edit.go:441:10: flow: ~r0 ← &{storage for &KeyError{...}}: +./edit.go:441:10: from &KeyError{...} (spill) at ./edit.go:441:10 +./edit.go:441:10: from &KeyError{...} (interface-converted) at ./edit.go:441:10 +./edit.go:441:10: from return &KeyError{...} (return) at ./edit.go:441:3 +./edit.go:439:17: parameter section leaks to {storage for &KeyError{...}} for sectionArg with derefs=0: +./edit.go:439:17: flow: {storage for &KeyError{...}} ← section: +./edit.go:439:17: from KeyError{...} (struct literal element) at ./edit.go:441:19 +./edit.go:439:17: leaking param: section +./edit.go:441:10: &KeyError{...} escapes to heap +./edit.go:451:16: append(idx, i) escapes to heap in (*File).headersOf: +./edit.go:451:16: flow: idx ← &{storage for append(idx, i)}: +./edit.go:451:16: from append(idx, i) (spill) at ./edit.go:451:16 +./edit.go:451:16: from idx = append(idx, i) (assign) at ./edit.go:451:8 +./edit.go:451:16: flow: ~r0 ← idx: +./edit.go:451:16: from return idx (return) at ./edit.go:454:2 +./edit.go:447:7: f does not escape +./edit.go:447:26: sk does not escape +./edit.go:451:16: append escapes to heap +./edit.go:459:43: (*File).removeSection capturing by value: sk (addr=false assign=false width=40) +./edit.go:459:30: parameter name leaks to {heap} for (*File).removeSection with derefs=0: +./edit.go:459:30: flow: {heap} ← name: +./edit.go:459:30: from (*File).apply(f, name, splices, func literal) (call parameter) at ./edit.go:475:16 +./edit.go:459:7: parameter f leaks to {heap} for (*File).removeSection with derefs=1: +./edit.go:459:7: flow: {temp} ← f: +./edit.go:459:7: from (*File).apply(f, name, splices, func literal) (call parameter) at ./edit.go:475:16 +./edit.go:459:7: flow: {heap} ← *{temp}: +./edit.go:475:37: parameter before leaks to {heap} for (*File).removeSection.func1 with derefs=1: +./edit.go:475:37: flow: entries ← before: +./edit.go:475:37: from entries, _ := before, 0 (assign-pair) at ./edit.go:476:29 +./edit.go:475:37: flow: {temp} ← entries: +./edit.go:475:37: flow: e ← *{temp}: +./edit.go:475:37: from for loop (range-deref) at ./edit.go:476:29 +./edit.go:475:37: flow: {heap} ← e: +./edit.go:475:37: from append(out, e) (call parameter) at ./edit.go:476:29 +./edit.go:459:7: leaking param content: f +./edit.go:459:30: leaking param: name +./edit.go:459:43: sk does not escape +./edit.go:475:37: leaking param content: before +./edit.go:475:45: after does not escape +./edit.go:460:24: append does not escape +./edit.go:473:19: append does not escape +./edit.go:475:32: func literal does not escape +./edit.go:476:29: append does not escape +./edit.go:483:43: (*File).renameSection capturing by value: sk (addr=false assign=false width=40) +./edit.go:483:47: (*File).renameSection capturing by value: to (addr=false assign=false width=40) +./edit.go:483:62: parameter header leaks to {heap} for (*File).renameSection with derefs=0: +./edit.go:483:62: flow: {heap} ← header: +./edit.go:483:62: from splice{...} (struct literal element) at ./edit.go:495:36 +./edit.go:483:62: from append(splices, splice{...}) (call parameter) at ./edit.go:495:20 +./edit.go:483:30: parameter name leaks to {heap} for (*File).renameSection with derefs=0: +./edit.go:483:30: flow: {heap} ← name: +./edit.go:483:30: from (*File).apply(f, name, splices, func literal) (call parameter) at ./edit.go:522:16 +./edit.go:483:47: parameter to leaks to {heap} for (*File).renameSection with derefs=0: +./edit.go:483:47: flow: {heap} ← to: +./edit.go:483:47: from before[i].sec = to (assign) at ./edit.go:525:19 +./edit.go:508:18: header + "\n" escapes to heap in (*File).renameSection: +./edit.go:508:18: flow: text ← &{storage for header + "\n"}: +./edit.go:508:18: from header + "\n" (spill) at ./edit.go:508:18 +./edit.go:508:18: from text := header + "\n" (assign) at ./edit.go:508:8 +./edit.go:508:18: flow: {heap} ← text: +./edit.go:508:18: from splice{...} (struct literal element) at ./edit.go:519:35 +./edit.go:508:18: from append(splices, splice{...}) (call parameter) at ./edit.go:519:19 +./edit.go:515:27: string(f.data[it.start:it.end]) escapes to heap in (*File).renameSection: +./edit.go:515:27: flow: text ← &{storage for string(f.data[it.start:it.end])}: +./edit.go:515:27: from string(f.data[it.start:it.end]) (spill) at ./edit.go:515:27 +./edit.go:515:27: from text += string(f.data[it.start:it.end]) (assign) at ./edit.go:515:11 +./edit.go:515:27: flow: {heap} ← text: +./edit.go:515:27: from splice{...} (struct literal element) at ./edit.go:519:35 +./edit.go:515:27: from append(splices, splice{...}) (call parameter) at ./edit.go:519:19 +./edit.go:483:7: parameter f leaks to {heap} for (*File).renameSection with derefs=1: +./edit.go:483:7: flow: {temp} ← f: +./edit.go:483:7: from (*File).apply(f, name, splices, func literal) (call parameter) at ./edit.go:522:16 +./edit.go:483:7: flow: {heap} ← *{temp}: +./edit.go:486:10: &KeyError{...} escapes to heap in (*File).renameSection: +./edit.go:486:10: flow: ~r0 ← &{storage for &KeyError{...}}: +./edit.go:486:10: from &KeyError{...} (spill) at ./edit.go:486:10 +./edit.go:486:10: from &KeyError{...} (interface-converted) at ./edit.go:486:10 +./edit.go:486:10: from return &KeyError{...} (return) at ./edit.go:486:3 +./edit.go:483:30: parameter name leaks to {storage for &KeyError{...}} for (*File).renameSection with derefs=0: +./edit.go:483:30: flow: {storage for &KeyError{...}} ← name: +./edit.go:483:30: from KeyError{...} (struct literal element) at ./edit.go:486:19 +./edit.go:483:7: leaking param content: f +./edit.go:483:30: leaking param: name +./edit.go:483:43: sk does not escape +./edit.go:483:47: leaking param: to +./edit.go:483:62: leaking param: header +./edit.go:522:37: before does not escape +./edit.go:522:45: after does not escape +./edit.go:484:24: append does not escape +./edit.go:486:10: &KeyError{...} escapes to heap +./edit.go:495:20: append does not escape +./edit.go:508:18: header + "\n" escapes to heap +./edit.go:515:27: string(f.data[it.start:it.end]) escapes to heap +./edit.go:519:19: append does not escape +./edit.go:522:32: func literal does not escape +./env.go:45:41: "Scope(" + ~r0 + ")" escapes to heap in Scope.String: +./env.go:45:41: flow: ~r0 ← &{storage for "Scope(" + ~r0 + ")"}: +./env.go:45:41: from "Scope(" + ~r0 + ")" (spill) at ./env.go:45:41 +./env.go:45:41: from return "Scope(" + ~r0 + ")" (return) at ./env.go:45:2 +./env.go:45:41: "Scope(" + ~r0 + ")" escapes to heap +./env.go:121:35: osEnviron{} escapes to heap in Discover: +./env.go:121:35: flow: {heap} ← &{storage for osEnviron{}}: +./env.go:121:35: from osEnviron{} (spill) at ./env.go:121:35 +./env.go:121:35: from discover(gitDir, osEnviron{}) (call parameter) at ./env.go:121:17 +./env.go:120:15: parameter gitDir leaks to {heap} for Discover with derefs=0: +./env.go:120:15: flow: {heap} ← gitDir: +./env.go:120:15: from discover(gitDir, osEnviron{}) (call parameter) at ./env.go:121:17 +./env.go:120:15: leaking param: gitDir +./env.go:121:35: osEnviron{} escapes to heap +./load.go:42:35: string(data) escapes to heap in Env.repo: +./load.go:42:35: flow: dir ← &{storage for string(data)}: +./load.go:42:35: from string(data) (spill) at ./load.go:42:35 +./load.go:42:35: from strings.TrimRight(string(data), "\r\n") (call parameter) at ./load.go:42:27 +./load.go:42:35: from dir := strings.TrimRight(string(data), "\r\n") (assign) at ./load.go:42:7 +./load.go:42:35: flow: filepath.path ← dir: +./load.go:42:35: from filepath.path := dir (assign-pair) at ./load.go:46:31 +./load.go:42:35: flow: {temp} ← filepath.path: +./load.go:42:35: from filepathlite.Clean(filepath.path) (call parameter) at ./load.go:46:31 +./load.go:42:35: flow: ~r0 ← {temp}: +./load.go:42:35: from ~r0 = filepathlite.Clean(filepath.path) (assign-pair) at ./load.go:46:31 +./load.go:42:35: flow: {heap} ← ~r0: +./load.go:42:35: from r.commonDir = ~r0 (assign) at ./load.go:46:15 +./load.go:31:7: parameter e leaks to {heap} for Env.repo with derefs=0: +./load.go:31:7: flow: {storage for ... argument} ← e: +./load.go:31:7: from e.GitDir (dot) at ./load.go:39:40 +./load.go:31:7: from ... argument (slice-literal-element) at ./load.go:39:38 +./load.go:31:7: flow: filepath.elem ← &{storage for ... argument}: +./load.go:31:7: from ... argument (spill) at ./load.go:39:38 +./load.go:31:7: from filepath.elem := ... argument (assign-pair) at ./load.go:39:38 +./load.go:31:7: flow: {temp} ← filepath.elem: +./load.go:31:7: from filepath.join(filepath.elem) (call parameter) at ./load.go:39:38 +./load.go:31:7: flow: ~r0 ← *{temp}: +./load.go:31:7: from ~r0 = filepath.join(filepath.elem) (assign-pair) at ./load.go:39:38 +./load.go:31:7: flow: path ← ~r0: +./load.go:31:7: from path := ~r0 (assign-pair) at ./load.go:39:24 +./load.go:31:7: flow: {heap} ← path: +./load.go:31:7: from readConfigFile(path, int64(4096)) (call parameter) at ./load.go:39:24 +./load.go:36:15: &FileError{...} escapes to heap in Env.repo: +./load.go:36:15: flow: ~r1 ← &{storage for &FileError{...}}: +./load.go:36:15: from &FileError{...} (spill) at ./load.go:36:15 +./load.go:36:15: from &FileError{...} (interface-converted) at ./load.go:36:15 +./load.go:36:15: from return nil, &FileError{...} (return) at ./load.go:36:3 +./load.go:48:15: &FileError{...} escapes to heap in Env.repo: +./load.go:48:15: flow: ~r1 ← &{storage for &FileError{...}}: +./load.go:48:15: from &FileError{...} (spill) at ./load.go:48:15 +./load.go:48:15: from &FileError{...} (interface-converted) at ./load.go:48:15 +./load.go:48:15: from return nil, &FileError{...} (return) at ./load.go:48:3 +./load.go:31:7: parameter e leaks to {storage for &FileError{...}} for Env.repo with derefs=0: +./load.go:31:7: flow: {storage for ... argument} ← e: +./load.go:31:7: from e.GitDir (dot) at ./load.go:48:47 +./load.go:31:7: from ... argument (slice-literal-element) at ./load.go:48:45 +./load.go:31:7: flow: filepath.elem ← &{storage for ... argument}: +./load.go:31:7: from ... argument (spill) at ./load.go:48:45 +./load.go:31:7: from filepath.elem := ... argument (assign-pair) at ./load.go:48:45 +./load.go:31:7: flow: {temp} ← filepath.elem: +./load.go:31:7: from filepath.join(filepath.elem) (call parameter) at ./load.go:48:45 +./load.go:31:7: flow: ~r0 ← *{temp}: +./load.go:31:7: from ~r0 = filepath.join(filepath.elem) (assign-pair) at ./load.go:48:45 +./load.go:31:7: flow: {storage for &FileError{...}} ← ~r0: +./load.go:31:7: from FileError{...} (struct literal element) at ./load.go:48:25 +./load.go:31:7: parameter e leaks to {storage for &FileError{...}} for Env.repo with derefs=0: +./load.go:31:7: flow: {storage for &FileError{...}} ← e: +./load.go:31:7: from e.GitDir (dot) at ./load.go:36:33 +./load.go:31:7: from FileError{...} (struct literal element) at ./load.go:36:25 +./load.go:38:7: &repo{...} escapes to heap in Env.repo: +./load.go:38:7: flow: r ← &{storage for &repo{...}}: +./load.go:38:7: from &repo{...} (spill) at ./load.go:38:7 +./load.go:38:7: from r := &repo{...} (assign) at ./load.go:38:4 +./load.go:38:7: flow: ~r0 ← r: +./load.go:38:7: from return r, nil (return) at ./load.go:50:2 +./load.go:31:7: parameter e leaks to {storage for &repo{...}} for Env.repo with derefs=0: +./load.go:31:7: flow: {storage for &repo{...}} ← e: +./load.go:31:7: from e.GitDir (dot) at ./load.go:38:22 +./load.go:31:7: from repo{...} (struct literal element) at ./load.go:38:12 +./load.go:31:7: leaking param: e +./load.go:36:15: &FileError{...} escapes to heap +./load.go:38:7: &repo{...} escapes to heap +./load.go:39:38: ... argument does not escape +./load.go:42:35: string(data) escapes to heap +./load.go:44:23: ... argument does not escape +./load.go:48:15: &FileError{...} escapes to heap +./load.go:48:45: ... argument does not escape +./load.go:180:7: parameter e leaks to {heap} for Env.newLoader with derefs=0: +./load.go:180:7: flow: {heap} ← e: +./load.go:180:7: from Env.repo(e) (call parameter) at ./load.go:181:18 +./load.go:185:9: &loader{...} escapes to heap in Env.newLoader: +./load.go:185:9: flow: ~r0 ← &{storage for &loader{...}}: +./load.go:185:9: from &loader{...} (spill) at ./load.go:185:9 +./load.go:185:9: from return &loader{...}, nil (return) at ./load.go:185:2 +./load.go:180:7: parameter e leaks to {storage for &loader{...}} for Env.newLoader with derefs=0: +./load.go:180:7: flow: {storage for &loader{...}} ← e: +./load.go:180:7: from loader{...} (struct literal element) at ./load.go:185:16 +./load.go:180:7: leaking param: e +./load.go:185:9: &loader{...} escapes to heap +./load.go:163:65: syscall.Errno(20) escapes to heap in isMissing: +./load.go:163:65: flow: {heap} ← &{storage for syscall.Errno(20)}: +./load.go:163:65: from syscall.Errno(20) (spill) at ./load.go:163:65 +./load.go:163:65: from errors.Is(err, syscall.Errno(20)) (call parameter) at ./load.go:163:52 +./load.go:162:16: parameter err leaks to {heap} for isMissing with derefs=0: +./load.go:162:16: flow: {heap} ← err: +./load.go:162:16: from errors.Is(err, fs.ErrNotExist) (call parameter) at ./load.go:163:18 +./load.go:162:16: leaking param: err +./load.go:163:65: syscall.Errno(20) escapes to heap +./glob.go:107:22: append(tok.ranges, [2]byte{...}) escapes to heap in compileClass: +./glob.go:107:22: flow: tok ← &{storage for append(tok.ranges, [2]byte{...})}: +./glob.go:107:22: from append(tok.ranges, [2]byte{...}) (spill) at ./glob.go:107:22 +./glob.go:107:22: from tok.ranges = append(tok.ranges, [2]byte{...}) (assign) at ./glob.go:107:14 +./glob.go:107:22: flow: ~r0 ← tok: +./glob.go:107:22: from return tok, i + 1, true (return) at ./glob.go:91:4 +./glob.go:80:19: p does not escape +./glob.go:107:22: append escapes to heap +./glob.go:40:18: append(toks, globToken{...}) escapes to heap in compileGlob: +./glob.go:40:18: flow: toks ← &{storage for append(toks, globToken{...})}: +./glob.go:40:18: from append(toks, globToken{...}) (spill) at ./glob.go:40:18 +./glob.go:40:18: from toks = append(toks, globToken{...}) (assign) at ./glob.go:40:10 +./glob.go:40:18: flow: ~r0 ← toks: +./glob.go:40:18: from return toks (return) at ./glob.go:75:2 +./glob.go:46:18: append(toks, globToken{...}) escapes to heap in compileGlob: +./glob.go:46:18: flow: toks ← &{storage for append(toks, globToken{...})}: +./glob.go:46:18: from append(toks, globToken{...}) (spill) at ./glob.go:46:18 +./glob.go:46:18: from toks = append(toks, globToken{...}) (assign) at ./glob.go:46:10 +./glob.go:46:18: flow: ~r0 ← toks: +./glob.go:46:18: from return toks (return) at ./glob.go:75:2 +./glob.go:54:17: append(toks, globToken{...}) escapes to heap in compileGlob: +./glob.go:54:17: flow: toks ← &{storage for append(toks, globToken{...})}: +./glob.go:54:17: from append(toks, globToken{...}) (spill) at ./glob.go:54:17 +./glob.go:54:17: from toks = append(toks, globToken{...}) (assign) at ./glob.go:54:9 +./glob.go:54:17: flow: ~r0 ← toks: +./glob.go:54:17: from return toks (return) at ./glob.go:75:2 +./glob.go:56:17: append(toks, globToken{...}) escapes to heap in compileGlob: +./glob.go:56:17: flow: toks ← &{storage for append(toks, globToken{...})}: +./glob.go:56:17: from append(toks, globToken{...}) (spill) at ./glob.go:56:17 +./glob.go:56:17: from toks = append(toks, globToken{...}) (assign) at ./glob.go:56:9 +./glob.go:56:17: flow: ~r0 ← toks: +./glob.go:56:17: from return toks (return) at ./glob.go:75:2 +./glob.go:60:18: append(toks, tok) escapes to heap in compileGlob: +./glob.go:60:18: flow: toks ← &{storage for append(toks, tok)}: +./glob.go:60:18: from append(toks, tok) (spill) at ./glob.go:60:18 +./glob.go:60:18: from toks = append(toks, tok) (assign) at ./glob.go:60:10 +./glob.go:60:18: flow: ~r0 ← toks: +./glob.go:60:18: from return toks (return) at ./glob.go:75:2 +./glob.go:63:18: append(toks, globToken{...}) escapes to heap in compileGlob: +./glob.go:63:18: flow: toks ← &{storage for append(toks, globToken{...})}: +./glob.go:63:18: from append(toks, globToken{...}) (spill) at ./glob.go:63:18 +./glob.go:63:18: from toks = append(toks, globToken{...}) (assign) at ./glob.go:63:10 +./glob.go:63:18: flow: ~r0 ← toks: +./glob.go:63:18: from return toks (return) at ./glob.go:75:2 +./glob.go:67:17: append(toks, globToken{...}) escapes to heap in compileGlob: +./glob.go:67:17: flow: toks ← &{storage for append(toks, globToken{...})}: +./glob.go:67:17: from append(toks, globToken{...}) (spill) at ./glob.go:67:17 +./glob.go:67:17: from toks = append(toks, globToken{...}) (assign) at ./glob.go:67:9 +./glob.go:67:17: flow: ~r0 ← toks: +./glob.go:67:17: from return toks (return) at ./glob.go:75:2 +./glob.go:70:17: append(toks, globToken{...}) escapes to heap in compileGlob: +./glob.go:70:17: flow: toks ← &{storage for append(toks, globToken{...})}: +./glob.go:70:17: from append(toks, globToken{...}) (spill) at ./glob.go:70:17 +./glob.go:70:17: from toks = append(toks, globToken{...}) (assign) at ./glob.go:70:9 +./glob.go:70:17: flow: ~r0 ← toks: +./glob.go:70:17: from return toks (return) at ./glob.go:75:2 +./glob.go:32:18: p does not escape +./glob.go:40:18: append escapes to heap +./glob.go:46:18: append escapes to heap +./glob.go:54:17: append escapes to heap +./glob.go:56:17: append escapes to heap +./glob.go:60:18: append escapes to heap +./glob.go:63:18: append escapes to heap +./glob.go:67:17: append escapes to heap +./glob.go:70:17: append escapes to heap +./glob.go:113:7: t does not escape +./glob.go:157:7: append(ss.list, id) escapes to heap in globMatch: +./glob.go:157:7: flow: {heap} ← &{storage for append(ss.list, id)}: +./glob.go:157:7: from append(ss.list, id) (spill) at ./glob.go:157:7 +./glob.go:157:7: from ss.list = append(ss.list, id) (assign) at ./glob.go:157:7 +./glob.go:160:13: globMatch ignoring self-assignment in ss.list = ss.list[:0] +./glob.go:165:13: append(ss.list, id) escapes to heap in globMatch: +./glob.go:165:13: flow: {heap} ← &{storage for append(ss.list, id)}: +./glob.go:165:13: from append(ss.list, id) (spill) at ./glob.go:165:13 +./glob.go:165:13: from ss.list = append(ss.list, id) (assign) at ./glob.go:165:13 +./glob.go:167:11: append(ss.list, id) escapes to heap in globMatch: +./glob.go:167:11: flow: {heap} ← &{storage for append(ss.list, id)}: +./glob.go:167:11: from append(ss.list, id) (spill) at ./glob.go:167:11 +./glob.go:167:11: from ss.list = append(ss.list, id) (assign) at ./glob.go:167:11 +./glob.go:177:11: append(ss.list, id) escapes to heap in globMatch: +./glob.go:177:11: flow: {heap} ← &{storage for append(ss.list, id)}: +./glob.go:177:11: from append(ss.list, id) (spill) at ./glob.go:177:11 +./glob.go:177:11: from ss.list = append(ss.list, id) (assign) at ./glob.go:177:11 +./glob.go:181:11: append(ss.list, id) escapes to heap in globMatch: +./glob.go:181:11: flow: {heap} ← &{storage for append(ss.list, id)}: +./glob.go:181:11: from append(ss.list, id) (spill) at ./glob.go:181:11 +./glob.go:181:11: from ss.list = append(ss.list, id) (assign) at ./glob.go:181:11 +./glob.go:185:11: append(ss.list, id) escapes to heap in globMatch: +./glob.go:185:11: flow: {heap} ← &{storage for append(ss.list, id)}: +./glob.go:185:11: from append(ss.list, id) (spill) at ./glob.go:185:11 +./glob.go:185:11: from ss.list = append(ss.list, id) (assign) at ./glob.go:185:11 +./glob.go:189:11: append(ss.list, id) escapes to heap in globMatch: +./glob.go:189:11: flow: {heap} ← &{storage for append(ss.list, id)}: +./glob.go:189:11: from append(ss.list, id) (spill) at ./glob.go:189:11 +./glob.go:189:11: from ss.list = append(ss.list, id) (assign) at ./glob.go:189:11 +./glob.go:192:13: append(ss.list, id) escapes to heap in globMatch: +./glob.go:192:13: flow: {heap} ← &{storage for append(ss.list, id)}: +./glob.go:192:13: from append(ss.list, id) (spill) at ./glob.go:192:13 +./glob.go:192:13: from ss.list = append(ss.list, id) (assign) at ./glob.go:192:13 +./glob.go:194:11: append(ss.list, id) escapes to heap in globMatch: +./glob.go:194:11: flow: {heap} ← &{storage for append(ss.list, id)}: +./glob.go:194:11: from append(ss.list, id) (spill) at ./glob.go:194:11 +./glob.go:194:11: from ss.list = append(ss.list, id) (assign) at ./glob.go:194:11 +./glob.go:197:10: append(ss.list, id) escapes to heap in globMatch: +./glob.go:197:10: flow: {heap} ← &{storage for append(ss.list, id)}: +./glob.go:197:10: from append(ss.list, id) (spill) at ./glob.go:197:10 +./glob.go:197:10: from ss.list = append(ss.list, id) (assign) at ./glob.go:197:10 +./glob.go:144:21: make([]uint32, size) escapes to heap in globMatch: +./glob.go:144:21: flow: {storage for &stateSet{...}} ← &{storage for make([]uint32, size)}: +./glob.go:144:21: from make([]uint32, size) (spill) at ./glob.go:144:21 +./glob.go:144:21: from stateSet{...} (struct literal element) at ./glob.go:144:21 +./glob.go:144:21: flow: ~r0 ← &{storage for &stateSet{...}}: +./glob.go:144:21: from &stateSet{...} (spill) at ./glob.go:144:21 +./glob.go:144:21: from ~r0 = &stateSet{...} (assign-pair) at ./glob.go:144:21 +./glob.go:144:21: flow: next ← ~r0: +./glob.go:144:21: from next := ~r0 (assign) at ./glob.go:144:7 +./glob.go:144:21: flow: ss ← next: +./glob.go:144:21: from ss, id := next, id (assign-pair) at ./glob.go:165:13 +./glob.go:144:21: flow: {temp} ← *ss: +./glob.go:144:21: from ss.list (dot of pointer) at ./glob.go:165:13 +./glob.go:144:21: from append(ss.list, id) (call parameter) at ./glob.go:165:13 +./glob.go:144:21: flow: {heap} ← {temp}: +./glob.go:144:21: from ss.list = append(ss.list, id) (assign) at ./glob.go:165:13 +./glob.go:143:20: make([]uint32, size) escapes to heap in globMatch: +./glob.go:143:20: flow: {storage for &stateSet{...}} ← &{storage for make([]uint32, size)}: +./glob.go:143:20: from make([]uint32, size) (spill) at ./glob.go:143:20 +./glob.go:143:20: from stateSet{...} (struct literal element) at ./glob.go:143:20 +./glob.go:143:20: flow: ~r0 ← &{storage for &stateSet{...}}: +./glob.go:143:20: from &stateSet{...} (spill) at ./glob.go:143:20 +./glob.go:143:20: from ~r0 = &stateSet{...} (assign-pair) at ./glob.go:143:20 +./glob.go:143:20: flow: cur ← ~r0: +./glob.go:143:20: from cur := ~r0 (assign) at ./glob.go:143:6 +./glob.go:143:20: flow: set ← cur: +./glob.go:143:20: from set, s := cur, int32(0) (assign-pair) at ./glob.go:157:7 +./glob.go:143:20: flow: ss ← set: +./glob.go:143:20: from ss, id := set, int32(2) * s (assign-pair) at ./glob.go:157:7 +./glob.go:143:20: flow: {temp} ← *ss: +./glob.go:143:20: from ss.list (dot of pointer) at ./glob.go:157:7 +./glob.go:143:20: from append(ss.list, id) (call parameter) at ./glob.go:157:7 +./glob.go:143:20: flow: {heap} ← {temp}: +./glob.go:143:20: from ss.list = append(ss.list, id) (assign) at ./glob.go:157:7 +./glob.go:137:16: pattern does not escape +./glob.go:137:25: name does not escape +./glob.go:143:20: &stateSet{...} does not escape +./glob.go:143:20: make([]uint32, size) escapes to heap +./glob.go:144:21: &stateSet{...} does not escape +./glob.go:144:21: make([]uint32, size) escapes to heap +./glob.go:157:7: append escapes to heap +./glob.go:165:13: append escapes to heap +./glob.go:167:11: append escapes to heap +./glob.go:177:11: append escapes to heap +./glob.go:181:11: append escapes to heap +./glob.go:185:11: append escapes to heap +./glob.go:189:11: append escapes to heap +./glob.go:192:13: append escapes to heap +./glob.go:194:11: append escapes to heap +./glob.go:197:10: append escapes to heap +./load.go:330:7: parameter l leaks to {heap} for (*loader).gitdir with derefs=2: +./load.go:330:7: flow: {heap} ← **l: +./load.go:330:7: from l.repo (dot of pointer) at ./load.go:356:41 +./load.go:330:7: from l.repo.gitDir (dot of pointer) at ./load.go:356:46 +./load.go:330:7: from filepath.EvalSymlinks(l.repo.gitDir) (call parameter) at ./load.go:356:39 +./load.go:334:18: &FileError{...} escapes to heap in (*loader).gitdir: +./load.go:334:18: flow: ~r1 ← &{storage for &FileError{...}}: +./load.go:334:18: from &FileError{...} (spill) at ./load.go:334:18 +./load.go:334:18: from &FileError{...} (interface-converted) at ./load.go:334:18 +./load.go:334:18: from return false, &FileError{...} (return) at ./load.go:334:4 +./load.go:330:25: parameter pattern leaks to {storage for &FileError{...}} for (*loader).gitdir with derefs=0: +./load.go:330:25: flow: {storage for &FileError{...}} ← pattern: +./load.go:330:25: from FileError{...} (struct literal element) at ./load.go:334:28 +./load.go:336:47: ~r0 + pattern[2:] escapes to heap in (*loader).gitdir: +./load.go:336:47: flow: pattern ← &{storage for ~r0 + pattern[2:]}: +./load.go:336:47: from ~r0 + pattern[2:] (spill) at ./load.go:336:47 +./load.go:336:47: from pattern = ~r0 + pattern[2:] (assign) at ./load.go:336:11 +./load.go:336:47: flow: {storage for &FileError{...}} ← pattern: +./load.go:336:47: from FileError{...} (struct literal element) at ./load.go:334:28 +./load.go:341:67: ~r0 + pattern[1:] escapes to heap in (*loader).gitdir: +./load.go:341:67: flow: pattern ← &{storage for ~r0 + pattern[1:]}: +./load.go:341:67: from ~r0 + pattern[1:] (spill) at ./load.go:341:67 +./load.go:341:67: from pattern = ~r0 + pattern[1:] (assign) at ./load.go:341:11 +./load.go:341:67: flow: {storage for &FileError{...}} ← pattern: +./load.go:341:67: from FileError{...} (struct literal element) at ./load.go:334:28 +./load.go:347:19: "**/" + pattern escapes to heap in (*loader).gitdir: +./load.go:347:19: flow: pattern ← &{storage for "**/" + pattern}: +./load.go:347:19: from "**/" + pattern (spill) at ./load.go:347:19 +./load.go:347:19: from pattern = "**/" + pattern (assign) at ./load.go:347:11 +./load.go:347:19: flow: {storage for &FileError{...}} ← pattern: +./load.go:347:19: from FileError{...} (struct literal element) at ./load.go:334:28 +./load.go:330:7: leaking param content: l +./load.go:330:25: leaking param: pattern +./load.go:330:34: from does not escape +./load.go:334:18: &FileError{...} escapes to heap +./load.go:336:47: ~r0 + pattern[2:] escapes to heap +./load.go:341:67: ~r0 + pattern[1:] escapes to heap +./load.go:347:19: "**/" + pattern escapes to heap +./load.go:104:7: parameter r leaks to {heap} for (*repo).branch with derefs=1: +./load.go:104:7: flow: {storage for ... argument} ← *r: +./load.go:104:7: from r.gitDir (dot of pointer) at ./load.go:105:40 +./load.go:104:7: from ... argument (slice-literal-element) at ./load.go:105:38 +./load.go:104:7: flow: filepath.elem ← &{storage for ... argument}: +./load.go:104:7: from ... argument (spill) at ./load.go:105:38 +./load.go:104:7: from filepath.elem := ... argument (assign-pair) at ./load.go:105:38 +./load.go:104:7: flow: {temp} ← filepath.elem: +./load.go:104:7: from filepath.join(filepath.elem) (call parameter) at ./load.go:105:38 +./load.go:104:7: flow: ~r0 ← *{temp}: +./load.go:104:7: from ~r0 = filepath.join(filepath.elem) (assign-pair) at ./load.go:105:38 +./load.go:104:7: flow: path ← ~r0: +./load.go:104:7: from path := ~r0 (assign-pair) at ./load.go:105:24 +./load.go:104:7: flow: {heap} ← path: +./load.go:104:7: from readConfigFile(path, int64(4096)) (call parameter) at ./load.go:105:24 +./load.go:109:36: string(data) escapes to heap in (*repo).branch: +./load.go:109:36: flow: strings.s ← &{storage for string(data)}: +./load.go:109:36: from string(data) (spill) at ./load.go:109:36 +./load.go:109:36: from strings.s, strings.prefix := string(data), "ref:" (assign-pair) at ./load.go:109:28 +./load.go:109:36: flow: stringslite.s ← strings.s: +./load.go:109:36: from stringslite.s, stringslite.prefix := strings.s, strings.prefix (assign-pair) at ./load.go:109:28 +./load.go:109:36: flow: stringslite.after ← stringslite.s: +./load.go:109:36: from stringslite.after, stringslite.found = stringslite.s, false (assign-pair) at ./load.go:109:28 +./load.go:109:36: flow: .autotmp_4 ← stringslite.after: +./load.go:109:36: flow: strings.after ← .autotmp_4: +./load.go:109:36: from strings.after, strings.found = string(.autotmp_4), .autotmp_5 (assign-pair) at ./load.go:109:28 +./load.go:109:36: flow: .autotmp_8 ← strings.after: +./load.go:109:36: flow: s ← .autotmp_8: +./load.go:109:36: from s, ok := string(.autotmp_8), .autotmp_9 (assign-pair) at ./load.go:109:8 +./load.go:109:36: flow: strings.s ← s: +./load.go:109:36: from strings.s, strings.prefix := s, "refs/heads/" (assign-pair) at ./load.go:114:31 +./load.go:109:36: flow: stringslite.s ← strings.s: +./load.go:109:36: from stringslite.s, stringslite.prefix := strings.s, strings.prefix (assign-pair) at ./load.go:114:31 +./load.go:109:36: flow: stringslite.after ← stringslite.s: +./load.go:109:36: from stringslite.after, stringslite.found = stringslite.s, false (assign-pair) at ./load.go:114:31 +./load.go:109:36: flow: .autotmp_4 ← stringslite.after: +./load.go:109:36: flow: strings.after ← .autotmp_4: +./load.go:109:36: from strings.after, strings.found = string(.autotmp_4), .autotmp_5 (assign-pair) at ./load.go:114:31 +./load.go:109:36: flow: .autotmp_11 ← strings.after: +./load.go:109:36: flow: name ← .autotmp_11: +./load.go:109:36: from name, ok := string(.autotmp_11), .autotmp_12 (assign-pair) at ./load.go:114:11 +./load.go:109:36: flow: ~r0 ← name: +./load.go:109:36: from return name (return) at ./load.go:118:2 +./load.go:104:7: leaking param content: r +./load.go:105:38: ... argument does not escape +./load.go:109:36: string(data) escapes to heap +./load.go:300:7: parameter l leaks to {heap} for (*loader).condition with derefs=2: +./load.go:300:7: flow: {heap} ← **l: +./load.go:300:7: from (*loader).gitdir(l, cond[7:], from, false) (call parameter) at ./load.go:303:18 +./load.go:300:28: parameter cond leaks to {heap} for (*loader).condition with derefs=0: +./load.go:300:28: flow: {heap} ← cond: +./load.go:300:28: from cond[7:] (slice) at ./load.go:303:23 +./load.go:300:28: from (*loader).gitdir(l, cond[7:], from, false) (call parameter) at ./load.go:303:18 +./load.go:300:7: leaking param content: l +./load.go:300:28: leaking param: cond +./load.go:300:34: from does not escape +./load.go:229:12: (*loader).load ignoring self-assignment in l.entries = l.entries[:start] +./load.go:231:21: append(l.entries, e) escapes to heap in (*loader).load: +./load.go:231:21: flow: {heap} ← &{storage for append(l.entries, e)}: +./load.go:231:21: from append(l.entries, e) (spill) at ./load.go:231:21 +./load.go:231:21: from l.entries = append(l.entries, e) (assign) at ./load.go:231:13 +./load.go:206:23: parameter path leaks to {heap} for (*loader).load with derefs=0: +./load.go:206:23: flow: {heap} ← path: +./load.go:206:23: from readConfigFile(path, int64(67108864) - l.bytes) (call parameter) at ./load.go:211:29 +./load.go:241:26: parameter e leaks to {heap} for (*loader).include with derefs=0: +./load.go:241:26: flow: {heap} ← e: +./load.go:241:26: from e.Key (dot) at ./load.go:248:27 +./load.go:241:26: from e.Key.Subsection (dot) at ./load.go:248:31 +./load.go:241:26: from (*loader).condition(l, e.Key.Subsection, from) (call parameter) at ./load.go:248:25 +./load.go:206:7: parameter l leaks to {heap} for (*loader).load with derefs=1: +./load.go:206:7: flow: {temp} ← *l: +./load.go:206:7: from l.entries (dot of pointer) at ./load.go:231:23 +./load.go:206:7: from append(l.entries, e) (call parameter) at ./load.go:231:21 +./load.go:206:7: flow: {temp} ← {temp}: +./load.go:206:7: flow: {heap} ← {temp}: +./load.go:206:7: from l.entries = append(l.entries, e) (assign) at ./load.go:231:13 +./load.go:241:7: parameter l leaks to {heap} for (*loader).include with derefs=1: +./load.go:241:7: flow: l ← l: +./load.go:241:7: from (*loader).load(l, path, scope, depth + 1) (call parameter) at ./load.go:275:15 +./load.go:241:7: flow: {temp} ← *l: +./load.go:241:7: from l.entries (dot of pointer) at ./load.go:231:23 +./load.go:241:7: from append(l.entries, e) (call parameter) at ./load.go:231:21 +./load.go:241:7: flow: {temp} ← {temp}: +./load.go:241:7: flow: {heap} ← {temp}: +./load.go:241:7: from l.entries = append(l.entries, e) (assign) at ./load.go:231:13 +./load.go:270:26: ~r0 + path escapes to heap in (*loader).include: +./load.go:270:26: flow: path ← &{storage for ~r0 + path}: +./load.go:270:26: from ~r0 + path (spill) at ./load.go:270:26 +./load.go:270:26: from path = ~r0 + path (assign) at ./load.go:270:8 +./load.go:270:26: flow: path ← path: +./load.go:270:26: from (*loader).load(l, path, scope, depth + 1) (call parameter) at ./load.go:275:15 +./load.go:270:26: flow: {heap} ← path: +./load.go:270:26: from readConfigFile(path, int64(67108864) - l.bytes) (call parameter) at ./load.go:211:29 +./load.go:225:24: append(out, Entry{...}) escapes to heap in (*loader).load: +./load.go:225:24: flow: out ← &{storage for append(out, Entry{...})}: +./load.go:225:24: from append(out, Entry{...}) (spill) at ./load.go:225:24 +./load.go:225:24: from out = append(out, Entry{...}) (assign) at ./load.go:225:24 +./load.go:225:24: flow: ~r0 ← out: +./load.go:225:24: from ~r0 = out (assign-pair) at ./load.go:225:24 +./load.go:225:24: flow: {heap} ← ~r0: +./load.go:225:24: from l.entries = ~r0 (assign) at ./load.go:225:12 +./load.go:273:139: path escapes to heap in (*loader).include: +./load.go:273:139: flow: {storage for ... argument} ← &{storage for path}: +./load.go:273:139: from path (spill) at ./load.go:273:139 +./load.go:273:139: from ... argument (slice-literal-element) at ./load.go:273:48 +./load.go:273:139: flow: fmt.a ← &{storage for ... argument}: +./load.go:273:139: from ... argument (spill) at ./load.go:273:48 +./load.go:273:139: from fmt.format, fmt.a := "%w while including %s from %s; this might be due to circular includes", ... argument (assign-pair) at ./load.go:273:48 +./load.go:273:139: flow: {heap} ← *fmt.a: +./load.go:273:139: from fmt.errorf(fmt.format, fmt.a...) (call parameter) at ./load.go:273:48 +./load.go:273:145: from escapes to heap in (*loader).include: +./load.go:273:145: flow: {storage for ... argument} ← &{storage for from}: +./load.go:273:145: from from (spill) at ./load.go:273:145 +./load.go:273:145: from ... argument (slice-literal-element) at ./load.go:273:48 +./load.go:273:145: flow: fmt.a ← &{storage for ... argument}: +./load.go:273:145: from ... argument (spill) at ./load.go:273:48 +./load.go:273:145: from fmt.format, fmt.a := "%w while including %s from %s; this might be due to circular includes", ... argument (assign-pair) at ./load.go:273:48 +./load.go:273:145: flow: {heap} ← *fmt.a: +./load.go:273:145: from fmt.errorf(fmt.format, fmt.a...) (call parameter) at ./load.go:273:48 +./load.go:241:35: parameter from leaks to {storage for from} for (*loader).include with derefs=0: +./load.go:241:35: flow: {storage for from} ← from: +./load.go:241:35: from from (interface-converted) at ./load.go:273:145 +./load.go:206:23: parameter path leaks to {storage for from} for (*loader).load with derefs=0: +./load.go:206:23: flow: from ← path: +./load.go:206:23: from (*loader).include(l, e, path, scope, depth) (call parameter) at ./load.go:232:22 +./load.go:206:23: flow: {storage for from} ← from: +./load.go:206:23: from from (interface-converted) at ./load.go:273:145 +./load.go:264:10: &FileError{...} escapes to heap in (*loader).include: +./load.go:264:10: flow: ~r0 ← &{storage for &FileError{...}}: +./load.go:264:10: from &FileError{...} (spill) at ./load.go:264:10 +./load.go:264:10: from &FileError{...} (interface-converted) at ./load.go:264:10 +./load.go:264:10: from return &FileError{...} (return) at ./load.go:264:3 +./load.go:268:11: &FileError{...} escapes to heap in (*loader).include: +./load.go:268:11: flow: ~r0 ← &{storage for &FileError{...}}: +./load.go:268:11: from &FileError{...} (spill) at ./load.go:268:11 +./load.go:268:11: from &FileError{...} (interface-converted) at ./load.go:268:11 +./load.go:268:11: from return &FileError{...} (return) at ./load.go:268:4 +./load.go:273:10: &FileError{...} escapes to heap in (*loader).include: +./load.go:273:10: flow: ~r0 ← &{storage for &FileError{...}}: +./load.go:273:10: from &FileError{...} (spill) at ./load.go:273:10 +./load.go:273:10: from &FileError{...} (interface-converted) at ./load.go:273:10 +./load.go:273:10: from return &FileError{...} (return) at ./load.go:273:3 +./load.go:257:16: &KeyError{...} escapes to heap in (*loader).include: +./load.go:257:16: flow: ~r0 ← &{storage for &KeyError{...}}: +./load.go:257:16: from &KeyError{...} (spill) at ./load.go:257:16 +./load.go:257:16: from &KeyError{...} (interface-converted) at ./load.go:257:16 +./load.go:257:16: from ~r0 = &KeyError{...} (assign-pair) at ./load.go:257:16 +./load.go:257:16: flow: ~r0 ← ~r0: +./load.go:257:16: from return ~r0 (return) at ./load.go:257:3 +./load.go:257:16: &FileError{...} escapes to heap in (*loader).include: +./load.go:257:16: flow: ~r0 ← &{storage for &FileError{...}}: +./load.go:257:16: from &FileError{...} (spill) at ./load.go:257:16 +./load.go:257:16: from &FileError{...} (interface-converted) at ./load.go:257:16 +./load.go:257:16: from ~r0 = &FileError{...} (assign-pair) at ./load.go:257:16 +./load.go:257:16: flow: ~r0 ← ~r0: +./load.go:257:16: from return ~r0 (return) at ./load.go:257:3 +./load.go:209:10: &FileError{...} escapes to heap in (*loader).load: +./load.go:209:10: flow: ~r0 ← &{storage for &FileError{...}}: +./load.go:209:10: from &FileError{...} (spill) at ./load.go:209:10 +./load.go:209:10: from &FileError{...} (interface-converted) at ./load.go:209:10 +./load.go:209:10: from return &FileError{...} (return) at ./load.go:209:3 +./load.go:209:10: flow: ~r0 ← ~r0: +./load.go:209:10: from return (*loader).load(l, path, scope, depth + 1) (return) at ./load.go:275:2 +./load.go:216:10: &FileError{...} escapes to heap in (*loader).load: +./load.go:216:10: flow: ~r0 ← &{storage for &FileError{...}}: +./load.go:216:10: from &FileError{...} (spill) at ./load.go:216:10 +./load.go:216:10: from &FileError{...} (interface-converted) at ./load.go:216:10 +./load.go:216:10: from return &FileError{...} (return) at ./load.go:216:3 +./load.go:216:10: flow: ~r0 ← ~r0: +./load.go:216:10: from return (*loader).load(l, path, scope, depth + 1) (return) at ./load.go:275:2 +./load.go:222:10: &FileError{...} escapes to heap in (*loader).load: +./load.go:222:10: flow: ~r0 ← &{storage for &FileError{...}}: +./load.go:222:10: from &FileError{...} (spill) at ./load.go:222:10 +./load.go:222:10: from &FileError{...} (interface-converted) at ./load.go:222:10 +./load.go:222:10: from return &FileError{...} (return) at ./load.go:222:3 +./load.go:222:10: flow: ~r0 ← ~r0: +./load.go:222:10: from return (*loader).load(l, path, scope, depth + 1) (return) at ./load.go:275:2 +./load.go:206:23: parameter path leaks to {storage for &FileError{...}} for (*loader).load with derefs=0: +./load.go:206:23: flow: {storage for &FileError{...}} ← path: +./load.go:206:23: from FileError{...} (struct literal element) at ./load.go:222:20 +./load.go:206:23: parameter path leaks to {storage for &FileError{...}} for (*loader).load with derefs=0: +./load.go:206:23: flow: {storage for &FileError{...}} ← path: +./load.go:206:23: from FileError{...} (struct literal element) at ./load.go:216:20 +./load.go:206:23: parameter path leaks to {storage for &FileError{...}} for (*loader).load with derefs=0: +./load.go:206:23: flow: {storage for &FileError{...}} ← path: +./load.go:206:23: from FileError{...} (struct literal element) at ./load.go:209:20 +./load.go:273:48: &errors.errorString{...} escapes to heap in (*loader).include: +./load.go:273:48: flow: ~r0 ← &{storage for &errors.errorString{...}}: +./load.go:273:48: from &errors.errorString{...} (spill) at ./load.go:273:48 +./load.go:273:48: from &errors.errorString{...} (interface-converted) at ./load.go:273:48 +./load.go:273:48: from ~r0 = &errors.errorString{...} (assign-pair) at ./load.go:273:48 +./load.go:273:48: flow: fmt.err ← ~r0: +./load.go:273:48: from fmt.err = ~r0 (assign-pair) at ./load.go:273:48 +./load.go:273:48: flow: {storage for &FileError{...}} ← fmt.err: +./load.go:273:48: from FileError{...} (struct literal element) at ./load.go:273:20 +./load.go:241:35: parameter from leaks to {storage for &FileError{...}} for (*loader).include with derefs=0: +./load.go:241:35: flow: {storage for &FileError{...}} ← from: +./load.go:241:35: from FileError{...} (struct literal element) at ./load.go:264:20 +./load.go:206:23: parameter path leaks to {storage for &FileError{...}} for (*loader).load with derefs=0: +./load.go:206:23: flow: from ← path: +./load.go:206:23: from (*loader).include(l, e, path, scope, depth) (call parameter) at ./load.go:232:22 +./load.go:206:23: flow: {storage for &FileError{...}} ← from: +./load.go:206:23: from FileError{...} (struct literal element) at ./load.go:264:20 +./load.go:257:16: k.Section + "." + k.Subsection + "." + k.Name escapes to heap in (*loader).include: +./load.go:257:16: flow: ~r0 ← &{storage for k.Section + "." + k.Subsection + "." + k.Name}: +./load.go:257:16: from k.Section + "." + k.Subsection + "." + k.Name (spill) at ./load.go:257:16 +./load.go:257:16: from ~r0 = k.Section + "." + k.Subsection + "." + k.Name (assign-pair) at ./load.go:257:16 +./load.go:257:16: flow: {storage for &KeyError{...}} ← ~r0: +./load.go:257:16: from KeyError{...} (struct literal element) at ./load.go:257:16 +./load.go:257:16: k.Section + "." + k.Name escapes to heap in (*loader).include: +./load.go:257:16: flow: ~r0 ← &{storage for k.Section + "." + k.Name}: +./load.go:257:16: from k.Section + "." + k.Name (spill) at ./load.go:257:16 +./load.go:257:16: from ~r0 = k.Section + "." + k.Name (assign-pair) at ./load.go:257:16 +./load.go:257:16: flow: {storage for &KeyError{...}} ← ~r0: +./load.go:257:16: from KeyError{...} (struct literal element) at ./load.go:257:16 +./load.go:257:16: &errors.errorString{...} escapes to heap in (*loader).include: +./load.go:257:16: flow: ~r0 ← &{storage for &errors.errorString{...}}: +./load.go:257:16: from &errors.errorString{...} (spill) at ./load.go:257:16 +./load.go:257:16: from &errors.errorString{...} (interface-converted) at ./load.go:257:16 +./load.go:257:16: from ~r0 = &errors.errorString{...} (assign-pair) at ./load.go:257:16 +./load.go:257:16: flow: {storage for &KeyError{...}} ← ~r0: +./load.go:257:16: from KeyError{...} (struct literal element) at ./load.go:257:16 +./load.go:257:16: "gitconfig: " + msg escapes to heap in (*loader).include: +./load.go:257:16: flow: errors.text ← &{storage for "gitconfig: " + msg}: +./load.go:257:16: from "gitconfig: " + msg (spill) at ./load.go:257:16 +./load.go:257:16: from errors.text := "gitconfig: " + msg (assign-pair) at ./load.go:257:16 +./load.go:257:16: flow: {storage for &errors.errorString{...}} ← errors.text: +./load.go:257:16: from errors.errorString{...} (struct literal element) at ./load.go:257:16 +./load.go:257:16: &SyntaxError{...} escapes to heap in (*loader).include: +./load.go:257:16: flow: {storage for &FileError{...}} ← &{storage for &SyntaxError{...}}: +./load.go:257:16: from &SyntaxError{...} (spill) at ./load.go:257:16 +./load.go:257:16: from &SyntaxError{...} (interface-converted) at ./load.go:257:16 +./load.go:257:16: from FileError{...} (struct literal element) at ./load.go:257:16 +./load.go:241:35: parameter from leaks to {storage for &FileError{...}} for (*loader).include with derefs=0: +./load.go:241:35: flow: from ← from: +./load.go:241:35: from _, from, e, msg := 0, from, e, "missing value for include.path" (assign-pair) at ./load.go:257:16 +./load.go:241:35: flow: {storage for &FileError{...}} ← from: +./load.go:241:35: from FileError{...} (struct literal element) at ./load.go:257:16 +./load.go:206:23: parameter path leaks to {storage for &FileError{...}} for (*loader).load with derefs=0: +./load.go:206:23: flow: from ← path: +./load.go:206:23: from (*loader).include(l, e, path, scope, depth) (call parameter) at ./load.go:232:22 +./load.go:206:23: flow: from ← from: +./load.go:206:23: from _, from, e, msg := 0, from, e, "missing value for include.path" (assign-pair) at ./load.go:257:16 +./load.go:206:23: flow: {storage for &FileError{...}} ← from: +./load.go:206:23: from FileError{...} (struct literal element) at ./load.go:257:16 +./load.go:241:35: parameter from leaks to {storage for &SyntaxError{...}} for (*loader).include with derefs=0: +./load.go:241:35: flow: from ← from: +./load.go:241:35: from _, from, e, msg := 0, from, e, "missing value for include.path" (assign-pair) at ./load.go:257:16 +./load.go:241:35: flow: {storage for &SyntaxError{...}} ← from: +./load.go:241:35: from SyntaxError{...} (struct literal element) at ./load.go:257:16 +./load.go:206:23: parameter path leaks to {storage for &SyntaxError{...}} for (*loader).load with derefs=0: +./load.go:206:23: flow: from ← path: +./load.go:206:23: from (*loader).include(l, e, path, scope, depth) (call parameter) at ./load.go:232:22 +./load.go:206:23: flow: from ← from: +./load.go:206:23: from _, from, e, msg := 0, from, e, "missing value for include.path" (assign-pair) at ./load.go:257:16 +./load.go:206:23: flow: {storage for &SyntaxError{...}} ← from: +./load.go:206:23: from SyntaxError{...} (struct literal element) at ./load.go:257:16 +./load.go:206:7: leaking param content: l +./load.go:206:23: leaking param: path +./load.go:241:7: leaking param content: l +./load.go:241:26: leaking param: e +./load.go:241:35: leaking param: from +./load.go:209:10: &FileError{...} escapes to heap +./load.go:216:10: &FileError{...} escapes to heap +./load.go:222:10: &FileError{...} escapes to heap +./load.go:225:24: append escapes to heap +./load.go:228:21: go.shape.[]github.com/git-bug/gitconfig.Entry{} does not escape +./load.go:228:21: append does not escape +./load.go:231:21: append escapes to heap +./load.go:257:16: &KeyError{...} escapes to heap +./load.go:257:16: k.Section + "." + k.Subsection + "." + k.Name escapes to heap +./load.go:257:16: k.Section + "." + k.Name escapes to heap +./load.go:257:16: "gitconfig: " + msg escapes to heap +./load.go:257:16: &errors.errorString{...} escapes to heap +./load.go:257:16: &FileError{...} escapes to heap +./load.go:257:16: &SyntaxError{...} escapes to heap +./load.go:264:10: &FileError{...} escapes to heap +./load.go:268:11: &FileError{...} escapes to heap +./load.go:270:26: ~r0 + path escapes to heap +./load.go:273:10: &FileError{...} escapes to heap +./load.go:273:48: ... argument does not escape +./load.go:273:139: path escapes to heap +./load.go:273:145: from escapes to heap +./load.go:273:48: &errors.errorString{...} escapes to heap +./load.go:198:7: fe escapes to heap in (*loader).loadFile: +./load.go:198:7: flow: {heap} ← &fe: +./load.go:198:7: from &fe (address-of) at ./load.go:199:21 +./load.go:198:7: from &fe (interface-converted) at ./load.go:199:21 +./load.go:198:7: from errors.As(err, &fe) (call parameter) at ./load.go:199:15 +./load.go:195:27: parameter path leaks to {heap} for (*loader).loadFile with derefs=0: +./load.go:195:27: flow: {heap} ← path: +./load.go:195:27: from (*loader).load(l, path, scope, 0) (call parameter) at ./load.go:196:15 +./load.go:195:7: parameter l leaks to {heap} for (*loader).loadFile with derefs=1: +./load.go:195:7: flow: {temp} ← l: +./load.go:195:7: from (*loader).load(l, path, scope, 0) (call parameter) at ./load.go:196:15 +./load.go:195:7: flow: {heap} ← *{temp}: +./load.go:195:7: leaking param content: l +./load.go:195:27: leaking param: path +./load.go:198:7: moved to heap: fe +./load.go:80:23: parameter entries leaks to {heap} for worktreeConfigIn with derefs=1: +./load.go:80:23: flow: {temp} ← entries: +./load.go:80:23: flow: e ← *{temp}: +./load.go:80:23: from for loop (range-deref) at ./load.go:83:14 +./load.go:80:23: flow: {heap} ← e: +./load.go:80:23: from Entry.Bool(e) (call parameter) at ./load.go:87:19 +./load.go:89:18: &FileError{...} escapes to heap in worktreeConfigIn: +./load.go:89:18: flow: ~r1 ← &{storage for &FileError{...}}: +./load.go:89:18: from &FileError{...} (spill) at ./load.go:89:18 +./load.go:89:18: from &FileError{...} (interface-converted) at ./load.go:89:18 +./load.go:89:18: from return false, &FileError{...} (return) at ./load.go:89:4 +./load.go:80:40: parameter path leaks to {storage for &FileError{...}} for worktreeConfigIn with derefs=0: +./load.go:80:40: flow: {storage for &FileError{...}} ← path: +./load.go:80:40: from FileError{...} (struct literal element) at ./load.go:89:28 +./load.go:80:23: leaking param content: entries +./load.go:80:40: leaking param: path +./load.go:89:18: &FileError{...} escapes to heap +./key.go:15:17: &KeyError{...} escapes to heap in ParseKey: +./key.go:15:17: flow: ~r1 ← &{storage for &KeyError{...}}: +./key.go:15:17: from &KeyError{...} (spill) at ./key.go:15:17 +./key.go:15:17: from &KeyError{...} (interface-converted) at ./key.go:15:17 +./key.go:15:17: from return Key{}, &KeyError{...} (return) at ./key.go:15:3 +./key.go:12:15: parameter s leaks to {storage for &KeyError{...}} for ParseKey with derefs=0: +./key.go:12:15: flow: {storage for &KeyError{...}} ← s: +./key.go:12:15: from KeyError{...} (struct literal element) at ./key.go:15:26 +./key.go:12:15: parameter s leaks to ~r0 for ParseKey with derefs=0: +./key.go:12:15: flow: {temp} ← s: +./key.go:12:15: from parseKey(s) (call parameter) at ./key.go:13:19 +./key.go:12:15: flow: .autotmp_5 ← {temp}: +./key.go:12:15: flow: k ← .autotmp_5: +./key.go:12:15: from k, ok := Key(.autotmp_5), .autotmp_6 (assign-pair) at ./key.go:13:8 +./key.go:12:15: flow: ~r0 ← k: +./key.go:12:15: from return k, nil (return) at ./key.go:17:2 +./key.go:12:15: leaking param: s +./key.go:15:17: &KeyError{...} escapes to heap +./load.go:384:21: append(l.entries, e) escapes to heap in (*loader).command: +./load.go:384:21: flow: {heap} ← &{storage for append(l.entries, e)}: +./load.go:384:21: from append(l.entries, e) (spill) at ./load.go:384:21 +./load.go:384:21: from l.entries = append(l.entries, e) (assign) at ./load.go:384:13 +./load.go:374:7: parameter l leaks to {heap} for (*loader).command with derefs=1: +./load.go:374:7: flow: {temp} ← *l: +./load.go:374:7: from l.entries (dot of pointer) at ./load.go:384:23 +./load.go:374:7: from append(l.entries, e) (call parameter) at ./load.go:384:21 +./load.go:374:7: flow: {temp} ← {temp}: +./load.go:374:7: flow: {heap} ← {temp}: +./load.go:374:7: from l.entries = append(l.entries, e) (assign) at ./load.go:384:13 +./load.go:374:7: leaking param content: l +./load.go:384:21: append escapes to heap +./env.go:137:7: parameter e leaks to {heap} for Env.Load with derefs=0: +./env.go:137:7: flow: {heap} ← e: +./env.go:137:7: from Env.newLoader(e) (call parameter) at ./env.go:138:23 +./env.go:137:7: leaking param: e +./env.go:154:42: ... argument does not escape +./env.go:157:68: ... argument does not escape +./env.go:162:46: ... argument does not escape +./env.go:178:7: parameter e leaks to {heap} for Env.LoadProtected with derefs=0: +./env.go:178:7: flow: {heap} ← e: +./env.go:178:7: from Env.newLoader(e) (call parameter) at ./env.go:179:23 +./env.go:178:7: leaking param: e +./env.go:247:15: parameter path leaks to {heap} for realPath with derefs=0: +./env.go:247:15: flow: {heap} ← path: +./env.go:247:15: from filepath.EvalSymlinks(path) (call parameter) at ./env.go:248:36 +./env.go:247:15: parameter path leaks to ~r0 for realPath with derefs=0: +./env.go:247:15: flow: filepath.path ← path: +./env.go:247:15: from filepath.path := path (assign-pair) at ./env.go:251:23 +./env.go:247:15: flow: {temp} ← filepath.path: +./env.go:247:15: from filepathlite.Clean(filepath.path) (call parameter) at ./env.go:251:23 +./env.go:247:15: flow: ~r0 ← {temp}: +./env.go:247:15: from ~r0 = filepathlite.Clean(filepath.path) (assign-pair) at ./env.go:251:23 +./env.go:247:15: flow: ~r0 ← ~r0: +./env.go:247:15: from return ~r0 (return) at ./env.go:251:2 +./env.go:247:15: leaking param: path +./env.go:208:7: parameter e leaks to {heap} for Env.SafeDirectory with derefs=0: +./env.go:208:7: flow: {heap} ← e: +./env.go:208:7: from Env.LoadProtected(e) (call parameter) at ./env.go:209:27 +./env.go:208:28: parameter dir leaks to {heap} for Env.SafeDirectory with derefs=0: +./env.go:208:28: flow: {heap} ← dir: +./env.go:208:28: from realPath(dir) (call parameter) at ./env.go:213:16 +./env.go:208:7: leaking param: e +./env.go:208:28: leaking param: dir +./env.go:227:80: ~r0 + "/" does not escape +./load.go:63:7: parameter r leaks to {heap} for (*repo).worktreeConfigEnabled with derefs=1: +./load.go:63:7: flow: r ← r: +./load.go:63:7: from r := r (assign-pair) at ./load.go:64:43 +./load.go:63:7: flow: {storage for ... argument} ← *r: +./load.go:63:7: from r.commonDir (dot of pointer) at ./load.go:64:43 +./load.go:63:7: from ... argument (slice-literal-element) at ./load.go:64:43 +./load.go:63:7: flow: filepath.elem ← &{storage for ... argument}: +./load.go:63:7: from ... argument (spill) at ./load.go:64:43 +./load.go:63:7: from filepath.elem := ... argument (assign-pair) at ./load.go:64:43 +./load.go:63:7: flow: {temp} ← filepath.elem: +./load.go:63:7: from filepath.join(filepath.elem) (call parameter) at ./load.go:64:43 +./load.go:63:7: flow: ~r0 ← *{temp}: +./load.go:63:7: from ~r0 = filepath.join(filepath.elem) (assign-pair) at ./load.go:64:43 +./load.go:63:7: flow: ~r0 ← ~r0: +./load.go:63:7: from ~r0 = ~r0 (assign-pair) at ./load.go:64:43 +./load.go:63:7: flow: {heap} ← ~r0: +./load.go:63:7: from readConfigFile(~r0, int64(67108864)) (call parameter) at ./load.go:64:29 +./load.go:69:17: &FileError{...} escapes to heap in (*repo).worktreeConfigEnabled: +./load.go:69:17: flow: ~r1 ← &{storage for &FileError{...}}: +./load.go:69:17: from &FileError{...} (spill) at ./load.go:69:17 +./load.go:69:17: from &FileError{...} (interface-converted) at ./load.go:69:17 +./load.go:69:17: from return false, &FileError{...} (return) at ./load.go:69:3 +./load.go:73:17: &FileError{...} escapes to heap in (*repo).worktreeConfigEnabled: +./load.go:73:17: flow: ~r1 ← &{storage for &FileError{...}}: +./load.go:73:17: from &FileError{...} (spill) at ./load.go:73:17 +./load.go:73:17: from &FileError{...} (interface-converted) at ./load.go:73:17 +./load.go:73:17: from return false, &FileError{...} (return) at ./load.go:73:3 +./load.go:63:7: parameter r leaks to {storage for &FileError{...}} for (*repo).worktreeConfigEnabled with derefs=1: +./load.go:63:7: flow: r ← r: +./load.go:63:7: from r := r (assign-pair) at ./load.go:73:47 +./load.go:63:7: flow: {storage for ... argument} ← *r: +./load.go:63:7: from r.commonDir (dot of pointer) at ./load.go:73:47 +./load.go:63:7: from ... argument (slice-literal-element) at ./load.go:73:47 +./load.go:63:7: flow: filepath.elem ← &{storage for ... argument}: +./load.go:63:7: from ... argument (spill) at ./load.go:73:47 +./load.go:63:7: from filepath.elem := ... argument (assign-pair) at ./load.go:73:47 +./load.go:63:7: flow: {temp} ← filepath.elem: +./load.go:63:7: from filepath.join(filepath.elem) (call parameter) at ./load.go:73:47 +./load.go:63:7: flow: ~r0 ← *{temp}: +./load.go:63:7: from ~r0 = filepath.join(filepath.elem) (assign-pair) at ./load.go:73:47 +./load.go:63:7: flow: ~r0 ← ~r0: +./load.go:63:7: from ~r0 = ~r0 (assign-pair) at ./load.go:73:47 +./load.go:63:7: flow: {storage for &FileError{...}} ← ~r0: +./load.go:63:7: from FileError{...} (struct literal element) at ./load.go:73:27 +./load.go:63:7: parameter r leaks to {storage for &FileError{...}} for (*repo).worktreeConfigEnabled with derefs=1: +./load.go:63:7: flow: r ← r: +./load.go:63:7: from r := r (assign-pair) at ./load.go:69:47 +./load.go:63:7: flow: {storage for ... argument} ← *r: +./load.go:63:7: from r.commonDir (dot of pointer) at ./load.go:69:47 +./load.go:63:7: from ... argument (slice-literal-element) at ./load.go:69:47 +./load.go:63:7: flow: filepath.elem ← &{storage for ... argument}: +./load.go:63:7: from ... argument (spill) at ./load.go:69:47 +./load.go:63:7: from filepath.elem := ... argument (assign-pair) at ./load.go:69:47 +./load.go:63:7: flow: {temp} ← filepath.elem: +./load.go:63:7: from filepath.join(filepath.elem) (call parameter) at ./load.go:69:47 +./load.go:63:7: flow: ~r0 ← *{temp}: +./load.go:63:7: from ~r0 = filepath.join(filepath.elem) (assign-pair) at ./load.go:69:47 +./load.go:63:7: flow: ~r0 ← ~r0: +./load.go:63:7: from ~r0 = ~r0 (assign-pair) at ./load.go:69:47 +./load.go:63:7: flow: {storage for &FileError{...}} ← ~r0: +./load.go:63:7: from FileError{...} (struct literal element) at ./load.go:69:27 +./load.go:63:7: leaking param content: r +./load.go:64:43: ... argument does not escape +./load.go:69:17: &FileError{...} escapes to heap +./load.go:69:47: ... argument does not escape +./load.go:71:31: ... argument does not escape +./load.go:73:17: &FileError{...} escapes to heap +./load.go:73:47: ... argument does not escape +./load.go:75:61: ... argument does not escape +./load.go:75:35: append does not escape +./load.go:75:84: ... argument does not escape +./load.go:97:7: parameter r leaks to {heap} for (*repo).severalWorktrees with derefs=1: +./load.go:97:7: flow: {storage for ... argument} ← *r: +./load.go:97:7: from r.commonDir (dot of pointer) at ./load.go:98:44 +./load.go:97:7: from ... argument (slice-literal-element) at ./load.go:98:42 +./load.go:97:7: flow: filepath.elem ← &{storage for ... argument}: +./load.go:97:7: from ... argument (spill) at ./load.go:98:42 +./load.go:97:7: from filepath.elem := ... argument (assign-pair) at ./load.go:98:42 +./load.go:97:7: flow: {temp} ← filepath.elem: +./load.go:97:7: from filepath.join(filepath.elem) (call parameter) at ./load.go:98:42 +./load.go:97:7: flow: ~r0 ← *{temp}: +./load.go:97:7: from ~r0 = filepath.join(filepath.elem) (assign-pair) at ./load.go:98:42 +./load.go:97:7: flow: {heap} ← ~r0: +./load.go:97:7: from os.ReadDir(~r0) (call parameter) at ./load.go:98:28 +./load.go:97:7: leaking param content: r +./load.go:98:42: ... argument does not escape +./env.go:353:7: parameter e leaks to {heap} for Env.scopeFile with derefs=0: +./env.go:353:7: flow: {heap} ← e: +./env.go:353:7: from Env.repo(e) (call parameter) at ./env.go:354:18 +./env.go:353:7: leaking param: e +./env.go:362:23: ... argument does not escape +./env.go:369:26: ... argument does not escape +./env.go:373:22: ... argument does not escape +./env.go:269:7: parameter e leaks to {heap} for Env.LoadScope with derefs=0: +./env.go:269:7: flow: {heap} ← e: +./env.go:269:7: from Env.newLoader(e) (call parameter) at ./env.go:270:23 +./env.go:269:7: leaking param: e +./env.go:307:7: parameter e leaks to {heap} for Env.LoadFile with derefs=0: +./env.go:307:7: flow: {heap} ← e: +./env.go:307:7: from Env.newLoader(e) (call parameter) at ./env.go:308:23 +./env.go:307:23: parameter path leaks to {heap} for Env.LoadFile with derefs=0: +./env.go:307:23: flow: {heap} ← path: +./env.go:307:23: from (*loader).loadFile(l, path, Scope(0), false) (call parameter) at ./env.go:312:22 +./env.go:307:7: leaking param: e +./env.go:307:23: leaking param: path +./env.go:326:7: parameter e leaks to {heap} for Env.WritePath with derefs=0: +./env.go:326:7: flow: {heap} ← e: +./env.go:326:7: from Env.scopeFile(e, s) (call parameter) at ./env.go:344:30 +./env.go:326:7: parameter e leaks to ~r0 for Env.WritePath with derefs=0: +./env.go:326:7: flow: ~r0 ← e: +./env.go:326:7: from e.SystemConfig (dot) at ./env.go:332:11 +./env.go:326:7: from return e.SystemConfig, nil (return) at ./env.go:332:3 +./env.go:326:7: leaking param: e +./update.go:96:18: parameter path leaks to {heap} for followLinks with derefs=0: +./update.go:96:18: flow: p ← path: +./update.go:96:18: from p := path (assign) at ./update.go:97:4 +./update.go:96:18: flow: {heap} ← p: +./update.go:96:18: from os.Lstat(p) (call parameter) at ./update.go:99:22 +./update.go:104:15: &FileError{...} escapes to heap in followLinks: +./update.go:104:15: flow: ~r1 ← &{storage for &FileError{...}}: +./update.go:104:15: from &FileError{...} (spill) at ./update.go:104:15 +./update.go:104:15: from &FileError{...} (interface-converted) at ./update.go:104:15 +./update.go:104:15: from return "", &FileError{...} (return) at ./update.go:104:4 +./update.go:110:15: &FileError{...} escapes to heap in followLinks: +./update.go:110:15: flow: ~r1 ← &{storage for &FileError{...}}: +./update.go:110:15: from &FileError{...} (spill) at ./update.go:110:15 +./update.go:110:15: from &FileError{...} (interface-converted) at ./update.go:110:15 +./update.go:110:15: from return "", &FileError{...} (return) at ./update.go:110:4 +./update.go:112:15: &FileError{...} escapes to heap in followLinks: +./update.go:112:15: flow: ~r1 ← &{storage for &FileError{...}}: +./update.go:112:15: from &FileError{...} (spill) at ./update.go:112:15 +./update.go:112:15: from &FileError{...} (interface-converted) at ./update.go:112:15 +./update.go:112:15: from return "", &FileError{...} (return) at ./update.go:112:4 +./update.go:116:15: &FileError{...} escapes to heap in followLinks: +./update.go:116:15: flow: ~r1 ← &{storage for &FileError{...}}: +./update.go:116:15: from &FileError{...} (spill) at ./update.go:116:15 +./update.go:116:15: from &FileError{...} (interface-converted) at ./update.go:116:15 +./update.go:116:15: from return "", &FileError{...} (return) at ./update.go:116:4 +./update.go:96:18: parameter path leaks to {storage for &FileError{...}} for followLinks with derefs=0: +./update.go:96:18: flow: p ← path: +./update.go:96:18: from p := path (assign) at ./update.go:97:4 +./update.go:96:18: flow: {storage for &FileError{...}} ← p: +./update.go:96:18: from FileError{...} (struct literal element) at ./update.go:116:25 +./update.go:96:18: parameter path leaks to {storage for &FileError{...}} for followLinks with derefs=0: +./update.go:96:18: flow: {storage for &FileError{...}} ← path: +./update.go:96:18: from FileError{...} (struct literal element) at ./update.go:112:25 +./update.go:96:18: parameter path leaks to {storage for &FileError{...}} for followLinks with derefs=0: +./update.go:96:18: flow: p ← path: +./update.go:96:18: from p := path (assign) at ./update.go:97:4 +./update.go:96:18: flow: {storage for &FileError{...}} ← p: +./update.go:96:18: from FileError{...} (struct literal element) at ./update.go:110:25 +./update.go:96:18: parameter path leaks to {storage for &FileError{...}} for followLinks with derefs=0: +./update.go:96:18: flow: p ← path: +./update.go:96:18: from p := path (assign) at ./update.go:97:4 +./update.go:96:18: flow: {storage for &FileError{...}} ← p: +./update.go:96:18: from FileError{...} (struct literal element) at ./update.go:104:25 +./update.go:96:18: parameter path leaks to ~r0 for followLinks with derefs=0: +./update.go:96:18: flow: p ← path: +./update.go:96:18: from p := path (assign) at ./update.go:97:4 +./update.go:96:18: flow: ~r0 ← p: +./update.go:96:18: from return p, nil (return) at ./update.go:101:4 +./update.go:96:18: leaking param: path +./update.go:104:15: &FileError{...} escapes to heap +./update.go:110:15: &FileError{...} escapes to heap +./update.go:112:15: &FileError{...} escapes to heap +./update.go:116:15: &FileError{...} escapes to heap +./update.go:119:24: ... argument does not escape +./update.go:87:18: callClosing capturing by value: f (addr=false assign=false width=8) +./update.go:87:18: parameter f leaks to {heap} for callClosing with derefs=0: +./update.go:87:18: flow: {heap} ← f: +./update.go:87:18: from fn(f) (call parameter) at ./update.go:89:11 +./update.go:87:18: leaking param: f +./update.go:87:27: fn does not escape +./update.go:88:8: func literal does not escape +./update.go:33:2: updateFile capturing by ref: committed (addr=false assign=true width=1) +./update.go:26:2: updateFile capturing by value: lock (addr=false assign=false width=8) +./update.go:25:2: updateFile capturing by value: lockPath (addr=false assign=false width=16) +./update.go:25:2: updateFile capturing by value: lockPath (addr=false assign=false width=16) +./update.go:20:2: updateFile capturing by value: target (addr=false assign=false width=16) +./update.go:19:17: parameter path leaks to {heap} for updateFile with derefs=0: +./update.go:19:17: flow: {heap} ← path: +./update.go:19:17: from followLinks(path) (call parameter) at ./update.go:20:28 +./update.go:25:21: target + ".lock" escapes to heap in updateFile: +./update.go:25:21: flow: lockPath ← &{storage for target + ".lock"}: +./update.go:25:21: from target + ".lock" (spill) at ./update.go:25:21 +./update.go:25:21: from lockPath := target + ".lock" (assign) at ./update.go:25:11 +./update.go:25:21: flow: {heap} ← lockPath: +./update.go:25:21: from os.OpenFile(lockPath, 193, fs.FileMode(438)) (call parameter) at ./update.go:26:26 +./update.go:29:11: &FileError{...} escapes to heap in updateFile: +./update.go:29:11: flow: err ← &{storage for &FileError{...}}: +./update.go:29:11: from &FileError{...} (spill) at ./update.go:29:11 +./update.go:29:11: from &FileError{...} (interface-converted) at ./update.go:29:11 +./update.go:29:11: from return &FileError{...} (return) at ./update.go:29:4 +./update.go:29:11: flow: {heap} ← err: +./update.go:29:11: from errors.Is(err, fs.ErrExist) (call parameter) at ./update.go:28:15 +./update.go:31:10: &FileError{...} escapes to heap in updateFile: +./update.go:31:10: flow: err ← &{storage for &FileError{...}}: +./update.go:31:10: from &FileError{...} (spill) at ./update.go:31:10 +./update.go:31:10: from &FileError{...} (interface-converted) at ./update.go:31:10 +./update.go:31:10: from return &FileError{...} (return) at ./update.go:31:3 +./update.go:31:10: flow: {heap} ← err: +./update.go:31:10: from errors.Is(err, fs.ErrExist) (call parameter) at ./update.go:28:15 +./update.go:48:10: &FileError{...} escapes to heap in updateFile: +./update.go:48:10: flow: err ← &{storage for &FileError{...}}: +./update.go:48:10: from &FileError{...} (spill) at ./update.go:48:10 +./update.go:48:10: from &FileError{...} (interface-converted) at ./update.go:48:10 +./update.go:48:10: from return &FileError{...} (return) at ./update.go:48:3 +./update.go:48:10: flow: {heap} ← err: +./update.go:48:10: from errors.Is(err, fs.ErrExist) (call parameter) at ./update.go:28:15 +./update.go:52:10: &FileError{...} escapes to heap in updateFile: +./update.go:52:10: flow: err ← &{storage for &FileError{...}}: +./update.go:52:10: from &FileError{...} (spill) at ./update.go:52:10 +./update.go:52:10: from &FileError{...} (interface-converted) at ./update.go:52:10 +./update.go:52:10: from return &FileError{...} (return) at ./update.go:52:3 +./update.go:52:10: flow: {heap} ← err: +./update.go:52:10: from errors.Is(err, fs.ErrExist) (call parameter) at ./update.go:28:15 +./update.go:64:10: &FileError{...} escapes to heap in updateFile: +./update.go:64:10: flow: err ← &{storage for &FileError{...}}: +./update.go:64:10: from &FileError{...} (spill) at ./update.go:64:10 +./update.go:64:10: from &FileError{...} (interface-converted) at ./update.go:64:10 +./update.go:64:10: from return &FileError{...} (return) at ./update.go:64:3 +./update.go:64:10: flow: {heap} ← err: +./update.go:64:10: from errors.Is(err, fs.ErrExist) (call parameter) at ./update.go:28:15 +./update.go:69:11: &FileError{...} escapes to heap in updateFile: +./update.go:69:11: flow: err ← &{storage for &FileError{...}}: +./update.go:69:11: from &FileError{...} (spill) at ./update.go:69:11 +./update.go:69:11: from &FileError{...} (interface-converted) at ./update.go:69:11 +./update.go:69:11: from return &FileError{...} (return) at ./update.go:69:4 +./update.go:69:11: flow: {heap} ← err: +./update.go:69:11: from errors.Is(err, fs.ErrExist) (call parameter) at ./update.go:28:15 +./update.go:73:11: &FileError{...} escapes to heap in updateFile: +./update.go:73:11: flow: err ← &{storage for &FileError{...}}: +./update.go:73:11: from &FileError{...} (spill) at ./update.go:73:11 +./update.go:73:11: from &FileError{...} (interface-converted) at ./update.go:73:11 +./update.go:73:11: from return &FileError{...} (return) at ./update.go:73:4 +./update.go:73:11: flow: {heap} ← err: +./update.go:73:11: from errors.Is(err, fs.ErrExist) (call parameter) at ./update.go:28:15 +./update.go:77:10: &FileError{...} escapes to heap in updateFile: +./update.go:77:10: flow: err ← &{storage for &FileError{...}}: +./update.go:77:10: from &FileError{...} (spill) at ./update.go:77:10 +./update.go:77:10: from &FileError{...} (interface-converted) at ./update.go:77:10 +./update.go:77:10: from return &FileError{...} (return) at ./update.go:77:3 +./update.go:77:10: flow: {heap} ← err: +./update.go:77:10: from errors.Is(err, fs.ErrExist) (call parameter) at ./update.go:28:15 +./update.go:80:10: &FileError{...} escapes to heap in updateFile: +./update.go:80:10: flow: err ← &{storage for &FileError{...}}: +./update.go:80:10: from &FileError{...} (spill) at ./update.go:80:10 +./update.go:80:10: from &FileError{...} (interface-converted) at ./update.go:80:10 +./update.go:80:10: from return &FileError{...} (return) at ./update.go:80:3 +./update.go:80:10: flow: {heap} ← err: +./update.go:80:10: from errors.Is(err, fs.ErrExist) (call parameter) at ./update.go:28:15 +./update.go:54:7: &File{...} escapes to heap in updateFile: +./update.go:54:7: flow: f ← &{storage for &File{...}}: +./update.go:54:7: from &File{...} (spill) at ./update.go:54:7 +./update.go:54:7: from f := &File{...} (assign) at ./update.go:54:4 +./update.go:54:7: flow: {heap} ← f: +./update.go:54:7: from callClosing(f, fn) (call parameter) at ./update.go:56:23 +./update.go:19:17: parameter path leaks to {storage for &File{...}} for updateFile with derefs=0: +./update.go:19:17: flow: {storage for &File{...}} ← path: +./update.go:19:17: from File{...} (struct literal element) at ./update.go:54:12 +./update.go:19:17: parameter path leaks to {storage for &FileError{...}} for updateFile with derefs=0: +./update.go:19:17: flow: {storage for &FileError{...}} ← path: +./update.go:19:17: from FileError{...} (struct literal element) at ./update.go:52:20 +./update.go:19:17: parameter path leaks to {storage for &FileError{...}} for updateFile with derefs=0: +./update.go:19:17: flow: {storage for &FileError{...}} ← path: +./update.go:19:17: from FileError{...} (struct literal element) at ./update.go:48:20 +./update.go:19:17: leaking param: path +./update.go:19:43: fn does not escape +./update.go:25:21: target + ".lock" escapes to heap +./update.go:29:11: &FileError{...} escapes to heap +./update.go:31:10: &FileError{...} escapes to heap +./update.go:34:8: func literal does not escape +./update.go:48:10: &FileError{...} escapes to heap +./update.go:52:10: &FileError{...} escapes to heap +./update.go:54:7: &File{...} escapes to heap +./update.go:59:16: string(bytes.a) does not escape +./update.go:59:16: string(bytes.b) does not escape +./update.go:64:10: &FileError{...} escapes to heap +./update.go:69:11: &FileError{...} escapes to heap +./update.go:73:11: &FileError{...} escapes to heap +./update.go:77:10: &FileError{...} escapes to heap +./update.go:79:27: func literal does not escape +./update.go:80:10: &FileError{...} escapes to heap +./env.go:379:7: parameter e leaks to {heap} for Env.UpdateScope with derefs=0: +./env.go:379:7: flow: {heap} ← e: +./env.go:379:7: from Env.scopeFile(e, s) (call parameter) at ./env.go:385:33 +./env.go:379:7: leaking param: e +./env.go:379:35: fn does not escape +./env.go:424:25: parameter path leaks to {heap} for Env.UpdateFile with derefs=0: +./env.go:424:25: flow: {heap} ← path: +./env.go:424:25: from updateFile(path, Scope(0), fn) (call parameter) at ./env.go:425:19 +./env.go:424:7: e does not escape +./env.go:424:25: leaking param: path +./env.go:424:38: fn does not escape +./errors.go:74:7: parameter e leaks to {heap} for (*KeyError).Error with derefs=1: +./errors.go:74:7: flow: {storage for ... argument} ← *e: +./errors.go:74:7: from e.Err (dot of pointer) at ./errors.go:75:32 +./errors.go:74:7: from e.Err (interface-converted) at ./errors.go:75:32 +./errors.go:74:7: from ... argument (slice-literal-element) at ./errors.go:75:20 +./errors.go:74:7: flow: {heap} ← {storage for ... argument}: +./errors.go:74:7: from ... argument (spill) at ./errors.go:75:20 +./errors.go:74:7: from fmt.Sprintf("%v: %q", ... argument...) (call parameter) at ./errors.go:75:20 +./errors.go:75:39: e.Key escapes to heap in (*KeyError).Error: +./errors.go:75:39: flow: {storage for ... argument} ← &{storage for e.Key}: +./errors.go:75:39: from e.Key (spill) at ./errors.go:75:39 +./errors.go:75:39: from ... argument (slice-literal-element) at ./errors.go:75:20 +./errors.go:75:39: flow: {heap} ← {storage for ... argument}: +./errors.go:75:39: from ... argument (spill) at ./errors.go:75:20 +./errors.go:75:39: from fmt.Sprintf("%v: %q", ... argument...) (call parameter) at ./errors.go:75:20 +./errors.go:74:7: parameter e leaks to {storage for e.Key} for (*KeyError).Error with derefs=1: +./errors.go:74:7: flow: {storage for e.Key} ← *e: +./errors.go:74:7: from e.Key (dot of pointer) at ./errors.go:75:39 +./errors.go:74:7: from e.Key (interface-converted) at ./errors.go:75:39 +./errors.go:74:7: leaking param content: e +./errors.go:75:20: ... argument does not escape +./errors.go:75:39: e.Key escapes to heap +./errors.go:78:7: parameter e leaks to ~r0 for (*KeyError).Unwrap with derefs=1: +./errors.go:78:7: flow: ~r0 ← *e: +./errors.go:78:7: from e.Err (dot of pointer) at ./errors.go:79:10 +./errors.go:78:7: from return e.Err (return) at ./errors.go:79:2 +./errors.go:78:7: leaking param: e to result ~r0 level=1 +./errors.go:91:6: se escapes to heap in (*FileError).Error: +./errors.go:91:6: flow: {heap} ← &se: +./errors.go:91:6: from &se (address-of) at ./errors.go:92:22 +./errors.go:91:6: from &se (interface-converted) at ./errors.go:92:22 +./errors.go:91:6: from errors.As(e.Err, &se) (call parameter) at ./errors.go:92:14 +./errors.go:90:7: parameter e leaks to {heap} for (*FileError).Error with derefs=1: +./errors.go:90:7: flow: {heap} ← *e: +./errors.go:90:7: from e.Err (dot of pointer) at ./errors.go:92:16 +./errors.go:90:7: from errors.As(e.Err, &se) (call parameter) at ./errors.go:92:14 +./errors.go:93:18: e.Msg escapes to heap in (*FileError).Error: +./errors.go:93:18: flow: {storage for ... argument} ← &{storage for e.Msg}: +./errors.go:93:18: from e.Msg (spill) at ./errors.go:93:18 +./errors.go:93:18: from ... argument (slice-literal-element) at ./errors.go:93:18 +./errors.go:93:18: flow: {heap} ← {storage for ... argument}: +./errors.go:93:18: from ... argument (spill) at ./errors.go:93:18 +./errors.go:93:18: from fmt.Sprintf("gitconfig: %s line %d in file %s", ... argument...) (call parameter) at ./errors.go:93:18 +./errors.go:93:18: e.Line escapes to heap in (*FileError).Error: +./errors.go:93:18: flow: {storage for ... argument} ← &{storage for e.Line}: +./errors.go:93:18: from e.Line (spill) at ./errors.go:93:18 +./errors.go:93:18: from ... argument (slice-literal-element) at ./errors.go:93:18 +./errors.go:93:18: flow: {heap} ← {storage for ... argument}: +./errors.go:93:18: from ... argument (spill) at ./errors.go:93:18 +./errors.go:93:18: from fmt.Sprintf("gitconfig: %s line %d in file %s", ... argument...) (call parameter) at ./errors.go:93:18 +./errors.go:93:18: e.File escapes to heap in (*FileError).Error: +./errors.go:93:18: flow: {storage for ... argument} ← &{storage for e.File}: +./errors.go:93:18: from e.File (spill) at ./errors.go:93:18 +./errors.go:93:18: from ... argument (slice-literal-element) at ./errors.go:93:18 +./errors.go:93:18: flow: {heap} ← {storage for ... argument}: +./errors.go:93:18: from ... argument (spill) at ./errors.go:93:18 +./errors.go:93:18: from fmt.Sprintf("gitconfig: %s line %d in file %s", ... argument...) (call parameter) at ./errors.go:93:18 +./errors.go:95:43: e.Path escapes to heap in (*FileError).Error: +./errors.go:95:43: flow: {storage for ... argument} ← &{storage for e.Path}: +./errors.go:95:43: from e.Path (spill) at ./errors.go:95:43 +./errors.go:95:43: from ... argument (slice-literal-element) at ./errors.go:95:20 +./errors.go:95:43: flow: {heap} ← {storage for ... argument}: +./errors.go:95:43: from ... argument (spill) at ./errors.go:95:20 +./errors.go:95:43: from fmt.Sprintf("gitconfig: %s: %v", ... argument...) (call parameter) at ./errors.go:95:20 +./errors.go:90:7: parameter e leaks to {storage for e.Path} for (*FileError).Error with derefs=1: +./errors.go:90:7: flow: {storage for e.Path} ← *e: +./errors.go:90:7: from e.Path (dot of pointer) at ./errors.go:95:43 +./errors.go:90:7: from e.Path (interface-converted) at ./errors.go:95:43 +./errors.go:90:7: leaking param content: e +./errors.go:91:6: moved to heap: se +./errors.go:93:18: ... argument does not escape +./errors.go:93:18: e.Msg escapes to heap +./errors.go:93:18: e.Line escapes to heap +./errors.go:93:18: e.File escapes to heap +./errors.go:95:20: ... argument does not escape +./errors.go:95:43: e.Path escapes to heap +./errors.go:98:7: parameter e leaks to ~r0 for (*FileError).Unwrap with derefs=1: +./errors.go:98:7: flow: ~r0 ← *e: +./errors.go:98:7: from e.Err (dot of pointer) at ./errors.go:99:10 +./errors.go:98:7: from return e.Err (return) at ./errors.go:99:2 +./errors.go:98:7: leaking param: e to result ~r0 level=1 +./errors.go:112:58: e.Msg escapes to heap in (*SyntaxError).Error: +./errors.go:112:58: flow: {storage for ... argument} ← &{storage for e.Msg}: +./errors.go:112:58: from e.Msg (spill) at ./errors.go:112:58 +./errors.go:112:58: from ... argument (slice-literal-element) at ./errors.go:112:20 +./errors.go:112:58: flow: {heap} ← {storage for ... argument}: +./errors.go:112:58: from ... argument (spill) at ./errors.go:112:20 +./errors.go:112:58: from fmt.Sprintf("gitconfig: %s line %d in file %s", ... argument...) (call parameter) at ./errors.go:112:20 +./errors.go:112:65: e.Line escapes to heap in (*SyntaxError).Error: +./errors.go:112:65: flow: {storage for ... argument} ← &{storage for e.Line}: +./errors.go:112:65: from e.Line (spill) at ./errors.go:112:65 +./errors.go:112:65: from ... argument (slice-literal-element) at ./errors.go:112:20 +./errors.go:112:65: flow: {heap} ← {storage for ... argument}: +./errors.go:112:65: from ... argument (spill) at ./errors.go:112:20 +./errors.go:112:65: from fmt.Sprintf("gitconfig: %s line %d in file %s", ... argument...) (call parameter) at ./errors.go:112:20 +./errors.go:112:73: e.File escapes to heap in (*SyntaxError).Error: +./errors.go:112:73: flow: {storage for ... argument} ← &{storage for e.File}: +./errors.go:112:73: from e.File (spill) at ./errors.go:112:73 +./errors.go:112:73: from ... argument (slice-literal-element) at ./errors.go:112:20 +./errors.go:112:73: flow: {heap} ← {storage for ... argument}: +./errors.go:112:73: from ... argument (spill) at ./errors.go:112:20 +./errors.go:112:73: from fmt.Sprintf("gitconfig: %s line %d in file %s", ... argument...) (call parameter) at ./errors.go:112:20 +./errors.go:111:7: parameter e leaks to {storage for e.File} for (*SyntaxError).Error with derefs=1: +./errors.go:111:7: flow: {storage for e.File} ← *e: +./errors.go:111:7: from e.File (dot of pointer) at ./errors.go:112:73 +./errors.go:111:7: from e.File (interface-converted) at ./errors.go:112:73 +./errors.go:111:7: parameter e leaks to {storage for e.Msg} for (*SyntaxError).Error with derefs=1: +./errors.go:111:7: flow: {storage for e.Msg} ← *e: +./errors.go:111:7: from e.Msg (dot of pointer) at ./errors.go:112:58 +./errors.go:111:7: from e.Msg (interface-converted) at ./errors.go:112:58 +./errors.go:111:7: leaking param content: e +./errors.go:112:20: ... argument does not escape +./errors.go:112:58: e.Msg escapes to heap +./errors.go:112:65: e.Line escapes to heap +./errors.go:112:73: e.File escapes to heap +./errors.go:124:7: parameter e leaks to {heap} for (*ValueError).Error with derefs=1: +./errors.go:124:7: flow: {heap} ← *e: +./errors.go:124:7: from e.Err (dot of pointer) at ./errors.go:135:18 +./errors.go:124:7: from e.Err.Error() (call parameter) at ./errors.go:135:28 +./errors.go:127:60: e.Type escapes to heap in (*ValueError).Error: +./errors.go:127:60: flow: {storage for ... argument} ← &{storage for e.Type}: +./errors.go:127:60: from e.Type (spill) at ./errors.go:127:60 +./errors.go:127:60: from ... argument (slice-literal-element) at ./errors.go:127:20 +./errors.go:127:60: flow: {heap} ← {storage for ... argument}: +./errors.go:127:60: from ... argument (spill) at ./errors.go:127:20 +./errors.go:127:60: from fmt.Sprintf("gitconfig: missing %s value for %q", ... argument...) (call parameter) at ./errors.go:127:20 +./errors.go:127:85: ~r0 escapes to heap in (*ValueError).Error: +./errors.go:127:85: flow: {storage for ... argument} ← &{storage for ~r0}: +./errors.go:127:85: from ~r0 (spill) at ./errors.go:127:85 +./errors.go:127:85: from ... argument (slice-literal-element) at ./errors.go:127:20 +./errors.go:127:85: flow: {heap} ← {storage for ... argument}: +./errors.go:127:85: from ... argument (spill) at ./errors.go:127:20 +./errors.go:127:85: from fmt.Sprintf("gitconfig: missing %s value for %q", ... argument...) (call parameter) at ./errors.go:127:20 +./errors.go:129:59: e.Type escapes to heap in (*ValueError).Error: +./errors.go:129:59: flow: {storage for ... argument} ← &{storage for e.Type}: +./errors.go:129:59: from e.Type (spill) at ./errors.go:129:59 +./errors.go:129:59: from ... argument (slice-literal-element) at ./errors.go:129:20 +./errors.go:129:59: flow: {heap} ← {storage for ... argument}: +./errors.go:129:59: from ... argument (spill) at ./errors.go:129:20 +./errors.go:129:59: from fmt.Sprintf("gitconfig: bad %s value %q for %q", ... argument...) (call parameter) at ./errors.go:129:20 +./errors.go:129:73: e.Entry.Value escapes to heap in (*ValueError).Error: +./errors.go:129:73: flow: {storage for ... argument} ← &{storage for e.Entry.Value}: +./errors.go:129:73: from e.Entry.Value (spill) at ./errors.go:129:73 +./errors.go:129:73: from ... argument (slice-literal-element) at ./errors.go:129:20 +./errors.go:129:73: flow: {heap} ← {storage for ... argument}: +./errors.go:129:73: from ... argument (spill) at ./errors.go:129:20 +./errors.go:129:73: from fmt.Sprintf("gitconfig: bad %s value %q for %q", ... argument...) (call parameter) at ./errors.go:129:20 +./errors.go:129:99: ~r0 escapes to heap in (*ValueError).Error: +./errors.go:129:99: flow: {storage for ... argument} ← &{storage for ~r0}: +./errors.go:129:99: from ~r0 (spill) at ./errors.go:129:99 +./errors.go:129:99: from ... argument (slice-literal-element) at ./errors.go:129:20 +./errors.go:129:99: flow: {heap} ← {storage for ... argument}: +./errors.go:129:99: from ... argument (spill) at ./errors.go:129:20 +./errors.go:129:99: from fmt.Sprintf("gitconfig: bad %s value %q for %q", ... argument...) (call parameter) at ./errors.go:129:20 +./errors.go:132:51: e.Entry.Origin.File escapes to heap in (*ValueError).Error: +./errors.go:132:51: flow: {storage for ... argument} ← &{storage for e.Entry.Origin.File}: +./errors.go:132:51: from e.Entry.Origin.File (spill) at ./errors.go:132:51 +./errors.go:132:51: from ... argument (slice-literal-element) at ./errors.go:132:21 +./errors.go:132:51: flow: {heap} ← {storage for ... argument}: +./errors.go:132:51: from ... argument (spill) at ./errors.go:132:21 +./errors.go:132:51: from fmt.Sprintf(" in file %s", ... argument...) (call parameter) at ./errors.go:132:21 +./errors.go:124:7: parameter e leaks to {storage for e.Entry.Origin.File} for (*ValueError).Error with derefs=1: +./errors.go:124:7: flow: {storage for e.Entry.Origin.File} ← *e: +./errors.go:124:7: from e.Entry (dot of pointer) at ./errors.go:132:38 +./errors.go:124:7: from e.Entry.Origin (dot) at ./errors.go:132:44 +./errors.go:124:7: from e.Entry.Origin.File (dot) at ./errors.go:132:51 +./errors.go:124:7: from e.Entry.Origin.File (interface-converted) at ./errors.go:132:51 +./errors.go:129:99: k.Section + "." + k.Subsection + "." + k.Name escapes to heap in (*ValueError).Error: +./errors.go:129:99: flow: ~r0 ← &{storage for k.Section + "." + k.Subsection + "." + k.Name}: +./errors.go:129:99: from k.Section + "." + k.Subsection + "." + k.Name (spill) at ./errors.go:129:99 +./errors.go:129:99: from ~r0 = k.Section + "." + k.Subsection + "." + k.Name (assign-pair) at ./errors.go:129:99 +./errors.go:129:99: flow: {storage for ~r0} ← ~r0: +./errors.go:129:99: from ~r0 (interface-converted) at ./errors.go:129:99 +./errors.go:129:99: k.Section + "." + k.Name escapes to heap in (*ValueError).Error: +./errors.go:129:99: flow: ~r0 ← &{storage for k.Section + "." + k.Name}: +./errors.go:129:99: from k.Section + "." + k.Name (spill) at ./errors.go:129:99 +./errors.go:129:99: from ~r0 = k.Section + "." + k.Name (assign-pair) at ./errors.go:129:99 +./errors.go:129:99: flow: {storage for ~r0} ← ~r0: +./errors.go:129:99: from ~r0 (interface-converted) at ./errors.go:129:99 +./errors.go:124:7: parameter e leaks to {storage for e.Entry.Value} for (*ValueError).Error with derefs=1: +./errors.go:124:7: flow: {storage for e.Entry.Value} ← *e: +./errors.go:124:7: from e.Entry (dot of pointer) at ./errors.go:129:67 +./errors.go:124:7: from e.Entry.Value (dot) at ./errors.go:129:73 +./errors.go:124:7: from e.Entry.Value (interface-converted) at ./errors.go:129:73 +./errors.go:124:7: parameter e leaks to {storage for e.Type} for (*ValueError).Error with derefs=1: +./errors.go:124:7: flow: {storage for e.Type} ← *e: +./errors.go:124:7: from e.Type (dot of pointer) at ./errors.go:129:59 +./errors.go:124:7: from e.Type (interface-converted) at ./errors.go:129:59 +./errors.go:127:85: k.Section + "." + k.Subsection + "." + k.Name escapes to heap in (*ValueError).Error: +./errors.go:127:85: flow: ~r0 ← &{storage for k.Section + "." + k.Subsection + "." + k.Name}: +./errors.go:127:85: from k.Section + "." + k.Subsection + "." + k.Name (spill) at ./errors.go:127:85 +./errors.go:127:85: from ~r0 = k.Section + "." + k.Subsection + "." + k.Name (assign-pair) at ./errors.go:127:85 +./errors.go:127:85: flow: {storage for ~r0} ← ~r0: +./errors.go:127:85: from ~r0 (interface-converted) at ./errors.go:127:85 +./errors.go:127:85: k.Section + "." + k.Name escapes to heap in (*ValueError).Error: +./errors.go:127:85: flow: ~r0 ← &{storage for k.Section + "." + k.Name}: +./errors.go:127:85: from k.Section + "." + k.Name (spill) at ./errors.go:127:85 +./errors.go:127:85: from ~r0 = k.Section + "." + k.Name (assign-pair) at ./errors.go:127:85 +./errors.go:127:85: flow: {storage for ~r0} ← ~r0: +./errors.go:127:85: from ~r0 (interface-converted) at ./errors.go:127:85 +./errors.go:124:7: parameter e leaks to {storage for e.Type} for (*ValueError).Error with derefs=1: +./errors.go:124:7: flow: {storage for e.Type} ← *e: +./errors.go:124:7: from e.Type (dot of pointer) at ./errors.go:127:60 +./errors.go:124:7: from e.Type (interface-converted) at ./errors.go:127:60 +./errors.go:135:15: ": " + e.Err.Error() escapes to heap in (*ValueError).Error: +./errors.go:135:15: flow: msg ← &{storage for ": " + e.Err.Error()}: +./errors.go:135:15: from ": " + e.Err.Error() (spill) at ./errors.go:135:15 +./errors.go:135:15: from msg += ": " + e.Err.Error() (assign) at ./errors.go:135:7 +./errors.go:135:15: flow: ~r0 ← msg: +./errors.go:135:15: from return msg (return) at ./errors.go:137:2 +./errors.go:124:7: leaking param content: e +./errors.go:127:20: ... argument does not escape +./errors.go:127:60: e.Type escapes to heap +./errors.go:127:85: ~r0 escapes to heap +./errors.go:127:85: k.Section + "." + k.Subsection + "." + k.Name escapes to heap +./errors.go:127:85: k.Section + "." + k.Name escapes to heap +./errors.go:129:20: ... argument does not escape +./errors.go:129:59: e.Type escapes to heap +./errors.go:129:73: e.Entry.Value escapes to heap +./errors.go:129:99: ~r0 escapes to heap +./errors.go:129:99: k.Section + "." + k.Subsection + "." + k.Name escapes to heap +./errors.go:129:99: k.Section + "." + k.Name escapes to heap +./errors.go:132:21: ... argument does not escape +./errors.go:132:51: e.Entry.Origin.File escapes to heap +./errors.go:135:15: ": " + e.Err.Error() escapes to heap +./errors.go:140:7: parameter e leaks to ~r0 for (*ValueError).Unwrap with derefs=1: +./errors.go:140:7: flow: ~r0 ← *e: +./errors.go:140:7: from e.Err (dot of pointer) at ./errors.go:141:10 +./errors.go:140:7: from return e.Err (return) at ./errors.go:141:2 +./errors.go:140:7: leaking param: e to result ~r0 level=1 +./file.go:55:12: parameter name leaks to {heap} for Parse with derefs=0: +./file.go:55:12: flow: {heap} ← name: +./file.go:55:12: from parse(name, data) (call parameter) at ./file.go:57:17 +./file.go:55:25: parameter data leaks to {heap} for Parse with derefs=0: +./file.go:55:25: flow: {heap} ← data: +./file.go:55:25: from parse(name, data) (call parameter) at ./file.go:57:17 +./file.go:56:20: append([]byte{}, bytes.b...) escapes to heap in Parse: +./file.go:56:20: flow: ~r0 ← &{storage for append([]byte{}, bytes.b...)}: +./file.go:56:20: from append([]byte{}, bytes.b...) (spill) at ./file.go:56:20 +./file.go:56:20: from ~r0 = append([]byte{}, bytes.b...) (assign-pair) at ./file.go:56:20 +./file.go:56:20: flow: data ← ~r0: +./file.go:56:20: from data = ~r0 (assign) at ./file.go:56:7 +./file.go:56:20: flow: {heap} ← data: +./file.go:56:20: from parse(name, data) (call parameter) at ./file.go:57:17 +./file.go:56:20: []byte{} escapes to heap in Parse: +./file.go:56:20: flow: {temp} ← &{storage for []byte{}}: +./file.go:56:20: from []byte{} (spill) at ./file.go:56:20 +./file.go:56:20: from append([]byte{}, bytes.b...) (call parameter) at ./file.go:56:20 +./file.go:56:20: flow: ~r0 ← {temp}: +./file.go:56:20: from ~r0 = append([]byte{}, bytes.b...) (assign-pair) at ./file.go:56:20 +./file.go:56:20: flow: data ← ~r0: +./file.go:56:20: from data = ~r0 (assign) at ./file.go:56:7 +./file.go:56:20: flow: {heap} ← data: +./file.go:56:20: from parse(name, data) (call parameter) at ./file.go:57:17 +./file.go:61:9: &File{...} escapes to heap in Parse: +./file.go:61:9: flow: ~r0 ← &{storage for &File{...}}: +./file.go:61:9: from &File{...} (spill) at ./file.go:61:9 +./file.go:61:9: from return &File{...}, nil (return) at ./file.go:61:2 +./file.go:55:12: parameter name leaks to {storage for &File{...}} for Parse with derefs=0: +./file.go:55:12: flow: {storage for &File{...}} ← name: +./file.go:55:12: from File{...} (struct literal element) at ./file.go:61:14 +./file.go:55:25: parameter data leaks to {storage for &File{...}} for Parse with derefs=0: +./file.go:55:25: flow: {storage for &File{...}} ← data: +./file.go:55:25: from File{...} (struct literal element) at ./file.go:61:14 +./file.go:55:12: leaking param: name +./file.go:55:25: leaking param: data +./file.go:56:20: []byte{} escapes to heap +./file.go:56:20: append escapes to heap +./file.go:61:9: &File{...} escapes to heap +./file.go:67:20: append([]byte{}, bytes.b...) escapes to heap in (*File).Bytes: +./file.go:67:20: flow: ~r0 ← &{storage for append([]byte{}, bytes.b...)}: +./file.go:67:20: from append([]byte{}, bytes.b...) (spill) at ./file.go:67:20 +./file.go:67:20: from ~r0 = append([]byte{}, bytes.b...) (assign-pair) at ./file.go:67:20 +./file.go:67:20: flow: ~r0 ← ~r0: +./file.go:67:20: from return ~r0 (return) at ./file.go:67:2 +./file.go:67:20: []byte{} escapes to heap in (*File).Bytes: +./file.go:67:20: flow: {temp} ← &{storage for []byte{}}: +./file.go:67:20: from []byte{} (spill) at ./file.go:67:20 +./file.go:67:20: from append([]byte{}, bytes.b...) (call parameter) at ./file.go:67:20 +./file.go:67:20: flow: ~r0 ← {temp}: +./file.go:67:20: from ~r0 = append([]byte{}, bytes.b...) (assign-pair) at ./file.go:67:20 +./file.go:67:20: flow: ~r0 ← ~r0: +./file.go:67:20: from return ~r0 (return) at ./file.go:67:2 +./file.go:66:7: f does not escape +./file.go:67:20: []byte{} escapes to heap +./file.go:67:20: append escapes to heap +./file.go:78:7: parameter f leaks to {heap} for (*File).Config with derefs=1: +./file.go:78:7: flow: file ← *f: +./file.go:78:7: from f.name (dot of pointer) at ./file.go:80:42 +./file.go:78:7: from p, scope, file, out := f.parsed, f.scope, f.name, nil (assign-pair) at ./file.go:80:31 +./file.go:78:7: flow: {heap} ← file: +./file.go:78:7: from Origin{...} (struct literal element) at ./file.go:80:31 +./file.go:78:7: from Entry{...} (struct literal element) at ./file.go:80:31 +./file.go:78:7: from append(out, Entry{...}) (call parameter) at ./file.go:80:31 +./file.go:80:31: append(out, Entry{...}) escapes to heap in (*File).Config: +./file.go:80:31: flow: out ← &{storage for append(out, Entry{...})}: +./file.go:80:31: from append(out, Entry{...}) (spill) at ./file.go:80:31 +./file.go:80:31: from out = append(out, Entry{...}) (assign) at ./file.go:80:31 +./file.go:80:31: flow: ~r0 ← out: +./file.go:80:31: from ~r0 = out (assign-pair) at ./file.go:80:31 +./file.go:80:31: flow: {heap} ← ~r0: +./file.go:80:31: from newConfig(~r0) (call parameter) at ./file.go:80:21 +./file.go:78:7: parameter f leaks to ~r0 for (*File).Config with derefs=1: +./file.go:78:7: flow: ~r0 ← *f: +./file.go:78:7: from f.snap (dot of pointer) at ./file.go:82:10 +./file.go:78:7: from return f.snap (return) at ./file.go:82:2 +./file.go:78:7: leaking param content: f +./file.go:80:31: append escapes to heap +./file.go:105:78: (*File).Set capturing by value: k (addr=false assign=false width=56) +./file.go:105:78: (*File).Set capturing by value: want (addr=false assign=false width=24) +./file.go:105:78: (*File).Set capturing by value: implicitAllowed (addr=false assign=false width=1) +./file.go:105:78: (*File).Set capturing by value: k (addr=false assign=false width=56) +./file.go:105:78: (*File).Set capturing by value: k (addr=false assign=false width=56) +./file.go:107:80: (*File).Set capturing by value: k (addr=false assign=false width=56) +./file.go:107:80: (*File).Set capturing by value: want (addr=false assign=false width=24) +./file.go:107:80: (*File).Set capturing by value: implicitAllowed (addr=false assign=false width=1) +./file.go:107:80: (*File).Set capturing by value: k (addr=false assign=false width=56) +./file.go:107:80: (*File).Set capturing by value: k (addr=false assign=false width=56) +./file.go:92:20: parameter key leaks to {heap} for (*File).Set with derefs=0: +./file.go:92:20: flow: {heap} ← key: +./file.go:92:20: from (*File).prepare(f, key, &value) (call parameter) at ./file.go:93:41 +./edit.go:134:14: parameter before leaks to {heap} for checkKey.func1#X5GLJN/kegQ=# with derefs=1: +./edit.go:134:14: flow: {heap} ← *before: +./edit.go:134:14: from filter(before, other) (call parameter) at ./edit.go:136:26 +./edit.go:134:22: parameter after leaks to {heap} for checkKey.func1#X5GLJN/kegQ=# with derefs=1: +./edit.go:134:22: flow: {heap} ← *after: +./edit.go:134:22: from filter(after, other) (call parameter) at ./edit.go:136:49 +./edit.go:134:14: parameter before leaks to {heap} for checkKey.func1#v+T99KtU5ug=# with derefs=1: +./edit.go:134:14: flow: {heap} ← *before: +./edit.go:134:14: from filter(before, other) (call parameter) at ./edit.go:136:26 +./edit.go:134:22: parameter after leaks to {heap} for checkKey.func1#v+T99KtU5ug=# with derefs=1: +./edit.go:134:22: flow: {heap} ← *after: +./edit.go:134:22: from filter(after, other) (call parameter) at ./edit.go:136:49 +./file.go:92:7: parameter f leaks to {heap} for (*File).Set with derefs=1: +./file.go:92:7: flow: {temp} ← f: +./file.go:92:7: from (*File).apply(f, key, []splice{...}, ~r0) (call parameter) at ./file.go:105:17 +./file.go:92:7: flow: {heap} ← *{temp}: +./file.go:100:10: &KeyError{...} escapes to heap in (*File).Set: +./file.go:100:10: flow: ~r0 ← &{storage for &KeyError{...}}: +./file.go:100:10: from &KeyError{...} (spill) at ./file.go:100:10 +./file.go:100:10: from &KeyError{...} (interface-converted) at ./file.go:100:10 +./file.go:100:10: from return &KeyError{...} (return) at ./file.go:100:3 +./file.go:92:20: parameter key leaks to {storage for &KeyError{...}} for (*File).Set with derefs=0: +./file.go:92:20: flow: {storage for &KeyError{...}} ← key: +./file.go:92:20: from KeyError{...} (struct literal element) at ./file.go:100:19 +./file.go:92:7: leaking param content: f +./file.go:92:20: leaking param: key +./file.go:92:25: value does not escape +./edit.go:134:14: leaking param content: before +./edit.go:134:22: leaking param content: after +./edit.go:135:17: e does not escape +./edit.go:139:29: e does not escape +./edit.go:134:14: leaking param content: before +./edit.go:134:22: leaking param content: after +./edit.go:135:17: e does not escape +./edit.go:139:29: e does not escape +./file.go:97:20: append does not escape +./file.go:100:10: &KeyError{...} escapes to heap +./file.go:105:31: []splice{...} does not escape +./file.go:105:90: []string{...} does not escape +./file.go:105:78: func literal does not escape +./edit.go:135:12: func literal does not escape +./edit.go:139:24: func literal does not escape +./file.go:107:30: []splice{...} does not escape +./file.go:107:92: []string{...} does not escape +./file.go:107:80: func literal does not escape +./edit.go:135:12: func literal does not escape +./edit.go:139:24: func literal does not escape +./file.go:119:81: (*File).ReplaceAll capturing by value: k (addr=false assign=false width=56) +./file.go:119:81: (*File).ReplaceAll capturing by value: want (addr=false assign=false width=24) +./file.go:119:81: (*File).ReplaceAll capturing by value: implicitAllowed (addr=false assign=false width=1) +./file.go:119:81: (*File).ReplaceAll capturing by value: k (addr=false assign=false width=56) +./file.go:119:81: (*File).ReplaceAll capturing by value: k (addr=false assign=false width=56) +./file.go:127:39: (*File).ReplaceAll capturing by value: k (addr=false assign=false width=56) +./file.go:127:39: (*File).ReplaceAll capturing by value: want (addr=false assign=false width=24) +./file.go:127:39: (*File).ReplaceAll capturing by value: implicitAllowed (addr=false assign=false width=1) +./file.go:127:39: (*File).ReplaceAll capturing by value: k (addr=false assign=false width=56) +./file.go:127:39: (*File).ReplaceAll capturing by value: k (addr=false assign=false width=56) +./file.go:112:27: parameter key leaks to {heap} for (*File).ReplaceAll with derefs=0: +./file.go:112:27: flow: {heap} ← key: +./file.go:112:27: from (*File).prepare(f, key, &value) (call parameter) at ./file.go:113:41 +./edit.go:134:14: parameter before leaks to {heap} for checkKey.func1#MKVITQ+eOz4=# with derefs=1: +./edit.go:134:14: flow: {heap} ← *before: +./edit.go:134:14: from filter(before, other) (call parameter) at ./edit.go:136:26 +./edit.go:134:22: parameter after leaks to {heap} for checkKey.func1#MKVITQ+eOz4=# with derefs=1: +./edit.go:134:22: flow: {heap} ← *after: +./edit.go:134:22: from filter(after, other) (call parameter) at ./edit.go:136:49 +./edit.go:134:14: parameter before leaks to {heap} for checkKey.func1#QqliH0hbpFs=# with derefs=1: +./edit.go:134:14: flow: {heap} ← *before: +./edit.go:134:14: from filter(before, other) (call parameter) at ./edit.go:136:26 +./edit.go:134:22: parameter after leaks to {heap} for checkKey.func1#QqliH0hbpFs=# with derefs=1: +./edit.go:134:22: flow: {heap} ← *after: +./edit.go:134:22: from filter(after, other) (call parameter) at ./edit.go:136:49 +./file.go:112:7: parameter f leaks to {heap} for (*File).ReplaceAll with derefs=1: +./file.go:112:7: flow: {temp} ← f: +./file.go:112:7: from (*File).apply(f, key, []splice{...}, ~r0) (call parameter) at ./file.go:119:17 +./file.go:112:7: flow: {heap} ← *{temp}: +./file.go:112:7: leaking param content: f +./file.go:112:27: leaking param: key +./file.go:112:32: value does not escape +./edit.go:134:14: leaking param content: before +./edit.go:134:22: leaking param content: after +./edit.go:135:17: e does not escape +./edit.go:139:29: e does not escape +./edit.go:134:14: leaking param content: before +./edit.go:134:22: leaking param content: after +./edit.go:135:17: e does not escape +./edit.go:139:29: e does not escape +./file.go:117:20: append does not escape +./file.go:119:31: []splice{...} does not escape +./file.go:119:93: []string{...} does not escape +./file.go:119:81: func literal does not escape +./edit.go:135:12: func literal does not escape +./edit.go:139:24: func literal does not escape +./file.go:124:19: append does not escape +./file.go:126:18: append does not escape +./file.go:127:51: []string{...} does not escape +./file.go:127:39: func literal does not escape +./edit.go:135:12: func literal does not escape +./edit.go:139:24: func literal does not escape +./file.go:132:2: (*File).Add capturing by value: k (addr=false assign=false width=56) +./file.go:136:6: (*File).Add capturing by value: want (addr=false assign=false width=24) +./file.go:144:18: (*File).Add.func1 capturing by value: k (addr=false assign=false width=56) +./file.go:144:18: (*File).Add.func1 capturing by value: want (addr=false assign=false width=24) +./file.go:144:18: (*File).Add.func1 capturing by value: implicitAllowed (addr=false assign=false width=1) +./file.go:144:18: (*File).Add.func1 capturing by value: k (addr=false assign=false width=56) +./file.go:144:18: (*File).Add.func1 capturing by value: k (addr=false assign=false width=56) +./file.go:131:20: parameter key leaks to {heap} for (*File).Add with derefs=0: +./file.go:131:20: flow: {heap} ← key: +./file.go:131:20: from (*File).prepare(f, key, &value) (call parameter) at ./file.go:132:41 +./file.go:131:25: parameter value leaks to {heap} for (*File).Add with derefs=0: +./file.go:131:25: flow: {heap} ← value: +./file.go:131:25: from append(want, value) (call parameter) at ./file.go:140:15 +./edit.go:134:14: parameter before leaks to {heap} for checkKey.1#r3iRv3NFPAI=# with derefs=1: +./edit.go:134:14: flow: {heap} ← *before: +./edit.go:134:14: from filter(before, other) (call parameter) at ./edit.go:136:26 +./edit.go:134:22: parameter after leaks to {heap} for checkKey.1#r3iRv3NFPAI=# with derefs=1: +./edit.go:134:22: flow: {heap} ← *after: +./edit.go:134:22: from filter(after, other) (call parameter) at ./edit.go:136:49 +./file.go:131:7: parameter f leaks to {heap} for (*File).Add with derefs=1: +./file.go:131:7: flow: {temp} ← f: +./file.go:131:7: from (*File).apply(f, key, []splice{...}, func literal) (call parameter) at ./file.go:141:16 +./file.go:131:7: flow: {heap} ← *{temp}: +./file.go:141:85: parameter after leaks to {heap} for (*File).Add.func1 with derefs=1: +./file.go:141:85: flow: entries ← after: +./file.go:141:85: from entries, _ := after, 0 (assign-pair) at ./file.go:143:16 +./file.go:141:85: flow: {temp} ← entries: +./file.go:141:85: flow: e ← *{temp}: +./file.go:141:85: from for loop (range-deref) at ./file.go:143:16 +./file.go:141:85: flow: {heap} ← e: +./file.go:141:85: from append(out, e) (call parameter) at ./file.go:143:16 +./file.go:141:77: parameter before leaks to {heap} for (*File).Add.func1 with derefs=1: +./file.go:141:77: flow: before ← before: +./file.go:141:77: from before, after := before, after (assign-pair) at ./file.go:144:33 +./file.go:141:77: flow: entries ← before: +./file.go:141:77: from entries, _ := before, 0 (assign-pair) at ./file.go:144:33 +./file.go:141:77: flow: {temp} ← entries: +./file.go:141:77: flow: e ← *{temp}: +./file.go:141:77: from for loop (range-deref) at ./file.go:144:33 +./file.go:141:77: flow: {heap} ← e: +./file.go:141:77: from append(out, e) (call parameter) at ./file.go:144:33 +./file.go:131:7: leaking param content: f +./file.go:131:20: leaking param: key +./file.go:131:25: leaking param: value +./file.go:141:77: leaking param content: before +./file.go:141:85: leaking param content: after +./edit.go:134:14: leaking param content: before +./edit.go:134:22: leaking param content: after +./edit.go:135:17: e does not escape +./edit.go:139:29: e does not escape +./file.go:137:31: append does not escape +./file.go:138:16: append does not escape +./file.go:140:15: append does not escape +./file.go:141:30: []splice{...} does not escape +./file.go:141:72: func literal does not escape +./file.go:143:16: append does not escape +./file.go:144:18: func literal does not escape +./edit.go:135:12: func literal does not escape +./edit.go:139:24: func literal does not escape +./file.go:144:33: append does not escape +./file.go:144:33: append does not escape +./file.go:144:33: append does not escape +./file.go:161:52: (*File).Unset capturing by value: k (addr=false assign=false width=56) +./file.go:161:52: (*File).Unset capturing by value: want (addr=false assign=false width=24) +./file.go:161:52: (*File).Unset capturing by value: implicitAllowed (addr=false assign=false width=1) +./file.go:161:52: (*File).Unset capturing by value: k (addr=false assign=false width=56) +./file.go:161:52: (*File).Unset capturing by value: k (addr=false assign=false width=56) +./file.go:151:22: parameter key leaks to {heap} for (*File).Unset with derefs=0: +./file.go:151:22: flow: {heap} ← key: +./file.go:151:22: from (*File).prepare(f, key, nil) (call parameter) at ./file.go:152:30 +./edit.go:134:14: parameter before leaks to {heap} for checkKey.func1#CZPSVfsmoKE=# with derefs=1: +./edit.go:134:14: flow: {heap} ← *before: +./edit.go:134:14: from filter(before, other) (call parameter) at ./edit.go:136:26 +./edit.go:134:22: parameter after leaks to {heap} for checkKey.func1#CZPSVfsmoKE=# with derefs=1: +./edit.go:134:22: flow: {heap} ← *after: +./edit.go:134:22: from filter(after, other) (call parameter) at ./edit.go:136:49 +./file.go:151:7: parameter f leaks to {heap} for (*File).Unset with derefs=1: +./file.go:151:7: flow: {temp} ← f: +./file.go:151:7: from (*File).apply(f, key, (*File).unsetEntries(f, idx), ~r0) (call parameter) at ./file.go:161:17 +./file.go:151:7: flow: {heap} ← *{temp}: +./file.go:164:16: &KeyError{...} escapes to heap in (*File).Unset: +./file.go:164:16: flow: err ← &{storage for &KeyError{...}}: +./file.go:164:16: from &KeyError{...} (spill) at ./file.go:164:16 +./file.go:164:16: from &KeyError{...} (interface-converted) at ./file.go:164:16 +./file.go:164:16: from return false, &KeyError{...} (return) at ./file.go:164:2 +./file.go:151:22: parameter key leaks to {storage for &KeyError{...}} for (*File).Unset with derefs=0: +./file.go:151:22: flow: {storage for &KeyError{...}} ← key: +./file.go:151:22: from KeyError{...} (struct literal element) at ./file.go:164:25 +./file.go:151:7: leaking param content: f +./file.go:151:22: leaking param: key +./edit.go:134:14: leaking param content: before +./edit.go:134:22: leaking param content: after +./edit.go:135:17: e does not escape +./edit.go:139:29: e does not escape +./file.go:156:20: append does not escape +./file.go:161:52: func literal does not escape +./edit.go:135:12: func literal does not escape +./edit.go:139:24: func literal does not escape +./file.go:164:16: &KeyError{...} escapes to heap +./file.go:178:54: (*File).UnsetAll capturing by value: k (addr=false assign=false width=56) +./file.go:178:54: (*File).UnsetAll capturing by value: want (addr=false assign=false width=24) +./file.go:178:54: (*File).UnsetAll capturing by value: implicitAllowed (addr=false assign=false width=1) +./file.go:178:54: (*File).UnsetAll capturing by value: k (addr=false assign=false width=56) +./file.go:178:54: (*File).UnsetAll capturing by value: k (addr=false assign=false width=56) +./file.go:169:25: parameter key leaks to {heap} for (*File).UnsetAll with derefs=0: +./file.go:169:25: flow: {heap} ← key: +./file.go:169:25: from (*File).prepare(f, key, nil) (call parameter) at ./file.go:170:30 +./edit.go:134:14: parameter before leaks to {heap} for checkKey.func1#tan11JIgj98=# with derefs=1: +./edit.go:134:14: flow: {heap} ← *before: +./edit.go:134:14: from filter(before, other) (call parameter) at ./edit.go:136:26 +./edit.go:134:22: parameter after leaks to {heap} for checkKey.func1#tan11JIgj98=# with derefs=1: +./edit.go:134:22: flow: {heap} ← *after: +./edit.go:134:22: from filter(after, other) (call parameter) at ./edit.go:136:49 +./file.go:169:7: parameter f leaks to {heap} for (*File).UnsetAll with derefs=1: +./file.go:169:7: flow: {temp} ← f: +./file.go:169:7: from (*File).apply(f, key, (*File).unsetEntries(f, idx), ~r0) (call parameter) at ./file.go:178:19 +./file.go:169:7: flow: {heap} ← *{temp}: +./file.go:169:7: leaking param content: f +./file.go:169:25: leaking param: key +./edit.go:134:14: leaking param content: before +./edit.go:134:22: leaking param content: after +./edit.go:135:17: e does not escape +./edit.go:139:29: e does not escape +./file.go:174:20: append does not escape +./file.go:178:54: func literal does not escape +./edit.go:135:12: func literal does not escape +./edit.go:139:24: func literal does not escape +./file.go:187:30: parameter section leaks to {heap} for (*File).RemoveSection with derefs=0: +./file.go:187:30: flow: {heap} ← section: +./file.go:187:30: from (*File).removeSection(f, section, sectionKey{...}) (call parameter) at ./file.go:194:24 +./file.go:187:7: parameter f leaks to {heap} for (*File).RemoveSection with derefs=1: +./file.go:187:7: flow: {temp} ← f: +./file.go:187:7: from (*File).removeSection(f, section, sectionKey{...}) (call parameter) at ./file.go:194:24 +./file.go:187:7: flow: {heap} ← *{temp}: +./file.go:194:64: string(b) escapes to heap in (*File).RemoveSection: +./file.go:194:64: flow: ~r0 ← &{storage for string(b)}: +./file.go:194:64: from string(b) (spill) at ./file.go:194:64 +./file.go:194:64: from ~r0 = string(b) (assign-pair) at ./file.go:194:64 +./file.go:188:23: &KeyError{...} escapes to heap in (*File).RemoveSection: +./file.go:188:23: flow: ~r0 ← &{storage for &KeyError{...}}: +./file.go:188:23: from &KeyError{...} (spill) at ./file.go:188:23 +./file.go:188:23: from &KeyError{...} (interface-converted) at ./file.go:188:23 +./file.go:188:23: from ~r0 = &KeyError{...} (assign-pair) at ./file.go:188:23 +./file.go:188:23: flow: err ← ~r0: +./file.go:188:23: from err := ~r0 (assign) at ./file.go:188:9 +./file.go:188:23: flow: err ← err: +./file.go:188:23: from return false, err (return) at ./file.go:189:3 +./file.go:191:22: &KeyError{...} escapes to heap in (*File).RemoveSection: +./file.go:191:22: flow: ~r0 ← &{storage for &KeyError{...}}: +./file.go:191:22: from &KeyError{...} (spill) at ./file.go:191:22 +./file.go:191:22: from &KeyError{...} (interface-converted) at ./file.go:191:22 +./file.go:191:22: from ~r0 = &KeyError{...} (assign-pair) at ./file.go:191:22 +./file.go:191:22: flow: err ← ~r0: +./file.go:191:22: from err := ~r0 (assign) at ./file.go:191:9 +./file.go:191:22: flow: err ← err: +./file.go:191:22: from return false, err (return) at ./file.go:192:3 +./file.go:187:30: parameter section leaks to {storage for &KeyError{...}} for (*File).RemoveSection with derefs=0: +./file.go:187:30: flow: section ← section: +./file.go:187:30: from section := section (assign-pair) at ./file.go:191:22 +./file.go:187:30: flow: {storage for &KeyError{...}} ← section: +./file.go:187:30: from KeyError{...} (struct literal element) at ./file.go:191:22 +./file.go:187:30: parameter section leaks to {storage for &KeyError{...}} for (*File).RemoveSection with derefs=0: +./file.go:187:30: flow: key ← section: +./file.go:187:30: from f, key := f, section (assign-pair) at ./file.go:188:23 +./file.go:187:30: flow: {storage for &KeyError{...}} ← key: +./file.go:187:30: from KeyError{...} (struct literal element) at ./file.go:188:23 +./file.go:187:7: leaking param content: f +./file.go:187:30: leaking param: section +./file.go:188:23: &KeyError{...} escapes to heap +./file.go:191:22: &KeyError{...} escapes to heap +./file.go:194:64: ([]byte)(s) does not escape +./file.go:194:64: string(b) escapes to heap +./file.go:200:33: parameter section leaks to {heap} for (*File).RemoveSubsection with derefs=0: +./file.go:200:33: flow: {heap} ← section: +./file.go:200:33: from (*File).removeSection(f, section, sectionKey{...}) (call parameter) at ./file.go:210:24 +./file.go:200:7: parameter f leaks to {heap} for (*File).RemoveSubsection with derefs=1: +./file.go:200:7: flow: {temp} ← f: +./file.go:200:7: from (*File).removeSection(f, section, sectionKey{...}) (call parameter) at ./file.go:210:24 +./file.go:200:7: flow: {heap} ← *{temp}: +./file.go:210:55: string(b) escapes to heap in (*File).RemoveSubsection: +./file.go:210:55: flow: ~r0 ← &{storage for string(b)}: +./file.go:210:55: from string(b) (spill) at ./file.go:210:55 +./file.go:210:55: from ~r0 = string(b) (assign-pair) at ./file.go:210:55 +./file.go:208:17: &KeyError{...} escapes to heap in (*File).RemoveSubsection: +./file.go:208:17: flow: err ← &{storage for &KeyError{...}}: +./file.go:208:17: from &KeyError{...} (spill) at ./file.go:208:17 +./file.go:208:17: from &KeyError{...} (interface-converted) at ./file.go:208:17 +./file.go:208:17: from return false, &KeyError{...} (return) at ./file.go:208:3 +./file.go:201:23: &KeyError{...} escapes to heap in (*File).RemoveSubsection: +./file.go:201:23: flow: ~r0 ← &{storage for &KeyError{...}}: +./file.go:201:23: from &KeyError{...} (spill) at ./file.go:201:23 +./file.go:201:23: from &KeyError{...} (interface-converted) at ./file.go:201:23 +./file.go:201:23: from ~r0 = &KeyError{...} (assign-pair) at ./file.go:201:23 +./file.go:201:23: flow: err ← ~r0: +./file.go:201:23: from err := ~r0 (assign) at ./file.go:201:9 +./file.go:201:23: flow: err ← err: +./file.go:201:23: from return false, err (return) at ./file.go:202:3 +./file.go:204:22: &KeyError{...} escapes to heap in (*File).RemoveSubsection: +./file.go:204:22: flow: ~r0 ← &{storage for &KeyError{...}}: +./file.go:204:22: from &KeyError{...} (spill) at ./file.go:204:22 +./file.go:204:22: from &KeyError{...} (interface-converted) at ./file.go:204:22 +./file.go:204:22: from ~r0 = &KeyError{...} (assign-pair) at ./file.go:204:22 +./file.go:204:22: flow: err ← ~r0: +./file.go:204:22: from err := ~r0 (assign) at ./file.go:204:9 +./file.go:204:22: flow: err ← err: +./file.go:204:22: from return false, err (return) at ./file.go:205:3 +./file.go:200:42: parameter sub leaks to {storage for &KeyError{...}} for (*File).RemoveSubsection with derefs=0: +./file.go:200:42: flow: {storage for &KeyError{...}} ← sub: +./file.go:200:42: from KeyError{...} (struct literal element) at ./file.go:208:26 +./file.go:200:33: parameter section leaks to {storage for &KeyError{...}} for (*File).RemoveSubsection with derefs=0: +./file.go:200:33: flow: section ← section: +./file.go:200:33: from section := section (assign-pair) at ./file.go:204:22 +./file.go:200:33: flow: {storage for &KeyError{...}} ← section: +./file.go:200:33: from KeyError{...} (struct literal element) at ./file.go:204:22 +./file.go:200:33: parameter section leaks to {storage for &KeyError{...}} for (*File).RemoveSubsection with derefs=0: +./file.go:200:33: flow: key ← section: +./file.go:200:33: from f, key := f, section (assign-pair) at ./file.go:201:23 +./file.go:200:33: flow: {storage for &KeyError{...}} ← key: +./file.go:200:33: from KeyError{...} (struct literal element) at ./file.go:201:23 +./file.go:200:7: leaking param content: f +./file.go:200:33: leaking param: section +./file.go:200:42: leaking param: sub +./file.go:201:23: &KeyError{...} escapes to heap +./file.go:204:22: &KeyError{...} escapes to heap +./file.go:208:17: &KeyError{...} escapes to heap +./file.go:210:55: ([]byte)(s) does not escape +./file.go:210:55: string(b) escapes to heap +./file.go:220:30: parameter oldName leaks to {heap} for (*File).RenameSection with derefs=0: +./file.go:220:30: flow: {heap} ← oldName: +./file.go:220:30: from (*File).renameSection(f, oldName, sectionKey{...}, to, formatHeader(newName, "", false)) (call parameter) at ./file.go:231:24 +./file.go:220:7: parameter f leaks to {heap} for (*File).RenameSection with derefs=1: +./file.go:220:7: flow: {temp} ← f: +./file.go:220:7: from (*File).renameSection(f, oldName, sectionKey{...}, to, formatHeader(newName, "", false)) (call parameter) at ./file.go:231:24 +./file.go:220:7: flow: {heap} ← *{temp}: +./file.go:230:38: string(b) escapes to heap in (*File).RenameSection: +./file.go:230:38: flow: ~r0 ← &{storage for string(b)}: +./file.go:230:38: from string(b) (spill) at ./file.go:230:38 +./file.go:230:38: from ~r0 = string(b) (assign-pair) at ./file.go:230:38 +./file.go:230:38: flow: to ← ~r0: +./file.go:230:38: from sectionKey{...} (struct literal element) at ./file.go:230:18 +./file.go:230:38: from to := sectionKey{...} (assign) at ./file.go:230:5 +./file.go:230:38: flow: {heap} ← to: +./file.go:230:38: from (*File).renameSection(f, oldName, sectionKey{...}, to, formatHeader(newName, "", false)) (call parameter) at ./file.go:231:24 +./file.go:220:39: parameter newName leaks to {heap} for (*File).RenameSection with derefs=0: +./file.go:220:39: flow: s ← newName: +./file.go:220:39: from s := newName (assign-pair) at ./file.go:230:38 +./file.go:220:39: flow: ~r0 ← s: +./file.go:220:39: from ~r0 = s (assign-pair) at ./file.go:230:38 +./file.go:220:39: flow: to ← ~r0: +./file.go:220:39: from sectionKey{...} (struct literal element) at ./file.go:230:18 +./file.go:220:39: from to := sectionKey{...} (assign) at ./file.go:230:5 +./file.go:220:39: flow: {heap} ← to: +./file.go:220:39: from (*File).renameSection(f, oldName, sectionKey{...}, to, formatHeader(newName, "", false)) (call parameter) at ./file.go:231:24 +./file.go:231:64: string(b) escapes to heap in (*File).RenameSection: +./file.go:231:64: flow: ~r0 ← &{storage for string(b)}: +./file.go:231:64: from string(b) (spill) at ./file.go:231:64 +./file.go:231:64: from ~r0 = string(b) (assign-pair) at ./file.go:231:64 +./file.go:221:23: &KeyError{...} escapes to heap in (*File).RenameSection: +./file.go:221:23: flow: ~r0 ← &{storage for &KeyError{...}}: +./file.go:221:23: from &KeyError{...} (spill) at ./file.go:221:23 +./file.go:221:23: from &KeyError{...} (interface-converted) at ./file.go:221:23 +./file.go:221:23: from ~r0 = &KeyError{...} (assign-pair) at ./file.go:221:23 +./file.go:221:23: flow: err ← ~r0: +./file.go:221:23: from err := ~r0 (assign) at ./file.go:221:9 +./file.go:221:23: flow: ~r0 ← err: +./file.go:221:23: from return err (return) at ./file.go:222:3 +./file.go:224:22: &KeyError{...} escapes to heap in (*File).RenameSection: +./file.go:224:22: flow: ~r0 ← &{storage for &KeyError{...}}: +./file.go:224:22: from &KeyError{...} (spill) at ./file.go:224:22 +./file.go:224:22: from &KeyError{...} (interface-converted) at ./file.go:224:22 +./file.go:224:22: from ~r0 = &KeyError{...} (assign-pair) at ./file.go:224:22 +./file.go:224:22: flow: err ← ~r0: +./file.go:224:22: from err := ~r0 (assign) at ./file.go:224:9 +./file.go:224:22: flow: ~r0 ← err: +./file.go:224:22: from return err (return) at ./file.go:225:3 +./file.go:227:22: &KeyError{...} escapes to heap in (*File).RenameSection: +./file.go:227:22: flow: ~r0 ← &{storage for &KeyError{...}}: +./file.go:227:22: from &KeyError{...} (spill) at ./file.go:227:22 +./file.go:227:22: from &KeyError{...} (interface-converted) at ./file.go:227:22 +./file.go:227:22: from ~r0 = &KeyError{...} (assign-pair) at ./file.go:227:22 +./file.go:227:22: flow: err ← ~r0: +./file.go:227:22: from err := ~r0 (assign) at ./file.go:227:9 +./file.go:227:22: flow: ~r0 ← err: +./file.go:227:22: from return err (return) at ./file.go:228:3 +./file.go:220:39: parameter newName leaks to {storage for &KeyError{...}} for (*File).RenameSection with derefs=0: +./file.go:220:39: flow: section ← newName: +./file.go:220:39: from section := newName (assign-pair) at ./file.go:227:22 +./file.go:220:39: flow: {storage for &KeyError{...}} ← section: +./file.go:220:39: from KeyError{...} (struct literal element) at ./file.go:227:22 +./file.go:220:30: parameter oldName leaks to {storage for &KeyError{...}} for (*File).RenameSection with derefs=0: +./file.go:220:30: flow: section ← oldName: +./file.go:220:30: from section := oldName (assign-pair) at ./file.go:224:22 +./file.go:220:30: flow: {storage for &KeyError{...}} ← section: +./file.go:220:30: from KeyError{...} (struct literal element) at ./file.go:224:22 +./file.go:220:30: parameter oldName leaks to {storage for &KeyError{...}} for (*File).RenameSection with derefs=0: +./file.go:220:30: flow: key ← oldName: +./file.go:220:30: from f, key := f, oldName (assign-pair) at ./file.go:221:23 +./file.go:220:30: flow: {storage for &KeyError{...}} ← key: +./file.go:220:30: from KeyError{...} (struct literal element) at ./file.go:221:23 +./file.go:220:7: leaking param content: f +./file.go:220:30: leaking param: oldName +./file.go:220:39: leaking param: newName +./file.go:221:23: &KeyError{...} escapes to heap +./file.go:224:22: &KeyError{...} escapes to heap +./file.go:227:22: &KeyError{...} escapes to heap +./file.go:230:38: ([]byte)(s) does not escape +./file.go:230:38: string(b) escapes to heap +./file.go:231:64: ([]byte)(s) does not escape +./file.go:231:64: string(b) escapes to heap +./file.go:240:33: parameter section leaks to {heap} for (*File).RenameSubsection with derefs=0: +./file.go:240:33: flow: {heap} ← section: +./file.go:240:33: from (*File).renameSection(f, section, sectionKey{...}, sectionKey{...}, formatHeader(section, newSub, true)) (call parameter) at ./file.go:253:24 +./file.go:240:50: parameter newSub leaks to {heap} for (*File).RenameSubsection with derefs=0: +./file.go:240:50: flow: {heap} ← newSub: +./file.go:240:50: from sectionKey{...} (struct literal element) at ./file.go:253:75 +./file.go:240:50: from (*File).renameSection(f, section, sectionKey{...}, sectionKey{...}, formatHeader(section, newSub, true)) (call parameter) at ./file.go:253:24 +./file.go:240:7: parameter f leaks to {heap} for (*File).RenameSubsection with derefs=1: +./file.go:240:7: flow: {temp} ← f: +./file.go:240:7: from (*File).renameSection(f, section, sectionKey{...}, sectionKey{...}, formatHeader(section, newSub, true)) (call parameter) at ./file.go:253:24 +./file.go:240:7: flow: {heap} ← *{temp}: +./file.go:252:19: string(b) escapes to heap in (*File).RenameSubsection: +./file.go:252:19: flow: ~r0 ← &{storage for string(b)}: +./file.go:252:19: from string(b) (spill) at ./file.go:252:19 +./file.go:252:19: from ~r0 = string(b) (assign-pair) at ./file.go:252:19 +./file.go:252:19: flow: sec ← ~r0: +./file.go:252:19: from sec := ~r0 (assign) at ./file.go:252:6 +./file.go:252:19: flow: {heap} ← sec: +./file.go:252:19: from sectionKey{...} (struct literal element) at ./file.go:253:75 +./file.go:252:19: from (*File).renameSection(f, section, sectionKey{...}, sectionKey{...}, formatHeader(section, newSub, true)) (call parameter) at ./file.go:253:24 +./file.go:249:11: &KeyError{...} escapes to heap in (*File).RenameSubsection: +./file.go:249:11: flow: ~r0 ← &{storage for &KeyError{...}}: +./file.go:249:11: from &KeyError{...} (spill) at ./file.go:249:11 +./file.go:249:11: from &KeyError{...} (interface-converted) at ./file.go:249:11 +./file.go:249:11: from return &KeyError{...} (return) at ./file.go:249:4 +./file.go:241:23: &KeyError{...} escapes to heap in (*File).RenameSubsection: +./file.go:241:23: flow: ~r0 ← &{storage for &KeyError{...}}: +./file.go:241:23: from &KeyError{...} (spill) at ./file.go:241:23 +./file.go:241:23: from &KeyError{...} (interface-converted) at ./file.go:241:23 +./file.go:241:23: from ~r0 = &KeyError{...} (assign-pair) at ./file.go:241:23 +./file.go:241:23: flow: err ← ~r0: +./file.go:241:23: from err := ~r0 (assign) at ./file.go:241:9 +./file.go:241:23: flow: ~r0 ← err: +./file.go:241:23: from return err (return) at ./file.go:242:3 +./file.go:244:22: &KeyError{...} escapes to heap in (*File).RenameSubsection: +./file.go:244:22: flow: ~r0 ← &{storage for &KeyError{...}}: +./file.go:244:22: from &KeyError{...} (spill) at ./file.go:244:22 +./file.go:244:22: from &KeyError{...} (interface-converted) at ./file.go:244:22 +./file.go:244:22: from ~r0 = &KeyError{...} (assign-pair) at ./file.go:244:22 +./file.go:244:22: flow: err ← ~r0: +./file.go:244:22: from err := ~r0 (assign) at ./file.go:244:9 +./file.go:244:22: flow: ~r0 ← err: +./file.go:244:22: from return err (return) at ./file.go:245:3 +./file.go:240:42: parameter oldSub leaks to {storage for &KeyError{...}} for (*File).RenameSubsection with derefs=0: +./file.go:240:42: flow: {storage for []string{...}} ← oldSub: +./file.go:240:42: from []string{...} (slice-literal-element) at ./file.go:247:30 +./file.go:240:42: flow: {temp} ← &{storage for []string{...}}: +./file.go:240:42: from []string{...} (spill) at ./file.go:247:30 +./file.go:240:42: flow: sub ← *{temp}: +./file.go:240:42: from for loop (range-deref) at ./file.go:247:16 +./file.go:240:42: flow: {storage for &KeyError{...}} ← sub: +./file.go:240:42: from KeyError{...} (struct literal element) at ./file.go:249:20 +./file.go:240:50: parameter newSub leaks to {storage for &KeyError{...}} for (*File).RenameSubsection with derefs=0: +./file.go:240:50: flow: {storage for []string{...}} ← newSub: +./file.go:240:50: from []string{...} (slice-literal-element) at ./file.go:247:30 +./file.go:240:50: flow: {temp} ← &{storage for []string{...}}: +./file.go:240:50: from []string{...} (spill) at ./file.go:247:30 +./file.go:240:50: flow: sub ← *{temp}: +./file.go:240:50: from for loop (range-deref) at ./file.go:247:16 +./file.go:240:50: flow: {storage for &KeyError{...}} ← sub: +./file.go:240:50: from KeyError{...} (struct literal element) at ./file.go:249:20 +./file.go:240:33: parameter section leaks to {storage for &KeyError{...}} for (*File).RenameSubsection with derefs=0: +./file.go:240:33: flow: section ← section: +./file.go:240:33: from section := section (assign-pair) at ./file.go:244:22 +./file.go:240:33: flow: {storage for &KeyError{...}} ← section: +./file.go:240:33: from KeyError{...} (struct literal element) at ./file.go:244:22 +./file.go:240:33: parameter section leaks to {storage for &KeyError{...}} for (*File).RenameSubsection with derefs=0: +./file.go:240:33: flow: key ← section: +./file.go:240:33: from f, key := f, section (assign-pair) at ./file.go:241:23 +./file.go:240:33: flow: {storage for &KeyError{...}} ← key: +./file.go:240:33: from KeyError{...} (struct literal element) at ./file.go:241:23 +./file.go:240:7: leaking param content: f +./file.go:240:33: leaking param: section +./file.go:240:42: leaking param: oldSub +./file.go:240:50: leaking param: newSub +./file.go:241:23: &KeyError{...} escapes to heap +./file.go:244:22: &KeyError{...} escapes to heap +./file.go:247:30: []string{...} does not escape +./file.go:249:11: &KeyError{...} escapes to heap +./file.go:252:19: ([]byte)(s) does not escape +./file.go:252:19: string(b) escapes to heap +./glob.go:216:9: &stateSet{...} escapes to heap in newStateSet: +./glob.go:216:9: flow: ~r0 ← &{storage for &stateSet{...}}: +./glob.go:216:9: from &stateSet{...} (spill) at ./glob.go:216:9 +./glob.go:216:9: from return &stateSet{...} (return) at ./glob.go:216:2 +./glob.go:216:29: make([]uint32, size) escapes to heap in newStateSet: +./glob.go:216:29: flow: {storage for &stateSet{...}} ← &{storage for make([]uint32, size)}: +./glob.go:216:29: from make([]uint32, size) (spill) at ./glob.go:216:29 +./glob.go:216:29: from stateSet{...} (struct literal element) at ./glob.go:216:18 +./glob.go:216:9: &stateSet{...} escapes to heap +./glob.go:216:29: make([]uint32, size) escapes to heap +./glob.go:220:10: (*stateSet).reset ignoring self-assignment in ss.list = ss.list[:0] +./glob.go:219:7: ss does not escape +./glob.go:230:18: append(ss.list, id) escapes to heap in (*stateSet).add: +./glob.go:230:18: flow: {heap} ← &{storage for append(ss.list, id)}: +./glob.go:230:18: from append(ss.list, id) (spill) at ./glob.go:230:18 +./glob.go:230:18: from ss.list = append(ss.list, id) (assign) at ./glob.go:230:10 +./glob.go:225:7: parameter ss leaks to {heap} for (*stateSet).add with derefs=1: +./glob.go:225:7: flow: {temp} ← *ss: +./glob.go:225:7: from ss.list (dot of pointer) at ./glob.go:230:21 +./glob.go:225:7: from append(ss.list, id) (call parameter) at ./glob.go:230:18 +./glob.go:225:7: flow: {heap} ← {temp}: +./glob.go:225:7: from ss.list = append(ss.list, id) (assign) at ./glob.go:230:10 +./glob.go:225:7: leaking param content: ss +./glob.go:230:18: append escapes to heap +./glob.go:234:7: ss does not escape +./key.go:56:47: k.Section + "." + k.Subsection + "." + k.Name escapes to heap in Key.String: +./key.go:56:47: flow: ~r0 ← &{storage for k.Section + "." + k.Subsection + "." + k.Name}: +./key.go:56:47: from k.Section + "." + k.Subsection + "." + k.Name (spill) at ./key.go:56:47 +./key.go:56:47: from return k.Section + "." + k.Subsection + "." + k.Name (return) at ./key.go:56:3 +./key.go:58:25: k.Section + "." + k.Name escapes to heap in Key.String: +./key.go:58:25: flow: ~r0 ← &{storage for k.Section + "." + k.Name}: +./key.go:58:25: from k.Section + "." + k.Name (spill) at ./key.go:58:25 +./key.go:58:25: from return k.Section + "." + k.Name (return) at ./key.go:58:2 +./key.go:54:7: k does not escape +./key.go:56:47: k.Section + "." + k.Subsection + "." + k.Name escapes to heap +./key.go:58:25: k.Section + "." + k.Name escapes to heap +./key.go:84:16: s does not escape +./key.go:98:19: s does not escape +./key.go:109:22: s does not escape +./key.go:124:18: string(b) escapes to heap in lowerASCII: +./key.go:124:18: flow: ~r0 ← &{storage for string(b)}: +./key.go:124:18: from string(b) (spill) at ./key.go:124:18 +./key.go:124:18: from return string(b) (return) at ./key.go:124:4 +./key.go:115:17: parameter s leaks to ~r0 for lowerASCII with derefs=0: +./key.go:115:17: flow: ~r0 ← s: +./key.go:115:17: from return s (return) at ./key.go:127:2 +./key.go:115:17: leaking param: s to result ~r0 level=0 +./key.go:118:16: ([]byte)(s) does not escape +./key.go:124:18: string(b) escapes to heap +./load.go:53:7: parameter r leaks to ~r0 for (*repo).localConfig with derefs=1: +./load.go:53:7: flow: {storage for ... argument} ← *r: +./load.go:53:7: from r.commonDir (dot of pointer) at ./load.go:54:24 +./load.go:53:7: from ... argument (slice-literal-element) at ./load.go:54:22 +./load.go:53:7: flow: filepath.elem ← &{storage for ... argument}: +./load.go:53:7: from ... argument (spill) at ./load.go:54:22 +./load.go:53:7: from filepath.elem := ... argument (assign-pair) at ./load.go:54:22 +./load.go:53:7: flow: {temp} ← filepath.elem: +./load.go:53:7: from filepath.join(filepath.elem) (call parameter) at ./load.go:54:22 +./load.go:53:7: flow: ~r0 ← *{temp}: +./load.go:53:7: from ~r0 = filepath.join(filepath.elem) (assign-pair) at ./load.go:54:22 +./load.go:53:7: flow: ~r0 ← ~r0: +./load.go:53:7: from return ~r0 (return) at ./load.go:54:2 +./load.go:53:7: leaking param: r to result ~r0 level=1 +./load.go:54:22: ... argument does not escape +./load.go:57:7: parameter r leaks to ~r0 for (*repo).worktreeConfig with derefs=1: +./load.go:57:7: flow: {storage for ... argument} ← *r: +./load.go:57:7: from r.gitDir (dot of pointer) at ./load.go:58:24 +./load.go:57:7: from ... argument (slice-literal-element) at ./load.go:58:22 +./load.go:57:7: flow: filepath.elem ← &{storage for ... argument}: +./load.go:57:7: from ... argument (spill) at ./load.go:58:22 +./load.go:57:7: from filepath.elem := ... argument (assign-pair) at ./load.go:58:22 +./load.go:57:7: flow: {temp} ← filepath.elem: +./load.go:57:7: from filepath.join(filepath.elem) (call parameter) at ./load.go:58:22 +./load.go:57:7: flow: ~r0 ← *{temp}: +./load.go:57:7: from ~r0 = filepath.join(filepath.elem) (assign-pair) at ./load.go:58:22 +./load.go:57:7: flow: ~r0 ← ~r0: +./load.go:57:7: from return ~r0 (return) at ./load.go:58:2 +./load.go:57:7: leaking param: r to result ~r0 level=1 +./load.go:58:22: ... argument does not escape +./load.go:122:16: parameter path leaks to {heap} for readSmall with derefs=0: +./load.go:122:16: flow: {heap} ← path: +./load.go:122:16: from readConfigFile(path, int64(4096)) (call parameter) at ./load.go:123:23 +./load.go:122:16: leaking param: path +./load.go:188:7: parameter l leaks to {heap} for (*loader).config with derefs=1: +./load.go:188:7: flow: {heap} ← *l: +./load.go:188:7: from l.entries (dot of pointer) at ./load.go:189:20 +./load.go:188:7: from newConfig(l.entries) (call parameter) at ./load.go:189:18 +./load.go:188:7: leaking param content: l +./load.go:282:10: &KeyError{...} escapes to heap in (*loader).fail: +./load.go:282:10: flow: ~r0 ← &{storage for &KeyError{...}}: +./load.go:282:10: from &KeyError{...} (spill) at ./load.go:282:10 +./load.go:282:10: from &KeyError{...} (interface-converted) at ./load.go:282:10 +./load.go:282:10: from return &KeyError{...} (return) at ./load.go:282:3 +./load.go:284:9: &FileError{...} escapes to heap in (*loader).fail: +./load.go:284:9: flow: ~r0 ← &{storage for &FileError{...}}: +./load.go:284:9: from &FileError{...} (spill) at ./load.go:284:9 +./load.go:284:9: from &FileError{...} (interface-converted) at ./load.go:284:9 +./load.go:284:9: from return &FileError{...} (return) at ./load.go:284:2 +./load.go:280:23: parameter from leaks to {storage for &FileError{...}} for (*loader).fail with derefs=0: +./load.go:280:23: flow: {storage for &FileError{...}} ← from: +./load.go:280:23: from FileError{...} (struct literal element) at ./load.go:284:19 +./load.go:284:37: &SyntaxError{...} escapes to heap in (*loader).fail: +./load.go:284:37: flow: {storage for &FileError{...}} ← &{storage for &SyntaxError{...}}: +./load.go:284:37: from &SyntaxError{...} (spill) at ./load.go:284:37 +./load.go:284:37: from &SyntaxError{...} (interface-converted) at ./load.go:284:37 +./load.go:284:37: from FileError{...} (struct literal element) at ./load.go:284:19 +./load.go:280:23: parameter from leaks to {storage for &SyntaxError{...}} for (*loader).fail with derefs=0: +./load.go:280:23: flow: {storage for &SyntaxError{...}} ← from: +./load.go:280:23: from SyntaxError{...} (struct literal element) at ./load.go:284:49 +./load.go:280:45: parameter msg leaks to {storage for &SyntaxError{...}} for (*loader).fail with derefs=0: +./load.go:280:45: flow: {storage for &SyntaxError{...}} ← msg: +./load.go:280:45: from SyntaxError{...} (struct literal element) at ./load.go:284:49 +./load.go:282:37: k.Section + "." + k.Subsection + "." + k.Name escapes to heap in (*loader).fail: +./load.go:282:37: flow: ~r0 ← &{storage for k.Section + "." + k.Subsection + "." + k.Name}: +./load.go:282:37: from k.Section + "." + k.Subsection + "." + k.Name (spill) at ./load.go:282:37 +./load.go:282:37: from ~r0 = k.Section + "." + k.Subsection + "." + k.Name (assign-pair) at ./load.go:282:37 +./load.go:282:37: flow: {storage for &KeyError{...}} ← ~r0: +./load.go:282:37: from KeyError{...} (struct literal element) at ./load.go:282:19 +./load.go:282:37: k.Section + "." + k.Name escapes to heap in (*loader).fail: +./load.go:282:37: flow: ~r0 ← &{storage for k.Section + "." + k.Name}: +./load.go:282:37: from k.Section + "." + k.Name (spill) at ./load.go:282:37 +./load.go:282:37: from ~r0 = k.Section + "." + k.Name (assign-pair) at ./load.go:282:37 +./load.go:282:37: flow: {storage for &KeyError{...}} ← ~r0: +./load.go:282:37: from KeyError{...} (struct literal element) at ./load.go:282:19 +./load.go:282:56: &errors.errorString{...} escapes to heap in (*loader).fail: +./load.go:282:56: flow: ~r0 ← &{storage for &errors.errorString{...}}: +./load.go:282:56: from &errors.errorString{...} (spill) at ./load.go:282:56 +./load.go:282:56: from &errors.errorString{...} (interface-converted) at ./load.go:282:56 +./load.go:282:56: from ~r0 = &errors.errorString{...} (assign-pair) at ./load.go:282:56 +./load.go:282:56: flow: {storage for &KeyError{...}} ← ~r0: +./load.go:282:56: from KeyError{...} (struct literal element) at ./load.go:282:19 +./load.go:282:71: "gitconfig: " + msg escapes to heap in (*loader).fail: +./load.go:282:71: flow: errors.text ← &{storage for "gitconfig: " + msg}: +./load.go:282:71: from "gitconfig: " + msg (spill) at ./load.go:282:71 +./load.go:282:71: from errors.text := "gitconfig: " + msg (assign-pair) at ./load.go:282:56 +./load.go:282:71: flow: {storage for &errors.errorString{...}} ← errors.text: +./load.go:282:71: from errors.errorString{...} (struct literal element) at ./load.go:282:56 +./load.go:280:7: l does not escape +./load.go:280:23: leaking param: from +./load.go:280:36: e does not escape +./load.go:280:45: leaking param: msg +./load.go:282:10: &KeyError{...} escapes to heap +./load.go:282:37: k.Section + "." + k.Subsection + "." + k.Name escapes to heap +./load.go:282:37: k.Section + "." + k.Name escapes to heap +./load.go:282:71: "gitconfig: " + msg escapes to heap +./load.go:282:56: &errors.errorString{...} escapes to heap +./load.go:284:9: &FileError{...} escapes to heap +./load.go:284:37: &SyntaxError{...} escapes to heap +./load.go:290:16: parameter path leaks to ~r0 for dirPrefix with derefs=0: +./load.go:290:16: flow: ~r0 ← path: +./load.go:290:16: from path[:i + 1] (slice) at ./load.go:295:13 +./load.go:290:16: from return path[:i + 1] (return) at ./load.go:295:2 +./load.go:290:16: leaking param: path to result ~r0 level=0 +./load.go:366:19: p does not escape +./parse.go:51:7: parameter p leaks to ~r0 for (*parsed).secOf with derefs=2: +./parse.go:51:7: flow: ~r0 ← **p: +./parse.go:51:7: from p.secs (dot of pointer) at ./parse.go:51:54 +./parse.go:51:7: from p.secs[it.sec] (dot of pointer) at ./parse.go:51:59 +./parse.go:51:7: from return p.secs[it.sec] (return) at ./parse.go:51:46 +./parse.go:51:7: leaking param: p to result ~r0 level=2 +./parse.go:55:39: parameter file leaks to {heap} for (*parsed).entries with derefs=0: +./parse.go:55:39: flow: {heap} ← file: +./parse.go:55:39: from Origin{...} (struct literal element) at ./parse.go:66:20 +./parse.go:55:39: from Entry{...} (struct literal element) at ./parse.go:62:26 +./parse.go:55:39: from append(out, Entry{...}) (call parameter) at ./parse.go:62:15 +./parse.go:55:52: parameter out leaks to {heap} for (*parsed).entries with derefs=1: +./parse.go:55:52: flow: {temp} ← out: +./parse.go:55:52: from append(out, Entry{...}) (call parameter) at ./parse.go:62:15 +./parse.go:55:52: flow: {heap} ← *{temp}: +./parse.go:55:52: from append(out, Entry{...}) (appendee slice) at ./parse.go:62:15 +./parse.go:55:7: parameter p leaks to {heap} for (*parsed).entries with derefs=2: +./parse.go:55:7: flow: sec ← **p: +./parse.go:55:7: from p.secs (dot of pointer) at ./parse.go:60:11 +./parse.go:55:7: from p.secs[it.sec] (dot of pointer) at ./parse.go:60:16 +./parse.go:55:7: from sec := p.secs[it.sec] (assign) at ./parse.go:60:7 +./parse.go:55:7: flow: {heap} ← sec: +./parse.go:55:7: from sec.section (dot) at ./parse.go:63:30 +./parse.go:55:7: from Key{...} (struct literal element) at ./parse.go:63:17 +./parse.go:55:7: from Entry{...} (struct literal element) at ./parse.go:62:26 +./parse.go:55:7: from append(out, Entry{...}) (call parameter) at ./parse.go:62:15 +./parse.go:55:52: parameter out leaks to ~r0 for (*parsed).entries with derefs=0: +./parse.go:55:52: flow: ~r0 ← out: +./parse.go:55:52: from return out (return) at ./parse.go:69:2 +./parse.go:62:15: append(out, Entry{...}) escapes to heap in (*parsed).entries: +./parse.go:62:15: flow: out ← &{storage for append(out, Entry{...})}: +./parse.go:62:15: from append(out, Entry{...}) (spill) at ./parse.go:62:15 +./parse.go:62:15: from out = append(out, Entry{...}) (assign) at ./parse.go:62:7 +./parse.go:62:15: flow: ~r0 ← out: +./parse.go:62:15: from return out (return) at ./parse.go:69:2 +./parse.go:55:7: leaking param content: p +./parse.go:55:39: leaking param: file +./parse.go:55:52: leaking param content: out +./parse.go:55:52: leaking param: out to result ~r0 level=0 +./parse.go:62:15: append escapes to heap +./parse.go:71:7: parameter p leaks to ~r0 for (*parsed).nameOf with derefs=2: +./parse.go:71:7: flow: ~r0 ← **p: +./parse.go:71:7: from p.texts (dot of pointer) at ./parse.go:71:52 +./parse.go:71:7: from p.texts[it.text] (dot of pointer) at ./parse.go:71:58 +./parse.go:71:7: from p.texts[it.text].name (dot) at ./parse.go:71:67 +./parse.go:71:7: from return p.texts[it.text].name (return) at ./parse.go:71:44 +./parse.go:71:7: leaking param: p to result ~r0 level=2 +./parse.go:72:7: parameter p leaks to ~r0 for (*parsed).valueOf with derefs=2: +./parse.go:72:7: flow: ~r0 ← **p: +./parse.go:72:7: from p.texts (dot of pointer) at ./parse.go:72:52 +./parse.go:72:7: from p.texts[it.text] (dot of pointer) at ./parse.go:72:58 +./parse.go:72:7: from p.texts[it.text].value (dot) at ./parse.go:72:67 +./parse.go:72:7: from return p.texts[it.text].value (return) at ./parse.go:72:44 +./parse.go:72:7: leaking param: p to result ~r0 level=2 +./parse.go:113:9: &SyntaxError{...} escapes to heap in (*parser).errorAt: +./parse.go:113:9: flow: ~r0 ← &{storage for &SyntaxError{...}}: +./parse.go:113:9: from &SyntaxError{...} (spill) at ./parse.go:113:9 +./parse.go:113:9: from &SyntaxError{...} (interface-converted) at ./parse.go:113:9 +./parse.go:113:9: from return &SyntaxError{...} (return) at ./parse.go:113:2 +./parse.go:112:7: parameter p leaks to {storage for &SyntaxError{...}} for (*parser).errorAt with derefs=1: +./parse.go:112:7: flow: {storage for &SyntaxError{...}} ← *p: +./parse.go:112:7: from p.name (dot of pointer) at ./parse.go:113:29 +./parse.go:112:7: from SyntaxError{...} (struct literal element) at ./parse.go:113:21 +./parse.go:112:36: parameter msg leaks to {storage for &SyntaxError{...}} for (*parser).errorAt with derefs=0: +./parse.go:112:36: flow: {storage for &SyntaxError{...}} ← msg: +./parse.go:112:36: from SyntaxError{...} (struct literal element) at ./parse.go:113:21 +./parse.go:112:7: leaking param content: p +./parse.go:112:36: leaking param: msg +./parse.go:113:9: &SyntaxError{...} escapes to heap +./parse.go:117:18: append(p.parsed.items, item{...}) escapes to heap in (*parser).add: +./parse.go:117:18: flow: {heap} ← &{storage for append(p.parsed.items, item{...})}: +./parse.go:117:18: from append(p.parsed.items, item{...}) (spill) at ./parse.go:117:18 +./parse.go:117:18: from p.parsed.items = append(p.parsed.items, item{...}) (assign) at ./parse.go:117:10 +./parse.go:116:7: parameter p leaks to {heap} for (*parser).add with derefs=1: +./parse.go:116:7: flow: {temp} ← *p: +./parse.go:116:7: from p.parsed (dot of pointer) at ./parse.go:117:20 +./parse.go:116:7: from p.parsed.items (dot) at ./parse.go:117:20 +./parse.go:116:7: from append(p.parsed.items, item{...}) (call parameter) at ./parse.go:117:18 +./parse.go:116:7: flow: {heap} ← {temp}: +./parse.go:116:7: from p.parsed.items = append(p.parsed.items, item{...}) (assign) at ./parse.go:117:10 +./parse.go:116:7: parameter p leaks to ~r0 for (*parser).add with derefs=1: +./parse.go:116:7: flow: ~r0 ← *p: +./parse.go:116:7: from p.parsed (dot of pointer) at ./parse.go:118:11 +./parse.go:116:7: from p.parsed.items (dot) at ./parse.go:118:11 +./parse.go:116:7: from p.parsed.items[len(p.parsed.items) - 1] (dot of pointer) at ./parse.go:118:17 +./parse.go:116:7: from &p.parsed.items[len(p.parsed.items) - 1] (address-of) at ./parse.go:118:9 +./parse.go:116:7: from return &p.parsed.items[len(p.parsed.items) - 1] (return) at ./parse.go:118:2 +./parse.go:116:7: leaking param content: p +./parse.go:117:18: append escapes to heap +./parse.go:139:18: append(p.parsed.secs, sec) escapes to heap in (*parser).setSection: +./parse.go:139:18: flow: {heap} ← &{storage for append(p.parsed.secs, sec)}: +./parse.go:139:18: from append(p.parsed.secs, sec) (spill) at ./parse.go:139:18 +./parse.go:139:18: from p.parsed.secs = append(p.parsed.secs, sec) (assign) at ./parse.go:139:10 +./parse.go:135:29: parameter sec leaks to {heap} for (*parser).setSection with derefs=0: +./parse.go:135:29: flow: {heap} ← sec: +./parse.go:135:29: from append(p.parsed.secs, sec) (call parameter) at ./parse.go:139:18 +./parse.go:135:7: parameter p leaks to {heap} for (*parser).setSection with derefs=1: +./parse.go:135:7: flow: {temp} ← *p: +./parse.go:135:7: from p.parsed (dot of pointer) at ./parse.go:139:20 +./parse.go:135:7: from p.parsed.secs (dot) at ./parse.go:139:20 +./parse.go:135:7: from append(p.parsed.secs, sec) (call parameter) at ./parse.go:139:18 +./parse.go:135:7: flow: {temp} ← {temp}: +./parse.go:135:7: flow: {heap} ← {temp}: +./parse.go:135:7: from p.parsed.secs = append(p.parsed.secs, sec) (assign) at ./parse.go:139:10 +./parse.go:135:7: leaking param content: p +./parse.go:135:29: leaking param: sec +./parse.go:139:18: append escapes to heap +./parse.go:148:14: data does not escape +./parse.go:159:16: data does not escape +./parse.go:164:17: data does not escape +./platform.go:14:18: parameter path leaks to {heap} for openRegular with derefs=0: +./platform.go:14:18: flow: {heap} ← path: +./platform.go:14:18: from os.OpenFile(path, flag, fs.FileMode(0)) (call parameter) at ./platform.go:19:20 +./platform.go:14:18: leaking param: path +./value.go:137:21: s does not escape +./value.go:137:24: t does not escape +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:7: parameter atomic.x leaks to {heap} for (*Pointer[go.shape.struct { os.mu sync.Mutex; os.buf *[]uint8; os.nbuf int; os.bufp int }]).CompareAndSwap with derefs=0: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:7: flow: {heap} ← atomic.x: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:7: from atomic.x.v (dot of pointer) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:68:33 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:7: from &atomic.x.v (address-of) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:68:31 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:7: from atomic.CompareAndSwapPointer(&atomic.x.v, unsafe.Pointer(atomic.old), unsafe.Pointer(atomic.new)) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:68:30 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:37: parameter atomic.old leaks to {heap} for (*Pointer[go.shape.struct { os.mu sync.Mutex; os.buf *[]uint8; os.nbuf int; os.bufp int }]).CompareAndSwap with derefs=0: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:37: flow: {heap} ← atomic.old: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:37: from atomic.CompareAndSwapPointer(&atomic.x.v, unsafe.Pointer(atomic.old), unsafe.Pointer(atomic.new)) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:68:30 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:42: parameter atomic.new leaks to {heap} for (*Pointer[go.shape.struct { os.mu sync.Mutex; os.buf *[]uint8; os.nbuf int; os.bufp int }]).CompareAndSwap with derefs=0: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:42: flow: {heap} ← atomic.new: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:42: from atomic.CompareAndSwapPointer(&atomic.x.v, unsafe.Pointer(atomic.old), unsafe.Pointer(atomic.new)) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:68:30 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:64:7: parameter atomic.x leaks to {heap} for (*Pointer[go.shape.struct { os.mu sync.Mutex; os.buf *[]uint8; os.nbuf int; os.bufp int }]).Swap with derefs=0: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:64:7: flow: {heap} ← atomic.x: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:64:7: from atomic.x.v (dot of pointer) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:64:72 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:64:7: from &atomic.x.v (address-of) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:64:70 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:64:7: from atomic.SwapPointer(&atomic.x.v, unsafe.Pointer(atomic.new)) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:64:69 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:64:27: parameter atomic.new leaks to {heap} for (*Pointer[go.shape.struct { os.mu sync.Mutex; os.buf *[]uint8; os.nbuf int; os.bufp int }]).Swap with derefs=0: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:64:27: flow: {heap} ← atomic.new: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:64:27: from atomic.SwapPointer(&atomic.x.v, unsafe.Pointer(atomic.new)) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:64:69 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:61:7: parameter atomic.x leaks to {heap} for (*Pointer[go.shape.struct { os.mu sync.Mutex; os.buf *[]uint8; os.nbuf int; os.bufp int }]).Store with derefs=0: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:61:7: flow: {heap} ← atomic.x: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:61:7: from atomic.x.v (dot of pointer) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:61:53 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:61:7: from &atomic.x.v (address-of) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:61:51 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:61:7: from atomic.StorePointer(&atomic.x.v, unsafe.Pointer(atomic.val)) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:61:50 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:61:28: parameter atomic.val leaks to {heap} for (*Pointer[go.shape.struct { os.mu sync.Mutex; os.buf *[]uint8; os.nbuf int; os.bufp int }]).Store with derefs=0: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:61:28: flow: {heap} ← atomic.val: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:61:28: from atomic.StorePointer(&atomic.x.v, unsafe.Pointer(atomic.val)) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:61:50 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:58:7: parameter atomic.x leaks to {heap} for (*Pointer[go.shape.struct { os.mu sync.Mutex; os.buf *[]uint8; os.nbuf int; os.bufp int }]).Load with derefs=0: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:58:7: flow: {heap} ← atomic.x: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:58:7: from atomic.x.v (dot of pointer) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:58:60 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:58:7: from &atomic.x.v (address-of) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:58:58 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:58:7: from atomic.LoadPointer(&atomic.x.v) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:58:57 +:1: parameter p leaks to {heap} for .eq.SI with derefs=1: +:1: flow: {heap} ← *p: +:1: from unsafe.Add(p, uintptr(0)) (call parameter) at :1 +:1: from *(*unsafe.Pointer)(unsafe.Add(p, uintptr(0))) (indirection) at :1 +:1: from runtime.memequal(*(*unsafe.Pointer)(unsafe.Add(p, uintptr(0))), *(*unsafe.Pointer)(unsafe.Add(q, uintptr(0))), *(*uintptr)(unsafe.Add(p, uintptr(8)))) (call parameter) at :1 +:1: parameter q leaks to {heap} for .eq.SI with derefs=1: +:1: flow: {heap} ← *q: +:1: from unsafe.Add(q, uintptr(0)) (call parameter) at :1 +:1: from *(*unsafe.Pointer)(unsafe.Add(q, uintptr(0))) (indirection) at :1 +:1: from runtime.memequal(*(*unsafe.Pointer)(unsafe.Add(p, uintptr(0))), *(*unsafe.Pointer)(unsafe.Add(q, uintptr(0))), *(*uintptr)(unsafe.Add(p, uintptr(8)))) (call parameter) at :1 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:7: parameter atomic.x leaks to {heap} for (*Pointer[os.dirInfo]).CompareAndSwap with derefs=0: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:7: flow: atomic.x ← atomic.x: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:7: from atomic.x, atomic..dict, atomic.old, atomic.new := atomic.x, &atomic..dict.Pointer[os.dirInfo], atomic.old, atomic.new (assign-pair) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:6 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:7: flow: {heap} ← atomic.x: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:7: from atomic.x.v (dot of pointer) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:6 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:7: from &atomic.x.v (address-of) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:6 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:7: from atomic.CompareAndSwapPointer(&atomic.x.v, unsafe.Pointer(atomic.old), unsafe.Pointer(atomic.new)) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:6 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:37: parameter atomic.old leaks to {heap} for (*Pointer[os.dirInfo]).CompareAndSwap with derefs=0: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:37: flow: atomic.old ← atomic.old: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:37: from atomic.x, atomic..dict, atomic.old, atomic.new := atomic.x, &atomic..dict.Pointer[os.dirInfo], atomic.old, atomic.new (assign-pair) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:6 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:37: flow: {heap} ← atomic.old: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:37: from atomic.CompareAndSwapPointer(&atomic.x.v, unsafe.Pointer(atomic.old), unsafe.Pointer(atomic.new)) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:6 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:42: parameter atomic.new leaks to {heap} for (*Pointer[os.dirInfo]).CompareAndSwap with derefs=0: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:42: flow: atomic.new ← atomic.new: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:42: from atomic.x, atomic..dict, atomic.old, atomic.new := atomic.x, &atomic..dict.Pointer[os.dirInfo], atomic.old, atomic.new (assign-pair) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:6 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:42: flow: {heap} ← atomic.new: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:42: from atomic.CompareAndSwapPointer(&atomic.x.v, unsafe.Pointer(atomic.old), unsafe.Pointer(atomic.new)) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:6 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:64:7: parameter atomic.x leaks to {heap} for (*Pointer[os.dirInfo]).Swap with derefs=0: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:64:7: flow: atomic.x ← atomic.x: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:64:7: from atomic.x, atomic..dict, atomic.new := atomic.x, &atomic..dict.Pointer[os.dirInfo], atomic.new (assign-pair) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:64:6 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:64:7: flow: {heap} ← atomic.x: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:64:7: from atomic.x.v (dot of pointer) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:64:6 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:64:7: from &atomic.x.v (address-of) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:64:6 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:64:7: from atomic.SwapPointer(&atomic.x.v, unsafe.Pointer(atomic.new)) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:64:6 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:64:27: parameter atomic.new leaks to {heap} for (*Pointer[os.dirInfo]).Swap with derefs=0: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:64:27: flow: atomic.new ← atomic.new: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:64:27: from atomic.x, atomic..dict, atomic.new := atomic.x, &atomic..dict.Pointer[os.dirInfo], atomic.new (assign-pair) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:64:6 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:64:27: flow: {heap} ← atomic.new: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:64:27: from atomic.SwapPointer(&atomic.x.v, unsafe.Pointer(atomic.new)) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:64:6 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:61:7: parameter atomic.x leaks to {heap} for (*Pointer[os.dirInfo]).Store with derefs=0: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:61:7: flow: atomic.x ← atomic.x: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:61:7: from atomic.x, atomic..dict, atomic.val := atomic.x, &atomic..dict.Pointer[os.dirInfo], atomic.val (assign-pair) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:61:6 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:61:7: flow: {heap} ← atomic.x: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:61:7: from atomic.x.v (dot of pointer) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:61:6 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:61:7: from &atomic.x.v (address-of) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:61:6 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:61:7: from atomic.StorePointer(&atomic.x.v, unsafe.Pointer(atomic.val)) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:61:6 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:61:28: parameter atomic.val leaks to {heap} for (*Pointer[os.dirInfo]).Store with derefs=0: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:61:28: flow: atomic.val ← atomic.val: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:61:28: from atomic.x, atomic..dict, atomic.val := atomic.x, &atomic..dict.Pointer[os.dirInfo], atomic.val (assign-pair) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:61:6 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:61:28: flow: {heap} ← atomic.val: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:61:28: from atomic.StorePointer(&atomic.x.v, unsafe.Pointer(atomic.val)) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:61:6 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:58:7: parameter atomic.x leaks to {heap} for (*Pointer[os.dirInfo]).Load with derefs=0: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:58:7: flow: atomic.x ← atomic.x: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:58:7: from atomic.x, atomic..dict := atomic.x, &atomic..dict.Pointer[os.dirInfo] (assign-pair) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:58:6 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:58:7: flow: {heap} ← atomic.x: +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:58:7: from atomic.x.v (dot of pointer) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:58:6 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:58:7: from &atomic.x.v (address-of) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:58:6 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:58:7: from atomic.LoadPointer(&atomic.x.v) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:58:6 +:1: parameter p leaks to {heap} for .eq.SM8S with derefs=1: +:1: flow: {heap} ← *p: +:1: from unsafe.Add(p, uintptr(0)) (call parameter) at :1 +:1: from *(*unsafe.Pointer)(unsafe.Add(p, uintptr(0))) (indirection) at :1 +:1: from runtime.memequal(*(*unsafe.Pointer)(unsafe.Add(p, uintptr(0))), *(*unsafe.Pointer)(unsafe.Add(q, uintptr(0))), *(*uintptr)(unsafe.Add(p, uintptr(8)))) (call parameter) at :1 +:1: parameter q leaks to {heap} for .eq.SM8S with derefs=1: +:1: flow: {heap} ← *q: +:1: from unsafe.Add(q, uintptr(0)) (call parameter) at :1 +:1: from *(*unsafe.Pointer)(unsafe.Add(q, uintptr(0))) (indirection) at :1 +:1: from runtime.memequal(*(*unsafe.Pointer)(unsafe.Add(p, uintptr(0))), *(*unsafe.Pointer)(unsafe.Add(q, uintptr(0))), *(*uintptr)(unsafe.Add(p, uintptr(8)))) (call parameter) at :1 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:27: parameter slices.s leaks to {heap} for Clone[go.shape.[]github.com/git-bug/gitconfig.Entry,go.shape.struct { Key github.com/git-bug/gitconfig.Key; Value string; Implicit bool; Origin github.com/git-bug/gitconfig.Origin }] with derefs=1: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:27: flow: {heap} ← *slices.s: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:27: from append(go.shape.[]github.com/git-bug/gitconfig.Entry{}, slices.s...) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:15 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:27: from append(go.shape.[]github.com/git-bug/gitconfig.Entry{}, slices.s...) (appended slice...) at ../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:15 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:15: append(go.shape.[]github.com/git-bug/gitconfig.Entry{}, slices.s...) escapes to heap in Clone[go.shape.[]github.com/git-bug/gitconfig.Entry,go.shape.struct { Key github.com/git-bug/gitconfig.Key; Value string; Implicit bool; Origin github.com/git-bug/gitconfig.Origin }]: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:15: flow: slices.~r0 ← &{storage for append(go.shape.[]github.com/git-bug/gitconfig.Entry{}, slices.s...)}: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:15: from append(go.shape.[]github.com/git-bug/gitconfig.Entry{}, slices.s...) (spill) at ../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:15 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:15: from return append(go.shape.[]github.com/git-bug/gitconfig.Entry{}, slices.s...) (return) at ../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:2 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:17: go.shape.[]github.com/git-bug/gitconfig.Entry{} escapes to heap in Clone[go.shape.[]github.com/git-bug/gitconfig.Entry,go.shape.struct { Key github.com/git-bug/gitconfig.Key; Value string; Implicit bool; Origin github.com/git-bug/gitconfig.Origin }]: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:17: flow: {temp} ← &{storage for go.shape.[]github.com/git-bug/gitconfig.Entry{}}: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:17: from go.shape.[]github.com/git-bug/gitconfig.Entry{} (spill) at ../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:17 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:17: from append(go.shape.[]github.com/git-bug/gitconfig.Entry{}, slices.s...) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:15 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:17: flow: {temp} ← {temp}: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:17: flow: slices.~r0 ← {temp}: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:17: from return append(go.shape.[]github.com/git-bug/gitconfig.Entry{}, slices.s...) (return) at ../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:2 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:17: go.shape.[]github.com/git-bug/gitconfig.Entry{} escapes to heap +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:15: append escapes to heap +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:27: parameter slices.s leaks to {heap} for Clone[[]github.com/git-bug/gitconfig.Entry,github.com/git-bug/gitconfig.Entry] with derefs=1: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:27: flow: slices.s ← slices.s: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:27: from slices..dict, slices.s := &slices..dict.Clone[[]github.com/git-bug/gitconfig.Entry,github.com/git-bug/gitconfig.Entry], slices.s (assign-pair) at ../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:27: flow: {heap} ← *slices.s: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:27: from append(go.shape.[]github.com/git-bug/gitconfig.Entry{}, slices.s...) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:27: from append(go.shape.[]github.com/git-bug/gitconfig.Entry{}, slices.s...) (appended slice...) at ../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: append(go.shape.[]github.com/git-bug/gitconfig.Entry{}, slices.s...) escapes to heap in Clone[[]github.com/git-bug/gitconfig.Entry,github.com/git-bug/gitconfig.Entry]: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: flow: slices.~r0 ← &{storage for append(go.shape.[]github.com/git-bug/gitconfig.Entry{}, slices.s...)}: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: from append(go.shape.[]github.com/git-bug/gitconfig.Entry{}, slices.s...) (spill) at ../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: from slices.~r0 = append(go.shape.[]github.com/git-bug/gitconfig.Entry{}, slices.s...) (assign-pair) at ../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: flow: slices.~r0 ← slices.~r0: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: from return slices.~r0 (return) at ../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: go.shape.[]github.com/git-bug/gitconfig.Entry{} escapes to heap in Clone[[]github.com/git-bug/gitconfig.Entry,github.com/git-bug/gitconfig.Entry]: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: flow: {temp} ← &{storage for go.shape.[]github.com/git-bug/gitconfig.Entry{}}: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: from go.shape.[]github.com/git-bug/gitconfig.Entry{} (spill) at ../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: from append(go.shape.[]github.com/git-bug/gitconfig.Entry{}, slices.s...) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: flow: {temp} ← {temp}: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: flow: slices.~r0 ← {temp}: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: from slices.~r0 = append(go.shape.[]github.com/git-bug/gitconfig.Entry{}, slices.s...) (assign-pair) at ../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: flow: slices.~r0 ← slices.~r0: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: from return slices.~r0 (return) at ../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: go.shape.[]github.com/git-bug/gitconfig.Entry{} escapes to heap +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: append escapes to heap +../../.asdf/installs/golang/1.27.1/go/src/slices/sort.go:30:30: parameter slices.x leaks to {heap} for SortFunc[go.shape.[]github.com/git-bug/gitconfig.splice,go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] with derefs=1: +../../.asdf/installs/golang/1.27.1/go/src/slices/sort.go:30:30: flow: {temp} ← slices.x: +../../.asdf/installs/golang/1.27.1/go/src/slices/sort.go:30:30: from slices.pdqsortCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }]((*[11]uintptr)(slices..dict[0]), slices.x, 0, slices.n, bits.Len(uint(slices.n)), slices.cmp) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/slices/sort.go:32:16 +../../.asdf/installs/golang/1.27.1/go/src/slices/sort.go:30:30: flow: {heap} ← *{temp}: +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:323:20: slices.reverseRangeCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] ignoring self-assignment in slices.data[slices.i], slices.data[slices.j] = slices.data[slices.j], slices.data[slices.i] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:323:20: slices.reverseRangeCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] ignoring self-assignment in slices.data[slices.i], slices.data[slices.j] = slices.data[slices.j], slices.data[slices.i] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:298:27: parameter slices.data leaks to {heap} for order2CmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] with derefs=1: +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:298:27: flow: {heap} ← *slices.data: +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:298:27: from slices.data[slices.b] (dot of pointer) at ../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:299:13 +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:298:27: from slices.cmp(slices.data[slices.b], slices.data[slices.a]) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:299:8 +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:315:35: parameter slices.data leaks to {heap} for medianAdjacentCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] with derefs=1: +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:315:35: flow: {heap} ← *slices.data: +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:315:35: from slices.medianCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }]((*[3]uintptr)(slices..dict[0]), slices.data, slices.a - 1, slices.a, slices.a + 1, slices.swaps, slices.cmp) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:316:22 +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:13:23: slices.insertionSortCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] ignoring self-assignment in slices.data[slices.j], slices.data[slices.j - 1] = slices.data[slices.j - 1], slices.data[slices.j] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:13:23: slices.insertionSortCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] ignoring self-assignment in slices.data[slices.j], slices.data[slices.j - 1] = slices.data[slices.j - 1], slices.data[slices.j] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:10:34: parameter slices.data leaks to {heap} for insertionSortCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] with derefs=1: +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:10:34: flow: {heap} ← *slices.data: +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:10:34: from slices.data[slices.j] (dot of pointer) at ../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:12:33 +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:10:34: from slices.cmp(slices.data[slices.j], slices.data[slices.j - 1]) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:12:28 +../../.asdf/installs/golang/1.27.1/go/src/slices/sort.go:30:30: parameter slices.x leaks to {heap} for SortFunc[[]github.com/git-bug/gitconfig.splice,github.com/git-bug/gitconfig.splice] with derefs=1: +../../.asdf/installs/golang/1.27.1/go/src/slices/sort.go:30:30: flow: slices.x ← slices.x: +../../.asdf/installs/golang/1.27.1/go/src/slices/sort.go:30:30: from slices..dict, slices.x, slices.cmp := &slices..dict.SortFunc[[]github.com/git-bug/gitconfig.splice,github.com/git-bug/gitconfig.splice], slices.x, slices.cmp (assign-pair) at ../../.asdf/installs/golang/1.27.1/go/src/slices/sort.go:30:6 +../../.asdf/installs/golang/1.27.1/go/src/slices/sort.go:30:30: flow: {temp} ← slices.x: +../../.asdf/installs/golang/1.27.1/go/src/slices/sort.go:30:30: from slices.pdqsortCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }]((*[11]uintptr)(slices..dict[0]), slices.x, 0, slices.n, bits.Len(uint(slices.n)), slices.cmp) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/slices/sort.go:30:6 +../../.asdf/installs/golang/1.27.1/go/src/slices/sort.go:30:30: flow: {heap} ← *{temp}: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:27: parameter slices.s leaks to {heap} for Clone[go.shape.[]string,go.shape.string] with derefs=1: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:27: flow: {heap} ← *slices.s: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:27: from append(go.shape.[]string{}, slices.s...) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:15 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:27: from append(go.shape.[]string{}, slices.s...) (appended slice...) at ../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:15 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:15: append(go.shape.[]string{}, slices.s...) escapes to heap in Clone[go.shape.[]string,go.shape.string]: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:15: flow: slices.~r0 ← &{storage for append(go.shape.[]string{}, slices.s...)}: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:15: from append(go.shape.[]string{}, slices.s...) (spill) at ../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:15 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:15: from return append(go.shape.[]string{}, slices.s...) (return) at ../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:2 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:17: go.shape.[]string{} escapes to heap in Clone[go.shape.[]string,go.shape.string]: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:17: flow: {temp} ← &{storage for go.shape.[]string{}}: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:17: from go.shape.[]string{} (spill) at ../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:17 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:17: from append(go.shape.[]string{}, slices.s...) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:15 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:17: flow: {temp} ← {temp}: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:17: flow: slices.~r0 ← {temp}: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:17: from return append(go.shape.[]string{}, slices.s...) (return) at ../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:2 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:17: go.shape.[]string{} escapes to heap +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:362:15: append escapes to heap +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:27: parameter slices.s leaks to {heap} for Clone[[]string,string] with derefs=1: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:27: flow: slices.s ← slices.s: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:27: from slices..dict, slices.s := &slices..dict.Clone[[]string,string], slices.s (assign-pair) at ../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:27: flow: {heap} ← *slices.s: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:27: from append(go.shape.[]string{}, slices.s...) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:27: from append(go.shape.[]string{}, slices.s...) (appended slice...) at ../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: append(go.shape.[]string{}, slices.s...) escapes to heap in Clone[[]string,string]: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: flow: slices.~r0 ← &{storage for append(go.shape.[]string{}, slices.s...)}: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: from append(go.shape.[]string{}, slices.s...) (spill) at ../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: from slices.~r0 = append(go.shape.[]string{}, slices.s...) (assign-pair) at ../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: flow: slices.~r0 ← slices.~r0: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: from return slices.~r0 (return) at ../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: go.shape.[]string{} escapes to heap in Clone[[]string,string]: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: flow: {temp} ← &{storage for go.shape.[]string{}}: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: from go.shape.[]string{} (spill) at ../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: from append(go.shape.[]string{}, slices.s...) (call parameter) at ../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: flow: {temp} ← {temp}: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: flow: slices.~r0 ← {temp}: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: from slices.~r0 = append(go.shape.[]string{}, slices.s...) (assign-pair) at ../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: flow: slices.~r0 ← slices.~r0: +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: from return slices.~r0 (return) at ../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: go.shape.[]string{} escapes to heap +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: append escapes to heap +:1: parameter p leaks to {heap} for .eq.SSM1K7SSM1K7M8SM8SI with derefs=1: +:1: flow: {heap} ← *p: +:1: from unsafe.Add(p, uintptr(0)) (call parameter) at :1 +:1: from *(*unsafe.Pointer)(unsafe.Add(p, uintptr(0))) (indirection) at :1 +:1: from runtime.memequal(*(*unsafe.Pointer)(unsafe.Add(p, uintptr(0))), *(*unsafe.Pointer)(unsafe.Add(q, uintptr(0))), *(*uintptr)(unsafe.Add(p, uintptr(8)))) (call parameter) at :1 +:1: parameter q leaks to {heap} for .eq.SSM1K7SSM1K7M8SM8SI with derefs=1: +:1: flow: {heap} ← *q: +:1: from unsafe.Add(q, uintptr(0)) (call parameter) at :1 +:1: from *(*unsafe.Pointer)(unsafe.Add(q, uintptr(0))) (indirection) at :1 +:1: from runtime.memequal(*(*unsafe.Pointer)(unsafe.Add(p, uintptr(0))), *(*unsafe.Pointer)(unsafe.Add(q, uintptr(0))), *(*uintptr)(unsafe.Add(p, uintptr(8)))) (call parameter) at :1 +:1: parameter p leaks to {heap} for .eq.SSM1K7SSM1K7M8SM8 with derefs=1: +:1: flow: {heap} ← *p: +:1: from unsafe.Add(p, uintptr(0)) (call parameter) at :1 +:1: from *(*unsafe.Pointer)(unsafe.Add(p, uintptr(0))) (indirection) at :1 +:1: from runtime.memequal(*(*unsafe.Pointer)(unsafe.Add(p, uintptr(0))), *(*unsafe.Pointer)(unsafe.Add(q, uintptr(0))), *(*uintptr)(unsafe.Add(p, uintptr(8)))) (call parameter) at :1 +:1: parameter q leaks to {heap} for .eq.SSM1K7SSM1K7M8SM8 with derefs=1: +:1: flow: {heap} ← *q: +:1: from unsafe.Add(q, uintptr(0)) (call parameter) at :1 +:1: from *(*unsafe.Pointer)(unsafe.Add(q, uintptr(0))) (indirection) at :1 +:1: from runtime.memequal(*(*unsafe.Pointer)(unsafe.Add(p, uintptr(0))), *(*unsafe.Pointer)(unsafe.Add(q, uintptr(0))), *(*uintptr)(unsafe.Add(p, uintptr(8)))) (call parameter) at :1 +:1: parameter p leaks to {heap} for .eq.SSM1K7S with derefs=1: +:1: flow: {heap} ← *p: +:1: from unsafe.Add(p, uintptr(0)) (call parameter) at :1 +:1: from *(*unsafe.Pointer)(unsafe.Add(p, uintptr(0))) (indirection) at :1 +:1: from runtime.memequal(*(*unsafe.Pointer)(unsafe.Add(p, uintptr(0))), *(*unsafe.Pointer)(unsafe.Add(q, uintptr(0))), *(*uintptr)(unsafe.Add(p, uintptr(8)))) (call parameter) at :1 +:1: parameter q leaks to {heap} for .eq.SSM1K7S with derefs=1: +:1: flow: {heap} ← *q: +:1: from unsafe.Add(q, uintptr(0)) (call parameter) at :1 +:1: from *(*unsafe.Pointer)(unsafe.Add(q, uintptr(0))) (indirection) at :1 +:1: from runtime.memequal(*(*unsafe.Pointer)(unsafe.Add(p, uintptr(0))), *(*unsafe.Pointer)(unsafe.Add(q, uintptr(0))), *(*uintptr)(unsafe.Add(p, uintptr(8)))) (call parameter) at :1 +:1: parameter p leaks to {heap} for .eq.SSM1 with derefs=1: +:1: flow: {heap} ← *p: +:1: from unsafe.Add(p, uintptr(0)) (call parameter) at :1 +:1: from *(*unsafe.Pointer)(unsafe.Add(p, uintptr(0))) (indirection) at :1 +:1: from runtime.memequal(*(*unsafe.Pointer)(unsafe.Add(p, uintptr(0))), *(*unsafe.Pointer)(unsafe.Add(q, uintptr(0))), *(*uintptr)(unsafe.Add(p, uintptr(8)))) (call parameter) at :1 +:1: parameter q leaks to {heap} for .eq.SSM1 with derefs=1: +:1: flow: {heap} ← *q: +:1: from unsafe.Add(q, uintptr(0)) (call parameter) at :1 +:1: from *(*unsafe.Pointer)(unsafe.Add(q, uintptr(0))) (indirection) at :1 +:1: from runtime.memequal(*(*unsafe.Pointer)(unsafe.Add(p, uintptr(0))), *(*unsafe.Pointer)(unsafe.Add(q, uintptr(0))), *(*uintptr)(unsafe.Add(p, uintptr(8)))) (call parameter) at :1 +:1: parameter p leaks to {heap} for .eq.M8SM8 with derefs=1: +:1: flow: {heap} ← *p: +:1: from unsafe.Add(p, uintptr(8)) (call parameter) at :1 +:1: from *(*unsafe.Pointer)(unsafe.Add(p, uintptr(8))) (indirection) at :1 +:1: from runtime.memequal(*(*unsafe.Pointer)(unsafe.Add(p, uintptr(8))), *(*unsafe.Pointer)(unsafe.Add(q, uintptr(8))), *(*uintptr)(unsafe.Add(p, uintptr(16)))) (call parameter) at :1 +:1: parameter q leaks to {heap} for .eq.M8SM8 with derefs=1: +:1: flow: {heap} ← *q: +:1: from unsafe.Add(q, uintptr(8)) (call parameter) at :1 +:1: from *(*unsafe.Pointer)(unsafe.Add(q, uintptr(8))) (indirection) at :1 +:1: from runtime.memequal(*(*unsafe.Pointer)(unsafe.Add(p, uintptr(8))), *(*unsafe.Pointer)(unsafe.Add(q, uintptr(8))), *(*uintptr)(unsafe.Add(p, uintptr(16)))) (call parameter) at :1 +:1: k.Section + "." + k.Subsection + "." + k.Name escapes to heap in (*Key).String: +:1: flow: ~r0 ← &{storage for k.Section + "." + k.Subsection + "." + k.Name}: +:1: from k.Section + "." + k.Subsection + "." + k.Name (spill) at :1 +:1: from ~r0 = k.Section + "." + k.Subsection + "." + k.Name (assign-pair) at :1 +:1: flow: ~r0 ← ~r0: +:1: from return ~r0 (return) at :1 +:1: k.Section + "." + k.Name escapes to heap in (*Key).String: +:1: flow: ~r0 ← &{storage for k.Section + "." + k.Name}: +:1: from k.Section + "." + k.Name (spill) at :1 +:1: from ~r0 = k.Section + "." + k.Name (assign-pair) at :1 +:1: flow: ~r0 ← ~r0: +:1: from return ~r0 (return) at :1 +:1: k.Section + "." + k.Subsection + "." + k.Name escapes to heap +:1: k.Section + "." + k.Name escapes to heap +./key.go:69:7: parameter k leaks to ~r0 for (*Key).sectionKey with derefs=1: +./key.go:69:7: flow: k ← *k: +./key.go:69:7: from k (indirection) at :1 +./key.go:69:7: from k := k (assign-pair) at :1 +./key.go:69:7: flow: ~r0 ← k: +./key.go:69:7: from k.Section (dot) at :1 +./key.go:69:7: from sectionKey{...} (struct literal element) at :1 +./key.go:69:7: from ~r0 = sectionKey{...} (assign-pair) at :1 +./key.go:69:7: flow: ~r0 ← ~r0: +./key.go:69:7: from return ~r0 (return) at :1 +./config.go:234:7: parameter e leaks to {heap} for (*Entry).Bool with derefs=1: +./config.go:234:7: flow: {heap} ← *e: +./config.go:234:7: from e (indirection) at :1 +./config.go:234:7: from Entry.Bool(e) (call parameter) at :1 +./config.go:248:7: parameter e leaks to {heap} for (*Entry).Int with derefs=1: +./config.go:248:7: flow: {heap} ← *e: +./config.go:248:7: from e (indirection) at :1 +./config.go:248:7: from Entry.Int(e) (call parameter) at :1 +./config.go:265:7: parameter e leaks to {heap} for (*Entry).Path with derefs=1: +./config.go:265:7: flow: {heap} ← *e: +./config.go:265:7: from e (indirection) at :1 +./config.go:265:7: from Entry.Path(e, home) (call parameter) at :1 +:1: &ValueError{...} escapes to heap in (*Entry).error: +:1: flow: ~r0 ← &{storage for &ValueError{...}}: +:1: from &ValueError{...} (spill) at :1 +:1: from &ValueError{...} (interface-converted) at :1 +:1: from ~r0 = &ValueError{...} (assign-pair) at :1 +:1: flow: ~r0 ← ~r0: +:1: from return ~r0 (return) at :1 +./config.go:191:7: parameter e leaks to {storage for &ValueError{...}} for (*Entry).error with derefs=1: +./config.go:191:7: flow: e ← *e: +./config.go:191:7: from e (indirection) at :1 +./config.go:191:7: from e, typ, err := e, typ, err (assign-pair) at :1 +./config.go:191:7: flow: {storage for &ValueError{...}} ← e: +./config.go:191:7: from ValueError{...} (struct literal element) at :1 +./config.go:191:22: parameter typ leaks to {storage for &ValueError{...}} for (*Entry).error with derefs=0: +./config.go:191:22: flow: typ ← typ: +./config.go:191:22: from e, typ, err := e, typ, err (assign-pair) at :1 +./config.go:191:22: flow: {storage for &ValueError{...}} ← typ: +./config.go:191:22: from ValueError{...} (struct literal element) at :1 +./config.go:191:34: parameter err leaks to {storage for &ValueError{...}} for (*Entry).error with derefs=0: +./config.go:191:34: flow: err ← err: +./config.go:191:34: from e, typ, err := e, typ, err (assign-pair) at :1 +./config.go:191:34: flow: {storage for &ValueError{...}} ← err: +./config.go:191:34: from ValueError{...} (struct literal element) at :1 +:1: &ValueError{...} escapes to heap +:1: parameter ~p0 leaks to {heap} for environ.Lookup with derefs=0: +:1: flow: {heap} ← ~p0: +:1: from ~p0.Lookup(key) (call parameter) at :1 +./discover.go:15:9: parameter key leaks to {heap} for environ.Lookup with derefs=0: +./discover.go:15:9: flow: {heap} ← key: +./discover.go:15:9: from ~p0.Lookup(key) (call parameter) at :1 +./discover.go:20:25: parameter key leaks to {heap} for (*osEnviron).Lookup with derefs=0: +./discover.go:20:25: flow: key ← key: +./discover.go:20:25: from ~p0, key := ~p0, key (assign-pair) at :1 +./discover.go:20:25: flow: {heap} ← key: +./discover.go:20:25: from os.LookupEnv(key) (call parameter) at :1 +./env.go:137:7: parameter e leaks to {heap} for (*Env).Load with derefs=1: +./env.go:137:7: flow: {heap} ← *e: +./env.go:137:7: from e (indirection) at :1 +./env.go:137:7: from Env.Load(e) (call parameter) at :1 +./env.go:307:7: parameter e leaks to {heap} for (*Env).LoadFile with derefs=1: +./env.go:307:7: flow: {heap} ← *e: +./env.go:307:7: from e (indirection) at :1 +./env.go:307:7: from Env.LoadFile(e, path) (call parameter) at :1 +./env.go:307:23: parameter path leaks to {heap} for (*Env).LoadFile with derefs=0: +./env.go:307:23: flow: {heap} ← path: +./env.go:307:23: from Env.LoadFile(e, path) (call parameter) at :1 +./env.go:178:7: parameter e leaks to {heap} for (*Env).LoadProtected with derefs=1: +./env.go:178:7: flow: {heap} ← *e: +./env.go:178:7: from e (indirection) at :1 +./env.go:178:7: from Env.LoadProtected(e) (call parameter) at :1 +./env.go:269:7: parameter e leaks to {heap} for (*Env).LoadScope with derefs=1: +./env.go:269:7: flow: {heap} ← *e: +./env.go:269:7: from e (indirection) at :1 +./env.go:269:7: from Env.LoadScope(e, s) (call parameter) at :1 +./env.go:208:7: parameter e leaks to {heap} for (*Env).SafeDirectory with derefs=1: +./env.go:208:7: flow: {heap} ← *e: +./env.go:208:7: from e (indirection) at :1 +./env.go:208:7: from Env.SafeDirectory(e, dir) (call parameter) at :1 +./env.go:208:28: parameter dir leaks to {heap} for (*Env).SafeDirectory with derefs=0: +./env.go:208:28: flow: {heap} ← dir: +./env.go:208:28: from Env.SafeDirectory(e, dir) (call parameter) at :1 +./env.go:424:25: parameter path leaks to {heap} for (*Env).UpdateFile with derefs=0: +./env.go:424:25: flow: path ← path: +./env.go:424:25: from e, path, fn := e, path, fn (assign-pair) at :1 +./env.go:424:25: flow: {heap} ← path: +./env.go:424:25: from updateFile(path, Scope(0), fn) (call parameter) at :1 +./env.go:379:7: parameter e leaks to {heap} for (*Env).UpdateScope with derefs=1: +./env.go:379:7: flow: {heap} ← *e: +./env.go:379:7: from e (indirection) at :1 +./env.go:379:7: from Env.UpdateScope(e, s, fn) (call parameter) at :1 +./env.go:326:7: parameter e leaks to {heap} for (*Env).WritePath with derefs=1: +./env.go:326:7: flow: {heap} ← *e: +./env.go:326:7: from e (indirection) at :1 +./env.go:326:7: from Env.WritePath(e, s) (call parameter) at :1 +./load.go:180:7: parameter e leaks to {heap} for (*Env).newLoader with derefs=1: +./load.go:180:7: flow: {heap} ← *e: +./load.go:180:7: from e (indirection) at :1 +./load.go:180:7: from Env.newLoader(e) (call parameter) at :1 +./load.go:31:7: parameter e leaks to {heap} for (*Env).repo with derefs=1: +./load.go:31:7: flow: {heap} ← *e: +./load.go:31:7: from e (indirection) at :1 +./load.go:31:7: from Env.repo(e) (call parameter) at :1 +./env.go:353:7: parameter e leaks to {heap} for (*Env).scopeFile with derefs=1: +./env.go:353:7: flow: {heap} ← *e: +./env.go:353:7: from e (indirection) at :1 +./env.go:353:7: from Env.scopeFile(e, s) (call parameter) at :1 +./parse.go:55:39: parameter file leaks to {heap} for (*File).entries with derefs=0: +./parse.go:55:39: flow: file ← file: +./parse.go:55:39: from p, scope, file, out := p.parsed, scope, file, out (assign-pair) at :1 +./parse.go:55:39: flow: {heap} ← file: +./parse.go:55:39: from Origin{...} (struct literal element) at :1 +./parse.go:55:39: from Entry{...} (struct literal element) at :1 +./parse.go:55:39: from append(out, Entry{...}) (call parameter) at :1 +./parse.go:55:52: parameter out leaks to {heap} for (*File).entries with derefs=1: +./parse.go:55:52: flow: out ← out: +./parse.go:55:52: from p, scope, file, out := p.parsed, scope, file, out (assign-pair) at :1 +./parse.go:55:52: flow: {temp} ← out: +./parse.go:55:52: from append(out, Entry{...}) (call parameter) at :1 +./parse.go:55:52: flow: {heap} ← *{temp}: +./parse.go:55:52: from append(out, Entry{...}) (appendee slice) at :1 +./parse.go:55:7: parameter p leaks to {heap} for (*File).entries with derefs=2: +./parse.go:55:7: flow: p ← p: +./parse.go:55:7: from p.parsed (dot of pointer) at :1 +./parse.go:55:7: from p.parsed (address-of) at :1 +./parse.go:55:7: from p, scope, file, out := p.parsed, scope, file, out (assign-pair) at :1 +./parse.go:55:7: flow: sec ← **p: +./parse.go:55:7: from p.secs (dot of pointer) at :1 +./parse.go:55:7: from p.secs[it.sec] (dot of pointer) at :1 +./parse.go:55:7: from sec := p.secs[it.sec] (assign) at :1 +./parse.go:55:7: flow: {heap} ← sec: +./parse.go:55:7: from sec.section (dot) at :1 +./parse.go:55:7: from Key{...} (struct literal element) at :1 +./parse.go:55:7: from Entry{...} (struct literal element) at :1 +./parse.go:55:7: from append(out, Entry{...}) (call parameter) at :1 +./parse.go:55:52: parameter out leaks to ~r0 for (*File).entries with derefs=0: +./parse.go:55:52: flow: out ← out: +./parse.go:55:52: from p, scope, file, out := p.parsed, scope, file, out (assign-pair) at :1 +./parse.go:55:52: flow: ~r0 ← out: +./parse.go:55:52: from ~r0 = out (assign-pair) at :1 +./parse.go:55:52: flow: ~r0 ← ~r0: +./parse.go:55:52: from return ~r0 (return) at :1 +:1: append(out, Entry{...}) escapes to heap in (*File).entries: +:1: flow: out ← &{storage for append(out, Entry{...})}: +:1: from append(out, Entry{...}) (spill) at :1 +:1: from out = append(out, Entry{...}) (assign) at :1 +:1: flow: ~r0 ← out: +:1: from ~r0 = out (assign-pair) at :1 +:1: flow: ~r0 ← ~r0: +:1: from return ~r0 (return) at :1 +:1: append escapes to heap +./parse.go:71:7: parameter p leaks to ~r0 for (*File).nameOf with derefs=2: +./parse.go:71:7: flow: p ← p: +./parse.go:71:7: from p.parsed (dot of pointer) at :1 +./parse.go:71:7: from p.parsed (address-of) at :1 +./parse.go:71:7: from p, it := p.parsed, it (assign-pair) at :1 +./parse.go:71:7: flow: ~r0 ← **p: +./parse.go:71:7: from p.texts (dot of pointer) at :1 +./parse.go:71:7: from p.texts[it.text] (dot of pointer) at :1 +./parse.go:71:7: from p.texts[it.text].name (dot) at :1 +./parse.go:71:7: from ~r0 = p.texts[it.text].name (assign-pair) at :1 +./parse.go:71:7: flow: ~r0 ← ~r0: +./parse.go:71:7: from return ~r0 (return) at :1 +./parse.go:51:7: parameter p leaks to ~r0 for (*File).secOf with derefs=2: +./parse.go:51:7: flow: p ← p: +./parse.go:51:7: from p.parsed (dot of pointer) at :1 +./parse.go:51:7: from p.parsed (address-of) at :1 +./parse.go:51:7: from p, it := p.parsed, it (assign-pair) at :1 +./parse.go:51:7: flow: ~r0 ← **p: +./parse.go:51:7: from p.secs (dot of pointer) at :1 +./parse.go:51:7: from p.secs[it.sec] (dot of pointer) at :1 +./parse.go:51:7: from ~r0 = p.secs[it.sec] (assign-pair) at :1 +./parse.go:51:7: flow: ~r0 ← ~r0: +./parse.go:51:7: from return ~r0 (return) at :1 +./parse.go:72:7: parameter p leaks to ~r0 for (*File).valueOf with derefs=2: +./parse.go:72:7: flow: p ← p: +./parse.go:72:7: from p.parsed (dot of pointer) at :1 +./parse.go:72:7: from p.parsed (address-of) at :1 +./parse.go:72:7: from p, it := p.parsed, it (assign-pair) at :1 +./parse.go:72:7: flow: ~r0 ← **p: +./parse.go:72:7: from p.texts (dot of pointer) at :1 +./parse.go:72:7: from p.texts[it.text] (dot of pointer) at :1 +./parse.go:72:7: from p.texts[it.text].value (dot) at :1 +./parse.go:72:7: from ~r0 = p.texts[it.text].value (assign-pair) at :1 +./parse.go:72:7: flow: ~r0 ← ~r0: +./parse.go:72:7: from return ~r0 (return) at :1 +./parse.go:55:39: parameter file leaks to {heap} for (*parser).entries with derefs=0: +./parse.go:55:39: flow: file ← file: +./parse.go:55:39: from p, scope, file, out := p.parsed, scope, file, out (assign-pair) at :1 +./parse.go:55:39: flow: {heap} ← file: +./parse.go:55:39: from Origin{...} (struct literal element) at :1 +./parse.go:55:39: from Entry{...} (struct literal element) at :1 +./parse.go:55:39: from append(out, Entry{...}) (call parameter) at :1 +./parse.go:55:52: parameter out leaks to {heap} for (*parser).entries with derefs=1: +./parse.go:55:52: flow: out ← out: +./parse.go:55:52: from p, scope, file, out := p.parsed, scope, file, out (assign-pair) at :1 +./parse.go:55:52: flow: {temp} ← out: +./parse.go:55:52: from append(out, Entry{...}) (call parameter) at :1 +./parse.go:55:52: flow: {heap} ← *{temp}: +./parse.go:55:52: from append(out, Entry{...}) (appendee slice) at :1 +./parse.go:55:7: parameter p leaks to {heap} for (*parser).entries with derefs=2: +./parse.go:55:7: flow: p ← p: +./parse.go:55:7: from p.parsed (dot of pointer) at :1 +./parse.go:55:7: from p.parsed (address-of) at :1 +./parse.go:55:7: from p, scope, file, out := p.parsed, scope, file, out (assign-pair) at :1 +./parse.go:55:7: flow: sec ← **p: +./parse.go:55:7: from p.secs (dot of pointer) at :1 +./parse.go:55:7: from p.secs[it.sec] (dot of pointer) at :1 +./parse.go:55:7: from sec := p.secs[it.sec] (assign) at :1 +./parse.go:55:7: flow: {heap} ← sec: +./parse.go:55:7: from sec.section (dot) at :1 +./parse.go:55:7: from Key{...} (struct literal element) at :1 +./parse.go:55:7: from Entry{...} (struct literal element) at :1 +./parse.go:55:7: from append(out, Entry{...}) (call parameter) at :1 +./parse.go:55:52: parameter out leaks to ~r0 for (*parser).entries with derefs=0: +./parse.go:55:52: flow: out ← out: +./parse.go:55:52: from p, scope, file, out := p.parsed, scope, file, out (assign-pair) at :1 +./parse.go:55:52: flow: ~r0 ← out: +./parse.go:55:52: from ~r0 = out (assign-pair) at :1 +./parse.go:55:52: flow: ~r0 ← ~r0: +./parse.go:55:52: from return ~r0 (return) at :1 +:1: append(out, Entry{...}) escapes to heap in (*parser).entries: +:1: flow: out ← &{storage for append(out, Entry{...})}: +:1: from append(out, Entry{...}) (spill) at :1 +:1: from out = append(out, Entry{...}) (assign) at :1 +:1: flow: ~r0 ← out: +:1: from ~r0 = out (assign-pair) at :1 +:1: flow: ~r0 ← ~r0: +:1: from return ~r0 (return) at :1 +:1: append escapes to heap +./parse.go:71:7: parameter p leaks to ~r0 for (*parser).nameOf with derefs=2: +./parse.go:71:7: flow: p ← p: +./parse.go:71:7: from p.parsed (dot of pointer) at :1 +./parse.go:71:7: from p.parsed (address-of) at :1 +./parse.go:71:7: from p, it := p.parsed, it (assign-pair) at :1 +./parse.go:71:7: flow: ~r0 ← **p: +./parse.go:71:7: from p.texts (dot of pointer) at :1 +./parse.go:71:7: from p.texts[it.text] (dot of pointer) at :1 +./parse.go:71:7: from p.texts[it.text].name (dot) at :1 +./parse.go:71:7: from ~r0 = p.texts[it.text].name (assign-pair) at :1 +./parse.go:71:7: flow: ~r0 ← ~r0: +./parse.go:71:7: from return ~r0 (return) at :1 +./parse.go:51:7: parameter p leaks to ~r0 for (*parser).secOf with derefs=2: +./parse.go:51:7: flow: p ← p: +./parse.go:51:7: from p.parsed (dot of pointer) at :1 +./parse.go:51:7: from p.parsed (address-of) at :1 +./parse.go:51:7: from p, it := p.parsed, it (assign-pair) at :1 +./parse.go:51:7: flow: ~r0 ← **p: +./parse.go:51:7: from p.secs (dot of pointer) at :1 +./parse.go:51:7: from p.secs[it.sec] (dot of pointer) at :1 +./parse.go:51:7: from ~r0 = p.secs[it.sec] (assign-pair) at :1 +./parse.go:51:7: flow: ~r0 ← ~r0: +./parse.go:51:7: from return ~r0 (return) at :1 +./parse.go:72:7: parameter p leaks to ~r0 for (*parser).valueOf with derefs=2: +./parse.go:72:7: flow: p ← p: +./parse.go:72:7: from p.parsed (dot of pointer) at :1 +./parse.go:72:7: from p.parsed (address-of) at :1 +./parse.go:72:7: from p, it := p.parsed, it (assign-pair) at :1 +./parse.go:72:7: flow: ~r0 ← **p: +./parse.go:72:7: from p.texts (dot of pointer) at :1 +./parse.go:72:7: from p.texts[it.text] (dot of pointer) at :1 +./parse.go:72:7: from p.texts[it.text].value (dot) at :1 +./parse.go:72:7: from ~r0 = p.texts[it.text].value (assign-pair) at :1 +./parse.go:72:7: flow: ~r0 ← ~r0: +./parse.go:72:7: from return ~r0 (return) at :1 diff --git a/.benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/inline.txt b/.benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/inline.txt new file mode 100644 index 0000000..df6eb87 --- /dev/null +++ b/.benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/inline.txt @@ -0,0 +1,777 @@ +./key.go:69:6: can inline Key.sectionKey with cost 11 as: method(Key) func() sectionKey { return sectionKey{...} } +./config.go:31:6: cannot inline newConfig: function too complex: cost 88 exceeds budget 80 +./key.go:78:6: can inline isAlpha with cost 12 as: func(byte) bool { return byte(97) <= c | byte(32) && c | byte(32) <= byte(122) } +./key.go:74:6: can inline isKeyChar with cost 28 as: func(byte) bool { return isAlpha(c) || byte(48) <= c && c <= byte(57) || c == byte(45) } +./key.go:84:6: can inline validName with cost 77 as: func(string) bool { if s == "" || !isAlpha(s[0]) { return false }; for loop; return true } +./key.go:115:6: can inline lowerASCII with cost 66 as: func(string) string { for loop; return s } +./key.go:98:6: can inline validSection with cost 52 as: func(string) bool { for loop; return true } +./key.go:109:6: can inline validSubsection with cost 70 as: func(string) bool { return !strings.ContainsAny(s, "\n\x00") } +./key.go:25:6: cannot inline parseKey: function too complex: cost 668 exceeds budget 80 +./config.go:49:6: cannot inline (*Config).lookup: function too complex: cost 83 exceeds budget 80 +./config.go:61:6: can inline (*Config).filter with cost 17 as: method(*Config) func(sectionKey) iter.Seq[github.com/git-bug/gitconfig.Entry] { return func literal } +./config.go:62:9: can inline (*Config).filter.func1 with cost 52 as: func(func(Entry) bool) { if c == nil { return }; for loop } +./config.go:75:6: cannot inline (*Config).Get: function too complex: cost 83 exceeds budget 80 +./config.go:85:6: cannot inline (*Config).GetAll: function too complex: cost 96 exceeds budget 80 +./config.go:98:6: can inline (*Config).All with cost 17 as: method(*Config) func() iter.Seq[github.com/git-bug/gitconfig.Entry] { return func literal } +./config.go:99:9: can inline (*Config).All.func1 with cost 35 as: func(func(Entry) bool) { if c == nil { return }; for loop } +./config.go:113:6: cannot inline (*Config).Section: function too complex: cost 91 exceeds budget 80 +./config.go:120:6: cannot inline (*Config).Subsection: function too complex: cost 95 exceeds budget 80 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: can inline slices.Clone[go.shape.[]string,go.shape.string] with cost 11 as: func(*[4]uintptr, go.shape.[]string) go.shape.[]string { if slices.s == nil { return nil }; return append(go.shape.[]string{}, slices.s...) } +./config.go:128:6: cannot inline (*Config).Subsections: function too complex: cost 94 exceeds budget 80 +./config.go:136:6: can inline (*Config).Value with cost 74 as: method(*Config) func(string, string) string { if ok { return e.Value }; return def } +./value.go:137:6: can inline equalFoldASCII with cost 64 as: func(string, string) bool { if len(s) != len(t) { return false }; for loop; return true } +./value.go:100:6: can inline digitValue with cost 37 as: func(byte) int { switch statement; return 36 } +./value.go:35:6: cannot inline parseInt: function too complex: cost 397 exceeds budget 80 +./value.go:15:6: cannot inline parseBool: function too complex: cost 510 exceeds budget 80 +./config.go:191:6: can inline Entry.error with cost 10 as: method(Entry) func(string, error) error { return &ValueError{...} } +./config.go:234:6: cannot inline Entry.Bool: function too complex: cost 97 exceeds budget 80 +./config.go:146:6: cannot inline (*Config).Bool: function too complex: cost 149 exceeds budget 80 +./config.go:248:6: cannot inline Entry.Int: function too complex: cost 110 exceeds budget 80 +./config.go:161:6: cannot inline (*Config).Int: function too complex: cost 149 exceeds budget 80 +./value.go:120:6: cannot inline expandPath: function too complex: cost 97 exceeds budget 80 +./config.go:265:6: cannot inline Entry.Path: function too complex: cost 111 exceeds budget 80 +./config.go:177:6: cannot inline (*Config).Path: function too complex: cost 219 exceeds budget 80 +./discover.go:20:6: can inline osEnviron.Lookup with cost 70 as: method(osEnviron) func(string) (string, bool) { return string(.autotmp_4), .autotmp_5 } +./discover.go:22:6: can inline get with cost 68 as: func(environ, string) string { v, _ := string(.autotmp_4), .autotmp_5; return v } +./discover.go:112:6: cannot inline countEntries: function too complex: cost 733 exceeds budget 80 +./discover.go:186:6: cannot inline unquote: function too complex: cost 237 exceeds budget 80 +./discover.go:181:6: can inline isParamSpace with cost 74 as: func(byte) bool { return strings.IndexByte(" \t\n\v\f\r", c) >= 0 } +./discover.go:148:6: cannot inline parseParameters: function too complex: cost 573 exceeds budget 80 +./platform.go:35:6: cannot inline transient: function too complex: cost 191 exceeds budget 80 +./platform.go:43:6: cannot inline retryTransient: function too complex: cost 405 exceeds budget 80 +./platform.go:14:6: can inline openRegular with cost 80 as: func(string) (*os.File, error) { flag := 0; flag |= 2048; return (*os.File)(.autotmp_4), .autotmp_5 } +./load.go:130:6: cannot inline readConfigFile: function too complex: cost 93 exceeds budget 80 +./load.go:135:24: cannot inline readConfigFile.func1: unhandled op DEFER +./load.go:140:3: can inline readConfigFile.func1.deferwrap1 with cost 69 as: func() { (*os.File).Close(.autotmp_5) } +./load.go:122:6: can inline readSmall with cost 71 as: func(string) ([]byte, error) { return ([]byte)(.autotmp_3), .autotmp_4 } +./discover.go:86:6: cannot inline resolveGitDir: function too complex: cost 605 exceeds budget 80 +./discover.go:27:6: cannot inline discover: function too complex: cost 1102 exceeds budget 80 +./edit.go:28:6: cannot inline editKey: function too complex: cost 226 exceeds budget 80 +./edit.go:66:6: can inline (*File).checkOpen with cost 13 as: method(*File) func(string) error { if f.closed { return &KeyError{...} }; return nil } +./edit.go:59:6: cannot inline checkValue: function too complex: cost 84 exceeds budget 80 +./edit.go:43:6: cannot inline (*File).prepare: function too complex: cost 192 exceeds budget 80 +./parse.go:51:6: can inline (*parsed).secOf with cost 6 as: method(*parsed) func(item) sectionKey { return p.secs[it.sec] } +./parse.go:71:6: can inline (*parsed).nameOf with cost 7 as: method(*parsed) func(item) string { return p.texts[it.text].name } +./edit.go:74:6: can inline (*File).entriesOf with cost 76 as: method(*File) func(Key) []int { idx = ; sk := Key.sectionKey(k); for loop; return idx } +./parse.go:72:6: can inline (*parsed).valueOf with cost 7 as: method(*parsed) func(item) string { return p.texts[it.text].value } +./edit.go:95:6: can inline flatten with cost 64 as: func(parsed) []flatEntry { out = ; for loop; return out } +./edit.go:105:6: can inline flatEntry.is with cost 26 as: method(flatEntry) func(Key) bool { return e.inSection && e.sec == Key.sectionKey(k) && e.name == k.Name } +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:10:6: can inline slices.insertionSortCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] with cost 73 as: func(*[2]uintptr, []go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }, int, int, func(go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }, go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }) int) { for loop } +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:20:6: cannot inline slices.siftDownCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }]: function too complex: cost 121 exceeds budget 80 +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:38:6: cannot inline slices.heapSortCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }]: function too complex: cost 200 exceeds budget 80 +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:240:6: cannot inline slices.breakPatternsCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }]: function too complex: cost 119 exceeds budget 80 +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:298:6: can inline slices.order2CmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] with cost 38 as: func(*[2]uintptr, []go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }, int, int, *int, func(go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }, go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }) int) (int, int) { if slices.cmp(slices.data[slices.b], slices.data[slices.a]) < 0 { *slices.swaps++; return slices.b, slices.a }; return slices.a, slices.b } +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:307:6: cannot inline slices.medianCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }]: function too complex: cost 158 exceeds budget 80 +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:315:6: can inline slices.medianAdjacentCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] with cost 74 as: func(*[3]uintptr, []go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }, int, *int, func(go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }, go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }) int) int { return slices.medianCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }]((*[3]uintptr)(slices..dict[0]), slices.data, slices.a - 1, slices.a, slices.a + 1, slices.swaps, slices.cmp) } +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:261:6: cannot inline slices.choosePivotCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }]: function too complex: cost 401 exceeds budget 80 +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:319:6: can inline slices.reverseRangeCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] with cost 35 as: func(*[2]uintptr, []go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }, int, int, func(go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }, go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }) int) { slices.i := slices.a; slices.j := slices.b - 1; for loop } +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:195:6: cannot inline slices.partialInsertionSortCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }]: function too complex: cost 228 exceeds budget 80 +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:173:6: cannot inline slices.partitionEqualCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }]: function too complex: cost 124 exceeds budget 80 +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:135:6: cannot inline slices.partitionCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }]: function too complex: cost 248 exceeds budget 80 +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:61:6: cannot inline slices.pdqsortCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }]: function too complex: cost 832 exceeds budget 80 +../../.asdf/installs/golang/1.27.1/go/src/slices/sort.go:30:6: can inline slices.SortFunc[go.shape.[]github.com/git-bug/gitconfig.splice,go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] with cost 77 as: func(*[5]uintptr, go.shape.[]github.com/git-bug/gitconfig.splice, func(go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }, go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }) int) { slices.n := len(slices.x); slices.pdqsortCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }]((*[11]uintptr)(slices..dict[0]), slices.x, 0, slices.n, bits.Len(uint(slices.n)), slices.cmp) } +./edit.go:112:27: can inline (*File).apply.func1 with cost 6 as: func(splice, splice) int { return a.start - b.start } +./parse.go:116:6: can inline (*parser).add with cost 36 as: method(*parser) func(itemKind, int, int) *item { p.parsed.items = append(p.parsed.items, item{...}); return &p.parsed.items[len(p.parsed.items) - 1] } +./parse.go:159:6: can inline isNewline with cost 27 as: func([]byte, int) bool { return data[i] == byte(10) || data[i] == byte(13) && i + 1 < len(data) && data[i + 1] == byte(10) } +./parse.go:148:6: can inline isSpace with cost 46 as: func([]byte, int) bool { switch statement; return false } +./parse.go:164:6: can inline newlineLen with cost 10 as: func([]byte, int) int { if data[i] == byte(13) { return 2 }; return 1 } +./parse.go:112:6: can inline (*parser).errorAt with cost 11 as: method(*parser) func(int, string) error { return &SyntaxError{...} } +./parse.go:135:6: can inline (*parser).setSection with cost 44 as: method(*parser) func(sectionKey) { i, ok := int32(.autotmp_4), .autotmp_5; if !ok { i = int32(len(p.parsed.secs)); p.parsed.secs = append(p.parsed.secs, sec); p.secIndex[sec] = i }; p.sec = i; p.inSection = true } +./parse.go:215:6: cannot inline (*parser).header: function too complex: cost 863 exceeds budget 80 +./parse.go:122:6: cannot inline (*parser).addEntry: function too complex: cost 162 exceeds budget 80 +./parse.go:334:6: cannot inline (*parser).value: unhandled op DEFER +./parse.go:337:8: can inline (*parser).value.func1 with cost 6 as: func() { p.buf = buf[:0] } +./parse.go:342:11: can inline (*parser).value.func2 with cost 15 as: func(int) { if pending >= 0 { buf = append(buf, d[pending:at]...); pending = -1 } } +./parse.go:296:6: cannot inline (*parser).entry: function too complex: cost 384 exceeds budget 80 +./parse.go:171:6: cannot inline (*parser).run: function too complex: cost 677 exceeds budget 80 +./parse.go:102:6: cannot inline parse: function too complex: cost 172 exceeds budget 80 +./edit.go:111:6: cannot inline (*File).apply: function too complex: cost 399 exceeds budget 80 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:20:6: can inline slices.Equal[go.shape.[]github.com/git-bug/gitconfig.flatEntry,go.shape.struct { github.com/git-bug/gitconfig.inSection bool; github.com/git-bug/gitconfig.sec github.com/git-bug/gitconfig.sectionKey; github.com/git-bug/gitconfig.name string; github.com/git-bug/gitconfig.value string; github.com/git-bug/gitconfig.implicit bool }] with cost 25 as: func(*[1]uintptr, go.shape.[]github.com/git-bug/gitconfig.flatEntry, go.shape.[]github.com/git-bug/gitconfig.flatEntry) bool { if len(slices.s1) != len(slices.s2) { return false }; for loop; return true } +./edit.go:152:6: can inline filter with cost 38 as: func([]flatEntry, func(flatEntry) bool) []flatEntry { out = ; for loop; return out } +./edit.go:133:6: can inline checkKey with cost 17 as: func(Key, []string, bool) func([]flatEntry, []flatEntry) bool { return func literal } +./edit.go:134:9: can inline checkKey.func1 with cost 231 as: func([]flatEntry, []flatEntry) bool { other := func literal; if !slices.Equal[go.shape.[]github.com/git-bug/gitconfig.flatEntry,go.shape.struct { github.com/git-bug/gitconfig.inSection bool; github.com/git-bug/gitconfig.sec github.com/git-bug/gitconfig.sectionKey; github.com/git-bug/gitconfig.name string; github.com/git-bug/gitconfig.value string; github.com/git-bug/gitconfig.implicit bool }](&slices..dict.Equal[[]github.com/git-bug/gitconfig.flatEntry,github.com/git-bug/gitconfig.flatEntry], filter(before, other), filter(after, other)) { return false }; got := filter(after, func literal); if len(got) != len(want) { return false }; for loop; return true } +./edit.go:135:12: can inline checkKey.func1.1 with cost 31 as: func(flatEntry) bool { return !flatEntry.is(e, k) } +./edit.go:139:24: can inline checkKey.func1.2 with cost 30 as: func(flatEntry) bool { return flatEntry.is(e, k) } +./edit.go:166:6: can inline (*File).ownStart with cost 31 as: method(*File) func(int) int { if i > 0 && f.parsed.items[i - 1].kind == itemKind(1) { return f.parsed.items[i - 1].start }; return f.parsed.items[i].start } +./edit.go:174:6: can inline (*File).firstOnLine with cost 45 as: method(*File) func(int) bool { j := i - 1; if j >= 0 && f.parsed.items[j].kind == itemKind(1) { j-- }; return j < 0 || f.parsed.items[j].kind == itemKind(2) || f.parsed.items[j].kind == itemKind(0) } +./edit.go:184:6: can inline (*File).newlineAfter with cost 30 as: method(*File) func(int) int { for loop; return -1 } +./edit.go:194:6: can inline (*File).lineEnd with cost 52 as: method(*File) func(int) int { if n >= 0 { return f.parsed.items[n].end }; return len(f.data) } +./edit.go:203:6: can inline (*File).terminator with cost 62 as: method(*File) func() string { if len(f.parsed.items) == 0 { return "" }; last := f.parsed.items[len(f.parsed.items) - 1]; switch statement; return "\n" } +./edit.go:228:6: cannot inline quoteValue: function too complex: cost 413 exceeds budget 80 +./edit.go:221:6: can inline formatEntry with cost 66 as: func(string, string) string { return "\t" + name + " = " + quoteValue(value) + "\n" } +./edit.go:254:6: cannot inline formatHeader: function too complex: cost 103 exceeds budget 80 +./edit.go:284:6: cannot inline (*File).entryLineEnd: function too complex: cost 100 exceeds budget 80 +./edit.go:263:6: cannot inline (*File).replaceEntry: function too complex: cost 229 exceeds budget 80 +./edit.go:274:6: cannot inline (*File).removeEntry: function too complex: cost 249 exceeds budget 80 +./edit.go:348:16: can inline (*File).unsetEntry.func1 with cost 23 as: func(item) bool { return it.kind == itemKind(4) && (*parsed).secOf(f.parsed, it) == f.parsed.secs[sec] } +./edit.go:346:6: cannot inline (*File).unsetEntry: function too complex: cost 515 exceeds budget 80 +./edit.go:334:27: can inline (*File).unsetEntries.func1 with cost 6 as: func(splice, splice) int { return a.start - b.start } +./edit.go:313:6: cannot inline (*File).unsetEntries: function too complex: cost 298 exceeds budget 80 +./edit.go:398:6: cannot inline (*File).insert: function too complex: cost 594 exceeds budget 80 +./edit.go:439:6: can inline sectionArg with cost 71 as: func(string) error { if section == "" || !validSection(section) { return &KeyError{...} }; return nil } +./edit.go:447:6: can inline (*File).headersOf with cost 40 as: method(*File) func(sectionKey) []int { idx = ; for loop; return idx } +./edit.go:459:6: cannot inline (*File).removeSection: function too complex: cost 265 exceeds budget 80 +./edit.go:475:32: can inline (*File).removeSection.func1 with cost 88 as: func([]flatEntry, []flatEntry) bool { return slices.Equal[go.shape.[]github.com/git-bug/gitconfig.flatEntry,go.shape.struct { github.com/git-bug/gitconfig.inSection bool; github.com/git-bug/gitconfig.sec github.com/git-bug/gitconfig.sectionKey; github.com/git-bug/gitconfig.name string; github.com/git-bug/gitconfig.value string; github.com/git-bug/gitconfig.implicit bool }](&slices..dict.Equal[[]github.com/git-bug/gitconfig.flatEntry,github.com/git-bug/gitconfig.flatEntry], filter(before, func literal), after) } +./edit.go:476:38: can inline (*File).removeSection.func1.1 with cost 9 as: func(flatEntry) bool { return !e.inSection || e.sec != sk } +./edit.go:483:6: cannot inline (*File).renameSection: function too complex: cost 479 exceeds budget 80 +./edit.go:522:32: can inline (*File).renameSection.func1 with cost 55 as: func([]flatEntry, []flatEntry) bool { for loop; return slices.Equal[go.shape.[]github.com/git-bug/gitconfig.flatEntry,go.shape.struct { github.com/git-bug/gitconfig.inSection bool; github.com/git-bug/gitconfig.sec github.com/git-bug/gitconfig.sectionKey; github.com/git-bug/gitconfig.name string; github.com/git-bug/gitconfig.value string; github.com/git-bug/gitconfig.implicit bool }](&slices..dict.Equal[[]github.com/git-bug/gitconfig.flatEntry,github.com/git-bug/gitconfig.flatEntry], before, after) } +./env.go:30:6: cannot inline Scope.String: function too complex: cost 99 exceeds budget 80 +./env.go:120:6: can inline Discover with cost 72 as: func(string) (Env, error) { return Env(.autotmp_3), .autotmp_4 } +./load.go:31:6: cannot inline Env.repo: function too complex: cost 583 exceeds budget 80 +./load.go:180:6: cannot inline Env.newLoader: function too complex: cost 81 exceeds budget 80 +./load.go:162:6: cannot inline isMissing: function too complex: cost 125 exceeds budget 80 +./parse.go:55:6: can inline (*parsed).entries with cost 71 as: method(*parsed) func(Scope, string, []Entry) []Entry { for loop; return out } +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: can inline slices.Clone[go.shape.[]github.com/git-bug/gitconfig.Entry,go.shape.struct { Key github.com/git-bug/gitconfig.Key; Value string; Implicit bool; Origin github.com/git-bug/gitconfig.Origin }] with cost 11 as: func(*[4]uintptr, go.shape.[]github.com/git-bug/gitconfig.Entry) go.shape.[]github.com/git-bug/gitconfig.Entry { if slices.s == nil { return nil }; return append(go.shape.[]github.com/git-bug/gitconfig.Entry{}, slices.s...) } +./load.go:290:6: can inline dirPrefix with cost 44 as: func(string) string { i := strings.LastIndexByte(path, byte(47)); return path[:i + 1] } +./load.go:366:6: can inline isAbsPattern with cost 61 as: func(string) bool { if strings.HasPrefix(p, "/") { return true }; return false && filepath.IsAbs(filepath.FromSlash(p)) } +./glob.go:80:6: cannot inline compileClass: function too complex: cost 167 exceeds budget 80 +./glob.go:32:6: cannot inline compileGlob: function too complex: cost 307 exceeds budget 80 +./glob.go:215:6: can inline newStateSet with cost 8 as: func(int32) *stateSet { return &stateSet{...} } +./glob.go:225:6: can inline (*stateSet).add with cost 26 as: method(*stateSet) func(int32) bool { if ss.mark[id] == ss.gen { return false }; ss.mark[id] = ss.gen; ss.list = append(ss.list, id); return true } +./glob.go:219:6: can inline (*stateSet).reset with cost 11 as: method(*stateSet) func() { ss.list = ss.list[:0]; ss.gen++ } +./glob.go:131:6: can inline sameByte with cost 28 as: func(byte, byte, bool) bool { return a == b || fold && isAlpha(a) && a ^ byte(32) == b } +./glob.go:124:6: can inline swapCase with cost 22 as: func(byte) byte { if isAlpha(c) { return c ^ byte(32) }; return c } +./glob.go:113:6: cannot inline globToken.inClass: function too complex: cost 95 exceeds budget 80 +./glob.go:234:6: can inline (*stateSet).has with cost 8 as: method(*stateSet) func(int32) bool { return ss.mark[id] == ss.gen } +./glob.go:148:11: can inline globMatch.func1 with cost 60 as: func(*stateSet, int32) { for loop } +./glob.go:137:6: cannot inline globMatch: function too complex: cost 936 exceeds budget 80 +./load.go:330:6: cannot inline (*loader).gitdir: function too complex: cost 532 exceeds budget 80 +./load.go:104:6: cannot inline (*repo).branch: function too complex: cost 333 exceeds budget 80 +./load.go:300:6: cannot inline (*loader).condition: function too complex: cost 408 exceeds budget 80 +./key.go:54:6: can inline Key.String with cost 20 as: method(Key) func() string { if k.HasSubsection { return k.Section + "." + k.Subsection + "." + k.Name }; return k.Section + "." + k.Name } +./load.go:280:6: can inline (*loader).fail with cost 62 as: method(*loader) func(string, Entry, string) error { if from == "" { return &KeyError{...} }; return &FileError{...} } +./load.go:206:6: cannot inline (*loader).load: function too complex: cost 452 exceeds budget 80 +./load.go:241:6: cannot inline (*loader).include: function too complex: cost 529 exceeds budget 80 +./load.go:195:6: cannot inline (*loader).loadFile: function too complex: cost 208 exceeds budget 80 +./load.go:53:6: can inline (*repo).localConfig with cost 69 as: method(*repo) func() string { return filepath.Join(... argument...) } +./load.go:80:6: cannot inline worktreeConfigIn: function too complex: cost 117 exceeds budget 80 +./load.go:57:6: can inline (*repo).worktreeConfig with cost 69 as: method(*repo) func() string { return filepath.Join(... argument...) } +./key.go:12:6: cannot inline ParseKey: function too complex: cost 82 exceeds budget 80 +./load.go:374:6: cannot inline (*loader).command: function too complex: cost 188 exceeds budget 80 +./load.go:188:6: can inline (*loader).config with cost 62 as: method(*loader) func() *Config { return newConfig(l.entries) } +./env.go:137:6: cannot inline Env.Load: function too complex: cost 819 exceeds budget 80 +./env.go:178:6: cannot inline Env.LoadProtected: function too complex: cost 368 exceeds budget 80 +./env.go:247:6: cannot inline realPath: function too complex: cost 138 exceeds budget 80 +./env.go:208:6: cannot inline Env.SafeDirectory: function too complex: cost 686 exceeds budget 80 +./load.go:63:6: cannot inline (*repo).worktreeConfigEnabled: function too complex: cost 791 exceeds budget 80 +./load.go:97:6: cannot inline (*repo).severalWorktrees: function too complex: cost 143 exceeds budget 80 +./env.go:353:6: cannot inline Env.scopeFile: function too complex: cost 447 exceeds budget 80 +./env.go:269:6: cannot inline Env.LoadScope: function too complex: cost 508 exceeds budget 80 +./env.go:307:6: cannot inline Env.LoadFile: function too complex: cost 212 exceeds budget 80 +./env.go:326:6: cannot inline Env.WritePath: function too complex: cost 208 exceeds budget 80 +./update.go:96:6: cannot inline followLinks: function too complex: cost 571 exceeds budget 80 +./update.go:87:6: cannot inline callClosing: unhandled op DEFER +./update.go:88:8: can inline callClosing.func1 with cost 4 as: func() { f.closed = true } +./update.go:19:6: cannot inline updateFile: unhandled op DEFER +./update.go:34:8: can inline updateFile.func1 with cost 132 as: func() { if !committed { (*os.File).Close(lock); os.Remove(lockPath) } } +./update.go:79:27: can inline updateFile.func2 with cost 67 as: func() error { return os.Rename(lockPath, target) } +./env.go:379:6: cannot inline Env.UpdateScope: function too complex: cost 217 exceeds budget 80 +./env.go:424:6: can inline Env.UpdateFile with cost 63 as: method(Env) func(string, func(*File) error) error { return updateFile(path, Scope(0), fn) } +./errors.go:74:6: can inline (*KeyError).Error with cost 69 as: method(*KeyError) func() string { return fmt.Sprintf("%v: %q", ... argument...) } +./errors.go:78:6: can inline (*KeyError).Unwrap with cost 3 as: method(*KeyError) func() error { return e.Err } +./errors.go:111:6: can inline (*SyntaxError).Error with cost 72 as: method(*SyntaxError) func() string { return fmt.Sprintf("gitconfig: %s line %d in file %s", ... argument...) } +./errors.go:90:6: cannot inline (*FileError).Error: function too complex: cost 219 exceeds budget 80 +./errors.go:98:6: can inline (*FileError).Unwrap with cost 3 as: method(*FileError) func() error { return e.Err } +./errors.go:124:6: cannot inline (*ValueError).Error: function too complex: cost 344 exceeds budget 80 +./errors.go:140:6: can inline (*ValueError).Unwrap with cost 3 as: method(*ValueError) func() error { return e.Err } +./file.go:55:6: cannot inline Parse: function too complex: cost 101 exceeds budget 80 +./file.go:66:6: can inline (*File).Bytes with cost 16 as: method(*File) func() []byte { return bytes.Clone(f.data) } +./file.go:78:6: cannot inline (*File).Config: function too complex: cost 150 exceeds budget 80 +./file.go:92:6: cannot inline (*File).Set: function too complex: cost 520 exceeds budget 80 +./file.go:112:6: cannot inline (*File).ReplaceAll: function too complex: cost 559 exceeds budget 80 +./file.go:131:6: cannot inline (*File).Add: function too complex: cost 340 exceeds budget 80 +./file.go:141:72: can inline (*File).Add.func1 with cost 158 as: func([]flatEntry, []flatEntry) bool { got := filter(after, func literal); return .autotmp_4(before, after) && !got[len(got) - 1].implicit } +./file.go:143:24: can inline (*File).Add.func1.1 with cost 30 as: func(flatEntry) bool { return flatEntry.is(e, k) } +./file.go:151:6: cannot inline (*File).Unset: function too complex: cost 329 exceeds budget 80 +./file.go:169:6: cannot inline (*File).UnsetAll: function too complex: cost 324 exceeds budget 80 +./file.go:187:6: cannot inline (*File).RemoveSection: function too complex: cost 253 exceeds budget 80 +./file.go:200:6: cannot inline (*File).RemoveSubsection: function too complex: cost 341 exceeds budget 80 +./file.go:220:6: cannot inline (*File).RenameSection: function too complex: cost 464 exceeds budget 80 +./file.go:240:6: cannot inline (*File).RenameSubsection: function too complex: cost 412 exceeds budget 80 +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:6: can inline atomic.(*Pointer[go.shape.struct { os.mu sync.Mutex; os.buf *[]uint8; os.nbuf int; os.bufp int }]).CompareAndSwap with cost 63 as: method(*atomic.Pointer[go.shape.struct { os.mu sync.Mutex; os.buf *[]uint8; os.nbuf int; os.bufp int }]) func(*[16]uintptr, *go.shape.struct { os.mu sync.Mutex; os.buf *[]uint8; os.nbuf int; os.bufp int }, *go.shape.struct { os.mu sync.Mutex; os.buf *[]uint8; os.nbuf int; os.bufp int }) bool { return atomic.CompareAndSwapPointer(&atomic.x.v, unsafe.Pointer(atomic.old), unsafe.Pointer(atomic.new)) } +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:64:6: can inline atomic.(*Pointer[go.shape.struct { os.mu sync.Mutex; os.buf *[]uint8; os.nbuf int; os.bufp int }]).Swap with cost 62 as: method(*atomic.Pointer[go.shape.struct { os.mu sync.Mutex; os.buf *[]uint8; os.nbuf int; os.bufp int }]) func(*[16]uintptr, *go.shape.struct { os.mu sync.Mutex; os.buf *[]uint8; os.nbuf int; os.bufp int }) *go.shape.struct { os.mu sync.Mutex; os.buf *[]uint8; os.nbuf int; os.bufp int } { return (*go.shape.struct { os.mu sync.Mutex; os.buf *[]uint8; os.nbuf int; os.bufp int })(atomic.SwapPointer(&atomic.x.v, unsafe.Pointer(atomic.new))) } +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:61:6: can inline atomic.(*Pointer[go.shape.struct { os.mu sync.Mutex; os.buf *[]uint8; os.nbuf int; os.bufp int }]).Store with cost 61 as: method(*atomic.Pointer[go.shape.struct { os.mu sync.Mutex; os.buf *[]uint8; os.nbuf int; os.bufp int }]) func(*[16]uintptr, *go.shape.struct { os.mu sync.Mutex; os.buf *[]uint8; os.nbuf int; os.bufp int }) { atomic.StorePointer(&atomic.x.v, unsafe.Pointer(atomic.val)) } +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:58:6: can inline atomic.(*Pointer[go.shape.struct { os.mu sync.Mutex; os.buf *[]uint8; os.nbuf int; os.bufp int }]).Load with cost 4 as: method(*atomic.Pointer[go.shape.struct { os.mu sync.Mutex; os.buf *[]uint8; os.nbuf int; os.bufp int }]) func(*[16]uintptr) *go.shape.struct { os.mu sync.Mutex; os.buf *[]uint8; os.nbuf int; os.bufp int } { return (*go.shape.struct { os.mu sync.Mutex; os.buf *[]uint8; os.nbuf int; os.bufp int })(atomic.LoadPointer(&atomic.x.v)) } +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:6: can inline atomic.(*Pointer[os.dirInfo]).CompareAndSwap with cost 70 as: method(*atomic.Pointer[os.dirInfo]) func(*os.dirInfo, *os.dirInfo) bool { return (*atomic.Pointer[go.shape.struct { os.mu sync.Mutex; os.buf *[]uint8; os.nbuf int; os.bufp int }]).CompareAndSwap(atomic.x, &atomic..dict.Pointer[os.dirInfo], atomic.old, atomic.new) } +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:64:6: can inline atomic.(*Pointer[os.dirInfo]).Swap with cost 68 as: method(*atomic.Pointer[os.dirInfo]) func(*os.dirInfo) *os.dirInfo { return (*atomic.Pointer[go.shape.struct { os.mu sync.Mutex; os.buf *[]uint8; os.nbuf int; os.bufp int }]).Swap(atomic.x, &atomic..dict.Pointer[os.dirInfo], atomic.new) } +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:61:6: can inline atomic.(*Pointer[os.dirInfo]).Store with cost 66 as: method(*atomic.Pointer[os.dirInfo]) func(*os.dirInfo) { (*atomic.Pointer[go.shape.struct { os.mu sync.Mutex; os.buf *[]uint8; os.nbuf int; os.bufp int }]).Store(atomic.x, &atomic..dict.Pointer[os.dirInfo], atomic.val) } +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:58:6: can inline atomic.(*Pointer[os.dirInfo]).Load with cost 9 as: method(*atomic.Pointer[os.dirInfo]) func() *os.dirInfo { return (*atomic.Pointer[go.shape.struct { os.mu sync.Mutex; os.buf *[]uint8; os.nbuf int; os.bufp int }]).Load(atomic.x, &atomic..dict.Pointer[os.dirInfo]) } +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:20:6: can inline slices.Equal[[]github.com/git-bug/gitconfig.flatEntry,github.com/git-bug/gitconfig.flatEntry] with cost 32 as: func([]flatEntry, []flatEntry) bool { return slices.Equal[go.shape.[]github.com/git-bug/gitconfig.flatEntry,go.shape.struct { github.com/git-bug/gitconfig.inSection bool; github.com/git-bug/gitconfig.sec github.com/git-bug/gitconfig.sectionKey; github.com/git-bug/gitconfig.name string; github.com/git-bug/gitconfig.value string; github.com/git-bug/gitconfig.implicit bool }](&slices..dict.Equal[[]github.com/git-bug/gitconfig.flatEntry,github.com/git-bug/gitconfig.flatEntry], slices.s1, slices.s2) } +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: can inline slices.Clone[[]github.com/git-bug/gitconfig.Entry,github.com/git-bug/gitconfig.Entry] with cost 17 as: func([]Entry) []Entry { return slices.Clone[go.shape.[]github.com/git-bug/gitconfig.Entry,go.shape.struct { Key github.com/git-bug/gitconfig.Key; Value string; Implicit bool; Origin github.com/git-bug/gitconfig.Origin }](&slices..dict.Clone[[]github.com/git-bug/gitconfig.Entry,github.com/git-bug/gitconfig.Entry], slices.s) } +../../.asdf/installs/golang/1.27.1/go/src/slices/sort.go:30:6: cannot inline slices.SortFunc[[]github.com/git-bug/gitconfig.splice,github.com/git-bug/gitconfig.splice]: function too complex: cost 83 exceeds budget 80 +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: can inline slices.Clone[[]string,string] with cost 17 as: func([]string) []string { return slices.Clone[go.shape.[]string,go.shape.string](&slices..dict.Clone[[]string,string], slices.s) } +./discover.go:136:36: inlining call to errors.New +./edit.go:17:31: inlining call to errors.New +./errors.go:23:26: inlining call to errors.New +./errors.go:27:32: inlining call to errors.New +./errors.go:32:28: inlining call to errors.New +./errors.go:36:30: inlining call to errors.New +./errors.go:40:24: inlining call to errors.New +./errors.go:44:30: inlining call to errors.New +./errors.go:48:27: inlining call to errors.New +./errors.go:52:28: inlining call to errors.New +./errors.go:56:29: inlining call to errors.New +./errors.go:60:25: inlining call to errors.New +./errors.go:64:24: inlining call to errors.New +./update.go:16:33: inlining call to errors.New +./value.go:12:32: inlining call to errors.New +./value.go:113:26: inlining call to errors.New +./value.go:114:26: inlining call to errors.New +./value.go:115:26: inlining call to errors.New +./config.go:40:28: inlining call to Key.sectionKey +./key.go:75:16: inlining call to isAlpha +./key.go:85:24: inlining call to isAlpha +./key.go:89:16: inlining call to isKeyChar +./key.go:89:16: inlining call to isAlpha +./key.go:100:16: inlining call to isKeyChar +./key.go:100:16: inlining call to isAlpha +./key.go:110:29: inlining call to strings.ContainsAny +./key.go:26:28: inlining call to strings.IndexByte +./key.go:27:31: inlining call to strings.LastIndexByte +./key.go:32:15: inlining call to validName +./key.go:35:27: inlining call to lowerASCII +./key.go:37:19: inlining call to validSection +./key.go:40:25: inlining call to lowerASCII +./key.go:43:18: inlining call to validSection +./key.go:43:49: inlining call to validSubsection +./key.go:46:24: inlining call to lowerASCII +./key.go:26:28: inlining call to stringslite.IndexByte +./key.go:27:31: inlining call to bytealg.LastIndexByteString +./key.go:32:15: inlining call to isAlpha +./key.go:32:15: inlining call to isKeyChar +./key.go:37:19: inlining call to isKeyChar +./key.go:43:18: inlining call to isKeyChar +./key.go:43:49: inlining call to strings.ContainsAny +./key.go:32:15: inlining call to isAlpha +./key.go:37:19: inlining call to isAlpha +./key.go:43:18: inlining call to isAlpha +./config.go:67:23: inlining call to Key.sectionKey +./config.go:114:48: inlining call to lowerASCII +./config.go:114:17: inlining call to (*Config).filter +./config.go:121:39: inlining call to lowerASCII +./config.go:121:17: inlining call to (*Config).filter +./config.go:132:46: inlining call to lowerASCII +./config.go:132:21: inlining call to slices.Clone[go.shape.[]string,go.shape.string] +./value.go:45:66: inlining call to digitValue +./value.go:56:25: inlining call to digitValue +./value.go:17:30: inlining call to equalFoldASCII +./value.go:17:58: inlining call to equalFoldASCII +./value.go:17:83: inlining call to equalFoldASCII +./value.go:19:21: inlining call to equalFoldASCII +./value.go:19:48: inlining call to equalFoldASCII +./value.go:19:74: inlining call to equalFoldASCII +./config.go:240:24: inlining call to Entry.error +./config.go:250:20: inlining call to Entry.error +./config.go:254:20: inlining call to Entry.error +./value.go:122:24: inlining call to strings.HasPrefix +./value.go:124:36: inlining call to strings.HasPrefix +./value.go:129:24: inlining call to strings.HasPrefix +./value.go:122:24: inlining call to stringslite.HasPrefix +./value.go:124:36: inlining call to stringslite.HasPrefix +./value.go:129:24: inlining call to stringslite.HasPrefix +./config.go:267:21: inlining call to Entry.error +./config.go:271:21: inlining call to Entry.error +./discover.go:113:14: inlining call to get +./discover.go:119:25: inlining call to fmt.Errorf +./discover.go:123:57: inlining call to strconv.Itoa +./discover.go:125:26: inlining call to fmt.Errorf +./discover.go:127:61: inlining call to strconv.Itoa +./discover.go:129:26: inlining call to fmt.Errorf +./discover.go:119:25: inlining call to errors.New +./discover.go:123:57: inlining call to strconv.Itoa +./discover.go:125:26: inlining call to errors.New +./discover.go:127:61: inlining call to strconv.Itoa +./discover.go:129:26: inlining call to errors.New +./discover.go:193:25: inlining call to strings.IndexByte +./discover.go:197:17: inlining call to strings.(*Builder).WriteString +./discover.go:200:16: inlining call to strings.(*Builder).WriteByte +./discover.go:204:19: inlining call to strings.(*Builder).String +./discover.go:193:25: inlining call to stringslite.IndexByte +./discover.go:197:17: inlining call to strings.(*Builder).copyCheck +./discover.go:200:16: inlining call to strings.(*Builder).copyCheck +./discover.go:197:17: inlining call to abi.NoEscape +./discover.go:200:16: inlining call to abi.NoEscape +./discover.go:182:26: inlining call to strings.IndexByte +./discover.go:182:26: inlining call to stringslite.IndexByte +./discover.go:156:32: inlining call to strings.CutPrefix +./discover.go:158:30: inlining call to isParamSpace +./discover.go:167:36: inlining call to strings.Cut +./discover.go:172:33: inlining call to isParamSpace +./discover.go:156:32: inlining call to stringslite.CutPrefix +./discover.go:158:30: inlining call to strings.IndexByte +./discover.go:172:33: inlining call to strings.IndexByte +./discover.go:156:32: inlining call to stringslite.HasPrefix +./discover.go:158:30: inlining call to stringslite.IndexByte +./discover.go:172:33: inlining call to stringslite.IndexByte +./load.go:136:24: inlining call to openRegular +./load.go:145:26: inlining call to fs.FileMode.IsRegular +./load.go:151:40: inlining call to io.LimitReader +./load.go:140:16: inlining call to os.(*File).Close +./discover.go:92:39: inlining call to fs.FileMode.IsRegular +./discover.go:95:24: inlining call to readSmall +./discover.go:99:31: inlining call to strings.CutPrefix +./discover.go:101:54: inlining call to errors.New +./discover.go:103:20: inlining call to filepath.IsAbs +./discover.go:104:36: inlining call to filepath.Dir +./discover.go:104:23: inlining call to filepath.Join +./discover.go:99:31: inlining call to stringslite.CutPrefix +./discover.go:103:20: inlining call to filepathlite.IsAbs +./discover.go:99:31: inlining call to stringslite.HasPrefix +./discover.go:103:20: inlining call to stringslite.HasPrefix +./discover.go:30:14: inlining call to get +./discover.go:40:16: inlining call to get +./discover.go:41:57: inlining call to filepath.Join +./discover.go:43:57: inlining call to filepath.Join +./discover.go:46:57: inlining call to filepath.Join +./discover.go:54:28: inlining call to fmt.Errorf +./discover.go:70:36: inlining call to get +./discover.go:54:28: inlining call to errors.New +./edit.go:33:28: inlining call to strings.IndexByte +./edit.go:34:31: inlining call to strings.LastIndexByte +./edit.go:33:28: inlining call to stringslite.IndexByte +./edit.go:34:31: inlining call to bytealg.LastIndexByteString +./edit.go:60:22: inlining call to strings.IndexByte +./edit.go:60:22: inlining call to stringslite.IndexByte +./edit.go:44:23: inlining call to (*File).checkOpen +./edit.go:76:20: inlining call to Key.sectionKey +./edit.go:78:53: inlining call to (*parsed).secOf +./edit.go:78:75: inlining call to (*parsed).nameOf +./edit.go:99:53: inlining call to (*parsed).secOf +./edit.go:99:67: inlining call to (*parsed).nameOf +./edit.go:99:82: inlining call to (*parsed).valueOf +./edit.go:106:45: inlining call to Key.sectionKey +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:244:28: inlining call to slices.nextPowerOfTwo +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:247:33: inlining call to slices.(*xorshift).Next +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:308:22: inlining call to slices.order2CmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:309:22: inlining call to slices.order2CmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:310:22: inlining call to slices.order2CmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:279:29: inlining call to slices.medianAdjacentCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:280:29: inlining call to slices.medianAdjacentCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:281:29: inlining call to slices.medianAdjacentCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:73:24: inlining call to slices.insertionSortCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] +../../.asdf/installs/golang/1.27.1/go/src/slices/zsortanyfunc.go:91:23: inlining call to slices.reverseRangeCmpFunc[go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] +./parse.go:153:20: inlining call to isNewline +./parse.go:219:30: inlining call to isKeyChar +./parse.go:222:20: inlining call to lowerASCII +./parse.go:224:19: inlining call to (*parser).errorAt +./parse.go:231:20: inlining call to (*parser).errorAt +./parse.go:234:30: inlining call to strings.IndexByte +./parse.go:240:14: inlining call to isSpace +./parse.go:241:28: inlining call to isSpace +./parse.go:245:20: inlining call to (*parser).errorAt +./parse.go:251:21: inlining call to (*parser).errorAt +./parse.go:260:22: inlining call to (*parser).errorAt +./parse.go:267:21: inlining call to (*parser).errorAt +./parse.go:273:30: inlining call to isNewline +./parse.go:274:20: inlining call to (*parser).errorAt +./parse.go:277:20: inlining call to (*parser).errorAt +./parse.go:281:30: inlining call to strings.IndexByte +./parse.go:287:19: inlining call to (*parser).errorAt +./parse.go:290:14: inlining call to (*parser).setSection +./parse.go:292:7: inlining call to (*parser).add +./parse.go:219:30: inlining call to isAlpha +./parse.go:234:30: inlining call to stringslite.IndexByte +./parse.go:240:14: inlining call to isNewline +./parse.go:241:28: inlining call to isNewline +./parse.go:281:30: inlining call to stringslite.IndexByte +./parse.go:123:13: inlining call to (*parser).add +./parse.go:126:17: inlining call to lowerASCII +./parse.go:350:15: inlining call to isNewline +./parse.go:352:34: inlining call to (*parser).errorAt +./parse.go:360:35: inlining call to (*parser).errorAt +./parse.go:362:10: inlining call to (*parser).value.func2 +./parse.go:367:9: inlining call to (*parser).value.func2 +./parse.go:368:16: inlining call to isNewline +./parse.go:369:24: inlining call to newlineLen +./parse.go:386:34: inlining call to (*parser).errorAt +./parse.go:390:9: inlining call to (*parser).value.func2 +./parse.go:404:9: inlining call to (*parser).value.func2 +./parse.go:410:32: inlining call to (*parser).errorAt +./parse.go:413:25: inlining call to bytes.IndexByte +./parse.go:300:29: inlining call to isKeyChar +./parse.go:308:29: inlining call to isNewline +./parse.go:314:19: inlining call to (*parser).errorAt +./parse.go:300:29: inlining call to isAlpha +./parse.go:173:20: inlining call to bytes.HasPrefix +./parse.go:174:8: inlining call to (*parser).add +./parse.go:181:15: inlining call to isSpace +./parse.go:182:33: inlining call to isSpace +./parse.go:185:9: inlining call to (*parser).add +./parse.go:186:17: inlining call to isNewline +./parse.go:187:23: inlining call to newlineLen +./parse.go:188:9: inlining call to (*parser).add +./parse.go:192:27: inlining call to bytes.IndexByte +./parse.go:199:9: inlining call to (*parser).add +./parse.go:204:15: inlining call to isAlpha +./parse.go:209:20: inlining call to (*parser).errorAt +./parse.go:173:20: inlining call to bytes.Equal +./parse.go:181:15: inlining call to isNewline +./parse.go:182:33: inlining call to isNewline +./edit.go:112:17: inlining call to slices.SortFunc[go.shape.[]github.com/git-bug/gitconfig.splice,go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] +./edit.go:122:33: inlining call to flatten +./edit.go:122:52: inlining call to flatten +./edit.go:122:33: inlining call to (*parsed).secOf +./edit.go:122:33: inlining call to (*parsed).nameOf +./edit.go:122:33: inlining call to (*parsed).valueOf +./edit.go:122:52: inlining call to (*parsed).secOf +./edit.go:122:52: inlining call to (*parsed).nameOf +./edit.go:122:52: inlining call to (*parsed).valueOf +./edit.go:136:26: inlining call to filter +./edit.go:136:49: inlining call to filter +./edit.go:136:19: inlining call to slices.Equal[go.shape.[]github.com/git-bug/gitconfig.flatEntry,go.shape.struct { github.com/git-bug/gitconfig.inSection bool; github.com/git-bug/gitconfig.sec github.com/git-bug/gitconfig.sectionKey; github.com/git-bug/gitconfig.name string; github.com/git-bug/gitconfig.value string; github.com/git-bug/gitconfig.implicit bool }] +./edit.go:139:16: inlining call to filter +./edit.go:136:26: inlining call to checkKey.func1.1 +./edit.go:136:49: inlining call to checkKey.func1.1 +./edit.go:139:16: inlining call to checkKey.func1.2 +./edit.go:136:26: inlining call to flatEntry.is +./edit.go:136:49: inlining call to flatEntry.is +./edit.go:139:16: inlining call to flatEntry.is +./edit.go:136:26: inlining call to Key.sectionKey +./edit.go:136:49: inlining call to Key.sectionKey +./edit.go:139:16: inlining call to Key.sectionKey +./edit.go:135:49: inlining call to flatEntry.is +./edit.go:135:49: inlining call to Key.sectionKey +./edit.go:139:60: inlining call to flatEntry.is +./edit.go:139:60: inlining call to Key.sectionKey +./edit.go:195:24: inlining call to (*File).newlineAfter +./edit.go:230:28: inlining call to strings.HasPrefix +./edit.go:230:57: inlining call to strings.HasSuffix +./edit.go:230:88: inlining call to strings.ContainsAny +./edit.go:232:15: inlining call to strings.(*Builder).WriteByte +./edit.go:237:16: inlining call to strings.(*Builder).WriteByte +./edit.go:238:16: inlining call to strings.(*Builder).WriteByte +./edit.go:240:18: inlining call to strings.(*Builder).WriteString +./edit.go:242:18: inlining call to strings.(*Builder).WriteString +./edit.go:244:16: inlining call to strings.(*Builder).WriteByte +./edit.go:248:15: inlining call to strings.(*Builder).WriteByte +./edit.go:250:18: inlining call to strings.(*Builder).String +./edit.go:230:28: inlining call to stringslite.HasPrefix +./edit.go:230:57: inlining call to stringslite.HasSuffix +./edit.go:232:15: inlining call to strings.(*Builder).copyCheck +./edit.go:237:16: inlining call to strings.(*Builder).copyCheck +./edit.go:238:16: inlining call to strings.(*Builder).copyCheck +./edit.go:240:18: inlining call to strings.(*Builder).copyCheck +./edit.go:242:18: inlining call to strings.(*Builder).copyCheck +./edit.go:244:16: inlining call to strings.(*Builder).copyCheck +./edit.go:248:15: inlining call to strings.(*Builder).copyCheck +./edit.go:232:15: inlining call to abi.NoEscape +./edit.go:237:16: inlining call to abi.NoEscape +./edit.go:238:16: inlining call to abi.NoEscape +./edit.go:240:18: inlining call to abi.NoEscape +./edit.go:242:18: inlining call to abi.NoEscape +./edit.go:244:16: inlining call to abi.NoEscape +./edit.go:248:15: inlining call to abi.NoEscape +./edit.go:258:26: inlining call to strings.NewReplacer +./edit.go:285:21: inlining call to (*File).newlineAfter +./edit.go:264:21: inlining call to formatEntry +./edit.go:265:19: inlining call to (*File).firstOnLine +./edit.go:269:26: inlining call to (*File).ownStart +./edit.go:275:18: inlining call to (*File).firstOnLine +./edit.go:276:27: inlining call to (*File).ownStart +./edit.go:278:26: inlining call to (*File).ownStart +./edit.go:354:66: inlining call to (*File).unsetEntry.func1 +./edit.go:357:16: inlining call to (*File).unsetEntry.func1 +./edit.go:364:82: inlining call to (*File).unsetEntry.func1 +./edit.go:380:20: inlining call to (*File).lineEnd +./edit.go:354:66: inlining call to (*parsed).secOf +./edit.go:357:16: inlining call to (*parsed).secOf +./edit.go:364:82: inlining call to (*parsed).secOf +./edit.go:380:20: inlining call to (*File).newlineAfter +./edit.go:348:76: inlining call to (*parsed).secOf +./edit.go:334:17: inlining call to slices.SortFunc[go.shape.[]github.com/git-bug/gitconfig.splice,go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] +./edit.go:399:20: inlining call to Key.sectionKey +./edit.go:402:38: inlining call to (*parsed).secOf +./edit.go:406:21: inlining call to formatEntry +./edit.go:408:55: inlining call to (*File).terminator +./edit.go:418:25: inlining call to (*File).newlineAfter +./edit.go:427:55: inlining call to (*File).terminator +./edit.go:440:35: inlining call to validSection +./edit.go:440:35: inlining call to isKeyChar +./edit.go:440:35: inlining call to isAlpha +./edit.go:450:38: inlining call to (*parsed).secOf +./edit.go:460:24: inlining call to (*File).headersOf +./edit.go:469:21: inlining call to (*File).ownStart +./edit.go:473:46: inlining call to (*File).ownStart +./edit.go:460:24: inlining call to (*parsed).secOf +./edit.go:476:29: inlining call to filter +./edit.go:476:22: inlining call to slices.Equal[go.shape.[]github.com/git-bug/gitconfig.flatEntry,go.shape.struct { github.com/git-bug/gitconfig.inSection bool; github.com/git-bug/gitconfig.sec github.com/git-bug/gitconfig.sectionKey; github.com/git-bug/gitconfig.name string; github.com/git-bug/gitconfig.value string; github.com/git-bug/gitconfig.implicit bool }] +./edit.go:476:29: inlining call to (*File).removeSection.func1.1 +./edit.go:484:24: inlining call to (*File).headersOf +./edit.go:494:20: inlining call to (*File).firstOnLine +./edit.go:505:25: inlining call to (*File).newlineAfter +./edit.go:512:40: inlining call to (*parsed).secOf +./edit.go:519:46: inlining call to (*File).ownStart +./edit.go:519:60: inlining call to (*File).lineEnd +./edit.go:484:24: inlining call to (*parsed).secOf +./edit.go:519:60: inlining call to (*File).newlineAfter +./edit.go:528:22: inlining call to slices.Equal[go.shape.[]github.com/git-bug/gitconfig.flatEntry,go.shape.struct { github.com/git-bug/gitconfig.inSection bool; github.com/git-bug/gitconfig.sec github.com/git-bug/gitconfig.sectionKey; github.com/git-bug/gitconfig.name string; github.com/git-bug/gitconfig.value string; github.com/git-bug/gitconfig.implicit bool }] +./env.go:45:32: inlining call to strconv.Itoa +./env.go:45:32: inlining call to strconv.Itoa +./load.go:35:20: inlining call to filepath.IsAbs +./load.go:39:38: inlining call to filepath.Join +./load.go:39:24: inlining call to readSmall +./load.go:43:21: inlining call to filepath.IsAbs +./load.go:44:23: inlining call to filepath.Join +./load.go:46:31: inlining call to filepath.Clean +./load.go:48:45: inlining call to filepath.Join +./load.go:35:20: inlining call to filepathlite.IsAbs +./load.go:43:21: inlining call to filepathlite.IsAbs +./load.go:35:20: inlining call to stringslite.HasPrefix +./load.go:43:21: inlining call to stringslite.HasPrefix +./load.go:291:28: inlining call to strings.LastIndexByte +./load.go:291:28: inlining call to bytealg.LastIndexByteString +./load.go:367:22: inlining call to strings.HasPrefix +./load.go:370:71: inlining call to filepath.FromSlash +./load.go:370:52: inlining call to filepath.IsAbs +./load.go:367:22: inlining call to stringslite.HasPrefix +./load.go:370:71: inlining call to filepathlite.FromSlash +./load.go:370:52: inlining call to filepathlite.IsAbs +./load.go:370:52: inlining call to stringslite.HasPrefix +./glob.go:132:34: inlining call to isAlpha +./glob.go:125:12: inlining call to isAlpha +./glob.go:116:56: inlining call to swapCase +./glob.go:116:71: inlining call to swapCase +./glob.go:116:56: inlining call to isAlpha +./glob.go:116:71: inlining call to isAlpha +./glob.go:143:20: inlining call to newStateSet +./glob.go:144:21: inlining call to newStateSet +./glob.go:157:7: inlining call to globMatch.func1 +./glob.go:160:13: inlining call to (*stateSet).reset +./glob.go:165:13: inlining call to (*stateSet).add +./glob.go:167:11: inlining call to globMatch.func1 +./glob.go:176:16: inlining call to sameByte +./glob.go:177:11: inlining call to globMatch.func1 +./glob.go:181:11: inlining call to globMatch.func1 +./glob.go:185:11: inlining call to globMatch.func1 +./glob.go:189:11: inlining call to globMatch.func1 +./glob.go:192:13: inlining call to (*stateSet).add +./glob.go:194:11: inlining call to globMatch.func1 +./glob.go:197:10: inlining call to globMatch.func1 +./glob.go:205:16: inlining call to (*stateSet).has +./glob.go:157:7: inlining call to (*stateSet).add +./glob.go:167:11: inlining call to (*stateSet).add +./glob.go:176:16: inlining call to isAlpha +./glob.go:177:11: inlining call to (*stateSet).add +./glob.go:181:11: inlining call to (*stateSet).add +./glob.go:185:11: inlining call to (*stateSet).add +./glob.go:189:11: inlining call to (*stateSet).add +./glob.go:194:11: inlining call to (*stateSet).add +./glob.go:197:10: inlining call to (*stateSet).add +./glob.go:149:14: inlining call to (*stateSet).add +./load.go:332:24: inlining call to strings.HasPrefix +./load.go:336:39: inlining call to dirPrefix +./load.go:336:29: inlining call to filepath.ToSlash +./load.go:337:24: inlining call to strings.HasPrefix +./load.go:341:48: inlining call to filepath.ToSlash +./load.go:341:31: inlining call to strings.TrimSuffix +./load.go:346:18: inlining call to isAbsPattern +./load.go:349:22: inlining call to strings.HasSuffix +./load.go:352:25: inlining call to filepath.ToSlash +./load.go:357:30: inlining call to filepath.ToSlash +./load.go:332:24: inlining call to stringslite.HasPrefix +./load.go:336:39: inlining call to strings.LastIndexByte +./load.go:336:29: inlining call to filepathlite.ToSlash +./load.go:337:24: inlining call to stringslite.HasPrefix +./load.go:341:48: inlining call to filepathlite.ToSlash +./load.go:341:31: inlining call to stringslite.TrimSuffix +./load.go:346:18: inlining call to strings.HasPrefix +./load.go:346:18: inlining call to filepath.FromSlash +./load.go:346:18: inlining call to filepath.IsAbs +./load.go:349:22: inlining call to stringslite.HasSuffix +./load.go:352:25: inlining call to filepathlite.ToSlash +./load.go:357:30: inlining call to filepathlite.ToSlash +./load.go:336:39: inlining call to bytealg.LastIndexByteString +./load.go:341:31: inlining call to stringslite.HasSuffix +./load.go:346:18: inlining call to stringslite.HasPrefix +./load.go:346:18: inlining call to filepathlite.FromSlash +./load.go:346:18: inlining call to filepathlite.IsAbs +./load.go:346:18: inlining call to stringslite.HasPrefix +./load.go:105:38: inlining call to filepath.Join +./load.go:105:24: inlining call to readSmall +./load.go:109:28: inlining call to strings.CutPrefix +./load.go:114:31: inlining call to strings.CutPrefix +./load.go:109:28: inlining call to stringslite.CutPrefix +./load.go:114:31: inlining call to stringslite.CutPrefix +./load.go:109:28: inlining call to stringslite.HasPrefix +./load.go:114:31: inlining call to stringslite.HasPrefix +./load.go:302:24: inlining call to strings.HasPrefix +./load.go:304:24: inlining call to strings.HasPrefix +./load.go:306:24: inlining call to strings.HasPrefix +./load.go:317:23: inlining call to strings.HasSuffix +./load.go:302:24: inlining call to stringslite.HasPrefix +./load.go:304:24: inlining call to stringslite.HasPrefix +./load.go:306:24: inlining call to stringslite.HasPrefix +./load.go:317:23: inlining call to stringslite.HasSuffix +./load.go:282:37: inlining call to Key.String +./load.go:282:56: inlining call to errors.New +./load.go:225:24: inlining call to (*parsed).entries +./load.go:228:21: inlining call to slices.Clone[go.shape.[]github.com/git-bug/gitconfig.Entry,go.shape.struct { Key github.com/git-bug/gitconfig.Key; Value string; Implicit bool; Origin github.com/git-bug/gitconfig.Origin }] +./load.go:257:16: inlining call to (*loader).fail +./load.go:266:20: inlining call to filepath.IsAbs +./load.go:270:19: inlining call to dirPrefix +./load.go:273:48: inlining call to fmt.Errorf +./load.go:257:16: inlining call to Key.String +./load.go:257:16: inlining call to errors.New +./load.go:266:20: inlining call to filepathlite.IsAbs +./load.go:270:19: inlining call to strings.LastIndexByte +./load.go:273:48: inlining call to errors.New +./load.go:266:20: inlining call to stringslite.HasPrefix +./load.go:270:19: inlining call to bytealg.LastIndexByteString +./load.go:54:22: inlining call to filepath.Join +./load.go:58:22: inlining call to filepath.Join +./env.go:154:42: inlining call to (*repo).localConfig +./env.go:157:68: inlining call to (*repo).localConfig +./env.go:162:46: inlining call to (*repo).worktreeConfig +./env.go:170:17: inlining call to (*loader).config +./env.go:154:42: inlining call to filepath.Join +./env.go:157:68: inlining call to filepath.Join +./env.go:162:46: inlining call to filepath.Join +./env.go:196:17: inlining call to (*loader).config +./env.go:251:23: inlining call to filepath.Clean +./env.go:221:25: inlining call to strings.HasSuffix +./env.go:222:50: inlining call to strings.TrimSuffix +./env.go:227:49: inlining call to strings.TrimSuffix +./env.go:227:25: inlining call to strings.HasPrefix +./env.go:233:36: inlining call to filepath.IsAbs +./env.go:221:25: inlining call to stringslite.HasSuffix +./env.go:222:50: inlining call to stringslite.TrimSuffix +./env.go:227:49: inlining call to stringslite.TrimSuffix +./env.go:227:25: inlining call to stringslite.HasPrefix +./env.go:233:36: inlining call to filepathlite.IsAbs +./env.go:222:50: inlining call to stringslite.HasSuffix +./env.go:227:49: inlining call to stringslite.HasSuffix +./env.go:233:36: inlining call to stringslite.HasPrefix +./load.go:64:43: inlining call to (*repo).localConfig +./load.go:69:47: inlining call to (*repo).localConfig +./load.go:71:31: inlining call to (*repo).localConfig +./load.go:73:47: inlining call to (*repo).localConfig +./load.go:75:61: inlining call to (*repo).localConfig +./load.go:75:35: inlining call to (*parsed).entries +./load.go:75:84: inlining call to (*repo).localConfig +./load.go:64:43: inlining call to filepath.Join +./load.go:69:47: inlining call to filepath.Join +./load.go:71:31: inlining call to filepath.Join +./load.go:73:47: inlining call to filepath.Join +./load.go:75:61: inlining call to filepath.Join +./load.go:75:84: inlining call to filepath.Join +./load.go:98:42: inlining call to filepath.Join +./env.go:362:23: inlining call to (*repo).localConfig +./env.go:369:26: inlining call to (*repo).worktreeConfig +./env.go:373:22: inlining call to (*repo).localConfig +./env.go:362:23: inlining call to filepath.Join +./env.go:369:26: inlining call to filepath.Join +./env.go:373:22: inlining call to filepath.Join +./env.go:300:17: inlining call to (*loader).config +./env.go:315:17: inlining call to (*loader).config +./update.go:107:27: inlining call to fs.FileMode.IsRegular +./update.go:114:27: inlining call to os.Readlink +./update.go:118:21: inlining call to filepath.IsAbs +./update.go:119:37: inlining call to filepath.Dir +./update.go:119:24: inlining call to filepath.Join +./update.go:118:21: inlining call to filepathlite.IsAbs +./update.go:118:21: inlining call to stringslite.HasPrefix +./update.go:59:16: inlining call to bytes.Equal +./update.go:72:38: inlining call to fs.FileMode.Perm +./update.go:72:23: inlining call to os.(*File).Chmod +./update.go:76:22: inlining call to os.(*File).Close +./update.go:36:14: inlining call to os.(*File).Close +./update.go:79:58: inlining call to os.Rename +./errors.go:93:18: inlining call to (*SyntaxError).Error +./errors.go:127:85: inlining call to Key.String +./errors.go:129:99: inlining call to Key.String +./file.go:56:20: inlining call to bytes.Clone +./file.go:67:20: inlining call to bytes.Clone +./file.go:80:31: inlining call to (*parsed).entries +./file.go:97:20: inlining call to (*File).entriesOf +./file.go:102:54: inlining call to (*parsed).valueOf +./file.go:105:78: inlining call to checkKey +./file.go:107:80: inlining call to checkKey +./file.go:97:20: inlining call to Key.sectionKey +./file.go:97:20: inlining call to (*parsed).secOf +./file.go:97:20: inlining call to (*parsed).nameOf +./file.go:117:20: inlining call to (*File).entriesOf +./file.go:119:81: inlining call to checkKey +./file.go:127:39: inlining call to checkKey +./file.go:117:20: inlining call to Key.sectionKey +./file.go:117:20: inlining call to (*parsed).secOf +./file.go:117:20: inlining call to (*parsed).nameOf +./file.go:137:31: inlining call to (*File).entriesOf +./file.go:138:32: inlining call to (*parsed).valueOf +./file.go:137:31: inlining call to Key.sectionKey +./file.go:137:31: inlining call to (*parsed).secOf +./file.go:137:31: inlining call to (*parsed).nameOf +./file.go:143:16: inlining call to filter +./file.go:144:18: inlining call to checkKey +./edit.go:134:9: can inline checkKey.1 with cost 231 as: func([]flatEntry, []flatEntry) bool { other := func literal; if !slices.Equal[go.shape.[]github.com/git-bug/gitconfig.flatEntry,go.shape.struct { github.com/git-bug/gitconfig.inSection bool; github.com/git-bug/gitconfig.sec github.com/git-bug/gitconfig.sectionKey; github.com/git-bug/gitconfig.name string; github.com/git-bug/gitconfig.value string; github.com/git-bug/gitconfig.implicit bool }](&slices..dict.Equal[[]github.com/git-bug/gitconfig.flatEntry,github.com/git-bug/gitconfig.flatEntry], filter(before, other), filter(after, other)) { return false }; got := filter(after, func literal); if len(got) != len(want) { return false }; for loop; return true } +./file.go:144:33: inlining call to checkKey.1 +./file.go:143:16: inlining call to (*File).Add.func1.1 +./file.go:144:33: inlining call to filter +./file.go:144:33: inlining call to filter +./file.go:144:33: inlining call to slices.Equal[go.shape.[]github.com/git-bug/gitconfig.flatEntry,go.shape.struct { github.com/git-bug/gitconfig.inSection bool; github.com/git-bug/gitconfig.sec github.com/git-bug/gitconfig.sectionKey; github.com/git-bug/gitconfig.name string; github.com/git-bug/gitconfig.value string; github.com/git-bug/gitconfig.implicit bool }] +./file.go:144:33: inlining call to filter +./file.go:143:16: inlining call to flatEntry.is +./edit.go:135:12: can inline checkKey.1.1 with cost 31 as: func(flatEntry) bool { return !flatEntry.is(e, k) } +./file.go:144:33: inlining call to checkKey.1.1 +./file.go:144:33: inlining call to checkKey.1.1 +./edit.go:139:24: can inline checkKey.1.2 with cost 30 as: func(flatEntry) bool { return flatEntry.is(e, k) } +./file.go:144:33: inlining call to checkKey.1.2 +./file.go:143:16: inlining call to Key.sectionKey +./file.go:144:33: inlining call to flatEntry.is +./file.go:144:33: inlining call to flatEntry.is +./file.go:144:33: inlining call to flatEntry.is +./file.go:144:33: inlining call to Key.sectionKey +./file.go:144:33: inlining call to Key.sectionKey +./file.go:144:33: inlining call to Key.sectionKey +./file.go:143:60: inlining call to flatEntry.is +./file.go:143:60: inlining call to Key.sectionKey +./file.go:156:20: inlining call to (*File).entriesOf +./file.go:161:52: inlining call to checkKey +./file.go:156:20: inlining call to Key.sectionKey +./file.go:156:20: inlining call to (*parsed).secOf +./file.go:156:20: inlining call to (*parsed).nameOf +./file.go:174:20: inlining call to (*File).entriesOf +./file.go:178:54: inlining call to checkKey +./file.go:174:20: inlining call to Key.sectionKey +./file.go:174:20: inlining call to (*parsed).secOf +./file.go:174:20: inlining call to (*parsed).nameOf +./file.go:188:23: inlining call to (*File).checkOpen +./file.go:191:22: inlining call to sectionArg +./file.go:194:64: inlining call to lowerASCII +./file.go:191:22: inlining call to validSection +./file.go:191:22: inlining call to isKeyChar +./file.go:191:22: inlining call to isAlpha +./file.go:201:23: inlining call to (*File).checkOpen +./file.go:204:22: inlining call to sectionArg +./file.go:207:21: inlining call to validSubsection +./file.go:210:55: inlining call to lowerASCII +./file.go:204:22: inlining call to validSection +./file.go:207:21: inlining call to strings.ContainsAny +./file.go:204:22: inlining call to isKeyChar +./file.go:204:22: inlining call to isAlpha +./file.go:221:23: inlining call to (*File).checkOpen +./file.go:224:22: inlining call to sectionArg +./file.go:227:22: inlining call to sectionArg +./file.go:230:38: inlining call to lowerASCII +./file.go:231:64: inlining call to lowerASCII +./file.go:224:22: inlining call to validSection +./file.go:227:22: inlining call to validSection +./file.go:224:22: inlining call to isKeyChar +./file.go:227:22: inlining call to isKeyChar +./file.go:224:22: inlining call to isAlpha +./file.go:227:22: inlining call to isAlpha +./file.go:241:23: inlining call to (*File).checkOpen +./file.go:244:22: inlining call to sectionArg +./file.go:248:22: inlining call to validSubsection +./file.go:252:19: inlining call to lowerASCII +./file.go:244:22: inlining call to validSection +./file.go:248:22: inlining call to strings.ContainsAny +./file.go:244:22: inlining call to isKeyChar +./file.go:244:22: inlining call to isAlpha +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:67:6: inlining call to atomic.(*Pointer[go.shape.struct { os.mu sync.Mutex; os.buf *[]uint8; os.nbuf int; os.bufp int }]).CompareAndSwap +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:64:6: inlining call to atomic.(*Pointer[go.shape.struct { os.mu sync.Mutex; os.buf *[]uint8; os.nbuf int; os.bufp int }]).Swap +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:61:6: inlining call to atomic.(*Pointer[go.shape.struct { os.mu sync.Mutex; os.buf *[]uint8; os.nbuf int; os.bufp int }]).Store +../../.asdf/installs/golang/1.27.1/go/src/sync/atomic/type.go:58:6: inlining call to atomic.(*Pointer[go.shape.struct { os.mu sync.Mutex; os.buf *[]uint8; os.nbuf int; os.bufp int }]).Load +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:20:6: inlining call to slices.Equal[go.shape.[]github.com/git-bug/gitconfig.flatEntry,go.shape.struct { github.com/git-bug/gitconfig.inSection bool; github.com/git-bug/gitconfig.sec github.com/git-bug/gitconfig.sectionKey; github.com/git-bug/gitconfig.name string; github.com/git-bug/gitconfig.value string; github.com/git-bug/gitconfig.implicit bool }] +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: inlining call to slices.Clone[go.shape.[]github.com/git-bug/gitconfig.Entry,go.shape.struct { Key github.com/git-bug/gitconfig.Key; Value string; Implicit bool; Origin github.com/git-bug/gitconfig.Origin }] +../../.asdf/installs/golang/1.27.1/go/src/slices/sort.go:30:6: inlining call to slices.SortFunc[go.shape.[]github.com/git-bug/gitconfig.splice,go.shape.struct { github.com/git-bug/gitconfig.start int; github.com/git-bug/gitconfig.end int; github.com/git-bug/gitconfig.text string }] +../../.asdf/installs/golang/1.27.1/go/src/slices/slices.go:355:6: inlining call to slices.Clone[go.shape.[]string,go.shape.string] diff --git "a/.benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/mem/\341\232\227\341\232\227BenchmarkConfig.profile" "b/.benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/mem/\341\232\227\341\232\227BenchmarkConfig.profile" new file mode 100644 index 0000000000000000000000000000000000000000..42e7eecf0e60fb478661b32d84e16a43a07eebef GIT binary patch literal 3211 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 literal 0 HcmV?d00001 diff --git "a/.benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/mem/\341\232\227\341\232\227BenchmarkEnv\341\232\213Load.profile" "b/.benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/mem/\341\232\227\341\232\227BenchmarkEnv\341\232\213Load.profile" new file mode 100644 index 0000000000000000000000000000000000000000..905f9a1a2371feb5ced5a35f6df5da4b3270a97c GIT binary patch literal 6471 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 literal 0 HcmV?d00001 diff --git "a/.benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/mem/\341\232\227\341\232\227BenchmarkEnv\341\232\213UpdateFile.profile" "b/.benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/mem/\341\232\227\341\232\227BenchmarkEnv\341\232\213UpdateFile.profile" new file mode 100644 index 0000000000000000000000000000000000000000..36f79539951ae68c41911d35416592e24bd03603 GIT binary patch literal 5739 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 S?M~e>;}zcXEvw#;3;+O@4upI_s#HM<(EWcdM> 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 JJg;>e007m*yCVPq literal 0 HcmV?d00001 diff --git "a/.benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/mem/\341\232\227\341\232\227BenchmarkFile.profile" "b/.benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/mem/\341\232\227\341\232\227BenchmarkFile.profile" new file mode 100644 index 0000000000000000000000000000000000000000..ede89cd5b6681f1cb2335bc56d6b2291dc4894fa GIT binary patch literal 9901 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 JRD1L0{{YOtN{avh literal 0 HcmV?d00001 diff --git "a/.benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/mem/\341\232\227\341\232\227BenchmarkParse.profile" "b/.benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/mem/\341\232\227\341\232\227BenchmarkParse.profile" new file mode 100644 index 0000000000000000000000000000000000000000..bc528f5b29b68b00c04205573dbf855f688bc8a1 GIT binary patch literal 6255 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 P@+kN1`NX8qqeuS(+8<`s literal 0 HcmV?d00001 diff --git a/.benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/meta.json b/.benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/meta.json new file mode 100644 index 0000000..e50571b --- /dev/null +++ b/.benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/meta.json @@ -0,0 +1,25 @@ +{ + "name": "baseline", + "benchs": [ + "BenchmarkConfig", + "BenchmarkEnv/Load", + "BenchmarkEnv/LoadProtected", + "BenchmarkEnv/UpdateFile", + "BenchmarkEnv/UpdateFileUnchanged", + "BenchmarkParse", + "BenchmarkFile" + ], + "git_commit": "74c4f677f7d380f117dd4e27dccad1b7bc042184", + "machine": { + "goos": "linux", + "goarch": "amd64", + "num_cpu": 12, + "physical_cores": 6, + "threads_per_core": 2, + "cpu": "AMD Ryzen 5 3600 6-Core Processor", + "cache_l1d": 32768, + "cache_l2": 524288, + "cache_l3": 16777216 + }, + "go_version": "go1.27.1" +} diff --git a/.benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/results.bench b/.benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/results.bench new file mode 100644 index 0000000..85f90cd --- /dev/null +++ b/.benchspotter/sessions/01a1208c-0b84-756b-ae17-41dad78c5d66/results.bench @@ -0,0 +1,515 @@ +goos: linux +goarch: amd64 +pkg: github.com/git-bug/gitconfig +cpu: AMD Ryzen 5 3600 6-Core Processor + +BenchmarkConfig/Get/n=10-12 14258364 84.61 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Get/n=10-12 11616332 91.39 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Get/n=10-12 14528949 79.53 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Get/n=10-12 15695257 79.17 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Get/n=10-12 14692323 81.03 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Get/n=10-12 15027236 80.15 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Get/n=10-12 15000626 80.44 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Get/n=10-12 14747677 80.75 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Get/n=10-12 14881987 78.91 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Get/n=10-12 14367001 78.17 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/GetMissing/n=10-12 17897163 76.34 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/GetMissing/n=10-12 17117432 72.35 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/GetMissing/n=10-12 17168808 70.82 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/GetMissing/n=10-12 16738501 70.24 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/GetMissing/n=10-12 17353603 70.18 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/GetMissing/n=10-12 17190526 70.49 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/GetMissing/n=10-12 17237251 70.51 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/GetMissing/n=10-12 16342612 72.06 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/GetMissing/n=10-12 17331231 71.01 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/GetMissing/n=10-12 16958082 69.44 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/GetAll/n=10-12 8302170 146 ns/op 112 B/op 1 allocs/op +BenchmarkConfig/GetAll/n=10-12 8551143 140.9 ns/op 112 B/op 1 allocs/op +BenchmarkConfig/GetAll/n=10-12 8366583 142.1 ns/op 112 B/op 1 allocs/op +BenchmarkConfig/GetAll/n=10-12 8581399 141.3 ns/op 112 B/op 1 allocs/op +BenchmarkConfig/GetAll/n=10-12 8435746 143 ns/op 112 B/op 1 allocs/op +BenchmarkConfig/GetAll/n=10-12 8549962 141.8 ns/op 112 B/op 1 allocs/op +BenchmarkConfig/GetAll/n=10-12 8560082 142.2 ns/op 112 B/op 1 allocs/op +BenchmarkConfig/GetAll/n=10-12 8564126 140.8 ns/op 112 B/op 1 allocs/op +BenchmarkConfig/GetAll/n=10-12 8098938 143.4 ns/op 112 B/op 1 allocs/op +BenchmarkConfig/GetAll/n=10-12 8406213 141.3 ns/op 112 B/op 1 allocs/op +BenchmarkConfig/Subsections/n=10-12 11655912 98.27 ns/op 160 B/op 1 allocs/op +BenchmarkConfig/Subsections/n=10-12 12310513 98.48 ns/op 160 B/op 1 allocs/op +BenchmarkConfig/Subsections/n=10-12 12261072 97.66 ns/op 160 B/op 1 allocs/op +BenchmarkConfig/Subsections/n=10-12 11990024 98.67 ns/op 160 B/op 1 allocs/op +BenchmarkConfig/Subsections/n=10-12 12416205 97.79 ns/op 160 B/op 1 allocs/op +BenchmarkConfig/Subsections/n=10-12 12161940 98.02 ns/op 160 B/op 1 allocs/op +BenchmarkConfig/Subsections/n=10-12 11422404 98.38 ns/op 160 B/op 1 allocs/op +BenchmarkConfig/Subsections/n=10-12 12226353 97.65 ns/op 160 B/op 1 allocs/op +BenchmarkConfig/Subsections/n=10-12 12222757 101.2 ns/op 160 B/op 1 allocs/op +BenchmarkConfig/Subsections/n=10-12 12205959 99.22 ns/op 160 B/op 1 allocs/op +BenchmarkConfig/Bool/n=10-12 12719163 94.15 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Bool/n=10-12 12479598 91.18 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Bool/n=10-12 13643412 93.72 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Bool/n=10-12 12883803 95.02 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Bool/n=10-12 12572098 93.63 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Bool/n=10-12 12732076 91.74 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Bool/n=10-12 11523427 95.25 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Bool/n=10-12 12880951 93.48 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Bool/n=10-12 13717155 91.76 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Bool/n=10-12 12044908 93.87 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Get/n=1000-12 14823087 80.91 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Get/n=1000-12 14933941 79.41 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Get/n=1000-12 14306074 80.63 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Get/n=1000-12 15050762 80.84 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Get/n=1000-12 14350953 81.81 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Get/n=1000-12 14687533 80.63 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Get/n=1000-12 14862950 80.24 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Get/n=1000-12 14778423 80.3 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Get/n=1000-12 14765944 80.9 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Get/n=1000-12 14944434 78.87 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/GetMissing/n=1000-12 16004414 69.83 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/GetMissing/n=1000-12 17301386 70.89 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/GetMissing/n=1000-12 16725273 71.53 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/GetMissing/n=1000-12 16157006 73.71 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/GetMissing/n=1000-12 16342540 72.31 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/GetMissing/n=1000-12 16515879 72.82 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/GetMissing/n=1000-12 16555854 72.38 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/GetMissing/n=1000-12 16302658 72.57 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/GetMissing/n=1000-12 17515651 68.03 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/GetMissing/n=1000-12 17854065 67.84 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/GetAll/n=1000-12 7403095 164.9 ns/op 112 B/op 1 allocs/op +BenchmarkConfig/GetAll/n=1000-12 7022899 158.7 ns/op 112 B/op 1 allocs/op +BenchmarkConfig/GetAll/n=1000-12 7744276 154.9 ns/op 112 B/op 1 allocs/op +BenchmarkConfig/GetAll/n=1000-12 7795984 153.4 ns/op 112 B/op 1 allocs/op +BenchmarkConfig/GetAll/n=1000-12 7884241 156.3 ns/op 112 B/op 1 allocs/op +BenchmarkConfig/GetAll/n=1000-12 7666278 156 ns/op 112 B/op 1 allocs/op +BenchmarkConfig/GetAll/n=1000-12 7638884 155 ns/op 112 B/op 1 allocs/op +BenchmarkConfig/GetAll/n=1000-12 7741814 155.8 ns/op 112 B/op 1 allocs/op +BenchmarkConfig/GetAll/n=1000-12 7483338 157.9 ns/op 112 B/op 1 allocs/op +BenchmarkConfig/GetAll/n=1000-12 7881342 154.5 ns/op 112 B/op 1 allocs/op +BenchmarkConfig/Subsections/n=1000-12 243411 5136 ns/op 16384 B/op 1 allocs/op +BenchmarkConfig/Subsections/n=1000-12 232696 5398 ns/op 16384 B/op 1 allocs/op +BenchmarkConfig/Subsections/n=1000-12 260228 4994 ns/op 16384 B/op 1 allocs/op +BenchmarkConfig/Subsections/n=1000-12 237465 4994 ns/op 16384 B/op 1 allocs/op +BenchmarkConfig/Subsections/n=1000-12 246728 4955 ns/op 16384 B/op 1 allocs/op +BenchmarkConfig/Subsections/n=1000-12 240993 4974 ns/op 16384 B/op 1 allocs/op +BenchmarkConfig/Subsections/n=1000-12 236058 4930 ns/op 16384 B/op 1 allocs/op +BenchmarkConfig/Subsections/n=1000-12 251113 5024 ns/op 16384 B/op 1 allocs/op +BenchmarkConfig/Subsections/n=1000-12 240362 5437 ns/op 16384 B/op 1 allocs/op +BenchmarkConfig/Subsections/n=1000-12 233271 5048 ns/op 16384 B/op 1 allocs/op +BenchmarkConfig/Bool/n=1000-12 13485553 95.75 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Bool/n=1000-12 12291747 96.46 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Bool/n=1000-12 12537336 96.21 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Bool/n=1000-12 12286720 94.72 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Bool/n=1000-12 12781742 95.16 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Bool/n=1000-12 12860050 91.14 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Bool/n=1000-12 13554027 95.22 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Bool/n=1000-12 12768790 91.99 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Bool/n=1000-12 12932084 97.73 ns/op 0 B/op 0 allocs/op +BenchmarkConfig/Bool/n=1000-12 12512444 96.15 ns/op 0 B/op 0 allocs/op +BenchmarkEnv/Load-12 4587 243570 ns/op 332496 B/op 932 allocs/op +BenchmarkEnv/Load-12 5019 242712 ns/op 332491 B/op 932 allocs/op +BenchmarkEnv/Load-12 4894 246259 ns/op 332490 B/op 932 allocs/op +BenchmarkEnv/Load-12 4629 248029 ns/op 332490 B/op 932 allocs/op +BenchmarkEnv/Load-12 5098 246052 ns/op 332491 B/op 932 allocs/op +BenchmarkEnv/Load-12 4822 247390 ns/op 332491 B/op 932 allocs/op +BenchmarkEnv/Load-12 4803 245124 ns/op 332491 B/op 932 allocs/op +BenchmarkEnv/Load-12 4958 245544 ns/op 332490 B/op 932 allocs/op +BenchmarkEnv/Load-12 4904 254155 ns/op 332491 B/op 932 allocs/op +BenchmarkEnv/Load-12 4854 260887 ns/op 332491 B/op 932 allocs/op +BenchmarkEnv/LoadProtected-12 16602 70730 ns/op 62025 B/op 219 allocs/op +BenchmarkEnv/LoadProtected-12 17863 66326 ns/op 62024 B/op 219 allocs/op +BenchmarkEnv/LoadProtected-12 18573 65110 ns/op 62024 B/op 219 allocs/op +BenchmarkEnv/LoadProtected-12 18350 65565 ns/op 62024 B/op 219 allocs/op +BenchmarkEnv/LoadProtected-12 18253 65437 ns/op 62024 B/op 219 allocs/op +BenchmarkEnv/LoadProtected-12 18346 65797 ns/op 62024 B/op 219 allocs/op +BenchmarkEnv/LoadProtected-12 18129 65922 ns/op 62024 B/op 219 allocs/op +BenchmarkEnv/LoadProtected-12 18188 65878 ns/op 62024 B/op 219 allocs/op +BenchmarkEnv/LoadProtected-12 18511 65015 ns/op 62024 B/op 219 allocs/op +BenchmarkEnv/LoadProtected-12 18404 65223 ns/op 62024 B/op 219 allocs/op +BenchmarkEnv/UpdateFile-12 4302 279626 ns/op 460670 B/op 993 allocs/op +BenchmarkEnv/UpdateFile-12 4226 280489 ns/op 460666 B/op 993 allocs/op +BenchmarkEnv/UpdateFile-12 4446 281411 ns/op 460666 B/op 993 allocs/op +BenchmarkEnv/UpdateFile-12 4358 281226 ns/op 460666 B/op 993 allocs/op +BenchmarkEnv/UpdateFile-12 4174 286693 ns/op 460667 B/op 993 allocs/op +BenchmarkEnv/UpdateFile-12 4124 283315 ns/op 460666 B/op 993 allocs/op +BenchmarkEnv/UpdateFile-12 4100 286072 ns/op 460667 B/op 993 allocs/op +BenchmarkEnv/UpdateFile-12 4066 281985 ns/op 460666 B/op 993 allocs/op +BenchmarkEnv/UpdateFile-12 4084 284529 ns/op 460666 B/op 993 allocs/op +BenchmarkEnv/UpdateFile-12 4342 283372 ns/op 460666 B/op 993 allocs/op +BenchmarkEnv/UpdateFileUnchanged-12 10000 112376 ns/op 136546 B/op 480 allocs/op +BenchmarkEnv/UpdateFileUnchanged-12 10000 113978 ns/op 136544 B/op 480 allocs/op +BenchmarkEnv/UpdateFileUnchanged-12 9598 112873 ns/op 136544 B/op 480 allocs/op +BenchmarkEnv/UpdateFileUnchanged-12 10000 113880 ns/op 136544 B/op 480 allocs/op +BenchmarkEnv/UpdateFileUnchanged-12 10000 112611 ns/op 136544 B/op 480 allocs/op +BenchmarkEnv/UpdateFileUnchanged-12 10000 111374 ns/op 136544 B/op 480 allocs/op +BenchmarkEnv/UpdateFileUnchanged-12 10000 111106 ns/op 136544 B/op 480 allocs/op +BenchmarkEnv/UpdateFileUnchanged-12 9643 113570 ns/op 136544 B/op 480 allocs/op +BenchmarkEnv/UpdateFileUnchanged-12 10000 114057 ns/op 136544 B/op 480 allocs/op +BenchmarkEnv/UpdateFileUnchanged-12 10000 113367 ns/op 136544 B/op 480 allocs/op +BenchmarkParse/realistic/1KiB-12 90344 13098 ns/op 87.42 MB/s 23584 B/op 103 allocs/op +BenchmarkParse/realistic/1KiB-12 91362 12899 ns/op 88.77 MB/s 23584 B/op 103 allocs/op +BenchmarkParse/realistic/1KiB-12 92511 13077 ns/op 87.56 MB/s 23584 B/op 103 allocs/op +BenchmarkParse/realistic/1KiB-12 90705 13067 ns/op 87.63 MB/s 23584 B/op 103 allocs/op +BenchmarkParse/realistic/1KiB-12 88819 13053 ns/op 87.72 MB/s 23584 B/op 103 allocs/op +BenchmarkParse/realistic/1KiB-12 91244 13200 ns/op 86.75 MB/s 23584 B/op 103 allocs/op +BenchmarkParse/realistic/1KiB-12 93631 13036 ns/op 87.83 MB/s 23584 B/op 103 allocs/op +BenchmarkParse/realistic/1KiB-12 90574 13102 ns/op 87.39 MB/s 23584 B/op 103 allocs/op +BenchmarkParse/realistic/1KiB-12 91056 13063 ns/op 87.65 MB/s 23584 B/op 103 allocs/op +BenchmarkParse/realistic/1KiB-12 89734 13133 ns/op 87.19 MB/s 23584 B/op 103 allocs/op +BenchmarkParse/realistic/64KiB-12 1885 620033 ns/op 106 MB/s 1.403045e+06 B/op 3776 allocs/op +BenchmarkParse/realistic/64KiB-12 1868 630203 ns/op 104.29 MB/s 1.403045e+06 B/op 3776 allocs/op +BenchmarkParse/realistic/64KiB-12 1975 620008 ns/op 106 MB/s 1.403046e+06 B/op 3776 allocs/op +BenchmarkParse/realistic/64KiB-12 1977 635108 ns/op 103.48 MB/s 1.403045e+06 B/op 3776 allocs/op +BenchmarkParse/realistic/64KiB-12 1732 647975 ns/op 101.43 MB/s 1.403046e+06 B/op 3776 allocs/op +BenchmarkParse/realistic/64KiB-12 1958 641927 ns/op 102.38 MB/s 1.403045e+06 B/op 3776 allocs/op +BenchmarkParse/realistic/64KiB-12 1857 648946 ns/op 101.28 MB/s 1.403048e+06 B/op 3776 allocs/op +BenchmarkParse/realistic/64KiB-12 1796 665087 ns/op 98.82 MB/s 1.403047e+06 B/op 3776 allocs/op +BenchmarkParse/realistic/64KiB-12 1852 666264 ns/op 98.64 MB/s 1.403047e+06 B/op 3776 allocs/op +BenchmarkParse/realistic/64KiB-12 1911 640820 ns/op 102.56 MB/s 1.403045e+06 B/op 3776 allocs/op +BenchmarkParse/realistic/1024KiB-12 111 1.0735175e+07 ns/op 97.68 MB/s 2.3841443e+07 B/op 59583 allocs/op +BenchmarkParse/realistic/1024KiB-12 99 1.080651e+07 ns/op 97.03 MB/s 2.3841441e+07 B/op 59583 allocs/op +BenchmarkParse/realistic/1024KiB-12 111 1.0627264e+07 ns/op 98.67 MB/s 2.3841498e+07 B/op 59583 allocs/op +BenchmarkParse/realistic/1024KiB-12 110 1.1035223e+07 ns/op 95.02 MB/s 2.3841446e+07 B/op 59583 allocs/op +BenchmarkParse/realistic/1024KiB-12 103 1.1453782e+07 ns/op 91.55 MB/s 2.3841449e+07 B/op 59583 allocs/op +BenchmarkParse/realistic/1024KiB-12 96 1.0607565e+07 ns/op 98.85 MB/s 2.3841443e+07 B/op 59583 allocs/op +BenchmarkParse/realistic/1024KiB-12 94 1.0842011e+07 ns/op 96.72 MB/s 2.3841443e+07 B/op 59583 allocs/op +BenchmarkParse/realistic/1024KiB-12 98 1.0670711e+07 ns/op 98.27 MB/s 2.3841443e+07 B/op 59583 allocs/op +BenchmarkParse/realistic/1024KiB-12 93 1.0834271e+07 ns/op 96.78 MB/s 2.3841442e+07 B/op 59583 allocs/op +BenchmarkParse/realistic/1024KiB-12 109 1.0916785e+07 ns/op 96.05 MB/s 2.3841447e+07 B/op 59583 allocs/op +BenchmarkParse/one_long_value/1KiB-12 208312 5639 ns/op 181.77 MB/s 6920 B/op 20 allocs/op +BenchmarkParse/one_long_value/1KiB-12 216039 5557 ns/op 184.44 MB/s 6920 B/op 20 allocs/op +BenchmarkParse/one_long_value/1KiB-12 222303 5588 ns/op 183.44 MB/s 6920 B/op 20 allocs/op +BenchmarkParse/one_long_value/1KiB-12 211384 5683 ns/op 180.35 MB/s 6920 B/op 20 allocs/op +BenchmarkParse/one_long_value/1KiB-12 202292 5687 ns/op 180.22 MB/s 6920 B/op 20 allocs/op +BenchmarkParse/one_long_value/1KiB-12 204313 5485 ns/op 186.88 MB/s 6920 B/op 20 allocs/op +BenchmarkParse/one_long_value/1KiB-12 219504 5576 ns/op 183.81 MB/s 6920 B/op 20 allocs/op +BenchmarkParse/one_long_value/1KiB-12 217599 5576 ns/op 183.83 MB/s 6920 B/op 20 allocs/op +BenchmarkParse/one_long_value/1KiB-12 220388 5596 ns/op 183.16 MB/s 6920 B/op 20 allocs/op +BenchmarkParse/one_long_value/1KiB-12 212626 5622 ns/op 182.33 MB/s 6920 B/op 20 allocs/op +BenchmarkParse/one_long_value/64KiB-12 4424 270803 ns/op 242.01 MB/s 426122 B/op 33 allocs/op +BenchmarkParse/one_long_value/64KiB-12 4549 272614 ns/op 240.4 MB/s 426122 B/op 33 allocs/op +BenchmarkParse/one_long_value/64KiB-12 4503 268264 ns/op 244.3 MB/s 426121 B/op 33 allocs/op +BenchmarkParse/one_long_value/64KiB-12 4387 290383 ns/op 225.69 MB/s 426122 B/op 33 allocs/op +BenchmarkParse/one_long_value/64KiB-12 4417 270492 ns/op 242.29 MB/s 426121 B/op 33 allocs/op +BenchmarkParse/one_long_value/64KiB-12 4287 271129 ns/op 241.72 MB/s 426122 B/op 33 allocs/op +BenchmarkParse/one_long_value/64KiB-12 4450 285618 ns/op 229.46 MB/s 426122 B/op 33 allocs/op +BenchmarkParse/one_long_value/64KiB-12 4231 269120 ns/op 243.52 MB/s 426122 B/op 33 allocs/op +BenchmarkParse/one_long_value/64KiB-12 4388 273997 ns/op 239.19 MB/s 426122 B/op 33 allocs/op +BenchmarkParse/one_long_value/64KiB-12 4498 268827 ns/op 243.79 MB/s 426122 B/op 33 allocs/op +BenchmarkParse/one_long_value/1024KiB-12 202 5.736891e+06 ns/op 182.78 MB/s 7.348433e+06 B/op 44 allocs/op +BenchmarkParse/one_long_value/1024KiB-12 218 5.408119e+06 ns/op 193.89 MB/s 7.348433e+06 B/op 44 allocs/op +BenchmarkParse/one_long_value/1024KiB-12 212 5.631481e+06 ns/op 186.2 MB/s 7.348432e+06 B/op 44 allocs/op +BenchmarkParse/one_long_value/1024KiB-12 212 5.716579e+06 ns/op 183.43 MB/s 7.348428e+06 B/op 44 allocs/op +BenchmarkParse/one_long_value/1024KiB-12 212 5.541765e+06 ns/op 189.21 MB/s 7.348437e+06 B/op 44 allocs/op +BenchmarkParse/one_long_value/1024KiB-12 213 5.616398e+06 ns/op 186.7 MB/s 7.348419e+06 B/op 44 allocs/op +BenchmarkParse/one_long_value/1024KiB-12 211 5.637667e+06 ns/op 185.99 MB/s 7.348424e+06 B/op 44 allocs/op +BenchmarkParse/one_long_value/1024KiB-12 210 5.598808e+06 ns/op 187.29 MB/s 7.348419e+06 B/op 44 allocs/op +BenchmarkParse/one_long_value/1024KiB-12 222 5.492982e+06 ns/op 190.89 MB/s 7.348427e+06 B/op 44 allocs/op +BenchmarkParse/one_long_value/1024KiB-12 218 5.575146e+06 ns/op 188.08 MB/s 7.348417e+06 B/op 44 allocs/op +BenchmarkParse/continuations/1KiB-12 154375 7904 ns/op 129.8 MB/s 25544 B/op 18 allocs/op +BenchmarkParse/continuations/1KiB-12 137611 7949 ns/op 129.07 MB/s 25544 B/op 18 allocs/op +BenchmarkParse/continuations/1KiB-12 151771 7724 ns/op 132.83 MB/s 25544 B/op 18 allocs/op +BenchmarkParse/continuations/1KiB-12 147100 8147 ns/op 125.94 MB/s 25544 B/op 18 allocs/op +BenchmarkParse/continuations/1KiB-12 151825 8182 ns/op 125.4 MB/s 25544 B/op 18 allocs/op +BenchmarkParse/continuations/1KiB-12 159620 7082 ns/op 144.87 MB/s 25544 B/op 18 allocs/op +BenchmarkParse/continuations/1KiB-12 177375 6979 ns/op 147.01 MB/s 25544 B/op 18 allocs/op +BenchmarkParse/continuations/1KiB-12 169858 7041 ns/op 145.71 MB/s 25544 B/op 18 allocs/op +BenchmarkParse/continuations/1KiB-12 167949 7040 ns/op 145.74 MB/s 25544 B/op 18 allocs/op +BenchmarkParse/continuations/1KiB-12 169417 7412 ns/op 138.41 MB/s 25544 B/op 18 allocs/op +BenchmarkParse/continuations/64KiB-12 3145 446197 ns/op 146.88 MB/s 1.580875e+06 B/op 31 allocs/op +BenchmarkParse/continuations/64KiB-12 2827 443114 ns/op 147.9 MB/s 1.580875e+06 B/op 31 allocs/op +BenchmarkParse/continuations/64KiB-12 2652 428170 ns/op 153.07 MB/s 1.580875e+06 B/op 31 allocs/op +BenchmarkParse/continuations/64KiB-12 3066 415606 ns/op 157.69 MB/s 1.580875e+06 B/op 31 allocs/op +BenchmarkParse/continuations/64KiB-12 3049 418954 ns/op 156.43 MB/s 1.580874e+06 B/op 31 allocs/op +BenchmarkParse/continuations/64KiB-12 3372 426723 ns/op 153.58 MB/s 1.580875e+06 B/op 31 allocs/op +BenchmarkParse/continuations/64KiB-12 3306 421887 ns/op 155.35 MB/s 1.580875e+06 B/op 31 allocs/op +BenchmarkParse/continuations/64KiB-12 2436 437463 ns/op 149.81 MB/s 1.580876e+06 B/op 31 allocs/op +BenchmarkParse/continuations/64KiB-12 2803 419370 ns/op 156.28 MB/s 1.580875e+06 B/op 31 allocs/op +BenchmarkParse/continuations/64KiB-12 2821 441901 ns/op 148.31 MB/s 1.580876e+06 B/op 31 allocs/op +BenchmarkParse/continuations/1024KiB-12 220 5.294937e+06 ns/op 198.03 MB/s 2.5100114e+07 B/op 41 allocs/op +BenchmarkParse/continuations/1024KiB-12 225 5.241623e+06 ns/op 200.05 MB/s 2.5100112e+07 B/op 41 allocs/op +BenchmarkParse/continuations/1024KiB-12 224 5.307707e+06 ns/op 197.56 MB/s 2.5100112e+07 B/op 41 allocs/op +BenchmarkParse/continuations/1024KiB-12 229 5.27292e+06 ns/op 198.86 MB/s 2.5100114e+07 B/op 41 allocs/op +BenchmarkParse/continuations/1024KiB-12 228 5.231762e+06 ns/op 200.43 MB/s 2.5100114e+07 B/op 41 allocs/op +BenchmarkParse/continuations/1024KiB-12 224 5.274249e+06 ns/op 198.81 MB/s 2.5100112e+07 B/op 41 allocs/op +BenchmarkParse/continuations/1024KiB-12 220 5.302059e+06 ns/op 197.77 MB/s 2.5100113e+07 B/op 41 allocs/op +BenchmarkParse/continuations/1024KiB-12 229 5.282274e+06 ns/op 198.51 MB/s 2.5100114e+07 B/op 41 allocs/op +BenchmarkParse/continuations/1024KiB-12 226 5.27206e+06 ns/op 198.89 MB/s 2.5100113e+07 B/op 41 allocs/op +BenchmarkParse/continuations/1024KiB-12 224 5.280571e+06 ns/op 198.57 MB/s 2.5100116e+07 B/op 41 allocs/op +BenchmarkParse/quotes/1KiB-12 240855 4747 ns/op 216.15 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/quotes/1KiB-12 253161 4747 ns/op 216.12 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/quotes/1KiB-12 250918 4689 ns/op 218.79 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/quotes/1KiB-12 248462 4766 ns/op 215.29 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/quotes/1KiB-12 234488 4796 ns/op 213.91 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/quotes/1KiB-12 244756 4739 ns/op 216.5 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/quotes/1KiB-12 246656 4902 ns/op 209.32 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/quotes/1KiB-12 234475 5024 ns/op 204.23 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/quotes/1KiB-12 244708 4951 ns/op 207.22 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/quotes/1KiB-12 244052 4953 ns/op 207.17 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/quotes/64KiB-12 5151 238317 ns/op 275 MB/s 262280 B/op 31 allocs/op +BenchmarkParse/quotes/64KiB-12 5024 231617 ns/op 282.96 MB/s 262280 B/op 31 allocs/op +BenchmarkParse/quotes/64KiB-12 5220 229357 ns/op 285.75 MB/s 262280 B/op 31 allocs/op +BenchmarkParse/quotes/64KiB-12 5389 234313 ns/op 279.7 MB/s 262280 B/op 31 allocs/op +BenchmarkParse/quotes/64KiB-12 4928 236522 ns/op 277.09 MB/s 262280 B/op 31 allocs/op +BenchmarkParse/quotes/64KiB-12 5232 231366 ns/op 283.27 MB/s 262280 B/op 31 allocs/op +BenchmarkParse/quotes/64KiB-12 4923 235167 ns/op 278.69 MB/s 262280 B/op 31 allocs/op +BenchmarkParse/quotes/64KiB-12 5342 230393 ns/op 284.46 MB/s 262280 B/op 31 allocs/op +BenchmarkParse/quotes/64KiB-12 5144 231818 ns/op 282.71 MB/s 262280 B/op 31 allocs/op +BenchmarkParse/quotes/64KiB-12 5340 235776 ns/op 277.97 MB/s 262280 B/op 31 allocs/op +BenchmarkParse/quotes/1024KiB-12 340 3.632466e+06 ns/op 288.67 MB/s 4.120727e+06 B/op 41 allocs/op +BenchmarkParse/quotes/1024KiB-12 319 3.704436e+06 ns/op 283.06 MB/s 4.120727e+06 B/op 41 allocs/op +BenchmarkParse/quotes/1024KiB-12 336 3.590574e+06 ns/op 292.04 MB/s 4.120728e+06 B/op 41 allocs/op +BenchmarkParse/quotes/1024KiB-12 294 3.89878e+06 ns/op 268.95 MB/s 4.120731e+06 B/op 41 allocs/op +BenchmarkParse/quotes/1024KiB-12 328 3.842416e+06 ns/op 272.9 MB/s 4.120731e+06 B/op 41 allocs/op +BenchmarkParse/quotes/1024KiB-12 312 3.770604e+06 ns/op 278.09 MB/s 4.120727e+06 B/op 41 allocs/op +BenchmarkParse/quotes/1024KiB-12 321 3.662682e+06 ns/op 286.29 MB/s 4.120728e+06 B/op 41 allocs/op +BenchmarkParse/quotes/1024KiB-12 346 3.581917e+06 ns/op 292.74 MB/s 4.120727e+06 B/op 41 allocs/op +BenchmarkParse/quotes/1024KiB-12 300 4.104923e+06 ns/op 255.44 MB/s 4.120725e+06 B/op 41 allocs/op +BenchmarkParse/quotes/1024KiB-12 295 3.807931e+06 ns/op 275.37 MB/s 4.12073e+06 B/op 41 allocs/op +BenchmarkParse/escapes/1KiB-12 325599 3586 ns/op 287.24 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/escapes/1KiB-12 336165 3502 ns/op 294.14 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/escapes/1KiB-12 300940 3510 ns/op 293.48 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/escapes/1KiB-12 334930 3601 ns/op 286.02 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/escapes/1KiB-12 325407 3520 ns/op 292.58 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/escapes/1KiB-12 335010 3501 ns/op 294.22 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/escapes/1KiB-12 309054 3565 ns/op 288.94 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/escapes/1KiB-12 358725 3495 ns/op 294.68 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/escapes/1KiB-12 328683 3556 ns/op 289.68 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/escapes/1KiB-12 329809 3545 ns/op 290.52 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/escapes/64KiB-12 7090 162697 ns/op 402.85 MB/s 262281 B/op 31 allocs/op +BenchmarkParse/escapes/64KiB-12 7256 161692 ns/op 405.35 MB/s 262281 B/op 31 allocs/op +BenchmarkParse/escapes/64KiB-12 7370 161366 ns/op 406.17 MB/s 262281 B/op 31 allocs/op +BenchmarkParse/escapes/64KiB-12 7095 163451 ns/op 400.99 MB/s 262281 B/op 31 allocs/op +BenchmarkParse/escapes/64KiB-12 7468 171028 ns/op 383.22 MB/s 262281 B/op 31 allocs/op +BenchmarkParse/escapes/64KiB-12 7407 160669 ns/op 407.93 MB/s 262281 B/op 31 allocs/op +BenchmarkParse/escapes/64KiB-12 6834 167212 ns/op 391.97 MB/s 262281 B/op 31 allocs/op +BenchmarkParse/escapes/64KiB-12 7346 163531 ns/op 400.79 MB/s 262281 B/op 31 allocs/op +BenchmarkParse/escapes/64KiB-12 7309 161794 ns/op 405.1 MB/s 262281 B/op 31 allocs/op +BenchmarkParse/escapes/64KiB-12 7324 162580 ns/op 403.14 MB/s 262281 B/op 31 allocs/op +BenchmarkParse/escapes/1024KiB-12 477 2.568169e+06 ns/op 408.3 MB/s 4.120728e+06 B/op 41 allocs/op +BenchmarkParse/escapes/1024KiB-12 492 2.493425e+06 ns/op 420.54 MB/s 4.120726e+06 B/op 41 allocs/op +BenchmarkParse/escapes/1024KiB-12 477 2.571703e+06 ns/op 407.74 MB/s 4.120726e+06 B/op 41 allocs/op +BenchmarkParse/escapes/1024KiB-12 475 2.442108e+06 ns/op 429.38 MB/s 4.120725e+06 B/op 41 allocs/op +BenchmarkParse/escapes/1024KiB-12 477 2.516388e+06 ns/op 416.7 MB/s 4.120729e+06 B/op 41 allocs/op +BenchmarkParse/escapes/1024KiB-12 446 2.537743e+06 ns/op 413.19 MB/s 4.120726e+06 B/op 41 allocs/op +BenchmarkParse/escapes/1024KiB-12 456 2.486657e+06 ns/op 421.68 MB/s 4.120727e+06 B/op 41 allocs/op +BenchmarkParse/escapes/1024KiB-12 438 2.733399e+06 ns/op 383.62 MB/s 4.120729e+06 B/op 41 allocs/op +BenchmarkParse/escapes/1024KiB-12 458 2.614714e+06 ns/op 401.03 MB/s 4.120726e+06 B/op 41 allocs/op +BenchmarkParse/escapes/1024KiB-12 492 2.77589e+06 ns/op 377.75 MB/s 4.120731e+06 B/op 41 allocs/op +BenchmarkParse/same_key/1KiB-12 68368 17704 ns/op 57.95 MB/s 48408 B/op 19 allocs/op +BenchmarkParse/same_key/1KiB-12 64387 18874 ns/op 54.36 MB/s 48408 B/op 19 allocs/op +BenchmarkParse/same_key/1KiB-12 67264 17767 ns/op 57.75 MB/s 48408 B/op 19 allocs/op +BenchmarkParse/same_key/1KiB-12 66754 18011 ns/op 56.96 MB/s 48408 B/op 19 allocs/op +BenchmarkParse/same_key/1KiB-12 65496 18357 ns/op 55.89 MB/s 48408 B/op 19 allocs/op +BenchmarkParse/same_key/1KiB-12 66531 17979 ns/op 57.07 MB/s 48408 B/op 19 allocs/op +BenchmarkParse/same_key/1KiB-12 68023 17767 ns/op 57.75 MB/s 48408 B/op 19 allocs/op +BenchmarkParse/same_key/1KiB-12 66466 18162 ns/op 56.49 MB/s 48408 B/op 19 allocs/op +BenchmarkParse/same_key/1KiB-12 61884 19209 ns/op 53.41 MB/s 48408 B/op 19 allocs/op +BenchmarkParse/same_key/1KiB-12 68253 17851 ns/op 57.47 MB/s 48408 B/op 19 allocs/op +BenchmarkParse/same_key/64KiB-12 712 1.623269e+06 ns/op 40.37 MB/s 4.445863e+06 B/op 31 allocs/op +BenchmarkParse/same_key/64KiB-12 693 1.713606e+06 ns/op 38.25 MB/s 4.445864e+06 B/op 31 allocs/op +BenchmarkParse/same_key/64KiB-12 747 1.65773e+06 ns/op 39.53 MB/s 4.445865e+06 B/op 31 allocs/op +BenchmarkParse/same_key/64KiB-12 704 1.673912e+06 ns/op 39.15 MB/s 4.445865e+06 B/op 31 allocs/op +BenchmarkParse/same_key/64KiB-12 739 1.70773e+06 ns/op 38.38 MB/s 4.445864e+06 B/op 31 allocs/op +BenchmarkParse/same_key/64KiB-12 757 1.656674e+06 ns/op 39.56 MB/s 4.445863e+06 B/op 31 allocs/op +BenchmarkParse/same_key/64KiB-12 721 1.680749e+06 ns/op 38.99 MB/s 4.445865e+06 B/op 31 allocs/op +BenchmarkParse/same_key/64KiB-12 763 1.639936e+06 ns/op 39.96 MB/s 4.445865e+06 B/op 31 allocs/op +BenchmarkParse/same_key/64KiB-12 718 1.643463e+06 ns/op 39.88 MB/s 4.445865e+06 B/op 31 allocs/op +BenchmarkParse/same_key/64KiB-12 710 1.739015e+06 ns/op 37.69 MB/s 4.445866e+06 B/op 31 allocs/op +BenchmarkParse/same_key/1024KiB-12 46 2.5490713e+07 ns/op 41.14 MB/s 7.4962713e+07 B/op 43 allocs/op +BenchmarkParse/same_key/1024KiB-12 45 2.5928325e+07 ns/op 40.44 MB/s 7.4962594e+07 B/op 43 allocs/op +BenchmarkParse/same_key/1024KiB-12 46 2.551367e+07 ns/op 41.1 MB/s 7.4962596e+07 B/op 43 allocs/op +BenchmarkParse/same_key/1024KiB-12 43 2.7723388e+07 ns/op 37.82 MB/s 7.4962592e+07 B/op 43 allocs/op +BenchmarkParse/same_key/1024KiB-12 42 2.8073295e+07 ns/op 37.35 MB/s 7.4962594e+07 B/op 43 allocs/op +BenchmarkParse/same_key/1024KiB-12 38 2.7600063e+07 ns/op 37.99 MB/s 7.4962592e+07 B/op 43 allocs/op +BenchmarkParse/same_key/1024KiB-12 36 2.7890114e+07 ns/op 37.6 MB/s 7.4962592e+07 B/op 43 allocs/op +BenchmarkParse/same_key/1024KiB-12 40 2.9165348e+07 ns/op 35.95 MB/s 7.4962592e+07 B/op 43 allocs/op +BenchmarkParse/same_key/1024KiB-12 40 2.8395829e+07 ns/op 36.93 MB/s 7.4962592e+07 B/op 43 allocs/op +BenchmarkParse/same_key/1024KiB-12 44 2.6767205e+07 ns/op 39.17 MB/s 7.4962718e+07 B/op 43 allocs/op +BenchmarkParse/headers/1KiB-12 111475 10751 ns/op 95.25 MB/s 12688 B/op 8 allocs/op +BenchmarkParse/headers/1KiB-12 110578 10660 ns/op 96.06 MB/s 12688 B/op 8 allocs/op +BenchmarkParse/headers/1KiB-12 112911 10723 ns/op 95.49 MB/s 12688 B/op 8 allocs/op +BenchmarkParse/headers/1KiB-12 112904 10753 ns/op 95.23 MB/s 12688 B/op 8 allocs/op +BenchmarkParse/headers/1KiB-12 112624 10778 ns/op 95.01 MB/s 12688 B/op 8 allocs/op +BenchmarkParse/headers/1KiB-12 111030 10799 ns/op 94.83 MB/s 12688 B/op 8 allocs/op +BenchmarkParse/headers/1KiB-12 113292 10631 ns/op 96.32 MB/s 12688 B/op 8 allocs/op +BenchmarkParse/headers/1KiB-12 112798 10790 ns/op 94.9 MB/s 12688 B/op 8 allocs/op +BenchmarkParse/headers/1KiB-12 111158 10725 ns/op 95.48 MB/s 12688 B/op 8 allocs/op +BenchmarkParse/headers/1KiB-12 113005 10687 ns/op 95.81 MB/s 12688 B/op 8 allocs/op +BenchmarkParse/headers/64KiB-12 1741 641781 ns/op 102.12 MB/s 729872 B/op 8 allocs/op +BenchmarkParse/headers/64KiB-12 1796 640829 ns/op 102.27 MB/s 729872 B/op 8 allocs/op +BenchmarkParse/headers/64KiB-12 1833 641820 ns/op 102.11 MB/s 729873 B/op 8 allocs/op +BenchmarkParse/headers/64KiB-12 1852 639703 ns/op 102.45 MB/s 729872 B/op 8 allocs/op +BenchmarkParse/headers/64KiB-12 1844 636648 ns/op 102.94 MB/s 729872 B/op 8 allocs/op +BenchmarkParse/headers/64KiB-12 1894 647593 ns/op 101.2 MB/s 729873 B/op 8 allocs/op +BenchmarkParse/headers/64KiB-12 1867 633572 ns/op 103.44 MB/s 729872 B/op 8 allocs/op +BenchmarkParse/headers/64KiB-12 1867 636784 ns/op 102.92 MB/s 729873 B/op 8 allocs/op +BenchmarkParse/headers/64KiB-12 1941 638279 ns/op 102.68 MB/s 729873 B/op 8 allocs/op +BenchmarkParse/headers/64KiB-12 1834 634835 ns/op 103.23 MB/s 729872 B/op 8 allocs/op +BenchmarkParse/headers/1024KiB-12 120 9.840621e+06 ns/op 106.56 MB/s 1.1543312e+07 B/op 8 allocs/op +BenchmarkParse/headers/1024KiB-12 121 9.854336e+06 ns/op 106.41 MB/s 1.1543312e+07 B/op 8 allocs/op +BenchmarkParse/headers/1024KiB-12 122 9.71464e+06 ns/op 107.94 MB/s 1.1543312e+07 B/op 8 allocs/op +BenchmarkParse/headers/1024KiB-12 122 9.76116e+06 ns/op 107.42 MB/s 1.1543312e+07 B/op 8 allocs/op +BenchmarkParse/headers/1024KiB-12 121 9.780622e+06 ns/op 107.21 MB/s 1.1543312e+07 B/op 8 allocs/op +BenchmarkParse/headers/1024KiB-12 120 9.859726e+06 ns/op 106.35 MB/s 1.1543312e+07 B/op 8 allocs/op +BenchmarkParse/headers/1024KiB-12 123 9.75166e+06 ns/op 107.53 MB/s 1.1543312e+07 B/op 8 allocs/op +BenchmarkParse/headers/1024KiB-12 121 9.846607e+06 ns/op 106.49 MB/s 1.1543312e+07 B/op 8 allocs/op +BenchmarkParse/headers/1024KiB-12 123 9.635251e+06 ns/op 108.83 MB/s 1.1543312e+07 B/op 8 allocs/op +BenchmarkParse/headers/1024KiB-12 122 9.688004e+06 ns/op 108.23 MB/s 1.1543312e+07 B/op 8 allocs/op +BenchmarkParse/long_subsection/1KiB-12 519026 2026 ns/op 506.82 MB/s 3648 B/op 13 allocs/op +BenchmarkParse/long_subsection/1KiB-12 572042 2042 ns/op 502.9 MB/s 3648 B/op 13 allocs/op +BenchmarkParse/long_subsection/1KiB-12 595951 2087 ns/op 491.98 MB/s 3648 B/op 13 allocs/op +BenchmarkParse/long_subsection/1KiB-12 580828 2049 ns/op 501.34 MB/s 3648 B/op 13 allocs/op +BenchmarkParse/long_subsection/1KiB-12 618507 2046 ns/op 501.84 MB/s 3648 B/op 13 allocs/op +BenchmarkParse/long_subsection/1KiB-12 580020 2148 ns/op 478.03 MB/s 3648 B/op 13 allocs/op +BenchmarkParse/long_subsection/1KiB-12 582886 2062 ns/op 498.07 MB/s 3648 B/op 13 allocs/op +BenchmarkParse/long_subsection/1KiB-12 547491 2037 ns/op 504.16 MB/s 3648 B/op 13 allocs/op +BenchmarkParse/long_subsection/1KiB-12 591332 2016 ns/op 509.42 MB/s 3648 B/op 13 allocs/op +BenchmarkParse/long_subsection/1KiB-12 547256 2070 ns/op 496.08 MB/s 3648 B/op 13 allocs/op +BenchmarkParse/long_subsection/64KiB-12 12032 99299 ns/op 660.02 MB/s 261824 B/op 26 allocs/op +BenchmarkParse/long_subsection/64KiB-12 12170 98395 ns/op 666.08 MB/s 261824 B/op 26 allocs/op +BenchmarkParse/long_subsection/64KiB-12 12337 96487 ns/op 679.25 MB/s 261825 B/op 26 allocs/op +BenchmarkParse/long_subsection/64KiB-12 12370 97164 ns/op 674.52 MB/s 261824 B/op 26 allocs/op +BenchmarkParse/long_subsection/64KiB-12 12255 97493 ns/op 672.24 MB/s 261824 B/op 26 allocs/op +BenchmarkParse/long_subsection/64KiB-12 12483 96815 ns/op 676.95 MB/s 261824 B/op 26 allocs/op +BenchmarkParse/long_subsection/64KiB-12 12420 97012 ns/op 675.57 MB/s 261825 B/op 26 allocs/op +BenchmarkParse/long_subsection/64KiB-12 12183 98665 ns/op 664.26 MB/s 261824 B/op 26 allocs/op +BenchmarkParse/long_subsection/64KiB-12 12513 96224 ns/op 681.11 MB/s 261824 B/op 26 allocs/op +BenchmarkParse/long_subsection/64KiB-12 12544 96060 ns/op 682.27 MB/s 261825 B/op 26 allocs/op +BenchmarkParse/long_subsection/1024KiB-12 637 1.885907e+06 ns/op 556.01 MB/s 4.120278e+06 B/op 36 allocs/op +BenchmarkParse/long_subsection/1024KiB-12 619 1.914979e+06 ns/op 547.57 MB/s 4.120277e+06 B/op 36 allocs/op +BenchmarkParse/long_subsection/1024KiB-12 606 1.895725e+06 ns/op 553.13 MB/s 4.120277e+06 B/op 36 allocs/op +BenchmarkParse/long_subsection/1024KiB-12 658 1.89123e+06 ns/op 554.44 MB/s 4.120279e+06 B/op 36 allocs/op +BenchmarkParse/long_subsection/1024KiB-12 633 1.905776e+06 ns/op 550.21 MB/s 4.12028e+06 B/op 36 allocs/op +BenchmarkParse/long_subsection/1024KiB-12 616 1.929449e+06 ns/op 543.46 MB/s 4.120279e+06 B/op 36 allocs/op +BenchmarkParse/long_subsection/1024KiB-12 648 1.880385e+06 ns/op 557.64 MB/s 4.120276e+06 B/op 36 allocs/op +BenchmarkParse/long_subsection/1024KiB-12 645 1.904431e+06 ns/op 550.6 MB/s 4.120281e+06 B/op 36 allocs/op +BenchmarkParse/long_subsection/1024KiB-12 634 1.908513e+06 ns/op 549.42 MB/s 4.120277e+06 B/op 36 allocs/op +BenchmarkParse/long_subsection/1024KiB-12 596 1.908037e+06 ns/op 549.56 MB/s 4.120276e+06 B/op 36 allocs/op +BenchmarkParse/comments/1KiB-12 390549 3017 ns/op 340.43 MB/s 7968 B/op 6 allocs/op +BenchmarkParse/comments/1KiB-12 405556 2971 ns/op 345.65 MB/s 7968 B/op 6 allocs/op +BenchmarkParse/comments/1KiB-12 404995 3015 ns/op 340.58 MB/s 7968 B/op 6 allocs/op +BenchmarkParse/comments/1KiB-12 395350 3029 ns/op 339.1 MB/s 7968 B/op 6 allocs/op +BenchmarkParse/comments/1KiB-12 392308 3057 ns/op 335.94 MB/s 7968 B/op 6 allocs/op +BenchmarkParse/comments/1KiB-12 386764 3042 ns/op 337.57 MB/s 7968 B/op 6 allocs/op +BenchmarkParse/comments/1KiB-12 401968 3033 ns/op 338.65 MB/s 7968 B/op 6 allocs/op +BenchmarkParse/comments/1KiB-12 348346 3022 ns/op 339.87 MB/s 7968 B/op 6 allocs/op +BenchmarkParse/comments/1KiB-12 393630 3027 ns/op 339.29 MB/s 7968 B/op 6 allocs/op +BenchmarkParse/comments/1KiB-12 406990 3062 ns/op 335.42 MB/s 7968 B/op 6 allocs/op +BenchmarkParse/comments/64KiB-12 6589 158810 ns/op 412.73 MB/s 483616 B/op 6 allocs/op +BenchmarkParse/comments/64KiB-12 7358 164238 ns/op 399.09 MB/s 483616 B/op 6 allocs/op +BenchmarkParse/comments/64KiB-12 7141 160829 ns/op 407.55 MB/s 483617 B/op 6 allocs/op +BenchmarkParse/comments/64KiB-12 7294 158015 ns/op 414.81 MB/s 483617 B/op 6 allocs/op +BenchmarkParse/comments/64KiB-12 7669 157771 ns/op 415.45 MB/s 483617 B/op 6 allocs/op +BenchmarkParse/comments/64KiB-12 7027 159721 ns/op 410.38 MB/s 483617 B/op 6 allocs/op +BenchmarkParse/comments/64KiB-12 7195 162734 ns/op 402.78 MB/s 483617 B/op 6 allocs/op +BenchmarkParse/comments/64KiB-12 6668 160569 ns/op 408.21 MB/s 483616 B/op 6 allocs/op +BenchmarkParse/comments/64KiB-12 7077 160660 ns/op 407.98 MB/s 483617 B/op 6 allocs/op +BenchmarkParse/comments/64KiB-12 7322 163013 ns/op 402.09 MB/s 483616 B/op 6 allocs/op +BenchmarkParse/comments/1024KiB-12 500 2.402606e+06 ns/op 436.43 MB/s 7.512353e+06 B/op 6 allocs/op +BenchmarkParse/comments/1024KiB-12 496 2.360589e+06 ns/op 444.2 MB/s 7.512352e+06 B/op 6 allocs/op +BenchmarkParse/comments/1024KiB-12 512 2.337546e+06 ns/op 448.58 MB/s 7.512353e+06 B/op 6 allocs/op +BenchmarkParse/comments/1024KiB-12 508 2.331435e+06 ns/op 449.76 MB/s 7.512353e+06 B/op 6 allocs/op +BenchmarkParse/comments/1024KiB-12 501 2.393732e+06 ns/op 438.05 MB/s 7.512353e+06 B/op 6 allocs/op +BenchmarkParse/comments/1024KiB-12 507 2.349216e+06 ns/op 446.35 MB/s 7.512352e+06 B/op 6 allocs/op +BenchmarkParse/comments/1024KiB-12 499 2.356872e+06 ns/op 444.9 MB/s 7.512353e+06 B/op 6 allocs/op +BenchmarkParse/comments/1024KiB-12 496 2.360781e+06 ns/op 444.17 MB/s 7.512352e+06 B/op 6 allocs/op +BenchmarkParse/comments/1024KiB-12 505 2.341432e+06 ns/op 447.84 MB/s 7.512352e+06 B/op 6 allocs/op +BenchmarkParse/comments/1024KiB-12 507 2.352952e+06 ns/op 445.64 MB/s 7.512353e+06 B/op 6 allocs/op +BenchmarkFile/Set/n=10-12 32388 36874 ns/op 79156 B/op 162 allocs/op +BenchmarkFile/Set/n=10-12 34860 34576 ns/op 79156 B/op 161 allocs/op +BenchmarkFile/Set/n=10-12 31663 36448 ns/op 79155 B/op 161 allocs/op +BenchmarkFile/Set/n=10-12 32635 35288 ns/op 79155 B/op 161 allocs/op +BenchmarkFile/Set/n=10-12 35481 33951 ns/op 79156 B/op 162 allocs/op +BenchmarkFile/Set/n=10-12 35470 34372 ns/op 79156 B/op 161 allocs/op +BenchmarkFile/Set/n=10-12 34107 34743 ns/op 79156 B/op 161 allocs/op +BenchmarkFile/Set/n=10-12 34537 34198 ns/op 79156 B/op 161 allocs/op +BenchmarkFile/Set/n=10-12 33093 34686 ns/op 79155 B/op 161 allocs/op +BenchmarkFile/Set/n=10-12 35330 34200 ns/op 79156 B/op 161 allocs/op +BenchmarkFile/SetUnchanged/n=10-12 1777142 672 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=10-12 1836876 649.5 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=10-12 1785456 674.4 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=10-12 1784798 673 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=10-12 1765108 679.3 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=10-12 1772678 675.4 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=10-12 1765484 675.8 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=10-12 1776146 674.5 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=10-12 1762842 678.2 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=10-12 1763796 678.2 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetNewSection/n=10-12 22210 53586 ns/op 112072 B/op 296 allocs/op +BenchmarkFile/SetNewSection/n=10-12 22615 52871 ns/op 112072 B/op 296 allocs/op +BenchmarkFile/SetNewSection/n=10-12 22689 52944 ns/op 112072 B/op 296 allocs/op +BenchmarkFile/SetNewSection/n=10-12 23026 53225 ns/op 112072 B/op 296 allocs/op +BenchmarkFile/SetNewSection/n=10-12 22468 53241 ns/op 112072 B/op 296 allocs/op +BenchmarkFile/SetNewSection/n=10-12 22190 53655 ns/op 112072 B/op 296 allocs/op +BenchmarkFile/SetNewSection/n=10-12 22042 53898 ns/op 112072 B/op 296 allocs/op +BenchmarkFile/SetNewSection/n=10-12 22264 53898 ns/op 112072 B/op 296 allocs/op +BenchmarkFile/SetNewSection/n=10-12 22448 53929 ns/op 112073 B/op 296 allocs/op +BenchmarkFile/SetNewSection/n=10-12 20338 58390 ns/op 112072 B/op 296 allocs/op +BenchmarkFile/ConfigAfterEdit/n=10-12 21932 53985 ns/op 110456 B/op 239 allocs/op +BenchmarkFile/ConfigAfterEdit/n=10-12 22218 54146 ns/op 110456 B/op 239 allocs/op +BenchmarkFile/ConfigAfterEdit/n=10-12 22770 52957 ns/op 110456 B/op 239 allocs/op +BenchmarkFile/ConfigAfterEdit/n=10-12 23065 52758 ns/op 110457 B/op 240 allocs/op +BenchmarkFile/ConfigAfterEdit/n=10-12 23254 52308 ns/op 110456 B/op 239 allocs/op +BenchmarkFile/ConfigAfterEdit/n=10-12 22642 52538 ns/op 110456 B/op 239 allocs/op +BenchmarkFile/ConfigAfterEdit/n=10-12 22845 53523 ns/op 110456 B/op 239 allocs/op +BenchmarkFile/ConfigAfterEdit/n=10-12 23142 52208 ns/op 110456 B/op 239 allocs/op +BenchmarkFile/ConfigAfterEdit/n=10-12 22696 52526 ns/op 110456 B/op 239 allocs/op +BenchmarkFile/ConfigAfterEdit/n=10-12 22670 53289 ns/op 110456 B/op 239 allocs/op +BenchmarkFile/Bytes/n=10-12 4063782 299.9 ns/op 1536 B/op 1 allocs/op +BenchmarkFile/Bytes/n=10-12 3894992 299.4 ns/op 1536 B/op 1 allocs/op +BenchmarkFile/Bytes/n=10-12 4059357 296.6 ns/op 1536 B/op 1 allocs/op +BenchmarkFile/Bytes/n=10-12 4062432 297.7 ns/op 1536 B/op 1 allocs/op +BenchmarkFile/Bytes/n=10-12 3986314 303.2 ns/op 1536 B/op 1 allocs/op +BenchmarkFile/Bytes/n=10-12 4088090 305.8 ns/op 1536 B/op 1 allocs/op +BenchmarkFile/Bytes/n=10-12 3747225 310.9 ns/op 1536 B/op 1 allocs/op +BenchmarkFile/Bytes/n=10-12 4041183 303.3 ns/op 1536 B/op 1 allocs/op +BenchmarkFile/Bytes/n=10-12 3936990 295.9 ns/op 1536 B/op 1 allocs/op +BenchmarkFile/Bytes/n=10-12 4056452 304.3 ns/op 1536 B/op 1 allocs/op +BenchmarkFile/Set/n=1000-12 270 4.665043e+06 ns/op 9.080753e+06 B/op 8158 allocs/op +BenchmarkFile/Set/n=1000-12 264 4.600826e+06 ns/op 9.080755e+06 B/op 8158 allocs/op +BenchmarkFile/Set/n=1000-12 249 4.663659e+06 ns/op 9.08075e+06 B/op 8158 allocs/op +BenchmarkFile/Set/n=1000-12 262 4.560795e+06 ns/op 9.080753e+06 B/op 8158 allocs/op +BenchmarkFile/Set/n=1000-12 261 4.545252e+06 ns/op 9.080751e+06 B/op 8158 allocs/op +BenchmarkFile/Set/n=1000-12 255 4.585769e+06 ns/op 9.080751e+06 B/op 8158 allocs/op +BenchmarkFile/Set/n=1000-12 265 4.528743e+06 ns/op 9.08076e+06 B/op 8158 allocs/op +BenchmarkFile/Set/n=1000-12 260 4.55837e+06 ns/op 9.080754e+06 B/op 8158 allocs/op +BenchmarkFile/Set/n=1000-12 254 4.733236e+06 ns/op 9.080751e+06 B/op 8158 allocs/op +BenchmarkFile/Set/n=1000-12 268 4.517181e+06 ns/op 9.080751e+06 B/op 8158 allocs/op +BenchmarkFile/SetUnchanged/n=1000-12 24054 50062 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=1000-12 23992 49860 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=1000-12 24243 49966 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=1000-12 24116 50252 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=1000-12 24015 49049 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=1000-12 23538 50949 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=1000-12 24710 47454 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=1000-12 24528 49760 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=1000-12 24070 50063 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=1000-12 24132 49845 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetNewSection/n=1000-12 165 7.069379e+06 ns/op 1.2362811e+07 B/op 16254 allocs/op +BenchmarkFile/SetNewSection/n=1000-12 171 6.921937e+06 ns/op 1.2362807e+07 B/op 16254 allocs/op +BenchmarkFile/SetNewSection/n=1000-12 169 7.026478e+06 ns/op 1.2362812e+07 B/op 16254 allocs/op +BenchmarkFile/SetNewSection/n=1000-12 170 6.985809e+06 ns/op 1.2362812e+07 B/op 16254 allocs/op +BenchmarkFile/SetNewSection/n=1000-12 172 6.945601e+06 ns/op 1.2362793e+07 B/op 16254 allocs/op +BenchmarkFile/SetNewSection/n=1000-12 175 6.895789e+06 ns/op 1.2362807e+07 B/op 16254 allocs/op +BenchmarkFile/SetNewSection/n=1000-12 171 6.970291e+06 ns/op 1.2362805e+07 B/op 16254 allocs/op +BenchmarkFile/SetNewSection/n=1000-12 172 6.93129e+06 ns/op 1.2362808e+07 B/op 16254 allocs/op +BenchmarkFile/SetNewSection/n=1000-12 174 6.858132e+06 ns/op 1.2362807e+07 B/op 16254 allocs/op +BenchmarkFile/SetNewSection/n=1000-12 165 7.168207e+06 ns/op 1.2362814e+07 B/op 16254 allocs/op +BenchmarkFile/ConfigAfterEdit/n=1000-12 163 7.088205e+06 ns/op 1.292619e+07 B/op 12280 allocs/op +BenchmarkFile/ConfigAfterEdit/n=1000-12 169 7.026903e+06 ns/op 1.2926194e+07 B/op 12280 allocs/op +BenchmarkFile/ConfigAfterEdit/n=1000-12 172 7.00595e+06 ns/op 1.2926191e+07 B/op 12280 allocs/op +BenchmarkFile/ConfigAfterEdit/n=1000-12 168 6.915877e+06 ns/op 1.2926181e+07 B/op 12280 allocs/op +BenchmarkFile/ConfigAfterEdit/n=1000-12 171 6.807039e+06 ns/op 1.2926174e+07 B/op 12280 allocs/op +BenchmarkFile/ConfigAfterEdit/n=1000-12 175 7.013696e+06 ns/op 1.292619e+07 B/op 12280 allocs/op +BenchmarkFile/ConfigAfterEdit/n=1000-12 165 7.023768e+06 ns/op 1.2926192e+07 B/op 12280 allocs/op +BenchmarkFile/ConfigAfterEdit/n=1000-12 169 6.876612e+06 ns/op 1.2926181e+07 B/op 12280 allocs/op +BenchmarkFile/ConfigAfterEdit/n=1000-12 166 7.025686e+06 ns/op 1.2926188e+07 B/op 12280 allocs/op +BenchmarkFile/ConfigAfterEdit/n=1000-12 166 7.155696e+06 ns/op 1.2926196e+07 B/op 12280 allocs/op +BenchmarkFile/Bytes/n=1000-12 42536 28533 ns/op 155649 B/op 1 allocs/op +BenchmarkFile/Bytes/n=1000-12 39154 30934 ns/op 155648 B/op 1 allocs/op +BenchmarkFile/Bytes/n=1000-12 38112 31965 ns/op 155648 B/op 1 allocs/op +BenchmarkFile/Bytes/n=1000-12 37158 32409 ns/op 155648 B/op 1 allocs/op +BenchmarkFile/Bytes/n=1000-12 38313 32188 ns/op 155648 B/op 1 allocs/op +BenchmarkFile/Bytes/n=1000-12 41460 30948 ns/op 155648 B/op 1 allocs/op +BenchmarkFile/Bytes/n=1000-12 36631 32433 ns/op 155648 B/op 1 allocs/op +BenchmarkFile/Bytes/n=1000-12 40725 31776 ns/op 155648 B/op 1 allocs/op +BenchmarkFile/Bytes/n=1000-12 37750 32391 ns/op 155648 B/op 1 allocs/op +BenchmarkFile/Bytes/n=1000-12 38304 31891 ns/op 155648 B/op 1 allocs/op diff --git "a/.benchspotter/sessions/01a12097-6c1b-7531-9b08-41118f50760f/cpu/\341\232\227\341\232\227BenchmarkProbe.profile" "b/.benchspotter/sessions/01a12097-6c1b-7531-9b08-41118f50760f/cpu/\341\232\227\341\232\227BenchmarkProbe.profile" new file mode 100644 index 0000000000000000000000000000000000000000..8b52abf5cbbd7540972e20f3f947bb45a76803ff GIT binary patch literal 48904 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 literal 0 HcmV?d00001 diff --git a/.benchspotter/sessions/01a12097-6c1b-7531-9b08-41118f50760f/meta.json b/.benchspotter/sessions/01a12097-6c1b-7531-9b08-41118f50760f/meta.json new file mode 100644 index 0000000..3dc61e1 --- /dev/null +++ b/.benchspotter/sessions/01a12097-6c1b-7531-9b08-41118f50760f/meta.json @@ -0,0 +1,19 @@ +{ + "name": "probes", + "benchs": [ + "BenchmarkProbe" + ], + "git_commit": "74c4f677f7d380f117dd4e27dccad1b7bc042184", + "machine": { + "goos": "linux", + "goarch": "amd64", + "num_cpu": 12, + "physical_cores": 6, + "threads_per_core": 2, + "cpu": "AMD Ryzen 5 3600 6-Core Processor", + "cache_l1d": 32768, + "cache_l2": 524288, + "cache_l3": 16777216 + }, + "go_version": "go1.27.1" +} diff --git a/.benchspotter/sessions/01a12097-6c1b-7531-9b08-41118f50760f/results.bench b/.benchspotter/sessions/01a12097-6c1b-7531-9b08-41118f50760f/results.bench new file mode 100644 index 0000000..a4c0219 --- /dev/null +++ b/.benchspotter/sessions/01a12097-6c1b-7531-9b08-41118f50760f/results.bench @@ -0,0 +1,59 @@ +goos: linux +goarch: amd64 +pkg: github.com/git-bug/gitconfig +cpu: AMD Ryzen 5 3600 6-Core Processor + +BenchmarkProbe/UnsetAllSections/n=256-12 1214 986139 ns/op 222858 B/op 52 allocs/op +BenchmarkProbe/UnsetAllSections/n=256-12 1204 990883 ns/op 222849 B/op 52 allocs/op +BenchmarkProbe/UnsetAllSections/n=256-12 1213 1.010632e+06 ns/op 222849 B/op 52 allocs/op +BenchmarkProbe/UnsetAllFlat/n=256-12 2242 526884 ns/op 168832 B/op 52 allocs/op +BenchmarkProbe/UnsetAllFlat/n=256-12 2242 518990 ns/op 168832 B/op 52 allocs/op +BenchmarkProbe/UnsetAllFlat/n=256-12 2272 523023 ns/op 168832 B/op 52 allocs/op +BenchmarkProbe/ReplaceAllFlat/n=256-12 19441 61817 ns/op 160481 B/op 57 allocs/op +BenchmarkProbe/ReplaceAllFlat/n=256-12 19671 60646 ns/op 160480 B/op 57 allocs/op +BenchmarkProbe/ReplaceAllFlat/n=256-12 19303 61461 ns/op 160480 B/op 57 allocs/op +BenchmarkProbe/RenameSectionOneLine/n=256-12 17032 71112 ns/op 168393 B/op 303 allocs/op +BenchmarkProbe/RenameSectionOneLine/n=256-12 16491 72511 ns/op 168393 B/op 303 allocs/op +BenchmarkProbe/RenameSectionOneLine/n=256-12 16771 71676 ns/op 168393 B/op 303 allocs/op +BenchmarkProbe/RemoveSectionSections/n=256-12 15346 78806 ns/op 213305 B/op 48 allocs/op +BenchmarkProbe/RemoveSectionSections/n=256-12 15358 78362 ns/op 213304 B/op 48 allocs/op +BenchmarkProbe/RemoveSectionSections/n=256-12 15223 78671 ns/op 213304 B/op 48 allocs/op +BenchmarkProbe/LoadIncludeIfGitdir/n=256-12 738 1.632159e+06 ns/op 684595 B/op 5954 allocs/op +BenchmarkProbe/LoadIncludeIfGitdir/n=256-12 724 1.64687e+06 ns/op 684595 B/op 5954 allocs/op +BenchmarkProbe/LoadIncludeIfGitdir/n=256-12 730 1.642532e+06 ns/op 684594 B/op 5954 allocs/op +BenchmarkProbe/UnsetAllSections/n=1024-12 76 1.573481e+07 ns/op 1.014829e+06 B/op 66 allocs/op +BenchmarkProbe/UnsetAllSections/n=1024-12 75 1.5914246e+07 ns/op 1.01483e+06 B/op 66 allocs/op +BenchmarkProbe/UnsetAllSections/n=1024-12 76 1.5651015e+07 ns/op 1.01483e+06 B/op 66 allocs/op +BenchmarkProbe/UnsetAllFlat/n=1024-12 140 8.511731e+06 ns/op 982063 B/op 67 allocs/op +BenchmarkProbe/UnsetAllFlat/n=1024-12 141 8.474946e+06 ns/op 982062 B/op 67 allocs/op +BenchmarkProbe/UnsetAllFlat/n=1024-12 138 8.596572e+06 ns/op 982061 B/op 67 allocs/op +BenchmarkProbe/ReplaceAllFlat/n=1024-12 4036 288188 ns/op 946276 B/op 70 allocs/op +BenchmarkProbe/ReplaceAllFlat/n=1024-12 4200 287403 ns/op 946275 B/op 70 allocs/op +BenchmarkProbe/ReplaceAllFlat/n=1024-12 4214 290750 ns/op 946276 B/op 70 allocs/op +BenchmarkProbe/RenameSectionOneLine/n=1024-12 2360 505646 ns/op 1.982294e+06 B/op 1079 allocs/op +BenchmarkProbe/RenameSectionOneLine/n=1024-12 2403 486532 ns/op 1.982296e+06 B/op 1079 allocs/op +BenchmarkProbe/RenameSectionOneLine/n=1024-12 2577 492874 ns/op 1.982295e+06 B/op 1079 allocs/op +BenchmarkProbe/RemoveSectionSections/n=1024-12 3654 340132 ns/op 977854 B/op 60 allocs/op +BenchmarkProbe/RemoveSectionSections/n=1024-12 3583 348576 ns/op 977853 B/op 60 allocs/op +BenchmarkProbe/RemoveSectionSections/n=1024-12 3486 345554 ns/op 977854 B/op 60 allocs/op +BenchmarkProbe/LoadIncludeIfGitdir/n=1024-12 180 6.586774e+06 ns/op 2.81671e+06 B/op 23631 allocs/op +BenchmarkProbe/LoadIncludeIfGitdir/n=1024-12 183 6.480406e+06 ns/op 2.816709e+06 B/op 23631 allocs/op +BenchmarkProbe/LoadIncludeIfGitdir/n=1024-12 183 6.524314e+06 ns/op 2.816715e+06 B/op 23631 allocs/op +BenchmarkProbe/UnsetAllSections/n=4096-12 4 2.86652704e+08 ns/op 4.161488e+06 B/op 92 allocs/op +BenchmarkProbe/UnsetAllSections/n=4096-12 4 2.96065105e+08 ns/op 4.161488e+06 B/op 92 allocs/op +BenchmarkProbe/UnsetAllSections/n=4096-12 4 2.90395055e+08 ns/op 4.161544e+06 B/op 93 allocs/op +BenchmarkProbe/UnsetAllFlat/n=4096-12 8 1.39637449e+08 ns/op 3.92391e+06 B/op 93 allocs/op +BenchmarkProbe/UnsetAllFlat/n=4096-12 8 1.3865881e+08 ns/op 3.923896e+06 B/op 93 allocs/op +BenchmarkProbe/UnsetAllFlat/n=4096-12 8 1.38232921e+08 ns/op 3.923938e+06 B/op 93 allocs/op +BenchmarkProbe/ReplaceAllFlat/n=4096-12 694 1.74319e+06 ns/op 3.777282e+06 B/op 84 allocs/op +BenchmarkProbe/ReplaceAllFlat/n=4096-12 596 1.923503e+06 ns/op 3.777278e+06 B/op 84 allocs/op +BenchmarkProbe/ReplaceAllFlat/n=4096-12 637 1.852339e+06 ns/op 3.777276e+06 B/op 84 allocs/op +BenchmarkProbe/RenameSectionOneLine/n=4096-12 230 5.192618e+06 ns/op 2.8214256e+07 B/op 4164 allocs/op +BenchmarkProbe/RenameSectionOneLine/n=4096-12 230 5.140154e+06 ns/op 2.8214258e+07 B/op 4164 allocs/op +BenchmarkProbe/RenameSectionOneLine/n=4096-12 230 5.269271e+06 ns/op 2.8214286e+07 B/op 4164 allocs/op +BenchmarkProbe/RemoveSectionSections/n=4096-12 525 2.310713e+06 ns/op 4.01364e+06 B/op 74 allocs/op +BenchmarkProbe/RemoveSectionSections/n=4096-12 546 2.299224e+06 ns/op 4.013644e+06 B/op 74 allocs/op +BenchmarkProbe/RemoveSectionSections/n=4096-12 538 2.278819e+06 ns/op 4.013644e+06 B/op 74 allocs/op +BenchmarkProbe/LoadIncludeIfGitdir/n=4096-12 42 2.7449247e+07 ns/op 1.1423055e+07 B/op 94301 allocs/op +BenchmarkProbe/LoadIncludeIfGitdir/n=4096-12 42 2.7776282e+07 ns/op 1.1423061e+07 B/op 94301 allocs/op +BenchmarkProbe/LoadIncludeIfGitdir/n=4096-12 43 2.7625295e+07 ns/op 1.1423066e+07 B/op 94301 allocs/op diff --git "a/.benchspotter/sessions/01a120a2-f2e8-7ce8-a8ac-b6a8bebf1cbb/cpu/\341\232\227\341\232\227BenchmarkProbe.profile" "b/.benchspotter/sessions/01a120a2-f2e8-7ce8-a8ac-b6a8bebf1cbb/cpu/\341\232\227\341\232\227BenchmarkProbe.profile" new file mode 100644 index 0000000000000000000000000000000000000000..5e525cf6c23f253728693f6ff8052ec0163fb783 GIT binary patch literal 61142 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%0Avc+8fZ4+GC z38H#^KuUQ6GVdwpY_g-3^%Lyg@g%Yon}X9_sQi)LdgTxLp%@%fy|{y_mfSM>ch$Q) zo_~G7d&(%|q#&($ilXGN&?JeAP*@n$&MV0^G3irNbiPx^r+T2G{~YGu9yfGMY~A?~ z<>6jG>d1J=#O3(;iEUdjwy`Pl_2Pxwx6uU6Jo4=gy^OLpIiy8)S_#Rq*qSC{%VRKc z24vI8r6c$6VQcOuK(*3y7}6-eM)T;3;tMEV)^?Dj_#`>;?OL)tsQMN+k6&#i3Z_?_ zKf3vkzREaRi40Xi&C;rO56QyhXX=jRr;5dQTA8V3TXc(pRu7P1r8cWNxrMt_q0L`kAdG}PP6pK>yXm+~p3qd+`JZNg;m zQ{g)Q?cpo!k){Ofss3LtKjpO#m^e8SboA_4^Zg4)Ox3+*@oxep?&(evo`$<#0=KG}Du-}pbC9DDO_Flcmq{28r9qN9gpa~BYeO+&Q9<)yt*M$dkL8T;6 z>8WOd_b>slQoNV^IW=%Wf&iewEC<|}wWum3&yfCsMHj%KxQCmI?-C(w{H|*yRLn^T zuSgo!BroZ6yvGTvJdlz3MP|}nUM2L8r|Au-; z`I}ZwXp$lcpkj)^V#QEkq|1qWQXm0UMY%_hevr`DN5 zdlfS6Y9D7+uKNX+4J9QRR~#;&bswPz9J~{CqdT=$-ST2gc4h6OI2Y);yI}hGw*^HX zcAjNgnpbx;Tf|;GC)W}*F3TZ^-{bl&z#QCxY)EIY8tn&K8C_O#fI(X`TP|qD{-S~U z3~xR{B4r?~o8nrvO@UnL+WDa&1`XUiyz{+fBu0mETm4UMlk{=?o7IaqTs=LqXuiuU zwTg_2kJyh4NsBehPdfhdlz(desx~wtonW>SFzg&Rv;^6L0s{m58Tu$cm9)=OGHN`0 zXdd6u5B2uC!@NYU2)kJ}YAndmV(>}1qzB5TJ}F+Z=On;e^`!~~GV{DhcHw?2xH?_l zHXan%8Ti|Mj;$}0-xXA$ORjX4|ACL;%MIcdmMvrlsVmLC#UR361hM^L5ungq#DW~* z-X=jH&e@`{Xm!HtI9}S3*9X-5l2eK3UcsV z_bTcZ|DN>}OVOYihyl^3s!s_MD$0mtsGRGywtUK3Grl8TAk*877l6CNkfv-wM=8c;iJbp5J%(Z-iK+^6*l;Wm zQHkJfBj__u)Jg$8xq-qX=GBe^y>W7Y{v8Ku(=szI$1QV zm;KWahvyCY``Y%Ippy;D-AW^vg{P*Y)y$r~w;$d85bCM>hO&RE=qQ-ns1_+FTG!bn zn?%NWHrRKh%pLoHNEpf!Fg4&eIpuiPXDUh_a@tYP; z=wDqyvo#5?V|~=WUO`Rbk&{YjT@cPb`F#{kh_)ozQ-aP)F0xq5S1a1YuIKXvsNi$|j3P+;9LIuRa zIEk0)=TgA2BZ2&$h-xVy$U9t%0S9_HSZ!HQ@Fr9Vt1}uez{pQ8WQF^u5i=(0FsHmp zSSWoGsgc92h_yP#5S)ErRI}kLjLpurwQ7&zzA|vU!&SVRYKeXU*^^vZFKUIw9%(yT zLhlEB$3suC@(EJ|>r~iw06*-kLkZBMMToDiq=Ju`d zR%x3p&qOiDXWVN`H{|HU%NTAETom(ir@<&~4v?{;ESb$7LgcL^W-^uDju z)&P45zhXMoxpIC%C5kWKgKx;+T+mT?fNehIRh!%dTKqXuX$_HT!&I^b*WA04!xH-6 zHi2RWPA3uo9Hn6Z)dw3`71U523~PkCLiE43niO3UiIEK;!qKA!XfIkC0-3b52GEUL*|>cGX5CF8SOz$75Kw09O5O)%+FRg9sLsz$ z#n1w%Cr+|W zhS?S^k0sN^k7RDVy_*@cfDoBK7PKDPgMxX=wd)pOE)U`iQ}u_M7C~s=pD(*_^In~ZU&$N04rRf%##I~(he{aWyFoM zXR;?o;?oiQLokFCJfYkOJfP5;ZEtXHC1&j?)Jml|1af*#Mq z|E?%N^I0=lOE|(FVRYEs;5Y;>e~5A;8l#c}Z}a3Sgjj+KK;3+x^piK0CsHVS1>9Y| zI0p>J9%{k28E(Wl{dl)%ZX4!2=LfZVj@ewAjb>DKeR5X`Hwym);frZlUlL(kd>&{h zSLF3ql-I_UqqzYY0V>AO&+G;zr5*9jnEwnkErJ++rkY!8dn89ePO{$Q;Z@>;h8pZK zvXp)TwLaeWKLSR~dH)30-f*I{_{p(OeTqODL%E>wW;V=AVsf6cc8_3RH}zVx(24EoXv2 z+XP>1Pu4i|E6o0@%_A!x+NjUucbT!Lp8B~9w>RgPMj7L%=3zn(1_qqyn+zGQ^bwY< z0;axz7ixWD!)gmt;q$vm=|I5wn{b9sw18gpE~T;ps0=Vc{evaaZu@60ghuH#>9G00 z#Ry*2=+EFB5_zg5cd^7b4rfP^N--$&JFL?1=r4J# zCW#ZIg21Ejq1Wl*gKs}vXh1*%O>;wQ=eNeEs#RJQGxjkV%E{O91%FbLP1jZ~>$2P^ z&v#mCsQ)hEbJ&|aL5(tFK^}TxQHjxScX*$XdStoSKV%b~8-aK#3HE{{6g$~}b$MVN zHBmJ|k|3Dza#vB*clW6@-^0~}U-iihSo_KX3QS&w-k}~WW1Kq1p9-Wlr<`yqmseY& zRAgurgb4gjlW)=St|PNMi(U%2+(X@0ACx3rZCVTPP+~bBx?UTN(RK4jyElP_u|6<{ z-4cH)Bw<_*6Eap?sfkvK+pYYr!Q>Aqd5agRuf(ZX2%HaZY#Oui0Fta07rWG2hYZ;r z`g{Wl+8g8quJe|+vG%^+Bw{Z%Ok-f&IE8ES5Dh9xSG}0CopZmo3~H+B%W7o50Cpc8 z3KVpmck8J{!^eKk8mTgvF^TzB_mdvIs2Y+q=FhI1>9cQ}s-)NWKK+B)XEI9;l0N2| z(Fgr+_P{?&#bzMG(_ueV2J&f_S)PYG!Fehe2Df{s&R!{7X^c;{o}+T*Y7}0U3e_kO+Rq$HiT$ivzYRxvOizbVQR7MXp z3ehb$>reNo$AX*D{roGg!~S5BW-2IrQK8zirz>cWQ4)PIdG5yJ(JRK*XDd%iMnl9y z$49o}bW8i)tXb=uVH_Ew8s1P(8Z^LqgH=HvI61}=d53;~j1XT!Te8J;PcGm>iRF5z zkv+xR-q6{qmAOl)qi_Ei%xyR&7}`$)1ShZ`pp^)i<18;gg`>4M-RmBW=Uw}K79rk+ z<^ZIl6n<0wj}t};k8sX0BL%>0Q%u$RVhBz#fQoVm*-;=R|6`q9pn#&r{m{lu{9c=J zB{IO~r^~sxsYcst+Y+qal>mhV?Cf%`#O_zHMv|uAIx7*&?x=ryc*&syCs7eDg$s^E z=ZS?i(Re;Ck!Uw1#<$X3jbts3D{cO7e%|dK_pLv>qVGX7D%DX``s~1ToNcInv#5x% zPt|y9xb`j_=V`=!naK)WVxP{CU;#uo)Vi_6EQyhrbdS*;!^qH|#2}gbjCIW{H}UhO z{W}yw#VMgT(RAUVwuFl54yRhjj8{Yel8Mefy=xjPxE1d$b2w@oV^tPIVt6#YH@=Xo zys4i)csrVYloK4$an6khWHUv&R*%iqB*)M!{1wZg>zy55&OCCn&Xo>)%bl+~N z0g-3i(=&CAQ7YNW4k1aq20vknZsBjk*8&b&;RI~XYbF$OFc@I zjcE3phI$I!e|bh0q@j$@n5_i^53r;_A7z~TA&VPq;s?h1`={BXgw=@9MbI#8m~NCG z-1s!=M3F5~iIrdAi#+=J)pLJ5Wv}Hz)JMW!?pxSG_?s_&HU=1F5XTaqvuA&xBq$60 zxc|bOF`M;X6ch<-(Ye7Ddcn(HDSk5;*1ID_&4hOVMwC5uUga;e?ThT=I_iHr!B6m;& zx=}uGC1RW>q>2T1oce^SOk|`yuKr@Yo8JVwLk3z0T)@ju%6?!4)0gLi3G{$|gV;`XNe%W{vqvi)Dnk^{VMI!u7)hVI+qCsq8Qpy3 zPI-Fz=Da}*o)|Xlg)aVIlkXX~hqbnrLnGD{?c|pAOv6hmvpzpCvR^QJQ-LW%!w5@y zDP_%?C@gA)Z{&3Ur52m!t{cHLd))acsmEa&v#~Wg?|X{=_6T#;Y1D<(`S@5i)#!^o zhwRoTEB7Fz7F|{cwV$+|0%Gzr{$TvSzx69lV_$mnp~GQT%ilhfYHgt~=9ECAjBFx* z)cm8(uo5oR96JZP8T$m1w2Btq>RAPzJ9dv}K`}u=Y}}RJ=Yr-_Ro^d#BoZD&7E`)H^9f6`r`x;!8sK@qhFj4EJ~7xf=rgPm#pB8jk$pbA^z z!T%eKAcusJ2q`2Ho6*R7as0lBJ*V3^o#a2~B|<{|M%}kL1+!M2_zl%VZcSk3o?l)u z*7GCF;xXCG!>1iglTJ6Q=Bn;qj5_*#XzMd<@H$%=+S#ky)c_Kerf=UUnaACRYZXhB z!(QvUZ#p=$j-!#Zm(sv@4U_;}9@7M7$*Pu>P4s+$`Ok=-FVhOD>#T9<{FE~P(K!3(1B=|%^P=v~1b zyu&|f)p<`MHV2xkm%r|4vaHr<;Y1sB7XgGmYk!a9{rZ))r+Vm}{Y~mh!ez&?QnDO? zs9qcThtO`dL2*hll!z1%iMG7lHusJ&^n|-!ayG%($dVP5IT_P;%d^w2XVbp-8I}@% zvTkN|N~trL3d1RB6e^=<;|ALOfP*uDd$?Hl=b)lQL%2*b`}Ba@e1*bj_J8({+<8mv zeM?ws*~ZL?;R&A`frjCl+lPRSO9vhSPw6QUxTTF((p^MMk!!IpSSoUSh43tE)*5Vd zo7VoiZ{~v1-uTZIMYUQ))!IE$$}}S^^C7%Hu#k_UWkCSmzL}nq(Obgs7|3JpC*O(X zI#&3#LW#$;Q#tW5X5lTe%goFpH5Ju!;ajcZ%vjMILKw9d|E@f6x zK##(~1>oGZK6|*kMPzJJ$1ii2)Q5galSu0#IacxR?!%%gpGm7UEqbA-->f=ikca)p z8=6cCn>lrqsg|ZQdx$gt@kQi&nywZqITWEC>l-z2arRn;Im*p0!d8`yVCa|b{-PGK zlidy<+rygyZ9&CilPwx*^E~TU4-Ru4HB4|r3qN6D6$up*JP(NuMd_wLIM!R$Sh!ye zjrZ+*i*CQ#>Fw-x-fp*DO;BAcu|12DXCr3s8*&|A88B%w3WE|}d*ba|x7u1n9w5GA z-Ix|r_g>*i?T&8XrIG&xOu1ujgWZb2#?Db<@&-sP+6$~vICuiE4hlWots><5Neh^= zkS8)pNKS-IFOpp~h+G1+B2fEDi@5?V@_*oKvd4^_CZ*vuWh!|N?|n5iB2PdZ5HCl` zYDF9@b#bMUEA#Thr7SeJm6!C%GyMMX%V9s7t9#PXPl^uxcb3V#!(~En^TnnO@^-b4 z*hx%$vhVZ%T;!oqrXapkxBdBUR0GP0iC)z5?l~jrxCyhT|9kRnJj`@#nW(juwx;wKDRJuAlY38uUu#jx+mkbsSi87wuRX7X=d)@YRj zPORX|BAchn=^XToZ>qzmbFFqi`*bz$oDFuACP#OMC%D)x#j6C;1`dv0aC!KmKr5{C zqyOg_nj@Xl50|R?W8A)c9zu z3cthvL6Vl1rsZJN?RdLqVHt^MJ033fOqYsfkN|$mF`7++9d;B}#|`o~v9Aoy`>9XS zI68e)PCm*#Hs+@JbzM1OYuh{%mY9}R0swL?Oi~jNOcxd=%_;nxJ6mgqh!w1=tco%v zH8j#pAmq+!zJrTyE?BX>E{*_MeUjX~DcO&&8FUrA;6j92crLGf3)}E&M)WX`5s?zOf_f$O#NAIeOgV9P z_=@|jNo477?3Q0)5H^x*H<`A4q%SB%S$oOKM%~MJx>mP4RBtm`B)dvLMrnx9{df#N zg=X&EawZ~O>szPHPD3UQY%CpXe<>}El-y)HIx9gmc}%44S&~2EQbo6&itCCB1+(!B z%D*kswXfvQO*;&6iQvBAW(K&5kht8gSU&6rA(I;5-*~>D5rK+!E-iEO-oZrDV+Fdh3ZFDk$ zM0{X-C2_NBlw|F^TDYF!x}YL*H0=iNmBL0MMs7$xKRxa=NeDT2bBs{i#Jamz{idY!}7vma-91daw7bQedz}%3-qYjTkK7Hhn;fnnB+HESe1) zg)%G?>svBvw{{=AA%vg^_x2nkaB>$85qMx!i%Y+8vyE^C6$4(psxULJYz-e9RXB-y zSR40Bu)mdKu&7K;n?>t*DDm=@H@%m|f>F7ARj_ZwCyq#~e3#o4M)>MvyH~d;iOYfz zCs9a~TXaEw9&#Hn+cQ*`>`AlBq{L_?1A#t$<*g)~N}1EhSSMf^CKjAnqqu1XQvMuS z{rU$#I)$5Q1kqaX2p_O|O?R>Y=tUCbo(E=?l5Ar6%2*%)&U9mY8WYb+l;Y@|8@#*m z18R=2KpblWhOdORlvI4jjDrrzHTVcIYB;;= zWK@~HnN)b&Puh3v8n%-jVRy+WyitSYS{zenZOh-+}aCYOj$tJz8u zrQQ{dJ=KAr0*yI?S1bM~=<=(4y9$w-4LG<&^@W2H*%Xm4iKt@Ux+Y(KoWZ^7Cm%u-;cvvnWZIZwzVb5N9zQN%@nmkL!g^#E-8~ zQ`UNU&f4uleLN%`y!u3_9H^}a?~$VS#x*d&Eq)C7zNxyuT3&#JQ;wY?Vk!0+0TzzD z_r6e5hB-`VS}@~p&^;9lP;8|jmIAef$;j>8NQFd+TL0d?H3H=zM$h7Yi|zY`?egGt zClt_VeUIh@74U@QJljp4%PN_a`tDDfB zzqMqZa!@c$hUjt!T-39_uzy?6z~)^^R}d4e%L5Bg`8U1?Tf2w~mi|{K=H^^iSZRc? zN`Y4R$&rMT5RPvvJrvoTjGm+T9tPjR^F$B07a4*dl4J+_72zrmB4=MmsO{H}j~e=I;u_Pt396_$oz!_CS4Mw4g0 zK4OQV8`i|V0?m|$_S?Bw&;7y;zPyfIpIo+tWg%W5uBT8wnn2cLd;l$C78Wi{E1e}i z+I%9QbS_KzX_azq)NRqn+2+rX{hl$Dp9D5|TGwS>0)nL=Rvj;S+GG}_=!5YbkJ{2c zk*r!7wt&UqkLf>@^YD>hWh+4ynPrKD!Qv60iK(o>J6IK#-7QKe9g6EJi%PiMRpA)2 z-aQZ!%DWzHnH2R?&IFP29=3G>?#`%z{2oMPi~Vbk1FfRHCTFEgZS!L31Sc*Z_gjfQ zELW%&Wr?_`IqylLm%GJPkrAtRGXnwXFj-)s>VpYUn{Ys*PSbA(IZMep0b%00GJFFJ zYaG+a)r``(uld>*X*?>+_~;8|D+4_TIxP#Mh)>=hD@TKrdskY83V)PMwCl7D4e^Ped~u4)UqgFN+IHpTK}CQ1hVpl>^g#= zJAY8_CZvR=MBX?Ol7z!CEc3xP0&il^>_}1Wo;0d@2!Y@_dQQ+Pl}Jj+zj@_%#6yeN zGxvpLIL-mx0p8rGIEQ>(GvA^NyQI5sp9BMFaPs#h7W^=d5L-@E+vaKzN7)-7?O28W zTwID-X0xyB%D@JgO??Lv%s8&!$y`m?=}wnq8D3m_RWE(as!oARWux8KN3WU`rFd$} zOKJLX%?W}EC49>lY3=ElF*A@wtAT!Vv)mM6C=ftlqeYniSg7l3alnF*r)SsEzUiCq zDR#HYb~x|XBpA#BHs}I;YgSta3d-iTCUrs_d@W>Bw*BMN3Xz&)w}p4=lygF`d;jmU z>U7??vj`IfL+rIuTBmIQYP5OUlF`aIDyA?j*<_JZ;EdwR^Wapi#Y}WB46}~LVetJ? zh#2`2gdiX+-y-zY7)och4WQKTgN^iJFk!yEuP1u`IEEq#|eCuDo+Q%S7* zUAQQAdY;7f%JU!#+lOuebaZmMV;C4-d-}Ox648nyzhr)j13w}E7B>V(fs~bAp~(Hm zhMvEa=keEk%Ib=z=nab!=(it?$vNif&HJIl-??kdjU8h@g9~3 zipa5KJf@n(tC?)KgztJ)d2tp>c95k5=DUE z_xFJ2Je={WNb`9ciMX#nvArp!w6wYSg;uPMfbRX;t5&lJ-Li~Du;2)yObFzt*NW`+!sof4wP}P+u~D=&lch*?0<{ zu+}VZQQr~c0ANs@@k3((Z3z&Th7xJ#j=p)teA(^Y;Pj-j$d7hQgeO3+m9pjKgfJUW zi$LVZr;9^C4P@no`5Wb!B{`7=`g|ku&C}Ct(icIY{_W+eS*(gmVJ%d zTru9@9SUbP$|PO@9v7>SP9m8nM}N!*uKLI05CkBlme6YwnA)>>t9q~C7$S83vdWO2 z4KO%uLhmrys0`_k1;CyEJ{tghb`y$29Pr^eF9VpH_Qx$6*S_MFft07S11=7h-U7&!MmOS`HbY$jQBq*D7peFwwN721ux9eqEz*0 z_ETD!ISX3WDn&@!LK6=E=G4LP5v#AK=YIM>y`dtm@wjoTh4bwz6#G^1FAf^Yva7m- zB{RoF1e`6D-LvDy$fBQi-Am!q{$gtx-mfN()E~mlUpOTS&VHm+^}Ic=CGK`gEa6j8 zs<3Z`&vMoJ(tJNs@m<5UKF5M^sO<7KIv8O|1C!5##5E`$ zvf%FbEiRCP`2W`Vm@7CqPo&E0*Cq>gHk=?3_Gz2#6MJ>ENI94$=W?1;PpYgtE4AlX z2To2FW_+R$PF40CkZN`2apfq@a*epRN>%z9KB*dK9-f{xlU6$lkD6EF$7i0qWy3Q( zkv|LH#tF3V3Vlq5Ue7&`udVq7^G|BhX+IEn5Fi2|^QO#6=<|$X34hTwIXmO%;93k%+5VAQ zJ(hXXWRjm~CUgF_xw;U-;xG9y`=2j`OQQc&nZMo z-T6K4ydcc3F+0TrsaWRc>zdgyQroP6okgF#8xs62exd)C>e-w)>vwDB5H7R;Iu=2q zFfE}E#wk|&`ZF`$Yvy-;L~IwG=+|CEDf}$_NtMd=Qp4!5JbJ!;4G}0;CM{ntFs)>8 z;uN-m?c0rwbE8)-^IKm*T$3<6VdfR!(gLyUr*`#U$^?iThV9ZdkghlYvp8qIc(~`o zF;nC=JYn)JI%JvOV?|akj$twjT!heYOz!C45OM$eegyOl^~1B^OF4wz6gMe!AK(S0 zTW=cAr+qiCr++RIb-#1va`9-sf9~zg@Gx32E2y46=}6NRAA*nKP^D8fB~a2s0nIOf zV`9S@S7l0gh-#F!&5Lp`gAYUcQ$*?A7tsgn`8pK(oN)w{XXlL5a*66=?4QW@72iXK zf9_{SrG@nQDsCG&d&Yb{R;59nhEw32bQTM_yi>O)_WCx)Sx0MIv^#&gJ)a_US9}p3 zO6?@pm1&nyOv%kYamswL)b$5po4CBlfXJ zbFgvPrLt1LrH^o1{p;hfHj1@6gQCybDKk9U(SasY?xC?{fQ8~5GxF{B>X@yG|6hVx zyc)J@dDzj7Bs`heU{*Lo%Z(Z*mq6vcbNLK1f;6Ztw8m1G+{)7 zk;4yHD8S4ZSduuAwfyJ(UIUA$lU&u(*$kc4_BR*cs7`vqN$*Z}$%A+){m5wfc~>7ANW zfV$r`CYPCiX9WW7oPK3V4?%s2jn%@mu{OfRIJT+2aBx~;*jid!mMaxeTm8cBXBzR3 zG@>^ZW65#MAkd%FWAZbtuUhd-?nPV<>eqR=!O~@MJxsD6r30gS!QF^QDmq6R%3gfG z3im0*PDzb4$qbWBEo0V-S(+w}X=Ukr;4<>)&Wv}Cha}?koMotY8YhRcR2y?LkCz?1 zH26i#mYkA5;NKJsWM)r|mVDbx3K}7IMrs$Y8yM%`-{o+})@y+NrX$g>9P+9x)7!`J zBNp4YKVc)#*Rs3hl6Cl>W4~rS@Uluckgz?q-i;7O;)e^7wyr zZ{`UjfOL)Ipj`IMGG>uhCtE2D3h)Isv=}@sOZ(TfR)nyF-xRdeA2hI2Sc2$=p6>|xi;*EUJGRUOMR+DNg643*tP1j zI&VByfs7|#1EUt*G zv=~Ii$vUkGeNXp`RQ9zYquCSe4_oKeV-7y_O!4}!Gsk#NXJJ@HND4j=@5f}CCPnZn zTt-XaNfmm51gNwCRo--rA`ErTRwUl0MbKOKeA@qKb2htM&T=LH<|WHG=NGiVP%jAx z5nHXCQJ)vrm0U>d9@tosqoNF;|1-OIFm<+e%lK>Mm*9e(zToopW(5v1X_`*VUkXBsIB-f_KjRn`QIwkuY_HWZW;+&spRdZ0eq32=K`y9jeCty%f}E z_~BcuhvN0SiI|>`A(E|zjLB~4#S#jh&(siIIc9X082~WI6y*T1X~F;@;;U9I4|oMZ zqPDn9b%nR0*F5^o3<}H(h01VZVzQ`hxHv1u;B?S^?fQ*>=ELPIDhwT^Kx=|+Vix&? z=dht9>3rMIchVMF7wrZLanX}Bm)*zrr(Fni?rYsNp*f|-*P4g)I5d$&PaRruR5tEA zv2)=0AZB@4t-qopH%+EmNmpGf^0r0EN@KgZb2&5>DQ=uh-Kxd=NVIaJyb5|Z2)l21 z)5+A9_$qr+^73*c!&FcT^d{!^)@*0iRxNwTdx>vi1iiEoxj8cuQLg$uaY>6yj`)=X zFLY{)@in{DAjyS6q2Y=j+j7z#6vI_9lZWr$&Cp>H0)CgohjD~TDbq8N0FVT|?J2nU zO2i1&@X4z+GBTBIUFYory4N+1zJ1~5{jtd`_}%jSMrYP;JuT=<43i}_)0(WOS;Ty# z*7spxQ;g=#(4Sy#ZekP7?SOMyx28q3GSN&@fSf>Uf%0MtH8wvfHnduPPv@?$4#<1J zTe`=mUgB>T3)aHsG?G$okAztx^w-JO3?Y&rU1UUPZg>6>o5qQ>A}8lUwiKo2)uX7y z=4c)UcE;R26pyrH%k^%r#?BEty&LruM^|4pyD+7XrTg~xmmZM z7hD*K69C+8r;>kqw`|3uD%TQ%9nxD}l5&M!Nz_O6pu&607R2(Z%VQ$v;0OG$HZZg$ zaMQuNC~87cft=7u<`f*X1=tpt`FDqP^sIo^%Sc*QVkex|VI%PL@!`$H$Ftn>lP}Q* zv>r8GFG?7rX+cieJ$tra*-tJi%FQuGovVeNUZfNw*aPaK0=&kYlX^S-$E(K7@o$Q0=P9GCu#-P&Hc64<1}a=98ftd-vAgLTRit*M>Tfe2@a%P0>a2!#d^r;2*FM@?Ytpa3>iUSfwiy5Cof#E^I){k%%a z&$k&z@5`Xqx0t8Lt}{Qh%1g5bL#@t0%{Z8KV@8M02@yD(pMC(U1_MgC5CEH0Hg(jYmZATe@__B61=VJ39WwOLQdi zj6WJEVF{~SGan?}A2`v3itZQQDp%i<$e z3Zyy~#O7Svoem9@0SYxbQL}z@z>HKN&%I&QC!m}R4DRaLyH_CCucH%HQgmwm5;0%sT??F$o*DvZlqNR%p}oZ_2e)D1XNqrS_ zR?L!NeZf3uQadxQ6r}t7@+wf=J5P=86^ZVYgu5w;JSphy^L{J5A>0zS>8!5Ky;SJ_ zxtU#{HF+k=eelwNC%HpM4wD2DNV{$r>9ziK)%KBn+#SWh$#Jvm?2Rdk$2gAzDj0(d z$FTUvV}XIw=Du2AXON0x|6De9<06DlEbE-VnZ>j10~KC96jJi`p_uAY)>zLcsr`f7 zvq%qQNpRs<{XU!uncY?-<77ON+TZ-z$e6VL7o@P?2)acF_EYx2e(%l*Zd+|jQ;Rpp z*n~j(XPZ%DHCIgNhCl5nj|umFT5TB2BNy}UG91K-2<4-sw}O6GC*<_dk?BA@7HIuL zTlguA5y5mtmd8BC+)kqUP!*w27b050VVo?&XH-?7JHt+r!5KfiCv(Ob5L)^Y&tZSn zl31*Bkr`uu3SI~nL{LH$N3;04t+&(JLmqxWHWr_IrPQ=@(0oh>aIp#@d$>5F5`E;xcz@=`^jj4yPQLnyf8Bp<7(02^oP+6b zqCgO9^A}`ccNw{d4IFBX3Af12BDQiO=v#I&G=Zh%?0K2zb6@_+)dp$;)-Y2i*oL*xJ;=y;=)QSimt_ks4iGE5_!~=Z z(&iqozGn3C{=P&=#{EJJ(NsX-qpkD`PJ{}6uw^q5Z0H~gF0S!e;BL0XkNpyf_76?< zi$hj#s2)Q7pz1c#5Iv|wZt@o++2|G1jNz$3YHp^Mec`Kf6H73&`A{$6ZxYxIovbpZH}wxuytc4bIXgY8<%?9>2Q6f-lh zh+0?G+0cgJynW9&BzOiNfzig-UY=t_x@c7SG3E;87XdkGrZ4M*ncRHb#Hs=)UG;?4 z-!g(;t*Q02bWjbWJ8JF22M+XqY3_gj&gRYAbxp>?FtN?|1%+eSE&X#Tf(qut25>x| zxaB~h`6?8EXTjEO!Xz$Syb#0Z=JP*=#GIlZPNj~bUi!RMp0t=Wfge8qS<;tXx#P0< zSDt+e#);$>Y@PhT_al`wv-+k&Na=2HT)WiJurJZm*2DM{e2EF$!rVzIA&~r*2U1kq zwCjmGPnjU$!#v8VF#e9^XF+63Cr8*mJmG|oZSTI{Uo|AZ%nv9MtuB#kVV>~CQ_q6A zt9%ZoT?xghI87oj(~KMZklE^nC8Jm&PEaU z%PH+)?O@>>akOq$PxV0qaDitZdIbiiw?51c#oS`kma4DAxF;=iOipi7`ifrs@bge_4BVU%P>H97-Pd47`+zC4O4M9nuH8*=}gQ(Nu zdt`AeqMxcS-i;n?AAx_8T^(W$G9>cWXPwL%VAMB)Uu|SP%++cCz_vvPKdeG*WIycw z?=VankLwZ-n-Y40_n;_O_Z&bxYgjsRopi^3-cI{qAcv%qC5BI8mAlj-<=@4X7IB`| zWPiRoFb_ctqkg4>`af!3k1lo~D+zjUV@EE)(SD9JCg6Q)at_ZCeT4oTz&e=pw*NRz#3qIW@nG?3#UK~kpVCawl?@1k;Kl%G zNaUkGDf0+L7`u^XEo7vb-?_>2MWbAT7}Zt^9Nv4I9ec+@?19d2Z(Znd+f?gSz~f+b zUxy0^Y39$fun^-4n+#FiE6Rc>Dnw@Zn+olcHQgb2nDiyhUw~wV8jw*}%tUReOx64h zsuH*vUFtU0J@r@33pds9Y(DpJ^nL56-Kii&hcvpqul%Wk2=o=?GgtK2H5TlI z-LS&1+8$Y)g7{$rvjYCS+CX6r(~*Qius}iHmRn*DtOa0z{GNhx_X-5SA-5r%UZUu)8PMS7e(fB}h_#LHEB8=HL~L4q$1@iVv)@o6Q_Bn5ywJztNp=su<7b2^91t_5KC@ z))!(Yj>e?wX^xSld%+mZNhLjkmd`DtCBZ67ukXA#mI{*Y&@`I{0tG}#rd@_RDeG3RJW;#%!ohJNw1LW?&<% zvDYnHhKA}kh)BuxFFG{_8hpA9nJI2$znIvzp|ra}bg-Pg>+LUY)H6qDn#)YTzD)o~ zVtb`QMw)86b1q?zrgo4v2}s)X9DsmjN@y2BfV8E&rFvITJdoUdcQ!3IAY0=Wc0T4y ziUol>ZxtSKuks^#*D^*8%208-z|t<4QwESpE z>>+!+0g54Nv@$Q}Px9^8@piBll{q;Nvde`9#w7|mwXRC#0~xj|WgS&*(7RaMAD6Un z6rG){7%Z#>M;hOeQ;5-_YgSJrzb`01cQpriOUC^5W#=(dGHncCLvB3(IL#MxeAz~A zvkUnBvNrIK`x}oSmg3=|vtRBeoSZqci~9TjWOwCTo-Fm&O%8_f z*uXV*kcDcx#FyB;Wdf^8TTEYEl>7^cT7j}|KU8d0C_?TLLqsD6zbY){u8V&@Lb&dR zY+m5=bGp`;Brq{~CPeVN?DTgGi}1SlT081ewa3X&W0i9ws$2RISR|o{$vgd@%qrSv zv?zDl+B9vhMS4;ZlU-DGk&O&9=o&0>Hz#)$jp1UPU=gYYsiW)F(Usy|?*?8NDvC%F zKi256<5juScPiw0hR$;33;L9$E!<$DL$st6V?E8Ys-e$q7Jtm_|}=(YIJL|aUz|>R_}27@4y)Os^!l>lskQG%eE7T zJsZSr{Bt>Au6tI*kr?^iij0s0)Z<_@2W#GEHODO`c|Sw|FD1wj#)lGg7sJw26#rCX zXH$Nq5>Ex-_i4R!!|Ed7LyzZs$}gE+2qN5omNJeh-q%^yCfTI?cr(%JG*KrS%!1P5 zEs))cP+6ftfp`ItjEELiW2Oo_FQ1#1sG6Iio9ZDgJlBuoPK6DI0NayC3kJcz3h;yB z5yBk*2lZ_Z-w7EWj;~ox!)|sh72+pv0Y7(|6$4pHY7YFloc+Vsh}Xyf%U7((F0ns+ zB;4J)F~bNMCp_6zWl7>*v;Q>kPlyPET|eEffSo2J3fi$N7r-^u3#KDT3B%ltl=ww` z5r}*JOBo9BUy#;6zq|+bCnsx>-v{ajmNJW2p36TBB2x8rY__B^jlUnCMlAU4ziQQ_ zr9`8iL%Sw>(T|Lpffh6SJ_MB-bIhxHS{7_9T_cahkOf-uUbuh9HT!H9A&1zGL5vF9 z5NRO)5N&PyH+Nuq8BT(C5uYfRzrxd3RE@i@^I*nH}u1RdOB1XglckRpjv(vd zz&U&>&R;61q+txDREU$_3pOt@D+b^`&rSfNI9BGdqaO*S5_Rn$I>V}@9_Uqn!ICqm zy4Ugxze?uO{R-z<7_ckUxNrn#>M$f<^*UA+j6sEM0!nA>9``hz9~Lw`oKAj&5&2at zSF)wi6%|ZOW-(tv*q`E#+^~>WkkG2Cv^#KR|E3Qo3I=9-oi7#Tlg>*`PYZoVE6mJ{ zWpI3WJ>NO%DudAf4jp3~afBbjrB-(z9XAQMx7rB~#>}N6n|&E(4NqB1DhF>MapUd%zFe@hAQM5|Ty_0sWsi zAYmVYt9ap9$83%pKYv}1j{qmq`gtft&?Thpo5i(s=1{BVmQicXp&N~mFRQ#x%!Jph$JqZ?>H?I! z`Iqv3k)~wO4Gtj`**r}K4P*t^HFHUlv|zME*gBI}do-wQ96UOpNPPh#P70Q6GfSOiq(;y29 zjy4pp&9&M@$^b)Jnfp1*)F<<5&%qZ1z=^tq_h6(1?^Aj6+WeRO%v|%(Q%dOUeCqQ$ zjf7gAqr^vh&5%)sQ@rKMGARK!&nyOist$CT4pY#n*q`naKR8fgK_C4I>4|#-vh6sw zsQ`>U%PTpsKvLpm{>e*2Ne``>_N2mL4bJvK0;C~(1i^r_2kR;d^^VGR~U^O(V=HyBGph~ttk+Kp|p( z{C@VV+1akwE8#d6ZJuELnDuEb>AEZ}I!;2B{fLoXgfeC&hZbB?_GTIlKGlu*kgmy6 zX+CTIv2TYE^7_<2x~z-QzW@!Ie};ou*W2YCVzM(rpC8wqKv@5pysX+DaBPDT(Ug&!IAsk0Spch_paKa~3&9m-J z#f1lp2%F~NP$$nO(xR3JdStp-?i0G=ojX1yN1(!oKLiz;*s7SD3zpm_rZ<3%F;*%c zQPKZc={95%qU|85hO$q6#MWPsVFzp(omTc$-d3ND|F(uUC{vEP#e&JG+>RxUm`*7V z2#C(=lSeJixz}WQWMeSB!8P8B(scx6-kM6oF+S;TM2WgEX_=ZKgk3@r9eBUj_b}Ff z|5oWdEtFony>|yE7lP8Fd^M#%fY&k1Ald_Y%6~AE7;hD*rYmepq=|a2&3{mSy)M4d zkE03CkPm4rs~JX3!+RBL#$LJaCdIEL0CgTaqHrA@ZqR#+Y!>~zSeeJj=wwyTy14|| zSA>$9EkY9umfwoLkGLL*`;m1Em=HoV^cHZ&AWGogO)H&MI6a7GAs&X+CToVNa@OP8 zZDSfz7#ZacAWiAyZu|%KpuZ=VX<1{cMw%Cva?`Pvd;}a@tG;8WmHZgFZN$vm$1iJC zexW(hfsDxT=c()c#^>rG75`mu#g*f?>njM!-b760Sv#to`{gK4Ob3~kp+K+in;_he zIk87e`%dUB4CxOs3ZQ6&4{C+OHWp7lbnZk$7z^_gvk((m&6~yUPpV6GN;+MBn9r@XJo>$)kcYQ4s)$HL$Gel z!`S96Ntns+dC6xz4zP+a>$_0LWZxGzf{2CCz6b17bvDYfi>cMrqZi;_REH=fWKurh z3TyaVL1tw(q{ecx%q0d$Y+POw6`z99ZiFFR;FO8P@V_yQ6x>LYDI&KdRI)sx zM(`jI3Hv6&+mcS9TMlc%W>xuwRR@O3aJ@%_lB^FkYJ-bc_Hgk^3u!u6ShZbW3q5v& z^XCqD6wjvmlD1GlcuK|t-*AfogWO0h3mA`c|Z&`HVP_@Xm~XH`&6fgao2hsZ~Z zi+H*?b=rdqS&__<-RBSnA+1{_v-=#H!}RtW5vg18v93`F=UpnNF0$oc$H?oHX!wLa zs?MEpg7y8cUI)CRPorCCk<9>;Hf(-$F{E5pcblX*{A8ynun5xW6V8CIOoXJKtUwCC zJ4@~ug`<`w`D2i248E|0Loamwg0lURNY%zB2h*Q=QF=iV^%HA0uz0uM#j#vo*{4*w zmLT`tuQ))i-zw5NU?^GAVC!Qk^!IHPm>nR-^1b=FhNkm|Xt$x14#+|Zh(Yo?_9a#4 zgHT)7xTS7)ltv4oU+>%&L#frkwn&_o$=IKChQp5zYMFq)e^Xfft^=%g*EYJ=!9qJX z@E7U~lUfwA_9}T(=^fUWZa&YIR=}l3tc5U9w}o|J{~n=DPa^$5e%GgbO|k;#;%nwW zIBCqpe!=~puy2c!YzXylb8XZ4J8-JQGcD8dlsq(#O8D?=3tlnn#YDcH=?T&Y5$FlX za=MuI|2r3z&vsVl-><`5kbV_ikC%!P5aLlK=gcAAN1VsL8SmYOSEeg`?!1#XsYd`8 z;YY~udKWJ1W>?p>#HCwv^hO4?=Z(c14oT|n}12Xo(gb{bpuTX!{P1$(#3N)t?fQpUz-#;x=LV{cCbZ1>`gqY8x~n0 zdptSEcR64`h9GFwWFYlFC}nLEA0sX87Kr*0I#&?tCxS)_ojhwCsW17mY&z!t@7v#n2tg1C9pFDBAd)rBJ^6YSl>Q zxQ^k4yvrN$ky;|&g8yf=G#W9PBTg2bJ$=)%Ou}OPK>xekg@nYB>Vk9H=s-O6VmN zNp*dLi_^k7F~jRm3r{TUc#tE&jW@^a&nX%ur}IK%N0yE{Xq?fqx2~PN`aL5kYf0n6 zp#~%bVZXVE4Yg+Nd(XsWka?5dTS-dSG$m7qtFz_Ntc5c$mAxl;#F*W`F0+=W{MQ!2 z!kv^l(%7na=_sZt_oqFWXJZ-@Bal{V_z|?!)h%`j?ZV3jr(fc$TwJuFOF)=Z`SLpCG)U<>Kt1N>rJsPk{`}f^mh^upn)j>Vmt_q)q_>hHA^0(wM}sy zk<@nsPQ?wv)G|*@V2fm98fe$130^%v+jI(dhJd)hD?0bnl@!n$*bCVXWBN4)nWz#NVk?;GhX*b@1X!Bk4blQ zA#%spHbqt|j;}st+G^PwOh}xx=~GCaBr4!57RJu;!3(P%TBmyX$DlPCR2AKoX8d)F zci{(ayEgUoA6GJ;%S+}?-f`b1d`f;EUt15~5(kR|R)5K-(Gwt^`@j3qkJ{@}yfN7` ze|fm>-v*dEGyk|Dgm_NoXs4T)%6oDAhvQN5{1wlCOXm2=D*PWarPB8vNj%U!cFIN! z*dD1*(z6?mKJ`$jnFLvNi5}wPEwm>?4MMAb;6&oW7drbgy@Vnt?>~16Ob+Q(>a*m& zB`U1K5|ez{eivz1&PF!QG6iNllYO<^_vNjQZHpCOHx9$=D5XpuKW;VvAstH7OyKW3P$O>HZFPpSgRSg9W%F@@P-e8)PZ-xb_<36OkDw*=(={jfRA zr+k;H^P%&E2lBa27@tcV4YgekSOroPq8IWFw1l&KSs;sR&c`lBt(|vHJ&EiSd3>5? zOu;T4piScq4Y=b*7u_N?%5>EY5@(mMbE;IdqMjxR5ZhF*JfgPgkJ2SO6$e)V#1?+Y zhQ0q3pjzm7U$c!3K#!coYJEl!5DCPly5v#^cno#A$yloew zu^+u588stPYETi@KpfC%+LEDv84b?U8#JWp=_f$840 z4hRsZcMQS8K~j0iJ%97R!s_@kM81mwd&#m1Xon9^cpfHXTJ~|^_`H(|e2*X$i9_yq z@J$vT_hW$_#TUnoiL*$kNnx&+Jz-A=Va>y^FQCB3qZiAB#lLjm9WWklWFvNKOBb1( zrOmuP2MXgK_WodB-0RM`YQKnKz*8^!Ym8UJaE#v~Js`I&CT)$KFJnl$H0vx9=MUI{;5V z&YJ|{7j^^=n{GJEhR?CQ2Whs2^1PXEnueZc@bI-oA6&IUO!jdiDVXp#E~`ProTvL8 zDY}E_p6I0Xjb#}uZfMD5j+1;JWL;Rlobmo^z!PyV?pp)Ev#1HU;Z45A{+{~aZj8v^ z6n>t5oR(doIe0*SVn-R{I8i`xiTXo!rBtb7jJNQQP024Ob6TTDC zy|)Yp@&}F)MhMj0m%-m)X@BT@P$k_4p6tHNpO;N)bCr%84x(-<07YSCKvQ^AU%a609FOSj{q~wSW*xvqp_R4snRp_1) zE)a|)9ubFP_NwNiZoP=cxHqGpMzNI?3WXsh=B=cqDOy-wo3v$zk{4fHbyu~MXLB!w zvbz+g_;8+14w{|WC`7EgzqMYcPyk4<1iEu35-|ZaQ=N{*)Jl~<;c89lHViN0!~hnA zbo$y_2M<>~Wc}Q0Y@G~X6PD;Tt$wpj`Q|@rT?wOud4>JXfJBrAgJ zb83LqrU*6ynz+q6HT4`|1MW-BX`#NSUeu^+m~S6k*TVMRKctn2*NHj!QR170{cS4K zel6f0?j<5Z;>;J-fupuu#73l(^qk5;6}H^+%r;JGzzI*Mb1`RKv(l$-#Ic|MaU|X- zng&qYHrLN)o969uuv`#VVJ^oS+XE|n^FQ=H`I}kYgF3^+x>3Q%&#BLcTTs46Q~_<~ z+}@Yl7cY4JS`(`M1#2HuC%3#0zNTEU$Rf6Rx5M!Z6GXsAd{61=hSr^Z_~+RI8fscH z)tB(-N+fJqUl*5*Lk52p{s2uxt?zQhd2z%uH?3cdtp{el*$dC_Cg;zlY9bF>2nY8h zs#&06eU-TSjj@Y6IYQ~?Ck$=1|LD<^SNMKzSpGT&n?VxM;4?a!jr6eoRf11FfT^1QVyeHs6#Sp>mFLi*)JIndPGN`qGla}fB%+|8yYRhzk0L=-aeeE?8qt@P z6jqDXL5!llZPII~IV z+HbP+br|lJ{2_mCN%^16Qz3$0|39bVf_#v#jne}jnZgk1E8eGS6>lTW1MnSJCBEXa zcx&6p!`thvBm-p!loW8ZoHqjMayhwkLml+_)8KD?_F8_Yv+Tl^|sNNfb= zDI}8NS(l$D4xr}Kena6t$Jt_2pCS1iBR(qPVNyv2pjQ{DyhnyBeJdDd6+1yi4TDZ> zxs{n3UnUHz;X2ivJb#Qj+`f=qHdv_8j-lg86s{AEvd`k#9bZ{zM^Ju69ef5x`&7<) z6U`X0h?Gu+Sf=jnhD*isAdw+rFFL^x|6OL?if2`xBro-)Ov6)U+dWzx&yL=67?>F6 z`>n)LNTkGEVq-pz@MZg9X*mt5`$}!%lzqmGCL)8|68--`6VwWtV6M<|MpE4 zKJpE%$h17Bke1#^z$@0`e5bG+usbdjO;cxdzB2D`Mz?|9IcN;q#7{}=$1)wyu>6+# zb+^YIHk!c}R?CLG`Ws5_T%D=uzi6Nwrl&KtP!`5rAASuFv;__VDrN#@xDgsz7P`Vj z-s-7Wc0~s_9x(c0&e>#&uKoAdiB6r61uI>FM>fVNLt=i6qIiZG#mRAaN2otAXUGLf zarI)!U7*j&C&KPRfXQ(NClv4{-XsHxh5rG>Y!?}DYiX|fMC%|T%8UWjwav9y?{Ax# z6(|}bzpPZ$c}1q?rF^P6U6jd-+H)}9@TKCT%w;$k;FE@ct5oJ=Bdez+FWioPk&Adx z>-Y^$MZQE@i(~EQI3783oK>-Vc2?g`3m)VwVd0-TaH2|3;S{B9LpRgTK&N~S=tUl- zTpk~?PHBy}hsSGajSuoH0Y`asO@s3DPu9<8T%GUXS!b|!lEQBS&%O1%xY1kn@1_ya zOk%#{E|dEYZY!iOB)RnHa~p%{v7GMeoSa}6rq!)ZoT7$%a`P0b{tsT_VS`xo*S|(w zL(%V_J+S#|A}6!XCo1YU=1Un5YVr+#2i%fl*;{2^D_+!!(L=25Wk?AfvLY0io)R1c6+#Cr0}`D-foCGtUX0W&-2lq&m;&Wa`n8jdsklsQ_vk-Z%3gI5b^D^8Bc! z#h#V>oNx|T;CpJOGnjd@Opy#YkoB1W1}ME}(!Qh|{Log`4J2D+Zmv7qDocC!QU28v z9wYbCgd%OxX8HWap8PBVEUn2V%!F__4@|_Adw1#xk0A;e66*lWUImQ&s?q>wF@>b-OnvSh? z)y!rGut#^%9fxy5!wOG)Z!ADsJ2#t4(ZA>P=)?EwRnDk+CFl+*B@%VuU z!rnj{5;tz`O`d-@4$qnwm2vH7e`JT2KM*|XG6!F4%p*OB5lr8Tk70d@5{UEJe`2y5 zcNis}-d(@ANXO;+&~>I!yzRvM$?}()TdKrUnp#dw$|XFk-y4qPg68XKr5p_a*RCMAWtL36{FeKU=<*dn%!voJw^dFFE3Q&S64QC%p`F=UO;^m2{s&+HwwR zuQ>RbDR=${ZD8edUy4)8{8#3~bFc32RDe7Ufg|LG=Nv-@TMKugK5`nJfFBoR5xDB! z+vTxdVQ+cPkf?XDa7BO(fNtV7tBaC2p)<;N>AlC?CKxr1G`V?1e0UM-ONdT%tmI9m zAWkN+KA&RVLM60KMMGj@_9+2Yu&vEycb=kR8R~p#9 zyck2<`we3s&~gDUoM_(0V@0ND2!!B$lMOR}$N9k|pqK?jlUM(S$sIP8J!{pq?9oJx zxTb#d_Vi$_nA9O}+^++UD0|{?%yDjnA7aM-ev zdhJ|7TH`_y*AQ@DW2rCR{*hEk{&FHP@CH}vrpYbRoQd2Uf6Q!F*|W_S75ov!{fqM0 zzh(@0WNk77CFr#(b0X~>2ZY#UspM{avg5J^;`tr&EW4HJmrFbpBR?O$54P_RrQ;qAkaJSx+6ZOlK+F_liDJx%=D z+jg`89t!p2PLdO0=mAm?sw3e8U*_qyT;fseqZHSVG0f*{4Ftgt;S?DnUP zedFq6m7s6ZR8puha5J1`?jht-3La|{?3OM6YuZ3nZ~aZE=#?@jB6?F1U|h&ZRcwR= zHe?D6(UV>=2*;d{K>Ii0%Ck4rxlg{jU8GNnu5UDShMRMUNz+21 z?kgsLPl{-n2cI5{b%o)te1h@Zrcy#&+JQ3)P|n4U{f7L-f^@ANY()*ul31NkzvsDzWGIFwbQP z>%h11cn_oURZc>J-|X#1FNF8;YtZ)x<8RxM$34kEZoy$O6Zx7RyR)X;KjPRNyoVY2 zNg*5f_;{@I7JV&TW(vgXhnefZRV&X0`HlWkVP4tayh=wJQD9zzhD!?TdhQ7Ldl}R4 zb|NM2vQ+cz5NZCG9kA}o!x&FDS+Y|w$2DHJEn-zF738#akYlaZN3b7-zdoCzjXASF z#?eP4;#BIvjD3Y0kGVB~g`v8u@(Boy#FccV_neTIOWu)))yD{4HIPj~;E0A>0}NO_ zYvMC&?e_LQM2D$1A0_MV@9o4feu|7(g8-^DTCeHXnM2wTmrze=jmie~;c}3LAutPJ zwD=c>S!JmmY2+rBo)It!F{{o|G_*-T%PL}tsPnx7`@;A5t7CX5a!_B0gzc%K;4~|5 zx5xP=R~_YTL?VWXxfSxx=604B0ZmEs`JuIw54UX?5}MuH_4+VXq6WRmP~%Yb?{cu- zxc;MCs^Km#bn)q-zWClkfc@e(_Di46MPFS1?Xj;{YO7(# zWK!+Z=I?ly5GvDrv>z&sD_4{`IzUo0KB%HJ*dv^SaxYCZ)mvQw_B{?~(}>)Xcn_&8 z!9%bpjxPx><<4p@;W~~=Zw+Ij)Ewhmw&RA>YA=qkva`hA83u~D%izuj>S2dHkPXljwD81h~PQS~S%vqYqP zO?(4vY9205h^{QEC~^+>Fz2{p#ffSeq|C7d^}LYT_ekoMH?yubDyNrEV>rc3k!ko3 zniyghtek2v^~mA%n{$dW0q9-OyjvhBrE31GNJ?^^Bt1fs5IV=u{wBv z9;st=e*r&*;L$P59%x!Y=Ykw)>c~!3yGnkS+EickF7xkACGB?g);t<|IqjiM$u2=| zKFQ)(pb0XeT1=O%W=1alun=+xXRCX*F!jA9vee4bRZx12j5KD$nxICzJ_KJ==Rvmd zm1E|Xb_#U2mK-A!hN&U-xgf+1Ch^AlRpB!g-%BziU&+=Qh(MhO7AUUB%}N_ym(I}G z*~EDgB7<;^aLhI52jN0N;%tqwr8N5jL;r;nk$_K0xB3q*1aZWGX)&qp z@{TpXpj7>&JvJGK``{gR%2}BpZ2g?#5O=yyzB4F zg0SH%-!eh?JctSz)lNhRjq#hugQtsMlk7ZTN8z@gf9UaA@?S8DKlkz^8S@A5sr@1T9_Rj}S zBZy?01*!4Oyf=5Zl}KzkRQOb%Q3D&iQJfa5cg0w&B8rovI3T3*WDU z!pd8Ad)M-0jL~l6NG1UZNZgE^4GI)D#&(pgraz75Mfkon8S_E^a z#IFKelAG{r8`;-&@}cltt?~WqM>{6GuwU0y5VAHb_vyB%rsJ zu<>gaYIDqeZgg_d`MWhXQdU`A+Ki=oKL#eQ?8!&-MiHuAB=IGyF8_*HH8>9YuGMHq z|DT-AdZEsX6V;##BPVLmhIbc)nZgb9)|hU_@z>Iu=`arMH%7Lc?Y-*Qn#UHP7E6|$ zPr(VcR@U-ZAV%WAipB$*p>)C=TZObsRT~ zW3TWVCaZWxvSB$`*l8G&BP3{doKp^KSu0C59@-@K`?4Cjm8AHgwX5yMVb`&4*~Wq| zN!0J*r)^3;yck?8=eqZfl6zpoy^9@M{~AKP#9tBeX`MY9O$p+gBWaNrO&s6YIYla1 zH7{Cs9VTWyFCww-*&N!$f+>hsm&|Z3Db#P^2D!@UeZO;!_~RuN#9sqPHJOxgH~L2$ zg5p?<#*Q)4*1J@xH;cyq*@2nL$F4H(R1!od?%v$4z96!2z%{H&bc+= zjen%{U^{C&T3#NtLDR*ts6M);&G!V|yNLB2gbz^-5r&MU|FNN)I|3X zA4Q7jcM)Cb&I~GTTF8QANqJ!=H2><*Tw5W^_;KcqgM>Ig&sae4vS*Rqvmt)5*6#6& z;XruPaRWr8fH7GyVO>Me^{7F-dMf-8Y?pMhkjL?1dbcOmYxma{7Cush&(dz|4{-4~ z&X4V&YMuEV?7q&pN;P%T$Q}G7%XJ)32d8(^jPBSpE-7yCn)8xgEIZDP$1yYc>k3Y! zAIHsY;U&ECr64@1t!Wwrp!EN*qpOZ<>U+a}RZvQl4gm=nk`jW1pfF+rL%Ky_h}1@x zgn)Dj6L3<}jdXX9ZX`zc=pMD-_4n7gpS#cY+2@@1Jn!>7?|aWpO%od{CC@k%c*^MO z$~RWW635C2`%4r?VY5<#X*6rFKHzf~e|lvnh);yvjT3VCi_oHv90`w^Xbe;YD<6^N zit9_y8>n1hf#pgL$QtgsCRELyFJll*s%%^EB8k{H9BkmxscuBra#;!{kqH_IA=+;z_gLbATxYdG@%R20d&E!lDRqd3+cXhVTC zM?OCvl6^H{*0p~oL^LH>iBFYh1vVKCNfItll!1|3lwrm+f?VZ(U(7Esr%vp7CAgfm z@;^AD-4=ZvGJN=^f^Sm(#a-#rcY`O%vSK<~h_zKYH89pa-dlMray07!7)>|>Q6E0XS_2tuuN;2t^A+atG z!fl|u)+R?`iBY>O6H4-yV;}SXG@yE-y7IT-RY{wv)X)R}B%0}ZXP|`L zqCntX^r5Ik-4~I!p;}=Ru65IB8q~s1!i4dg;eDXKaGL<=aNVvPDsMQSI=z)hO$F|R zTE|xa=OlQlg~b6Ml?+LYP#;|0nkD+(j*9w*{RrZ3-7UN2}Ir?`h;6o|yDFLT1 zMuFi(a5t=PO7WhuG$(6p+=3&C>dOe*4vN1-hT(X{51 zjoSY7wOJyW?;l=~4@P1@552e%*C#n2bDW&2?85H=g+HkxSH-W}?j`*G$ml0WW1yU! zb(8QgUJ^#cyKPP447#Hhx=3rvcQUDi>!*8s@mInLN6Nmhy@)oT`Qr}Q+py^ zTu%}^DUgWT*TBP7^;{PNvIx>$9-#K19e5oY5QZDDlDgOYz&9PhM-`?E^|0|&ma=zM z$^V+E0tpw2*tqPcFH6>PUy?=|ZWNmTUH7;w|63e5UsnVn=Ja zy{Jz7axr%=@vJ=xBJ{>Gs2M`i@U}~d@4t7%^NNd6P=kKYTB^j-p*q9^m_OR@_n+*x zV!p)E`cu8kh4O$()plr-E7ePVHt$mek%gP0FIKz!Js%@2S4#VrIyFP&>K~4xdk11x zYYJwvtqb7+qA}`5_nw|N+(!$G`K{=a*d~hnJMSW#REC6juB?nEh2leMVc5TpS5l&8 zgi7k(rZ_Lxk!rXPvHuZ`gwQSgZXW5`?Keni#0zmrj@i&SpH|THi=jS4UlN)ND+gU* zwa?6}e^x(kq7p9R{}9jaI`z?RSeDTf!>9%^B|hmOB(7j0oHzWOH2=hfo!3h3nr8oLSIo@?e^zgSUrup@cf*IWKNG zs|9x=`>ER~mx??@8+h(|yeW?ghT~uVBt}I{lN2G^iMAhZkPVYEXxl!|FAzK4&mad| z&$Ik1S-!Z%LixOb+-9tV&ad%dgXn+OrTE);dbNif75Bof)W*yYe>=+YV+;zj0# zgNU29-qHR6#uAlU&PP!k#PF^7n_ir35x)-CrHr}Qm1-Bbwst!!|3)yn=%y>7KCZ~Y zEC9@DJi&^D%x$k~iK2p^63eV$R3=pC-GWdB3GgqYWNR2beKzBB)nm>tJkpfgs>*R;m!WDdrHLBs;3i_zUK6g7Vte z=C7{tJSMU~l36*L^N58t&?ae}$TdZ*q_gh1b0qgV4S*;G#V$4q1(MY`P0w|>;eLYRHg z(C|!n>DdQyRr+Mgl-`6ta9cJ0V9w2)t~cKLg$5#C6Ir8@wf|X&5=$3A#-hk~!NGj# zH2}#-7xn7+GBk&F_GCq3H`cuObU>!imcq!ne(&SYi49*LiFxpB_Za>WqK=YZLT#wk z`zRis;QSJLXcP6iKF_eI+0BXaBzg8Ip2f|z5q_~4?B$7haUNF4KBaQ%vfE||q8NPM z+=T(YK(m$J)WpZ-Jg_360Q}PRvB)Yl&W{qSN9{PGO_04{+Uil;W-_a{=<*~!wChTE z7Qz}ICBFG95$Pal;lPA35&@F~H!QCt{5d;h!WnJTWHPNqT8mu9A@O%8TROA<${ze> z$9b}uxN)HR+NZ&LR)^v@Z$+ll&@u{p=}i!EG>nrbN;@+VM&Zwk+Pn(a%!#OMiZE;m zYov1>g%3Qd9tW25;&qux`*!_wzxJ!s569UdPA&bJNwCZ_5Az=M8v71rj1t-?dLiQ@ zwIo*a!MsOxTmm;u%Ou7UVnMh0We^c$mjrt(pr12Xi+`Bwd{_~kmv?HLHnEpjE87`_ zmJv3Bi0gw=)Y?afE$}+)>B{(9<9Ew8jIc^`d~R>Cs@jwnNCQuVI+9J(SbDQ|YJ&xl zlzeo8qeX@|VS1&Jhg0%J{MQ;%>rTPahs)8;cNEP<<6DfzL8C^-7nz z>!Z%@RTrCihU#hc=G>a_&|9i6e>I)&JaOz%1s4A^eZ%5mXaS`w3xrd+WFp$LZ*wJU zd3V(Etnx>(TX@mf*C??AzP^cd}=ujCd$7-9uXZW&E##6_z0h?vo3EM_TR6{lYKxU#*zg9 z;RJe8AxsnA?@nRI>aR z2p^v9rC}+P?tjx{DLfV{utFz1uqIS;@hzdinOn^w}4PG?(wrJR~RjX&Tqxm_?G&T~?Samt30|pP&6TaBf34!445j z`3x$jFY4y}+RY^YSlh{@JzGeeR>s`pE$f_M3(1-%Te3^cPP#4Px{h8A@rd{FUic0| zQ6i?HK`$O!&->gAv7<6=?$`4L2p4s5$~eryHc4+sct@(Tt3dLCmX~Y>oO(|dFK#Ht zY`wQ4aU+d%NhiN~;?g^7F}GBR=+3l`d0<~DPk~F|N+~fAn>dJqzp^)y2X<)FK~D&* zrC%Pu8z>NBt-u4{82(Msf&PR%QIYH@s2zYP_+X?uUZp6}GGEwYyUkEq6X=?#jQo5F zN&U4?Tz{UlppH5q7U9083=Sb7A5dk zLmwLo5ef=p;@PydcV@sW)vRfg97(b*s=}S|5zY=V&Q%1-o?dwiP7lF`qB=WNiBM?i zfGwr1YU;c9(Mljn%QKwQI=FVazanyF){}DzZM*)cukbv&!QZV;DFYep7Wiz_vdU3% zF+t^u#sS*5v(PRfeWZ8eBE9{GGQ{F%*;8Px;QV`nGA1QQ%w@(I$!K${_cl?2+b&e` zTB7l}kH*4m_%)GAwJ`Gmg17ar)Ff)EduO*+snK9=bvs8}$(l`BtWx85^jsuTkUHuq z<+HT?*L$ICQ()(jh&qBbp?+GSsdXz1txyf@1lXIlu?Y@87ffaE`3o{MAd7wsN^E9Z zC#wO`sHa$UQF%)jD>3zNQ_Hi<6GOs?6`Dx!S}{wQlLPZ zL9Fym3Jx*mjjq2? z2c@K2C*YbRP~8}9;|vV$yTbU32lw(RQ{<0bx^!=b&Z9?E=dizrLd|65@hH>7j?tz`QnS44F?a7sBz zvV73V0ijH`y|CgyBnHY+#}y#Gc{f*%qCJ=X!2ex5MxMoTI&jOFE>c=ed)2&)bsmYb zaL`UNK681h(^!TzRc~IHoN_KhmG=h!mXnHVT4~ZiD(OxFBuwgF-Vt>oSVG+`qq!ZS zI^diy^z1C)f%A(*nuQhYXo*GeD^JNr!ojPflF3QkQIwxyH^^A*lC9%zpyqbeaLQ1G z%kKVX=Y zv-B?@@dbvR6h0Vw!KaIdedZHoA+j2DQJ1ZR6`}dYeTigor z7FLMW+jPaB=eX0y186Z3{UiHIIvM@Z7<6&O=q(zJPdCKt6(Yl?*;+!}!AuyB7B$qL zUJH!V2@5=cT>admRnhLvIthPQfOysG&>o=4Fb@F3O4riiN|~FUhCQtj z0sypo9X}k$_Sfix)-MeFQ+gNM-{&c>%x-I<)&cZ1_n^AI5Oj6Gvo!_P;qPIZ*OP>5tKqBI@S?cgmh(Dl-b*RbmW~V*et!r&M?r?=EE`a zOC5`Lx^x@0d# z`wUP`$Lq)L?()3I0nj0Vn6Vr1p8%Tw{fyj4lG~Kq#Euw8xJ6b`luwDX;T(LEEb8UkG;CK z8dY2SypPLnIaOtTqpX{iK#r|9tSeNPQTSXNS8KWl!+7(%k4Dm~YfEr#WA4=z3V36P^1~m$Y*;5Hfd1MbgrE70BrY;K z5o>3%`d3N22f|6z_NkKxLwZVs;}I7Z+bLHDkXn(|_}NZ|Z~%C#(jkC2UUx~lYd8A~MvlJ4- z@l{}Dmj?iq>+3>vQ3)@hY)M?;ez)xaqqGH&B5`R6Y=DY8D!^RiDD&m`xI6i6X^Y-E z0s*?wRQ`!!K0AGWqvLx#47P5Yj8U(EtjmI~vCMYP_@3XT5!3KGquCM8AFCt@_zjqM z+Lp(%PQKrm%5X{(Xle>*sj?p4 z;XFix`}%cnUZkL@6P>(NjTwR-BOKFUmHmB~xy(P{HIL=1sk)sc8 zesjxvF8Cdza*ASJKD~6jE=*AH-+wbyJOqbdpHzO6=f-j%QF=jlhYMf6c`K}2ayL_} zZz{uRDHo~o$#hV{a*k>AoPd+Om*+mJDl((A5B|h=t_$gmGZ>^_#fr_Q0O!()PhK}* zwRFvsoW_NBSbEFO?0;vMjSd&~3Uwj@vamO$nn+K69rsfBWkuYqihltTEODBMR1#Vh z+NHVK*ZTsRKX9Qa26#SiwO0sjZ-yDv_xqLq@F8PJmXa!GyaTcA|6PHxw~pYg=oC8; zTqF9d?}`OhbQ5 zv8oSwX4EeY*Mdv`QQZ3P%2cy}j*5<)f17H^j2AMQ@+|;SmB0>9h{W`nt~xAM=1bH~-If#|2)0ack>J2=eXg7NKrIeh z(#pLkCMxeIvdCkb zbxnu^V##Z_&_%HXPrWvS7U(=-9Q^uJ-$yU?>7R2;WoGiCy!?UobeRKDdUV~hJ#t&P z;yHkJ>{KGf>Z{-*qT(iZN3LpbMVbbk6=?0294oUFMi^?~6vQ^(FY*lFlo3B?C^E zj~$7c>p98je_$D_#_x6Vy*n)|T(^UTx4S|k02~&ux-yD64E>SdF%e?<=uaxq6#?2WbiY9RE}ZhIm4r;pr^y#^`KSb|8cr z>{_Zeh?7+u^giKJd2{s7e?Wca|HH+hu}c}^$x1mW{_HV%|4JUB%kaH2Ev3@SwUuR@ zpJq<4FmAnZyK{@!$oRb!(%FFtRo7z1S(TCM#*#YRBPxqF(438#7-idw_sgd&yJJG% zIoBmc#v=ch{MUXe05m&!NdA0?#ei7Mi{o!tm^)wW1(GPcrN|TS;OM*=KdV*wZV=L| z5~KCz#?NG_#3I=zCL>gbI?-=NBE|)?wGIhyir6=mvv_PGhYRX@|M?xis+Yg4xyc8-j=Xw@A5O6o?^an`d&nRum1-B&abH-`$h zL#ftiXSpYjY~}^FL`=galKY&RE26}Vgn*0BdsL<39%W5} z0&)Wj7`YPaO0W?zdH#zqutZ!zz6-q)E|~;?pU&}8=YU_eFd+s`dc5~X91BZPExKeB zzTRc0nXxelKIM^3EH4jf7nY%uSfTZFF3w)a6iPCRai0ea!9K-agj-073U`81t&h?t z39z9UMN&Op)KE9)?I&XGXCM^ptr;M)biQb3^sgfC?-gVwS9Zmq$}jgC=eIfGqT33e zTYFCxt8O|~qi!}P@McqZrx<5AeaXyCNkP)z*l?F?Y?XYL2 z>nW^YeEV@rT=vWK`yAeA$gZD(Gc%$DsWN8XS}S6zM2dM&+XE{ukmt5%pec8ypZ zWCJcT-V57ZR;0;PA>=-QUD8ryxjsngU*WN)fSh&MaH_q%I+s7t^>*zITPkP+b85VQ zli_kw#viTjhVeN+z;X)3hNuAkOdN+$w1si@MKnxkdM)sCf@6|Zt2f|KTXIsRy+@?ht~nsYSGr_NN6f2QW^6&yCXtGJ!kT9c53FJim`*lIv~m<2Hd{m zbH4YK4pHo3`VF<)XAw)tK@ zuP5Na{{r#EAlxgprP`#w9uy?G`N({u*}PYezsR`XaPOFlyrgY>g#_C23`};hfc6B& zl$z@(v6r)ILO3NMfR?G5$Dpd?r(H>;4^$fe-PpE4)pvKM1@32Zb+0tYVHgyFwJna+#i`UvyV z6JE>b@wv*nljcVuO|?~QpnvWpuHD2q6`GpGAHl5_%162GWIg# zi?Q+>euY^h{v^wUUd&q`u8)~->tlR;c;z}NOQ%$Xa9_k&j>1=FEF-`K9->H_DBv8`#Z)lfhOf&lSr(v})`7fA=OLCZ8r5 zjb&U3Ae~2{zV?UNWpD|D6|Xg&SzawNGz?Sj^Nf#iS5iYWKC+@Fq#+szje^?>J}z=~ z8Md{W9P6JD6HiM1T>)fM$X}DrODJr-wj^@!sRo=MueAmcQRXFu9-f#G&qcs#fbV5s z6EiFnF$#~xQQfrfRTewG9j|Fs7VZ0|1*oslSxbC60lN0tLs$ygnYKvyX=P8B|EOjA z>}4f7IhQA1cb3(iGe|eePPo1#$yAs#mv)moDYRGAx+?ojg&W(py^~!pZ#7d~O0Y!G zw`!;;A<2YUr+9YeGJB@y9BT1PiEp1ujDJyJm!=vj^WK+*WZKPMj3vI9QW6zhqh`+R zSjxM`l<%BmGXT+@C#L-U0WH31m3U|4)k80PZGuUN4nTj(OQXNck`I)#%ikwsP(1g2 z*R*vP#3Qv@JC5^lbfk|H3cXBOpqisKgG{0Yr=kma9(K*oAJkc|G$;c_3<21`N`N+N zTP6fa8kSe9#j#r7_l2=Rh^{{M6j~b@6*$xxMHf8{esoD4pbX55Q&7|M0MzOCT=#N* zlR=@=1B8>S7uI2GN3!DDr~Qr#@DR`fe zqMfSfX_BU^<1dQ=VjOqx>wRO0gK`eQVh$%7iVaGJNbjFt{c20P|m8(%Fsv1G@1HODay;A7*o{CkDjU2hjGk$O$+IY8h)#!>2e zQf-79zs$fOsZsBt^==kwF7Bd;hKGo1x{4L?LynH6CFoaC#v)GC*hU6RR1<45y$6F{ zYr(m!YpeWM>66AG(&Ki2gW)5(fPg!3_`f{e27B&=O$!czRY~VvnWP7Udf;Gj!d@iH zG(_QR56#3YuA}SkWI+evkB+s;e}md=lkEIEXp+%M%V~;A1534pG-K34PcbvYSaNbv zn#rCmZ0UUuvoA@nfO+}Vk2S^5|-`O$%b2t zEz5Vn+-USPWQ}dmeKe<{xyJ@3M8;WcCD7i>RCO)b;ZsgX0VmUI8W;jKlsq>Z#`CCD z#aCN$7`yIpRc(1}T`J~r2k531#0l2arFi&ZCFoqT2>akAYprPlmq8kvu@xPKJ=^a) zde18Ki!1jG106-|mEM(azIn2|7C`mTS`$9udaDQGd3~H?yGzFW_qKG5g>d=BkOljc ze;DKMN_ch2=IyPP=J#Dk4-kqsnQBZ@_3m%rMslsi@sd@$lT`DyakI2;v&6f?g~O}2 zRvO5k9sZDX2YD)5l22#v$%~np#7(-8(Pf zm?|h4lhuFx=U-RTN7=FRbVhI9jgtF)oma5HTC7c0w3>PjQl3R=lfPiC)ou%?z8G`1PWoIf2S4h+;TNyl*gET=PQGzeydv^}#=~^! zJ<}MJGWusI$!YjZmEPDpnrFB^P^+|+w$b^;SyefeL_PbedO5Q1ZnoQ;NJt}iqd*yE zuzN}OR9nl-#`@(5#ptwa}HVEy%D7zh=R^vZ%)oFYf!jY-(s3wZhGw|Dp+Y;UxzrJkJ- zBmR385x1}7vFP1ACCG)B?((w_ zXWaT< zokYvs!_&SdJ0007-ym(2(O^98dj?y4PBVwJ0POFk2K`fiu+LI!C-)iod54)b# zXSn7x=Io)*{dw-w#W;0!!4Qg5pM~Bezd>DW28~#_+FfuoJ_#XRHZ)6KKv$@;Zw@jL zGVG1!+K!jUWoImt$%T2w(yl(H){I#%v+OUlxP2Ztg``HSS4c_9_2O)x#G&0W&r6?} z6ZJk$cW>;o)aP?NhE3DIvVDo#)me4cPZTwBsv9+M8V#iUMURTz`1YoPtLO0=)ssO8 z!B?7$*A~Y%5H3EQFmc}Q$A5KF8PP$yh7~4-=K5@y7KRNX&g1E k$~tTmh+ae12vU2s2{sB$Nkn-zn(o|k!G(S;CcAy>e;&{1g#Z8m literal 0 HcmV?d00001 diff --git a/.benchspotter/sessions/01a120a2-f2e8-7ce8-a8ac-b6a8bebf1cbb/git.diff b/.benchspotter/sessions/01a120a2-f2e8-7ce8-a8ac-b6a8bebf1cbb/git.diff new file mode 100644 index 0000000..371e4b1 --- /dev/null +++ b/.benchspotter/sessions/01a120a2-f2e8-7ce8-a8ac-b6a8bebf1cbb/git.diff @@ -0,0 +1,144 @@ +diff --git a/edit.go b/edit.go +index 75c1521..3862ece 100644 +--- a/edit.go ++++ b/edit.go +@@ -311,10 +311,6 @@ func (f *File) entryLineEnd(i int) int { + // after the previous header or a BOM (the rest of its line becomes a + // newline), and ends at the next header, its indentation included. + func (f *File) unsetEntries(idx []int) []splice { +- removed := make(map[int]bool, len(idx)) +- for _, i := range idx { +- removed[i] = true +- } + // Comments at the end of a removed entry's line play no part. + trailing := make(map[int]bool) + for _, i := range idx { +@@ -324,10 +320,21 @@ func (f *File) unsetEntries(idx []int) []splice { + } + } + } ++ // comments[j] counts the comments of items[:j] that play a part. ++ comments := make([]int, len(f.items)+1) ++ for j, it := range f.items { ++ comments[j+1] = comments[j] ++ if it.kind == itemComment && !trailing[j] { ++ comments[j+1]++ ++ } ++ } + +- var splices []splice +- for _, i := range idx { +- splices = append(splices, f.unsetEntry(i, removed, trailing)) ++ // From the last entry back, so that a forward scan reaching a removed ++ // entry can stop where that entry's own scan did. ++ forward := make(map[int]int, len(idx)) ++ splices := make([]splice, len(idx)) ++ for n := len(idx) - 1; n >= 0; n-- { ++ splices[n] = f.unsetEntry(idx[n], forward, comments) + } + + // Merge the regions that overlap: a region may hold other entries. +@@ -343,7 +350,11 @@ func (f *File) unsetEntries(idx []int) []splice { + return merged + } + +-func (f *File) unsetEntry(i int, removed, trailing map[int]bool) splice { ++// unsetEntry returns the splice that removes the entry at i. forward holds ++// where the forward scan of each removed entry after i stopped; the scan of ++// i is added to it. comments counts the comments that play a part, as ++// unsetEntries computes it. ++func (f *File) unsetEntry(i int, forward map[int]int, comments []int) splice { + sec := f.items[i].sec + sameHeader := func(it item) bool { return it.kind == itemHeader && f.secOf(it) == f.secs[sec] } + +@@ -360,11 +371,17 @@ func (f *File) unsetEntry(i int, removed, trailing map[int]bool) splice { + } + fw := i + 1 + for ; fw < len(f.items); fw++ { ++ if end, ok := forward[fw]; ok { ++ // A removed entry: the scan goes on as its own did. ++ fw = end ++ break ++ } + it := f.items[fw] +- if it.kind == itemEntry && !removed[fw] || it.kind == itemHeader && !sameHeader(it) { ++ if it.kind == itemEntry || it.kind == itemHeader && !sameHeader(it) { + break + } + } ++ forward[i] = fw + if !headers || fw < len(f.items) && f.items[fw].kind == itemEntry { + return f.removeEntry(i) + } +@@ -385,10 +402,10 @@ func (f *File) unsetEntry(i int, removed, trailing map[int]bool) splice { + if fw < len(f.items) { + end = f.items[fw].start + } +- for j, it := range f.items { +- if it.kind == itemComment && it.start >= start && it.end <= end && !trailing[j] { +- return f.removeEntry(i) +- } ++ // The region is items[from:fw]: start and end are item boundaries. ++ from, _ := slices.BinarySearchFunc(f.items, start, func(it item, start int) int { return it.start - start }) ++ if comments[fw]-comments[from] > 0 { ++ return f.removeEntry(i) + } + return splice{start, end, text} + } +@@ -505,18 +522,19 @@ func (f *File) renameSection(name string, sk, to sectionKey, header string) erro + if n := f.newlineAfter(h); n >= 0 { + end = n + 1 + } +- text := header + "\n" ++ var text strings.Builder ++ text.WriteString(header + "\n") + if rest < end && f.items[rest].kind != itemNewline { +- text += "\t" ++ text.WriteByte('\t') + for _, it := range f.items[rest:end] { + if it.kind == itemHeader && f.secOf(it) == sk { +- text += header ++ text.WriteString(header) + } else { +- text += string(f.data[it.start:it.end]) ++ text.Write(f.data[it.start:it.end]) + } + } + } +- splices = append(splices, splice{f.ownStart(h), f.lineEnd(h), text}) ++ splices = append(splices, splice{f.ownStart(h), f.lineEnd(h), text.String()}) + done = end - 1 + } + return f.apply(name, splices, func(before, after []flatEntry) bool { +diff --git a/load.go b/load.go +index ac7a002..0d2b65e 100644 +--- a/load.go ++++ b/load.go +@@ -175,6 +175,9 @@ type loader struct { + + branch string + branchRead bool ++ ++ realGitDir string // with '/', "" if it cannot be resolved ++ realDirRead bool + } + + func (e Env) newLoader() (*loader, error) { +@@ -353,10 +356,14 @@ func (l *loader) gitdir(pattern, from string, fold bool) (bool, error) { + if globMatch(pattern, dir, fold) { + return true, nil + } +- if real, err := filepath.EvalSymlinks(l.repo.gitDir); err == nil { +- if real := filepath.ToSlash(real); real != dir { +- return globMatch(pattern, real, fold), nil ++ if !l.realDirRead { ++ if real, err := filepath.EvalSymlinks(l.repo.gitDir); err == nil { ++ l.realGitDir = filepath.ToSlash(real) + } ++ l.realDirRead = true ++ } ++ if l.realGitDir != "" && l.realGitDir != dir { ++ return globMatch(pattern, l.realGitDir, fold), nil + } + return false, nil + } diff --git a/.benchspotter/sessions/01a120a2-f2e8-7ce8-a8ac-b6a8bebf1cbb/meta.json b/.benchspotter/sessions/01a120a2-f2e8-7ce8-a8ac-b6a8bebf1cbb/meta.json new file mode 100644 index 0000000..e6fec94 --- /dev/null +++ b/.benchspotter/sessions/01a120a2-f2e8-7ce8-a8ac-b6a8bebf1cbb/meta.json @@ -0,0 +1,19 @@ +{ + "name": "probes-fixed", + "benchs": [ + "BenchmarkProbe" + ], + "git_commit": "74c4f677f7d380f117dd4e27dccad1b7bc042184", + "machine": { + "goos": "linux", + "goarch": "amd64", + "num_cpu": 12, + "physical_cores": 6, + "threads_per_core": 2, + "cpu": "AMD Ryzen 5 3600 6-Core Processor", + "cache_l1d": 32768, + "cache_l2": 524288, + "cache_l3": 16777216 + }, + "go_version": "go1.27.1" +} diff --git a/.benchspotter/sessions/01a120a2-f2e8-7ce8-a8ac-b6a8bebf1cbb/results.bench b/.benchspotter/sessions/01a120a2-f2e8-7ce8-a8ac-b6a8bebf1cbb/results.bench new file mode 100644 index 0000000..14bc489 --- /dev/null +++ b/.benchspotter/sessions/01a120a2-f2e8-7ce8-a8ac-b6a8bebf1cbb/results.bench @@ -0,0 +1,59 @@ +goos: linux +goarch: amd64 +pkg: github.com/git-bug/gitconfig +cpu: AMD Ryzen 5 3600 6-Core Processor + +BenchmarkProbe/UnsetAllSections/n=256-12 8848 126797 ns/op 224195 B/op 46 allocs/op +BenchmarkProbe/UnsetAllSections/n=256-12 9118 128210 ns/op 224192 B/op 46 allocs/op +BenchmarkProbe/UnsetAllSections/n=256-12 9129 128586 ns/op 224192 B/op 46 allocs/op +BenchmarkProbe/UnsetAllFlat/n=256-12 15631 76657 ns/op 165824 B/op 46 allocs/op +BenchmarkProbe/UnsetAllFlat/n=256-12 15644 77720 ns/op 165824 B/op 46 allocs/op +BenchmarkProbe/UnsetAllFlat/n=256-12 15744 75660 ns/op 165824 B/op 46 allocs/op +BenchmarkProbe/ReplaceAllFlat/n=256-12 19417 62517 ns/op 160480 B/op 57 allocs/op +BenchmarkProbe/ReplaceAllFlat/n=256-12 19240 61979 ns/op 160480 B/op 57 allocs/op +BenchmarkProbe/ReplaceAllFlat/n=256-12 19669 61454 ns/op 160480 B/op 57 allocs/op +BenchmarkProbe/RenameSectionOneLine/n=256-12 24957 46795 ns/op 63696 B/op 50 allocs/op +BenchmarkProbe/RenameSectionOneLine/n=256-12 25459 46907 ns/op 63696 B/op 50 allocs/op +BenchmarkProbe/RenameSectionOneLine/n=256-12 26306 45686 ns/op 63696 B/op 50 allocs/op +BenchmarkProbe/RemoveSectionSections/n=256-12 15030 80256 ns/op 213304 B/op 48 allocs/op +BenchmarkProbe/RemoveSectionSections/n=256-12 14792 80997 ns/op 213304 B/op 48 allocs/op +BenchmarkProbe/RemoveSectionSections/n=256-12 15039 80380 ns/op 213304 B/op 48 allocs/op +BenchmarkProbe/LoadIncludeIfGitdir/n=256-12 3999 292125 ns/op 470418 B/op 3149 allocs/op +BenchmarkProbe/LoadIncludeIfGitdir/n=256-12 4120 291655 ns/op 470418 B/op 3149 allocs/op +BenchmarkProbe/LoadIncludeIfGitdir/n=256-12 4045 299015 ns/op 470417 B/op 3149 allocs/op +BenchmarkProbe/UnsetAllSections/n=1024-12 2222 533993 ns/op 977389 B/op 57 allocs/op +BenchmarkProbe/UnsetAllSections/n=1024-12 2323 541567 ns/op 977390 B/op 57 allocs/op +BenchmarkProbe/UnsetAllSections/n=1024-12 2140 561709 ns/op 977391 B/op 57 allocs/op +BenchmarkProbe/UnsetAllFlat/n=1024-12 3334 341217 ns/op 922733 B/op 58 allocs/op +BenchmarkProbe/UnsetAllFlat/n=1024-12 3610 342554 ns/op 922732 B/op 58 allocs/op +BenchmarkProbe/UnsetAllFlat/n=1024-12 3540 346555 ns/op 922733 B/op 58 allocs/op +BenchmarkProbe/ReplaceAllFlat/n=1024-12 4158 307842 ns/op 946276 B/op 70 allocs/op +BenchmarkProbe/ReplaceAllFlat/n=1024-12 4003 318898 ns/op 946276 B/op 70 allocs/op +BenchmarkProbe/ReplaceAllFlat/n=1024-12 4124 309992 ns/op 946278 B/op 70 allocs/op +BenchmarkProbe/RenameSectionOneLine/n=1024-12 6123 179341 ns/op 306129 B/op 62 allocs/op +BenchmarkProbe/RenameSectionOneLine/n=1024-12 6516 179272 ns/op 306129 B/op 62 allocs/op +BenchmarkProbe/RenameSectionOneLine/n=1024-12 6736 179813 ns/op 306129 B/op 62 allocs/op +BenchmarkProbe/RemoveSectionSections/n=1024-12 3250 377700 ns/op 977854 B/op 60 allocs/op +BenchmarkProbe/RemoveSectionSections/n=1024-12 3145 374978 ns/op 977855 B/op 60 allocs/op +BenchmarkProbe/RemoveSectionSections/n=1024-12 3189 366536 ns/op 977853 B/op 60 allocs/op +BenchmarkProbe/LoadIncludeIfGitdir/n=1024-12 1074 1.136291e+06 ns/op 1.957399e+06 B/op 12378 allocs/op +BenchmarkProbe/LoadIncludeIfGitdir/n=1024-12 1044 1.174265e+06 ns/op 1.9574e+06 B/op 12378 allocs/op +BenchmarkProbe/LoadIncludeIfGitdir/n=1024-12 1011 1.195348e+06 ns/op 1.9574e+06 B/op 12378 allocs/op +BenchmarkProbe/UnsetAllSections/n=4096-12 416 2.928603e+06 ns/op 4.042093e+06 B/op 80 allocs/op +BenchmarkProbe/UnsetAllSections/n=4096-12 394 3.150212e+06 ns/op 4.042095e+06 B/op 80 allocs/op +BenchmarkProbe/UnsetAllSections/n=4096-12 382 3.067227e+06 ns/op 4.042092e+06 B/op 80 allocs/op +BenchmarkProbe/UnsetAllFlat/n=4096-12 618 1.86093e+06 ns/op 3.73899e+06 B/op 81 allocs/op +BenchmarkProbe/UnsetAllFlat/n=4096-12 662 1.841739e+06 ns/op 3.73899e+06 B/op 81 allocs/op +BenchmarkProbe/UnsetAllFlat/n=4096-12 650 1.870803e+06 ns/op 3.73899e+06 B/op 81 allocs/op +BenchmarkProbe/ReplaceAllFlat/n=4096-12 736 1.624229e+06 ns/op 3.777274e+06 B/op 84 allocs/op +BenchmarkProbe/ReplaceAllFlat/n=4096-12 722 1.625224e+06 ns/op 3.777273e+06 B/op 84 allocs/op +BenchmarkProbe/ReplaceAllFlat/n=4096-12 733 1.625364e+06 ns/op 3.777274e+06 B/op 84 allocs/op +BenchmarkProbe/RenameSectionOneLine/n=4096-12 1546 779117 ns/op 1.594459e+06 B/op 79 allocs/op +BenchmarkProbe/RenameSectionOneLine/n=4096-12 1620 756191 ns/op 1.594459e+06 B/op 79 allocs/op +BenchmarkProbe/RenameSectionOneLine/n=4096-12 1562 757840 ns/op 1.594459e+06 B/op 79 allocs/op +BenchmarkProbe/RemoveSectionSections/n=4096-12 549 2.265801e+06 ns/op 4.013646e+06 B/op 74 allocs/op +BenchmarkProbe/RemoveSectionSections/n=4096-12 516 2.31401e+06 ns/op 4.013645e+06 B/op 74 allocs/op +BenchmarkProbe/RemoveSectionSections/n=4096-12 534 2.275376e+06 ns/op 4.013646e+06 B/op 74 allocs/op +BenchmarkProbe/LoadIncludeIfGitdir/n=4096-12 206 5.824772e+06 ns/op 7.983289e+06 B/op 49256 allocs/op +BenchmarkProbe/LoadIncludeIfGitdir/n=4096-12 200 5.966529e+06 ns/op 7.983288e+06 B/op 49256 allocs/op +BenchmarkProbe/LoadIncludeIfGitdir/n=4096-12 200 5.946946e+06 ns/op 7.983294e+06 B/op 49256 allocs/op diff --git a/edit.go b/edit.go index 75c1521..3862ece 100644 --- a/edit.go +++ b/edit.go @@ -311,10 +311,6 @@ func (f *File) entryLineEnd(i int) int { // after the previous header or a BOM (the rest of its line becomes a // newline), and ends at the next header, its indentation included. func (f *File) unsetEntries(idx []int) []splice { - removed := make(map[int]bool, len(idx)) - for _, i := range idx { - removed[i] = true - } // Comments at the end of a removed entry's line play no part. trailing := make(map[int]bool) for _, i := range idx { @@ -324,10 +320,21 @@ func (f *File) unsetEntries(idx []int) []splice { } } } + // comments[j] counts the comments of items[:j] that play a part. + comments := make([]int, len(f.items)+1) + for j, it := range f.items { + comments[j+1] = comments[j] + if it.kind == itemComment && !trailing[j] { + comments[j+1]++ + } + } - var splices []splice - for _, i := range idx { - splices = append(splices, f.unsetEntry(i, removed, trailing)) + // From the last entry back, so that a forward scan reaching a removed + // entry can stop where that entry's own scan did. + forward := make(map[int]int, len(idx)) + splices := make([]splice, len(idx)) + for n := len(idx) - 1; n >= 0; n-- { + splices[n] = f.unsetEntry(idx[n], forward, comments) } // Merge the regions that overlap: a region may hold other entries. @@ -343,7 +350,11 @@ func (f *File) unsetEntries(idx []int) []splice { return merged } -func (f *File) unsetEntry(i int, removed, trailing map[int]bool) splice { +// unsetEntry returns the splice that removes the entry at i. forward holds +// where the forward scan of each removed entry after i stopped; the scan of +// i is added to it. comments counts the comments that play a part, as +// unsetEntries computes it. +func (f *File) unsetEntry(i int, forward map[int]int, comments []int) splice { sec := f.items[i].sec sameHeader := func(it item) bool { return it.kind == itemHeader && f.secOf(it) == f.secs[sec] } @@ -360,11 +371,17 @@ func (f *File) unsetEntry(i int, removed, trailing map[int]bool) splice { } fw := i + 1 for ; fw < len(f.items); fw++ { + if end, ok := forward[fw]; ok { + // A removed entry: the scan goes on as its own did. + fw = end + break + } it := f.items[fw] - if it.kind == itemEntry && !removed[fw] || it.kind == itemHeader && !sameHeader(it) { + if it.kind == itemEntry || it.kind == itemHeader && !sameHeader(it) { break } } + forward[i] = fw if !headers || fw < len(f.items) && f.items[fw].kind == itemEntry { return f.removeEntry(i) } @@ -385,10 +402,10 @@ func (f *File) unsetEntry(i int, removed, trailing map[int]bool) splice { if fw < len(f.items) { end = f.items[fw].start } - for j, it := range f.items { - if it.kind == itemComment && it.start >= start && it.end <= end && !trailing[j] { - return f.removeEntry(i) - } + // The region is items[from:fw]: start and end are item boundaries. + from, _ := slices.BinarySearchFunc(f.items, start, func(it item, start int) int { return it.start - start }) + if comments[fw]-comments[from] > 0 { + return f.removeEntry(i) } return splice{start, end, text} } @@ -505,18 +522,19 @@ func (f *File) renameSection(name string, sk, to sectionKey, header string) erro if n := f.newlineAfter(h); n >= 0 { end = n + 1 } - text := header + "\n" + var text strings.Builder + text.WriteString(header + "\n") if rest < end && f.items[rest].kind != itemNewline { - text += "\t" + text.WriteByte('\t') for _, it := range f.items[rest:end] { if it.kind == itemHeader && f.secOf(it) == sk { - text += header + text.WriteString(header) } else { - text += string(f.data[it.start:it.end]) + text.Write(f.data[it.start:it.end]) } } } - splices = append(splices, splice{f.ownStart(h), f.lineEnd(h), text}) + splices = append(splices, splice{f.ownStart(h), f.lineEnd(h), text.String()}) done = end - 1 } return f.apply(name, splices, func(before, after []flatEntry) bool { diff --git a/load.go b/load.go index ac7a002..0d2b65e 100644 --- a/load.go +++ b/load.go @@ -175,6 +175,9 @@ type loader struct { branch string branchRead bool + + realGitDir string // with '/', "" if it cannot be resolved + realDirRead bool } func (e Env) newLoader() (*loader, error) { @@ -353,10 +356,14 @@ func (l *loader) gitdir(pattern, from string, fold bool) (bool, error) { if globMatch(pattern, dir, fold) { return true, nil } - if real, err := filepath.EvalSymlinks(l.repo.gitDir); err == nil { - if real := filepath.ToSlash(real); real != dir { - return globMatch(pattern, real, fold), nil + if !l.realDirRead { + if real, err := filepath.EvalSymlinks(l.repo.gitDir); err == nil { + l.realGitDir = filepath.ToSlash(real) } + l.realDirRead = true + } + if l.realGitDir != "" && l.realGitDir != dir { + return globMatch(pattern, l.realGitDir, fold), nil } return false, nil } From 71b8d7b14a8e174c4b8f53d34575d55ba89a629c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Michael=20Mur=C3=A9?= Date: Fri, 9 Oct 2026 14:53:08 +0200 Subject: [PATCH 04/10] reduce mem allocations --- ...\232\227\341\232\227BenchmarkEdit.profile" | Bin 0 -> 30865 bytes ...2\227BenchmarkEnv\341\232\213Load.profile" | Bin 0 -> 14195 bytes ...2\213LoadFileManyGitdirConditions.profile" | Bin 0 -> 13268 bytes ...hmarkEnv\341\232\213LoadProtected.profile" | Bin 0 -> 12507 bytes ...enchmarkEnv\341\232\213UpdateFile.profile" | Bin 0 -> 14859 bytes ...nv\341\232\213UpdateFileUnchanged.profile" | Bin 0 -> 12735 bytes .../git.diff | 69 ++ ...\232\227\341\232\227BenchmarkEdit.profile" | Bin 0 -> 7821 bytes ...2\227BenchmarkEnv\341\232\213Load.profile" | Bin 0 -> 6156 bytes ...2\213LoadFileManyGitdirConditions.profile" | Bin 0 -> 4519 bytes ...hmarkEnv\341\232\213LoadProtected.profile" | Bin 0 -> 6503 bytes ...enchmarkEnv\341\232\213UpdateFile.profile" | Bin 0 -> 5481 bytes ...nv\341\232\213UpdateFileUnchanged.profile" | Bin 0 -> 4683 bytes .../meta.json | 24 + .../results.bench | 145 ++++ ...\232\227\341\232\227BenchmarkEdit.profile" | Bin 0 -> 32691 bytes ...\232\227\341\232\227BenchmarkFile.profile" | Bin 0 -> 37549 bytes ...232\227\341\232\227BenchmarkParse.profile" | Bin 0 -> 47793 bytes .../git.diff | 325 +++++++++ ...\232\227\341\232\227BenchmarkEdit.profile" | Bin 0 -> 8023 bytes ...\232\227\341\232\227BenchmarkFile.profile" | Bin 0 -> 9695 bytes ...232\227\341\232\227BenchmarkParse.profile" | Bin 0 -> 6581 bytes .../meta.json | 21 + .../results.bench | 465 ++++++++++++ .../git.diff | 680 ++++++++++++++++++ .../meta.json | 21 + .../results.bench | 41 ++ edit.go | 107 ++- env_test.go | 10 + file.go | 19 +- file_test.go | 37 + parse.go | 59 +- 32 files changed, 1952 insertions(+), 71 deletions(-) create mode 100644 ".benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/cpu/\341\232\227\341\232\227BenchmarkEdit.profile" create mode 100644 ".benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/cpu/\341\232\227\341\232\227BenchmarkEnv\341\232\213Load.profile" create mode 100644 ".benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/cpu/\341\232\227\341\232\227BenchmarkEnv\341\232\213LoadFileManyGitdirConditions.profile" create mode 100644 ".benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/cpu/\341\232\227\341\232\227BenchmarkEnv\341\232\213LoadProtected.profile" create mode 100644 ".benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/cpu/\341\232\227\341\232\227BenchmarkEnv\341\232\213UpdateFile.profile" create mode 100644 ".benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/cpu/\341\232\227\341\232\227BenchmarkEnv\341\232\213UpdateFileUnchanged.profile" create mode 100644 .benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/git.diff create mode 100644 ".benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/mem/\341\232\227\341\232\227BenchmarkEdit.profile" create mode 100644 ".benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/mem/\341\232\227\341\232\227BenchmarkEnv\341\232\213Load.profile" create mode 100644 ".benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/mem/\341\232\227\341\232\227BenchmarkEnv\341\232\213LoadFileManyGitdirConditions.profile" create mode 100644 ".benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/mem/\341\232\227\341\232\227BenchmarkEnv\341\232\213LoadProtected.profile" create mode 100644 ".benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/mem/\341\232\227\341\232\227BenchmarkEnv\341\232\213UpdateFile.profile" create mode 100644 ".benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/mem/\341\232\227\341\232\227BenchmarkEnv\341\232\213UpdateFileUnchanged.profile" create mode 100644 .benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/meta.json create mode 100644 .benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/results.bench create mode 100644 ".benchspotter/sessions/01a120ad-1c44-74d9-95fb-be4ffe0c882d/cpu/\341\232\227\341\232\227BenchmarkEdit.profile" create mode 100644 ".benchspotter/sessions/01a120ad-1c44-74d9-95fb-be4ffe0c882d/cpu/\341\232\227\341\232\227BenchmarkFile.profile" create mode 100644 ".benchspotter/sessions/01a120ad-1c44-74d9-95fb-be4ffe0c882d/cpu/\341\232\227\341\232\227BenchmarkParse.profile" create mode 100644 .benchspotter/sessions/01a120ad-1c44-74d9-95fb-be4ffe0c882d/git.diff create mode 100644 ".benchspotter/sessions/01a120ad-1c44-74d9-95fb-be4ffe0c882d/mem/\341\232\227\341\232\227BenchmarkEdit.profile" create mode 100644 ".benchspotter/sessions/01a120ad-1c44-74d9-95fb-be4ffe0c882d/mem/\341\232\227\341\232\227BenchmarkFile.profile" create mode 100644 ".benchspotter/sessions/01a120ad-1c44-74d9-95fb-be4ffe0c882d/mem/\341\232\227\341\232\227BenchmarkParse.profile" create mode 100644 .benchspotter/sessions/01a120ad-1c44-74d9-95fb-be4ffe0c882d/meta.json create mode 100644 .benchspotter/sessions/01a120ad-1c44-74d9-95fb-be4ffe0c882d/results.bench create mode 100644 .benchspotter/sessions/01a120b8-cecb-7ce8-8e6b-119d836f987e/git.diff create mode 100644 .benchspotter/sessions/01a120b8-cecb-7ce8-8e6b-119d836f987e/meta.json create mode 100644 .benchspotter/sessions/01a120b8-cecb-7ce8-8e6b-119d836f987e/results.bench diff --git "a/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/cpu/\341\232\227\341\232\227BenchmarkEdit.profile" "b/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/cpu/\341\232\227\341\232\227BenchmarkEdit.profile" new file mode 100644 index 0000000000000000000000000000000000000000..fca1f1dddb814ebba37c409666de0eca3856e1d4 GIT binary patch literal 30865 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 literal 0 HcmV?d00001 diff --git "a/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/cpu/\341\232\227\341\232\227BenchmarkEnv\341\232\213Load.profile" "b/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/cpu/\341\232\227\341\232\227BenchmarkEnv\341\232\213Load.profile" new file mode 100644 index 0000000000000000000000000000000000000000..17ced3e77cc489b4fae8da9905d0f213eadcad0d GIT binary patch literal 14195 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 z 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 EA2wW+H~;_u literal 0 HcmV?d00001 diff --git "a/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/cpu/\341\232\227\341\232\227BenchmarkEnv\341\232\213LoadProtected.profile" "b/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/cpu/\341\232\227\341\232\227BenchmarkEnv\341\232\213LoadProtected.profile" new file mode 100644 index 0000000000000000000000000000000000000000..fec897cf73e7d1dcc2ecffc91e3f2c0c3d2e758d GIT binary patch literal 12507 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

3lMjs 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 ka8@T*TP3kj?vd|+ttL4mKC2;HNA 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 literal 0 HcmV?d00001 diff --git "a/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/cpu/\341\232\227\341\232\227BenchmarkEnv\341\232\213UpdateFileUnchanged.profile" "b/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/cpu/\341\232\227\341\232\227BenchmarkEnv\341\232\213UpdateFileUnchanged.profile" new file mode 100644 index 0000000000000000000000000000000000000000..87ad5b7ac91512ef9d42392cbb3b9583a39366ed GIT binary patch literal 12735 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 wFSsI2TT^xmVqdBj1(^4}yeevgLsf04JFZ2$lO literal 0 HcmV?d00001 diff --git a/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/git.diff b/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/git.diff new file mode 100644 index 0000000..b6e6218 --- /dev/null +++ b/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/git.diff @@ -0,0 +1,69 @@ +diff --git a/env_test.go b/env_test.go +index c4f3ce1..780217e 100644 +--- a/env_test.go ++++ b/env_test.go +@@ -1697,6 +1697,16 @@ func BenchmarkEnv(b *testing.B) { + _, _ = env.LoadProtected() + } + }) ++ b.Run("LoadFileManyGitdirConditions", func(b *testing.B) { ++ // The git directory's real path is resolved once per load, not ++ // once per condition. ++ path := filepath.Join(tempDir(b), "config") ++ writeFile(b, path, strings.Repeat("[includeIf \"gitdir:/nope/\"]\n\tpath = x\n", 1000)) ++ b.ReportAllocs() ++ for b.Loop() { ++ _, _ = env.LoadFile(path) ++ } ++ }) + b.Run("UpdateFile", func(b *testing.B) { + path := filepath.Join(env.GitDir, "config") + i := 0 +diff --git a/file_test.go b/file_test.go +index 1415a54..cb6a960 100644 +--- a/file_test.go ++++ b/file_test.go +@@ -1063,6 +1063,43 @@ func BenchmarkParse(b *testing.B) { + } + } + ++// BenchmarkEdit measures edits that touch many lines at once, on inputs ++// built to hit their slow paths; each iteration parses the file first. ++// Throughput (MB/s) must not fall as the size grows: these edits are linear. ++func BenchmarkEdit(b *testing.B) { ++ edits := []struct { ++ name string ++ gen func(n int) []byte ++ edit func(f *gitconfig.File) error ++ }{ ++ {"UnsetAll one section", func(n int) []byte { return sized("[a]\n", "\tk = v\n", n) }, func(f *gitconfig.File) error { ++ _, err := f.UnsetAll("a.k") ++ return err ++ }}, ++ {"UnsetAll section per value", func(n int) []byte { return sized("", "[a]\n\tk = v\n", n) }, func(f *gitconfig.File) error { ++ _, err := f.UnsetAll("a.k") ++ return err ++ }}, ++ {"RenameSection one line", func(n int) []byte { return append(sized("", "[a]", n), " k = v\n"...) }, func(f *gitconfig.File) error { ++ return f.RenameSection("a", "b") ++ }}, ++ } ++ for _, e := range edits { ++ for _, n := range []int{1 << 10, 1 << 16, 1 << 20} { ++ data := e.gen(n) ++ b.Run(fmt.Sprintf("%s/%dKiB", e.name, n>>10), func(b *testing.B) { ++ b.SetBytes(int64(len(data))) ++ b.ReportAllocs() ++ for b.Loop() { ++ f, err := gitconfig.Parse("f", data) ++ require.NoError(b, err) ++ require.NoError(b, e.edit(f)) ++ } ++ }) ++ } ++ } ++} ++ + func BenchmarkFile(b *testing.B) { + for _, n := range []int{10, 1000} { + data := []byte(bigConfig(n)) diff --git "a/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/mem/\341\232\227\341\232\227BenchmarkEdit.profile" "b/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/mem/\341\232\227\341\232\227BenchmarkEdit.profile" new file mode 100644 index 0000000000000000000000000000000000000000..264af6bdae9540fa4f89530515f6d4dae418915a GIT binary patch literal 7821 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 L*xa!pih}Y#-WW{; literal 0 HcmV?d00001 diff --git "a/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/mem/\341\232\227\341\232\227BenchmarkEnv\341\232\213Load.profile" "b/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/mem/\341\232\227\341\232\227BenchmarkEnv\341\232\213Load.profile" new file mode 100644 index 0000000000000000000000000000000000000000..c064ba50f19237202efb6cbcd7b804172eeee8fd GIT binary patch literal 6156 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

S*wXc0y@7Q;;;x;)77j~ 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%0D{ zzC0QyE;Nj(D>$Jg#+UYZZ^k}-UBhuTrMYG2l!N;S8&G#M@3O?sPFa^3c{V_&bSQ^2MRHg>kPE^TdA z9b45jC9OBKH8(W3v@~@$H#fF4Hm14_qqV!KxjVJ2t;f*Xd(tiG#^%(24*+du7mG_G F006zF;`smo literal 0 HcmV?d00001 diff --git "a/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/mem/\341\232\227\341\232\227BenchmarkEnv\341\232\213LoadProtected.profile" "b/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/mem/\341\232\227\341\232\227BenchmarkEnv\341\232\213LoadProtected.profile" new file mode 100644 index 0000000000000000000000000000000000000000..7392f21cd477a161d94806f33c446c723aea3a39 GIT binary patch literal 6503 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 NF3baKG@sz%{SV{}jd}n8 literal 0 HcmV?d00001 diff --git "a/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/mem/\341\232\227\341\232\227BenchmarkEnv\341\232\213UpdateFile.profile" "b/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/mem/\341\232\227\341\232\227BenchmarkEnv\341\232\213UpdateFile.profile" new file mode 100644 index 0000000000000000000000000000000000000000..481ef63223c51fb8faca007f135b3c20f96a6fbe GIT binary patch literal 5481 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 F;C~y~E~5Yd literal 0 HcmV?d00001 diff --git a/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/meta.json b/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/meta.json new file mode 100644 index 0000000..d9b3e36 --- /dev/null +++ b/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/meta.json @@ -0,0 +1,24 @@ +{ + "name": "edit-benches", + "benchs": [ + "BenchmarkEnv/Load", + "BenchmarkEnv/LoadProtected", + "BenchmarkEnv/LoadFileManyGitdirConditions", + "BenchmarkEnv/UpdateFile", + "BenchmarkEnv/UpdateFileUnchanged", + "BenchmarkEdit" + ], + "git_commit": "9f097cd6b40f09dd20e5e00b92bd6ded3ca0f281", + "machine": { + "goos": "linux", + "goarch": "amd64", + "num_cpu": 12, + "physical_cores": 6, + "threads_per_core": 2, + "cpu": "AMD Ryzen 5 3600 6-Core Processor", + "cache_l1d": 32768, + "cache_l2": 524288, + "cache_l3": 16777216 + }, + "go_version": "go1.27.1" +} diff --git a/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/results.bench b/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/results.bench new file mode 100644 index 0000000..df8598f --- /dev/null +++ b/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/results.bench @@ -0,0 +1,145 @@ +goos: linux +goarch: amd64 +pkg: github.com/git-bug/gitconfig +cpu: AMD Ryzen 5 3600 6-Core Processor + +BenchmarkEnv/Load-12 5012 241503 ns/op 332510 B/op 932 allocs/op +BenchmarkEnv/Load-12 5055 237011 ns/op 332506 B/op 932 allocs/op +BenchmarkEnv/Load-12 4833 247790 ns/op 332507 B/op 932 allocs/op +BenchmarkEnv/Load-12 4948 262598 ns/op 332507 B/op 932 allocs/op +BenchmarkEnv/Load-12 4952 247394 ns/op 332507 B/op 932 allocs/op +BenchmarkEnv/Load-12 4938 237301 ns/op 332506 B/op 932 allocs/op +BenchmarkEnv/Load-12 4702 242795 ns/op 332507 B/op 932 allocs/op +BenchmarkEnv/Load-12 4986 237644 ns/op 332507 B/op 932 allocs/op +BenchmarkEnv/Load-12 5089 232608 ns/op 332507 B/op 932 allocs/op +BenchmarkEnv/Load-12 4891 234684 ns/op 332507 B/op 932 allocs/op +BenchmarkEnv/LoadProtected-12 18220 65050 ns/op 62041 B/op 219 allocs/op +BenchmarkEnv/LoadProtected-12 18184 65361 ns/op 62040 B/op 219 allocs/op +BenchmarkEnv/LoadProtected-12 18378 65616 ns/op 62040 B/op 219 allocs/op +BenchmarkEnv/LoadProtected-12 18579 64420 ns/op 62040 B/op 219 allocs/op +BenchmarkEnv/LoadProtected-12 18400 64840 ns/op 62040 B/op 219 allocs/op +BenchmarkEnv/LoadProtected-12 18554 64231 ns/op 62040 B/op 219 allocs/op +BenchmarkEnv/LoadProtected-12 18663 64566 ns/op 62040 B/op 219 allocs/op +BenchmarkEnv/LoadProtected-12 18583 64480 ns/op 62040 B/op 219 allocs/op +BenchmarkEnv/LoadProtected-12 18693 64180 ns/op 62040 B/op 219 allocs/op +BenchmarkEnv/LoadProtected-12 18700 64691 ns/op 62040 B/op 219 allocs/op +BenchmarkEnv/LoadFileManyGitdirConditions-12 1105 1.123003e+06 ns/op 1.881754e+06 B/op 12101 allocs/op +BenchmarkEnv/LoadFileManyGitdirConditions-12 1070 1.101759e+06 ns/op 1.881736e+06 B/op 12101 allocs/op +BenchmarkEnv/LoadFileManyGitdirConditions-12 1053 1.101034e+06 ns/op 1.881737e+06 B/op 12101 allocs/op +BenchmarkEnv/LoadFileManyGitdirConditions-12 1146 1.094549e+06 ns/op 1.881736e+06 B/op 12101 allocs/op +BenchmarkEnv/LoadFileManyGitdirConditions-12 1125 1.082766e+06 ns/op 1.881735e+06 B/op 12101 allocs/op +BenchmarkEnv/LoadFileManyGitdirConditions-12 1135 1.108419e+06 ns/op 1.881735e+06 B/op 12101 allocs/op +BenchmarkEnv/LoadFileManyGitdirConditions-12 1063 1.09794e+06 ns/op 1.881737e+06 B/op 12101 allocs/op +BenchmarkEnv/LoadFileManyGitdirConditions-12 1086 1.10521e+06 ns/op 1.881736e+06 B/op 12101 allocs/op +BenchmarkEnv/LoadFileManyGitdirConditions-12 1094 1.171132e+06 ns/op 1.881737e+06 B/op 12101 allocs/op +BenchmarkEnv/LoadFileManyGitdirConditions-12 986 1.125506e+06 ns/op 1.881736e+06 B/op 12101 allocs/op +BenchmarkEnv/UpdateFile-12 4190 271686 ns/op 460668 B/op 993 allocs/op +BenchmarkEnv/UpdateFile-12 4456 274471 ns/op 460667 B/op 993 allocs/op +BenchmarkEnv/UpdateFile-12 4729 275723 ns/op 460666 B/op 993 allocs/op +BenchmarkEnv/UpdateFile-12 4462 271889 ns/op 460666 B/op 993 allocs/op +BenchmarkEnv/UpdateFile-12 4380 270158 ns/op 460666 B/op 993 allocs/op +BenchmarkEnv/UpdateFile-12 4204 277096 ns/op 460666 B/op 993 allocs/op +BenchmarkEnv/UpdateFile-12 4135 278751 ns/op 460666 B/op 993 allocs/op +BenchmarkEnv/UpdateFile-12 4646 270537 ns/op 460666 B/op 993 allocs/op +BenchmarkEnv/UpdateFile-12 4436 272529 ns/op 460666 B/op 993 allocs/op +BenchmarkEnv/UpdateFile-12 4336 272191 ns/op 460666 B/op 993 allocs/op +BenchmarkEnv/UpdateFileUnchanged-12 10000 107961 ns/op 136545 B/op 480 allocs/op +BenchmarkEnv/UpdateFileUnchanged-12 10000 107468 ns/op 136545 B/op 480 allocs/op +BenchmarkEnv/UpdateFileUnchanged-12 10000 108063 ns/op 136544 B/op 480 allocs/op +BenchmarkEnv/UpdateFileUnchanged-12 10000 109785 ns/op 136544 B/op 480 allocs/op +BenchmarkEnv/UpdateFileUnchanged-12 10000 108510 ns/op 136544 B/op 480 allocs/op +BenchmarkEnv/UpdateFileUnchanged-12 10000 108888 ns/op 136544 B/op 480 allocs/op +BenchmarkEnv/UpdateFileUnchanged-12 9543 112027 ns/op 136544 B/op 480 allocs/op +BenchmarkEnv/UpdateFileUnchanged-12 10000 110303 ns/op 136544 B/op 480 allocs/op +BenchmarkEnv/UpdateFileUnchanged-12 10000 110549 ns/op 136544 B/op 480 allocs/op +BenchmarkEnv/UpdateFileUnchanged-12 10000 109377 ns/op 136544 B/op 480 allocs/op +BenchmarkEdit/UnsetAll_one_section/1KiB-12 24992 48458 ns/op 21.17 MB/s 116801 B/op 45 allocs/op +BenchmarkEdit/UnsetAll_one_section/1KiB-12 25394 48523 ns/op 21.14 MB/s 116800 B/op 45 allocs/op +BenchmarkEdit/UnsetAll_one_section/1KiB-12 23578 48785 ns/op 21.03 MB/s 116800 B/op 45 allocs/op +BenchmarkEdit/UnsetAll_one_section/1KiB-12 25435 47119 ns/op 21.77 MB/s 116800 B/op 45 allocs/op +BenchmarkEdit/UnsetAll_one_section/1KiB-12 25606 47586 ns/op 21.56 MB/s 116800 B/op 45 allocs/op +BenchmarkEdit/UnsetAll_one_section/1KiB-12 25616 47607 ns/op 21.55 MB/s 116800 B/op 45 allocs/op +BenchmarkEdit/UnsetAll_one_section/1KiB-12 25425 47311 ns/op 21.69 MB/s 116800 B/op 45 allocs/op +BenchmarkEdit/UnsetAll_one_section/1KiB-12 25312 47771 ns/op 21.48 MB/s 116800 B/op 45 allocs/op +BenchmarkEdit/UnsetAll_one_section/1KiB-12 25722 47106 ns/op 21.78 MB/s 116800 B/op 45 allocs/op +BenchmarkEdit/UnsetAll_one_section/1KiB-12 25611 46886 ns/op 21.88 MB/s 116800 B/op 45 allocs/op +BenchmarkEdit/UnsetAll_one_section/64KiB-12 229 5.223861e+06 ns/op 12.55 MB/s 9.285321e+06 B/op 107 allocs/op +BenchmarkEdit/UnsetAll_one_section/64KiB-12 232 5.112092e+06 ns/op 12.82 MB/s 9.28532e+06 B/op 107 allocs/op +BenchmarkEdit/UnsetAll_one_section/64KiB-12 238 5.116727e+06 ns/op 12.81 MB/s 9.285327e+06 B/op 107 allocs/op +BenchmarkEdit/UnsetAll_one_section/64KiB-12 224 5.389997e+06 ns/op 12.16 MB/s 9.285338e+06 B/op 107 allocs/op +BenchmarkEdit/UnsetAll_one_section/64KiB-12 218 5.208605e+06 ns/op 12.58 MB/s 9.285335e+06 B/op 107 allocs/op +BenchmarkEdit/UnsetAll_one_section/64KiB-12 238 4.952627e+06 ns/op 13.23 MB/s 9.285355e+06 B/op 107 allocs/op +BenchmarkEdit/UnsetAll_one_section/64KiB-12 236 4.986969e+06 ns/op 13.14 MB/s 9.285334e+06 B/op 107 allocs/op +BenchmarkEdit/UnsetAll_one_section/64KiB-12 236 5.071369e+06 ns/op 12.92 MB/s 9.285339e+06 B/op 107 allocs/op +BenchmarkEdit/UnsetAll_one_section/64KiB-12 235 5.001953e+06 ns/op 13.1 MB/s 9.285328e+06 B/op 107 allocs/op +BenchmarkEdit/UnsetAll_one_section/64KiB-12 247 4.941395e+06 ns/op 13.26 MB/s 9.285326e+06 B/op 107 allocs/op +BenchmarkEdit/UnsetAll_one_section/1024KiB-12 18 7.4505016e+07 ns/op 14.07 MB/s 1.64574835e+08 B/op 622 allocs/op +BenchmarkEdit/UnsetAll_one_section/1024KiB-12 16 7.4735616e+07 ns/op 14.03 MB/s 1.64574529e+08 B/op 622 allocs/op +BenchmarkEdit/UnsetAll_one_section/1024KiB-12 15 7.5954921e+07 ns/op 13.81 MB/s 1.64574538e+08 B/op 622 allocs/op +BenchmarkEdit/UnsetAll_one_section/1024KiB-12 16 7.7238758e+07 ns/op 13.58 MB/s 1.64574515e+08 B/op 622 allocs/op +BenchmarkEdit/UnsetAll_one_section/1024KiB-12 15 7.7903187e+07 ns/op 13.46 MB/s 1.64574538e+08 B/op 622 allocs/op +BenchmarkEdit/UnsetAll_one_section/1024KiB-12 14 8.0328085e+07 ns/op 13.05 MB/s 1.64574541e+08 B/op 622 allocs/op +BenchmarkEdit/UnsetAll_one_section/1024KiB-12 15 7.8560708e+07 ns/op 13.35 MB/s 1.64574538e+08 B/op 622 allocs/op +BenchmarkEdit/UnsetAll_one_section/1024KiB-12 15 7.6633014e+07 ns/op 13.68 MB/s 1.64574917e+08 B/op 622 allocs/op +BenchmarkEdit/UnsetAll_one_section/1024KiB-12 15 7.8626452e+07 ns/op 13.34 MB/s 1.64574538e+08 B/op 622 allocs/op +BenchmarkEdit/UnsetAll_one_section/1024KiB-12 14 7.7921155e+07 ns/op 13.46 MB/s 1.64574525e+08 B/op 622 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 23151 52263 ns/op 19.78 MB/s 92608 B/op 43 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 22872 51578 ns/op 20.05 MB/s 92608 B/op 43 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 23139 52356 ns/op 19.75 MB/s 92608 B/op 43 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 20388 55894 ns/op 18.5 MB/s 92608 B/op 43 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 23473 51433 ns/op 20.1 MB/s 92608 B/op 43 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 23798 50874 ns/op 20.32 MB/s 92608 B/op 43 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 23052 53274 ns/op 19.41 MB/s 92608 B/op 43 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 23304 51407 ns/op 20.11 MB/s 92608 B/op 43 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 23028 52248 ns/op 19.79 MB/s 92608 B/op 43 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 23043 52120 ns/op 19.84 MB/s 92608 B/op 43 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 285 4.233862e+06 ns/op 15.48 MB/s 5.893476e+06 B/op 84 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 279 4.254785e+06 ns/op 15.4 MB/s 5.893476e+06 B/op 84 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 284 4.177645e+06 ns/op 15.69 MB/s 5.893478e+06 B/op 84 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 283 4.225172e+06 ns/op 15.51 MB/s 5.893476e+06 B/op 84 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 284 4.190192e+06 ns/op 15.64 MB/s 5.893479e+06 B/op 84 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 284 4.19033e+06 ns/op 15.64 MB/s 5.893482e+06 B/op 84 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 267 4.401359e+06 ns/op 14.89 MB/s 5.893483e+06 B/op 84 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 289 4.19691e+06 ns/op 15.62 MB/s 5.89348e+06 B/op 84 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 271 4.336991e+06 ns/op 15.11 MB/s 5.893481e+06 B/op 84 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 282 4.261353e+06 ns/op 15.38 MB/s 5.893478e+06 B/op 84 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 18 6.5209017e+07 ns/op 16.08 MB/s 1.10928098e+08 B/op 359 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 16 6.4119783e+07 ns/op 16.35 MB/s 1.10928086e+08 B/op 359 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 18 6.3904657e+07 ns/op 16.41 MB/s 1.10928086e+08 B/op 359 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 16 6.3818774e+07 ns/op 16.43 MB/s 1.10928051e+08 B/op 359 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 16 6.4315706e+07 ns/op 16.3 MB/s 1.10928086e+08 B/op 359 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 16 6.4330359e+07 ns/op 16.3 MB/s 1.10928072e+08 B/op 359 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 16 6.4296497e+07 ns/op 16.31 MB/s 1.10928086e+08 B/op 359 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 16 6.4794364e+07 ns/op 16.18 MB/s 1.10928079e+08 B/op 359 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 16 6.4290026e+07 ns/op 16.31 MB/s 1.10928107e+08 B/op 359 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 18 6.5052421e+07 ns/op 16.12 MB/s 1.10928073e+08 B/op 359 allocs/op +BenchmarkEdit/RenameSection_one_line/1KiB-12 19653 60606 ns/op 17.04 MB/s 91472 B/op 53 allocs/op +BenchmarkEdit/RenameSection_one_line/1KiB-12 19838 60903 ns/op 16.96 MB/s 91472 B/op 53 allocs/op +BenchmarkEdit/RenameSection_one_line/1KiB-12 19718 61200 ns/op 16.88 MB/s 91472 B/op 53 allocs/op +BenchmarkEdit/RenameSection_one_line/1KiB-12 19851 60693 ns/op 17.02 MB/s 91472 B/op 53 allocs/op +BenchmarkEdit/RenameSection_one_line/1KiB-12 19701 60974 ns/op 16.94 MB/s 91472 B/op 53 allocs/op +BenchmarkEdit/RenameSection_one_line/1KiB-12 19495 60933 ns/op 16.95 MB/s 91472 B/op 53 allocs/op +BenchmarkEdit/RenameSection_one_line/1KiB-12 19958 60714 ns/op 17.01 MB/s 91472 B/op 53 allocs/op +BenchmarkEdit/RenameSection_one_line/1KiB-12 19819 60609 ns/op 17.04 MB/s 91472 B/op 53 allocs/op +BenchmarkEdit/RenameSection_one_line/1KiB-12 19388 61425 ns/op 16.82 MB/s 91472 B/op 53 allocs/op +BenchmarkEdit/RenameSection_one_line/1KiB-12 19386 61863 ns/op 16.7 MB/s 91472 B/op 53 allocs/op +BenchmarkEdit/RenameSection_one_line/64KiB-12 200 5.925565e+06 ns/op 11.06 MB/s 1.0203044e+07 B/op 103 allocs/op +BenchmarkEdit/RenameSection_one_line/64KiB-12 202 5.820491e+06 ns/op 11.26 MB/s 1.0203058e+07 B/op 103 allocs/op +BenchmarkEdit/RenameSection_one_line/64KiB-12 206 5.833726e+06 ns/op 11.24 MB/s 1.0203054e+07 B/op 103 allocs/op +BenchmarkEdit/RenameSection_one_line/64KiB-12 198 5.979629e+06 ns/op 10.96 MB/s 1.0203056e+07 B/op 103 allocs/op +BenchmarkEdit/RenameSection_one_line/64KiB-12 200 6.009091e+06 ns/op 10.91 MB/s 1.0203047e+07 B/op 103 allocs/op +BenchmarkEdit/RenameSection_one_line/64KiB-12 198 5.995473e+06 ns/op 10.93 MB/s 1.0203043e+07 B/op 103 allocs/op +BenchmarkEdit/RenameSection_one_line/64KiB-12 199 5.953213e+06 ns/op 11.01 MB/s 1.0203049e+07 B/op 103 allocs/op +BenchmarkEdit/RenameSection_one_line/64KiB-12 194 6.095935e+06 ns/op 10.75 MB/s 1.0203063e+07 B/op 103 allocs/op +BenchmarkEdit/RenameSection_one_line/64KiB-12 201 5.925326e+06 ns/op 11.06 MB/s 1.0203056e+07 B/op 103 allocs/op +BenchmarkEdit/RenameSection_one_line/64KiB-12 205 5.881998e+06 ns/op 11.14 MB/s 1.0203051e+07 B/op 103 allocs/op +BenchmarkEdit/RenameSection_one_line/1024KiB-12 14 8.003303e+07 ns/op 13.1 MB/s 1.75181749e+08 B/op 150 allocs/op +BenchmarkEdit/RenameSection_one_line/1024KiB-12 14 8.0758246e+07 ns/op 12.98 MB/s 1.75181781e+08 B/op 151 allocs/op +BenchmarkEdit/RenameSection_one_line/1024KiB-12 13 7.8895688e+07 ns/op 13.29 MB/s 1.75181799e+08 B/op 151 allocs/op +BenchmarkEdit/RenameSection_one_line/1024KiB-12 14 7.8704744e+07 ns/op 13.32 MB/s 1.75181749e+08 B/op 150 allocs/op +BenchmarkEdit/RenameSection_one_line/1024KiB-12 14 7.959157e+07 ns/op 13.17 MB/s 1.75181717e+08 B/op 150 allocs/op +BenchmarkEdit/RenameSection_one_line/1024KiB-12 14 7.955495e+07 ns/op 13.18 MB/s 1.75181733e+08 B/op 150 allocs/op +BenchmarkEdit/RenameSection_one_line/1024KiB-12 14 7.9595676e+07 ns/op 13.17 MB/s 1.75181733e+08 B/op 150 allocs/op +BenchmarkEdit/RenameSection_one_line/1024KiB-12 13 7.9909298e+07 ns/op 13.12 MB/s 1.7518173e+08 B/op 150 allocs/op +BenchmarkEdit/RenameSection_one_line/1024KiB-12 14 8.0221386e+07 ns/op 13.07 MB/s 1.75181749e+08 B/op 150 allocs/op +BenchmarkEdit/RenameSection_one_line/1024KiB-12 13 7.9051805e+07 ns/op 13.26 MB/s 1.7518179e+08 B/op 151 allocs/op diff --git "a/.benchspotter/sessions/01a120ad-1c44-74d9-95fb-be4ffe0c882d/cpu/\341\232\227\341\232\227BenchmarkEdit.profile" "b/.benchspotter/sessions/01a120ad-1c44-74d9-95fb-be4ffe0c882d/cpu/\341\232\227\341\232\227BenchmarkEdit.profile" new file mode 100644 index 0000000000000000000000000000000000000000..de6e28ddcf6002d0ac102820549af458b68177c3 GIT binary patch literal 32691 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 literal 0 HcmV?d00001 diff --git "a/.benchspotter/sessions/01a120ad-1c44-74d9-95fb-be4ffe0c882d/cpu/\341\232\227\341\232\227BenchmarkFile.profile" "b/.benchspotter/sessions/01a120ad-1c44-74d9-95fb-be4ffe0c882d/cpu/\341\232\227\341\232\227BenchmarkFile.profile" new file mode 100644 index 0000000000000000000000000000000000000000..f388e3a03803c5955abf2fcddc7fdc16fab29633 GIT binary patch literal 37549 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 JbOpIM0RWVwWQYI& literal 0 HcmV?d00001 diff --git "a/.benchspotter/sessions/01a120ad-1c44-74d9-95fb-be4ffe0c882d/cpu/\341\232\227\341\232\227BenchmarkParse.profile" "b/.benchspotter/sessions/01a120ad-1c44-74d9-95fb-be4ffe0c882d/cpu/\341\232\227\341\232\227BenchmarkParse.profile" new file mode 100644 index 0000000000000000000000000000000000000000..e2547d7e8a02c63cecfcff51062ab6f45926e304 GIT binary patch literal 47793 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®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 Za8`k>10), func(b *testing.B) { +++ b.SetBytes(int64(len(data))) +++ b.ReportAllocs() +++ for b.Loop() { +++ f, err := gitconfig.Parse("f", data) +++ require.NoError(b, err) +++ require.NoError(b, e.edit(f)) +++ } +++ }) +++ } +++ } +++} +++ ++ func BenchmarkFile(b *testing.B) { ++ for _, n := range []int{10, 1000} { ++ data := []byte(bigConfig(n)) +diff --git a/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/meta.json b/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/meta.json +new file mode 100644 +index 0000000..d9b3e36 +--- /dev/null ++++ b/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/meta.json +@@ -0,0 +1,24 @@ ++{ ++ "name": "edit-benches", ++ "benchs": [ ++ "BenchmarkEnv/Load", ++ "BenchmarkEnv/LoadProtected", ++ "BenchmarkEnv/LoadFileManyGitdirConditions", ++ "BenchmarkEnv/UpdateFile", ++ "BenchmarkEnv/UpdateFileUnchanged", ++ "BenchmarkEdit" ++ ], ++ "git_commit": "9f097cd6b40f09dd20e5e00b92bd6ded3ca0f281", ++ "machine": { ++ "goos": "linux", ++ "goarch": "amd64", ++ "num_cpu": 12, ++ "physical_cores": 6, ++ "threads_per_core": 2, ++ "cpu": "AMD Ryzen 5 3600 6-Core Processor", ++ "cache_l1d": 32768, ++ "cache_l2": 524288, ++ "cache_l3": 16777216 ++ }, ++ "go_version": "go1.27.1" ++} +diff --git a/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/results.bench b/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/results.bench +new file mode 100644 +index 0000000..df8598f +--- /dev/null ++++ b/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/results.bench +@@ -0,0 +1,145 @@ ++goos: linux ++goarch: amd64 ++pkg: github.com/git-bug/gitconfig ++cpu: AMD Ryzen 5 3600 6-Core Processor ++ ++BenchmarkEnv/Load-12 5012 241503 ns/op 332510 B/op 932 allocs/op ++BenchmarkEnv/Load-12 5055 237011 ns/op 332506 B/op 932 allocs/op ++BenchmarkEnv/Load-12 4833 247790 ns/op 332507 B/op 932 allocs/op ++BenchmarkEnv/Load-12 4948 262598 ns/op 332507 B/op 932 allocs/op ++BenchmarkEnv/Load-12 4952 247394 ns/op 332507 B/op 932 allocs/op ++BenchmarkEnv/Load-12 4938 237301 ns/op 332506 B/op 932 allocs/op ++BenchmarkEnv/Load-12 4702 242795 ns/op 332507 B/op 932 allocs/op ++BenchmarkEnv/Load-12 4986 237644 ns/op 332507 B/op 932 allocs/op ++BenchmarkEnv/Load-12 5089 232608 ns/op 332507 B/op 932 allocs/op ++BenchmarkEnv/Load-12 4891 234684 ns/op 332507 B/op 932 allocs/op ++BenchmarkEnv/LoadProtected-12 18220 65050 ns/op 62041 B/op 219 allocs/op ++BenchmarkEnv/LoadProtected-12 18184 65361 ns/op 62040 B/op 219 allocs/op ++BenchmarkEnv/LoadProtected-12 18378 65616 ns/op 62040 B/op 219 allocs/op ++BenchmarkEnv/LoadProtected-12 18579 64420 ns/op 62040 B/op 219 allocs/op ++BenchmarkEnv/LoadProtected-12 18400 64840 ns/op 62040 B/op 219 allocs/op ++BenchmarkEnv/LoadProtected-12 18554 64231 ns/op 62040 B/op 219 allocs/op ++BenchmarkEnv/LoadProtected-12 18663 64566 ns/op 62040 B/op 219 allocs/op ++BenchmarkEnv/LoadProtected-12 18583 64480 ns/op 62040 B/op 219 allocs/op ++BenchmarkEnv/LoadProtected-12 18693 64180 ns/op 62040 B/op 219 allocs/op ++BenchmarkEnv/LoadProtected-12 18700 64691 ns/op 62040 B/op 219 allocs/op ++BenchmarkEnv/LoadFileManyGitdirConditions-12 1105 1.123003e+06 ns/op 1.881754e+06 B/op 12101 allocs/op ++BenchmarkEnv/LoadFileManyGitdirConditions-12 1070 1.101759e+06 ns/op 1.881736e+06 B/op 12101 allocs/op ++BenchmarkEnv/LoadFileManyGitdirConditions-12 1053 1.101034e+06 ns/op 1.881737e+06 B/op 12101 allocs/op ++BenchmarkEnv/LoadFileManyGitdirConditions-12 1146 1.094549e+06 ns/op 1.881736e+06 B/op 12101 allocs/op ++BenchmarkEnv/LoadFileManyGitdirConditions-12 1125 1.082766e+06 ns/op 1.881735e+06 B/op 12101 allocs/op ++BenchmarkEnv/LoadFileManyGitdirConditions-12 1135 1.108419e+06 ns/op 1.881735e+06 B/op 12101 allocs/op ++BenchmarkEnv/LoadFileManyGitdirConditions-12 1063 1.09794e+06 ns/op 1.881737e+06 B/op 12101 allocs/op ++BenchmarkEnv/LoadFileManyGitdirConditions-12 1086 1.10521e+06 ns/op 1.881736e+06 B/op 12101 allocs/op ++BenchmarkEnv/LoadFileManyGitdirConditions-12 1094 1.171132e+06 ns/op 1.881737e+06 B/op 12101 allocs/op ++BenchmarkEnv/LoadFileManyGitdirConditions-12 986 1.125506e+06 ns/op 1.881736e+06 B/op 12101 allocs/op ++BenchmarkEnv/UpdateFile-12 4190 271686 ns/op 460668 B/op 993 allocs/op ++BenchmarkEnv/UpdateFile-12 4456 274471 ns/op 460667 B/op 993 allocs/op ++BenchmarkEnv/UpdateFile-12 4729 275723 ns/op 460666 B/op 993 allocs/op ++BenchmarkEnv/UpdateFile-12 4462 271889 ns/op 460666 B/op 993 allocs/op ++BenchmarkEnv/UpdateFile-12 4380 270158 ns/op 460666 B/op 993 allocs/op ++BenchmarkEnv/UpdateFile-12 4204 277096 ns/op 460666 B/op 993 allocs/op ++BenchmarkEnv/UpdateFile-12 4135 278751 ns/op 460666 B/op 993 allocs/op ++BenchmarkEnv/UpdateFile-12 4646 270537 ns/op 460666 B/op 993 allocs/op ++BenchmarkEnv/UpdateFile-12 4436 272529 ns/op 460666 B/op 993 allocs/op ++BenchmarkEnv/UpdateFile-12 4336 272191 ns/op 460666 B/op 993 allocs/op ++BenchmarkEnv/UpdateFileUnchanged-12 10000 107961 ns/op 136545 B/op 480 allocs/op ++BenchmarkEnv/UpdateFileUnchanged-12 10000 107468 ns/op 136545 B/op 480 allocs/op ++BenchmarkEnv/UpdateFileUnchanged-12 10000 108063 ns/op 136544 B/op 480 allocs/op ++BenchmarkEnv/UpdateFileUnchanged-12 10000 109785 ns/op 136544 B/op 480 allocs/op ++BenchmarkEnv/UpdateFileUnchanged-12 10000 108510 ns/op 136544 B/op 480 allocs/op ++BenchmarkEnv/UpdateFileUnchanged-12 10000 108888 ns/op 136544 B/op 480 allocs/op ++BenchmarkEnv/UpdateFileUnchanged-12 9543 112027 ns/op 136544 B/op 480 allocs/op ++BenchmarkEnv/UpdateFileUnchanged-12 10000 110303 ns/op 136544 B/op 480 allocs/op ++BenchmarkEnv/UpdateFileUnchanged-12 10000 110549 ns/op 136544 B/op 480 allocs/op ++BenchmarkEnv/UpdateFileUnchanged-12 10000 109377 ns/op 136544 B/op 480 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1KiB-12 24992 48458 ns/op 21.17 MB/s 116801 B/op 45 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1KiB-12 25394 48523 ns/op 21.14 MB/s 116800 B/op 45 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1KiB-12 23578 48785 ns/op 21.03 MB/s 116800 B/op 45 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1KiB-12 25435 47119 ns/op 21.77 MB/s 116800 B/op 45 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1KiB-12 25606 47586 ns/op 21.56 MB/s 116800 B/op 45 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1KiB-12 25616 47607 ns/op 21.55 MB/s 116800 B/op 45 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1KiB-12 25425 47311 ns/op 21.69 MB/s 116800 B/op 45 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1KiB-12 25312 47771 ns/op 21.48 MB/s 116800 B/op 45 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1KiB-12 25722 47106 ns/op 21.78 MB/s 116800 B/op 45 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1KiB-12 25611 46886 ns/op 21.88 MB/s 116800 B/op 45 allocs/op ++BenchmarkEdit/UnsetAll_one_section/64KiB-12 229 5.223861e+06 ns/op 12.55 MB/s 9.285321e+06 B/op 107 allocs/op ++BenchmarkEdit/UnsetAll_one_section/64KiB-12 232 5.112092e+06 ns/op 12.82 MB/s 9.28532e+06 B/op 107 allocs/op ++BenchmarkEdit/UnsetAll_one_section/64KiB-12 238 5.116727e+06 ns/op 12.81 MB/s 9.285327e+06 B/op 107 allocs/op ++BenchmarkEdit/UnsetAll_one_section/64KiB-12 224 5.389997e+06 ns/op 12.16 MB/s 9.285338e+06 B/op 107 allocs/op ++BenchmarkEdit/UnsetAll_one_section/64KiB-12 218 5.208605e+06 ns/op 12.58 MB/s 9.285335e+06 B/op 107 allocs/op ++BenchmarkEdit/UnsetAll_one_section/64KiB-12 238 4.952627e+06 ns/op 13.23 MB/s 9.285355e+06 B/op 107 allocs/op ++BenchmarkEdit/UnsetAll_one_section/64KiB-12 236 4.986969e+06 ns/op 13.14 MB/s 9.285334e+06 B/op 107 allocs/op ++BenchmarkEdit/UnsetAll_one_section/64KiB-12 236 5.071369e+06 ns/op 12.92 MB/s 9.285339e+06 B/op 107 allocs/op ++BenchmarkEdit/UnsetAll_one_section/64KiB-12 235 5.001953e+06 ns/op 13.1 MB/s 9.285328e+06 B/op 107 allocs/op ++BenchmarkEdit/UnsetAll_one_section/64KiB-12 247 4.941395e+06 ns/op 13.26 MB/s 9.285326e+06 B/op 107 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1024KiB-12 18 7.4505016e+07 ns/op 14.07 MB/s 1.64574835e+08 B/op 622 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1024KiB-12 16 7.4735616e+07 ns/op 14.03 MB/s 1.64574529e+08 B/op 622 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1024KiB-12 15 7.5954921e+07 ns/op 13.81 MB/s 1.64574538e+08 B/op 622 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1024KiB-12 16 7.7238758e+07 ns/op 13.58 MB/s 1.64574515e+08 B/op 622 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1024KiB-12 15 7.7903187e+07 ns/op 13.46 MB/s 1.64574538e+08 B/op 622 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1024KiB-12 14 8.0328085e+07 ns/op 13.05 MB/s 1.64574541e+08 B/op 622 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1024KiB-12 15 7.8560708e+07 ns/op 13.35 MB/s 1.64574538e+08 B/op 622 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1024KiB-12 15 7.6633014e+07 ns/op 13.68 MB/s 1.64574917e+08 B/op 622 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1024KiB-12 15 7.8626452e+07 ns/op 13.34 MB/s 1.64574538e+08 B/op 622 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1024KiB-12 14 7.7921155e+07 ns/op 13.46 MB/s 1.64574525e+08 B/op 622 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 23151 52263 ns/op 19.78 MB/s 92608 B/op 43 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 22872 51578 ns/op 20.05 MB/s 92608 B/op 43 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 23139 52356 ns/op 19.75 MB/s 92608 B/op 43 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 20388 55894 ns/op 18.5 MB/s 92608 B/op 43 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 23473 51433 ns/op 20.1 MB/s 92608 B/op 43 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 23798 50874 ns/op 20.32 MB/s 92608 B/op 43 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 23052 53274 ns/op 19.41 MB/s 92608 B/op 43 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 23304 51407 ns/op 20.11 MB/s 92608 B/op 43 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 23028 52248 ns/op 19.79 MB/s 92608 B/op 43 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 23043 52120 ns/op 19.84 MB/s 92608 B/op 43 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 285 4.233862e+06 ns/op 15.48 MB/s 5.893476e+06 B/op 84 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 279 4.254785e+06 ns/op 15.4 MB/s 5.893476e+06 B/op 84 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 284 4.177645e+06 ns/op 15.69 MB/s 5.893478e+06 B/op 84 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 283 4.225172e+06 ns/op 15.51 MB/s 5.893476e+06 B/op 84 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 284 4.190192e+06 ns/op 15.64 MB/s 5.893479e+06 B/op 84 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 284 4.19033e+06 ns/op 15.64 MB/s 5.893482e+06 B/op 84 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 267 4.401359e+06 ns/op 14.89 MB/s 5.893483e+06 B/op 84 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 289 4.19691e+06 ns/op 15.62 MB/s 5.89348e+06 B/op 84 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 271 4.336991e+06 ns/op 15.11 MB/s 5.893481e+06 B/op 84 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 282 4.261353e+06 ns/op 15.38 MB/s 5.893478e+06 B/op 84 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 18 6.5209017e+07 ns/op 16.08 MB/s 1.10928098e+08 B/op 359 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 16 6.4119783e+07 ns/op 16.35 MB/s 1.10928086e+08 B/op 359 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 18 6.3904657e+07 ns/op 16.41 MB/s 1.10928086e+08 B/op 359 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 16 6.3818774e+07 ns/op 16.43 MB/s 1.10928051e+08 B/op 359 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 16 6.4315706e+07 ns/op 16.3 MB/s 1.10928086e+08 B/op 359 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 16 6.4330359e+07 ns/op 16.3 MB/s 1.10928072e+08 B/op 359 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 16 6.4296497e+07 ns/op 16.31 MB/s 1.10928086e+08 B/op 359 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 16 6.4794364e+07 ns/op 16.18 MB/s 1.10928079e+08 B/op 359 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 16 6.4290026e+07 ns/op 16.31 MB/s 1.10928107e+08 B/op 359 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 18 6.5052421e+07 ns/op 16.12 MB/s 1.10928073e+08 B/op 359 allocs/op ++BenchmarkEdit/RenameSection_one_line/1KiB-12 19653 60606 ns/op 17.04 MB/s 91472 B/op 53 allocs/op ++BenchmarkEdit/RenameSection_one_line/1KiB-12 19838 60903 ns/op 16.96 MB/s 91472 B/op 53 allocs/op ++BenchmarkEdit/RenameSection_one_line/1KiB-12 19718 61200 ns/op 16.88 MB/s 91472 B/op 53 allocs/op ++BenchmarkEdit/RenameSection_one_line/1KiB-12 19851 60693 ns/op 17.02 MB/s 91472 B/op 53 allocs/op ++BenchmarkEdit/RenameSection_one_line/1KiB-12 19701 60974 ns/op 16.94 MB/s 91472 B/op 53 allocs/op ++BenchmarkEdit/RenameSection_one_line/1KiB-12 19495 60933 ns/op 16.95 MB/s 91472 B/op 53 allocs/op ++BenchmarkEdit/RenameSection_one_line/1KiB-12 19958 60714 ns/op 17.01 MB/s 91472 B/op 53 allocs/op ++BenchmarkEdit/RenameSection_one_line/1KiB-12 19819 60609 ns/op 17.04 MB/s 91472 B/op 53 allocs/op ++BenchmarkEdit/RenameSection_one_line/1KiB-12 19388 61425 ns/op 16.82 MB/s 91472 B/op 53 allocs/op ++BenchmarkEdit/RenameSection_one_line/1KiB-12 19386 61863 ns/op 16.7 MB/s 91472 B/op 53 allocs/op ++BenchmarkEdit/RenameSection_one_line/64KiB-12 200 5.925565e+06 ns/op 11.06 MB/s 1.0203044e+07 B/op 103 allocs/op ++BenchmarkEdit/RenameSection_one_line/64KiB-12 202 5.820491e+06 ns/op 11.26 MB/s 1.0203058e+07 B/op 103 allocs/op ++BenchmarkEdit/RenameSection_one_line/64KiB-12 206 5.833726e+06 ns/op 11.24 MB/s 1.0203054e+07 B/op 103 allocs/op ++BenchmarkEdit/RenameSection_one_line/64KiB-12 198 5.979629e+06 ns/op 10.96 MB/s 1.0203056e+07 B/op 103 allocs/op ++BenchmarkEdit/RenameSection_one_line/64KiB-12 200 6.009091e+06 ns/op 10.91 MB/s 1.0203047e+07 B/op 103 allocs/op ++BenchmarkEdit/RenameSection_one_line/64KiB-12 198 5.995473e+06 ns/op 10.93 MB/s 1.0203043e+07 B/op 103 allocs/op ++BenchmarkEdit/RenameSection_one_line/64KiB-12 199 5.953213e+06 ns/op 11.01 MB/s 1.0203049e+07 B/op 103 allocs/op ++BenchmarkEdit/RenameSection_one_line/64KiB-12 194 6.095935e+06 ns/op 10.75 MB/s 1.0203063e+07 B/op 103 allocs/op ++BenchmarkEdit/RenameSection_one_line/64KiB-12 201 5.925326e+06 ns/op 11.06 MB/s 1.0203056e+07 B/op 103 allocs/op ++BenchmarkEdit/RenameSection_one_line/64KiB-12 205 5.881998e+06 ns/op 11.14 MB/s 1.0203051e+07 B/op 103 allocs/op ++BenchmarkEdit/RenameSection_one_line/1024KiB-12 14 8.003303e+07 ns/op 13.1 MB/s 1.75181749e+08 B/op 150 allocs/op ++BenchmarkEdit/RenameSection_one_line/1024KiB-12 14 8.0758246e+07 ns/op 12.98 MB/s 1.75181781e+08 B/op 151 allocs/op ++BenchmarkEdit/RenameSection_one_line/1024KiB-12 13 7.8895688e+07 ns/op 13.29 MB/s 1.75181799e+08 B/op 151 allocs/op ++BenchmarkEdit/RenameSection_one_line/1024KiB-12 14 7.8704744e+07 ns/op 13.32 MB/s 1.75181749e+08 B/op 150 allocs/op ++BenchmarkEdit/RenameSection_one_line/1024KiB-12 14 7.959157e+07 ns/op 13.17 MB/s 1.75181717e+08 B/op 150 allocs/op ++BenchmarkEdit/RenameSection_one_line/1024KiB-12 14 7.955495e+07 ns/op 13.18 MB/s 1.75181733e+08 B/op 150 allocs/op ++BenchmarkEdit/RenameSection_one_line/1024KiB-12 14 7.9595676e+07 ns/op 13.17 MB/s 1.75181733e+08 B/op 150 allocs/op ++BenchmarkEdit/RenameSection_one_line/1024KiB-12 13 7.9909298e+07 ns/op 13.12 MB/s 1.7518173e+08 B/op 150 allocs/op ++BenchmarkEdit/RenameSection_one_line/1024KiB-12 14 8.0221386e+07 ns/op 13.07 MB/s 1.75181749e+08 B/op 150 allocs/op ++BenchmarkEdit/RenameSection_one_line/1024KiB-12 13 7.9051805e+07 ns/op 13.26 MB/s 1.7518179e+08 B/op 151 allocs/op +diff --git a/env_test.go b/env_test.go +index c4f3ce1..780217e 100644 +--- a/env_test.go ++++ b/env_test.go +@@ -1697,6 +1697,16 @@ func BenchmarkEnv(b *testing.B) { + _, _ = env.LoadProtected() + } + }) ++ b.Run("LoadFileManyGitdirConditions", func(b *testing.B) { ++ // The git directory's real path is resolved once per load, not ++ // once per condition. ++ path := filepath.Join(tempDir(b), "config") ++ writeFile(b, path, strings.Repeat("[includeIf \"gitdir:/nope/\"]\n\tpath = x\n", 1000)) ++ b.ReportAllocs() ++ for b.Loop() { ++ _, _ = env.LoadFile(path) ++ } ++ }) + b.Run("UpdateFile", func(b *testing.B) { + path := filepath.Join(env.GitDir, "config") + i := 0 +diff --git a/file_test.go b/file_test.go +index 1415a54..cb6a960 100644 +--- a/file_test.go ++++ b/file_test.go +@@ -1063,6 +1063,43 @@ func BenchmarkParse(b *testing.B) { + } + } + ++// BenchmarkEdit measures edits that touch many lines at once, on inputs ++// built to hit their slow paths; each iteration parses the file first. ++// Throughput (MB/s) must not fall as the size grows: these edits are linear. ++func BenchmarkEdit(b *testing.B) { ++ edits := []struct { ++ name string ++ gen func(n int) []byte ++ edit func(f *gitconfig.File) error ++ }{ ++ {"UnsetAll one section", func(n int) []byte { return sized("[a]\n", "\tk = v\n", n) }, func(f *gitconfig.File) error { ++ _, err := f.UnsetAll("a.k") ++ return err ++ }}, ++ {"UnsetAll section per value", func(n int) []byte { return sized("", "[a]\n\tk = v\n", n) }, func(f *gitconfig.File) error { ++ _, err := f.UnsetAll("a.k") ++ return err ++ }}, ++ {"RenameSection one line", func(n int) []byte { return append(sized("", "[a]", n), " k = v\n"...) }, func(f *gitconfig.File) error { ++ return f.RenameSection("a", "b") ++ }}, ++ } ++ for _, e := range edits { ++ for _, n := range []int{1 << 10, 1 << 16, 1 << 20} { ++ data := e.gen(n) ++ b.Run(fmt.Sprintf("%s/%dKiB", e.name, n>>10), func(b *testing.B) { ++ b.SetBytes(int64(len(data))) ++ b.ReportAllocs() ++ for b.Loop() { ++ f, err := gitconfig.Parse("f", data) ++ require.NoError(b, err) ++ require.NoError(b, e.edit(f)) ++ } ++ }) ++ } ++ } ++} ++ + func BenchmarkFile(b *testing.B) { + for _, n := range []int{10, 1000} { + data := []byte(bigConfig(n)) diff --git "a/.benchspotter/sessions/01a120ad-1c44-74d9-95fb-be4ffe0c882d/mem/\341\232\227\341\232\227BenchmarkEdit.profile" "b/.benchspotter/sessions/01a120ad-1c44-74d9-95fb-be4ffe0c882d/mem/\341\232\227\341\232\227BenchmarkEdit.profile" new file mode 100644 index 0000000000000000000000000000000000000000..fde2cabfaad5b425de4eb679a38e29019eed1d85 GIT binary patch literal 8023 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 F`ai=8u(|*M literal 0 HcmV?d00001 diff --git "a/.benchspotter/sessions/01a120ad-1c44-74d9-95fb-be4ffe0c882d/mem/\341\232\227\341\232\227BenchmarkFile.profile" "b/.benchspotter/sessions/01a120ad-1c44-74d9-95fb-be4ffe0c882d/mem/\341\232\227\341\232\227BenchmarkFile.profile" new file mode 100644 index 0000000000000000000000000000000000000000..692b86d17edcc67f4eef8f1b16a58f2da68764a3 GIT binary patch literal 9695 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 literal 0 HcmV?d00001 diff --git "a/.benchspotter/sessions/01a120ad-1c44-74d9-95fb-be4ffe0c882d/mem/\341\232\227\341\232\227BenchmarkParse.profile" "b/.benchspotter/sessions/01a120ad-1c44-74d9-95fb-be4ffe0c882d/mem/\341\232\227\341\232\227BenchmarkParse.profile" new file mode 100644 index 0000000000000000000000000000000000000000..d69aa202f30d9f7563c227c9a708876d5732dc3d GIT binary patch literal 6581 zcmW+)byyT%7p6f#>6S*iq;o-$k`$y{mQGg?U06a|SdeBxVyUG;>BXf}x_>k)4T1^_ zNGyEoH-F6Y%)K*b&OPtF=Y7xNOd!MicM;u{fZxBPH=7T#FtY$5b3To5^U1HWo7x&D zJP1hTi6R1$wZfA=7OjW;`a52gXE^1mKOM54lys`PeqsKUi!0$L5!3lt7n$Jk_@rQ@ z2$y)=h~qPAV7eK*G0XaHTSjTZ_uf&-JHZME?6~5E_r;10)=Qr3*|$L%v;OnifvEM@qUmTMf&5;qhBhrFD<<(DMb4>(V<(B#)pdjIsFrTr3#qpBh~ZAYT;<1j4l z3p`+*dQ>4(IB-gop~;SbcLT1L=b4sG$stAj&(~N?F?N=+hK3nGy7tnust;&9#QX1k z`c#94Im#m%N1|_-KMg*#Y2A961T-J)f2TgoDRy;lz$45S4{0sc^>3rs(IZX%5jfHj zKwaUHLvST&;O>K*A}M=aPXNj05BZ|qLL;W%Z>wMR&b`gE7f4-U6#>B9NS?G;?5Y|5 zDb^fuflVd=Al1B>7d(z~Wqz#Ees~}$ z1m{GjUw6UIG}vFIkzdi24Y_57ff0l<*M*$u!t1?wD1)IZ39tHIekpr`A47aNK4vtt z#RyRU+`lb7;FV4IM|{l9hW*J3#UXL5Oqvs(Dq_{4Y0QW5^WkYRC)(h`jpFS~rThD_ zp;4tLS;6b0uix?SyAoYZs%p19*N<5P-un&OHwc+UxVr1%H9R&@I31|774KgiT=wt= zsqltls48UgBWn!g-|ldM+f#>A3WTyh0`%!7I_u85c=vi`+;e-tpZ2vl%W|L2Je(u> z&She%$=P#lX3(Ars;pDUOaesJ4WQ&8n%0%_3Ol%|>Ge7_r0`5P@1Dkgv{>+;3oN@O zHH56{*QM9>OB?WO7(Ikc`p(Pllx;z=K3Fn5Kch1**#B6Rdu~#Ox?+*PkP1C~cjJ3a zX|vM$GGEk2*dkxKH4+i2n(>UX(9Ic>x4Q1lU{Yc0tDM!|4w|ZhZdY(+1@m6fgd&noSPM(4~Rwc}QtCOwpUD9+IS(7jmj9 zkKyka&X~8^R)@Fkz270b{=3ZJjI=>f@~8^orqhfn48%wW6-H?uhksv+B($+XOtg4x znXEFayNqjiPl+5N7KOhMp26Kv6)=iXQN$O3zWl1|8!9W(Jq;Zhn8dMv&_y?HTf<~r zvFhX9NHuM3xwi0_*xKgEf zh*0V};Uu#vM^PW>oj|TL(haqsHu@m*pouLJ)vT$T;Rzd4{pP1-xIOMsPzFJT9_tAm zqB)RsLf~;!e#hn+B)yppBz`SxD8EXkP|yT$d(T#Oy6G#t(;Y zF?gw|ry8B&cDp^02())wmV|Z8QYWHx1iPa@3f&!ngeE1F2R*YhP1TsJ)CwEV=sAt9 zQb~4V09$t_iX{>+Dk{N^L_6G3`fpZ?Q%6ein)DPXn7c5ODbmV`99wEUZ$BlY#Fd73 zZUTH)kUNVlXTZ-cSH)@&3-q(G8UhkYRSabL1Fb+#h^4w(S*-c-e@a8HnGD(B2fktZ zQ@4hb-zXqt+%qb&W9PI|`2AI#2vh9V{>|AO zl)DEK^61ciaUcaG8X-|zRcU&Zfq6>0Pk6ainL!Po|f2krC}l=f2Om;4SN0T}+nz z{xZ4Q21s*;=JCtxeEjh<{Pa7$61Psj-mP2n*%H7N0>h~E*wTmr`CabQj+-%L8~x=mjiA(+Lp z2(lJ`%3zt*-O~*7rKR)Sr=j>!7p1%TD{m6ga(~9+M{Q0Q6_XBN9CbNymQx;7ulIvD zgcH>Pd1u?^@xz}C7_Am_4M-;Oaf}qV(E1yl$q#RE*$q}s=vkWa&dZ8i`4a+YhR)$~ zM`)Cf1-tTHphNEAJ225yvZV9xpJU4|HY$oblgah<8maBpnzxBcB z3CVK5hlVi1G&@31jP$arzSD8A{YcgQtcVkhm|n;a3Hg-vo{EI}R_>;~Mxa;jONi`| z%G?@r8|bXJMQKXTes+vsH>b=!a+S;ELnvlc3Y#m?f>2av!0y3bx&D%0*38XCW}oWI zAaXfKExThYw-<+@BMm;U+BpAucfQh{udaw4TuukgLh&&_3({6wUHTn!9g{vLhCk0O z_$AmF%hzMkX&K_V9=wkWzo)(7^Qs2c9=#v=nY^gHaZqP zfTwI!a$k@UcDt6Nm6DLmC}FSzFmxf)Zf1V@i%~%BkB>Q(?ONFywORqnvo*~tBdp<_ zFM2*ywUC^I+B|N8kLmQ|m&0v=?Aw5ObPbNaVnrLjtHn~55YAEhz#DF^9jb2>hfF7h z?`FG2h~IcS2r(B@&FI)T-;LLZ5pPDzLC3P2dwgujCkWSA9+1kz(z@@NV0iT<-iJ;l z0u1^66k;29>~x2P<`eLv9z}Ah-As|O4OtB9-2;f-{9IPFGV~N8p+2X&-RQ?g`fwqv z+1;iJk47>R3_X>uXvQCeUjDtbWy`2b4}!*?uB%>ZA`Qez-&3tHuAHvKhX@R{Yk`JN z3yx8916zz%cAJ+)gj8dplkq2}aYqU;T4wnxYJJn}-e2;_ZRC>@;VWv^u}1S#4$^^K zg9H`@5B|%j#isPyP^m$_9T~cZ`fEnF>7(8^!=o(`EBAP=rliOCT+{ZO;h9hHG5VKr zqm}{g)oI^z4RRMJyrr)dUqsM2Vuq^N+poyu$+BbfTV{f4AUBB{AfYa$;%wATv+yktxDA(T{2AB76Bsy2#cGm7BI)(}RWPH$ z8||uINf$s#HSb&1>sYE~ho7rHl1#Y|CqRx|cB(Bn@v)W4LeQCQ?ZN&GG|Ye@pDS)6 z+tZkEHcAj+OZ$Km7gRrenjGZg0#tbY740DIr9;5qDV^3L=P4rl8I@%|cv>6eNbrIT zP9F+{asShYMkG^DD$5|xnIlB@f1FZ06j-#T8@%=w^GSwYG3P}ZB~Tx@>_m_vh*Ul-z&m|zHBe|$$2aVCHNiS zZ`18K?ZYIN8uDztW>$Fe6z=LfNz?u8k9r0K7>&NxBp=F(NQV1cX3K5&MXKs_kPwoQ zMxl(3?+mB}{pts!v&IVijv{Qr@uPN27hDT;6&6P7h|u?kLjo35RSQE{!_2Jb-o6D= z333w3=?En0v;0W^JnBdkGuh?p|SCXfwCI8e(m%Rrvn+cvOaJtiDbM* z2e2Q2mzV5Kjgo}2H@C7s{ILUdA0>Bmn0$ear$HnA?C*Y;J<3{~?|%Xq;^4gAxn)Ov z=2~~??A-a&+uo3;-_a?~hB}^2(H9uHs47d*HneV7-58%?TX;{k1K+*8Rm)da(A?t= z`dhJgnzH_RIiLzUB3%Uy+Ud8DYw`VWl%h&cCboum4vt1RtkN~ZMyK8yh5|83Gf+KZ zfzR}h!+-adH>1=NK}GZPx0~g~6rHS&bYlwvygP8W=C?b82sd)MbdjCS3b%D-EbCo; zQJ3ycP?}NaC)MB!^j$ryU-J|t;xcq>{aE|bX9HQRDMp$bw!W$hq!w~Wa=XUZ4}18X zde&cXsjGn*v#oYC%3hgz+NqOFp1!pih=1gBPP?r%^O!0lXzj3RfAj~-TQyKNl?8O4 z6tEH)d8#zvsk@GlRmDvEfm?^sgTLgQ){ADM4QC(5;YY!GuE*F;gEvSdskqOxTGp;} zIK$oFYEN5TpLmA4)m#4ed#6n~m@8RB?di|{VH@+(wPOFu%cLQM587xrdEl(Dsdja!xS`B<3~Nk>}iEPe^$` z|F>tzSn1{1o;2ZbSaw70KNc5z#&Bhjhx;?y3X8Pjjx-E5feV}WCM|IV|5 z&S8;}V@O&S2EM|gD?OpL%|AvX8D1~ywRq9+3j|8@#lWXeGT$AHoTJt#zHRMjC$Ds( zLMvOK!vk!%!B5oAOOsS()~g&zPWNN<6SbMJFF5 zsy~JVDRIhyQwRyx+f@wsMdb}{p@przI=9V%cj0xp^HaM7FJOf;+T;2e*=$#z?u>{q z+}?lHy=5=ktbSFS$;YJ^ajHs>tth5tosN*_@-aa6VBY7UYu+u8vJL)vedgzGVe9bi z&Nh^gb&OJ@{^N{osP39L66u`fP?nnyd^7DcB3z}oQzZ4qA#Ji_NwmZ9*coR0bOB-g zDfau0yfEN%ldHJVTB;!%ka{14D+Lt4ih$4a&dCQ~LID_2sW3>RM_Y@w+b?Soi7=P< zS_d*~Qy191OaJ)b@#^gx8;9NUaanRv(wM2_ok0C-X<~j2iLWMn1SH0aznzcXoaQTu zB5j{v)hBI$a-#5G0v;DIEHOQbRaotpf~R+MmTm@76}N7p5<2tvzn#3E;l(AwRz2m; z@Ch18rVLp7-TI>6Z2%=Qhf3lh70IM@3w!FDf*kd>0Yd@oj+au%W=&psUM{He1+H3D}aK5>XJc`ezK4LzbQJ-J`+G-A{T1R}6FH zpKPy(X1I=ceP}CxD1{)uUJzZ7xan8NQ{~JzvwrZfG3c@HH#Q+Kf9|p3{NhO2MC^Br z#I{7H&nD?yl7#nXhG%NR(6H2neBZE4htr@CwvCNh9lXqYt% zAb%dG4EqzmpSb$yPb`GkJ|H`iji>oboOd(wqmE!Xt+Sm7cT1A^fB$ zYQE0GPGfDa;73}Hl&TG0%|k#zt_0C&;*t;M<;6|=QuZ+@R)dR&4Lw(N1iV`IvIk7X zA_Kp@xf8oAk?_-%8)(yQ)xNSe<466NZlD-wJ93y=NlR?f5aUEt3%8k&z)`8j(BUGE zjh)C?^ad-5m-H4ByP5(fG!k$G9#>ubnVrXCrfQDh$npWNKfBL+a0bo=K8YP#94$Wu z-ACb!ag4bT)gpE;#BePkO`snD*Ju&sS(x^kBk<7%@Jc2bVnb4JAMvkO;eG?pw$-jP zrD$|B)7l_ex|-uj87@qlxO&rUSc_PwB3>G}P3(dOtaZ%cfD~MG*7Ox*(H^XjcQ?|> zPW~vAGxO3^22t@*>ilC>UE4YGaB$VXIO9_kO=~f^lzc)Epu>{b)guIB;wi);Nh|@k3HG3d3W=XIl^Y2SFIM;k#YgH z<1i<10jjXqxw;eZO6G@Ndsg9=Ex?(~j{|jkOAefCU5I@xGZL}97oUdHN4;bxJ?{Ly z{!)5dWl*k`nPps*+orN3zsD%s7zFm_)s$80v?O(oA)OqFd=YFHr}`|q<}UyINdXe% z6*9W-21^sr?af0dH2HhYwsO~S;YACBNKqPMlWT`#WGhb)VfEHPsYITc8vjI|plRhf zwnnXcW;P1n^3bi29(DlBGtbo5(8EysyEV>yWkU!V!D9o{5?4@i3AV1tA>$r^GpEJbHRU&N0uGuUJl}|@gDgrxCemj z7^i4V<*FH`0I8R?nbt$2ktM>Z&-_}I*VdFSVTHZwriMnhFHn)zt6Xo-{;=ZARV&a= zV`UHA?}hbn61C22ZGlVC$ImfpRnch(vlT^89X#VRm;a)~nnPck%y!k)6YSii<>V8% zwO0Sa)Y4^T9s8U+>=8W_OQ^fqR)WuzCi4Y3K&I(@^*aF;5Y!VV@YETK96~jrudZAF zo9v50>by>=#q#bmDzeU8^CiA3LW;9ae{d#^K43fWovLe)kfKkrFc7V-O%UjjmHpG> zUd?aIBqsV`zgMF_ddkx28^Gj0?vnbiGdadGWxD|?N3?d{Foc^qAY1YW+#T{W;-2gr zjRvQ4(12QTO6<4#uTDRn6$9v@`&KtkbSRR1vK6MvIr~ZvL-kBAW*p`$1QPGXUmYOJ zL$~`0d=&-lvBAa9C9s1M=hQJE)SkokzJ_>?qP4$CE5LV_ihR{8swxqz`fe)yC=}HJ zKc;1R@izV&8rgEv9YsTBXGd2hjrpkeK$3|Tx*yFX&FfNuuB`Mrq&=fLh`iJN(7pcP zHq9@#s#1K4xAbZw%w!OY&LP>P-IV=FyJ-uG{{{#D>3=5_5ziKXPmAvbd)16CM8mEK zIZrlsvi106I9!+! zmHu{y8{uz)Dy{Mxj5J;;Kl)^M^J@so)`Z4|uGrM~qQQM@#~%w>uzmF;u(haO?z_dO z)jvUktSoFOMcc6Tx>sixEN5BSq*sr2?EVn9_Z?}i=&Zc3^O`**RKDNH^AM_Eet%(B zKQ8LfHy$e8W2S|TstUyJ=v}lux;QR>;WisfrpQIqE#5pSpEi3IsCLf zf3cc9Kq(#7NpqARX>G>)LyF8N_GHc@enSTMP!0m4S+oT&?JO+pnC5hMH{Wg97gxgh zHAhNtp$S3^RY0S>JTYDps(k2oN2}N+g}T?#k2c?cBfBl1@e-cHpU{Kw#d)! zFWekn(Q2u@uwy#92@_Ea%^Q5eL$SOWF zbByd1=D3D(Amje4e87&g$Zldy`*H9oveqm*;rsKC&tvYhSzDQys8qKqn0PRkW@zXM e^Y)JLvw|=CDxJ*wAEn%};E`^pR~pLT;r$P1g#S+f literal 0 HcmV?d00001 diff --git a/.benchspotter/sessions/01a120ad-1c44-74d9-95fb-be4ffe0c882d/meta.json b/.benchspotter/sessions/01a120ad-1c44-74d9-95fb-be4ffe0c882d/meta.json new file mode 100644 index 0000000..3fa672b --- /dev/null +++ b/.benchspotter/sessions/01a120ad-1c44-74d9-95fb-be4ffe0c882d/meta.json @@ -0,0 +1,21 @@ +{ + "name": "pre-alloc", + "benchs": [ + "BenchmarkParse", + "BenchmarkEdit", + "BenchmarkFile" + ], + "git_commit": "9f097cd6b40f09dd20e5e00b92bd6ded3ca0f281", + "machine": { + "goos": "linux", + "goarch": "amd64", + "num_cpu": 12, + "physical_cores": 6, + "threads_per_core": 2, + "cpu": "AMD Ryzen 5 3600 6-Core Processor", + "cache_l1d": 32768, + "cache_l2": 524288, + "cache_l3": 16777216 + }, + "go_version": "go1.27.1" +} diff --git a/.benchspotter/sessions/01a120ad-1c44-74d9-95fb-be4ffe0c882d/results.bench b/.benchspotter/sessions/01a120ad-1c44-74d9-95fb-be4ffe0c882d/results.bench new file mode 100644 index 0000000..fbbd9e8 --- /dev/null +++ b/.benchspotter/sessions/01a120ad-1c44-74d9-95fb-be4ffe0c882d/results.bench @@ -0,0 +1,465 @@ +goos: linux +goarch: amd64 +pkg: github.com/git-bug/gitconfig +cpu: AMD Ryzen 5 3600 6-Core Processor + +BenchmarkParse/realistic/1KiB-12 83026 13708 ns/op 83.53 MB/s 23584 B/op 103 allocs/op +BenchmarkParse/realistic/1KiB-12 87609 13688 ns/op 83.65 MB/s 23584 B/op 103 allocs/op +BenchmarkParse/realistic/1KiB-12 91252 12959 ns/op 88.36 MB/s 23584 B/op 103 allocs/op +BenchmarkParse/realistic/1KiB-12 91803 13511 ns/op 84.75 MB/s 23584 B/op 103 allocs/op +BenchmarkParse/realistic/1KiB-12 84506 15551 ns/op 73.63 MB/s 23584 B/op 103 allocs/op +BenchmarkParse/realistic/1KiB-12 70053 15386 ns/op 74.42 MB/s 23584 B/op 103 allocs/op +BenchmarkParse/realistic/1KiB-12 82062 16189 ns/op 70.73 MB/s 23584 B/op 103 allocs/op +BenchmarkParse/realistic/1KiB-12 89076 14005 ns/op 81.76 MB/s 23584 B/op 103 allocs/op +BenchmarkParse/realistic/1KiB-12 84879 14041 ns/op 81.55 MB/s 23584 B/op 103 allocs/op +BenchmarkParse/realistic/1KiB-12 89379 13220 ns/op 86.61 MB/s 23584 B/op 103 allocs/op +BenchmarkParse/realistic/64KiB-12 1698 688465 ns/op 95.46 MB/s 1.403047e+06 B/op 3776 allocs/op +BenchmarkParse/realistic/64KiB-12 1708 695199 ns/op 94.54 MB/s 1.403047e+06 B/op 3776 allocs/op +BenchmarkParse/realistic/64KiB-12 1782 684237 ns/op 96.05 MB/s 1.403047e+06 B/op 3776 allocs/op +BenchmarkParse/realistic/64KiB-12 1760 678508 ns/op 96.86 MB/s 1.40305e+06 B/op 3776 allocs/op +BenchmarkParse/realistic/64KiB-12 1682 686529 ns/op 95.73 MB/s 1.403047e+06 B/op 3776 allocs/op +BenchmarkParse/realistic/64KiB-12 1737 672764 ns/op 97.69 MB/s 1.403047e+06 B/op 3776 allocs/op +BenchmarkParse/realistic/64KiB-12 1662 673737 ns/op 97.55 MB/s 1.403048e+06 B/op 3776 allocs/op +BenchmarkParse/realistic/64KiB-12 1749 700319 ns/op 93.85 MB/s 1.403049e+06 B/op 3776 allocs/op +BenchmarkParse/realistic/64KiB-12 1656 675158 ns/op 97.34 MB/s 1.403048e+06 B/op 3776 allocs/op +BenchmarkParse/realistic/64KiB-12 1762 678389 ns/op 96.88 MB/s 1.403046e+06 B/op 3776 allocs/op +BenchmarkParse/realistic/1024KiB-12 110 1.0765335e+07 ns/op 97.4 MB/s 2.3841446e+07 B/op 59583 allocs/op +BenchmarkParse/realistic/1024KiB-12 111 1.0676391e+07 ns/op 98.22 MB/s 2.384144e+07 B/op 59583 allocs/op +BenchmarkParse/realistic/1024KiB-12 109 1.0949445e+07 ns/op 95.77 MB/s 2.3841441e+07 B/op 59583 allocs/op +BenchmarkParse/realistic/1024KiB-12 111 1.0656516e+07 ns/op 98.4 MB/s 2.3841442e+07 B/op 59583 allocs/op +BenchmarkParse/realistic/1024KiB-12 112 1.0709655e+07 ns/op 97.91 MB/s 2.3841442e+07 B/op 59583 allocs/op +BenchmarkParse/realistic/1024KiB-12 93 1.0816731e+07 ns/op 96.94 MB/s 2.3841441e+07 B/op 59583 allocs/op +BenchmarkParse/realistic/1024KiB-12 109 1.0856884e+07 ns/op 96.58 MB/s 2.3841446e+07 B/op 59583 allocs/op +BenchmarkParse/realistic/1024KiB-12 111 1.0733721e+07 ns/op 97.69 MB/s 2.3841445e+07 B/op 59583 allocs/op +BenchmarkParse/realistic/1024KiB-12 110 1.0762067e+07 ns/op 97.43 MB/s 2.3841443e+07 B/op 59583 allocs/op +BenchmarkParse/realistic/1024KiB-12 93 1.1137335e+07 ns/op 94.15 MB/s 2.3841446e+07 B/op 59583 allocs/op +BenchmarkParse/one_long_value/1KiB-12 198596 5630 ns/op 182.05 MB/s 6920 B/op 20 allocs/op +BenchmarkParse/one_long_value/1KiB-12 216338 5493 ns/op 186.6 MB/s 6920 B/op 20 allocs/op +BenchmarkParse/one_long_value/1KiB-12 219686 5556 ns/op 184.49 MB/s 6920 B/op 20 allocs/op +BenchmarkParse/one_long_value/1KiB-12 210943 5863 ns/op 174.83 MB/s 6920 B/op 20 allocs/op +BenchmarkParse/one_long_value/1KiB-12 206650 5705 ns/op 179.66 MB/s 6920 B/op 20 allocs/op +BenchmarkParse/one_long_value/1KiB-12 208838 5603 ns/op 182.92 MB/s 6920 B/op 20 allocs/op +BenchmarkParse/one_long_value/1KiB-12 220760 5539 ns/op 185.04 MB/s 6920 B/op 20 allocs/op +BenchmarkParse/one_long_value/1KiB-12 218010 5514 ns/op 185.89 MB/s 6920 B/op 20 allocs/op +BenchmarkParse/one_long_value/1KiB-12 200760 5545 ns/op 184.87 MB/s 6920 B/op 20 allocs/op +BenchmarkParse/one_long_value/1KiB-12 220879 5709 ns/op 179.53 MB/s 6920 B/op 20 allocs/op +BenchmarkParse/one_long_value/64KiB-12 4755 264593 ns/op 247.69 MB/s 426122 B/op 33 allocs/op +BenchmarkParse/one_long_value/64KiB-12 4600 263787 ns/op 248.45 MB/s 426121 B/op 33 allocs/op +BenchmarkParse/one_long_value/64KiB-12 4490 278786 ns/op 235.08 MB/s 426122 B/op 33 allocs/op +BenchmarkParse/one_long_value/64KiB-12 3930 264764 ns/op 247.53 MB/s 426122 B/op 33 allocs/op +BenchmarkParse/one_long_value/64KiB-12 4484 268936 ns/op 243.69 MB/s 426121 B/op 33 allocs/op +BenchmarkParse/one_long_value/64KiB-12 4318 263481 ns/op 248.74 MB/s 426122 B/op 33 allocs/op +BenchmarkParse/one_long_value/64KiB-12 4380 270802 ns/op 242.01 MB/s 426122 B/op 33 allocs/op +BenchmarkParse/one_long_value/64KiB-12 4580 265061 ns/op 247.25 MB/s 426122 B/op 33 allocs/op +BenchmarkParse/one_long_value/64KiB-12 4633 265604 ns/op 246.75 MB/s 426122 B/op 33 allocs/op +BenchmarkParse/one_long_value/64KiB-12 4692 264415 ns/op 247.86 MB/s 426122 B/op 33 allocs/op +BenchmarkParse/one_long_value/1024KiB-12 228 5.495416e+06 ns/op 190.81 MB/s 7.348428e+06 B/op 44 allocs/op +BenchmarkParse/one_long_value/1024KiB-12 211 5.666804e+06 ns/op 185.04 MB/s 7.348426e+06 B/op 44 allocs/op +BenchmarkParse/one_long_value/1024KiB-12 214 5.537454e+06 ns/op 189.36 MB/s 7.348429e+06 B/op 44 allocs/op +BenchmarkParse/one_long_value/1024KiB-12 220 5.448728e+06 ns/op 192.44 MB/s 7.348437e+06 B/op 44 allocs/op +BenchmarkParse/one_long_value/1024KiB-12 214 5.531962e+06 ns/op 189.55 MB/s 7.348424e+06 B/op 44 allocs/op +BenchmarkParse/one_long_value/1024KiB-12 200 5.743669e+06 ns/op 182.56 MB/s 7.348426e+06 B/op 44 allocs/op +BenchmarkParse/one_long_value/1024KiB-12 204 5.811108e+06 ns/op 180.44 MB/s 7.348417e+06 B/op 44 allocs/op +BenchmarkParse/one_long_value/1024KiB-12 211 5.652375e+06 ns/op 185.51 MB/s 7.348431e+06 B/op 44 allocs/op +BenchmarkParse/one_long_value/1024KiB-12 216 5.56808e+06 ns/op 188.32 MB/s 7.348429e+06 B/op 44 allocs/op +BenchmarkParse/one_long_value/1024KiB-12 212 5.695833e+06 ns/op 184.1 MB/s 7.348421e+06 B/op 44 allocs/op +BenchmarkParse/continuations/1KiB-12 161748 7217 ns/op 142.16 MB/s 25544 B/op 18 allocs/op +BenchmarkParse/continuations/1KiB-12 163987 7278 ns/op 140.97 MB/s 25544 B/op 18 allocs/op +BenchmarkParse/continuations/1KiB-12 165102 7100 ns/op 144.51 MB/s 25544 B/op 18 allocs/op +BenchmarkParse/continuations/1KiB-12 170420 7413 ns/op 138.41 MB/s 25544 B/op 18 allocs/op +BenchmarkParse/continuations/1KiB-12 146666 7563 ns/op 135.65 MB/s 25544 B/op 18 allocs/op +BenchmarkParse/continuations/1KiB-12 166305 7182 ns/op 142.86 MB/s 25544 B/op 18 allocs/op +BenchmarkParse/continuations/1KiB-12 171048 6938 ns/op 147.88 MB/s 25544 B/op 18 allocs/op +BenchmarkParse/continuations/1KiB-12 175833 7235 ns/op 141.81 MB/s 25544 B/op 18 allocs/op +BenchmarkParse/continuations/1KiB-12 165363 7455 ns/op 137.62 MB/s 25544 B/op 18 allocs/op +BenchmarkParse/continuations/1KiB-12 158204 7316 ns/op 140.25 MB/s 25544 B/op 18 allocs/op +BenchmarkParse/continuations/64KiB-12 2934 393071 ns/op 166.73 MB/s 1.580873e+06 B/op 31 allocs/op +BenchmarkParse/continuations/64KiB-12 3181 385380 ns/op 170.06 MB/s 1.580873e+06 B/op 31 allocs/op +BenchmarkParse/continuations/64KiB-12 2953 384010 ns/op 170.67 MB/s 1.580872e+06 B/op 31 allocs/op +BenchmarkParse/continuations/64KiB-12 3214 379961 ns/op 172.49 MB/s 1.580873e+06 B/op 31 allocs/op +BenchmarkParse/continuations/64KiB-12 3495 378436 ns/op 173.18 MB/s 1.580873e+06 B/op 31 allocs/op +BenchmarkParse/continuations/64KiB-12 3607 391178 ns/op 167.54 MB/s 1.580873e+06 B/op 31 allocs/op +BenchmarkParse/continuations/64KiB-12 3302 391269 ns/op 167.5 MB/s 1.580874e+06 B/op 31 allocs/op +BenchmarkParse/continuations/64KiB-12 3166 394305 ns/op 166.21 MB/s 1.580874e+06 B/op 31 allocs/op +BenchmarkParse/continuations/64KiB-12 3051 377800 ns/op 173.47 MB/s 1.580872e+06 B/op 31 allocs/op +BenchmarkParse/continuations/64KiB-12 3372 406805 ns/op 161.1 MB/s 1.580874e+06 B/op 31 allocs/op +BenchmarkParse/continuations/1024KiB-12 210 5.354373e+06 ns/op 195.84 MB/s 2.5100114e+07 B/op 41 allocs/op +BenchmarkParse/continuations/1024KiB-12 229 5.234955e+06 ns/op 200.3 MB/s 2.5100112e+07 B/op 41 allocs/op +BenchmarkParse/continuations/1024KiB-12 219 5.353152e+06 ns/op 195.88 MB/s 2.5100115e+07 B/op 41 allocs/op +BenchmarkParse/continuations/1024KiB-12 230 5.319542e+06 ns/op 197.12 MB/s 2.5100114e+07 B/op 41 allocs/op +BenchmarkParse/continuations/1024KiB-12 225 5.286862e+06 ns/op 198.34 MB/s 2.5100111e+07 B/op 41 allocs/op +BenchmarkParse/continuations/1024KiB-12 230 5.207043e+06 ns/op 201.38 MB/s 2.5100113e+07 B/op 41 allocs/op +BenchmarkParse/continuations/1024KiB-12 225 5.290348e+06 ns/op 198.21 MB/s 2.5100113e+07 B/op 41 allocs/op +BenchmarkParse/continuations/1024KiB-12 229 5.219685e+06 ns/op 200.89 MB/s 2.5100113e+07 B/op 41 allocs/op +BenchmarkParse/continuations/1024KiB-12 230 5.167203e+06 ns/op 202.93 MB/s 2.5100112e+07 B/op 41 allocs/op +BenchmarkParse/continuations/1024KiB-12 225 5.263038e+06 ns/op 199.23 MB/s 2.5100114e+07 B/op 41 allocs/op +BenchmarkParse/quotes/1KiB-12 254515 4658 ns/op 220.27 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/quotes/1KiB-12 265190 4649 ns/op 220.7 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/quotes/1KiB-12 259603 4630 ns/op 221.61 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/quotes/1KiB-12 260840 4594 ns/op 223.32 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/quotes/1KiB-12 263204 4635 ns/op 221.36 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/quotes/1KiB-12 252586 4773 ns/op 214.96 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/quotes/1KiB-12 251140 4670 ns/op 219.69 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/quotes/1KiB-12 259864 4617 ns/op 222.23 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/quotes/1KiB-12 261169 4624 ns/op 221.87 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/quotes/1KiB-12 252844 4609 ns/op 222.62 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/quotes/64KiB-12 4928 250430 ns/op 261.7 MB/s 262281 B/op 31 allocs/op +BenchmarkParse/quotes/64KiB-12 5007 236883 ns/op 276.67 MB/s 262281 B/op 31 allocs/op +BenchmarkParse/quotes/64KiB-12 5145 227674 ns/op 287.86 MB/s 262281 B/op 31 allocs/op +BenchmarkParse/quotes/64KiB-12 4978 232353 ns/op 282.06 MB/s 262281 B/op 31 allocs/op +BenchmarkParse/quotes/64KiB-12 4965 232323 ns/op 282.1 MB/s 262281 B/op 31 allocs/op +BenchmarkParse/quotes/64KiB-12 4812 242845 ns/op 269.88 MB/s 262281 B/op 31 allocs/op +BenchmarkParse/quotes/64KiB-12 5360 238681 ns/op 274.58 MB/s 262281 B/op 31 allocs/op +BenchmarkParse/quotes/64KiB-12 5016 229561 ns/op 285.49 MB/s 262281 B/op 31 allocs/op +BenchmarkParse/quotes/64KiB-12 5110 235491 ns/op 278.3 MB/s 262281 B/op 31 allocs/op +BenchmarkParse/quotes/64KiB-12 4443 240182 ns/op 272.87 MB/s 262281 B/op 31 allocs/op +BenchmarkParse/quotes/1024KiB-12 313 3.704413e+06 ns/op 283.06 MB/s 4.12073e+06 B/op 41 allocs/op +BenchmarkParse/quotes/1024KiB-12 338 3.637324e+06 ns/op 288.28 MB/s 4.120728e+06 B/op 41 allocs/op +BenchmarkParse/quotes/1024KiB-12 336 3.811741e+06 ns/op 275.09 MB/s 4.120731e+06 B/op 41 allocs/op +BenchmarkParse/quotes/1024KiB-12 310 3.950411e+06 ns/op 265.44 MB/s 4.120726e+06 B/op 41 allocs/op +BenchmarkParse/quotes/1024KiB-12 307 3.991823e+06 ns/op 262.68 MB/s 4.120728e+06 B/op 41 allocs/op +BenchmarkParse/quotes/1024KiB-12 322 3.816813e+06 ns/op 274.73 MB/s 4.120731e+06 B/op 41 allocs/op +BenchmarkParse/quotes/1024KiB-12 316 3.700635e+06 ns/op 283.35 MB/s 4.120729e+06 B/op 41 allocs/op +BenchmarkParse/quotes/1024KiB-12 327 3.653394e+06 ns/op 287.01 MB/s 4.12073e+06 B/op 41 allocs/op +BenchmarkParse/quotes/1024KiB-12 319 3.67143e+06 ns/op 285.6 MB/s 4.12073e+06 B/op 41 allocs/op +BenchmarkParse/quotes/1024KiB-12 309 3.924588e+06 ns/op 267.18 MB/s 4.12073e+06 B/op 41 allocs/op +BenchmarkParse/escapes/1KiB-12 328123 3504 ns/op 293.97 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/escapes/1KiB-12 328660 3521 ns/op 292.51 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/escapes/1KiB-12 343232 3619 ns/op 284.59 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/escapes/1KiB-12 333943 3608 ns/op 285.46 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/escapes/1KiB-12 345814 3675 ns/op 280.28 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/escapes/1KiB-12 304610 3624 ns/op 284.18 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/escapes/1KiB-12 318465 3668 ns/op 280.77 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/escapes/1KiB-12 343503 3787 ns/op 271.98 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/escapes/1KiB-12 306086 3593 ns/op 286.63 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/escapes/1KiB-12 332097 3634 ns/op 283.44 MB/s 4104 B/op 18 allocs/op +BenchmarkParse/escapes/64KiB-12 4210 317885 ns/op 206.18 MB/s 262283 B/op 31 allocs/op +BenchmarkParse/escapes/64KiB-12 5474 208630 ns/op 314.15 MB/s 262282 B/op 31 allocs/op +BenchmarkParse/escapes/64KiB-12 6140 189138 ns/op 346.53 MB/s 262281 B/op 31 allocs/op +BenchmarkParse/escapes/64KiB-12 6489 182784 ns/op 358.58 MB/s 262281 B/op 31 allocs/op +BenchmarkParse/escapes/64KiB-12 7150 176911 ns/op 370.48 MB/s 262281 B/op 31 allocs/op +BenchmarkParse/escapes/64KiB-12 7638 224640 ns/op 291.76 MB/s 262282 B/op 31 allocs/op +BenchmarkParse/escapes/64KiB-12 6823 174884 ns/op 374.77 MB/s 262281 B/op 31 allocs/op +BenchmarkParse/escapes/64KiB-12 6592 171656 ns/op 381.82 MB/s 262281 B/op 31 allocs/op +BenchmarkParse/escapes/64KiB-12 7178 170657 ns/op 384.06 MB/s 262281 B/op 31 allocs/op +BenchmarkParse/escapes/64KiB-12 6930 172764 ns/op 379.37 MB/s 262281 B/op 31 allocs/op +BenchmarkParse/escapes/1024KiB-12 460 2.956955e+06 ns/op 354.62 MB/s 4.120734e+06 B/op 41 allocs/op +BenchmarkParse/escapes/1024KiB-12 427 2.820456e+06 ns/op 371.78 MB/s 4.120732e+06 B/op 41 allocs/op +BenchmarkParse/escapes/1024KiB-12 460 2.609394e+06 ns/op 401.85 MB/s 4.120728e+06 B/op 41 allocs/op +BenchmarkParse/escapes/1024KiB-12 441 2.845873e+06 ns/op 368.46 MB/s 4.120728e+06 B/op 41 allocs/op +BenchmarkParse/escapes/1024KiB-12 463 2.854916e+06 ns/op 367.29 MB/s 4.12073e+06 B/op 41 allocs/op +BenchmarkParse/escapes/1024KiB-12 454 2.85234e+06 ns/op 367.62 MB/s 4.120729e+06 B/op 41 allocs/op +BenchmarkParse/escapes/1024KiB-12 463 2.594006e+06 ns/op 404.23 MB/s 4.120727e+06 B/op 41 allocs/op +BenchmarkParse/escapes/1024KiB-12 452 3.07302e+06 ns/op 341.22 MB/s 4.120733e+06 B/op 41 allocs/op +BenchmarkParse/escapes/1024KiB-12 427 2.909474e+06 ns/op 360.4 MB/s 4.120729e+06 B/op 41 allocs/op +BenchmarkParse/escapes/1024KiB-12 397 2.931484e+06 ns/op 357.7 MB/s 4.12073e+06 B/op 41 allocs/op +BenchmarkParse/same_key/1KiB-12 62742 18607 ns/op 55.14 MB/s 48408 B/op 19 allocs/op +BenchmarkParse/same_key/1KiB-12 65608 18856 ns/op 54.41 MB/s 48408 B/op 19 allocs/op +BenchmarkParse/same_key/1KiB-12 60404 19066 ns/op 53.81 MB/s 48408 B/op 19 allocs/op +BenchmarkParse/same_key/1KiB-12 65659 18846 ns/op 54.44 MB/s 48408 B/op 19 allocs/op +BenchmarkParse/same_key/1KiB-12 52842 20331 ns/op 50.47 MB/s 48408 B/op 19 allocs/op +BenchmarkParse/same_key/1KiB-12 63850 20232 ns/op 50.71 MB/s 48408 B/op 19 allocs/op +BenchmarkParse/same_key/1KiB-12 62703 20269 ns/op 50.62 MB/s 48408 B/op 19 allocs/op +BenchmarkParse/same_key/1KiB-12 58990 19755 ns/op 51.94 MB/s 48408 B/op 19 allocs/op +BenchmarkParse/same_key/1KiB-12 61843 18833 ns/op 54.48 MB/s 48408 B/op 19 allocs/op +BenchmarkParse/same_key/1KiB-12 63619 18915 ns/op 54.24 MB/s 48408 B/op 19 allocs/op +BenchmarkParse/same_key/64KiB-12 592 1.862989e+06 ns/op 35.18 MB/s 4.445868e+06 B/op 31 allocs/op +BenchmarkParse/same_key/64KiB-12 678 1.863095e+06 ns/op 35.18 MB/s 4.445867e+06 B/op 31 allocs/op +BenchmarkParse/same_key/64KiB-12 669 1.787368e+06 ns/op 36.67 MB/s 4.445865e+06 B/op 31 allocs/op +BenchmarkParse/same_key/64KiB-12 682 1.75479e+06 ns/op 37.35 MB/s 4.445868e+06 B/op 31 allocs/op +BenchmarkParse/same_key/64KiB-12 676 1.814948e+06 ns/op 36.11 MB/s 4.445866e+06 B/op 31 allocs/op +BenchmarkParse/same_key/64KiB-12 688 1.813523e+06 ns/op 36.14 MB/s 4.445865e+06 B/op 31 allocs/op +BenchmarkParse/same_key/64KiB-12 691 1.736947e+06 ns/op 37.73 MB/s 4.445866e+06 B/op 31 allocs/op +BenchmarkParse/same_key/64KiB-12 678 1.82226e+06 ns/op 35.97 MB/s 4.445865e+06 B/op 31 allocs/op +BenchmarkParse/same_key/64KiB-12 652 1.824434e+06 ns/op 35.92 MB/s 4.445869e+06 B/op 31 allocs/op +BenchmarkParse/same_key/64KiB-12 686 1.776034e+06 ns/op 36.9 MB/s 4.445868e+06 B/op 31 allocs/op +BenchmarkParse/same_key/1024KiB-12 46 2.5679564e+07 ns/op 40.83 MB/s 7.496272e+07 B/op 43 allocs/op +BenchmarkParse/same_key/1024KiB-12 44 2.602143e+07 ns/op 40.3 MB/s 7.4962592e+07 B/op 43 allocs/op +BenchmarkParse/same_key/1024KiB-12 39 2.6262302e+07 ns/op 39.93 MB/s 7.4962594e+07 B/op 43 allocs/op +BenchmarkParse/same_key/1024KiB-12 44 2.6871269e+07 ns/op 39.02 MB/s 7.4962602e+07 B/op 43 allocs/op +BenchmarkParse/same_key/1024KiB-12 44 2.6421975e+07 ns/op 39.69 MB/s 7.4962592e+07 B/op 43 allocs/op +BenchmarkParse/same_key/1024KiB-12 42 2.8436658e+07 ns/op 36.87 MB/s 7.4962594e+07 B/op 43 allocs/op +BenchmarkParse/same_key/1024KiB-12 44 2.7014693e+07 ns/op 38.82 MB/s 7.4962597e+07 B/op 43 allocs/op +BenchmarkParse/same_key/1024KiB-12 43 2.7528903e+07 ns/op 38.09 MB/s 7.4962594e+07 B/op 43 allocs/op +BenchmarkParse/same_key/1024KiB-12 43 2.7778631e+07 ns/op 37.75 MB/s 7.4962592e+07 B/op 43 allocs/op +BenchmarkParse/same_key/1024KiB-12 40 2.9247706e+07 ns/op 35.85 MB/s 7.4962592e+07 B/op 43 allocs/op +BenchmarkParse/headers/1KiB-12 106965 11083 ns/op 92.39 MB/s 12688 B/op 8 allocs/op +BenchmarkParse/headers/1KiB-12 108086 11115 ns/op 92.13 MB/s 12688 B/op 8 allocs/op +BenchmarkParse/headers/1KiB-12 106798 11076 ns/op 92.45 MB/s 12688 B/op 8 allocs/op +BenchmarkParse/headers/1KiB-12 109377 11075 ns/op 92.46 MB/s 12688 B/op 8 allocs/op +BenchmarkParse/headers/1KiB-12 107755 11417 ns/op 89.69 MB/s 12688 B/op 8 allocs/op +BenchmarkParse/headers/1KiB-12 108224 11284 ns/op 90.75 MB/s 12688 B/op 8 allocs/op +BenchmarkParse/headers/1KiB-12 107266 11174 ns/op 91.64 MB/s 12688 B/op 8 allocs/op +BenchmarkParse/headers/1KiB-12 105124 11317 ns/op 90.49 MB/s 12688 B/op 8 allocs/op +BenchmarkParse/headers/1KiB-12 107433 11168 ns/op 91.69 MB/s 12688 B/op 8 allocs/op +BenchmarkParse/headers/1KiB-12 105373 11297 ns/op 90.64 MB/s 12688 B/op 8 allocs/op +BenchmarkParse/headers/64KiB-12 1796 672041 ns/op 97.52 MB/s 729873 B/op 8 allocs/op +BenchmarkParse/headers/64KiB-12 1818 655212 ns/op 100.02 MB/s 729873 B/op 8 allocs/op +BenchmarkParse/headers/64KiB-12 1800 663163 ns/op 98.82 MB/s 729872 B/op 8 allocs/op +BenchmarkParse/headers/64KiB-12 1797 672167 ns/op 97.5 MB/s 729873 B/op 8 allocs/op +BenchmarkParse/headers/64KiB-12 1686 664834 ns/op 98.57 MB/s 729873 B/op 8 allocs/op +BenchmarkParse/headers/64KiB-12 1806 664166 ns/op 98.67 MB/s 729872 B/op 8 allocs/op +BenchmarkParse/headers/64KiB-12 1774 661822 ns/op 99.02 MB/s 729872 B/op 8 allocs/op +BenchmarkParse/headers/64KiB-12 1696 666669 ns/op 98.3 MB/s 729873 B/op 8 allocs/op +BenchmarkParse/headers/64KiB-12 1711 659590 ns/op 99.36 MB/s 729873 B/op 8 allocs/op +BenchmarkParse/headers/64KiB-12 1777 655237 ns/op 100.02 MB/s 729872 B/op 8 allocs/op +BenchmarkParse/headers/1024KiB-12 115 1.0406017e+07 ns/op 100.77 MB/s 1.1543313e+07 B/op 8 allocs/op +BenchmarkParse/headers/1024KiB-12 100 1.0062324e+07 ns/op 104.21 MB/s 1.1543314e+07 B/op 8 allocs/op +BenchmarkParse/headers/1024KiB-12 100 1.0241278e+07 ns/op 102.39 MB/s 1.1543313e+07 B/op 8 allocs/op +BenchmarkParse/headers/1024KiB-12 100 1.0133456e+07 ns/op 103.48 MB/s 1.1543312e+07 B/op 8 allocs/op +BenchmarkParse/headers/1024KiB-12 100 1.0093323e+07 ns/op 103.89 MB/s 1.1543312e+07 B/op 8 allocs/op +BenchmarkParse/headers/1024KiB-12 100 1.0283257e+07 ns/op 101.97 MB/s 1.1543312e+07 B/op 8 allocs/op +BenchmarkParse/headers/1024KiB-12 100 1.0202408e+07 ns/op 102.78 MB/s 1.1543315e+07 B/op 8 allocs/op +BenchmarkParse/headers/1024KiB-12 100 1.0395811e+07 ns/op 100.87 MB/s 1.1543314e+07 B/op 8 allocs/op +BenchmarkParse/headers/1024KiB-12 100 1.0061598e+07 ns/op 104.22 MB/s 1.1543314e+07 B/op 8 allocs/op +BenchmarkParse/headers/1024KiB-12 100 1.0019518e+07 ns/op 104.65 MB/s 1.1543312e+07 B/op 8 allocs/op +BenchmarkParse/long_subsection/1KiB-12 545482 2018 ns/op 508.9 MB/s 3648 B/op 13 allocs/op +BenchmarkParse/long_subsection/1KiB-12 647542 2078 ns/op 494.12 MB/s 3648 B/op 13 allocs/op +BenchmarkParse/long_subsection/1KiB-12 573482 2066 ns/op 497.05 MB/s 3648 B/op 13 allocs/op +BenchmarkParse/long_subsection/1KiB-12 591535 1995 ns/op 514.8 MB/s 3648 B/op 13 allocs/op +BenchmarkParse/long_subsection/1KiB-12 592261 2031 ns/op 505.6 MB/s 3648 B/op 13 allocs/op +BenchmarkParse/long_subsection/1KiB-12 555657 2022 ns/op 507.83 MB/s 3648 B/op 13 allocs/op +BenchmarkParse/long_subsection/1KiB-12 563414 2037 ns/op 504.08 MB/s 3648 B/op 13 allocs/op +BenchmarkParse/long_subsection/1KiB-12 582015 2100 ns/op 489.1 MB/s 3648 B/op 13 allocs/op +BenchmarkParse/long_subsection/1KiB-12 579451 2023 ns/op 507.66 MB/s 3648 B/op 13 allocs/op +BenchmarkParse/long_subsection/1KiB-12 589474 2047 ns/op 501.61 MB/s 3648 B/op 13 allocs/op +BenchmarkParse/long_subsection/64KiB-12 10000 104220 ns/op 628.85 MB/s 261824 B/op 26 allocs/op +BenchmarkParse/long_subsection/64KiB-12 12189 98446 ns/op 665.74 MB/s 261824 B/op 26 allocs/op +BenchmarkParse/long_subsection/64KiB-12 12008 99512 ns/op 658.61 MB/s 261825 B/op 26 allocs/op +BenchmarkParse/long_subsection/64KiB-12 10000 104011 ns/op 630.11 MB/s 261824 B/op 26 allocs/op +BenchmarkParse/long_subsection/64KiB-12 10000 102161 ns/op 641.52 MB/s 261825 B/op 26 allocs/op +BenchmarkParse/long_subsection/64KiB-12 10000 100613 ns/op 651.39 MB/s 261825 B/op 26 allocs/op +BenchmarkParse/long_subsection/64KiB-12 10000 102659 ns/op 638.42 MB/s 261825 B/op 26 allocs/op +BenchmarkParse/long_subsection/64KiB-12 10000 100171 ns/op 654.27 MB/s 261825 B/op 26 allocs/op +BenchmarkParse/long_subsection/64KiB-12 11875 100985 ns/op 649 MB/s 261825 B/op 26 allocs/op +BenchmarkParse/long_subsection/64KiB-12 12190 99074 ns/op 661.51 MB/s 261824 B/op 26 allocs/op +BenchmarkParse/long_subsection/1024KiB-12 615 1.91745e+06 ns/op 546.86 MB/s 4.120276e+06 B/op 36 allocs/op +BenchmarkParse/long_subsection/1024KiB-12 627 1.906956e+06 ns/op 549.87 MB/s 4.120278e+06 B/op 36 allocs/op +BenchmarkParse/long_subsection/1024KiB-12 567 1.984071e+06 ns/op 528.5 MB/s 4.120274e+06 B/op 36 allocs/op +BenchmarkParse/long_subsection/1024KiB-12 627 1.919475e+06 ns/op 546.28 MB/s 4.120276e+06 B/op 36 allocs/op +BenchmarkParse/long_subsection/1024KiB-12 640 1.897154e+06 ns/op 552.71 MB/s 4.120277e+06 B/op 36 allocs/op +BenchmarkParse/long_subsection/1024KiB-12 619 1.963785e+06 ns/op 533.96 MB/s 4.120276e+06 B/op 36 allocs/op +BenchmarkParse/long_subsection/1024KiB-12 588 1.932142e+06 ns/op 542.7 MB/s 4.120277e+06 B/op 36 allocs/op +BenchmarkParse/long_subsection/1024KiB-12 608 1.984127e+06 ns/op 528.48 MB/s 4.120275e+06 B/op 36 allocs/op +BenchmarkParse/long_subsection/1024KiB-12 613 2.00698e+06 ns/op 522.47 MB/s 4.120275e+06 B/op 36 allocs/op +BenchmarkParse/long_subsection/1024KiB-12 578 1.959753e+06 ns/op 535.06 MB/s 4.120275e+06 B/op 36 allocs/op +BenchmarkParse/comments/1KiB-12 384217 3124 ns/op 328.7 MB/s 7968 B/op 6 allocs/op +BenchmarkParse/comments/1KiB-12 397478 3080 ns/op 333.47 MB/s 7968 B/op 6 allocs/op +BenchmarkParse/comments/1KiB-12 392512 3066 ns/op 335 MB/s 7968 B/op 6 allocs/op +BenchmarkParse/comments/1KiB-12 401457 3094 ns/op 331.96 MB/s 7968 B/op 6 allocs/op +BenchmarkParse/comments/1KiB-12 343982 3133 ns/op 327.75 MB/s 7968 B/op 6 allocs/op +BenchmarkParse/comments/1KiB-12 392181 3120 ns/op 329.17 MB/s 7968 B/op 6 allocs/op +BenchmarkParse/comments/1KiB-12 388008 3124 ns/op 328.75 MB/s 7968 B/op 6 allocs/op +BenchmarkParse/comments/1KiB-12 338295 3163 ns/op 324.7 MB/s 7968 B/op 6 allocs/op +BenchmarkParse/comments/1KiB-12 387487 3008 ns/op 341.41 MB/s 7968 B/op 6 allocs/op +BenchmarkParse/comments/1KiB-12 422719 3111 ns/op 330.17 MB/s 7968 B/op 6 allocs/op +BenchmarkParse/comments/64KiB-12 7417 161752 ns/op 405.23 MB/s 483616 B/op 6 allocs/op +BenchmarkParse/comments/64KiB-12 7168 162647 ns/op 402.99 MB/s 483617 B/op 6 allocs/op +BenchmarkParse/comments/64KiB-12 6481 165445 ns/op 396.18 MB/s 483616 B/op 6 allocs/op +BenchmarkParse/comments/64KiB-12 7027 163774 ns/op 400.22 MB/s 483616 B/op 6 allocs/op +BenchmarkParse/comments/64KiB-12 6954 163152 ns/op 401.75 MB/s 483617 B/op 6 allocs/op +BenchmarkParse/comments/64KiB-12 7471 170575 ns/op 384.26 MB/s 483617 B/op 6 allocs/op +BenchmarkParse/comments/64KiB-12 6968 184831 ns/op 354.63 MB/s 483617 B/op 6 allocs/op +BenchmarkParse/comments/64KiB-12 7239 170400 ns/op 384.66 MB/s 483617 B/op 6 allocs/op +BenchmarkParse/comments/64KiB-12 6801 172054 ns/op 380.96 MB/s 483616 B/op 6 allocs/op +BenchmarkParse/comments/64KiB-12 7296 165157 ns/op 396.87 MB/s 483616 B/op 6 allocs/op +BenchmarkParse/comments/1024KiB-12 448 2.520214e+06 ns/op 416.07 MB/s 7.512352e+06 B/op 6 allocs/op +BenchmarkParse/comments/1024KiB-12 475 2.505116e+06 ns/op 418.58 MB/s 7.512353e+06 B/op 6 allocs/op +BenchmarkParse/comments/1024KiB-12 472 2.518064e+06 ns/op 416.42 MB/s 7.512352e+06 B/op 6 allocs/op +BenchmarkParse/comments/1024KiB-12 486 2.496114e+06 ns/op 420.09 MB/s 7.512352e+06 B/op 6 allocs/op +BenchmarkParse/comments/1024KiB-12 471 2.497548e+06 ns/op 419.84 MB/s 7.512353e+06 B/op 6 allocs/op +BenchmarkParse/comments/1024KiB-12 472 2.542276e+06 ns/op 412.46 MB/s 7.512354e+06 B/op 6 allocs/op +BenchmarkParse/comments/1024KiB-12 477 2.502418e+06 ns/op 419.03 MB/s 7.512352e+06 B/op 6 allocs/op +BenchmarkParse/comments/1024KiB-12 463 2.531251e+06 ns/op 414.25 MB/s 7.512352e+06 B/op 6 allocs/op +BenchmarkParse/comments/1024KiB-12 472 2.518997e+06 ns/op 416.27 MB/s 7.512353e+06 B/op 6 allocs/op +BenchmarkParse/comments/1024KiB-12 476 2.512886e+06 ns/op 417.28 MB/s 7.512352e+06 B/op 6 allocs/op +BenchmarkEdit/UnsetAll_one_section/1KiB-12 24416 49078 ns/op 20.91 MB/s 116801 B/op 45 allocs/op +BenchmarkEdit/UnsetAll_one_section/1KiB-12 23944 50426 ns/op 20.35 MB/s 116800 B/op 45 allocs/op +BenchmarkEdit/UnsetAll_one_section/1KiB-12 24201 49564 ns/op 20.7 MB/s 116800 B/op 45 allocs/op +BenchmarkEdit/UnsetAll_one_section/1KiB-12 24566 49238 ns/op 20.84 MB/s 116800 B/op 45 allocs/op +BenchmarkEdit/UnsetAll_one_section/1KiB-12 25104 49030 ns/op 20.93 MB/s 116800 B/op 45 allocs/op +BenchmarkEdit/UnsetAll_one_section/1KiB-12 24901 47897 ns/op 21.42 MB/s 116800 B/op 45 allocs/op +BenchmarkEdit/UnsetAll_one_section/1KiB-12 24788 48121 ns/op 21.32 MB/s 116800 B/op 45 allocs/op +BenchmarkEdit/UnsetAll_one_section/1KiB-12 24578 50152 ns/op 20.46 MB/s 116800 B/op 45 allocs/op +BenchmarkEdit/UnsetAll_one_section/1KiB-12 24750 48820 ns/op 21.02 MB/s 116800 B/op 45 allocs/op +BenchmarkEdit/UnsetAll_one_section/1KiB-12 24697 49711 ns/op 20.64 MB/s 116800 B/op 45 allocs/op +BenchmarkEdit/UnsetAll_one_section/64KiB-12 210 5.624253e+06 ns/op 11.65 MB/s 9.285314e+06 B/op 107 allocs/op +BenchmarkEdit/UnsetAll_one_section/64KiB-12 217 5.538302e+06 ns/op 11.83 MB/s 9.285347e+06 B/op 107 allocs/op +BenchmarkEdit/UnsetAll_one_section/64KiB-12 218 5.423618e+06 ns/op 12.08 MB/s 9.285331e+06 B/op 107 allocs/op +BenchmarkEdit/UnsetAll_one_section/64KiB-12 229 5.505822e+06 ns/op 11.9 MB/s 9.285334e+06 B/op 107 allocs/op +BenchmarkEdit/UnsetAll_one_section/64KiB-12 220 5.271599e+06 ns/op 12.43 MB/s 9.285331e+06 B/op 107 allocs/op +BenchmarkEdit/UnsetAll_one_section/64KiB-12 229 5.50148e+06 ns/op 11.91 MB/s 9.285339e+06 B/op 107 allocs/op +BenchmarkEdit/UnsetAll_one_section/64KiB-12 211 5.594794e+06 ns/op 11.71 MB/s 9.285335e+06 B/op 107 allocs/op +BenchmarkEdit/UnsetAll_one_section/64KiB-12 218 5.449454e+06 ns/op 12.03 MB/s 9.285335e+06 B/op 107 allocs/op +BenchmarkEdit/UnsetAll_one_section/64KiB-12 211 5.524356e+06 ns/op 11.86 MB/s 9.285332e+06 B/op 107 allocs/op +BenchmarkEdit/UnsetAll_one_section/64KiB-12 213 5.543786e+06 ns/op 11.82 MB/s 9.285342e+06 B/op 107 allocs/op +BenchmarkEdit/UnsetAll_one_section/1024KiB-12 18 7.4107434e+07 ns/op 14.15 MB/s 1.64574853e+08 B/op 622 allocs/op +BenchmarkEdit/UnsetAll_one_section/1024KiB-12 16 7.6939121e+07 ns/op 13.63 MB/s 1.64574515e+08 B/op 622 allocs/op +BenchmarkEdit/UnsetAll_one_section/1024KiB-12 14 8.0118687e+07 ns/op 13.09 MB/s 1.64574558e+08 B/op 622 allocs/op +BenchmarkEdit/UnsetAll_one_section/1024KiB-12 14 7.9396842e+07 ns/op 13.21 MB/s 1.64574533e+08 B/op 622 allocs/op +BenchmarkEdit/UnsetAll_one_section/1024KiB-12 14 8.0425569e+07 ns/op 13.04 MB/s 1.64574541e+08 B/op 622 allocs/op +BenchmarkEdit/UnsetAll_one_section/1024KiB-12 14 8.1728653e+07 ns/op 12.83 MB/s 1.64574549e+08 B/op 622 allocs/op +BenchmarkEdit/UnsetAll_one_section/1024KiB-12 16 8.1735177e+07 ns/op 12.83 MB/s 1.64574508e+08 B/op 622 allocs/op +BenchmarkEdit/UnsetAll_one_section/1024KiB-12 14 8.0531444e+07 ns/op 13.02 MB/s 1.64574533e+08 B/op 622 allocs/op +BenchmarkEdit/UnsetAll_one_section/1024KiB-12 15 7.8696242e+07 ns/op 13.32 MB/s 1.64574531e+08 B/op 622 allocs/op +BenchmarkEdit/UnsetAll_one_section/1024KiB-12 14 7.9835963e+07 ns/op 13.13 MB/s 1.64574517e+08 B/op 622 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 22503 52724 ns/op 19.61 MB/s 92608 B/op 43 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 23161 53267 ns/op 19.41 MB/s 92608 B/op 43 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 22696 54191 ns/op 19.08 MB/s 92608 B/op 43 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 21891 53393 ns/op 19.37 MB/s 92608 B/op 43 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 22026 53599 ns/op 19.29 MB/s 92608 B/op 43 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 22737 53115 ns/op 19.47 MB/s 92608 B/op 43 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 21966 54045 ns/op 19.13 MB/s 92608 B/op 43 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 22215 54201 ns/op 19.08 MB/s 92608 B/op 43 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 22311 55738 ns/op 18.55 MB/s 92608 B/op 43 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 21316 54472 ns/op 18.98 MB/s 92608 B/op 43 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 279 4.406251e+06 ns/op 14.87 MB/s 5.893478e+06 B/op 84 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 273 4.378019e+06 ns/op 14.97 MB/s 5.893479e+06 B/op 84 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 276 4.271998e+06 ns/op 15.34 MB/s 5.893476e+06 B/op 84 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 285 4.228529e+06 ns/op 15.5 MB/s 5.893478e+06 B/op 84 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 276 4.431388e+06 ns/op 14.79 MB/s 5.89348e+06 B/op 84 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 274 4.427621e+06 ns/op 14.8 MB/s 5.893481e+06 B/op 84 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 273 4.264495e+06 ns/op 15.37 MB/s 5.893482e+06 B/op 84 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 297 4.114335e+06 ns/op 15.93 MB/s 5.893475e+06 B/op 84 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 282 4.249894e+06 ns/op 15.42 MB/s 5.893477e+06 B/op 84 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 270 4.294874e+06 ns/op 15.26 MB/s 5.89348e+06 B/op 84 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 18 6.3955365e+07 ns/op 16.4 MB/s 1.10928092e+08 B/op 359 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 18 6.3867034e+07 ns/op 16.42 MB/s 1.10928061e+08 B/op 359 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 16 6.3293301e+07 ns/op 16.57 MB/s 1.10928072e+08 B/op 359 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 18 6.3122281e+07 ns/op 16.61 MB/s 1.10928073e+08 B/op 359 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 16 6.3179136e+07 ns/op 16.6 MB/s 1.10928093e+08 B/op 359 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 16 6.432926e+07 ns/op 16.3 MB/s 1.10928086e+08 B/op 359 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 16 6.3214335e+07 ns/op 16.59 MB/s 1.10928121e+08 B/op 359 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 18 6.3417434e+07 ns/op 16.53 MB/s 1.10928067e+08 B/op 359 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 16 6.3391137e+07 ns/op 16.54 MB/s 1.10928079e+08 B/op 359 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 18 6.2512064e+07 ns/op 16.77 MB/s 1.10928067e+08 B/op 359 allocs/op +BenchmarkEdit/RenameSection_one_line/1KiB-12 19615 61085 ns/op 16.91 MB/s 91472 B/op 53 allocs/op +BenchmarkEdit/RenameSection_one_line/1KiB-12 19327 62647 ns/op 16.49 MB/s 91472 B/op 53 allocs/op +BenchmarkEdit/RenameSection_one_line/1KiB-12 19471 61292 ns/op 16.85 MB/s 91472 B/op 53 allocs/op +BenchmarkEdit/RenameSection_one_line/1KiB-12 19258 62149 ns/op 16.62 MB/s 91472 B/op 53 allocs/op +BenchmarkEdit/RenameSection_one_line/1KiB-12 18934 62228 ns/op 16.6 MB/s 91472 B/op 53 allocs/op +BenchmarkEdit/RenameSection_one_line/1KiB-12 19300 61862 ns/op 16.7 MB/s 91472 B/op 53 allocs/op +BenchmarkEdit/RenameSection_one_line/1KiB-12 19381 61134 ns/op 16.9 MB/s 91472 B/op 53 allocs/op +BenchmarkEdit/RenameSection_one_line/1KiB-12 19339 62614 ns/op 16.5 MB/s 91472 B/op 53 allocs/op +BenchmarkEdit/RenameSection_one_line/1KiB-12 19650 61289 ns/op 16.85 MB/s 91472 B/op 53 allocs/op +BenchmarkEdit/RenameSection_one_line/1KiB-12 19312 64292 ns/op 16.07 MB/s 91472 B/op 53 allocs/op +BenchmarkEdit/RenameSection_one_line/64KiB-12 207 5.727538e+06 ns/op 11.44 MB/s 1.0203052e+07 B/op 103 allocs/op +BenchmarkEdit/RenameSection_one_line/64KiB-12 196 5.930894e+06 ns/op 11.05 MB/s 1.0203054e+07 B/op 103 allocs/op +BenchmarkEdit/RenameSection_one_line/64KiB-12 199 5.97393e+06 ns/op 10.97 MB/s 1.0203057e+07 B/op 103 allocs/op +BenchmarkEdit/RenameSection_one_line/64KiB-12 204 6.043115e+06 ns/op 10.85 MB/s 1.0203055e+07 B/op 103 allocs/op +BenchmarkEdit/RenameSection_one_line/64KiB-12 190 6.378874e+06 ns/op 10.28 MB/s 1.020305e+07 B/op 103 allocs/op +BenchmarkEdit/RenameSection_one_line/64KiB-12 194 6.209061e+06 ns/op 10.56 MB/s 1.0203052e+07 B/op 103 allocs/op +BenchmarkEdit/RenameSection_one_line/64KiB-12 192 6.16533e+06 ns/op 10.63 MB/s 1.0203054e+07 B/op 103 allocs/op +BenchmarkEdit/RenameSection_one_line/64KiB-12 192 6.2297e+06 ns/op 10.52 MB/s 1.0203053e+07 B/op 103 allocs/op +BenchmarkEdit/RenameSection_one_line/64KiB-12 192 6.247756e+06 ns/op 10.49 MB/s 1.0203057e+07 B/op 103 allocs/op +BenchmarkEdit/RenameSection_one_line/64KiB-12 195 6.169213e+06 ns/op 10.62 MB/s 1.0203054e+07 B/op 103 allocs/op +BenchmarkEdit/RenameSection_one_line/1024KiB-12 14 8.1323978e+07 ns/op 12.89 MB/s 1.75181733e+08 B/op 150 allocs/op +BenchmarkEdit/RenameSection_one_line/1024KiB-12 13 8.0046083e+07 ns/op 13.1 MB/s 1.75181782e+08 B/op 151 allocs/op +BenchmarkEdit/RenameSection_one_line/1024KiB-12 14 8.1019413e+07 ns/op 12.94 MB/s 1.75181717e+08 B/op 150 allocs/op +BenchmarkEdit/RenameSection_one_line/1024KiB-12 14 8.1187236e+07 ns/op 12.92 MB/s 1.75181693e+08 B/op 150 allocs/op +BenchmarkEdit/RenameSection_one_line/1024KiB-12 13 8.0527948e+07 ns/op 13.02 MB/s 1.75181747e+08 B/op 150 allocs/op +BenchmarkEdit/RenameSection_one_line/1024KiB-12 13 8.3236348e+07 ns/op 12.6 MB/s 1.7518179e+08 B/op 151 allocs/op +BenchmarkEdit/RenameSection_one_line/1024KiB-12 13 8.2176743e+07 ns/op 12.76 MB/s 1.75181764e+08 B/op 150 allocs/op +BenchmarkEdit/RenameSection_one_line/1024KiB-12 13 8.0932106e+07 ns/op 12.96 MB/s 1.75181756e+08 B/op 150 allocs/op +BenchmarkEdit/RenameSection_one_line/1024KiB-12 13 8.235478e+07 ns/op 12.73 MB/s 1.75181713e+08 B/op 150 allocs/op +BenchmarkEdit/RenameSection_one_line/1024KiB-12 13 8.3229086e+07 ns/op 12.6 MB/s 1.75181773e+08 B/op 151 allocs/op +BenchmarkFile/Set/n=10-12 30895 37357 ns/op 79156 B/op 162 allocs/op +BenchmarkFile/Set/n=10-12 35222 36026 ns/op 79156 B/op 161 allocs/op +BenchmarkFile/Set/n=10-12 31662 38499 ns/op 79155 B/op 161 allocs/op +BenchmarkFile/Set/n=10-12 29900 38924 ns/op 79155 B/op 161 allocs/op +BenchmarkFile/Set/n=10-12 31828 37913 ns/op 79155 B/op 161 allocs/op +BenchmarkFile/Set/n=10-12 29434 38475 ns/op 79155 B/op 161 allocs/op +BenchmarkFile/Set/n=10-12 31032 37017 ns/op 79155 B/op 161 allocs/op +BenchmarkFile/Set/n=10-12 33693 42788 ns/op 79156 B/op 162 allocs/op +BenchmarkFile/Set/n=10-12 33193 34223 ns/op 79155 B/op 161 allocs/op +BenchmarkFile/Set/n=10-12 35308 34704 ns/op 79156 B/op 162 allocs/op +BenchmarkFile/SetUnchanged/n=10-12 2074623 595.5 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=10-12 2074032 579 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=10-12 2051220 586.1 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=10-12 2030247 585.3 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=10-12 2056933 586.7 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=10-12 2077357 581 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=10-12 2052550 584.7 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=10-12 2043246 586.2 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=10-12 2066917 582.6 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=10-12 2043548 581.9 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetNewSection/n=10-12 22312 53506 ns/op 112072 B/op 296 allocs/op +BenchmarkFile/SetNewSection/n=10-12 22234 54093 ns/op 112072 B/op 296 allocs/op +BenchmarkFile/SetNewSection/n=10-12 22412 53512 ns/op 112072 B/op 296 allocs/op +BenchmarkFile/SetNewSection/n=10-12 22231 53811 ns/op 112072 B/op 296 allocs/op +BenchmarkFile/SetNewSection/n=10-12 21938 56133 ns/op 112072 B/op 296 allocs/op +BenchmarkFile/SetNewSection/n=10-12 21019 55154 ns/op 112072 B/op 296 allocs/op +BenchmarkFile/SetNewSection/n=10-12 22291 54227 ns/op 112072 B/op 296 allocs/op +BenchmarkFile/SetNewSection/n=10-12 20970 56859 ns/op 112072 B/op 296 allocs/op +BenchmarkFile/SetNewSection/n=10-12 21548 56258 ns/op 112072 B/op 296 allocs/op +BenchmarkFile/SetNewSection/n=10-12 20793 55855 ns/op 112072 B/op 296 allocs/op +BenchmarkFile/ConfigAfterEdit/n=10-12 22939 52691 ns/op 110456 B/op 239 allocs/op +BenchmarkFile/ConfigAfterEdit/n=10-12 22183 52748 ns/op 110456 B/op 239 allocs/op +BenchmarkFile/ConfigAfterEdit/n=10-12 22447 53262 ns/op 110456 B/op 239 allocs/op +BenchmarkFile/ConfigAfterEdit/n=10-12 22678 52941 ns/op 110456 B/op 239 allocs/op +BenchmarkFile/ConfigAfterEdit/n=10-12 21838 55029 ns/op 110456 B/op 239 allocs/op +BenchmarkFile/ConfigAfterEdit/n=10-12 21415 55100 ns/op 110456 B/op 239 allocs/op +BenchmarkFile/ConfigAfterEdit/n=10-12 21428 55302 ns/op 110456 B/op 239 allocs/op +BenchmarkFile/ConfigAfterEdit/n=10-12 21957 54722 ns/op 110456 B/op 239 allocs/op +BenchmarkFile/ConfigAfterEdit/n=10-12 22525 53152 ns/op 110456 B/op 239 allocs/op +BenchmarkFile/ConfigAfterEdit/n=10-12 22014 54701 ns/op 110456 B/op 239 allocs/op +BenchmarkFile/Bytes/n=10-12 3867669 303.9 ns/op 1536 B/op 1 allocs/op +BenchmarkFile/Bytes/n=10-12 4109804 297.8 ns/op 1536 B/op 1 allocs/op +BenchmarkFile/Bytes/n=10-12 3951469 298.5 ns/op 1536 B/op 1 allocs/op +BenchmarkFile/Bytes/n=10-12 4004516 303.6 ns/op 1536 B/op 1 allocs/op +BenchmarkFile/Bytes/n=10-12 3907399 310.3 ns/op 1536 B/op 1 allocs/op +BenchmarkFile/Bytes/n=10-12 4051450 297.2 ns/op 1536 B/op 1 allocs/op +BenchmarkFile/Bytes/n=10-12 4044996 294.8 ns/op 1536 B/op 1 allocs/op +BenchmarkFile/Bytes/n=10-12 4081429 301.3 ns/op 1536 B/op 1 allocs/op +BenchmarkFile/Bytes/n=10-12 4085800 303 ns/op 1536 B/op 1 allocs/op +BenchmarkFile/Bytes/n=10-12 3632848 307.2 ns/op 1536 B/op 1 allocs/op +BenchmarkFile/Set/n=1000-12 262 4.63775e+06 ns/op 9.080756e+06 B/op 8158 allocs/op +BenchmarkFile/Set/n=1000-12 254 4.577455e+06 ns/op 9.080775e+06 B/op 8158 allocs/op +BenchmarkFile/Set/n=1000-12 265 4.548097e+06 ns/op 9.080754e+06 B/op 8158 allocs/op +BenchmarkFile/Set/n=1000-12 264 4.532329e+06 ns/op 9.080748e+06 B/op 8158 allocs/op +BenchmarkFile/Set/n=1000-12 267 4.496907e+06 ns/op 9.080755e+06 B/op 8158 allocs/op +BenchmarkFile/Set/n=1000-12 266 4.611598e+06 ns/op 9.080752e+06 B/op 8158 allocs/op +BenchmarkFile/Set/n=1000-12 262 4.524577e+06 ns/op 9.080753e+06 B/op 8158 allocs/op +BenchmarkFile/Set/n=1000-12 262 4.524664e+06 ns/op 9.080751e+06 B/op 8158 allocs/op +BenchmarkFile/Set/n=1000-12 267 4.485563e+06 ns/op 9.080753e+06 B/op 8158 allocs/op +BenchmarkFile/Set/n=1000-12 267 4.526553e+06 ns/op 9.080748e+06 B/op 8158 allocs/op +BenchmarkFile/SetUnchanged/n=1000-12 29433 40547 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=1000-12 29688 40248 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=1000-12 29122 40642 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=1000-12 29416 40816 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=1000-12 29971 40231 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=1000-12 29672 40278 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=1000-12 29830 40457 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=1000-12 29086 40866 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=1000-12 29964 40343 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=1000-12 30118 40082 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetNewSection/n=1000-12 175 6.798115e+06 ns/op 1.2362806e+07 B/op 16254 allocs/op +BenchmarkFile/SetNewSection/n=1000-12 175 6.887704e+06 ns/op 1.236281e+07 B/op 16254 allocs/op +BenchmarkFile/SetNewSection/n=1000-12 172 6.861706e+06 ns/op 1.2362796e+07 B/op 16254 allocs/op +BenchmarkFile/SetNewSection/n=1000-12 174 6.892087e+06 ns/op 1.2362812e+07 B/op 16254 allocs/op +BenchmarkFile/SetNewSection/n=1000-12 170 6.960185e+06 ns/op 1.236281e+07 B/op 16254 allocs/op +BenchmarkFile/SetNewSection/n=1000-12 177 6.753263e+06 ns/op 1.2362817e+07 B/op 16254 allocs/op +BenchmarkFile/SetNewSection/n=1000-12 172 6.876183e+06 ns/op 1.2362809e+07 B/op 16254 allocs/op +BenchmarkFile/SetNewSection/n=1000-12 171 7.024126e+06 ns/op 1.2362811e+07 B/op 16254 allocs/op +BenchmarkFile/SetNewSection/n=1000-12 168 6.993871e+06 ns/op 1.2362802e+07 B/op 16254 allocs/op +BenchmarkFile/SetNewSection/n=1000-12 176 6.841669e+06 ns/op 1.2362803e+07 B/op 16254 allocs/op +BenchmarkFile/ConfigAfterEdit/n=1000-12 172 6.841966e+06 ns/op 1.292618e+07 B/op 12280 allocs/op +BenchmarkFile/ConfigAfterEdit/n=1000-12 172 6.825954e+06 ns/op 1.2926181e+07 B/op 12280 allocs/op +BenchmarkFile/ConfigAfterEdit/n=1000-12 163 7.246492e+06 ns/op 1.2926193e+07 B/op 12280 allocs/op +BenchmarkFile/ConfigAfterEdit/n=1000-12 174 6.980143e+06 ns/op 1.2926184e+07 B/op 12280 allocs/op +BenchmarkFile/ConfigAfterEdit/n=1000-12 158 7.295322e+06 ns/op 1.2926181e+07 B/op 12280 allocs/op +BenchmarkFile/ConfigAfterEdit/n=1000-12 166 6.954853e+06 ns/op 1.2926182e+07 B/op 12280 allocs/op +BenchmarkFile/ConfigAfterEdit/n=1000-12 166 7.153265e+06 ns/op 1.2926188e+07 B/op 12280 allocs/op +BenchmarkFile/ConfigAfterEdit/n=1000-12 169 6.962722e+06 ns/op 1.2926181e+07 B/op 12280 allocs/op +BenchmarkFile/ConfigAfterEdit/n=1000-12 174 6.870898e+06 ns/op 1.2926187e+07 B/op 12280 allocs/op +BenchmarkFile/ConfigAfterEdit/n=1000-12 168 7.047383e+06 ns/op 1.2926195e+07 B/op 12280 allocs/op +BenchmarkFile/Bytes/n=1000-12 44668 28972 ns/op 155648 B/op 1 allocs/op +BenchmarkFile/Bytes/n=1000-12 42621 30060 ns/op 155648 B/op 1 allocs/op +BenchmarkFile/Bytes/n=1000-12 36308 30783 ns/op 155648 B/op 1 allocs/op +BenchmarkFile/Bytes/n=1000-12 37310 30085 ns/op 155648 B/op 1 allocs/op +BenchmarkFile/Bytes/n=1000-12 40918 31566 ns/op 155648 B/op 1 allocs/op +BenchmarkFile/Bytes/n=1000-12 38487 31343 ns/op 155648 B/op 1 allocs/op +BenchmarkFile/Bytes/n=1000-12 39242 31834 ns/op 155648 B/op 1 allocs/op +BenchmarkFile/Bytes/n=1000-12 35860 32289 ns/op 155648 B/op 1 allocs/op +BenchmarkFile/Bytes/n=1000-12 36783 32320 ns/op 155648 B/op 1 allocs/op +BenchmarkFile/Bytes/n=1000-12 36924 31025 ns/op 155648 B/op 1 allocs/op diff --git a/.benchspotter/sessions/01a120b8-cecb-7ce8-8e6b-119d836f987e/git.diff b/.benchspotter/sessions/01a120b8-cecb-7ce8-8e6b-119d836f987e/git.diff new file mode 100644 index 0000000..eea72da --- /dev/null +++ b/.benchspotter/sessions/01a120b8-cecb-7ce8-8e6b-119d836f987e/git.diff @@ -0,0 +1,680 @@ +diff --git a/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/git.diff b/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/git.diff +new file mode 100644 +index 0000000..b6e6218 +--- /dev/null ++++ b/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/git.diff +@@ -0,0 +1,69 @@ ++diff --git a/env_test.go b/env_test.go ++index c4f3ce1..780217e 100644 ++--- a/env_test.go +++++ b/env_test.go ++@@ -1697,6 +1697,16 @@ func BenchmarkEnv(b *testing.B) { ++ _, _ = env.LoadProtected() ++ } ++ }) +++ b.Run("LoadFileManyGitdirConditions", func(b *testing.B) { +++ // The git directory's real path is resolved once per load, not +++ // once per condition. +++ path := filepath.Join(tempDir(b), "config") +++ writeFile(b, path, strings.Repeat("[includeIf \"gitdir:/nope/\"]\n\tpath = x\n", 1000)) +++ b.ReportAllocs() +++ for b.Loop() { +++ _, _ = env.LoadFile(path) +++ } +++ }) ++ b.Run("UpdateFile", func(b *testing.B) { ++ path := filepath.Join(env.GitDir, "config") ++ i := 0 ++diff --git a/file_test.go b/file_test.go ++index 1415a54..cb6a960 100644 ++--- a/file_test.go +++++ b/file_test.go ++@@ -1063,6 +1063,43 @@ func BenchmarkParse(b *testing.B) { ++ } ++ } ++ +++// BenchmarkEdit measures edits that touch many lines at once, on inputs +++// built to hit their slow paths; each iteration parses the file first. +++// Throughput (MB/s) must not fall as the size grows: these edits are linear. +++func BenchmarkEdit(b *testing.B) { +++ edits := []struct { +++ name string +++ gen func(n int) []byte +++ edit func(f *gitconfig.File) error +++ }{ +++ {"UnsetAll one section", func(n int) []byte { return sized("[a]\n", "\tk = v\n", n) }, func(f *gitconfig.File) error { +++ _, err := f.UnsetAll("a.k") +++ return err +++ }}, +++ {"UnsetAll section per value", func(n int) []byte { return sized("", "[a]\n\tk = v\n", n) }, func(f *gitconfig.File) error { +++ _, err := f.UnsetAll("a.k") +++ return err +++ }}, +++ {"RenameSection one line", func(n int) []byte { return append(sized("", "[a]", n), " k = v\n"...) }, func(f *gitconfig.File) error { +++ return f.RenameSection("a", "b") +++ }}, +++ } +++ for _, e := range edits { +++ for _, n := range []int{1 << 10, 1 << 16, 1 << 20} { +++ data := e.gen(n) +++ b.Run(fmt.Sprintf("%s/%dKiB", e.name, n>>10), func(b *testing.B) { +++ b.SetBytes(int64(len(data))) +++ b.ReportAllocs() +++ for b.Loop() { +++ f, err := gitconfig.Parse("f", data) +++ require.NoError(b, err) +++ require.NoError(b, e.edit(f)) +++ } +++ }) +++ } +++ } +++} +++ ++ func BenchmarkFile(b *testing.B) { ++ for _, n := range []int{10, 1000} { ++ data := []byte(bigConfig(n)) +diff --git a/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/meta.json b/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/meta.json +new file mode 100644 +index 0000000..d9b3e36 +--- /dev/null ++++ b/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/meta.json +@@ -0,0 +1,24 @@ ++{ ++ "name": "edit-benches", ++ "benchs": [ ++ "BenchmarkEnv/Load", ++ "BenchmarkEnv/LoadProtected", ++ "BenchmarkEnv/LoadFileManyGitdirConditions", ++ "BenchmarkEnv/UpdateFile", ++ "BenchmarkEnv/UpdateFileUnchanged", ++ "BenchmarkEdit" ++ ], ++ "git_commit": "9f097cd6b40f09dd20e5e00b92bd6ded3ca0f281", ++ "machine": { ++ "goos": "linux", ++ "goarch": "amd64", ++ "num_cpu": 12, ++ "physical_cores": 6, ++ "threads_per_core": 2, ++ "cpu": "AMD Ryzen 5 3600 6-Core Processor", ++ "cache_l1d": 32768, ++ "cache_l2": 524288, ++ "cache_l3": 16777216 ++ }, ++ "go_version": "go1.27.1" ++} +diff --git a/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/results.bench b/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/results.bench +new file mode 100644 +index 0000000..df8598f +--- /dev/null ++++ b/.benchspotter/sessions/01a120a7-af08-711e-9648-85d370040ba2/results.bench +@@ -0,0 +1,145 @@ ++goos: linux ++goarch: amd64 ++pkg: github.com/git-bug/gitconfig ++cpu: AMD Ryzen 5 3600 6-Core Processor ++ ++BenchmarkEnv/Load-12 5012 241503 ns/op 332510 B/op 932 allocs/op ++BenchmarkEnv/Load-12 5055 237011 ns/op 332506 B/op 932 allocs/op ++BenchmarkEnv/Load-12 4833 247790 ns/op 332507 B/op 932 allocs/op ++BenchmarkEnv/Load-12 4948 262598 ns/op 332507 B/op 932 allocs/op ++BenchmarkEnv/Load-12 4952 247394 ns/op 332507 B/op 932 allocs/op ++BenchmarkEnv/Load-12 4938 237301 ns/op 332506 B/op 932 allocs/op ++BenchmarkEnv/Load-12 4702 242795 ns/op 332507 B/op 932 allocs/op ++BenchmarkEnv/Load-12 4986 237644 ns/op 332507 B/op 932 allocs/op ++BenchmarkEnv/Load-12 5089 232608 ns/op 332507 B/op 932 allocs/op ++BenchmarkEnv/Load-12 4891 234684 ns/op 332507 B/op 932 allocs/op ++BenchmarkEnv/LoadProtected-12 18220 65050 ns/op 62041 B/op 219 allocs/op ++BenchmarkEnv/LoadProtected-12 18184 65361 ns/op 62040 B/op 219 allocs/op ++BenchmarkEnv/LoadProtected-12 18378 65616 ns/op 62040 B/op 219 allocs/op ++BenchmarkEnv/LoadProtected-12 18579 64420 ns/op 62040 B/op 219 allocs/op ++BenchmarkEnv/LoadProtected-12 18400 64840 ns/op 62040 B/op 219 allocs/op ++BenchmarkEnv/LoadProtected-12 18554 64231 ns/op 62040 B/op 219 allocs/op ++BenchmarkEnv/LoadProtected-12 18663 64566 ns/op 62040 B/op 219 allocs/op ++BenchmarkEnv/LoadProtected-12 18583 64480 ns/op 62040 B/op 219 allocs/op ++BenchmarkEnv/LoadProtected-12 18693 64180 ns/op 62040 B/op 219 allocs/op ++BenchmarkEnv/LoadProtected-12 18700 64691 ns/op 62040 B/op 219 allocs/op ++BenchmarkEnv/LoadFileManyGitdirConditions-12 1105 1.123003e+06 ns/op 1.881754e+06 B/op 12101 allocs/op ++BenchmarkEnv/LoadFileManyGitdirConditions-12 1070 1.101759e+06 ns/op 1.881736e+06 B/op 12101 allocs/op ++BenchmarkEnv/LoadFileManyGitdirConditions-12 1053 1.101034e+06 ns/op 1.881737e+06 B/op 12101 allocs/op ++BenchmarkEnv/LoadFileManyGitdirConditions-12 1146 1.094549e+06 ns/op 1.881736e+06 B/op 12101 allocs/op ++BenchmarkEnv/LoadFileManyGitdirConditions-12 1125 1.082766e+06 ns/op 1.881735e+06 B/op 12101 allocs/op ++BenchmarkEnv/LoadFileManyGitdirConditions-12 1135 1.108419e+06 ns/op 1.881735e+06 B/op 12101 allocs/op ++BenchmarkEnv/LoadFileManyGitdirConditions-12 1063 1.09794e+06 ns/op 1.881737e+06 B/op 12101 allocs/op ++BenchmarkEnv/LoadFileManyGitdirConditions-12 1086 1.10521e+06 ns/op 1.881736e+06 B/op 12101 allocs/op ++BenchmarkEnv/LoadFileManyGitdirConditions-12 1094 1.171132e+06 ns/op 1.881737e+06 B/op 12101 allocs/op ++BenchmarkEnv/LoadFileManyGitdirConditions-12 986 1.125506e+06 ns/op 1.881736e+06 B/op 12101 allocs/op ++BenchmarkEnv/UpdateFile-12 4190 271686 ns/op 460668 B/op 993 allocs/op ++BenchmarkEnv/UpdateFile-12 4456 274471 ns/op 460667 B/op 993 allocs/op ++BenchmarkEnv/UpdateFile-12 4729 275723 ns/op 460666 B/op 993 allocs/op ++BenchmarkEnv/UpdateFile-12 4462 271889 ns/op 460666 B/op 993 allocs/op ++BenchmarkEnv/UpdateFile-12 4380 270158 ns/op 460666 B/op 993 allocs/op ++BenchmarkEnv/UpdateFile-12 4204 277096 ns/op 460666 B/op 993 allocs/op ++BenchmarkEnv/UpdateFile-12 4135 278751 ns/op 460666 B/op 993 allocs/op ++BenchmarkEnv/UpdateFile-12 4646 270537 ns/op 460666 B/op 993 allocs/op ++BenchmarkEnv/UpdateFile-12 4436 272529 ns/op 460666 B/op 993 allocs/op ++BenchmarkEnv/UpdateFile-12 4336 272191 ns/op 460666 B/op 993 allocs/op ++BenchmarkEnv/UpdateFileUnchanged-12 10000 107961 ns/op 136545 B/op 480 allocs/op ++BenchmarkEnv/UpdateFileUnchanged-12 10000 107468 ns/op 136545 B/op 480 allocs/op ++BenchmarkEnv/UpdateFileUnchanged-12 10000 108063 ns/op 136544 B/op 480 allocs/op ++BenchmarkEnv/UpdateFileUnchanged-12 10000 109785 ns/op 136544 B/op 480 allocs/op ++BenchmarkEnv/UpdateFileUnchanged-12 10000 108510 ns/op 136544 B/op 480 allocs/op ++BenchmarkEnv/UpdateFileUnchanged-12 10000 108888 ns/op 136544 B/op 480 allocs/op ++BenchmarkEnv/UpdateFileUnchanged-12 9543 112027 ns/op 136544 B/op 480 allocs/op ++BenchmarkEnv/UpdateFileUnchanged-12 10000 110303 ns/op 136544 B/op 480 allocs/op ++BenchmarkEnv/UpdateFileUnchanged-12 10000 110549 ns/op 136544 B/op 480 allocs/op ++BenchmarkEnv/UpdateFileUnchanged-12 10000 109377 ns/op 136544 B/op 480 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1KiB-12 24992 48458 ns/op 21.17 MB/s 116801 B/op 45 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1KiB-12 25394 48523 ns/op 21.14 MB/s 116800 B/op 45 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1KiB-12 23578 48785 ns/op 21.03 MB/s 116800 B/op 45 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1KiB-12 25435 47119 ns/op 21.77 MB/s 116800 B/op 45 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1KiB-12 25606 47586 ns/op 21.56 MB/s 116800 B/op 45 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1KiB-12 25616 47607 ns/op 21.55 MB/s 116800 B/op 45 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1KiB-12 25425 47311 ns/op 21.69 MB/s 116800 B/op 45 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1KiB-12 25312 47771 ns/op 21.48 MB/s 116800 B/op 45 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1KiB-12 25722 47106 ns/op 21.78 MB/s 116800 B/op 45 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1KiB-12 25611 46886 ns/op 21.88 MB/s 116800 B/op 45 allocs/op ++BenchmarkEdit/UnsetAll_one_section/64KiB-12 229 5.223861e+06 ns/op 12.55 MB/s 9.285321e+06 B/op 107 allocs/op ++BenchmarkEdit/UnsetAll_one_section/64KiB-12 232 5.112092e+06 ns/op 12.82 MB/s 9.28532e+06 B/op 107 allocs/op ++BenchmarkEdit/UnsetAll_one_section/64KiB-12 238 5.116727e+06 ns/op 12.81 MB/s 9.285327e+06 B/op 107 allocs/op ++BenchmarkEdit/UnsetAll_one_section/64KiB-12 224 5.389997e+06 ns/op 12.16 MB/s 9.285338e+06 B/op 107 allocs/op ++BenchmarkEdit/UnsetAll_one_section/64KiB-12 218 5.208605e+06 ns/op 12.58 MB/s 9.285335e+06 B/op 107 allocs/op ++BenchmarkEdit/UnsetAll_one_section/64KiB-12 238 4.952627e+06 ns/op 13.23 MB/s 9.285355e+06 B/op 107 allocs/op ++BenchmarkEdit/UnsetAll_one_section/64KiB-12 236 4.986969e+06 ns/op 13.14 MB/s 9.285334e+06 B/op 107 allocs/op ++BenchmarkEdit/UnsetAll_one_section/64KiB-12 236 5.071369e+06 ns/op 12.92 MB/s 9.285339e+06 B/op 107 allocs/op ++BenchmarkEdit/UnsetAll_one_section/64KiB-12 235 5.001953e+06 ns/op 13.1 MB/s 9.285328e+06 B/op 107 allocs/op ++BenchmarkEdit/UnsetAll_one_section/64KiB-12 247 4.941395e+06 ns/op 13.26 MB/s 9.285326e+06 B/op 107 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1024KiB-12 18 7.4505016e+07 ns/op 14.07 MB/s 1.64574835e+08 B/op 622 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1024KiB-12 16 7.4735616e+07 ns/op 14.03 MB/s 1.64574529e+08 B/op 622 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1024KiB-12 15 7.5954921e+07 ns/op 13.81 MB/s 1.64574538e+08 B/op 622 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1024KiB-12 16 7.7238758e+07 ns/op 13.58 MB/s 1.64574515e+08 B/op 622 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1024KiB-12 15 7.7903187e+07 ns/op 13.46 MB/s 1.64574538e+08 B/op 622 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1024KiB-12 14 8.0328085e+07 ns/op 13.05 MB/s 1.64574541e+08 B/op 622 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1024KiB-12 15 7.8560708e+07 ns/op 13.35 MB/s 1.64574538e+08 B/op 622 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1024KiB-12 15 7.6633014e+07 ns/op 13.68 MB/s 1.64574917e+08 B/op 622 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1024KiB-12 15 7.8626452e+07 ns/op 13.34 MB/s 1.64574538e+08 B/op 622 allocs/op ++BenchmarkEdit/UnsetAll_one_section/1024KiB-12 14 7.7921155e+07 ns/op 13.46 MB/s 1.64574525e+08 B/op 622 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 23151 52263 ns/op 19.78 MB/s 92608 B/op 43 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 22872 51578 ns/op 20.05 MB/s 92608 B/op 43 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 23139 52356 ns/op 19.75 MB/s 92608 B/op 43 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 20388 55894 ns/op 18.5 MB/s 92608 B/op 43 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 23473 51433 ns/op 20.1 MB/s 92608 B/op 43 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 23798 50874 ns/op 20.32 MB/s 92608 B/op 43 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 23052 53274 ns/op 19.41 MB/s 92608 B/op 43 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 23304 51407 ns/op 20.11 MB/s 92608 B/op 43 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 23028 52248 ns/op 19.79 MB/s 92608 B/op 43 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 23043 52120 ns/op 19.84 MB/s 92608 B/op 43 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 285 4.233862e+06 ns/op 15.48 MB/s 5.893476e+06 B/op 84 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 279 4.254785e+06 ns/op 15.4 MB/s 5.893476e+06 B/op 84 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 284 4.177645e+06 ns/op 15.69 MB/s 5.893478e+06 B/op 84 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 283 4.225172e+06 ns/op 15.51 MB/s 5.893476e+06 B/op 84 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 284 4.190192e+06 ns/op 15.64 MB/s 5.893479e+06 B/op 84 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 284 4.19033e+06 ns/op 15.64 MB/s 5.893482e+06 B/op 84 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 267 4.401359e+06 ns/op 14.89 MB/s 5.893483e+06 B/op 84 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 289 4.19691e+06 ns/op 15.62 MB/s 5.89348e+06 B/op 84 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 271 4.336991e+06 ns/op 15.11 MB/s 5.893481e+06 B/op 84 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 282 4.261353e+06 ns/op 15.38 MB/s 5.893478e+06 B/op 84 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 18 6.5209017e+07 ns/op 16.08 MB/s 1.10928098e+08 B/op 359 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 16 6.4119783e+07 ns/op 16.35 MB/s 1.10928086e+08 B/op 359 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 18 6.3904657e+07 ns/op 16.41 MB/s 1.10928086e+08 B/op 359 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 16 6.3818774e+07 ns/op 16.43 MB/s 1.10928051e+08 B/op 359 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 16 6.4315706e+07 ns/op 16.3 MB/s 1.10928086e+08 B/op 359 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 16 6.4330359e+07 ns/op 16.3 MB/s 1.10928072e+08 B/op 359 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 16 6.4296497e+07 ns/op 16.31 MB/s 1.10928086e+08 B/op 359 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 16 6.4794364e+07 ns/op 16.18 MB/s 1.10928079e+08 B/op 359 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 16 6.4290026e+07 ns/op 16.31 MB/s 1.10928107e+08 B/op 359 allocs/op ++BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 18 6.5052421e+07 ns/op 16.12 MB/s 1.10928073e+08 B/op 359 allocs/op ++BenchmarkEdit/RenameSection_one_line/1KiB-12 19653 60606 ns/op 17.04 MB/s 91472 B/op 53 allocs/op ++BenchmarkEdit/RenameSection_one_line/1KiB-12 19838 60903 ns/op 16.96 MB/s 91472 B/op 53 allocs/op ++BenchmarkEdit/RenameSection_one_line/1KiB-12 19718 61200 ns/op 16.88 MB/s 91472 B/op 53 allocs/op ++BenchmarkEdit/RenameSection_one_line/1KiB-12 19851 60693 ns/op 17.02 MB/s 91472 B/op 53 allocs/op ++BenchmarkEdit/RenameSection_one_line/1KiB-12 19701 60974 ns/op 16.94 MB/s 91472 B/op 53 allocs/op ++BenchmarkEdit/RenameSection_one_line/1KiB-12 19495 60933 ns/op 16.95 MB/s 91472 B/op 53 allocs/op ++BenchmarkEdit/RenameSection_one_line/1KiB-12 19958 60714 ns/op 17.01 MB/s 91472 B/op 53 allocs/op ++BenchmarkEdit/RenameSection_one_line/1KiB-12 19819 60609 ns/op 17.04 MB/s 91472 B/op 53 allocs/op ++BenchmarkEdit/RenameSection_one_line/1KiB-12 19388 61425 ns/op 16.82 MB/s 91472 B/op 53 allocs/op ++BenchmarkEdit/RenameSection_one_line/1KiB-12 19386 61863 ns/op 16.7 MB/s 91472 B/op 53 allocs/op ++BenchmarkEdit/RenameSection_one_line/64KiB-12 200 5.925565e+06 ns/op 11.06 MB/s 1.0203044e+07 B/op 103 allocs/op ++BenchmarkEdit/RenameSection_one_line/64KiB-12 202 5.820491e+06 ns/op 11.26 MB/s 1.0203058e+07 B/op 103 allocs/op ++BenchmarkEdit/RenameSection_one_line/64KiB-12 206 5.833726e+06 ns/op 11.24 MB/s 1.0203054e+07 B/op 103 allocs/op ++BenchmarkEdit/RenameSection_one_line/64KiB-12 198 5.979629e+06 ns/op 10.96 MB/s 1.0203056e+07 B/op 103 allocs/op ++BenchmarkEdit/RenameSection_one_line/64KiB-12 200 6.009091e+06 ns/op 10.91 MB/s 1.0203047e+07 B/op 103 allocs/op ++BenchmarkEdit/RenameSection_one_line/64KiB-12 198 5.995473e+06 ns/op 10.93 MB/s 1.0203043e+07 B/op 103 allocs/op ++BenchmarkEdit/RenameSection_one_line/64KiB-12 199 5.953213e+06 ns/op 11.01 MB/s 1.0203049e+07 B/op 103 allocs/op ++BenchmarkEdit/RenameSection_one_line/64KiB-12 194 6.095935e+06 ns/op 10.75 MB/s 1.0203063e+07 B/op 103 allocs/op ++BenchmarkEdit/RenameSection_one_line/64KiB-12 201 5.925326e+06 ns/op 11.06 MB/s 1.0203056e+07 B/op 103 allocs/op ++BenchmarkEdit/RenameSection_one_line/64KiB-12 205 5.881998e+06 ns/op 11.14 MB/s 1.0203051e+07 B/op 103 allocs/op ++BenchmarkEdit/RenameSection_one_line/1024KiB-12 14 8.003303e+07 ns/op 13.1 MB/s 1.75181749e+08 B/op 150 allocs/op ++BenchmarkEdit/RenameSection_one_line/1024KiB-12 14 8.0758246e+07 ns/op 12.98 MB/s 1.75181781e+08 B/op 151 allocs/op ++BenchmarkEdit/RenameSection_one_line/1024KiB-12 13 7.8895688e+07 ns/op 13.29 MB/s 1.75181799e+08 B/op 151 allocs/op ++BenchmarkEdit/RenameSection_one_line/1024KiB-12 14 7.8704744e+07 ns/op 13.32 MB/s 1.75181749e+08 B/op 150 allocs/op ++BenchmarkEdit/RenameSection_one_line/1024KiB-12 14 7.959157e+07 ns/op 13.17 MB/s 1.75181717e+08 B/op 150 allocs/op ++BenchmarkEdit/RenameSection_one_line/1024KiB-12 14 7.955495e+07 ns/op 13.18 MB/s 1.75181733e+08 B/op 150 allocs/op ++BenchmarkEdit/RenameSection_one_line/1024KiB-12 14 7.9595676e+07 ns/op 13.17 MB/s 1.75181733e+08 B/op 150 allocs/op ++BenchmarkEdit/RenameSection_one_line/1024KiB-12 13 7.9909298e+07 ns/op 13.12 MB/s 1.7518173e+08 B/op 150 allocs/op ++BenchmarkEdit/RenameSection_one_line/1024KiB-12 14 8.0221386e+07 ns/op 13.07 MB/s 1.75181749e+08 B/op 150 allocs/op ++BenchmarkEdit/RenameSection_one_line/1024KiB-12 13 7.9051805e+07 ns/op 13.26 MB/s 1.7518179e+08 B/op 151 allocs/op +diff --git a/edit.go b/edit.go +index 3862ece..da3e2e2 100644 +--- a/edit.go ++++ b/edit.go +@@ -92,23 +92,61 @@ type flatEntry struct { + implicit bool + } + +-func flatten(p parsed) []flatEntry { +- var out []flatEntry +- for _, it := range p.items { +- if it.kind == itemEntry { +- out = append(out, flatEntry{it.inSection, p.secOf(it), p.nameOf(it), p.valueOf(it), it.implicit}) ++func (e flatEntry) is(k Key) bool { ++ return e.inSection && e.sec == k.sectionKey() && e.name == k.Name ++} ++ ++// flatCursor walks the entries of a parsed file, without copying them out: ++// the checks of an edit compare two whole files. ++type flatCursor struct { ++ p *parsed ++ i int ++ keep func(flatEntry) bool ++} ++ ++// next returns the next entry keep accepts, or false at the end. ++func (c *flatCursor) next() (flatEntry, bool) { ++ for c.i < len(c.p.items) { ++ it := c.p.items[c.i] ++ c.i++ ++ if it.kind != itemEntry { ++ continue ++ } ++ e := flatEntry{it.inSection, c.p.secOf(it), c.p.nameOf(it), c.p.valueOf(it), it.implicit} ++ if c.keep == nil || c.keep(e) { ++ return e, true + } + } +- return out ++ return flatEntry{}, false + } + +-func (e flatEntry) is(k Key) bool { +- return e.inSection && e.sec == k.sectionKey() && e.name == k.Name ++// sameEntries reports whether the entries of before that keepBefore accepts, ++// changed by conv, are the entries of after that keepAfter accepts. A nil ++// function keeps every entry, or changes none. ++func sameEntries(before, after *parsed, keepBefore, keepAfter func(flatEntry) bool, conv func(flatEntry) flatEntry) bool { ++ b := flatCursor{p: before, keep: keepBefore} ++ a := flatCursor{p: after, keep: keepAfter} ++ for { ++ eb, okB := b.next() ++ ea, okA := a.next() ++ if okB != okA { ++ return false ++ } ++ if !okB { ++ return true ++ } ++ if conv != nil { ++ eb = conv(eb) ++ } ++ if eb != ea { ++ return false ++ } ++ } + } + + // apply splices the bytes of the file, parses the result, and keeps it if + // check accepts the entries before and after the edit. +-func (f *File) apply(key string, splices []splice, check func(before, after []flatEntry) bool) error { ++func (f *File) apply(key string, splices []splice, check func(before, after *parsed) bool) error { + slices.SortFunc(splices, func(a, b splice) int { return a.start - b.start }) + data := make([]byte, 0, len(f.data)+64) + at := 0 +@@ -119,7 +157,7 @@ func (f *File) apply(key string, splices []splice, check func(before, after []fl + } + data = append(data, f.data[at:]...) + p, err := parse(f.name, data) +- if err != nil || !check(flatten(f.parsed), flatten(p)) { ++ if err != nil || !check(&f.parsed, &p) { + return &KeyError{Key: key, Err: errUnsafeEdit} + } + f.data = data +@@ -129,34 +167,25 @@ func (f *File) apply(key string, splices []splice, check func(before, after []fl + } + + // checkKey returns a check that the entries of other keys are unchanged and +-// that k has the values want after the edit. +-func checkKey(k Key, want []string, implicitAllowed bool) func(before, after []flatEntry) bool { +- return func(before, after []flatEntry) bool { ++// that k has the values want after the edit. Only the first implicitOK of ++// them may be implicit. ++func checkKey(k Key, want []string, implicitOK int) func(before, after *parsed) bool { ++ return func(before, after *parsed) bool { + other := func(e flatEntry) bool { return !e.is(k) } +- if !slices.Equal(filter(before, other), filter(after, other)) { +- return false +- } +- got := filter(after, func(e flatEntry) bool { return e.is(k) }) +- if len(got) != len(want) { ++ if !sameEntries(before, after, other, other, nil) { + return false + } +- for i, e := range got { +- if e.value != want[i] || e.implicit && !implicitAllowed { ++ got := flatCursor{p: after, keep: func(e flatEntry) bool { return e.is(k) }} ++ for i := 0; ; i++ { ++ e, ok := got.next() ++ if !ok { ++ return i == len(want) ++ } ++ if i == len(want) || e.value != want[i] || e.implicit && i >= implicitOK { + return false + } + } +- return true +- } +-} +- +-func filter(entries []flatEntry, keep func(flatEntry) bool) []flatEntry { +- var out []flatEntry +- for _, e := range entries { +- if keep(e) { +- out = append(out, e) +- } + } +- return out + } + + // Layout helpers. A token is a header or an entry; the whitespace before a +@@ -489,8 +518,8 @@ func (f *File) removeSection(name string, sk sectionKey) (bool, error) { + } + splices = append(splices, splice{f.ownStart(h), end, ""}) + } +- err := f.apply(name, splices, func(before, after []flatEntry) bool { +- return slices.Equal(filter(before, func(e flatEntry) bool { return !e.inSection || e.sec != sk }), after) ++ err := f.apply(name, splices, func(before, after *parsed) bool { ++ return sameEntries(before, after, func(e flatEntry) bool { return !e.inSection || e.sec != sk }, nil, nil) + }) + return err == nil, err + } +@@ -537,12 +566,12 @@ func (f *File) renameSection(name string, sk, to sectionKey, header string) erro + splices = append(splices, splice{f.ownStart(h), f.lineEnd(h), text.String()}) + done = end - 1 + } +- return f.apply(name, splices, func(before, after []flatEntry) bool { +- for i := range before { +- if before[i].inSection && before[i].sec == sk { +- before[i].sec = to ++ return f.apply(name, splices, func(before, after *parsed) bool { ++ return sameEntries(before, after, nil, nil, func(e flatEntry) flatEntry { ++ if e.inSection && e.sec == sk { ++ e.sec = to + } +- } +- return slices.Equal(before, after) ++ return e ++ }) + }) + } +diff --git a/env_test.go b/env_test.go +index c4f3ce1..780217e 100644 +--- a/env_test.go ++++ b/env_test.go +@@ -1697,6 +1697,16 @@ func BenchmarkEnv(b *testing.B) { + _, _ = env.LoadProtected() + } + }) ++ b.Run("LoadFileManyGitdirConditions", func(b *testing.B) { ++ // The git directory's real path is resolved once per load, not ++ // once per condition. ++ path := filepath.Join(tempDir(b), "config") ++ writeFile(b, path, strings.Repeat("[includeIf \"gitdir:/nope/\"]\n\tpath = x\n", 1000)) ++ b.ReportAllocs() ++ for b.Loop() { ++ _, _ = env.LoadFile(path) ++ } ++ }) + b.Run("UpdateFile", func(b *testing.B) { + path := filepath.Join(env.GitDir, "config") + i := 0 +diff --git a/file.go b/file.go +index 19d352d..a0484be 100644 +--- a/file.go ++++ b/file.go +@@ -102,9 +102,9 @@ func (f *File) Set(key, value string) error { + if it := f.items[idx[0]]; !it.implicit && f.valueOf(it) == value { + return nil + } +- return f.apply(key, []splice{f.replaceEntry(idx[0], name, value)}, checkKey(k, []string{value}, false)) ++ return f.apply(key, []splice{f.replaceEntry(idx[0], name, value)}, checkKey(k, []string{value}, 0)) + } +- return f.apply(key, []splice{f.insert(k, section, sub, name, value)}, checkKey(k, []string{value}, false)) ++ return f.apply(key, []splice{f.insert(k, section, sub, name, value)}, checkKey(k, []string{value}, 0)) + } + + // ReplaceAll replaces all values of key with a single value, or adds it if +@@ -116,7 +116,7 @@ func (f *File) ReplaceAll(key, value string) error { + } + idx := f.entriesOf(k) + if len(idx) == 0 { +- return f.apply(key, []splice{f.insert(k, section, sub, name, value)}, checkKey(k, []string{value}, false)) ++ return f.apply(key, []splice{f.insert(k, section, sub, name, value)}, checkKey(k, []string{value}, 0)) + } + // The values collapse into one, at the place of the last. + var splices []splice +@@ -124,7 +124,7 @@ func (f *File) ReplaceAll(key, value string) error { + splices = append(splices, f.removeEntry(i)) + } + splices = append(splices, f.replaceEntry(idx[len(idx)-1], name, value)) +- return f.apply(key, splices, checkKey(k, []string{value}, false)) ++ return f.apply(key, splices, checkKey(k, []string{value}, 0)) + } + + // Add adds a value to key, keeping existing ones, like `git config --add`. +@@ -138,11 +138,8 @@ func (f *File) Add(key, value string) error { + want = append(want, f.valueOf(f.items[i])) + } + want = append(want, value) +- return f.apply(key, []splice{f.insert(k, section, sub, name, value)}, func(before, after []flatEntry) bool { +- // Implicit values are kept: only the new one must not be. +- got := filter(after, func(e flatEntry) bool { return e.is(k) }) +- return checkKey(k, want, true)(before, after) && !got[len(got)-1].implicit +- }) ++ // Implicit values are kept: only the new one must not be. ++ return f.apply(key, []splice{f.insert(k, section, sub, name, value)}, checkKey(k, want, len(want)-1)) + } + + // Unset removes the value of key, like `git config --unset `, and +@@ -158,7 +155,7 @@ func (f *File) Unset(key string) (removed bool, err error) { + case 0: + return false, nil + case 1: +- err := f.apply(key, f.unsetEntries(idx), checkKey(k, nil, false)) ++ err := f.apply(key, f.unsetEntries(idx), checkKey(k, nil, 0)) + return err == nil, err + } + return false, &KeyError{Key: key, Err: ErrMultipleValues} +@@ -175,7 +172,7 @@ func (f *File) UnsetAll(key string) (removed int, err error) { + if len(idx) == 0 { + return 0, nil + } +- if err := f.apply(key, f.unsetEntries(idx), checkKey(k, nil, false)); err != nil { ++ if err := f.apply(key, f.unsetEntries(idx), checkKey(k, nil, 0)); err != nil { + return 0, err + } + return len(idx), nil +diff --git a/file_test.go b/file_test.go +index 1415a54..cb6a960 100644 +--- a/file_test.go ++++ b/file_test.go +@@ -1063,6 +1063,43 @@ func BenchmarkParse(b *testing.B) { + } + } + ++// BenchmarkEdit measures edits that touch many lines at once, on inputs ++// built to hit their slow paths; each iteration parses the file first. ++// Throughput (MB/s) must not fall as the size grows: these edits are linear. ++func BenchmarkEdit(b *testing.B) { ++ edits := []struct { ++ name string ++ gen func(n int) []byte ++ edit func(f *gitconfig.File) error ++ }{ ++ {"UnsetAll one section", func(n int) []byte { return sized("[a]\n", "\tk = v\n", n) }, func(f *gitconfig.File) error { ++ _, err := f.UnsetAll("a.k") ++ return err ++ }}, ++ {"UnsetAll section per value", func(n int) []byte { return sized("", "[a]\n\tk = v\n", n) }, func(f *gitconfig.File) error { ++ _, err := f.UnsetAll("a.k") ++ return err ++ }}, ++ {"RenameSection one line", func(n int) []byte { return append(sized("", "[a]", n), " k = v\n"...) }, func(f *gitconfig.File) error { ++ return f.RenameSection("a", "b") ++ }}, ++ } ++ for _, e := range edits { ++ for _, n := range []int{1 << 10, 1 << 16, 1 << 20} { ++ data := e.gen(n) ++ b.Run(fmt.Sprintf("%s/%dKiB", e.name, n>>10), func(b *testing.B) { ++ b.SetBytes(int64(len(data))) ++ b.ReportAllocs() ++ for b.Loop() { ++ f, err := gitconfig.Parse("f", data) ++ require.NoError(b, err) ++ require.NoError(b, e.edit(f)) ++ } ++ }) ++ } ++ } ++} ++ + func BenchmarkFile(b *testing.B) { + for _, n := range []int{10, 1000} { + data := []byte(bigConfig(n)) +diff --git a/parse.go b/parse.go +index 0ddcfba..06030b0 100644 +--- a/parse.go ++++ b/parse.go +@@ -93,14 +93,15 @@ type parser struct { + sec int32 // current section + inSection bool + secIndex map[sectionKey]int32 ++ headers map[string]int32 // the section of each header, by its bytes + names map[string]string // key names, interned +- buf []byte // scratch for values ++ buf []byte // scratch for values and subsections + } + + // parse splits data into items, or returns the *SyntaxError git would + // report. + func parse(name string, data []byte) (parsed, error) { +- p := &parser{name: name, data: data, line: 1, secIndex: make(map[sectionKey]int32), names: make(map[string]string)} ++ p := &parser{name: name, data: data, line: 1, secIndex: make(map[sectionKey]int32), headers: make(map[string]int32), names: make(map[string]string)} + p.items = make([]item, 0, 2*bytes.Count(data, []byte{'\n'})+4) + p.secs = []sectionKey{{}} + if err := p.run(); err != nil { +@@ -131,16 +132,15 @@ func (p *parser) addEntry(start, end int, name []byte, value string) *item { + return it + } + +-// setSection makes sec the current section. +-func (p *parser) setSection(sec sectionKey) { ++// section returns the index of sec in p.secs, adding it if absent. ++func (p *parser) section(sec sectionKey) int32 { + i, ok := p.secIndex[sec] + if !ok { + i = int32(len(p.secs)) + p.secs = append(p.secs, sec) + p.secIndex[sec] = i + } +- p.sec = i +- p.inSection = true ++ return i + } + + // isSpace reports whether data[i] is whitespace between tokens: a space, a +@@ -219,22 +219,19 @@ func (p *parser) header() error { + for i < len(d) && (isKeyChar(d[i]) || d[i] == '.') { + i++ + } +- name := lowerASCII(string(d[start+1 : i])) ++ nameEnd := i + if i == len(d) { + return p.errorAt(p.line+1, "unterminated section header") + } + +- var sec sectionKey ++ sub := p.buf[:0] ++ defer func() { p.buf = sub[:0] }() ++ hasSub := false + switch { + case d[i] == ']': +- if name == "" { ++ if nameEnd == start+1 { + return p.errorAt(p.line, "empty section name") + } +- sec.section = name +- if dot := strings.IndexByte(name, '.'); dot >= 0 { +- // Legacy header [a.B]: subsection "b". +- sec = sectionKey{name[:dot], name[dot+1:], true} +- } + i++ + + case isSpace(d, i): +@@ -245,7 +242,6 @@ func (p *parser) header() error { + return p.errorAt(p.line, "invalid section header") + } + i++ +- var sub []byte + for { + if i == len(d) || d[i] == '\n' { + return p.errorAt(p.line, "unterminated subsection") +@@ -277,22 +273,43 @@ func (p *parser) header() error { + return p.errorAt(p.line, "invalid section header") + } + i++ +- sec = sectionKey{name, string(sub), true} +- if dot := strings.IndexByte(name, '.'); dot >= 0 { +- // [a.b "x"]: git reads the keys as a.b.x.. +- sec = sectionKey{name[:dot], name[dot+1:] + "." + string(sub), true} +- } ++ hasSub = true + + default: + return p.errorAt(p.line, "invalid section header") + } + +- p.setSection(sec) ++ // The section is decoded once for each spelling of a header: files ++ // repeat their headers. ++ sec, ok := p.headers[string(d[start:i])] ++ if !ok { ++ sec = p.section(headerKey(lowerASCII(string(d[start+1:nameEnd])), sub, hasSub)) ++ p.headers[string(d[start:i])] = sec ++ } ++ p.sec = sec ++ p.inSection = true + p.pos = i + p.add(itemHeader, start, i) + return nil + } + ++// headerKey returns the section of a header with the lowered name, and the ++// subsection sub if hasSub. ++func headerKey(name string, sub []byte, hasSub bool) sectionKey { ++ dot := strings.IndexByte(name, '.') ++ switch { ++ case !hasSub && dot < 0: ++ return sectionKey{section: name} ++ case !hasSub: ++ // Legacy header [a.B]: subsection "b". ++ return sectionKey{name[:dot], name[dot+1:], true} ++ case dot < 0: ++ return sectionKey{name, string(sub), true} ++ } ++ // [a.b "x"]: git reads the keys as a.b.x.. ++ return sectionKey{name[:dot], name[dot+1:] + "." + string(sub), true} ++} ++ + func (p *parser) entry() error { + d := p.data + start := p.pos diff --git a/.benchspotter/sessions/01a120b8-cecb-7ce8-8e6b-119d836f987e/meta.json b/.benchspotter/sessions/01a120b8-cecb-7ce8-8e6b-119d836f987e/meta.json new file mode 100644 index 0000000..851ce9d --- /dev/null +++ b/.benchspotter/sessions/01a120b8-cecb-7ce8-8e6b-119d836f987e/meta.json @@ -0,0 +1,21 @@ +{ + "name": "alloc-AB", + "benchs": [ + "BenchmarkParse", + "BenchmarkEdit", + "BenchmarkFile" + ], + "git_commit": "9f097cd6b40f09dd20e5e00b92bd6ded3ca0f281", + "machine": { + "goos": "linux", + "goarch": "amd64", + "num_cpu": 12, + "physical_cores": 6, + "threads_per_core": 2, + "cpu": "AMD Ryzen 5 3600 6-Core Processor", + "cache_l1d": 32768, + "cache_l2": 524288, + "cache_l3": 16777216 + }, + "go_version": "go1.27.1" +} diff --git a/.benchspotter/sessions/01a120b8-cecb-7ce8-8e6b-119d836f987e/results.bench b/.benchspotter/sessions/01a120b8-cecb-7ce8-8e6b-119d836f987e/results.bench new file mode 100644 index 0000000..d833a78 --- /dev/null +++ b/.benchspotter/sessions/01a120b8-cecb-7ce8-8e6b-119d836f987e/results.bench @@ -0,0 +1,41 @@ +goos: linux +goarch: amd64 +pkg: github.com/git-bug/gitconfig +cpu: AMD Ryzen 5 3600 6-Core Processor + +BenchmarkParse/realistic/1KiB-12 98496 12082 ns/op 94.77 MB/s 23800 B/op 85 allocs/op +BenchmarkParse/realistic/1KiB-12 101469 12106 ns/op 94.58 MB/s 23800 B/op 85 allocs/op +BenchmarkParse/realistic/1KiB-12 99706 12085 ns/op 94.74 MB/s 23800 B/op 85 allocs/op +BenchmarkParse/realistic/1KiB-12 101668 12170 ns/op 94.08 MB/s 23800 B/op 85 allocs/op +BenchmarkParse/realistic/1KiB-12 104539 12012 ns/op 95.32 MB/s 23800 B/op 85 allocs/op +BenchmarkParse/realistic/1KiB-12 98101 12146 ns/op 94.27 MB/s 23800 B/op 85 allocs/op +BenchmarkParse/realistic/1KiB-12 100449 12077 ns/op 94.8 MB/s 23800 B/op 85 allocs/op +BenchmarkParse/realistic/1KiB-12 99398 12106 ns/op 94.58 MB/s 23800 B/op 85 allocs/op +BenchmarkParse/realistic/1KiB-12 98299 12120 ns/op 94.47 MB/s 23800 B/op 85 allocs/op +BenchmarkParse/realistic/1KiB-12 99037 12132 ns/op 94.38 MB/s 23800 B/op 85 allocs/op +BenchmarkParse/realistic/64KiB-12 2174 810528 ns/op 81.09 MB/s 1.396506e+06 B/op 2066 allocs/op +BenchmarkParse/realistic/64KiB-12 1722 816902 ns/op 80.45 MB/s 1.396503e+06 B/op 2066 allocs/op +BenchmarkParse/realistic/64KiB-12 1850 643690 ns/op 102.1 MB/s 1.396499e+06 B/op 2066 allocs/op +BenchmarkParse/realistic/64KiB-12 1858 633611 ns/op 103.73 MB/s 1.396502e+06 B/op 2066 allocs/op +BenchmarkParse/realistic/64KiB-12 1756 630631 ns/op 104.22 MB/s 1.396499e+06 B/op 2066 allocs/op +BenchmarkParse/realistic/64KiB-12 1914 636040 ns/op 103.33 MB/s 1.396498e+06 B/op 2066 allocs/op +BenchmarkParse/realistic/64KiB-12 1900 634445 ns/op 103.59 MB/s 1.396498e+06 B/op 2066 allocs/op +BenchmarkParse/realistic/64KiB-12 1982 620801 ns/op 105.87 MB/s 1.396498e+06 B/op 2066 allocs/op +BenchmarkParse/realistic/64KiB-12 1916 765270 ns/op 85.88 MB/s 1.396502e+06 B/op 2066 allocs/op +BenchmarkParse/realistic/64KiB-12 1982 599231 ns/op 109.68 MB/s 1.396495e+06 B/op 2066 allocs/op +BenchmarkParse/realistic/1024KiB-12 128 9.216998e+06 ns/op 113.77 MB/s 2.3731898e+07 B/op 32121 allocs/op +BenchmarkParse/realistic/1024KiB-12 100 1.103815e+07 ns/op 95 MB/s 2.3731982e+07 B/op 32121 allocs/op +BenchmarkParse/realistic/1024KiB-12 120 9.878692e+06 ns/op 106.15 MB/s 2.3731896e+07 B/op 32121 allocs/op +BenchmarkParse/realistic/1024KiB-12 123 9.716865e+06 ns/op 107.91 MB/s 2.3731901e+07 B/op 32121 allocs/op +BenchmarkParse/realistic/1024KiB-12 123 9.780195e+06 ns/op 107.22 MB/s 2.3731902e+07 B/op 32121 allocs/op +BenchmarkParse/realistic/1024KiB-12 91 1.1581071e+07 ns/op 90.54 MB/s 2.3731925e+07 B/op 32121 allocs/op +BenchmarkParse/realistic/1024KiB-12 100 1.0990645e+07 ns/op 95.41 MB/s 2.3731923e+07 B/op 32121 allocs/op +BenchmarkParse/realistic/1024KiB-12 121 9.874891e+06 ns/op 106.19 MB/s 2.37319e+07 B/op 32121 allocs/op +BenchmarkParse/realistic/1024KiB-12 128 9.467725e+06 ns/op 110.75 MB/s 2.3731905e+07 B/op 32121 allocs/op +BenchmarkParse/realistic/1024KiB-12 98 1.1610986e+07 ns/op 90.31 MB/s 2.3731923e+07 B/op 32121 allocs/op +BenchmarkParse/one_long_value/1KiB-12 168272 7172 ns/op 142.93 MB/s 7184 B/op 23 allocs/op +BenchmarkParse/one_long_value/1KiB-12 184128 5902 ns/op 173.67 MB/s 7184 B/op 23 allocs/op +BenchmarkParse/one_long_value/1KiB-12 212677 5542 ns/op 184.95 MB/s 7184 B/op 23 allocs/op +BenchmarkParse/one_long_value/1KiB-12 214167 5601 ns/op 183 MB/s 7184 B/op 23 allocs/op +BenchmarkParse/one_long_value/1KiB-12 214615 5571 ns/op 183.98 MB/s 7184 B/op 23 allocs/op +BenchmarkParse/one_long_value/1KiB-12 211438 5613 ns/op 182.61 MB/s 7184 B/op 23 allocs/op diff --git a/edit.go b/edit.go index 3862ece..da3e2e2 100644 --- a/edit.go +++ b/edit.go @@ -92,23 +92,61 @@ type flatEntry struct { implicit bool } -func flatten(p parsed) []flatEntry { - var out []flatEntry - for _, it := range p.items { - if it.kind == itemEntry { - out = append(out, flatEntry{it.inSection, p.secOf(it), p.nameOf(it), p.valueOf(it), it.implicit}) +func (e flatEntry) is(k Key) bool { + return e.inSection && e.sec == k.sectionKey() && e.name == k.Name +} + +// flatCursor walks the entries of a parsed file, without copying them out: +// the checks of an edit compare two whole files. +type flatCursor struct { + p *parsed + i int + keep func(flatEntry) bool +} + +// next returns the next entry keep accepts, or false at the end. +func (c *flatCursor) next() (flatEntry, bool) { + for c.i < len(c.p.items) { + it := c.p.items[c.i] + c.i++ + if it.kind != itemEntry { + continue + } + e := flatEntry{it.inSection, c.p.secOf(it), c.p.nameOf(it), c.p.valueOf(it), it.implicit} + if c.keep == nil || c.keep(e) { + return e, true } } - return out + return flatEntry{}, false } -func (e flatEntry) is(k Key) bool { - return e.inSection && e.sec == k.sectionKey() && e.name == k.Name +// sameEntries reports whether the entries of before that keepBefore accepts, +// changed by conv, are the entries of after that keepAfter accepts. A nil +// function keeps every entry, or changes none. +func sameEntries(before, after *parsed, keepBefore, keepAfter func(flatEntry) bool, conv func(flatEntry) flatEntry) bool { + b := flatCursor{p: before, keep: keepBefore} + a := flatCursor{p: after, keep: keepAfter} + for { + eb, okB := b.next() + ea, okA := a.next() + if okB != okA { + return false + } + if !okB { + return true + } + if conv != nil { + eb = conv(eb) + } + if eb != ea { + return false + } + } } // apply splices the bytes of the file, parses the result, and keeps it if // check accepts the entries before and after the edit. -func (f *File) apply(key string, splices []splice, check func(before, after []flatEntry) bool) error { +func (f *File) apply(key string, splices []splice, check func(before, after *parsed) bool) error { slices.SortFunc(splices, func(a, b splice) int { return a.start - b.start }) data := make([]byte, 0, len(f.data)+64) at := 0 @@ -119,7 +157,7 @@ func (f *File) apply(key string, splices []splice, check func(before, after []fl } data = append(data, f.data[at:]...) p, err := parse(f.name, data) - if err != nil || !check(flatten(f.parsed), flatten(p)) { + if err != nil || !check(&f.parsed, &p) { return &KeyError{Key: key, Err: errUnsafeEdit} } f.data = data @@ -129,34 +167,25 @@ func (f *File) apply(key string, splices []splice, check func(before, after []fl } // checkKey returns a check that the entries of other keys are unchanged and -// that k has the values want after the edit. -func checkKey(k Key, want []string, implicitAllowed bool) func(before, after []flatEntry) bool { - return func(before, after []flatEntry) bool { +// that k has the values want after the edit. Only the first implicitOK of +// them may be implicit. +func checkKey(k Key, want []string, implicitOK int) func(before, after *parsed) bool { + return func(before, after *parsed) bool { other := func(e flatEntry) bool { return !e.is(k) } - if !slices.Equal(filter(before, other), filter(after, other)) { - return false - } - got := filter(after, func(e flatEntry) bool { return e.is(k) }) - if len(got) != len(want) { + if !sameEntries(before, after, other, other, nil) { return false } - for i, e := range got { - if e.value != want[i] || e.implicit && !implicitAllowed { + got := flatCursor{p: after, keep: func(e flatEntry) bool { return e.is(k) }} + for i := 0; ; i++ { + e, ok := got.next() + if !ok { + return i == len(want) + } + if i == len(want) || e.value != want[i] || e.implicit && i >= implicitOK { return false } } - return true - } -} - -func filter(entries []flatEntry, keep func(flatEntry) bool) []flatEntry { - var out []flatEntry - for _, e := range entries { - if keep(e) { - out = append(out, e) - } } - return out } // Layout helpers. A token is a header or an entry; the whitespace before a @@ -489,8 +518,8 @@ func (f *File) removeSection(name string, sk sectionKey) (bool, error) { } splices = append(splices, splice{f.ownStart(h), end, ""}) } - err := f.apply(name, splices, func(before, after []flatEntry) bool { - return slices.Equal(filter(before, func(e flatEntry) bool { return !e.inSection || e.sec != sk }), after) + err := f.apply(name, splices, func(before, after *parsed) bool { + return sameEntries(before, after, func(e flatEntry) bool { return !e.inSection || e.sec != sk }, nil, nil) }) return err == nil, err } @@ -537,12 +566,12 @@ func (f *File) renameSection(name string, sk, to sectionKey, header string) erro splices = append(splices, splice{f.ownStart(h), f.lineEnd(h), text.String()}) done = end - 1 } - return f.apply(name, splices, func(before, after []flatEntry) bool { - for i := range before { - if before[i].inSection && before[i].sec == sk { - before[i].sec = to + return f.apply(name, splices, func(before, after *parsed) bool { + return sameEntries(before, after, nil, nil, func(e flatEntry) flatEntry { + if e.inSection && e.sec == sk { + e.sec = to } - } - return slices.Equal(before, after) + return e + }) }) } diff --git a/env_test.go b/env_test.go index c4f3ce1..780217e 100644 --- a/env_test.go +++ b/env_test.go @@ -1697,6 +1697,16 @@ func BenchmarkEnv(b *testing.B) { _, _ = env.LoadProtected() } }) + b.Run("LoadFileManyGitdirConditions", func(b *testing.B) { + // The git directory's real path is resolved once per load, not + // once per condition. + path := filepath.Join(tempDir(b), "config") + writeFile(b, path, strings.Repeat("[includeIf \"gitdir:/nope/\"]\n\tpath = x\n", 1000)) + b.ReportAllocs() + for b.Loop() { + _, _ = env.LoadFile(path) + } + }) b.Run("UpdateFile", func(b *testing.B) { path := filepath.Join(env.GitDir, "config") i := 0 diff --git a/file.go b/file.go index 19d352d..a0484be 100644 --- a/file.go +++ b/file.go @@ -102,9 +102,9 @@ func (f *File) Set(key, value string) error { if it := f.items[idx[0]]; !it.implicit && f.valueOf(it) == value { return nil } - return f.apply(key, []splice{f.replaceEntry(idx[0], name, value)}, checkKey(k, []string{value}, false)) + return f.apply(key, []splice{f.replaceEntry(idx[0], name, value)}, checkKey(k, []string{value}, 0)) } - return f.apply(key, []splice{f.insert(k, section, sub, name, value)}, checkKey(k, []string{value}, false)) + return f.apply(key, []splice{f.insert(k, section, sub, name, value)}, checkKey(k, []string{value}, 0)) } // ReplaceAll replaces all values of key with a single value, or adds it if @@ -116,7 +116,7 @@ func (f *File) ReplaceAll(key, value string) error { } idx := f.entriesOf(k) if len(idx) == 0 { - return f.apply(key, []splice{f.insert(k, section, sub, name, value)}, checkKey(k, []string{value}, false)) + return f.apply(key, []splice{f.insert(k, section, sub, name, value)}, checkKey(k, []string{value}, 0)) } // The values collapse into one, at the place of the last. var splices []splice @@ -124,7 +124,7 @@ func (f *File) ReplaceAll(key, value string) error { splices = append(splices, f.removeEntry(i)) } splices = append(splices, f.replaceEntry(idx[len(idx)-1], name, value)) - return f.apply(key, splices, checkKey(k, []string{value}, false)) + return f.apply(key, splices, checkKey(k, []string{value}, 0)) } // Add adds a value to key, keeping existing ones, like `git config --add`. @@ -138,11 +138,8 @@ func (f *File) Add(key, value string) error { want = append(want, f.valueOf(f.items[i])) } want = append(want, value) - return f.apply(key, []splice{f.insert(k, section, sub, name, value)}, func(before, after []flatEntry) bool { - // Implicit values are kept: only the new one must not be. - got := filter(after, func(e flatEntry) bool { return e.is(k) }) - return checkKey(k, want, true)(before, after) && !got[len(got)-1].implicit - }) + // Implicit values are kept: only the new one must not be. + return f.apply(key, []splice{f.insert(k, section, sub, name, value)}, checkKey(k, want, len(want)-1)) } // Unset removes the value of key, like `git config --unset `, and @@ -158,7 +155,7 @@ func (f *File) Unset(key string) (removed bool, err error) { case 0: return false, nil case 1: - err := f.apply(key, f.unsetEntries(idx), checkKey(k, nil, false)) + err := f.apply(key, f.unsetEntries(idx), checkKey(k, nil, 0)) return err == nil, err } return false, &KeyError{Key: key, Err: ErrMultipleValues} @@ -175,7 +172,7 @@ func (f *File) UnsetAll(key string) (removed int, err error) { if len(idx) == 0 { return 0, nil } - if err := f.apply(key, f.unsetEntries(idx), checkKey(k, nil, false)); err != nil { + if err := f.apply(key, f.unsetEntries(idx), checkKey(k, nil, 0)); err != nil { return 0, err } return len(idx), nil diff --git a/file_test.go b/file_test.go index 1415a54..cb6a960 100644 --- a/file_test.go +++ b/file_test.go @@ -1063,6 +1063,43 @@ func BenchmarkParse(b *testing.B) { } } +// BenchmarkEdit measures edits that touch many lines at once, on inputs +// built to hit their slow paths; each iteration parses the file first. +// Throughput (MB/s) must not fall as the size grows: these edits are linear. +func BenchmarkEdit(b *testing.B) { + edits := []struct { + name string + gen func(n int) []byte + edit func(f *gitconfig.File) error + }{ + {"UnsetAll one section", func(n int) []byte { return sized("[a]\n", "\tk = v\n", n) }, func(f *gitconfig.File) error { + _, err := f.UnsetAll("a.k") + return err + }}, + {"UnsetAll section per value", func(n int) []byte { return sized("", "[a]\n\tk = v\n", n) }, func(f *gitconfig.File) error { + _, err := f.UnsetAll("a.k") + return err + }}, + {"RenameSection one line", func(n int) []byte { return append(sized("", "[a]", n), " k = v\n"...) }, func(f *gitconfig.File) error { + return f.RenameSection("a", "b") + }}, + } + for _, e := range edits { + for _, n := range []int{1 << 10, 1 << 16, 1 << 20} { + data := e.gen(n) + b.Run(fmt.Sprintf("%s/%dKiB", e.name, n>>10), func(b *testing.B) { + b.SetBytes(int64(len(data))) + b.ReportAllocs() + for b.Loop() { + f, err := gitconfig.Parse("f", data) + require.NoError(b, err) + require.NoError(b, e.edit(f)) + } + }) + } + } +} + func BenchmarkFile(b *testing.B) { for _, n := range []int{10, 1000} { data := []byte(bigConfig(n)) diff --git a/parse.go b/parse.go index 0ddcfba..06030b0 100644 --- a/parse.go +++ b/parse.go @@ -93,14 +93,15 @@ type parser struct { sec int32 // current section inSection bool secIndex map[sectionKey]int32 + headers map[string]int32 // the section of each header, by its bytes names map[string]string // key names, interned - buf []byte // scratch for values + buf []byte // scratch for values and subsections } // parse splits data into items, or returns the *SyntaxError git would // report. func parse(name string, data []byte) (parsed, error) { - p := &parser{name: name, data: data, line: 1, secIndex: make(map[sectionKey]int32), names: make(map[string]string)} + p := &parser{name: name, data: data, line: 1, secIndex: make(map[sectionKey]int32), headers: make(map[string]int32), names: make(map[string]string)} p.items = make([]item, 0, 2*bytes.Count(data, []byte{'\n'})+4) p.secs = []sectionKey{{}} if err := p.run(); err != nil { @@ -131,16 +132,15 @@ func (p *parser) addEntry(start, end int, name []byte, value string) *item { return it } -// setSection makes sec the current section. -func (p *parser) setSection(sec sectionKey) { +// section returns the index of sec in p.secs, adding it if absent. +func (p *parser) section(sec sectionKey) int32 { i, ok := p.secIndex[sec] if !ok { i = int32(len(p.secs)) p.secs = append(p.secs, sec) p.secIndex[sec] = i } - p.sec = i - p.inSection = true + return i } // isSpace reports whether data[i] is whitespace between tokens: a space, a @@ -219,22 +219,19 @@ func (p *parser) header() error { for i < len(d) && (isKeyChar(d[i]) || d[i] == '.') { i++ } - name := lowerASCII(string(d[start+1 : i])) + nameEnd := i if i == len(d) { return p.errorAt(p.line+1, "unterminated section header") } - var sec sectionKey + sub := p.buf[:0] + defer func() { p.buf = sub[:0] }() + hasSub := false switch { case d[i] == ']': - if name == "" { + if nameEnd == start+1 { return p.errorAt(p.line, "empty section name") } - sec.section = name - if dot := strings.IndexByte(name, '.'); dot >= 0 { - // Legacy header [a.B]: subsection "b". - sec = sectionKey{name[:dot], name[dot+1:], true} - } i++ case isSpace(d, i): @@ -245,7 +242,6 @@ func (p *parser) header() error { return p.errorAt(p.line, "invalid section header") } i++ - var sub []byte for { if i == len(d) || d[i] == '\n' { return p.errorAt(p.line, "unterminated subsection") @@ -277,22 +273,43 @@ func (p *parser) header() error { return p.errorAt(p.line, "invalid section header") } i++ - sec = sectionKey{name, string(sub), true} - if dot := strings.IndexByte(name, '.'); dot >= 0 { - // [a.b "x"]: git reads the keys as a.b.x.. - sec = sectionKey{name[:dot], name[dot+1:] + "." + string(sub), true} - } + hasSub = true default: return p.errorAt(p.line, "invalid section header") } - p.setSection(sec) + // The section is decoded once for each spelling of a header: files + // repeat their headers. + sec, ok := p.headers[string(d[start:i])] + if !ok { + sec = p.section(headerKey(lowerASCII(string(d[start+1:nameEnd])), sub, hasSub)) + p.headers[string(d[start:i])] = sec + } + p.sec = sec + p.inSection = true p.pos = i p.add(itemHeader, start, i) return nil } +// headerKey returns the section of a header with the lowered name, and the +// subsection sub if hasSub. +func headerKey(name string, sub []byte, hasSub bool) sectionKey { + dot := strings.IndexByte(name, '.') + switch { + case !hasSub && dot < 0: + return sectionKey{section: name} + case !hasSub: + // Legacy header [a.B]: subsection "b". + return sectionKey{name[:dot], name[dot+1:], true} + case dot < 0: + return sectionKey{name, string(sub), true} + } + // [a.b "x"]: git reads the keys as a.b.x.. + return sectionKey{name[:dot], name[dot+1:] + "." + string(sub), true} +} + func (p *parser) entry() error { d := p.data start := p.pos From 3c173a8c04fbc1e2d960cc039c9954b6f2407c72 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Michael=20Mur=C3=A9?= Date: Fri, 9 Oct 2026 15:10:23 +0200 Subject: [PATCH 05/10] address review comments --- ...\232\227\341\232\227BenchmarkEdit.profile" | Bin 0 -> 31944 bytes ...\232\227\341\232\227BenchmarkFile.profile" | Bin 0 -> 37557 bytes ...232\227\341\232\227BenchmarkParse.profile" | Bin 0 -> 49206 bytes ...\232\227\341\232\227BenchmarkEdit.profile" | Bin 0 -> 7096 bytes ...\232\227\341\232\227BenchmarkFile.profile" | Bin 0 -> 8534 bytes ...232\227\341\232\227BenchmarkParse.profile" | Bin 0 -> 6984 bytes .../results.bench | 424 ++++++++++++++++++ env.go | 10 +- env_test.go | 110 +++++ glob.go | 68 ++- interop_test.go | 5 + update.go | 20 +- 12 files changed, 617 insertions(+), 20 deletions(-) create mode 100644 ".benchspotter/sessions/01a120b8-cecb-7ce8-8e6b-119d836f987e/cpu/\341\232\227\341\232\227BenchmarkEdit.profile" create mode 100644 ".benchspotter/sessions/01a120b8-cecb-7ce8-8e6b-119d836f987e/cpu/\341\232\227\341\232\227BenchmarkFile.profile" create mode 100644 ".benchspotter/sessions/01a120b8-cecb-7ce8-8e6b-119d836f987e/cpu/\341\232\227\341\232\227BenchmarkParse.profile" create mode 100644 ".benchspotter/sessions/01a120b8-cecb-7ce8-8e6b-119d836f987e/mem/\341\232\227\341\232\227BenchmarkEdit.profile" create mode 100644 ".benchspotter/sessions/01a120b8-cecb-7ce8-8e6b-119d836f987e/mem/\341\232\227\341\232\227BenchmarkFile.profile" create mode 100644 ".benchspotter/sessions/01a120b8-cecb-7ce8-8e6b-119d836f987e/mem/\341\232\227\341\232\227BenchmarkParse.profile" diff --git "a/.benchspotter/sessions/01a120b8-cecb-7ce8-8e6b-119d836f987e/cpu/\341\232\227\341\232\227BenchmarkEdit.profile" "b/.benchspotter/sessions/01a120b8-cecb-7ce8-8e6b-119d836f987e/cpu/\341\232\227\341\232\227BenchmarkEdit.profile" new file mode 100644 index 0000000000000000000000000000000000000000..1d4c7d41326379eaf6f99d442f4938f666c9a704 GIT binary patch literal 31944 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 z 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

=#5zQWw2v`NZ5ZTPVTpJq@p@fNP;3^z^fwQl2Cw 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 literal 0 HcmV?d00001 diff --git "a/.benchspotter/sessions/01a120b8-cecb-7ce8-8e6b-119d836f987e/cpu/\341\232\227\341\232\227BenchmarkParse.profile" "b/.benchspotter/sessions/01a120b8-cecb-7ce8-8e6b-119d836f987e/cpu/\341\232\227\341\232\227BenchmarkParse.profile" new file mode 100644 index 0000000000000000000000000000000000000000..730353b727a4495ad62ccb50202ddb10461a7b59 GIT binary patch literal 49206 zcmX6^by!s0*QEvqkS^(xE~O=g?(Py05kb0y0frh7q>&U57(gVXyHi?9I)oubLWYu| zzx)0^{@~%^%-p;0IXl)~dtK%@FvfpBI1iD*{%MRBUYBJ-?KdWuPO5XAKeZG5mfWnV z_kthyzk0+uytp_RW?^3Qtaos+f(Y03>7e+_tqX45WL5TrF9viw1{2SJfA;zBSGSM* zWpK6Cx1Ae3$Jy$es5X=CYm*jRr#0a>-}`oas%soslTrL>uRE`x6N_07cZ_$(-PPH! zKEoZb4AeYVpBgJzWr=%FoOD|jr*4TjcP{~kPcZ5w=vz3B0E0*>%P2-wHGINYY~d-% z&wPtE5MU0HEMxYx1ZwM%KMzgA_CowIx;vBw10}ojV22_dJuUDlhm#SXJ5`2qi56wS zxIl?2fkTlJ%}3x8#OdB|&B=9?RrWla)runPo~d<$6uNMHj0YX;4xDhg`xq8XOtc)> z4Sz$a)xT3-Pd{)gZu=0H7uQV}=PGuu6o*AjCG8Tb?45Sz%^5E3O}}9o&P1pQp$H3@ zb#UhBWb;D0bBw7oru4w4Od0z0?iAP4BqlEW8+<

JD~%*H0AI`b}puR-$&MxhU=U z@>-pvjKwp4az7c)e92?tsWLqM)Ht%Z<6?uZz?Hu!;>3TfG=;C=P_@9- zmGM{`zv(N@)j*B4F9=S6RSs8QN=n4kAvAV;O<7^R&Hq_xtLmp*1tQ`V|56J0!& zlt`eWE;GwNNUcDMb1qhHDbtX8UL!_jv+48eY3FN5LSp8Rl1o&OqTDiJ>{H|k(MU=q z9z0B4e=gjlD)S6mB#{Q)HxpRk`e-jqD_N*F%w{*U->lG}ip{nE+s!PY!xmw~D*JFI zl91B-aZ{3RdpXw1>0Mm^`?^}91fTQ-x3_w zzVO$LY;@3j-~JCt#>@>mc;lw%%#h3!m3l85Syv06AFM7%kf8AT%!)*c6=*Gt#lHOm zO@$au@MB1HD3>d<8)+;`1=7(TtuNlCToMjA zjnH&7TFLHa?A{;5HCF?NmA(w3ru?6e@IUer~T)+Ol))S>S3cssQYZ{`B$Lar99UrXpEa zrka7Mz|G)jt5$}#sKC^v=&diJf@)MhD$xxYFWzhx0%9G%ZcZSRb z{IK+UOXfARKO|_9K0VcS{mPR&*uH9`K6O`;;$8l6k={v3pPt$gYw>I-6ErHA}ROLac zaPrg<_rCnY-qX+ru;KH7+I^cB+dr9b|KH}-m`eY%=L#xifiVUL}&K3EO8Rj$Q zXvRW2O|pC9YTBpf-1Ktl34(yf$*JdWO}-B$CsI;DvobYwt8mkYM(?}c9jq6~?Z^?W zGaog0!2Wnd>bn5nd%1&3CM8)@zab`l+NSg{kEa zDQE4q>J5V=XCrsHk##8lKlV5QB%zs*$$XLr8E+GpTkz$tMFVa^IqiI|;UKi#HC8C= z?JMP2)VsXKu2g;TkVxlnmg5bzJ+0efRNQp6vCA#@dgxCbUc!&}nJiBBzIr3ka;Mj7 zae=5y^b3> z-mz&T0TBq-*qFR%b5h-tK<%!0U`*63&ReAO3IKapsg161KHa6z4?us(Wf;qzz)< zmi9>?S7mykUzJF!%|Q3862$){4LJlwV%B>rOJ6?~~FH)yU#dp-hNQqsUTzYwY^x6KUXVrfPdG>1)aX**yQ?NR*0&E#JG zRerx&QGXNLEg_TiH&x)!^o(9f5KZrS3g4eg1k|;_SMeb)8T3oCfYn{Xc8^FTR*WWxs1Z?)2(C?Ve z_bj$Dg;Q-MtQ66iu)oTcKx}<X&U`B_g&QOL7F~kNNV-M0U0c&Y7lj*b?$NN zu`yYsQVQ-KxYOm#so`FW^zfO<>jgHDMwIM4`2l{P`yhL(GK)>Q;SV+Op=0cL`Sk1M zxJU4fba)ne9hFxZZ#C^P{6|z+sXw( zl7WcCg)tSsN;aky8mL~ZQx5X z?!Hjum68h(q%I9?)a%vLp=Y7da!GqH69*&xaFElOFGkE$!w{tQZF0Q10B|4(tT{GY3qa>y|j3XbuOE;eb57PZ5 zMn3rxCG;osDzv}3$dm9FMy(et`p>Eu#l*HoX zXq^3!^l%=*obhm$6mm;(B{YK1d243VP?QhYk`tIowykxtG7D-UjASevD~?5#top+K zGc#Is_dhck_X$?10C+<7Tm>z%=GXAQ2uc_xE1gGs!2T|C1Kv%4tp|tk-O}<`hal zPm=(-_PIyf0+95z_SA4NDfH*IDKZwW=Po-RY(p*Y>$}mX-FGre9ihLU?IN^s;Ve&m zydGp52fC3n7=HOl?Cn|HgL=l3 zpf3-pj)%IsPQm~BAF@&^A2!)n$lq$~vKY>_4qgVKZ3m)5MyzpN4sSrqkB_ISTO9J% zSaYPB*}%)$(+$@<)xu2M)d4p%?uJVrX7L;DMNq#NR391#A9g?blQ*ODMOgN`Q!#Hz z7U*x^4RU}-A3^FKN_4D<>O=a!={j+5O}+TR{dpaBQ@N>qpPAz~52P*svgoP0Q|oe2 z)q9lVw2pqH$60zqNfzAr;l}T@>|v{(FqNa7p`CD~1oaTBWeS2VET%J4a5GC|kvx|$ zHCJr=UNrQuWu%tF@e;||6ZSf6G^a$8X19x1X z!37c}UYipcuw}<(c%CHS16E5u;NVDRDO$K9ZIcAeM~4J^2%CKYNO3$<1KnIN!A0VN zyC1)!8Xc!cOA_8wUy_&&Lv)zYIz6Gk*eHQ+1=;qo@0L!Z1A zqEeK(n5P*#Kcf{H_aGh8g#BDdPC*v2r%XLiO6OXFOWvbqPT1kA;sHRaIEZ4h$9oS0 zA*2my7h|X1l{p@4w6yik9TzmG$Vlm{>dhZ~NGvlaxyYpj##;YC=@p?w#Ti_a8R> zY==LX7c37uV;->a3VS`I)l3xFVT)w10LamsB&E!ra^P+XS==3aY*Yij5>Pp!eHs39 za3yCfcQ{Jgz)U~BGwe6y4=Zq6?OgdKH2ZQM`*3q#=-2z6JJws>bGa+STQVXHCJeiq zQqB_CAyLQC|3gqEQtm-jq}Vg-Q+qnP8IIp$|6SIe4lG03_ivh1qV%b#j)k66n9UUZ z+KnN*Q(F;<=TPUIp#_>EP)lowQUll~xdMfr2$oxo^E;NOu{}rF+kqnr$Aqvsw72aX zvBf4h{rr8Q(%>Qq)K44po=_}oUg;9(1&h%_qK~0ZBi(0Z1@!J%R9vqXaXQ+0KmMDr zI9fDL_8h$L33h4ByD@8f%|{=q>9R?5ZRU*Y9)${;R*|-ik}GEIQDR{rFt9D)^~6B^ z*rx-6nYOds^|txb3C}?O^i!lADRJ~(CvXB1beJ+&eFda*ggaaENcv_mvkM<*-Z_H( z-=gHuCy~`EB$hmb3O&|?V!)<%&qSDx4%+J5Mzh$)KIj&OsVSf>eY;J%C_@zldIU)C zS=xlslOn=tE`GAy%aumYdfb!H5y{Z?F)KU1Kdq&OzPtR-tM#%eCr{@YfH z*YjgOU836 zj~dt-=4D=d;P~Z4@uB3A$4P@@X??UHfv0qXJ?4+`wiHZ|ILNXijCB7{_FC@EtDfJ`lH0vqhn}~27$OL9y2fKnu^D9q>!r!a4j)9F#6t;-hDgu!bJVjZ8Tgm$HocF6O)e%qfuyi%%%?!#9^`{ zMsp7%Z(5&{?Dk`sn@es&1hH(SAkXD;Y@UFJ`L*21;@^|pPedDs#f6g`IgyU`S|Z$1 zfUR-~&%h80_vBID`a7)LK-45ztKf{*GNw-q6_}Y zkA-I*L`Q`ac+#TEG%ggMFJe2r;8Ey$6ogTUVS@>90)BiuTi(b5_Va+ZYMEN+qtzIY zPCnLMp+OP7$Qj#5S}%F{BX*|TK^?PA9g0^iSNKTrN!m>G~iW{nGBF9>g2v^KwdJ_Eze;^i}{!y9qm7ynAbSioGD zT2$i3qYtxu0z3kJm??I3R86okUwYC(IE{x+Mx_sfljhn%Rm24fYSwT+ng zE(JL{jQ(YCM>(cD4kT3T*jfmo0<`1(Hu5fE3-V}9QR?)hoUr^Cb3vEl?^Lj;kZ+J# zO8bBpN=(g?!(p`la4iWtsDU(3p$BRKLFdF|;i`zUTJ{BS12L2_@~Eh>iNKQ&6+zz* ze1~MpNUOVqWGWDOLE4m*XU^N>))O?be|ZiHB$u0^al%I7f>+ceiU~ZWQ5nx0fg>R) zEp80alS3r*(6inK7%y0YTCkyOopc2Zu2}mFNhSDB6evz`D3f(F<%TX&@RH*AUW`fim#geG1on41%QUO7&oi7uKgu9Whn=ADEzo;<(0QusfN<8T1X3u}R(kDy1pd5X^^AC;QP zp6pf}MEWazp$q5vi9K*?Li!g2cU3{)j@Ba=Gr4cIlPpakfBpW%hD^04xT?2%mf z|ujaI9KzM3{K1_2$-Ig zj_0(}3uh_>d6)f(_K2H#66=_`GW%{<5Zz5e!u?*t1~Rm=F^+w+OOEs)T$t(zOXnecrv&=`>yq!$`Om+#{j zbfIL>;afpNi^W(erzVbP3jb7`Oe`~`yqG5tJ6b(PG#n!sLv@;H!_k%QN3gE1s!q0L z7Nj^kQQvqvZ{t@yLFm)kK}p|ZM>M7ZE(VPC-Tgjbk;zi+JJo1Ry13T%dZP&-U)1&ju z;12B7A?+Pw4b|db&)P(K+Iw!?opOF*iH@@YMS~il)Dz7j^Jto*466gL!_h;J%%xmc zcd)XJ@G|fD^ksNEe_6(IKsQCZ$8m9at;As1?=_)A@hxm*3H$l8N%H3dA}9!;~Fgk##BsM&%NktOswGr+hUn3a5Fnq=mtw|5@6P}_)iU7E# z$*Aj52}UjmLI~VKTo1Hpf%C4#rC$~42`J|8kQkaMEsP`W8r7fh_0aW}%)jLqC31rCQ_qA=VCP4pu#~qHuFUz+ z@i7AoeLr3}D_44Y?`}cn@!g+o2apWM*Xe%7@U{QQc_;|YDhPP6QMzS<>t!JajDTKR ziNpBayZfPzl)r`1+``Eh@Pm0SHSPKmp{Zj-lbJ6O$kvPZptIT%Paxu8 zCP;^eZD01a~7AH3_TS<~Sw73hN z^m;P_^SSYy&zM%;irM3zH4HcS?jb+NaU4=bi_(&&Ci!R1;GCwKVrH*Wkve*fvDugn zcxefkNB;Py4wBe=!YBuDDD{!%5GY$Yrz!j2p%7HxzL7R6foUA?D3N1p_=4t5JuWy; zRygME{A8%nhN znBj%6{v&eA>i4H!HORP}lpRL$v&)#EKg85&!)U%me(3!wK#qO}otrppxgxst#oHRp z_tLXKzC>uc$OYDG&8|m|*uOBkFgM#C?diwyU`YF3l7R_;oED@}NrU1i>{*V%PM{}>5Y(VL$r7w7M?$RqBnT~y)cQg01=+DNaJ7t*)>2tgB+}dtSD1D`#^?NIBBdLzSDBeafm1F0 zWh?(I?B4Prun@`EzaLp=Ftr0U;=*5>YS-n)`;A>m`d|NZ%o zP+CM>*kGqFfSOd~FT;2 zrKG~n^6wV#OOnU@X%S;#xV*Vv7btU19ORS2ng6>r0&bS@qFYj-;X}-;lu!I$Ka{=7 z{v`P3L+w+eALPu2RFYPxc*vyDOASL+_ofdH{X@^;C9^L3CtAL^jWZdDTT`F!&9P)= z%)be`T9xFktjiM_^8?^!RG-pDIBtl%=e_DOPi9gC2~x^9s%t*u((fx_FcJ7Xzt;br?Kxe1 z9FBj$Q%!DqGmJ(f@!dTs((N%%(3BCfgw!}9g@G8cf_XixeMcZ@cb{aSa z0;fQkCKLHw9Di~Eqs1VwUI?Op#6o}-I;VFP_omqIs8=l_^W#k|${DLjVU`=C z7UEJ%&qnZ#qUeGtq>3EYnB@1}1~LAuKEEZqc2D&F8d76m|#6~&wAyrhcok(KV=M6Hu`#^eLdch9dAe=bW=JY~d4DO}g3kI3!{Pt(F?3 z4POn*Eg!x_{C1_xQ5GrHT;)giR4wCt`Wz<8u^Lt0rhS)}xx&BZKGW2}2J-&-hJRq# zjcj!sda9;^%j?Fo7|h&E;Qnb*jhkKqI~W+($L56ZgBIdYsnfsHl2&l?TTK9DZWRWp z$X~>oHSz?wa;d;-=jauX?cw~Bvop}PF0=t8pNmp5b3Jjkg9b$wZ^ScAg zp6$%YB`Hq&xmS5$-IpSiWp|s2E5*tH@yG8quvH%P2h4B3o`je8Si?Q!et&M}NGdly zysKGoE_qDQ9v{xWDgccdxx1;_g=}IxBT%^3*!W|j(s-FK@$*7?HE!AxaTGw$OvZCAk8PIRYt;^^Zj|B4!K*^( zf(^C&5#>c8a_03RY}i5GKkO-BNbhQA2@(0pujHk+>W( zPg)$5QbcuVpZIV`a1#@**$clBoxdc?jffstaidcZaZxi?rDUGG#<0+ZoIw-vZ~3^lkFa-cp)(nYxR*~5oK4?3^8 zgH^F3x8Pid8swjS-zcf_N?*k58GZ5`vWzRrC1R zW@9H`kRy|4Pva%L4PV}h4L~(fGuZ%XwF)}VdiB$l=P%YiUrRMOcW;KbX9liUDGvAT z5T)3IaCDj97tg3XW0he?hmp;P&fXfn>KvVr;WKaqT|QGr;{#JtH_uKV)4dc*=1Kg# zr!TZL6!ud_kk6<84rIQ{xa&Zk(c&Gx@B8RGN$4$GxdRpg+qiuBGY~IoJ*+;X(mN(h z-O=JmGb6q-qy?AAK`WNH!Zr-ADb0`$y>q|571yC0u8Vc!7kFAzQz=R$)(erWl5qfsPraEPgVslY%NBB3wW zd#Akkq;L!Y>kvf4xH`Ax3fo(MkaclZ#VKMXBuU`tiS{N$nJaKn@%$ySX zA&DEl{mQLM=7A5XVJpas#>X;=X$DO~%BJU;5LF1*Tee>x0~dqBt_lAN^<|O1)4fq{ zR#wzlrw&aQ=Jdz0E!8|7lo}FL+pKEwk7U*4MO7hpmtSYT`YpLsyj}78FG2mMOPuPQ zXY$;5msklmlt9tC#3CY zzze)rTI~9|&7O~*ugvk0GzlgVnT#?(!KziHEmfzazZY3II3=L?QRXl5YT4k;gcH|@ z+0SPQX*IqnlQFjFMT=9+RN`!~)+u3g{deVD^rFgX=}Pv#gx|g_Vk@$32C4{HfsZfG`~K^T%g* zMTu6HZw2KXBoc|^>Dvx+kadVSX_pB!3CIhIw5=6Je#BvAG=L3QLz;?t8aYeEz_LZ1>Y>2^dP6K=hP1>Oaf9Hl1( zKbdSb29o(u*e1hQdwF(H66FRrSuH_L^|oMp!;B}xp7Q4(-VCKGo^jwzMPKc5j2jK6 z=2``AJU#gz-x~)h5%;lBJD3WIF*4`Uz#d58^hF22Wk&M$pd>1w?AtY+ zdLg#Ee69%`?1KWqI12PiOzDr3v5R9bHPW|OMuzfyXDU=skm#^@6d+bscd|k+E9qU`+Ea|k; z%EamYuSeg~3SK1^==>dM&?tPcB+BHO=o=zSIj+*#r*8bppVvwDr(VMF6ft==exsXycnTS88*9X^iXoCJB?eG7##J6FOo zc%mApCuH~h%eLeV;@|$nr~GfAAdqrQq#={SVUhGjCFEhnXnFI{%S5EoL)_11?71y7Xt*<0az2ka2X*RV>w~JeA>vY)D z%)UG>D(FslM#mMf<})1|u-?+AHl&s3%25Ao$>DLnCGO4^&d5r3IiSHSsZaL$!8t51 zlyT}+xJ@+qsb;%qP5CXg$(5wWX`>E)`?3i@rEqDjNolr=LWtrbns!T4x3@RBzN$0j z2xbu|p1l~Le5;w9Co5>gkuPP-k(Tf~9HI@J{+WC#NRN7hk}O!AOgDAa#fUeceb`PX zeP;WBo%I7vC3%S!#GqQ|2!!Cvr~_~?KK^Ot3D%TxuaSzRjxtRpCHhkyE_1xdlj`fE z`;|u)<`r2fC6B=}#;+UtfBa@ow@5j@)YNs>q6Up?l04~IO39p@)<0*{w>~_x!O0ec zwt=OU-{qZpC2qTwh&7(9HxzaX@@eRniC9g11bT5vv(weu7^p8Nst z|K^c6^NiZtylwlhP-tMhQc8Vx4p(Q2WHI}dmPUH~+1st}nO7;9x%;eX5t(7T!;-&T zzp5mABxHuY0q3y-qrx{DR7k9mqJ^Bt2Mw+^|6r~1U)f3(IMVg!=B}8}xD%`!f1$hz zwx^pPwYlVwtyNcjqs6SNYZ2?sz z(AL~nt?>~Od{5*OPx?&|9ZW+eh$XnA%Pp#$z_WOJWJOf86qL=4ZyfgRiO1qkmb8e4 zFhPRg`6|qDG8wfdW+MrU3;jbCutB)u88}l7D*3OpTNL=(E^xM^AwW}7ZQE ze}1h>f79B(B)898&kV_?xWs>DOrC29s>}8R^7ij2pn~WiqB(%>xC39*76l{gqO;~T z!2FvE+poo~HwqI>e@*`GKc(HnyK4S*u6Kh38zCbk;+zb7X2RL8Lq{#sw=hSPm|WT( zuC73MPdE>52$<4ffuTxGD7EKMLMLd2nFpo-X@`7%>l>{rsQM{_NowsTUsTCyCHbk> zgo7kEiH1pHG)GdKo(GyD4MxWD;=EIe(xiE}-d;hq zPY<8rGd3HOe_0MZ88GDgfNX{=D@bFxf` z&*|c@BwvAmiO%s|QeF_-J5oK(ycacW$K!`A|fQsezn`)b1G7Y;R%!B3vk8tq|`vy3$wa{CpGeFS;>0%@k0eU z!Z7nPVSai48r-oH;*>&~!>I{u09~DOkpc*+a9XH6tY@;RGE(y9Tp$V!s6c-!h$M}i zTjplcY^zx8dHZObG8i>o`{O7`_lsO*zWyOh&Z zIYk7wkNUDqAZs6GRvB8zPQtai{;cs-7>D_DBnf;HI_jnzOZ_|QpT-4(>YaWZ07i6B zno@{6ktdB)EpmVj#&O;19DT__0xi?|HSkpEm|&Cxg4-(@S*e+ka9Bkh^k2&tI`m6%K?8>ito{%l zW@$@U|I>!Xli8GrB*w~561sojtbexc`*f)F`bGyarcn$YZefF1}i^>KJW2=r8a8H*xhPHx!Bh?;0&WjHu8MNQhD}1FZ zYN6M@M@lld%hwt^NE^hn{GaqUkDZE<>1>CjZdYFjYUVc?MK0>~!l(x(WiTx{py@!d zJCiGhRn)hPJ<7E{#mqJ@n>O>0)3XM|zP%;#cWEIPMu<7MSsXx}SQXdtxl~wwn+Oz; zGxBZr)pQ|=D>>91#>y?RJVyta@3MR;t%29)By7xDb@bFc)2qY(b788<2|IjyGFNip zRl5`}+2GWpsmF&uCvFZC{Cb*vFQK$4W)6tuYw2gkHe-S)Dn&TvrD7P`I{A5J=2td# zy_!LpenaH0el^YM9Tiyg0$o=xbfy2eWV$qL(wM$tj!U8>=b0!b=ZRG-O1khn{B*Ur zu<4N5P;JSG{8A^k~sKmck8JmgoC-ZVT;trsxZuSxyg zP4G~1gEY>=U0Z(IOr)AV#ZVeT+}N__oBtxidc8nZnAhvm03M-x%i7=XL_$*W{jYj2 zyjlj#sGTG!BrdfB^!vx@@zu;bM&!R7yL?Fd(Z_5zuwV4S?6I0D_t0;(^F;)TNc*^fGwrjc zv86}MlC)9v=~1PB#=&5J(uXN^w@G*|tEnb2XzoD`2ytqu*FPZ= zLP!u_4K>+IYUjP3n%M;VpD;L{@YGM%UZz*rkF;z;@OG4q8{N(`JAc}Hb3fw!@wDfJ z+Loax_nR)9^Ec3y*QO#a;0tjzLdsjfTm_%{`0-RbtybnAX%|MRLF;3I5%QdO+} z=7rQ!wyAPD&qRGYv|iGIxx~C<4yuoj(pp36)^b~9d4G2H>i0M^E1@?1=$Sp>lR!wm zHO+tMTvfjo#= zocCwVJSh*6)UyoBIH~89hHKmWae7tii1C`kBuCoT3$LaDy{NYwtBLM|8y}yz;W}Dr zK)(+?r>=fcftLdPDl|1_-1yZB8~XP%oSO5qi-1r4gvR1UyTEj5 zTaZyL*&LQj!NraQwM81gd03o4mxURSese+Z5|zSpL2jfS3XyV2syl{FuCp&KZ9TTe zaii=o04RVo(pP{AEHD05ce9WwtXMb z@^j$z37roGCvW0%2sBXE zCSSjqp~2!7Ih7WhN~1#p)c(?0U#y&Wj9;t?m^#0LxHqC3{!lc@K*D2Qrn@%&B<~*I zocMaYT~?7)D{wPfL3`9pvA~R=!gRxPdolH zKeQg)O*`Ib!tu8Os$Ko2fT4nVR?N)R**t0v-UMD_>+?{x_AYZE539AO=*n|G8~Oy z#mSmlt{*m{C+<{%dyp9)ICXWaPMP*vshDFMBox6`9ZxWfWPXVW`e}3}22}>nzjVT- zLWaZzxgB$-MKr>RF#&^JKyDNrI+3>V)bP`jumO^$|Ce=^x;Bo49E7F+wep+VLs_sz{x0H)}*gM>n&+_TGw|OdDl{OOy!Myp=(gKOW==EI4lvqolUj9!xUb zq>VFkugVzhwSiCIJFrhX(fX5-HJG7n$gZa?$Z$A+ugDsqTaz3GATNvniE0YRQ!Wrdb;&ml#Zj+At~vt$#K@oB#S{AVwmEUo%9ph@jBC77i!GnB70hE{7P9CV zUj5@Km^nh+^17Ir2vs*=hUfIUo7kyHCs~oQEeq}7lI~<>^RZ68{il2cDt3T=+?pU% zKDnH$`_(}0&KIXb~3 zr#J46Q|~*MOv+Q+uFp&L^wjyHGO>Tn7MFiawc7pJlMj;+sH&c+nl*T8f`d=Yvm)ef zIUplJg%pURzq|k%UsVOM+Bzr723u4J855}ijXvgD6Liaj2+uO??||2aH1#^enpJZV zS%ZLI(KT3#8;t;yD2eivV0E~he1CJ--vt*O_|p^&VkCzF6s*b_Fkidmhxl7jT@HolK8T|bHz3Jqq)Ege3%`NP>o5cB^y`otONWsW~ z7V~Rer!W$MJOlM@8ADYB4EFlu(131}tM%DHBg{#Fbp85YQ6z~m1k!}wo&U}_RnxZj zN=`7IyN8R~pXbwrU@eb!n(7FJOY&2_YxL}9bWtkl>{d$;SHM(&Gf~v8FLNnYrdzhj zSM5>pgY}TA#^fXu@uYx?Od&O;dQtE6&eErv%+kvp$P8VHRjl(M+P$S|U6WbkS6n&y z{0pb^dQ-SsOXeC8@8?zTa2Tm!=8@F{zV41W5-+L&JtU_B&40SK92`b6m@-gb{*54m zRgG=;Umr&V6iz9X)_01VINQcpyLL?%S#aas5K6i5(61w$p8(pHdw3!NgtzZ4o0LNt zM*DI{fO$QjE+X}vn#*To+53dFXS;pVuwa7eSKm4YOLdUq`CFR~j$I%4>+D~z6XkTM zY`oIp>Q%SYmh19z6ziAs%H9)Z7gw9Nb-^A(7UF}grM2t-O}!LB<}PRHWo_X<DJn&MEN!fvFopOv2Q0rks_)Wywu&-7;a|JvAOkftRz>qwkACi{u=*6dh2>o`f&#Ah0f5enx>t)cyHTkl zjbwMrj`|jzzh;>5w%!>T<}ed2Y`LmsYWfCx_JM-VDsazKn1hy9p%!wN;=d*x>ZF2} zzP9Ekb-FRln#ujcvQEgk<-B=w*|gQ^+z>E_ev&5rERK3ozNnId!nPM8P6C+`S_u+y zzptH~H2*g?H6+Msh+bUS&Eh1@P|l+$KK$1hcd$CSYY-JM6>mX?x~%70sl@2~c~mp9 zJFyT5@CGjxuoa#!@|TA4Q$>JsDPe|@>v6byYr1eS zFM&0FmKe$se~qrzVYY?6{%~e>1zA&;FVHSRo<$M51J zpX5SQ^jacZ>j8CiQ$X$8Ce!z{!P4f0>aezKw>+t)e85jA&M7alA5r+~qMnoaeGn`n z@cb}tML;GQoTYVg?qam=N>ZCY8renYSvpQa=Z{#b)$fp3Y#%t3j_lsZ zmqqpF9!7c)c(sfRq+X1SH00HuEQq2wI+aGSpfnX5|IDYk8od-{ZkK0lLgT!FyBz; zSaFg7idZsuIiz@9TyYB2O9K$i<=1JaUJc`yU-x<+vfp$lBd{3k&;DiqCxkMbl2QN& z(vNUKf-dg9B$Y8`=VPnG>3`;EeU;a zsTxW1=bBR-y_w2@vh;@`rfyBZ9Gx533a2umzeNBpNZ7^SXI4n1cqKW#`!0$o>o*xr z_;c*P&>*<%bfSY_$~gUQ_V&~+)Shdl!%sc+@AoH8(Dp}_&qne-b1$Z?vJ_(l+l*Pxki|}jR9lNbLk{ir;1zj zo#PST;MK9HMyIMG*ylGs3wXc_&L{M~93>9+ZR1*jv-mqm^8$J&K%P*6aDi9HOeMGj za4Ks2#?-kxKzeHXr}p?g&+~yiXTAEdhk!QO{xz;OZg*&yh@1Nei|&Br*lq$vU1id{ zaZ~!U(Uh!zvfp5)u3*?_w==1&*>`DKl8dg=0=AHe+JM+U4P|_PW4S|hU#$gyb~#&R zl&arv_vIVJ7UKM(DOC?cbnJoJeC#lx_T2XfFy$&vvVP&PRo0 z%NgRQ1&CJ)oJw?jMgl(EouG>c7$<(1EXAN%ft4g9g8qr%C=^@hSvm>T(X40@?1+vI zafs(L$teTx>#E;u`t}!#+e&A@7(3H$+aM1rvo5{nX83@p{G-3_T%v9;0}-sh`YG~B z&Q4*~p=l|vkl?^g0{&O4X?3?&4^Sd|79y;h>YgFWY7;(l?`0sZfa&+LUCArZ*pavt zloCmhlh5>&NGp1fNQ>faFV(+5Xj$d1k=gR?qGX(gtcS3;V{v7D5B3X(v*i{K7d=Ef zN7mZ6Z-q`}eOw zAAG@Oze*2yaA{bN`>G} z$FJZvE_5FF`F;d%&xN=Uq-tHnWJ*6iCmp{{2;BvKUOtre$I7j`c47J8@S-Vi=bLe( z%Yrh>duZExsl0*T;m!WGzB-{ATS%o~%+_Y*_N3+pZVvscH}2VpIUu^N^-cPIjK?@a zbf&O-Nkm1OH38>sLqx-wV}aL6%Yf#j;mY_oFtb180bWxpyI6ne(I7TSjpWS1qgmb{ z9*h0X$xeRcRX-jqNEC=S;prJQTHw-Bq zlA`bVz5h?FS*$f5=FEBK?7gpj-OmX(wA1Zz+A)iJ`?QxGL}vxnX`FH-D!Cn2w1vH{ zuzr5}AgB0d`A8GqtohaoyFlCcu6cELbeK?emD!qhRBj=wt2}4rNacX>!+%etzDpE% zF5#nuZT4E+8WWZ4%)oJ|C;`P3djl+-44sxg@m@mswa?{01b$Hf1_5mjCvMiw0GCF< zOPgG#7o3G1KnHB^otL1mI9?|3tV$cc5fC+aL(=qN(d@L|dvT}jn3GNm-4C=V%>gJ7K{uV<{C2Z!QUIQqkbYYxZ+m;tjNPe5d!n!+_i1iva$@;#5}% zzd&|108uRlpXlmS+u-`L-j)LFp;4VCBX#ZF76RbgGw5wAD;?@fIhn-vu*+bEj6K=X zY{!~e>kEeGeyg4J9m$04`>Xct*`lmh3Nx{IICv%e;k#JuBJvpM zE0ppy=Ecc7n^zzB=`C$OPp4s@x3vJjh|G;%ez{%XO82ML~zS{ zwc<3L6bI%F4ui72BZ&xefH~lb1=zY9Zu| zudMNxNcHnAzs>esl`FcOynWI~5vhRG6zsTnl#j zFYg|V$0f?C(BCvVj^seS9kMJ%c{%^8s%L1r6$={of#-Ka*rp;LK2f2zdn^M^jCh21 zP$B>|CGVu0uAeMabaRxQ{I6o-WE%OvKTpvw%j`tNQvcAH+m8-0y{wfy>HZGT7VV3a z0j4$=1UO(V%-f0Gx+aSyGTZ3PK~i5^=Jtc95X;M>%Kj;pcZ}GqF({i~uW86aDp}8K zM&a3Q%hDtpu4a6!=Mkgf>pSO`I;+g3eSTlu_eKZj?7sg)ZzwJsO$Y~8A^ECbE~&C; zReqiN$=1SvOIL+n;dXmfs1JaFwEORV)zwR?at*dy-q!8EWu+1R2nonjeo?#cz^O52 zu;by8WkU}++CF*oahCwt|@xn%acpn@r5PHs?$)!o9s@7RNg&bE0}On;7Q} zdHWfa2B!p#GT>WbV@6abkDTRMphGXuXpC!PRNq@8CmERUen{fjihsxPt3yq+~I zgRPG>S18xKLclJ}c)$J7!aH22>hqRvrj<3cExl0dn+PSf0M~Pu0B%C|Cc^W9P z+Ad6|V!c%6vN5A=39M=Afo_p8V#;E+C-u6ou3@IKtWnkoThT0;<@b1-+c*hMyaRek zB=?d0#HKXi%p8sr{)CvLF+%gR!S|m}=zC~BwYx|DsO~AhpM7q%*|blA@pD+lc$xpB zY(>5{O>y;QLf&5$tMy_@Kg`PHym)+r2$BW72O*GSb!=1BYmXd5p=Rxg12^Dwt$ID9 z<7PtE@y3y39H2iX9vN;DHti=T-F7SzdRCR%mxC)}kM?+lK7QV^_!`bEVxb26WYE-U zq4|{>OAz8{+^&jOMaWA5Ae@*~SUVffBy8R)t0E||zRf@X0$X7Kj5~V3qxkROdxaA& z;6+bsd0q}03~S&lX z36t{kQg&9ekH^b z?6ZaipoCIo*5Sn_3VBagw@gEG%AS@Rjyrlqf-YZ$3w!bRb=a62WDLj+zG7B}+ovC> z<{MSsU4vE8@I0GO3K~rbgP0!3e!pT1q`FpRR$6`O-fZ7Lf)Qrq9Zr1B)3u3*pH?kW z7$ClEkboyD2mu(<%DSAzmJwP?rZ8dpjE1}kdf~H|7hQ*O;>TWsQ=3RsLy7}|rXvfM z-;>`ledY-{5-_a6vxbuNBuPj5Oi6z5kU5`l!lsW5W0xA3+jZ)&k9^5*1VIIrsA5eVDN=e&6{4FWVsbyo4W@oFqMI zH29eUbp=()n^JVj!?Qo3OOH!*wz4CDf@FrhMNf>EP%{uk>6BFrtekE=Od6oHC8QYe zC-EDAr+-9`jnjTOdC-@P=-*VRXwQBjR3<}(lOZjDwS-g zY~6a@afso_&QxERaUU@T=Nai^2(NY=3YJl#C+0Y3u+UPU()qL$oj^tXO2c#+!=Ki= zdn=>fF*r<~npKMV{!;T~#1gqb9h@+QS1h<U2P9*i08bd#+f*boq7ri8U81NGS zKE0UqnsZ3H3JEHzaBvYyY6ejfcme1Blq=UYr*^AYl| z#Yw3K?dM209Fnnfh9DjcJc%5!sKbFa^ep17M^*EG!15-Vs8kQm>D~{lT^y4vxBZa_ zb*Id-L@yZCBNi;qLHEx%bjdc0Sgxb@dpd5&JiI>Y-aOp?4B!)4Y`MM&H)%{@57JxS z>hr$Q3cRGs(kXW|SIOBW2u`%h+#B)6xrurlhObWyu8DHGfD?Xl;BO_w?Qg80?*aS_ zTQ#s#>H#hpY|eU4X8&Wtrw;rC-EjM?#iB@dT?5b{kQx4>s6-6Nk!Kbly3x7WsEcPl z2y<}_kWMrJJ4(?}RMfvSgk?2AKh5`YKnxnMLxo(8OD|j_dVWLwfHiNZZ2%|zxcmSmFAx660l)=H$0@=A3IYY1ec|_@Gjv)@X4yvy<@fDYM>v$yA8Dcpja1?V8kc$;_;C z;1ww}Wcj49JcBp?DpC*bHdeq~c(wl}9GS+}bn27p6{)onQt9d?z9Q;dnNVO{;SRoxw3Hxhhm9bOY+_wmDeL74 zcYuNfk7jieAg|jnGW}D5{ew1)m_(3z7*$>Z7aNU$AmWSflyl3S2$`PVsl)r$31keO zihyE*6PjVg&SFZ=zb67hkUSTDYO8cI2YFiJ{!zT_h~g{uFae%rLsiwJ=Dy97(=Dbn zWD^lJzDs#e!y&~tH=YOstPHDgcVD^CJoLlkeEs$x>!IVXS-Bhsa<$6~6D zAl1mn>H~XFbzE}>)07%BJ>W&23nyL7k6Zq>&RVf`iD$pCV!eQ_~*=XupAq5At2M`)^^Y1-yy?_ zo?#i`m|D4zV>EuBvt|-_YO{Da3yFBc?8D7BsDY3AjbLo3jRa!nXf?8L&p5BW18Dq+C@jRzDKc)y1KQc{a?Po~~1 zS(#4Z_$&#bGWZ_K&oX-UP7VsHnyIR*uro5tuoa*83l;x#y2)FE2#9@-6~o zGV?9^90z$= zOOJ?UKBvw&5hY}Km3@UNJ!;FTe=$boNOA9^s894Q#M|jL=FH7Uwk+f77czrYT zyoPfia%`P-Y5XB{`WW>zoU6z=L$i8ADx8`63q%&@43tCdx;sH1UJaFdwcpi@5Y}@# z4Z580AzH5Tx?R}hGXn1Mv$!0E97+(ot@+V34FRv(#V0a;NsreTR$$!;hQS2O+YnoZ zcQo08h&ny^JtRuTGD?zKScUSql&IJ!LWN57?w?wK3hpJ|4_4%(_7^YH_?$=BTTiDl zH|Ar_hl^fqZF3~0m|<1!kg$0kQ_jo>ID~Eooyl?;&#Y?sBoXCG_+OX#wZx&C>@XBN zjoqjA1-?{0wpL)KJK`oxw17igqcWQIH1RM)L0)nT(yn=8K*OetRr&r|(TIok=iS$) zaLSvG6516P36i>4W%$ZF;hJMnuhH|=|I&a+`%4!uX3pJf zmNV(3;|_oo?$c75u|LFvy*n*xbt0pe%1{0Nby_Dn{gMo=%TuDaY#xrk$PC<4_WC;aWE<{V{@#oucy6$jqx#mq+uyut|I;WHo zLS?Xj{Vt8BxoLIT%Nq09mhdxFITmtV{ONtqM%`r_4fGJtd3+ zEe?GjJzD{$=(BjT+u+}SZruVukuj5Smp_r+1#e19HSoTcILlL0`T2ciAR||spjxC$ zO-NLTC;+ikyuu?v;wV`l=2m1XS zR|l&`W+LtdfsSgcz11b7{Sm_@p z5?sBrw-;d%E#^MVn+23mlen@p4xp~il4n#NJJ0()z90B^@!jw3?nGmL^QCLpA1zwU zAG$N^c*Wbz&QdX|cv%GJj^o9cjuCn(8o}1`Su8y&vQo6`sto)%!WytaDXWdXbcIz#aCO*81T(11 zyJe7a;T#l*a*muY03hWem}Gx1)z9(GE=)P0^i>Crt6Hqhl`R-3vt$0rxl5OQcxn8@ zMNPS(r%#Al75nT|9`jaXT|cAkdMrmKP{D2GAvU>^DW^j(v7Q00dLzm?dR{;w7jz~+ z(2JkE+c8yEuXxwYj+~`PNXWJ&q?Z{U5iOFBvKFRyX9VkLWv)F+D z=szhV(AjAo4vk;ZMx$a|L!~UO6SpL_XtiuB%XH5Qbs$Vk>@VA{&K1W7f31L0@NrGe zBm}UUnUI7$h3uucqI28arL&?{qvu|Ac_Ao1xvTs({syK&R``)?q7E*n4%+s`2yPr04Sja+YJq_Zge_nt>E4B-Qmcmy4c+00lDclhoM!!Y` zcA1Et(QFh^(y)C>j9nlTX=EYc*>%;WXN(xOOczwG6+(t6lg6449HyFX?yks}$Gs>+ zUxA^7niP+I1xd%bX*OAQ6hKzeP@yP4z_TGX8R_tMY0gmObGfOaI*zG9Y*UKw;}>R> zvg35C)LpX(vTm38M-Iy}fqk3AQ|Vvtx~PE5X8Vt4ok^9rnFrYy zb2)W6Y1-7aiA>QotaL&zKS49=wwW1O%>QM_;MM9ji#PPO5%ICf@u@snQ9@_!*FBCV8`a zy>q?C%URa@R4D5&C+W{m@9~K6R0FZxAsczLlum<+0BRQIM2aD&lPe`8I@=)E>kZ?q z9Ejdht$O8K(c2?Ly=ai|GCxSBKTNjRi9}*_v-ga0@H|EmRbjCBb|~JE_E`1~%!?!( zb;FP53!Ti8)zJ8uj0(c+^=wXjtJVG(Wzn()VLb=Oo+?g<|-Q$Y`pO0`6anY>7^T?uJiO*@aPqdUo&3wjEZ&jax`H}Oup>KIsMv&vX z9ogNr$7hDIO-L#YPNto^m|${qdUv%6y1^*RW?h-5(|@{Kyw7mavc}JUNou<(XkTWk zT&bD+K@f2$R*PgC%N>-YeD*!~19C6=aV^#V%zXE!f=~dZ_W;MrZaV4n8+9`S)^oSm z8{&_;$BJ^Yua8Z}{O@9(hh{P$V5nB%)q>g|-vUbHoa#1o+!#LuH>aWakmSHP)cw5g zV|5z+)z<8a)~)#+T!!Sg%Ihkftp>_*2q!=LmrQ$WSm|fA2HsS>d3VU^Bwz#{QB#T6 z%RcP;Emz};3b-T63bo&1`9mTt&N_4$9l%OHY~rl`st%ZTLlCGN9hRw%5c=_WX{o#(;aTvn}FD+ z1`nd4{`F!JZ5i*iasMJIGzGDN^Et&b*~tXII6vixoQrd_*uxlWMOC}4@m73y>$Pa8 z8^pdO>xNMx3Ak^jW+(wq8P{`tI-iIaV&txoqCSai*Io*aZ%`=8n@D?no*S#8&z;B? zbA~E{Y~YtTY>({|N?U{l+cbXUkaO*i{0iqUyV$nTlVY}P%++WqW;iBC5<(LwwsEU2 zYH)mp*;fUdMPfptBOqzz-3+P*5mfQT9CH%xMk@Oo(%|b~SwHBN`5g^dYX~p?c&qL8 zuX#)I+~)%u*6YP4txA4F0MpBiU9fK1nigPPzwb^ z>=CTCE!#WXfYe4y_HH2%bZ93`fEd%Z^|D}}@4{eWc zBTcxAc07(DjCLuYTsqkr?Y0Sa(_kx1hbj)F-aK3Qz5+4Od7^^$F|%^fzIQAy>htPi zow|U4n&`E}n&pz!(x4Z;sRhqQ`g+zPcF1^H14(}#Y%8PrTK>Iu3*O~@7L$!=d9zaX`yU`=QGN$q=k<^GU>c3S#-QPrzneu9e5GOa3AdosU#5nsYj0mLj@zZGLpXMt}+H7umTz z=XaApskm~yeZq-%wi5iDd>FXRAMm_cX~OADd}m&f*f_cJ6uG{8bBP=E6wig!Z8k@D z?}<_6$VQ}DN-5wxgOum~zh*;;hz!e9u!H_5ch~CylIsJ8R0;9+j2Ei6eb|c3^G!YR z1FO`wb5lf9#gj;C5T67aLv`F{xtcpbFo3tS{Oeh>pUh-PXFc84r3^>a$P+~g zv$~>RoctU2U@GVrdhO%>Q#zZ{0*iiu@WYO=iX?Tz-=^gYx!raaISPw*y_E#{jA+Ew zzsuyoT@FA82z>4qe<7)I%$dP8Z%TVh2mI&LUn-_mh!Rq!r1|dgZa=n@0|HL5EhLVN zE4ewKQ^<%#_=NbF!EPtS*ue$EIAbz*fc2z6(2dz=J3{eQ$h z?pmU^@VMgi2Ce7~_&*~H4=~{W#$68PPlVRRQ|K^%Q*@RCR;hf-K7Mec0-qes=Jh!5Cs+PoH^{>yDZ5$P$x z2H46{|H8MExFLM{W^6PhwD>7WyaU;Wuv|=%Ejsqb6eS6})go>07aF3RGAD^-3KW;Y zu%K&m9`_v-!L|Wg0+wGN?l(=(s`JOJHiq8|>f3MXf<#cr=&wKO&l;b=Y3GSvb%i=` z4s*vm@o1F(@YGpXorqw=ZCfGq!tik#KaIA0=buSin!MYIrAn|3PW2YU-Zx%+7tD)< zo>uvzu$-5!hR0z!S}>hKU`vLi6x}caVw)eZTa+{F`g>JLqMWfhc~d9fDu+~ucAT`- zu3tqJUzPu!m)CD+0>?0-{Kwmv@^~8?uflzaA{^FrU8A@+H1lswe5}6`IP6u)J)hOz zCKFNQ-Z*!_Jk@8v>KBLzwEMJ$`nb*4@UcZ&p!?c0Y`8nAzPdlX6*zf|DQ z%prd4!gJB!Nv^s=FoUYAA)H280kf(#U`yqKoXqR{7twV2xMf3+FOn<4hHZwp&KcYH z75GLTtWBm?8JlI0mB>G~GH#k!{csN^m~JbvhF|IwcPFIoOy@U_lhnyVHIOu6gXZ4= z{#~kqg|hE}J@z}2f*H?8DVO7sEB}*E%q_dt^%)t^Sr*8urOz02VTP-Nbv`_K&;eifqk=mHegm>z@OEE;h7E>jrr6+1e4D&rg3)_?&K213O@{6CbAZuVQmNVe^A$v$n!OWA-hL z(1a0S5019}n0lYMs@s9}FRw(Fc++@0Ilxm=@0R19Ei=3Z-^b#opI}-g(`uAh{KI=A zC3134t;wfZG%?Rz#N0ISIm~5)e65_nuR_}kT249pM8b}>YR&?JDu|`y)zPTMtHf;1 z;)_a5-uIm0ZFH;zj5<9-Ysf3x-Bs~DF~3C3tWk~o3;kB7!KWKvS~GY@af)+K2e6E% zIQm>Z?Jw}Z@8gzHQA-;0DGFoXU}OULhiI^NZ`Fl}1OwZ_O7U!x4s%(`k#Y)eMx4_oJF%sb~t6 z(ZfJXUu+cp9)4EkNeVT+Qv)$1L6LE%9Z|<(+7pVzU`n6G2~GIdZ2hewqvsc0sNIzh zS>h)k^-k{c^C*@n<`LT8=L{DqYiW3o_~Z;4-mM#QpI$~O)2^SWb0ozWudKJcJ1Cx* z#%ZL=l37!IYooZH^({m0Td%MYgAM8U+nd8;w$-iO`3Ui1?whd%bbL(5WP~2z+~)_p%~Hn>dH zhM$cN_v;tG_$lt^ANkl34DoinzmX1cFFdpAFCXyMwk3l!5%rgc7W*T@5Uz;p$*K6jcPSQIz{k6F`3* zQ-o3l&Wfg=w7)$FEF@a{)bSe533@$4mKdUf`7+s+rRN-wYT85SY}2E?t@qJAgu{hv4xPnMpSdI9 zNS|>{R#gAprXZYk^Ici|!-5R`$(;3a22<{-BMX0n*aqYpdNt{93~t|d}No#EyECC+1Yc z_qb=gQSbcx!^KkON4c}M8L3wVqBo@LP6?ISqXlY2yumnU&o5TPnJ#$wD13Z_UAI|W zxt2CHwmDpp;u_yY4OBxigC11Qg^vHJBYK}6Hoq6mx~Li2ab$Yd1Ufv^ZjqkNLqFQT z=#lK3aTr)AiamL)VDlMcVQ^5G_t=H@GoXKboz~{4t$<+s&^Tbv$mM)N$^_0wqv&soGoW=ngCBLhxLxNAz#yu9yz`71%a66=MP3HRUG z6>n#9I}l7hQx&~-@d;;97c+qg1xMw!E%)#(HoJb$S=)K~^0}j@MuAeCpR4S@Uy;vxerbLQlaZW!bb*Nz0rIo^EpkV8+TYCR{5E8@Yd&laKSGY1n)GfOJ4J=Q1TC=*rEn&FE94R)nyd-N=?j z{%}wAp~Fy9sWT;3MDa#TOjX3k+Xdu~tbu1zzru_#rT04#;(0B% z-$s+kr5Wx&y-!Nv{^I51;mGxxJ`tF3dt}oHWG?CJ))V>Oewo}<;ftYp+u=7Y$M&OJ zB?&5Jm}T24wr@wGQ5xP{^bjJ7>dTANoVB4u#mJtbRN-7Hbi;r3T=-{31M4)U4l?Q3 z(0U9{bXNgu+$sh@5ql4Aa?%{#jWB+#dygV};U3;5!1Kr&+2Ob=n(2MpNN-4uC4$8wtF+~oUC*c_GP_#xUww$&9SOe5O@IxR~M@-`g( zFhseQD3Zei=9pY8rWcUpXXX0UGXIjg;E_>dX5RtERd&e$_AO&c?$tw0!6 z-*(gL*67w8mSF!52lTgEdD0B2KtM^7hw6nyWtJZxO4Eho6Q_Lh6{y>0+m;vVr#kG1 zNLFMcTOgL=!6j+$Ee!ixjE*Itow`Mlj)K~PaeKP*N0%W-dSMd_7IbJ!vl^l_Md33jW)U4oY9MBQAgRk zI_i_8`UH>DAN@cR9>WgP+tJpF2i~4Xw;}%v*P>yE%S}In+$W4fywKL}RuO8U<^P9B$PC-~` zKu-L!>zS}bpXiut%QVj<9jbbS#k8M}6_@5`9opEFy;g`%c9u+j&g(dq;q1e;#w~fX zX$?_|R^`R@OrU=2a^oM*zun6-%x;{5k|_Bxw{d@P?z1`ER(*$%x)U7V5qUQ2fqW4v zsKO>wNf3z$;*5DnN&a!id0OcVoHt71SfSQRB+ZDz30zAzPIr|dh<6ahdcsA%jU*L| z)zY94KFih;GL#eg{w0XhGU%k6bieEgNeigt$4P@Y;QKqexP7XhfQL@LYk4$9chlIg zFnYacuysL}fc{b45*x+HGLfY_TgW;7p-C4ym=#?(o)K-u32mN#2PBgy_&WgZK{xo# zDUXG{3wOACY8!~BR^D*)B33fqhTxNO9!G?zi%xSNhta`>E@6r>5mr$G(v8h1a}D-w7=fZ_cRQA_GM@ylFmWxkF?O zJke?U^R}bJlwjh+&)!ZQLkW4?>>g)^^J0p`3O z@qdY%-{;yw6k+PWgy|~;I(HdYllYrK9{!ykv@EJk>cKN8ij{(Nch>HYMQ1quF`W3i zRU8=8kD9?Y=OGlULl~1C$Rp`=pE+xxr$aW~>?tov$AzV7@axN^U->=hi#mmAzdMh4 zo^IGtv)ENJttVbLXvBf~7C6c|4((Bw6O_kn?%UA_#nTFr$5s!@8Fiw}TiPlzZj| z{+3@kx!79MN2g%m0Fnp`sw%XbxA4RH#e`nhvqS&v`LFGhEwz>S zw?DVmRtc<6BfqvWB&@19F4zhYb-YpF+Ej)&rIP=^x49_sYNhdc%pWY!5?nCwYK5^#a4Sw=saT$2OKeM{RliKZWVXw+_ZlEZBU zQq*p6ocwmy^B=?T5&92HZ<1DEZ|j){n=#)_a5PS3>Ih{bHOh*^jYHbp>x&qANqM3nPA4lK)ax6 z()VP%8DatB-|}Zvasxown(Bf&*!U2j2;iu~Ija~J_D=bh?djFun&CR$8uk7JQ8IL% zF>L=e9YWsEb71& z(IhwJGq`7^i$B?QRnxltX6QXBR~w|T_}PJ6$2ZyZ+Lvlv%=X(TVmQ=eCX)i)ciY-< zl+7uhe;Q@;@zsj+eq}bZExzK9iU+86z*BN^=B^DqUo2 z`5{g&#$E$L+69v-L13{h4yf8qrtiG;sczsN5*L_C)X-3fJ>}bjyzMA%1csVI8cXL% zzusM`!7X0o5W|5aCb(zEVpRs{@rcVAWZu%5$iW#*U_hRuQtZWf(ePdjREN;yD+LYH zc-!WhN9Uh@ovps+oeRWoAV}|=UK2hGX)>gDW2tO0K#&=fCWeTPJ+__pwTt;iaCM$H z*f{66oiJ4OIl{+DhVVVt8|gAyj+ulTJ`oX{VXnEh9J)KobCcb~rrVAZwRP$tj0U9j z-r7s6X+K3AUab85SZMoPbi1(tTxKQoGZ*+ ze03xuAX-#9#_D>XRs_=!WRyPcOCGK;jDKun#6iz6N`Byko@h8GM#dPwD2hDld+he{ z*|?Z3Kf)gmUmVD{k=DBa5=E!6S^{eT!>N1;lI6B_w45-0-uJa4Kia% zNcjoic`xfosM}mw#aSQOLr>tlZ&G<7#2bWggZuwB(9m<}=@N|2dsnTUlT=LEM~GUV zcR*E)Iz(&#%MMd)uN7)mv8XO2?T>_h14<&)PBE-EJi;jqz5HV9YFaU;EgxyL$LQ9` zK0M)hwH2yx&Unz#8LHxSaeEQ5oiJQ?gXw({Iecni11(N-t{e*}ue;NZpF6Yz@(8by zt>8akE$3VZO7;UDj5~GUPvkb+e-FY1bVt9={}8tWaVs46*b-&Cl~MDv(3ZAi+i~BMj_m;Jb9130K;T#)t zaMh2QHzgrn0+aqvQ zBunS>@H}Sj&a=E^ubXIxF~D`4w9td*9G9}XQ%$B z|HQBK11O`hq!)%!)Vq1*DwbE8T+Z)ODz(wBubWTQ8an(9)h#lR!k?x*2j{JB4@!hf zo=}LKOwD%9k1ft^R67y3x64#7>@isl$rxb97@U;>&O{Kkn*|U$#+sJxne+fY^#@W% zrH8aH#VM`Qzuk9Gudi9Q&VdrPW}AMrmcDjqN_btcZGgEjj?x&v$BRf%n;JJ@eW#a& z<8T4ic4WO9%?AulpBeb(w-2Q9Ngw<`2=4|>{tjiO9EU4gMo zCMggxfv(H{<-G+_doLzFS*Ru`@HiH)#x{M9<+IYlGB_0Bj3PTaU!nr8@p)B_^Xrl) z=^~`X$DG( zbeNR>+HA!V34-!8gx`_p>JW5TGVztwX^Qc#XqREw^&9dbARSkkudY z`^6C!50G}Foq=&KwyZB?m^bAhPRN$N{l6%R%f>uHKRKe3=QOfDh=bJNzm`QO@1QHB ze~3K??AScL{2k80L6d`kGy89=^x-ye%$8Bg`mOwP<=(45b?V@4eZRNGLVECGTF0@^ z+AbRTsI+<~9`)8XsYHPiWd>yaR3MGkD*0U<&czE!)28QC-wpH$LTyeJYzN3bjG7H~ zA$<~GR5gE-TYnUE5m-Z|ilkfI%N0u!6CZ%b#Sg4oxG)XbT!N9y3;5P{D*t#ec`@z^7KbtBvEb?bQ(l$l}EH%mpf^{e}z97E2-_A<9G};MN#*{=$>P=~+jxPZXK0T(*La6DJ-R%s9RHM*bqP^B`&R|A=a!XUitX;~ z_CkwRpuT&@K6KKyB-fnMxfvm!s!7@i{urmCmV)vHu3mcPpi9Bbc;y;pHG|qIF@jT5hlB zAE|EgKlh(jUhoTII$Ja#Uyj%3D`&aur27;REhwvjwnVGWZ&%vbr^qcbi8uA3G|rzl zer4PFlMW~A)beBMJT=@qFR)=;0ku@U+brEQlz&-_KJSOPZsC8Qs^;X6P%dSMDO`+7 zyy>S`${c19BpQ)Wd4BUc9^MH36a$c4Ku#4@4wE z@wtA%J-)Y`0LNq#*sxA|-L?UL>%?3-+dH9Yae0f(P@@-5AJ;zJq@oN#3+rT|X#(8z zuZ|vN+xG^U5*>a&OU=|2b-D!WZ~mmQrd~o1}TeGMfik z*>vrRFW~ocZ{+t27r@+7JyM3kxd81!h)!T^@JS&Nl*-$;jMCc&@t`JPF~3GuzWh5Q zNbzT`Y8(&oh7;7!lb7gtsrgv`&&z7dCY>kBLr4+ob^dO5VK$Io{aFF%(SnJ5^ zg-AARC{d9FeWmoDw&=<4+aE0tD7y@^tS8PZhs4d<{?s&sCBL_LuYJBIeUup7UOM_9 zFY?IO{Yb6yfjpR7^2fR#P&u_0j_nmBwk4SF&KaD7y#uj8qDecMk*p_y-n@1eCPZmy zbG&*k|VM@;!Ib#s`co_Aa_E(F3Ybi-T+$_v@gr0H6(ht1Dv|_24sPpiU&cgR+Cl zk`B&I#&6{p^FW`0`%#ObM89GekCJ(eSwmajZ7}nS-9fyR?GkbreTP0j^+YW%!Mbs+SXpX@lB$5;M>~;lpb4sxGoty?M-SK(zs}=bHb+$JsUV!Ki7Ky zD`ZY`@UJbq?TrpOD@6{!F#7}7e`Mg{@=5#Xho+r$R(8}IsTYAcErMGnukL=N+nt_e z6m5xZjNA$l^i8SBH$J8Osk9}$gk3E9_Fu2X*1Zb6BYZQT~5j`@A`K> zLHG#$NV}Wkw2^f+a#$x~mJw7E$J<(*!kb2CP^O^h1BCt*eQWBoi%y!6-9M_e^mVkC zCvZsurYO1w-S%4;>o#dCMKE7`g|*Zf1D)>TzclvF)J)RxC%9iz^|YwsQd6{K_X7ca z$zqvb>@18ff3MAb5539;L#UDZRAet5$|cO!`mwm2dw7IBJ4ySf7 zFK;UtJ2;YVXbZhL=;7HG_pg<`i0FauN1SR0mr#5!nZEn}hrerlOfcR*^tozp87N%J zU+kWL`X^uAC;90W%2IGIL|IKG$Q#qKF)+#~j-?E>%|}4r%uCAEgT(@;Ae_Rm!|5L` zK=P)%?SbyS9-{rkX_qOmK3go1BCf1A-}Q;isrcCqWpd`GgC85Am9p0tQ`igS#BH`J z4Wq?S!uCGD%ZtnJ^(um%uht$1xmP4nf=u6BDYu*2nTI{FIiLLEam{{}THkz_{!GKN zxmJPpGq=%uX(nS#rev|tkHq7qPf}QWDszkNQwv6E`}C<_L^ZG{)Q@2tDb75K3P0dy zlslAB`gAQ=EpXv2uxHFQnQ+KrGSsj_tYcL#cmd0}OGQa>m$jN7)`npH0XKpxd12_< zHw|P|6fXiqcW~8+wHSjGR6@wO4V%fu3f^-b?MCy>vADil~6RWUA&( zVd)uf`{BBEfyOhKG;jaYksA^#-$?4s0LEF7SuXm?PDbsEhvmQtuXkaFD=c|F2OH&` zSbgwo6@4<2yxBNk{M{Gl|2n$Lur``5iaVu9a4BBg-Mvt>xVsjoxVyU-cPQ=-!QI`1 z7c0RXzP#VB>?YY~c6Rojd+wQ;dp9YqUnGU#alfrc&1$>F7whK*tn9aVJ00bqk*!9X zZX6-4yIz5ww6ASF<0eDPU99aMs6Pnj#-*>s*fcCmYS4Q9e7hjsL6H?;G^T12pSS-8 zB*JpFw0My9LYPe6T|g{vTO<9whNM!F^W&raTF}$mZ6YJBd*Z#v@Ro=Jcw#jz>Jsez6y6C`d>mPZe6!F#q(mOQ6$=qL6o7$K@r~_juxHu zi_%<3n6ObvajYzmEwbbJJWll%txYvd*If}8@&{^bmuDMs39>r5d3$*v5w`2y+KKNS znil;)dhbv>R3-JrNgdXTjcg|!w1eDY?D)TgTh6xcVd3${9q*UxpO8mVc9;g<3>SXA zIwTP)`CU?{jk=G2KlF1S!`oyUq2SNF0zaGiW0m&>rf4yG#7r zQEc(WWl0&ZJIT#~MF_cORv7O0>?~qcVpA42_(*cg-|XSm<}d8O)FxdlaN2+8E4SmX z*~~AC>g+b;#y>G_mS^B9&D%^q2I-d|DMQz@)z0aceJQKbp5#f8mPf%;-gS)B+qq5L z1wS0+7WBQ|59aWD?@%%r|x3ACn$6a`I)XH`Ek6J-)fZ6^6~=t zg1C|6k!DJAl`svJV~Ur@9Qz(bdtA-n-hR~?gn187pC4^KHn-pogD=DTy)qF-%zy|4 z_SvC)52``;RN|9{C z&b_Zuw||Pu`e4~#Q+nKQ<&cc&+B^elXwkXH9mnk+SLfHmjTs7m2gQb9pIU?S(MC39 zpP$tt6h6e3S0vc=NS76&rHg%q26coO2QY9G@R~J8P@zN^KLUf1tm|aMMmiV+-P$65 zWt=E!mV{#EbRSGaX52--!*Zi)VU_ezvin#uYdholUSQ5wZj%Yp4|o^4^QCF{rthn? zJM`*&dLqVK{SrUssLS{*U*s@+-PAcf1qU)KGay4ZIB5fO{LLd8qlibR(0h0Qg-qi-BWE@SdvjETHYgRLU)dx9Kw0RZo0$FXNWn`Sh19vCa;nE z%g`o6D@}mANqCDv=wiBf%SC?DVGcdQu$25_S-+Rzn7wwbJxgz6X1a%#hk?9 z-5;BKtla+@yb|09=Uk;8z^m|T`a136USH%b7B)fAj8?V+ss163_BjXHZNhQFPcNVv z)rybC3U%+2y(fK@sh8fV&{MnieXu75fn^*lZL^xeWCP>AWSG)k`JRN? z5m^lEjQsX=X$TQKA=L8FV8>E?A6t+@!bqu|j8+YN?a0h}J{Vb~Razrcjq|Enwp z;5lDwtI3^m5!jam-G3X!{7Yd-*}K5yC>j>O(24mw?HlD2lsgYQC?BnLJ4#jX6Uw^N zXIPc}WW+;dL~@w>1T?aBCAf13lk=O;GnR+}E9SgMu(phX6jlt+CvOJA!}Zf98^`16r+F&XFu! z((ZH|wZc|%W=%XYh#5veElxtkeV7EKXB1SUA$^$FxSA$Gm;Ul78fGePZko@{fHp>5plQbQQ#fJ3p8QccY~NuZiS74E_!Xbe=n*&(ZAB(i z9&yh#TO_H7e|i$CGuE`L8DvV}$5H!RC0!oXM?U-yeBP+zzgO($w-EX0;LaD*k*5l@ zvTkA3#pHa0mp{zI%Oa_=U5}RRJ|Ju7UY3D|czLOJc?%vk^tf@yWxcNNm^wwpPAQWT zO2MY=f=ww+6kmfqsQcJD*pYvVV;sr%3&v!s2q&3wxo1WivrL;GGfW z1c#!v&L74`FkPbZt11~;Qw3d#z?a_kkp{p7p$dxz|2+?H|!{A@VKdW*Hk!Jbt;fX;%a z80|^iHJ}%%?->5=OUc3aUX5m0FcQ}I%CXL;bBxzY0`LlUI6<2H239u-%|3~JphoXW z-p#P)4Yq8%x9JL*cX!@YPC@Wb->uQACqWqbnC2Qzq>aH60chdq8&;<;^X=b+ZI9b0 z0-BDqp}a$VVPXycs)6u3oD4@Uf0bd`XXhfU(1DTHqwp)nzPEz-L#sGoYcxU6lv+T$ zgeFTH&VmAr)i2iASdQX_|6L^C^NMYD2W59UPvp;XCMCvX&Ow6Y8>jptx(AoxPHsRUkz*Lv;HT6=q+(6JiK z(uBc(zf5k5MCN5vIktGX-D^3Q4i!GhLExctq}W2!GhnDLX`Xg)cu(I3(S)K+6Zb!$ zVjv~|NLIx_?wy$(h14WgIz(-iS;j@*tO6odiV*rXVj1M=;JPCgrqmCcsp&hQVSdIwq18QPq zP^I*a<5~LpdAq9orhK9rE+X{_t4) zDAa=(9s!Ep-Sb^xE*#%Q94kzSK@|atH|y^O#kj~9xWb%CH4y)^>3OS(ML_0e{2gbT zLSW@~K0&lopko%hPbl$}Wg3j8vVr7YgH`H_c8uwi2I%b;5aT`Y$M+y8U`;L~Wpe89 z49+ygi*Ql}^sc=U?S+N5OoPgn$tnX$3_%HdMDJ)j z0NTP)$SAf(F$13DICJ1pvaipX3UgsL;4iqChH-GeHgN~$BD6Aq&oYwy5VXpH>Dze= zLs}UyKc(!-%8~WHZe5IvmwcbE&P9mE@d(M4O-E)fv`m7I20R+wewo=SxJ-T(?M@ZeZiTZg{*o>}JdM2L*!q zooYSYYL*)!FPO3s`ZRZ!FOCLb-7v>>RkLDCAPPLG0lUPaDo90k1GP@jLv7xI7IZGTb=l}0 zkc+?oc-$4=t6mrQ;s$*9%8-(ZvKs{pq=#3;*uOFO+(esP1%o*__^6DZMLN~Z?c|8({C89{Ik8a!6ZqXJ>s|=X# zkU?`w2T6dtjd_dHra0RZrD>*L7Sh8SW2>#)cYa{Gn416%ktDAiR(~vRVKf^cUrLW6 z^Ku*5mM1JlJyQpw~{YWmGdBJ%E;b6V8$;^8gzuKJ&o96;^{vQ3N zwP{)WMf7ao+4b%1p1`pe21ABre|IE?FGDMoMKB+DMyrH`{v5rJVJDK0cB)y40YwC8 zdxW=*^^>1(SqxeG6t1)q5~d1-tUREFKBhVqPHc!@bVPz=y;>mSMes4SDXEhKE|+n7 zCFq~PcKd@Bfb>K7#!LMPP#WpO^@L_3s1 zYAU}1Xv^4lD83hF(ce}sxz@=B=J~c~bT--uNA1% z!IG+gI!Ee8&YWbui(CH#)OZN8!ewWbzr>%1ZF?aI{sA(nz?;f*P2S%{T$i&~uACcO zt(?w-*x>&m74iDlRO4_3?jy(3l_gguBE&O*zxtXOwG$VOjPUu5&2iAxw6L|ykKUGy z^^D^<1&XR*S+3-MRYp`q8s%mH*Q^b0G(ruMPVQ7mZs$H0v8gqgKU<3|@RJFx(%ovf zxeT1Rf{@{--`#%jDF24jwCVI7>VG=z!OT_GqDEMUa7Ktj5zttVe6xyXm(fZ^s}u>7 zjcux$Oh)O7jq;XPL?aZE4gE%Fs}7RkY<~{sh4_{bM%|eJI~1Sm*sC_?hMtz!_w_Eg?DX<1dNcpA#3$A9#>l%p z?M&5*T;^V?xZ;=3JWa2?Meic7UHxWP4G~zk&_S()fhp_;@G!n9%6wn!XwOWOi6AGv;XN1 z(Zx*Pfbjq64ho_(0b3}qpy*Ht0xQX_TOgk$Lq0B$J-iG5sgS?4LEt4CWwZHb62vQN ziFxbIhfKELc6{vLj2}npj|Xih15wBA52Z@Jf9@+>lBI*4Z10_NQnBiK zjN~FtA^+LZ<}e3~66xQqLu%W?Oh7k^&)K&!$Zd3*;8#wI4j6$4W zpD7VyYs5p#Q~=jGbsXxB0FS4&v&j= zbx?>o+`I6Fv03?;%MH~HR86ElI6wg~J33+3rk%xGIO9VXNp3PQ+ll2wY2E)tR)_#z z%Vj+krJx;~eJ|sAkz!zNVU%lDGTXVAC|^184^jl%jbBIxnxL5Gg`%!>Dqd9q#zEl2 zSyY^?5+oSHd0e_EmKzr13**^Q{@cO<@2omSTTzaLg8oB{?m%{c$+)+pNE#bFzVGxcc9}?UG*Bv zRu3nL-c$P*5BD2&ib2PL0bD&Q9_1^KCf_p!G`pR=Hin;$9`dTsBrc6M<=~^K$>;W9 z?u?;oeNBwKSiLiYk`%!vRsrQC(-;@i*pML^%RLi|DFunXNFEq+3KT-cltju(WU>sl zy$YcCBom56420+zfmRgmdC8GWVKP?5zks^BNyX!`?}4>I8ht}x0>{mf{W7e-gkhR-v}_iVZ_Jdc3~ zeP%m;&0YvT#lU?Pi_<%bkI$1bQMu4$430C?v=Bb&_HDh5HN+^qm`N5$9oeyOa*rxD z6QG2{>x625+f>YinpfwkGyhK>DBx5y7L*H}NAI|!+BS!xvH{S5ev=QJ`KQBjLI;j1 zo^za?wPV_N@wWC@fi|TC<8JFd9PLWgNDH}W_*R$ia-BsGiW13~q44~~?sHbPR zF{wp&R@JDi_yQI6O_;&jof@Pc+0lu;hW8)Xlod052bxEAe2i`*-lFl=03F;+^lftU znG}W@eexJaQepeWb`$a?z@aelwh*zRfq2@F&3}+X#hTbB)RXKLZHK@ zO!C0U-7=gIY>x_PkrF?-`g7At^D5OxsZY^ur$Ybap)S0z?8Slmko&W)U)f9WB~IIO z9CJO0!)t^hu~)Ti-0y~pG>U^p{~@-Hm0;_xmjSHG|9<-T=zlyy2F0(=>%ip(>%(Bx zIlZE4lvp17QI>Jps@lyV`^#(^nO)$inz%tv2)#yi_pN@^VpyS8HS^J^xIL(`!R7jb z?aGPG%V^i@3c)ER20~EWxd&+6W#5R}*aaM^I*-neb?2ijAfwA;Hr)*IH zt;2vyqNS4xdJA<38&b4$3q64D`g5*gzi?=g?a@ZTj&%#q*vITq^QSyX1)gg3} zPj-X$RF+ju_lpU_U3M{(67VpRpP^Ic!0pWz_r}Jm`J3Hfna*%Sb!};<6ewakkNd`%t5j)g@OpgV2SO=03I-H0fB)P8(lq zRqnclUQ!Q7C0G zd7(~K`LRUA3m9eP^_7)neQE%|UtJLG#3(2KZVs*+S6+2D(24g)nL^_&)!%9%+y?JG zluIu4oYEh|?E0ZfH58HKsL5>T)*W(K%9iDh>u0SHe-eY)JO*pZ@w-4c(eb%mWmt_V zqoSW0yIr(kd%Z;&lPVF5i$fia>JF_;^h7-OKG)`$Hy|zqQSp2{Wqu@igVJ@8BLw?rYgd1$E8M85WGMZN_Cf0hsZ&LVtD?j!Uc}lp*;AB zev_A!_Qhu=x`ue=cdhd&G2b?tR(^k3oT)1CXArkcM0Z+;DC9ATKsEvCNs_y#ziw;cSe$h5!pD|}Z3+*~d-P}ROuswE>#sCoRF(2-SwQP)Lln>x+WD&4~wKcv^=u3xuU zvdY1z=4*7Ha&`_NaEwP0S&O2Si;FN``*EbxF0=Imn}4UBM7Qib#j4~OLTR&2o!p$$ z*0UI`Ls8sA;m?pq%my2SIL8B0>ATE@?|GE4o4KweQ&Z_@YBK6F=`_BNPX(yc6W`#t zeRV}yUtKV5a8K=^f&1Y_Sf#P+-V`uwA%@LP*!+2=il%WUfQ#OT<$hK;oOQYU?LI(+ z{dl#T-iNlq5(I)8cE41o^p?iIDzOCW0D4F>KO95wH^9xOJ-^?$%-okN94EW};|&W^ z7y4Y>kpunwTyIAdqX=E5 z`1u%64;A3&KN{Zu*mufm`W>22AkiC&!zM2tDutLXAaC-GUO{_kc!kqLG}K``#`mPV z*?VCB%Tda2M2fi-3ABR$82Zsvtm#8J1LIx8-qedBLvQTkB2GN$^T4h`?@d+D-_TyTb9K zR2$N*2`RfL|7cH2o{Frb_-}JGmOx7Su7B2Yy^oyu#J+HO(t4N~2<02e9CE)ZGCtgD z@j|v>)&^zN+nBsi%w#sBp3CK6IVmpxn$qhD`le4x_zLV~{m(YH`P{y! zhPCkVmEc3CO&1?u``qIDnw+(= zg|w%_!fdFu{qo87R%zIhCPar)ssK;SQr9WZvi{8bVskli(XUjYM2kUlbVckglhlU5 z>T`+FQt9~fmT--N`6kO+ePc0_u;?*VYj6YzAe079Vx1LYU9KCy z^B=n%f5dYr^7YB#9UHuCFSV8c(<_ZKe?>r+`aVJ&NxP3;2wnO8XUkJqcQ~sIRt)cS z2$y;x3d)ai)hqhM+$s?t2P)#`rF8RfWpWxbyBVPf=&bTki@Pz>qam6@eM=B?;c z^ug^cXqE~`TdPYUDx1b1f~j30Dkg;ID!Ux|MudePl0J z46eP0dvK|xTT{6){-`hfYy zhx%M{CO}htmB5;rC*(J(wnD8YU+N1Ur9 zfV3@Do)M>=(*08lI*BXSwSH}F=yP(nnN z8qlTp@xdMI&w%C(MD_Lg9*f055f5MXXECT%z3rE{?O8|m-;KFt5{+F!lo%f5`etI9 zSergf04XuiS-ctsm8GFe2&Y1@yBeg_4C$@^2-UhkqU0IIw)$?zC97eV%%Xw(scgcW z#zWNMMlaF2?>tBd;OB)VQrn_BJG~62IN`6fMcwm7n(@#VAWWQiJeeSf+R;`Kc0D8@1>C{_+od*npY~=lZ{D!jWkY6(~HC8v%DP(s6n75}+y^ zj0ykpB+|P~l;hll2w_x#c@9uHibHOL7GxH_wfJK0|C19;)|FU}>V^N(*YLQ6VB;zr zpC1VzD90kV?k&4{Bn8Scl+B-ukdrAOqN9olM)PEn5x{zYR?etL-D)pd96ZiCZ)x$g*Pk*KRIR8nYsx}uNsCZ@L@hnMiqAHfJ;y` zvmK**(ENo#YG15!a&jon^&YcR^pkmCwg)}?0~P|xUEP>7*)GmFjE?&qEahLGV>+g% zx7V5@8&{|iZsC)b+Z}i1U+-r7GZ%V#sj!q?W&n( zwWy&|H?>bOs6@J3ST>An8kLbzv3v_Nt(@y|WEn$+J6ev>rK(oM861A;M5|hkM7}dN zxAcle>B^>K;)2hwlp?djB09UHQNWd#6CazOF8SN&rtg1PW8Cw^%>Vg}8GlUKYk!aN{nBY0Dg*BW!jaJTN zKD~x2f?V-?W5}FI^(WSO(iCQ7+Jk<+?#G|w@&&FKbH0wsdH_adl~y@&ff!8$)?UKw zeolq1O{-E}0=)urgVOM$7|s%jrp;;cwdn3yKPz~bfsL`}7g$xSQ>In^z7 z@w~}P1mLHC+ybPs3yf0bYwgtfBu0@Fw1Jv`ajy9^>zKjv8*I!GWXJJq9P{ubt6jj3cZ};jE9IA<4@8e>+U}PY$r9$(!xDP*;pLd!g60TN+74EU7TQkW>Kcm&Urif zEJa9RxtOA-v=dG|{mQAo-&YLSySZmvgA1fqZ1&rYA1(J+Xp14qO+O<11TEQaJonXV z_u$-+565$Vx~`UIknN?%aFPf-|BQdMSGK-)flp@|t9>*-IAHmQ44*C(B4<9SScqM! z8+ziLUod~ALk~@8_j+|OvwR7b0oawX^B4Y!Fmc+sups)A;w@g!Oz=h1k$}f(6DqNW zMfhn9a!+<@->F55T;Ny!N+@k&$g_MUkWloSHlG=akuA}0$+9b-L|T^+MtN78>}hqCsyVIO(Z+W@X9r6o z4olH0Sq56_lxMPHOPk%+Qieat$LU(sM+oL26(BVyif|MQq=3tmgwVpBNN6Jt~rAid_8Ktq_GUt*Lu$`GrxO;a38F z#n=WLa_7+CEFKFU6aoK!?`>L*yJ&sBKuVQK_2RVeyWYU0KSp6b>o($oFU12%@P*fZ zxwdRUtXCl1eNH>UcXp8pc-^ckJj+jp?wlflz8?5ELScqopjK;$+D3Z7GE0-`XuzF{xK- z{4KR*VUBZ>HSEENEyGI&kPs}$A^HS?yXOU`I{KYW%zWS-?2H@Aa9#3FOI2b~)ygY)8Qj zy5ajiv5WNKVNS)e#sZl@^C_g(G4`BN8H4WJQjO-Mp&eqiLb;iS<+tFBVRiP6 z&!zU#=W7VP17vY>3V{S6I=UDU-3N#kp#O$N!nr(VS{P|elh|K( z3E#p))70e!hif~k$Iv#D><$~yHP;kbJ(PXzzX^XB2G#e+5e3INf2Hsf!}zkHTo=}^ z2x=dqxc&{pA$r#?$LD}h9!}9@Z)H=jm_?%7FMrvZ)xrg%~ z5=MFjs$2Hj3QTc_u_cy}pT9s%zPta|x)*W2TGKJvysq3MeB4T@c7${77BXHlU~MrKS~vD(y_lZF3$p5qELOBA zI6AyO*eoKC^J~0g?X5g2TaUO1E9<6-z!L*~oGCX198^*iATA@4z*#O$n~`1eJFwWC zKfP68^hWo>*?0ObhB2!JVo}PHpLn`k3fw>|$1t^~5v~eD_n%E~CLPaABgZb{%=t4K zWu8;XzBGC?pEa{FD0|<`%1uZOMeXp{$!xZFx3>q4LCxn_3MJpf*-o8D&y^V&Yso0* zUftMNp>8mSg>$3s8~XFNYgi5^_EDJW?r_+uf_9B5)kiV9G!`6$2pAPwO6C}GAtugC z{r78;|9JCnzn?V~){mn5DIXRZFg)V1A2~Uu(D3DIpS;36Q8hY=eos+qB-nk`g7`RH z-)Xn=021OC?{+M`?N>`TM|cd^wkdyU4WrkNjh?W=fYA(RP^ft63w0}rfE9gK+*~?y zf{sYmc2L@B_K=z9xK-fBqGR8I*6>n9H-9Uqh_A;VlNu3h6;u-_!8C=g3 zk$RBe6@jjgL=4TI0}JM@jl$8B&DpFzpQN;@403fvEts{0w7pP_@CMhE8=*s95Qap} z1`>`secF{DPE}$E#ppVEm*NXHB%XB8W#@bIEFmUMHN8f>Z5v;R9s2hTLHrRza0e& z^TS7RP?fd>Ttb!r434&y->89bv6ej-x{$D&;B!8@>jBC?41SLH z2>!6<-=s6pb)L*-7;4;Va}^!YMWw*I&z)J>Vzqi#x}K8+Vd;{*PT%TBsbF7p?v>YW zXQgUZ7UPsN3uG2LN=>}gXDQ!+%=u((hgiwD@C>gKkSMvvp}Fw21hP#0gYrrsmcCv) zd{LHBOHJzy_U*JCKx;_%a&PE`6Zzx%qSq*j)32C`1d%$yn}iNYtYC^6H#6q;BFGds zoMTWTji-xNI;U75e!0(nT52@)x z+{Qkmgocg%`#VZIM$$c`2C3m9aU`nB#E9{6fc-6qEJJLF$1j)w(ZM%%@LEc0Ww3N~ zLXTtSu~O5irq2T9o_6HdCXl%x5RL76@i@(sIvHl$qS1Qd&D46Cn1~|b?JCr z8F3~Di5p+%S2g!GEU?Dto2x$bC7-lm2afHO^Y_1}M{>~)w*{QqqGD^)M0FjHR$OQ~ zEohc=OGqK9cZPM`#KciN=8_hfe$mHi()#j~nPNkh?t>D3B_Yh*eoNI88U{B#qjzBk zH*DAdf=r$P!)@nO(`JfFbSFz4Qu}8+J~DWDg8ZuHNQ5;>L!>=AHF=i!>ms=rqwnP* zvYBt8Kctl$#f{QuzmC|kZLrooF>S2UXXN9A;&a2>XVTTGeRhjRw=0B-hTat`d=Vaq8R<%#M%E_G&OL6x08QP9r-#RlP~cs zL0a83cE8HLmA+#|lTTP3BT>elM`q5ra~DE#$#YHnp$khw)#6Dm%v&cVNKB;NX02>R zqXKwZpX*+}KY9c_XJ2S({&u^f60Pi`k~xp4&~;`tMO+JGzwZf2)9L*|pPBoXPMT;@ zVT&7Gvt;XjHeKduTkq4vQPXf z*DkO~?wpaKpy6}9N$sAVDtOYuo`?0wa`MBnK!kCFwP}7nsOy=S`-Uf!4TBc5BeL_S zZB0{C2)SJ^Um^@4!V3hgl(+F;2hc0c;PHpoMDE0{svt}1H1J=W1bsOhYT zuj5bPj23(!m%gE{f;5m(%Y6ZKL&3x7F5{=#3PN%-))fq47PaW9u;o{v49D2_BgXU}>&9g>U*mD6 z6~yPr>*X|*)XV<{7otP|X}Cuo|E1h4X)!$lBOxNAa*BIUoJ(k7?13tBh=YV!cf3oa z_;~hHY-hZr+rwuiVy$gd-JJIcMuoOkB;JL;rmcH$!z_Pfqc_b*CpQ##ArIy`81ZgY zTMF;e{V}!$+oNTF19y5mX{;i6tJ&=mh-eaaW)EUUnww(zf7cH|`a9kRzu{w_|gHvQ{`|nbS`q9GG3g zaO3)U+)#Zw3)oNPzqWYWdHtolE`v~lV9aQ^i2d;^)$A|_)D5vl4gZduHI3?ZLmjfeVR-TavM-1_*SH9?Q`TiHVVQ3FQ_8&7wkt|SN% zeO#(rm}9CL^o`crJyuh5PafTjIzI_iCj72->uw=m`Rz7m%j}HvqwcrPmK@uTB-UPp z$381=?0nneSkYX_HxoFV(5e<32A>f1%9DewG~9hW+dZwT-E2_{VgLW@T&&pj5LY_p zU3vjlo2-~tfM$ML9~J@Iz-1f?>^M_N9M16R zJE4$Ox=2sB9L}7b_H%VP`B9N%h{KY`Z0$(|TGi?J!z`U#Xe^@48?1}2(SvIEfrP}c zbBj92FdKAwpca7`zwy+gLc85B*n~XzebS9qc-g3%ZsGMg33!?hU+QBx;p9sBi<6BwCUVUy))4r+*Rk12xN5axy@8J96G#Cql)-vqp^)jJ0~ zZST~lJLui0&wuadv7Il+pm5`%;ru(LZXs)fpJ6mcO+7pGPLi3I6Bt-Gko;x*DaNn~ zHf3Pa!b&C}#{cQ0?vGATW8jnjpX~hbnr7cY zEfjNJJpR-lzBT7q7BeI?$&bP);!)?)jl1q~RFr9Ib-x)G+DF|c3*Yd1{)A-CyqKG< zStLSZkik<;)wY{77X)mb%~lZ|0g_y$(|HdH6w*AITAU4x5NKE^#Wk>AAad8RU^G0A zo}g{p$-{Y^d&)khc8OeoG*4!UGbXxA4isPD1wR^&G@*>v4Z;Q@E3Jv!PZ%Odt5<7G zWnRA1_u*Lv^1U?{enrqCF=IN_rAs!s;mskou#tIf6jfa}EF$_sF*S%QEN||N&5L41 zu-S-aSJ13!Cy(Wlf{3)HAJj5ie~Xeb8QSDqO}3mdkIv&c5wH7y(p${&!e=GAq-VT; z!)RVDid~THZMT((%-DhfRujgv1dA0U1Es8ooc09p7ieWp^xYd%u@9!i6-&Ja=L7js6vk zq2~2ioqN$_>>+()h?2Xpt=7b3mQ6@A$chLxEhfPC^VL(3AG!AVkcmm++A|*XT$!D8 z(wu`PLG#9)Cb&SCUj|4Rm+vwyGK2rCX3m-PIVV+Q=TXXZ z=z%cW&1L`Z4MIGj;NPmk3pMFHbw~PGsm`_WCwu$4#Hpe*7esVnq8wB5U-xTMOh^RB z+!*ZBtJjR+7G+J2g~!Sm+) z1|di2@21O)H7TbRs2vtjX9@}3Uf5E(@viemC&9_@`}-!OKg%BkP(Rb&PJ}a|q5cPU C5?clU literal 0 HcmV?d00001 diff --git "a/.benchspotter/sessions/01a120b8-cecb-7ce8-8e6b-119d836f987e/mem/\341\232\227\341\232\227BenchmarkEdit.profile" "b/.benchspotter/sessions/01a120b8-cecb-7ce8-8e6b-119d836f987e/mem/\341\232\227\341\232\227BenchmarkEdit.profile" new file mode 100644 index 0000000000000000000000000000000000000000..f16e513e9d91eb8c2230a4c0e34ce9cb210cc75a GIT binary patch literal 7096 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 aR_S{B6#5jDx{pt2&uI52Z^%WTJ^LSxbhF6- literal 0 HcmV?d00001 diff --git "a/.benchspotter/sessions/01a120b8-cecb-7ce8-8e6b-119d836f987e/mem/\341\232\227\341\232\227BenchmarkFile.profile" "b/.benchspotter/sessions/01a120b8-cecb-7ce8-8e6b-119d836f987e/mem/\341\232\227\341\232\227BenchmarkFile.profile" new file mode 100644 index 0000000000000000000000000000000000000000..0b7dfc5356abe55935a5127f592541a23b81cdb5 GIT binary patch literal 8534 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 literal 0 HcmV?d00001 diff --git "a/.benchspotter/sessions/01a120b8-cecb-7ce8-8e6b-119d836f987e/mem/\341\232\227\341\232\227BenchmarkParse.profile" "b/.benchspotter/sessions/01a120b8-cecb-7ce8-8e6b-119d836f987e/mem/\341\232\227\341\232\227BenchmarkParse.profile" new file mode 100644 index 0000000000000000000000000000000000000000..4be707500f8993227ebb8c11df461a7f131c4303 GIT binary patch literal 6984 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 literal 0 HcmV?d00001 diff --git a/.benchspotter/sessions/01a120b8-cecb-7ce8-8e6b-119d836f987e/results.bench b/.benchspotter/sessions/01a120b8-cecb-7ce8-8e6b-119d836f987e/results.bench index d833a78..600c57d 100644 --- a/.benchspotter/sessions/01a120b8-cecb-7ce8-8e6b-119d836f987e/results.bench +++ b/.benchspotter/sessions/01a120b8-cecb-7ce8-8e6b-119d836f987e/results.bench @@ -39,3 +39,427 @@ BenchmarkParse/one_long_value/1KiB-12 212677 5542 ns/op 184.95 MB/s 7184 B/op 23 BenchmarkParse/one_long_value/1KiB-12 214167 5601 ns/op 183 MB/s 7184 B/op 23 allocs/op BenchmarkParse/one_long_value/1KiB-12 214615 5571 ns/op 183.98 MB/s 7184 B/op 23 allocs/op BenchmarkParse/one_long_value/1KiB-12 211438 5613 ns/op 182.61 MB/s 7184 B/op 23 allocs/op +BenchmarkParse/one_long_value/1KiB-12 207934 5539 ns/op 185.05 MB/s 7184 B/op 23 allocs/op +BenchmarkParse/one_long_value/1KiB-12 217893 5701 ns/op 179.79 MB/s 7184 B/op 23 allocs/op +BenchmarkParse/one_long_value/1KiB-12 204313 5804 ns/op 176.59 MB/s 7184 B/op 23 allocs/op +BenchmarkParse/one_long_value/1KiB-12 223256 5609 ns/op 182.75 MB/s 7184 B/op 23 allocs/op +BenchmarkParse/one_long_value/64KiB-12 4531 265462 ns/op 246.88 MB/s 426385 B/op 36 allocs/op +BenchmarkParse/one_long_value/64KiB-12 4632 263493 ns/op 248.72 MB/s 426384 B/op 36 allocs/op +BenchmarkParse/one_long_value/64KiB-12 4358 277081 ns/op 236.53 MB/s 426385 B/op 36 allocs/op +BenchmarkParse/one_long_value/64KiB-12 4620 398611 ns/op 164.41 MB/s 426386 B/op 36 allocs/op +BenchmarkParse/one_long_value/64KiB-12 3921 293000 ns/op 223.68 MB/s 426385 B/op 36 allocs/op +BenchmarkParse/one_long_value/64KiB-12 4423 273972 ns/op 239.21 MB/s 426385 B/op 36 allocs/op +BenchmarkParse/one_long_value/64KiB-12 4557 264860 ns/op 247.44 MB/s 426385 B/op 36 allocs/op +BenchmarkParse/one_long_value/64KiB-12 4539 271160 ns/op 241.69 MB/s 426385 B/op 36 allocs/op +BenchmarkParse/one_long_value/64KiB-12 4245 280616 ns/op 233.55 MB/s 426385 B/op 36 allocs/op +BenchmarkParse/one_long_value/64KiB-12 4124 297314 ns/op 220.43 MB/s 426385 B/op 36 allocs/op +BenchmarkParse/one_long_value/1024KiB-12 198 5.843213e+06 ns/op 179.45 MB/s 7.348683e+06 B/op 47 allocs/op +BenchmarkParse/one_long_value/1024KiB-12 212 5.765323e+06 ns/op 181.88 MB/s 7.34868e+06 B/op 47 allocs/op +BenchmarkParse/one_long_value/1024KiB-12 204 6.48352e+06 ns/op 161.73 MB/s 7.348681e+06 B/op 47 allocs/op +BenchmarkParse/one_long_value/1024KiB-12 204 6.04976e+06 ns/op 173.33 MB/s 7.348675e+06 B/op 47 allocs/op +BenchmarkParse/one_long_value/1024KiB-12 152 7.178469e+06 ns/op 146.07 MB/s 7.348686e+06 B/op 47 allocs/op +BenchmarkParse/one_long_value/1024KiB-12 202 5.752349e+06 ns/op 182.29 MB/s 7.34868e+06 B/op 47 allocs/op +BenchmarkParse/one_long_value/1024KiB-12 206 5.716846e+06 ns/op 183.42 MB/s 7.348675e+06 B/op 47 allocs/op +BenchmarkParse/one_long_value/1024KiB-12 204 5.72527e+06 ns/op 183.15 MB/s 7.348684e+06 B/op 47 allocs/op +BenchmarkParse/one_long_value/1024KiB-12 212 5.686385e+06 ns/op 184.4 MB/s 7.348684e+06 B/op 47 allocs/op +BenchmarkParse/one_long_value/1024KiB-12 216 5.684373e+06 ns/op 184.47 MB/s 7.348677e+06 B/op 47 allocs/op +BenchmarkParse/continuations/1KiB-12 159111 7556 ns/op 135.78 MB/s 25808 B/op 21 allocs/op +BenchmarkParse/continuations/1KiB-12 144363 8105 ns/op 126.59 MB/s 25808 B/op 21 allocs/op +BenchmarkParse/continuations/1KiB-12 142924 7600 ns/op 135.01 MB/s 25808 B/op 21 allocs/op +BenchmarkParse/continuations/1KiB-12 156525 7539 ns/op 136.1 MB/s 25808 B/op 21 allocs/op +BenchmarkParse/continuations/1KiB-12 147247 7918 ns/op 129.57 MB/s 25808 B/op 21 allocs/op +BenchmarkParse/continuations/1KiB-12 154094 7837 ns/op 130.92 MB/s 25808 B/op 21 allocs/op +BenchmarkParse/continuations/1KiB-12 161887 7763 ns/op 132.17 MB/s 25808 B/op 21 allocs/op +BenchmarkParse/continuations/1KiB-12 171967 7040 ns/op 145.74 MB/s 25808 B/op 21 allocs/op +BenchmarkParse/continuations/1KiB-12 172468 6988 ns/op 146.82 MB/s 25808 B/op 21 allocs/op +BenchmarkParse/continuations/1KiB-12 175572 6930 ns/op 148.06 MB/s 25808 B/op 21 allocs/op +BenchmarkParse/continuations/64KiB-12 3117 382878 ns/op 171.17 MB/s 1.581137e+06 B/op 34 allocs/op +BenchmarkParse/continuations/64KiB-12 3019 389403 ns/op 168.3 MB/s 1.581137e+06 B/op 34 allocs/op +BenchmarkParse/continuations/64KiB-12 2731 396542 ns/op 165.27 MB/s 1.581138e+06 B/op 34 allocs/op +BenchmarkParse/continuations/64KiB-12 3147 395942 ns/op 165.52 MB/s 1.581138e+06 B/op 34 allocs/op +BenchmarkParse/continuations/64KiB-12 3140 383666 ns/op 170.82 MB/s 1.581137e+06 B/op 34 allocs/op +BenchmarkParse/continuations/64KiB-12 2457 410520 ns/op 159.65 MB/s 1.581138e+06 B/op 34 allocs/op +BenchmarkParse/continuations/64KiB-12 2727 420864 ns/op 155.72 MB/s 1.581138e+06 B/op 34 allocs/op +BenchmarkParse/continuations/64KiB-12 2930 441887 ns/op 148.31 MB/s 1.581138e+06 B/op 34 allocs/op +BenchmarkParse/continuations/64KiB-12 2593 409242 ns/op 160.14 MB/s 1.581138e+06 B/op 34 allocs/op +BenchmarkParse/continuations/64KiB-12 3240 408440 ns/op 160.46 MB/s 1.581139e+06 B/op 34 allocs/op +BenchmarkParse/continuations/1024KiB-12 241 4.841404e+06 ns/op 216.59 MB/s 2.5100371e+07 B/op 44 allocs/op +BenchmarkParse/continuations/1024KiB-12 246 4.831505e+06 ns/op 217.03 MB/s 2.5100369e+07 B/op 44 allocs/op +BenchmarkParse/continuations/1024KiB-12 244 4.839587e+06 ns/op 216.67 MB/s 2.5100369e+07 B/op 44 allocs/op +BenchmarkParse/continuations/1024KiB-12 243 4.901073e+06 ns/op 213.95 MB/s 2.5100369e+07 B/op 44 allocs/op +BenchmarkParse/continuations/1024KiB-12 248 4.811825e+06 ns/op 217.92 MB/s 2.5100369e+07 B/op 44 allocs/op +BenchmarkParse/continuations/1024KiB-12 240 4.9261e+06 ns/op 212.86 MB/s 2.5100368e+07 B/op 44 allocs/op +BenchmarkParse/continuations/1024KiB-12 240 4.876976e+06 ns/op 215.01 MB/s 2.5100369e+07 B/op 44 allocs/op +BenchmarkParse/continuations/1024KiB-12 240 4.889801e+06 ns/op 214.44 MB/s 2.510037e+07 B/op 44 allocs/op +BenchmarkParse/continuations/1024KiB-12 238 4.876571e+06 ns/op 215.02 MB/s 2.5100369e+07 B/op 44 allocs/op +BenchmarkParse/continuations/1024KiB-12 248 4.849401e+06 ns/op 216.23 MB/s 2.5100371e+07 B/op 44 allocs/op +BenchmarkParse/quotes/1KiB-12 244732 4676 ns/op 219.4 MB/s 4368 B/op 21 allocs/op +BenchmarkParse/quotes/1KiB-12 249798 4837 ns/op 212.13 MB/s 4368 B/op 21 allocs/op +BenchmarkParse/quotes/1KiB-12 254726 4707 ns/op 217.98 MB/s 4368 B/op 21 allocs/op +BenchmarkParse/quotes/1KiB-12 255338 4688 ns/op 218.84 MB/s 4368 B/op 21 allocs/op +BenchmarkParse/quotes/1KiB-12 258063 4867 ns/op 210.8 MB/s 4368 B/op 21 allocs/op +BenchmarkParse/quotes/1KiB-12 243198 4726 ns/op 217.1 MB/s 4368 B/op 21 allocs/op +BenchmarkParse/quotes/1KiB-12 256525 4647 ns/op 220.8 MB/s 4368 B/op 21 allocs/op +BenchmarkParse/quotes/1KiB-12 252800 4651 ns/op 220.62 MB/s 4368 B/op 21 allocs/op +BenchmarkParse/quotes/1KiB-12 262669 4774 ns/op 214.94 MB/s 4368 B/op 21 allocs/op +BenchmarkParse/quotes/1KiB-12 232527 4775 ns/op 214.86 MB/s 4368 B/op 21 allocs/op +BenchmarkParse/quotes/64KiB-12 5299 223110 ns/op 293.75 MB/s 262544 B/op 34 allocs/op +BenchmarkParse/quotes/64KiB-12 5137 219847 ns/op 298.11 MB/s 262544 B/op 34 allocs/op +BenchmarkParse/quotes/64KiB-12 5241 227202 ns/op 288.46 MB/s 262544 B/op 34 allocs/op +BenchmarkParse/quotes/64KiB-12 5202 229687 ns/op 285.34 MB/s 262544 B/op 34 allocs/op +BenchmarkParse/quotes/64KiB-12 5478 233586 ns/op 280.57 MB/s 262544 B/op 34 allocs/op +BenchmarkParse/quotes/64KiB-12 5484 224393 ns/op 292.07 MB/s 262544 B/op 34 allocs/op +BenchmarkParse/quotes/64KiB-12 5113 230155 ns/op 284.76 MB/s 262544 B/op 34 allocs/op +BenchmarkParse/quotes/64KiB-12 5166 228993 ns/op 286.2 MB/s 262544 B/op 34 allocs/op +BenchmarkParse/quotes/64KiB-12 5275 228425 ns/op 286.91 MB/s 262544 B/op 34 allocs/op +BenchmarkParse/quotes/64KiB-12 5264 226237 ns/op 289.69 MB/s 262544 B/op 34 allocs/op +BenchmarkParse/quotes/1024KiB-12 340 3.524691e+06 ns/op 297.5 MB/s 4.120981e+06 B/op 44 allocs/op +BenchmarkParse/quotes/1024KiB-12 340 3.58415e+06 ns/op 292.56 MB/s 4.120984e+06 B/op 44 allocs/op +BenchmarkParse/quotes/1024KiB-12 338 3.565965e+06 ns/op 294.05 MB/s 4.120986e+06 B/op 44 allocs/op +BenchmarkParse/quotes/1024KiB-12 326 3.580807e+06 ns/op 292.83 MB/s 4.120982e+06 B/op 44 allocs/op +BenchmarkParse/quotes/1024KiB-12 338 3.495076e+06 ns/op 300.02 MB/s 4.120983e+06 B/op 44 allocs/op +BenchmarkParse/quotes/1024KiB-12 321 3.68879e+06 ns/op 284.26 MB/s 4.120986e+06 B/op 44 allocs/op +BenchmarkParse/quotes/1024KiB-12 332 3.759898e+06 ns/op 278.88 MB/s 4.120989e+06 B/op 44 allocs/op +BenchmarkParse/quotes/1024KiB-12 333 3.529801e+06 ns/op 297.06 MB/s 4.120983e+06 B/op 44 allocs/op +BenchmarkParse/quotes/1024KiB-12 334 3.558531e+06 ns/op 294.67 MB/s 4.120986e+06 B/op 44 allocs/op +BenchmarkParse/quotes/1024KiB-12 301 3.861701e+06 ns/op 271.53 MB/s 4.120989e+06 B/op 44 allocs/op +BenchmarkParse/escapes/1KiB-12 323125 3564 ns/op 289 MB/s 4368 B/op 21 allocs/op +BenchmarkParse/escapes/1KiB-12 339340 3565 ns/op 288.88 MB/s 4368 B/op 21 allocs/op +BenchmarkParse/escapes/1KiB-12 322316 3563 ns/op 289.08 MB/s 4368 B/op 21 allocs/op +BenchmarkParse/escapes/1KiB-12 337710 3549 ns/op 290.25 MB/s 4368 B/op 21 allocs/op +BenchmarkParse/escapes/1KiB-12 333478 3573 ns/op 288.27 MB/s 4368 B/op 21 allocs/op +BenchmarkParse/escapes/1KiB-12 324721 3548 ns/op 290.29 MB/s 4368 B/op 21 allocs/op +BenchmarkParse/escapes/1KiB-12 341749 3628 ns/op 283.94 MB/s 4368 B/op 21 allocs/op +BenchmarkParse/escapes/1KiB-12 332493 3504 ns/op 293.93 MB/s 4368 B/op 21 allocs/op +BenchmarkParse/escapes/1KiB-12 356616 3551 ns/op 290.04 MB/s 4368 B/op 21 allocs/op +BenchmarkParse/escapes/1KiB-12 328112 3550 ns/op 290.12 MB/s 4368 B/op 21 allocs/op +BenchmarkParse/escapes/64KiB-12 8210 148062 ns/op 442.67 MB/s 262544 B/op 34 allocs/op +BenchmarkParse/escapes/64KiB-12 7800 148624 ns/op 440.99 MB/s 262544 B/op 34 allocs/op +BenchmarkParse/escapes/64KiB-12 7808 148647 ns/op 440.92 MB/s 262544 B/op 34 allocs/op +BenchmarkParse/escapes/64KiB-12 8032 153218 ns/op 427.77 MB/s 262544 B/op 34 allocs/op +BenchmarkParse/escapes/64KiB-12 8584 150255 ns/op 436.21 MB/s 262544 B/op 34 allocs/op +BenchmarkParse/escapes/64KiB-12 8349 149158 ns/op 439.41 MB/s 262544 B/op 34 allocs/op +BenchmarkParse/escapes/64KiB-12 7939 148068 ns/op 442.65 MB/s 262544 B/op 34 allocs/op +BenchmarkParse/escapes/64KiB-12 8061 149061 ns/op 439.7 MB/s 262544 B/op 34 allocs/op +BenchmarkParse/escapes/64KiB-12 8014 150630 ns/op 435.12 MB/s 262544 B/op 34 allocs/op +BenchmarkParse/escapes/64KiB-12 8048 148891 ns/op 440.2 MB/s 262544 B/op 34 allocs/op +BenchmarkParse/escapes/1024KiB-12 495 2.552001e+06 ns/op 410.89 MB/s 4.120986e+06 B/op 44 allocs/op +BenchmarkParse/escapes/1024KiB-12 422 2.692705e+06 ns/op 389.42 MB/s 4.120988e+06 B/op 44 allocs/op +BenchmarkParse/escapes/1024KiB-12 441 2.563992e+06 ns/op 408.96 MB/s 4.120985e+06 B/op 44 allocs/op +BenchmarkParse/escapes/1024KiB-12 432 2.677018e+06 ns/op 391.7 MB/s 4.120989e+06 B/op 44 allocs/op +BenchmarkParse/escapes/1024KiB-12 459 2.570174e+06 ns/op 407.98 MB/s 4.120988e+06 B/op 44 allocs/op +BenchmarkParse/escapes/1024KiB-12 486 2.589066e+06 ns/op 405 MB/s 4.120989e+06 B/op 44 allocs/op +BenchmarkParse/escapes/1024KiB-12 457 2.431313e+06 ns/op 431.28 MB/s 4.120985e+06 B/op 44 allocs/op +BenchmarkParse/escapes/1024KiB-12 484 2.465482e+06 ns/op 425.31 MB/s 4.12099e+06 B/op 44 allocs/op +BenchmarkParse/escapes/1024KiB-12 502 2.388281e+06 ns/op 439.05 MB/s 4.120985e+06 B/op 44 allocs/op +BenchmarkParse/escapes/1024KiB-12 523 2.378019e+06 ns/op 440.95 MB/s 4.120985e+06 B/op 44 allocs/op +BenchmarkParse/same_key/1KiB-12 71072 16630 ns/op 61.7 MB/s 48672 B/op 22 allocs/op +BenchmarkParse/same_key/1KiB-12 72723 16650 ns/op 61.62 MB/s 48672 B/op 22 allocs/op +BenchmarkParse/same_key/1KiB-12 73953 16546 ns/op 62.01 MB/s 48672 B/op 22 allocs/op +BenchmarkParse/same_key/1KiB-12 67302 17913 ns/op 57.28 MB/s 48672 B/op 22 allocs/op +BenchmarkParse/same_key/1KiB-12 66685 18020 ns/op 56.94 MB/s 48672 B/op 22 allocs/op +BenchmarkParse/same_key/1KiB-12 72214 16651 ns/op 61.62 MB/s 48672 B/op 22 allocs/op +BenchmarkParse/same_key/1KiB-12 72188 16496 ns/op 62.2 MB/s 48672 B/op 22 allocs/op +BenchmarkParse/same_key/1KiB-12 68553 16908 ns/op 60.68 MB/s 48672 B/op 22 allocs/op +BenchmarkParse/same_key/1KiB-12 70267 16939 ns/op 60.57 MB/s 48672 B/op 22 allocs/op +BenchmarkParse/same_key/1KiB-12 70260 16728 ns/op 61.33 MB/s 48672 B/op 22 allocs/op +BenchmarkParse/same_key/64KiB-12 664 1.826244e+06 ns/op 35.89 MB/s 4.446123e+06 B/op 34 allocs/op +BenchmarkParse/same_key/64KiB-12 650 1.891215e+06 ns/op 34.65 MB/s 4.44612e+06 B/op 34 allocs/op +BenchmarkParse/same_key/64KiB-12 621 1.851504e+06 ns/op 35.4 MB/s 4.446119e+06 B/op 34 allocs/op +BenchmarkParse/same_key/64KiB-12 654 1.818073e+06 ns/op 36.05 MB/s 4.446118e+06 B/op 34 allocs/op +BenchmarkParse/same_key/64KiB-12 658 1.824682e+06 ns/op 35.92 MB/s 4.446117e+06 B/op 34 allocs/op +BenchmarkParse/same_key/64KiB-12 662 1.845494e+06 ns/op 35.51 MB/s 4.446119e+06 B/op 34 allocs/op +BenchmarkParse/same_key/64KiB-12 640 1.853216e+06 ns/op 35.36 MB/s 4.446119e+06 B/op 34 allocs/op +BenchmarkParse/same_key/64KiB-12 637 1.851019e+06 ns/op 35.41 MB/s 4.446118e+06 B/op 34 allocs/op +BenchmarkParse/same_key/64KiB-12 675 1.807891e+06 ns/op 36.25 MB/s 4.446119e+06 B/op 34 allocs/op +BenchmarkParse/same_key/64KiB-12 684 1.7897e+06 ns/op 36.62 MB/s 4.446118e+06 B/op 34 allocs/op +BenchmarkParse/same_key/1024KiB-12 45 2.6231202e+07 ns/op 39.97 MB/s 7.4962855e+07 B/op 46 allocs/op +BenchmarkParse/same_key/1024KiB-12 46 2.5111723e+07 ns/op 41.76 MB/s 7.4962848e+07 B/op 46 allocs/op +BenchmarkParse/same_key/1024KiB-12 48 2.4809864e+07 ns/op 42.26 MB/s 7.4962968e+07 B/op 46 allocs/op +BenchmarkParse/same_key/1024KiB-12 48 2.475029e+07 ns/op 42.37 MB/s 7.4962848e+07 B/op 46 allocs/op +BenchmarkParse/same_key/1024KiB-12 48 2.506669e+07 ns/op 41.83 MB/s 7.4962848e+07 B/op 46 allocs/op +BenchmarkParse/same_key/1024KiB-12 45 2.5566657e+07 ns/op 41.01 MB/s 7.4962848e+07 B/op 46 allocs/op +BenchmarkParse/same_key/1024KiB-12 46 2.5403104e+07 ns/op 41.28 MB/s 7.4962848e+07 B/op 46 allocs/op +BenchmarkParse/same_key/1024KiB-12 46 2.5523669e+07 ns/op 41.08 MB/s 7.496285e+07 B/op 46 allocs/op +BenchmarkParse/same_key/1024KiB-12 45 2.5917124e+07 ns/op 40.46 MB/s 7.4962848e+07 B/op 46 allocs/op +BenchmarkParse/same_key/1024KiB-12 43 2.6897904e+07 ns/op 38.98 MB/s 7.4962853e+07 B/op 46 allocs/op +BenchmarkParse/headers/1KiB-12 167066 6818 ns/op 150.19 MB/s 12960 B/op 12 allocs/op +BenchmarkParse/headers/1KiB-12 178939 6829 ns/op 149.94 MB/s 12960 B/op 12 allocs/op +BenchmarkParse/headers/1KiB-12 179001 6842 ns/op 149.67 MB/s 12960 B/op 12 allocs/op +BenchmarkParse/headers/1KiB-12 177456 6766 ns/op 151.35 MB/s 12960 B/op 12 allocs/op +BenchmarkParse/headers/1KiB-12 180487 6843 ns/op 149.64 MB/s 12960 B/op 12 allocs/op +BenchmarkParse/headers/1KiB-12 172934 6784 ns/op 150.94 MB/s 12960 B/op 12 allocs/op +BenchmarkParse/headers/1KiB-12 156220 6976 ns/op 146.79 MB/s 12960 B/op 12 allocs/op +BenchmarkParse/headers/1KiB-12 183199 6850 ns/op 149.5 MB/s 12960 B/op 12 allocs/op +BenchmarkParse/headers/1KiB-12 174961 6834 ns/op 149.83 MB/s 12960 B/op 12 allocs/op +BenchmarkParse/headers/1KiB-12 178612 6906 ns/op 148.28 MB/s 12960 B/op 12 allocs/op +BenchmarkParse/headers/64KiB-12 3112 379353 ns/op 172.76 MB/s 730145 B/op 12 allocs/op +BenchmarkParse/headers/64KiB-12 2973 398466 ns/op 164.47 MB/s 730145 B/op 12 allocs/op +BenchmarkParse/headers/64KiB-12 3016 399233 ns/op 164.15 MB/s 730145 B/op 12 allocs/op +BenchmarkParse/headers/64KiB-12 2869 399890 ns/op 163.88 MB/s 730145 B/op 12 allocs/op +BenchmarkParse/headers/64KiB-12 3040 408991 ns/op 160.24 MB/s 730145 B/op 12 allocs/op +BenchmarkParse/headers/64KiB-12 2791 394505 ns/op 166.12 MB/s 730145 B/op 12 allocs/op +BenchmarkParse/headers/64KiB-12 3133 387418 ns/op 169.16 MB/s 730145 B/op 12 allocs/op +BenchmarkParse/headers/64KiB-12 2839 391336 ns/op 167.47 MB/s 730145 B/op 12 allocs/op +BenchmarkParse/headers/64KiB-12 3094 400192 ns/op 163.76 MB/s 730145 B/op 12 allocs/op +BenchmarkParse/headers/64KiB-12 2900 391480 ns/op 167.41 MB/s 730145 B/op 12 allocs/op +BenchmarkParse/headers/1024KiB-12 199 5.828334e+06 ns/op 179.91 MB/s 1.1543585e+07 B/op 12 allocs/op +BenchmarkParse/headers/1024KiB-12 210 5.630595e+06 ns/op 186.23 MB/s 1.1543584e+07 B/op 12 allocs/op +BenchmarkParse/headers/1024KiB-12 210 5.630526e+06 ns/op 186.23 MB/s 1.1543584e+07 B/op 12 allocs/op +BenchmarkParse/headers/1024KiB-12 212 5.609366e+06 ns/op 186.93 MB/s 1.1543584e+07 B/op 12 allocs/op +BenchmarkParse/headers/1024KiB-12 212 5.713623e+06 ns/op 183.52 MB/s 1.1543586e+07 B/op 12 allocs/op +BenchmarkParse/headers/1024KiB-12 207 5.744549e+06 ns/op 182.53 MB/s 1.1543585e+07 B/op 12 allocs/op +BenchmarkParse/headers/1024KiB-12 208 5.702827e+06 ns/op 183.87 MB/s 1.1543584e+07 B/op 12 allocs/op +BenchmarkParse/headers/1024KiB-12 202 5.809036e+06 ns/op 180.51 MB/s 1.1543585e+07 B/op 12 allocs/op +BenchmarkParse/headers/1024KiB-12 208 5.727577e+06 ns/op 183.07 MB/s 1.1543584e+07 B/op 12 allocs/op +BenchmarkParse/headers/1024KiB-12 207 5.781065e+06 ns/op 181.38 MB/s 1.1543585e+07 B/op 12 allocs/op +BenchmarkParse/long_subsection/1KiB-12 471932 2516 ns/op 408.11 MB/s 5112 B/op 19 allocs/op +BenchmarkParse/long_subsection/1KiB-12 476712 2505 ns/op 410.02 MB/s 5112 B/op 19 allocs/op +BenchmarkParse/long_subsection/1KiB-12 486252 2597 ns/op 395.47 MB/s 5112 B/op 19 allocs/op +BenchmarkParse/long_subsection/1KiB-12 456918 2651 ns/op 387.38 MB/s 5112 B/op 19 allocs/op +BenchmarkParse/long_subsection/1KiB-12 454606 2737 ns/op 375.24 MB/s 5112 B/op 19 allocs/op +BenchmarkParse/long_subsection/1KiB-12 452276 2603 ns/op 394.62 MB/s 5112 B/op 19 allocs/op +BenchmarkParse/long_subsection/1KiB-12 477220 2542 ns/op 404 MB/s 5112 B/op 19 allocs/op +BenchmarkParse/long_subsection/1KiB-12 488622 2545 ns/op 403.54 MB/s 5112 B/op 19 allocs/op +BenchmarkParse/long_subsection/1KiB-12 494998 2500 ns/op 410.75 MB/s 5112 B/op 19 allocs/op +BenchmarkParse/long_subsection/1KiB-12 474442 2553 ns/op 402.24 MB/s 5112 B/op 19 allocs/op +BenchmarkParse/long_subsection/64KiB-12 9476 110812 ns/op 591.45 MB/s 335865 B/op 32 allocs/op +BenchmarkParse/long_subsection/64KiB-12 10000 109076 ns/op 600.85 MB/s 335866 B/op 32 allocs/op +BenchmarkParse/long_subsection/64KiB-12 10000 106781 ns/op 613.77 MB/s 335865 B/op 32 allocs/op +BenchmarkParse/long_subsection/64KiB-12 10000 107454 ns/op 609.93 MB/s 335865 B/op 32 allocs/op +BenchmarkParse/long_subsection/64KiB-12 10000 105492 ns/op 621.27 MB/s 335865 B/op 32 allocs/op +BenchmarkParse/long_subsection/64KiB-12 10000 111444 ns/op 588.09 MB/s 335866 B/op 32 allocs/op +BenchmarkParse/long_subsection/64KiB-12 10000 105963 ns/op 618.51 MB/s 335865 B/op 32 allocs/op +BenchmarkParse/long_subsection/64KiB-12 10000 104771 ns/op 625.54 MB/s 335865 B/op 32 allocs/op +BenchmarkParse/long_subsection/64KiB-12 10000 106865 ns/op 613.29 MB/s 335865 B/op 32 allocs/op +BenchmarkParse/long_subsection/64KiB-12 10000 105530 ns/op 621.04 MB/s 335866 B/op 32 allocs/op +BenchmarkParse/long_subsection/1024KiB-12 556 2.266373e+06 ns/op 462.67 MB/s 5.177367e+06 B/op 42 allocs/op +BenchmarkParse/long_subsection/1024KiB-12 537 2.258514e+06 ns/op 464.28 MB/s 5.17736e+06 B/op 42 allocs/op +BenchmarkParse/long_subsection/1024KiB-12 536 2.227851e+06 ns/op 470.67 MB/s 5.177365e+06 B/op 42 allocs/op +BenchmarkParse/long_subsection/1024KiB-12 549 2.281338e+06 ns/op 459.63 MB/s 5.177361e+06 B/op 42 allocs/op +BenchmarkParse/long_subsection/1024KiB-12 537 2.283466e+06 ns/op 459.21 MB/s 5.177366e+06 B/op 42 allocs/op +BenchmarkParse/long_subsection/1024KiB-12 526 2.257562e+06 ns/op 464.47 MB/s 5.177362e+06 B/op 42 allocs/op +BenchmarkParse/long_subsection/1024KiB-12 543 2.185419e+06 ns/op 479.81 MB/s 5.177367e+06 B/op 42 allocs/op +BenchmarkParse/long_subsection/1024KiB-12 506 2.240107e+06 ns/op 468.09 MB/s 5.177365e+06 B/op 42 allocs/op +BenchmarkParse/long_subsection/1024KiB-12 534 2.256651e+06 ns/op 464.66 MB/s 5.177367e+06 B/op 42 allocs/op +BenchmarkParse/long_subsection/1024KiB-12 501 2.249869e+06 ns/op 466.06 MB/s 5.177366e+06 B/op 42 allocs/op +BenchmarkParse/comments/1KiB-12 413898 2862 ns/op 358.85 MB/s 8016 B/op 7 allocs/op +BenchmarkParse/comments/1KiB-12 396931 2908 ns/op 353.22 MB/s 8016 B/op 7 allocs/op +BenchmarkParse/comments/1KiB-12 384942 2944 ns/op 348.79 MB/s 8016 B/op 7 allocs/op +BenchmarkParse/comments/1KiB-12 396912 2855 ns/op 359.76 MB/s 8016 B/op 7 allocs/op +BenchmarkParse/comments/1KiB-12 408728 2854 ns/op 359.8 MB/s 8016 B/op 7 allocs/op +BenchmarkParse/comments/1KiB-12 412206 2929 ns/op 350.64 MB/s 8016 B/op 7 allocs/op +BenchmarkParse/comments/1KiB-12 420957 2859 ns/op 359.21 MB/s 8016 B/op 7 allocs/op +BenchmarkParse/comments/1KiB-12 423242 2846 ns/op 360.92 MB/s 8016 B/op 7 allocs/op +BenchmarkParse/comments/1KiB-12 433494 2887 ns/op 355.73 MB/s 8016 B/op 7 allocs/op +BenchmarkParse/comments/1KiB-12 449575 2870 ns/op 357.85 MB/s 8016 B/op 7 allocs/op +BenchmarkParse/comments/64KiB-12 7530 163541 ns/op 400.79 MB/s 483664 B/op 7 allocs/op +BenchmarkParse/comments/64KiB-12 7156 161723 ns/op 405.3 MB/s 483664 B/op 7 allocs/op +BenchmarkParse/comments/64KiB-12 6975 163812 ns/op 400.13 MB/s 483665 B/op 7 allocs/op +BenchmarkParse/comments/64KiB-12 7422 161467 ns/op 405.94 MB/s 483664 B/op 7 allocs/op +BenchmarkParse/comments/64KiB-12 6914 161553 ns/op 405.72 MB/s 483664 B/op 7 allocs/op +BenchmarkParse/comments/64KiB-12 6943 164399 ns/op 398.7 MB/s 483665 B/op 7 allocs/op +BenchmarkParse/comments/64KiB-12 6032 166916 ns/op 392.69 MB/s 483665 B/op 7 allocs/op +BenchmarkParse/comments/64KiB-12 7501 164736 ns/op 397.89 MB/s 483664 B/op 7 allocs/op +BenchmarkParse/comments/64KiB-12 6940 160267 ns/op 408.98 MB/s 483664 B/op 7 allocs/op +BenchmarkParse/comments/64KiB-12 6241 161307 ns/op 406.34 MB/s 483664 B/op 7 allocs/op +BenchmarkParse/comments/1024KiB-12 464 2.567127e+06 ns/op 408.46 MB/s 7.512401e+06 B/op 7 allocs/op +BenchmarkParse/comments/1024KiB-12 470 2.521007e+06 ns/op 415.94 MB/s 7.5124e+06 B/op 7 allocs/op +BenchmarkParse/comments/1024KiB-12 477 2.497534e+06 ns/op 419.85 MB/s 7.5124e+06 B/op 7 allocs/op +BenchmarkParse/comments/1024KiB-12 469 2.523982e+06 ns/op 415.45 MB/s 7.5124e+06 B/op 7 allocs/op +BenchmarkParse/comments/1024KiB-12 465 2.53307e+06 ns/op 413.96 MB/s 7.512401e+06 B/op 7 allocs/op +BenchmarkParse/comments/1024KiB-12 482 2.515405e+06 ns/op 416.86 MB/s 7.5124e+06 B/op 7 allocs/op +BenchmarkParse/comments/1024KiB-12 484 2.492833e+06 ns/op 420.64 MB/s 7.5124e+06 B/op 7 allocs/op +BenchmarkParse/comments/1024KiB-12 477 2.504671e+06 ns/op 418.65 MB/s 7.5124e+06 B/op 7 allocs/op +BenchmarkParse/comments/1024KiB-12 465 2.534522e+06 ns/op 413.72 MB/s 7.512401e+06 B/op 7 allocs/op +BenchmarkParse/comments/1024KiB-12 452 2.562974e+06 ns/op 409.13 MB/s 7.512401e+06 B/op 7 allocs/op +BenchmarkEdit/UnsetAll_one_section/1KiB-12 30248 39691 ns/op 25.85 MB/s 68184 B/op 41 allocs/op +BenchmarkEdit/UnsetAll_one_section/1KiB-12 28885 40981 ns/op 25.04 MB/s 68184 B/op 41 allocs/op +BenchmarkEdit/UnsetAll_one_section/1KiB-12 29887 40633 ns/op 25.25 MB/s 68184 B/op 41 allocs/op +BenchmarkEdit/UnsetAll_one_section/1KiB-12 30684 39624 ns/op 25.89 MB/s 68184 B/op 41 allocs/op +BenchmarkEdit/UnsetAll_one_section/1KiB-12 30318 39602 ns/op 25.91 MB/s 68184 B/op 41 allocs/op +BenchmarkEdit/UnsetAll_one_section/1KiB-12 30070 39310 ns/op 26.1 MB/s 68184 B/op 41 allocs/op +BenchmarkEdit/UnsetAll_one_section/1KiB-12 30463 39687 ns/op 25.85 MB/s 68184 B/op 41 allocs/op +BenchmarkEdit/UnsetAll_one_section/1KiB-12 30253 40485 ns/op 25.34 MB/s 68184 B/op 41 allocs/op +BenchmarkEdit/UnsetAll_one_section/1KiB-12 29690 39938 ns/op 25.69 MB/s 68184 B/op 41 allocs/op +BenchmarkEdit/UnsetAll_one_section/1KiB-12 30445 39678 ns/op 25.86 MB/s 68184 B/op 41 allocs/op +BenchmarkEdit/UnsetAll_one_section/64KiB-12 400 3.018787e+06 ns/op 21.71 MB/s 5.705927e+06 B/op 93 allocs/op +BenchmarkEdit/UnsetAll_one_section/64KiB-12 394 3.031728e+06 ns/op 21.62 MB/s 5.70593e+06 B/op 93 allocs/op +BenchmarkEdit/UnsetAll_one_section/64KiB-12 397 3.02041e+06 ns/op 21.7 MB/s 5.705932e+06 B/op 93 allocs/op +BenchmarkEdit/UnsetAll_one_section/64KiB-12 384 3.098119e+06 ns/op 21.15 MB/s 5.705945e+06 B/op 93 allocs/op +BenchmarkEdit/UnsetAll_one_section/64KiB-12 393 2.987426e+06 ns/op 21.94 MB/s 5.705935e+06 B/op 93 allocs/op +BenchmarkEdit/UnsetAll_one_section/64KiB-12 391 3.022324e+06 ns/op 21.68 MB/s 5.705932e+06 B/op 93 allocs/op +BenchmarkEdit/UnsetAll_one_section/64KiB-12 394 3.134989e+06 ns/op 20.91 MB/s 5.70593e+06 B/op 93 allocs/op +BenchmarkEdit/UnsetAll_one_section/64KiB-12 378 3.147148e+06 ns/op 20.82 MB/s 5.705931e+06 B/op 93 allocs/op +BenchmarkEdit/UnsetAll_one_section/64KiB-12 397 3.075578e+06 ns/op 21.31 MB/s 5.70593e+06 B/op 93 allocs/op +BenchmarkEdit/UnsetAll_one_section/64KiB-12 405 3.012771e+06 ns/op 21.75 MB/s 5.705927e+06 B/op 93 allocs/op +BenchmarkEdit/UnsetAll_one_section/1024KiB-12 21 5.3726348e+07 ns/op 19.52 MB/s 9.5762504e+07 B/op 596 allocs/op +BenchmarkEdit/UnsetAll_one_section/1024KiB-12 21 5.3193404e+07 ns/op 19.71 MB/s 9.5762238e+07 B/op 596 allocs/op +BenchmarkEdit/UnsetAll_one_section/1024KiB-12 20 5.5104985e+07 ns/op 19.03 MB/s 9.576225e+07 B/op 596 allocs/op +BenchmarkEdit/UnsetAll_one_section/1024KiB-12 21 5.7249859e+07 ns/op 18.32 MB/s 9.5762243e+07 B/op 596 allocs/op +BenchmarkEdit/UnsetAll_one_section/1024KiB-12 22 5.4863962e+07 ns/op 19.11 MB/s 9.5762242e+07 B/op 596 allocs/op +BenchmarkEdit/UnsetAll_one_section/1024KiB-12 21 5.5631806e+07 ns/op 18.85 MB/s 9.5762243e+07 B/op 596 allocs/op +BenchmarkEdit/UnsetAll_one_section/1024KiB-12 22 5.6294417e+07 ns/op 18.63 MB/s 9.5762237e+07 B/op 596 allocs/op +BenchmarkEdit/UnsetAll_one_section/1024KiB-12 21 5.4814864e+07 ns/op 19.13 MB/s 9.5762238e+07 B/op 596 allocs/op +BenchmarkEdit/UnsetAll_one_section/1024KiB-12 22 5.4993133e+07 ns/op 19.07 MB/s 9.5762232e+07 B/op 596 allocs/op +BenchmarkEdit/UnsetAll_one_section/1024KiB-12 20 5.6212895e+07 ns/op 18.65 MB/s 9.5762239e+07 B/op 596 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 27382 44019 ns/op 23.49 MB/s 68568 B/op 40 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 27558 43466 ns/op 23.79 MB/s 68568 B/op 40 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 27434 43873 ns/op 23.57 MB/s 68568 B/op 40 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 27482 43902 ns/op 23.55 MB/s 68568 B/op 40 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 27218 43620 ns/op 23.7 MB/s 68568 B/op 40 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 27433 43651 ns/op 23.69 MB/s 68568 B/op 40 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 27334 43785 ns/op 23.62 MB/s 68568 B/op 40 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 26629 44409 ns/op 23.28 MB/s 68568 B/op 40 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 26890 43757 ns/op 23.63 MB/s 68568 B/op 40 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1KiB-12 26859 44192 ns/op 23.4 MB/s 68568 B/op 40 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 368 3.25052e+06 ns/op 20.16 MB/s 3.903353e+06 B/op 72 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 368 3.239066e+06 ns/op 20.23 MB/s 3.903355e+06 B/op 72 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 372 3.214841e+06 ns/op 20.39 MB/s 3.903355e+06 B/op 72 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 369 3.231707e+06 ns/op 20.28 MB/s 3.903357e+06 B/op 72 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 340 3.431382e+06 ns/op 19.1 MB/s 3.903358e+06 B/op 72 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 373 3.245817e+06 ns/op 20.19 MB/s 3.903354e+06 B/op 72 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 380 3.183671e+06 ns/op 20.59 MB/s 3.903353e+06 B/op 72 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 370 3.21263e+06 ns/op 20.4 MB/s 3.903355e+06 B/op 72 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 357 3.297649e+06 ns/op 19.87 MB/s 3.903356e+06 B/op 72 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/64KiB-12 372 3.301616e+06 ns/op 19.85 MB/s 3.903353e+06 B/op 72 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 25 4.7101973e+07 ns/op 22.26 MB/s 6.7551927e+07 B/op 335 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 24 4.6501323e+07 ns/op 22.55 MB/s 6.7551928e+07 B/op 335 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 25 4.6851508e+07 ns/op 22.38 MB/s 6.7551927e+07 B/op 335 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 25 4.6525166e+07 ns/op 22.54 MB/s 6.7551927e+07 B/op 335 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 25 4.7196917e+07 ns/op 22.22 MB/s 6.7551927e+07 B/op 335 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 22 4.7113476e+07 ns/op 22.26 MB/s 6.7551928e+07 B/op 335 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 25 4.6917263e+07 ns/op 22.35 MB/s 6.7551927e+07 B/op 335 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 22 4.7983891e+07 ns/op 21.85 MB/s 6.7551938e+07 B/op 335 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 24 4.6804266e+07 ns/op 22.4 MB/s 6.7551928e+07 B/op 335 allocs/op +BenchmarkEdit/UnsetAll_section_per_value/1024KiB-12 25 4.7128275e+07 ns/op 22.25 MB/s 6.7551927e+07 B/op 335 allocs/op +BenchmarkEdit/RenameSection_one_line/1KiB-12 26847 44797 ns/op 23.06 MB/s 91888 B/op 58 allocs/op +BenchmarkEdit/RenameSection_one_line/1KiB-12 27152 44660 ns/op 23.13 MB/s 91888 B/op 58 allocs/op +BenchmarkEdit/RenameSection_one_line/1KiB-12 26806 45758 ns/op 22.58 MB/s 91888 B/op 58 allocs/op +BenchmarkEdit/RenameSection_one_line/1KiB-12 26992 44653 ns/op 23.13 MB/s 91888 B/op 58 allocs/op +BenchmarkEdit/RenameSection_one_line/1KiB-12 26252 45162 ns/op 22.87 MB/s 91888 B/op 58 allocs/op +BenchmarkEdit/RenameSection_one_line/1KiB-12 26881 45251 ns/op 22.83 MB/s 91888 B/op 58 allocs/op +BenchmarkEdit/RenameSection_one_line/1KiB-12 26350 45127 ns/op 22.89 MB/s 91888 B/op 58 allocs/op +BenchmarkEdit/RenameSection_one_line/1KiB-12 26959 45181 ns/op 22.86 MB/s 91888 B/op 58 allocs/op +BenchmarkEdit/RenameSection_one_line/1KiB-12 26979 45261 ns/op 22.82 MB/s 91888 B/op 58 allocs/op +BenchmarkEdit/RenameSection_one_line/1KiB-12 26582 44233 ns/op 23.35 MB/s 91888 B/op 58 allocs/op +BenchmarkEdit/RenameSection_one_line/64KiB-12 256 4.717275e+06 ns/op 13.89 MB/s 1.0203484e+07 B/op 108 allocs/op +BenchmarkEdit/RenameSection_one_line/64KiB-12 249 4.882828e+06 ns/op 13.42 MB/s 1.0203494e+07 B/op 108 allocs/op +BenchmarkEdit/RenameSection_one_line/64KiB-12 254 4.741235e+06 ns/op 13.82 MB/s 1.0203489e+07 B/op 108 allocs/op +BenchmarkEdit/RenameSection_one_line/64KiB-12 252 4.919881e+06 ns/op 13.32 MB/s 1.0203484e+07 B/op 108 allocs/op +BenchmarkEdit/RenameSection_one_line/64KiB-12 248 4.822133e+06 ns/op 13.59 MB/s 1.0203494e+07 B/op 108 allocs/op +BenchmarkEdit/RenameSection_one_line/64KiB-12 240 4.947286e+06 ns/op 13.25 MB/s 1.0203484e+07 B/op 108 allocs/op +BenchmarkEdit/RenameSection_one_line/64KiB-12 238 4.965071e+06 ns/op 13.2 MB/s 1.0203492e+07 B/op 108 allocs/op +BenchmarkEdit/RenameSection_one_line/64KiB-12 213 5.277208e+06 ns/op 12.42 MB/s 1.0203491e+07 B/op 108 allocs/op +BenchmarkEdit/RenameSection_one_line/64KiB-12 234 5.035859e+06 ns/op 13.02 MB/s 1.0203492e+07 B/op 108 allocs/op +BenchmarkEdit/RenameSection_one_line/64KiB-12 241 4.964547e+06 ns/op 13.2 MB/s 1.0203485e+07 B/op 108 allocs/op +BenchmarkEdit/RenameSection_one_line/1024KiB-12 20 5.7212119e+07 ns/op 18.33 MB/s 1.75182164e+08 B/op 155 allocs/op +BenchmarkEdit/RenameSection_one_line/1024KiB-12 18 5.6285053e+07 ns/op 18.63 MB/s 1.75182156e+08 B/op 155 allocs/op +BenchmarkEdit/RenameSection_one_line/1024KiB-12 18 5.6764819e+07 ns/op 18.47 MB/s 1.75182175e+08 B/op 156 allocs/op +BenchmarkEdit/RenameSection_one_line/1024KiB-12 18 5.6595931e+07 ns/op 18.53 MB/s 1.75182182e+08 B/op 156 allocs/op +BenchmarkEdit/RenameSection_one_line/1024KiB-12 18 5.8090739e+07 ns/op 18.05 MB/s 1.751822e+08 B/op 156 allocs/op +BenchmarkEdit/RenameSection_one_line/1024KiB-12 18 5.7314467e+07 ns/op 18.3 MB/s 1.75182168e+08 B/op 155 allocs/op +BenchmarkEdit/RenameSection_one_line/1024KiB-12 18 5.715157e+07 ns/op 18.35 MB/s 1.7518215e+08 B/op 155 allocs/op +BenchmarkEdit/RenameSection_one_line/1024KiB-12 18 5.6573782e+07 ns/op 18.53 MB/s 1.751822e+08 B/op 156 allocs/op +BenchmarkEdit/RenameSection_one_line/1024KiB-12 20 5.7670295e+07 ns/op 18.18 MB/s 1.75182208e+08 B/op 156 allocs/op +BenchmarkEdit/RenameSection_one_line/1024KiB-12 19 5.865655e+07 ns/op 17.88 MB/s 1.75182204e+08 B/op 156 allocs/op +BenchmarkFile/Set/n=10-12 41673 29335 ns/op 32534 B/op 162 allocs/op +BenchmarkFile/Set/n=10-12 41652 29408 ns/op 32534 B/op 162 allocs/op +BenchmarkFile/Set/n=10-12 40716 29653 ns/op 32534 B/op 162 allocs/op +BenchmarkFile/Set/n=10-12 41114 29747 ns/op 32534 B/op 162 allocs/op +BenchmarkFile/Set/n=10-12 41599 29386 ns/op 32534 B/op 162 allocs/op +BenchmarkFile/Set/n=10-12 39153 31075 ns/op 32534 B/op 162 allocs/op +BenchmarkFile/Set/n=10-12 38833 29808 ns/op 32534 B/op 162 allocs/op +BenchmarkFile/Set/n=10-12 41344 29403 ns/op 32534 B/op 162 allocs/op +BenchmarkFile/Set/n=10-12 40138 29783 ns/op 32534 B/op 162 allocs/op +BenchmarkFile/Set/n=10-12 41134 29993 ns/op 32534 B/op 162 allocs/op +BenchmarkFile/SetUnchanged/n=10-12 1728762 705.7 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=10-12 1631811 713.9 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=10-12 1771570 677.3 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=10-12 1767153 684.1 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=10-12 1771474 681.1 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=10-12 1770790 676.5 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=10-12 1751448 685.8 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=10-12 1748499 682.4 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=10-12 1740174 686.2 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=10-12 1764769 678.5 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetNewSection/n=10-12 23562 50788 ns/op 67432 B/op 327 allocs/op +BenchmarkFile/SetNewSection/n=10-12 23940 50323 ns/op 67432 B/op 327 allocs/op +BenchmarkFile/SetNewSection/n=10-12 23473 50955 ns/op 67432 B/op 327 allocs/op +BenchmarkFile/SetNewSection/n=10-12 23218 51762 ns/op 67432 B/op 327 allocs/op +BenchmarkFile/SetNewSection/n=10-12 23976 50369 ns/op 67432 B/op 327 allocs/op +BenchmarkFile/SetNewSection/n=10-12 23823 49981 ns/op 67432 B/op 327 allocs/op +BenchmarkFile/SetNewSection/n=10-12 23792 50717 ns/op 67432 B/op 327 allocs/op +BenchmarkFile/SetNewSection/n=10-12 22773 52963 ns/op 67432 B/op 327 allocs/op +BenchmarkFile/SetNewSection/n=10-12 22906 51646 ns/op 67432 B/op 327 allocs/op +BenchmarkFile/SetNewSection/n=10-12 23438 51483 ns/op 67432 B/op 327 allocs/op +BenchmarkFile/ConfigAfterEdit/n=10-12 25704 46585 ns/op 63839 B/op 240 allocs/op +BenchmarkFile/ConfigAfterEdit/n=10-12 25952 46559 ns/op 63839 B/op 240 allocs/op +BenchmarkFile/ConfigAfterEdit/n=10-12 25489 46513 ns/op 63839 B/op 240 allocs/op +BenchmarkFile/ConfigAfterEdit/n=10-12 26023 46133 ns/op 63839 B/op 240 allocs/op +BenchmarkFile/ConfigAfterEdit/n=10-12 26163 46769 ns/op 63839 B/op 240 allocs/op +BenchmarkFile/ConfigAfterEdit/n=10-12 25068 47073 ns/op 63839 B/op 240 allocs/op +BenchmarkFile/ConfigAfterEdit/n=10-12 25882 46493 ns/op 63839 B/op 240 allocs/op +BenchmarkFile/ConfigAfterEdit/n=10-12 25860 46505 ns/op 63839 B/op 240 allocs/op +BenchmarkFile/ConfigAfterEdit/n=10-12 25404 47202 ns/op 63839 B/op 240 allocs/op +BenchmarkFile/ConfigAfterEdit/n=10-12 25201 46701 ns/op 63839 B/op 240 allocs/op +BenchmarkFile/Bytes/n=10-12 4164099 297.8 ns/op 1536 B/op 1 allocs/op +BenchmarkFile/Bytes/n=10-12 4033780 298.3 ns/op 1536 B/op 1 allocs/op +BenchmarkFile/Bytes/n=10-12 4128052 296.8 ns/op 1536 B/op 1 allocs/op +BenchmarkFile/Bytes/n=10-12 4124798 298.6 ns/op 1536 B/op 1 allocs/op +BenchmarkFile/Bytes/n=10-12 4043148 293.2 ns/op 1536 B/op 1 allocs/op +BenchmarkFile/Bytes/n=10-12 3803600 301.5 ns/op 1536 B/op 1 allocs/op +BenchmarkFile/Bytes/n=10-12 3759801 300.2 ns/op 1536 B/op 1 allocs/op +BenchmarkFile/Bytes/n=10-12 4021701 293.5 ns/op 1536 B/op 1 allocs/op +BenchmarkFile/Bytes/n=10-12 4109550 290.4 ns/op 1536 B/op 1 allocs/op +BenchmarkFile/Bytes/n=10-12 4009456 297.6 ns/op 1536 B/op 1 allocs/op +BenchmarkFile/Set/n=1000-12 411 2.868195e+06 ns/op 3.53158e+06 B/op 10127 allocs/op +BenchmarkFile/Set/n=1000-12 441 2.743965e+06 ns/op 3.531581e+06 B/op 10127 allocs/op +BenchmarkFile/Set/n=1000-12 415 2.805316e+06 ns/op 3.53158e+06 B/op 10127 allocs/op +BenchmarkFile/Set/n=1000-12 429 2.816515e+06 ns/op 3.531581e+06 B/op 10127 allocs/op +BenchmarkFile/Set/n=1000-12 409 2.87294e+06 ns/op 3.531581e+06 B/op 10127 allocs/op +BenchmarkFile/Set/n=1000-12 420 2.834364e+06 ns/op 3.53158e+06 B/op 10127 allocs/op +BenchmarkFile/Set/n=1000-12 393 2.830313e+06 ns/op 3.531579e+06 B/op 10127 allocs/op +BenchmarkFile/Set/n=1000-12 417 2.895135e+06 ns/op 3.531581e+06 B/op 10127 allocs/op +BenchmarkFile/Set/n=1000-12 418 2.908667e+06 ns/op 3.53158e+06 B/op 10127 allocs/op +BenchmarkFile/Set/n=1000-12 418 2.89274e+06 ns/op 3.531581e+06 B/op 10127 allocs/op +BenchmarkFile/SetUnchanged/n=1000-12 23536 50099 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=1000-12 23934 50065 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=1000-12 24116 49964 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=1000-12 23734 50294 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=1000-12 23936 50395 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=1000-12 24082 49991 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=1000-12 24067 49918 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=1000-12 24110 49165 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=1000-12 23938 49023 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetUnchanged/n=1000-12 22592 49977 ns/op 8 B/op 1 allocs/op +BenchmarkFile/SetNewSection/n=1000-12 195 5.912392e+06 ns/op 7.063893e+06 B/op 20257 allocs/op +BenchmarkFile/SetNewSection/n=1000-12 213 5.713267e+06 ns/op 7.063893e+06 B/op 20257 allocs/op +BenchmarkFile/SetNewSection/n=1000-12 210 5.759223e+06 ns/op 7.063892e+06 B/op 20257 allocs/op +BenchmarkFile/SetNewSection/n=1000-12 206 5.808959e+06 ns/op 7.063891e+06 B/op 20257 allocs/op +BenchmarkFile/SetNewSection/n=1000-12 207 5.749402e+06 ns/op 7.063895e+06 B/op 20257 allocs/op +BenchmarkFile/SetNewSection/n=1000-12 205 5.814124e+06 ns/op 7.063893e+06 B/op 20257 allocs/op +BenchmarkFile/SetNewSection/n=1000-12 207 5.723606e+06 ns/op 7.06389e+06 B/op 20257 allocs/op +BenchmarkFile/SetNewSection/n=1000-12 206 5.800222e+06 ns/op 7.063892e+06 B/op 20257 allocs/op +BenchmarkFile/SetNewSection/n=1000-12 202 5.852603e+06 ns/op 7.063894e+06 B/op 20257 allocs/op +BenchmarkFile/SetNewSection/n=1000-12 211 5.762766e+06 ns/op 7.063896e+06 B/op 20257 allocs/op +BenchmarkFile/ConfigAfterEdit/n=1000-12 192 6.223014e+06 ns/op 7.377055e+06 B/op 14249 allocs/op +BenchmarkFile/ConfigAfterEdit/n=1000-12 195 6.133095e+06 ns/op 7.377056e+06 B/op 14249 allocs/op +BenchmarkFile/ConfigAfterEdit/n=1000-12 194 6.205278e+06 ns/op 7.377058e+06 B/op 14249 allocs/op +BenchmarkFile/ConfigAfterEdit/n=1000-12 193 6.143424e+06 ns/op 7.376123e+06 B/op 14249 allocs/op +BenchmarkFile/ConfigAfterEdit/n=1000-12 196 6.170515e+06 ns/op 7.377063e+06 B/op 14249 allocs/op +BenchmarkFile/ConfigAfterEdit/n=1000-12 190 6.191896e+06 ns/op 7.377058e+06 B/op 14249 allocs/op +BenchmarkFile/ConfigAfterEdit/n=1000-12 192 6.199909e+06 ns/op 7.377057e+06 B/op 14249 allocs/op +BenchmarkFile/ConfigAfterEdit/n=1000-12 193 6.404785e+06 ns/op 7.377065e+06 B/op 14249 allocs/op +BenchmarkFile/ConfigAfterEdit/n=1000-12 188 6.32039e+06 ns/op 7.377065e+06 B/op 14249 allocs/op +BenchmarkFile/ConfigAfterEdit/n=1000-12 192 6.210494e+06 ns/op 7.377059e+06 B/op 14249 allocs/op +BenchmarkFile/Bytes/n=1000-12 36672 32750 ns/op 155649 B/op 1 allocs/op +BenchmarkFile/Bytes/n=1000-12 40292 31666 ns/op 155650 B/op 1 allocs/op +BenchmarkFile/Bytes/n=1000-12 40029 30171 ns/op 155650 B/op 1 allocs/op +BenchmarkFile/Bytes/n=1000-12 42747 30375 ns/op 155650 B/op 1 allocs/op +BenchmarkFile/Bytes/n=1000-12 40814 31550 ns/op 155649 B/op 1 allocs/op +BenchmarkFile/Bytes/n=1000-12 35986 31921 ns/op 155648 B/op 1 allocs/op +BenchmarkFile/Bytes/n=1000-12 38697 31148 ns/op 155648 B/op 1 allocs/op +BenchmarkFile/Bytes/n=1000-12 36982 31782 ns/op 155648 B/op 1 allocs/op +BenchmarkFile/Bytes/n=1000-12 38062 31989 ns/op 155648 B/op 1 allocs/op +BenchmarkFile/Bytes/n=1000-12 39504 31617 ns/op 155648 B/op 1 allocs/op diff --git a/env.go b/env.go index 109c543..730e3c4 100644 --- a/env.go +++ b/env.go @@ -211,6 +211,13 @@ func (e Env) SafeDirectory(dir string) (bool, error) { return false, err } dir = realPath(dir) + if !filepath.IsAbs(dir) { + // The entries that count are absolute. Joining the real working + // directory drops a leading ".." correctly: it has no links. + if wd, err := os.Getwd(); err == nil { + dir = filepath.Join(realPath(wd), dir) + } + } safe := false for _, entry := range c.GetAll("safe.directory") { switch v := entry.Value; { @@ -220,7 +227,8 @@ func (e Env) SafeDirectory(dir string) (bool, error) { safe = true case strings.HasSuffix(v, "/*"): prefix, err := Entry{Value: strings.TrimSuffix(v, "*")}.Path(e.Home) - if err != nil { + if err != nil || !filepath.IsAbs(prefix) { + // As for exact entries, relative ones are skipped. continue } if p, err := filepath.EvalSymlinks(prefix); err == nil { diff --git a/env_test.go b/env_test.go index 780217e..ebe5ad6 100644 --- a/env_test.go +++ b/env_test.go @@ -529,6 +529,53 @@ func TestEnvIncludeIf(t *testing.T) { assert.True(t, included(t, env, "gitdir:"+s+"/link/"), "path as given") }) + t.Run("gitdir classes", func(t *testing.T) { + // Checked against git 2.56. A malformed class does not fall back + // to literal characters: the pattern matches nothing. + for _, tc := range []struct { + name string // of the directory holding .git + cond string + want bool + }{ + {"x1", "gitdir:" + s + "/x[[:digit:]]/", true}, + {"x1", "gitdir:" + s + "/[[:lower:]][[:digit:]]/", true}, + {"x1", "gitdir:" + s + "/[[:upper:]]1/", false}, + {"x1", "gitdir/i:" + s + "/[[:upper:]]1/", true}, + {"x1", "gitdir:" + s + "/x[[:alpha:][:digit:]]/", true}, + {"x1", "gitdir:" + s + "/x[![:alpha:]]/", true}, + {"x1", "gitdir:" + s + "/x[[:punct:]]/", false}, + {"x1", "gitdir:" + s + "/x[[:digit:]a-]/", true}, + {"x1", "gitdir:" + s + "/x[[:bogus:]]/", false}, + {"x1", "gitdir:" + s + "/x[![:bogus:]]/", false}, + {"x1", "gitdir:" + s + "/x[1[:bogus:]]/", false}, + {"x1", "gitdir:" + s + "/x[[:DIGIT:]]/", false}, + {"x1", "gitdir:" + s + "/x[[::]1]/", false}, + {"x1", "gitdir:" + s + "/x[[:digit:]/", false}, + {"x1", "gitdir:" + s + "/x1/[a", false}, + {"x-", "gitdir:" + s + "/x[[:digit:]-z]/", true}, + {"xd", "gitdir:" + s + "/x[[:digit]/", true}, // no ":]": '[', ':', 'd', ... + {"a[b", "gitdir:" + s + "/a[b/", false}, + {"a[b", "gitdir:" + s + "/a[[]b/", true}, + {"a[b", "gitdir:" + s + "/[[:alpha:]][[]b/", true}, + } { + t.Run(tc.name+" "+tc.cond, func(t *testing.T) { + gitDir := filepath.Join(dir, tc.name, ".git") + initRepo(t, gitDir, "") + assert.Equal(t, tc.want, included(t, gitconfig.Env{GitDir: gitDir}, tc.cond)) + }) + } + }) + + t.Run("malformed patterns take linear time", func(t *testing.T) { + // Each '[' would otherwise scan the rest of the pattern. A final + // ":]" makes each "[:" look for the end of a class name. + for _, p := range []string{"[", "[\\\\]", "[:", "[[:"} { + cond := "gitdir:" + strings.Repeat(p, 1<<18/len(p)) + assert.False(t, included(t, env, cond), "%q", p) + assert.False(t, included(t, env, cond+":]"), "%q, then \":]\"", p) + } + }) + t.Run("onbranch", func(t *testing.T) { for _, tc := range []struct { head string @@ -776,6 +823,32 @@ func TestEnvSafeDirectory(t *testing.T) { }) } + t.Run("relative directory", func(t *testing.T) { + // Checked against git 2.56: "../*" trusts nothing, as "../repo" + // does not. A relative dir is taken from the working directory. + t.Chdir(a) + for _, tc := range []struct { + entry string + dir string + want bool + }{ + {s + "/a", ".", true}, + {s + "/a/b", "b", true}, + {s + "/ab", "../ab", true}, + {s + "/*", "../ab", true}, + {"../*", "../ab", false}, + {"../ab", "../ab", false}, + } { + t.Run(tc.entry+" "+tc.dir, func(t *testing.T) { + global := filepath.Join(tempDir(t), "global") + writeFile(t, global, "[safe]\n\tdirectory = "+tc.entry+"\n") + got, err := gitconfig.Env{GlobalConfig: []string{global}}.SafeDirectory(tc.dir) + require.NoError(t, err) + assert.Equal(t, tc.want, got) + }) + } + }) + t.Run("listed through an include", func(t *testing.T) { dir := tempDir(t) writeFile(t, filepath.Join(dir, "global"), "[include]\n\tpath = inc\n") @@ -1333,6 +1406,26 @@ func TestEnvUpdateFileSymlinks(t *testing.T) { assertLink(t, filepath.Join(dir, "d", "l2"), "../real") }) + t.Run("relative target through a directory link", func(t *testing.T) { + if runtime.GOOS == "windows" { + t.Skip("Windows removes \"..\" from a path before following links") + } + // cfg/link -> d/../real, with cfg/d -> ../store/sub: the ".." is + // that of store/sub, so the file is store/real, not cfg/real. + dir := tempDir(t) + target := filepath.Join(dir, "store", "real") + decoy := filepath.Join(dir, "cfg", "real") + writeFile(t, target, "[a]\n\tk = v\n") + writeFile(t, decoy, "[a]\n\tk = v\n") + require.NoError(t, os.Mkdir(filepath.Join(dir, "store", "sub"), 0o755)) + symlink(t, "../store/sub", filepath.Join(dir, "cfg", "d")) + symlink(t, "d/../real", filepath.Join(dir, "cfg", "link")) + + require.NoError(t, gitconfig.Env{}.UpdateFile(filepath.Join(dir, "cfg", "link"), set)) + assert.Equal(t, "[a]\n\tk = w\n", readFile(t, target)) + assert.Equal(t, "[a]\n\tk = v\n", readFile(t, decoy)) + }) + t.Run("dangling link creates the target", func(t *testing.T) { dir := tempDir(t) link := filepath.Join(dir, "link") @@ -1596,6 +1689,23 @@ func TestEnvUpdateFilePermissions(t *testing.T) { }) } + t.Run("lock private until written", func(t *testing.T) { + path := filepath.Join(tempDir(t), "config") + writeFile(t, path, "[a]\n\tk = v\n") + require.NoError(t, os.Chmod(path, 0o644)) + + err := gitconfig.Env{}.UpdateFile(path, func(f *gitconfig.File) error { + fi, err := os.Stat(path + ".lock") + require.NoError(t, err) + assert.Equal(t, os.FileMode(0o600), fi.Mode().Perm()) + return f.Set("a.k", "w") + }) + require.NoError(t, err) + fi, err := os.Stat(path) + require.NoError(t, err) + assert.Equal(t, os.FileMode(0o644), fi.Mode().Perm()) + }) + t.Run("new file", func(t *testing.T) { // As any new file: 0666 minus the umask. dir := tempDir(t) diff --git a/glob.go b/glob.go index b92b626..765c5c2 100644 --- a/glob.go +++ b/glob.go @@ -1,10 +1,14 @@ package gitconfig +import "strings" + // The patterns of includeIf "gitdir:" and "onbranch:" are matched as paths: // '*' and '?' do not match '/', "**/" at the start of a segment matches any // number of directories, "**" ending the pattern after a '/' (or alone) // matches anything, "[...]" is a class of characters ("[!...]" or "[^...]" -// negated, "a-z" a range) and '\' quotes the next character. +// negated, "a-z" a range, "[:digit:]" a named class) and '\' quotes the +// next character. A pattern with an unterminated class, or an unknown class +// name, matches nothing, as in git. // // The pattern is compiled into tokens and matched by simulating every // possible position in the pattern at once, so that the time is linear in @@ -29,8 +33,11 @@ type globToken struct { negate bool // globClass } -func compileGlob(p string) []globToken { +// compileGlob compiles p, or returns false if it is malformed. +func compileGlob(p string) ([]globToken, bool) { var toks []globToken + // A "[:" starts a named class only if a ":]" follows somewhere. + lastColon := strings.LastIndex(p, ":]") segStart := true for i := 0; i < len(p); { c := p[i] @@ -56,13 +63,14 @@ func compileGlob(p string) []globToken { toks = append(toks, globToken{kind: globAny}) i++ case c == '[': - if tok, n, ok := compileClass(p[i:]); ok { - toks = append(toks, tok) - i += n - } else { - toks = append(toks, globToken{kind: globLit, c: c}) - i++ + tok, end, ok := compileClass(p, i, lastColon) + if !ok { + // Failing at once keeps the work linear: no other '[' + // rescans the rest of the pattern. + return nil, false } + toks = append(toks, tok) + i = end case c == '\\' && i+1 < len(p): toks = append(toks, globToken{kind: globLit, c: p[i+1]}) i += 2 @@ -72,14 +80,15 @@ func compileGlob(p string) []globToken { } segStart = toks[len(toks)-1].kind == globLit && toks[len(toks)-1].c == '/' } - return toks + return toks, true } -// compileClass compiles the class at the start of p, and returns its length, -// or false if it is not terminated. -func compileClass(p string) (globToken, int, bool) { +// compileClass compiles the class starting at p[start], and returns the +// index past its end, or false if it is not terminated or names an unknown +// class. lastColon is the index of the last ":]" in p. +func compileClass(p string, start, lastColon int) (globToken, int, bool) { tok := globToken{kind: globClass} - i := 1 + i := start + 1 if i < len(p) && (p[i] == '!' || p[i] == '^') { tok.negate = true i++ @@ -91,6 +100,18 @@ func compileClass(p string) (globToken, int, bool) { return tok, i + 1, true } first = false + if c == '[' && i+1 < len(p) && p[i+1] == ':' && i+2 <= lastColon { + // Found, as some ":]" starts at or after i+2. A known name + // ends within a few bytes, and an unknown one fails. + n := strings.Index(p[i+2:], ":]") + ranges, ok := namedClasses[p[i+2:i+2+n]] + if !ok { + return globToken{}, 0, false + } + tok.ranges = append(tok.ranges, ranges...) + i += 2 + n + 2 + continue + } if c == '\\' && i+1 < len(p) { i++ c = p[i] @@ -110,6 +131,22 @@ func compileClass(p string) (globToken, int, bool) { return globToken{}, 0, false } +// namedClasses are the ranges of the named classes, in ASCII. +var namedClasses = map[string][][2]byte{ + "alnum": {{'0', '9'}, {'A', 'Z'}, {'a', 'z'}}, + "alpha": {{'A', 'Z'}, {'a', 'z'}}, + "blank": {{' ', ' '}, {'\t', '\t'}}, + "cntrl": {{0, 31}, {127, 127}}, + "digit": {{'0', '9'}}, + "graph": {{'!', '~'}}, + "lower": {{'a', 'z'}}, + "print": {{' ', '~'}}, + "punct": {{'!', '/'}, {':', '@'}, {'[', '`'}, {'{', '~'}}, + "space": {{'\t', '\r'}, {' ', ' '}}, + "upper": {{'A', 'Z'}}, + "xdigit": {{'0', '9'}, {'A', 'F'}, {'a', 'f'}}, +} + func (t globToken) inClass(c byte, fold bool) bool { in := false for _, r := range t.ranges { @@ -135,7 +172,10 @@ func sameByte(a, b byte, fold bool) bool { // globMatch reports whether name matches pattern. With fold, the case of // ASCII letters is ignored. func globMatch(pattern, name string, fold bool) bool { - toks := compileGlob(pattern) + toks, ok := compileGlob(pattern) + if !ok { + return false + } n := int32(len(toks)) // A state is a position in the pattern, 2*s for token s, or 2*s+1 for // the inside of the directories matched by the globDirs token s. Only diff --git a/interop_test.go b/interop_test.go index 756e0cd..fb45641 100644 --- a/interop_test.go +++ b/interop_test.go @@ -781,6 +781,11 @@ var gitScenarios = []gitScenario{ "onbranch:mai", "onbranch:other", "onbranch:main/", + "onbranch:[[:lower:]]ain", + "onbranch:[[:digit:]]ain", + "onbranch:m[![:digit:]]in", + "onbranch:[[:bogus:]]ain", + "onbranch:ma[in", "nosuch:x", } var global strings.Builder diff --git a/update.go b/update.go index 9954819..a2ffa8e 100644 --- a/update.go +++ b/update.go @@ -22,8 +22,15 @@ func updateFile(path string, scope Scope, fn func(*File) error) (err error) { return err } + // The lock gets the target's permissions before the new content is + // written: until then, a lock replacing a file that exists is private, + // so that no one can open it and read a private file through it. + perm := os.FileMode(0o666) + if _, err := os.Lstat(target); err == nil { + perm = 0o600 + } lockPath := target + ".lock" - lock, err := os.OpenFile(lockPath, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o666) + lock, err := os.OpenFile(lockPath, os.O_WRONLY|os.O_CREATE|os.O_EXCL, perm) if err != nil { if errors.Is(err, fs.ErrExist) { return &FileError{Path: lockPath, Err: ErrLocked} @@ -60,9 +67,6 @@ func updateFile(path string, scope Scope, fn func(*File) error) (err error) { return nil } - if _, err := lock.Write(f.data); err != nil { - return &FileError{Path: lockPath, Err: err} - } if exists && runtime.GOOS != "windows" { fi, err := os.Stat(target) if err != nil { @@ -73,6 +77,9 @@ func updateFile(path string, scope Scope, fn func(*File) error) (err error) { return &FileError{Path: lockPath, Err: err} } } + if _, err := lock.Write(f.data); err != nil { + return &FileError{Path: lockPath, Err: err} + } if err := lock.Close(); err != nil { return &FileError{Path: lockPath, Err: err} } @@ -116,7 +123,10 @@ func followLinks(path string) (string, error) { return "", &FileError{Path: p, Err: err} } if !filepath.IsAbs(link) { - link = filepath.Join(filepath.Dir(p), link) + // Not filepath.Join: cleaning would drop a ".." before the + // system follows the links leading to it. + dir, _ := filepath.Split(p) + link = dir + link } p = link } From fb7205f79d86c0d520511cebaaa1564b05f8f016 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Michael=20Mur=C3=A9?= Date: Fri, 9 Oct 2026 16:24:54 +0200 Subject: [PATCH 06/10] address more PR reviews --- discover.go | 4 +++- env_test.go | 63 +++++++++++++++++++++++++++++++++++++++++++++++++++++ errors.go | 3 +-- load.go | 58 +++++++++++++++++++++++++++++++++++++++++++----- 4 files changed, 119 insertions(+), 9 deletions(-) diff --git a/discover.go b/discover.go index d3c9a37..3e35734 100644 --- a/discover.go +++ b/discover.go @@ -101,7 +101,9 @@ func resolveGitDir(gitDir string) (string, error) { return "", &FileError{Path: gitDir, Err: errors.New("invalid gitfile format")} } if !filepath.IsAbs(path) { - path = filepath.Join(filepath.Dir(gitDir), path) + if path, err = joinReal(filepath.Dir(gitDir), path); err != nil { + return "", &FileError{Path: gitDir, Err: err} + } } return path, nil } diff --git a/env_test.go b/env_test.go index ebe5ad6..7313a7f 100644 --- a/env_test.go +++ b/env_test.go @@ -464,6 +464,17 @@ func TestEnvLoadLimits(t *testing.T) { require.NoError(t, err) } }) + + t.Run("repeated includeIf paths", func(t *testing.T) { + // One costly pattern, then many paths under it: the condition is + // evaluated once, not once per path. + dir := tempDir(t) + writeFile(t, filepath.Join(dir, "main"), "[includeIf \"gitdir:"+strings.Repeat("a*", 1<<17)+"\"]\n"+strings.Repeat("path =\n", 1<<16)) + initRepo(t, filepath.Join(dir, ".git"), "") + + _, err := gitconfig.Env{GitDir: filepath.Join(dir, ".git"), GlobalConfig: []string{filepath.Join(dir, "main")}}.Load() + require.NoError(t, err) + }) } func TestEnvIncludeIf(t *testing.T) { @@ -529,6 +540,26 @@ func TestEnvIncludeIf(t *testing.T) { assert.True(t, included(t, env, "gitdir:"+s+"/link/"), "path as given") }) + t.Run("gitdir:./ from a relative file", func(t *testing.T) { + // "./" is the absolute directory of the file: loaded as "config" + // from cfg, "gitdir:./repo/" is cfg/repo/, not any repo/. + cfg := filepath.Join(tempDir(t), "cfg") + writeFile(t, filepath.Join(cfg, "config"), "[includeIf \"gitdir:./repo/\"]\n\tpath = "+s+"/inc\n") + t.Chdir(cfg) + for _, tc := range []struct { + gitDir string + want bool + }{ + {filepath.Join(cfg, "repo", ".git"), true}, + {filepath.Join(dir, "other", "repo", ".git"), false}, + } { + c, err := gitconfig.Env{GitDir: tc.gitDir}.LoadFile("config") + require.NoError(t, err) + _, ok := c.Get("a.k") + assert.Equal(t, tc.want, ok, tc.gitDir) + } + }) + t.Run("gitdir classes", func(t *testing.T) { // Checked against git 2.56. A malformed class does not fall back // to literal characters: the pattern matches nothing. @@ -738,6 +769,24 @@ func TestEnvLoadScope(t *testing.T) { require.NoError(t, err) assert.Equal(t, []scoped{{gitconfig.ScopeWorktree, "linked"}}, scopedValues(c.GetAll("a.k"))) }) + + t.Run("linked worktree through a link", func(t *testing.T) { + // commondir's ".." apply to the real directory, as the system + // resolves them, not to the link's parent. + env := fullEnv(t) + local := filepath.Join(env.GitDir, "config") + wt := addWorktree(t, env.GitDir, "wt", "other") + link := filepath.Join(tempDir(t), "wt") + symlink(t, wt, link) + env.GitDir = link + + path, err := env.WritePath(gitconfig.ScopeLocal) + require.NoError(t, err) + assert.Equal(t, local, path) + c, err := env.LoadScope(gitconfig.ScopeLocal) + require.NoError(t, err) + assert.Equal(t, "local", c.Value("a.k", "")) + }) } func TestEnvLoadFile(t *testing.T) { @@ -1092,6 +1141,20 @@ func TestDiscover(t *testing.T) { assert.Equal(t, wt, filepath.Clean(env.GitDir)) }) + t.Run("gitdir file through a link", func(t *testing.T) { + // The ".." of the gitdir file apply to the real directory that + // holds it, not to the link's parent. + home := cleanGitEnv(t) + gitDir := filepath.Join(home, "real", "target", ".git") + initRepo(t, gitDir, "") + writeFile(t, filepath.Join(home, "real", "proj", ".git"), "gitdir: ../target/.git\n") + symlink(t, filepath.Join(home, "real", "proj"), filepath.Join(home, "proj")) + + env, err := gitconfig.Discover(filepath.Join(home, "proj", ".git")) + require.NoError(t, err) + assert.Equal(t, gitDir, env.GitDir) + }) + t.Run("malformed gitdir file", func(t *testing.T) { home := cleanGitEnv(t) writeFile(t, filepath.Join(home, "wt", ".git"), "garbage\n") diff --git a/errors.go b/errors.go index dc7260c..2c784ed 100644 --- a/errors.go +++ b/errors.go @@ -88,8 +88,7 @@ type FileError struct { } func (e *FileError) Error() string { - var se *SyntaxError - if errors.As(e.Err, &se) && se.File == e.Path { + if se, ok := errors.AsType[*SyntaxError](e.Err); ok && se.File == e.Path { return se.Error() } return fmt.Sprintf("gitconfig: %s: %v", e.Path, e.Err) diff --git a/load.go b/load.go index 0d2b65e..f061f21 100644 --- a/load.go +++ b/load.go @@ -41,7 +41,9 @@ func (e Env) repo() (*repo, error) { case err == nil: dir := strings.TrimRight(string(data), "\r\n") if !filepath.IsAbs(dir) { - dir = filepath.Join(e.GitDir, dir) + if dir, err = joinReal(e.GitDir, dir); err != nil { + return nil, &FileError{Path: e.GitDir, Err: err} + } } r.commonDir = filepath.Clean(dir) case !errors.Is(err, fs.ErrNotExist): @@ -50,6 +52,17 @@ func (e Env) repo() (*repo, error) { return r, nil } +// joinReal joins the relative path rel to the directory dir as the system +// resolves it: the links of dir are followed before the ".." of rel apply, +// where filepath.Join would apply them first. +func joinReal(dir, rel string) (string, error) { + real, err := filepath.EvalSymlinks(dir) + if err != nil { + return "", err + } + return filepath.Join(real, rel), nil +} + func (r *repo) localConfig() string { return filepath.Join(r.commonDir, "config") } @@ -178,8 +191,14 @@ type loader struct { realGitDir string // with '/', "" if it cannot be resolved realDirRead bool + + conds map[condKey]bool // includeIf conditions evaluated so far } +// condKey is an includeIf condition and the file that holds it, which +// "gitdir:./" depends on. +type condKey struct{ cond, from string } + func (e Env) newLoader() (*loader, error) { r, err := e.repo() if err != nil { @@ -298,9 +317,28 @@ func dirPrefix(path string) string { return path[:i+1] } -// condition evaluates the condition of an includeIf. Unknown conditions, -// and those this package does not support (hasconfig:), are false. +// condition evaluates the condition of an includeIf, once per condition +// and file: a file can repeat path under one costly gitdir: pattern. func (l *loader) condition(cond, from string) (bool, error) { + k := condKey{cond, from} + if ok, found := l.conds[k]; found { + return ok, nil + } + ok, err := l.evalCondition(cond, from) + if err != nil { + return false, err + } + if l.conds == nil { + l.conds = make(map[condKey]bool) + } + l.conds[k] = ok + return ok, nil +} + +// evalCondition evaluates the condition of an includeIf. Unknown +// conditions, and those this package does not support (hasconfig:), are +// false. +func (l *loader) evalCondition(cond, from string) (bool, error) { switch { case strings.HasPrefix(cond, "gitdir:"): return l.gitdir(cond[len("gitdir:"):], from, false) @@ -326,8 +364,8 @@ func (l *loader) condition(cond, from string) (bool, error) { } // gitdir evaluates includeIf "gitdir:": "~/" is the home -// directory, "./" the directory of the including file, a relative pattern -// matches at any depth ("**/" prepended) and a trailing '/' matches +// directory, "./" the absolute directory of the including file, a relative +// pattern matches at any depth ("**/" prepended) and a trailing '/' matches // everything below ("**" appended). The pattern is matched against the git // directory as given and its real path. func (l *loader) gitdir(pattern, from string, fold bool) (bool, error) { @@ -336,7 +374,15 @@ func (l *loader) gitdir(pattern, from string, fold bool) (bool, error) { if from == "" { return false, &FileError{Path: pattern, Err: ErrNotAbsolute} } - pattern = filepath.ToSlash(dirPrefix(from)) + pattern[2:] + dir := dirPrefix(from) + if !filepath.IsAbs(from) { + abs, err := filepath.Abs(from) + if err != nil { + return false, &FileError{Path: from, Err: err} + } + dir = dirPrefix(abs) + } + pattern = filepath.ToSlash(dir) + pattern[2:] case strings.HasPrefix(pattern, "~/"): if l.env.Home == "" { return false, nil From 2cff948d4ebb6ad69283f5f23c7a04eb5a79082a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Michael=20Mur=C3=A9?= Date: Fri, 9 Oct 2026 16:34:27 +0200 Subject: [PATCH 07/10] simplify the code --- config.go | 15 ++----- edit.go | 109 ++++++++++++++++++++++++++------------------------- env.go | 115 ++++++++++++++++++++++++++++-------------------------- file.go | 77 ++++++++++++++---------------------- glob.go | 8 ++-- load.go | 3 +- parse.go | 55 ++++++++++++-------------- 7 files changed, 178 insertions(+), 204 deletions(-) diff --git a/config.go b/config.go index e41a291..9e9a64a 100644 --- a/config.go +++ b/config.go @@ -96,16 +96,10 @@ func (c *Config) GetAll(key string) []Entry { // All returns every entry, in order. func (c *Config) All() iter.Seq[Entry] { - return func(yield func(Entry) bool) { - if c == nil { - return - } - for _, e := range c.entries { - if !yield(e) { - return - } - } + if c == nil { + return slices.Values([]Entry(nil)) } + return slices.Values(c.entries) } // Section returns every entry of section [section] itself, in order; entries @@ -260,8 +254,7 @@ func (e Entry) Int() (int64, error) { // include paths: a leading "~/" is replaced by home, usually Env.Home. A "~/" // with an empty home, a leading "%(prefix)/" (the prefix of the git binary, // which depends on how it was built) and an implicit value are a -// *ValueError. Config.Path -// does the same for a key. +// *ValueError. Config.Path does the same for a key. func (e Entry) Path(home string) (string, error) { if e.Implicit { return "", e.error("path", nil) diff --git a/edit.go b/edit.go index da3e2e2..c790413 100644 --- a/edit.go +++ b/edit.go @@ -22,45 +22,33 @@ type splice struct { text string } -// editKey validates key for an edit and returns it in canonical form, with -// its section, subsection and name as the caller spelled them, for new -// lines and headers. -func editKey(key string) (k Key, section, sub, name string, err error) { +// prepare checks that the file is open and validates key for an edit. It +// returns the key in canonical form, with its section and name as the +// caller spelled them, for new lines and headers; the subsection of the +// canonical form is already spelled as given. +func (f *File) prepare(key string) (k Key, section, name string, err error) { + if err := f.checkOpen(key); err != nil { + return Key{}, "", "", err + } k, ok := parseKey(key) if !ok || k.Section == "" { - return Key{}, "", "", "", &KeyError{Key: key, Err: ErrInvalidKey} - } - first := strings.IndexByte(key, '.') - last := strings.LastIndexByte(key, '.') - section, name = key[:first], key[last+1:] - if k.HasSubsection { - sub = key[first+1 : last] + return Key{}, "", "", &KeyError{Key: key, Err: ErrInvalidKey} } - return k, section, sub, name, nil + section = key[:strings.IndexByte(key, '.')] + name = key[strings.LastIndexByte(key, '.')+1:] + return k, section, name, nil } -// prepare validates the key and, if value is not nil, the value of an edit. -func (f *File) prepare(key string, value *string) (k Key, section, sub, name string, err error) { - if err := f.checkOpen(key); err != nil { - return Key{}, "", "", "", err - } - k, section, sub, name, err = editKey(key) +// prepareValue is prepare for an edit that writes value. +func (f *File) prepareValue(key, value string) (k Key, section, name string, err error) { + k, section, name, err = f.prepare(key) if err != nil { - return Key{}, "", "", "", err - } - if value != nil { - if err := checkValue(key, *value); err != nil { - return Key{}, "", "", "", err - } + return Key{}, "", "", err } - return k, section, sub, name, nil -} - -func checkValue(key, value string) error { if strings.IndexByte(value, 0) >= 0 { - return &KeyError{Key: key, Err: ErrInvalidValue} + return Key{}, "", "", &KeyError{Key: key, Err: ErrInvalidValue} } - return nil + return k, section, name, nil } func (f *File) checkOpen(key string) error { @@ -75,7 +63,7 @@ func (f *File) entriesOf(k Key) []int { var idx []int sk := k.sectionKey() for i, it := range f.items { - if it.kind == itemEntry && it.inSection && f.secOf(it) == sk && f.nameOf(it) == k.Name { + if it.kind == itemEntry && f.secOf(it) == sk && f.nameOf(it) == k.Name { idx = append(idx, i) } } @@ -83,17 +71,17 @@ func (f *File) entriesOf(k Key) []int { } // flatEntry is an entry as the checks of an edit compare them: entries -// before any header included, origins left out. +// before any header included, with the zero sec, origins left out. The keys +// and sections edits compare them with always have a section name. type flatEntry struct { - inSection bool - sec sectionKey - name string - value string - implicit bool + sec sectionKey + name string + value string + implicit bool } func (e flatEntry) is(k Key) bool { - return e.inSection && e.sec == k.sectionKey() && e.name == k.Name + return e.sec == k.sectionKey() && e.name == k.Name } // flatCursor walks the entries of a parsed file, without copying them out: @@ -112,7 +100,7 @@ func (c *flatCursor) next() (flatEntry, bool) { if it.kind != itemEntry { continue } - e := flatEntry{it.inSection, c.p.secOf(it), c.p.nameOf(it), c.p.valueOf(it), it.implicit} + e := flatEntry{c.p.secOf(it), c.p.nameOf(it), c.p.valueOf(it), it.implicit} if c.keep == nil || c.keep(e) { return e, true } @@ -301,10 +289,11 @@ func (f *File) replaceEntry(i int, name, value string) splice { // removeEntry returns the splice that removes the entry at i: its line, or // the rest of the line after a header, which then ends with a newline. func (f *File) removeEntry(i int) splice { - if f.firstOnLine(i) { - return splice{f.ownStart(i), f.entryLineEnd(i), ""} + text := "" + if !f.firstOnLine(i) { + text = "\n" } - return splice{f.ownStart(i), f.entryLineEnd(i), "\n"} + return splice{f.ownStart(i), f.entryLineEnd(i), text} } // entryLineEnd returns where the line of the entry at i ends for git when it @@ -441,19 +430,14 @@ func (f *File) unsetEntry(i int, forward map[int]int, comments []int) splice { // insert returns the splice that adds a new entry for k, at the end of the // last section that matches, or in a new section at the end of the file. -func (f *File) insert(k Key, section, sub, name, value string) splice { - sk := k.sectionKey() - h := -1 - for i, it := range f.items { - if it.kind == itemHeader && f.secOf(it) == sk { - h = i - } - } +func (f *File) insert(k Key, section, name, value string) splice { line := formatEntry(name, value) - if h < 0 { - return splice{len(f.data), len(f.data), f.terminator() + formatHeader(section, sub, k.HasSubsection) + "\n" + line} + headers := f.headersOf(k.sectionKey()) + if len(headers) == 0 { + return splice{len(f.data), len(f.data), f.terminator() + formatHeader(section, k.Subsection, k.HasSubsection) + "\n" + line} } + h := headers[len(headers)-1] last := h for i := h + 1; i < len(f.items) && f.items[i].kind != itemHeader; i++ { if f.items[i].kind == itemEntry { @@ -481,6 +465,23 @@ func (f *File) insert(k Key, section, sub, name, value string) splice { return splice{end, end, "\n" + line} } +// prepareSection checks that the file is open and validates the name of a +// section given to a section edit, and its subsections. +func (f *File) prepareSection(section string, subs ...string) error { + if err := f.checkOpen(section); err != nil { + return err + } + if err := sectionArg(section); err != nil { + return err + } + for _, sub := range subs { + if !validSubsection(sub) { + return &KeyError{Key: sub, Err: ErrInvalidKey} + } + } + return nil +} + // sectionArg validates the name of a section given to a section edit. func sectionArg(section string) error { if section == "" || !validSection(section) { @@ -519,7 +520,7 @@ func (f *File) removeSection(name string, sk sectionKey) (bool, error) { splices = append(splices, splice{f.ownStart(h), end, ""}) } err := f.apply(name, splices, func(before, after *parsed) bool { - return sameEntries(before, after, func(e flatEntry) bool { return !e.inSection || e.sec != sk }, nil, nil) + return sameEntries(before, after, func(e flatEntry) bool { return e.sec != sk }, nil, nil) }) return err == nil, err } @@ -568,7 +569,7 @@ func (f *File) renameSection(name string, sk, to sectionKey, header string) erro } return f.apply(name, splices, func(before, after *parsed) bool { return sameEntries(before, after, nil, nil, func(e flatEntry) flatEntry { - if e.inSection && e.sec == sk { + if e.sec == sk { e.sec = to } return e diff --git a/env.go b/env.go index 730e3c4..8080051 100644 --- a/env.go +++ b/env.go @@ -139,15 +139,11 @@ func (e Env) Load() (*Config, error) { if err != nil { return nil, err } - if e.SystemConfig != "" { - if err := l.loadFile(e.SystemConfig, ScopeSystem, false); err != nil { - return nil, err - } + if err := l.system(false); err != nil { + return nil, err } - for _, path := range e.GlobalConfig { - if err := l.loadFile(path, ScopeGlobal, true); err != nil { - return nil, err - } + if err := l.global(); err != nil { + return nil, err } if l.repo != nil { start := len(l.entries) @@ -170,6 +166,26 @@ func (e Env) Load() (*Config, error) { return l.config(), nil } +// system loads the system scope, if any. If skipUnreadable, a file that +// cannot be read for lack of permission is skipped. +func (l *loader) system(skipUnreadable bool) error { + if l.env.SystemConfig == "" { + return nil + } + return l.loadFile(l.env.SystemConfig, ScopeSystem, skipUnreadable) +} + +// global loads the global scope, skipping the files that cannot be read for +// lack of permission, as git does. +func (l *loader) global() error { + for _, path := range l.env.GlobalConfig { + if err := l.loadFile(path, ScopeGlobal, true); err != nil { + return err + } + } + return nil +} + // LoadProtected returns the configuration of the protected scopes only, with // includes followed: system, global and command line, in that order. This is // what git uses for keys a repository must not be able to set, such as @@ -180,15 +196,11 @@ func (e Env) LoadProtected() (*Config, error) { if err != nil { return nil, err } - if e.SystemConfig != "" { - if err := l.loadFile(e.SystemConfig, ScopeSystem, true); err != nil { - return nil, err - } + if err := l.system(true); err != nil { + return nil, err } - for _, path := range e.GlobalConfig { - if err := l.loadFile(path, ScopeGlobal, true); err != nil { - return nil, err - } + if err := l.global(); err != nil { + return nil, err } if err := l.command(); err != nil { return nil, err @@ -226,7 +238,7 @@ func (e Env) SafeDirectory(dir string) (bool, error) { case v == "*": safe = true case strings.HasSuffix(v, "/*"): - prefix, err := Entry{Value: strings.TrimSuffix(v, "*")}.Path(e.Home) + prefix, err := expandPath(strings.TrimSuffix(v, "*"), e.Home) if err != nil || !filepath.IsAbs(prefix) { // As for exact entries, relative ones are skipped. continue @@ -237,7 +249,7 @@ func (e Env) SafeDirectory(dir string) (bool, error) { } } default: - p, err := entry.Path(e.Home) + p, err := expandPath(v, e.Home) if err != nil || !filepath.IsAbs(p) { // "." and unexpandable values are skipped. continue @@ -281,19 +293,13 @@ func (e Env) LoadScope(s Scope) (*Config, error) { } switch s { case ScopeSystem: - if e.SystemConfig != "" { - err = l.loadFile(e.SystemConfig, ScopeSystem, false) - } + err = l.system(false) case ScopeGlobal: - for _, path := range e.GlobalConfig { - if err = l.loadFile(path, ScopeGlobal, true); err != nil { - break - } - } + err = l.global() case ScopeLocal, ScopeWorktree: var path string var scope Scope - path, scope, err = e.scopeFile(s) + path, scope, err = scopeFile(l.repo, s) if err == nil { err = l.loadFile(path, scope, false) } @@ -332,37 +338,44 @@ func (e Env) LoadFile(path string) (*Config, error) { // ScopeLocal and ScopeWorktree outside a repository, ScopeWorktree in a // repository with several worktrees and no extensions.worktreeConfig. func (e Env) WritePath(s Scope) (string, error) { + path, _, err := e.writeTarget(s) + return path, err +} + +// writeTarget returns the file WritePath returns, and the scope its entries +// have. +func (e Env) writeTarget(s Scope) (string, Scope, error) { switch s { case ScopeSystem: if e.SystemConfig == "" { - return "", ErrNoScope + return "", 0, ErrNoScope } - return e.SystemConfig, nil + return e.SystemConfig, s, nil case ScopeGlobal: if len(e.GlobalConfig) == 0 { - return "", ErrNoScope + return "", 0, ErrNoScope } for i := len(e.GlobalConfig) - 1; i >= 0; i-- { if _, err := os.Lstat(e.GlobalConfig[i]); err == nil { - return e.GlobalConfig[i], nil + return e.GlobalConfig[i], s, nil } } - return e.GlobalConfig[len(e.GlobalConfig)-1], nil + return e.GlobalConfig[len(e.GlobalConfig)-1], s, nil case ScopeLocal, ScopeWorktree: - path, _, err := e.scopeFile(s) - return path, err + r, err := e.repo() + if err != nil { + return "", 0, err + } + return scopeFile(r, s) } - return "", ErrNoScope + return "", 0, ErrNoScope } -// scopeFile returns the file of the local or worktree scope, and the scope -// its entries have: without extensions.worktreeConfig, the worktree scope -// is the local config, if the repository has a single worktree. -func (e Env) scopeFile(s Scope) (string, Scope, error) { - r, err := e.repo() - if err != nil { - return "", 0, err - } +// scopeFile returns the file of the local or worktree scope of r, nil +// outside a repository, and the scope its entries have: without +// extensions.worktreeConfig, the worktree scope is the local config, if the +// repository has a single worktree. +func scopeFile(r *repo, s Scope) (string, Scope, error) { if r == nil { return "", 0, ErrNoScope } @@ -385,16 +398,7 @@ func (e Env) scopeFile(s Scope) (string, Scope, error) { // entries have the scope LoadScope gives them. Writes never go into an // included file. func (e Env) UpdateScope(s Scope, fn func(*File) error) error { - var path string - var scope Scope - var err error - switch s { - case ScopeLocal, ScopeWorktree: - path, scope, err = e.scopeFile(s) - default: - path, err = e.WritePath(s) - scope = s - } + path, scope, err := e.writeTarget(s) if err != nil { return err } @@ -422,8 +426,9 @@ func (e Env) UpdateScope(s Scope, fn func(*File) error) error { // for a moment. // // If fn returns an error or panics, the lock is released and nothing is -// written; the panic then continues. Readers see either the old or the new file, never a partial one. -// After fn returns, edits of the File fail with ErrClosed. +// written; the panic then continues. Readers see either the old or the new +// file, never a partial one. After fn returns, edits of the File fail with +// ErrClosed. // // Following the symbolic link in step 1 is what git does, and what dotfile // managers rely on. It also means that whoever controls the directory of diff --git a/file.go b/file.go index a0484be..03ebb60 100644 --- a/file.go +++ b/file.go @@ -27,8 +27,9 @@ import ( // // Edits fail with ErrInvalidKey if a key or section name is one git rejects, // or a key with an empty section (".sub.name", which git reads from a -// header [ "sub"]), and with ErrInvalidValue if a value contains a NUL byte. Removing something -// that is absent is not an error: the methods report what they removed. +// header [ "sub"]), and with ErrInvalidValue if a value contains a NUL +// byte. Removing something that is absent is not an error: the methods +// report what they removed. // // An edit cannot inject anything: whatever the key, subsection and value, // the edited file parses to the entries before the edit with exactly that @@ -90,46 +91,48 @@ func (f *File) Config() *Config { // difference with git's edits. An implicit entry ("[a]\n\tk") is never // already set, even for value "": it reads as true, and "k = " as false. func (f *File) Set(key, value string) error { - k, section, sub, name, err := f.prepare(key, &value) + k, section, name, err := f.prepareValue(key, value) if err != nil { return err } - idx := f.entriesOf(k) - switch { - case len(idx) > 1: - return &KeyError{Key: key, Err: ErrMultipleValues} - case len(idx) == 1: + var sp splice + switch idx := f.entriesOf(k); len(idx) { + case 0: + sp = f.insert(k, section, name, value) + case 1: if it := f.items[idx[0]]; !it.implicit && f.valueOf(it) == value { return nil } - return f.apply(key, []splice{f.replaceEntry(idx[0], name, value)}, checkKey(k, []string{value}, 0)) + sp = f.replaceEntry(idx[0], name, value) + default: + return &KeyError{Key: key, Err: ErrMultipleValues} } - return f.apply(key, []splice{f.insert(k, section, sub, name, value)}, checkKey(k, []string{value}, 0)) + return f.apply(key, []splice{sp}, checkKey(k, []string{value}, 0)) } // ReplaceAll replaces all values of key with a single value, or adds it if // key is absent, like `git config --replace-all `. func (f *File) ReplaceAll(key, value string) error { - k, section, sub, name, err := f.prepare(key, &value) + k, section, name, err := f.prepareValue(key, value) if err != nil { return err } - idx := f.entriesOf(k) - if len(idx) == 0 { - return f.apply(key, []splice{f.insert(k, section, sub, name, value)}, checkKey(k, []string{value}, 0)) - } - // The values collapse into one, at the place of the last. var splices []splice - for _, i := range idx[:len(idx)-1] { - splices = append(splices, f.removeEntry(i)) + if idx := f.entriesOf(k); len(idx) == 0 { + splices = append(splices, f.insert(k, section, name, value)) + } else { + // The values collapse into one, at the place of the last. + for _, i := range idx[:len(idx)-1] { + splices = append(splices, f.removeEntry(i)) + } + splices = append(splices, f.replaceEntry(idx[len(idx)-1], name, value)) } - splices = append(splices, f.replaceEntry(idx[len(idx)-1], name, value)) return f.apply(key, splices, checkKey(k, []string{value}, 0)) } // Add adds a value to key, keeping existing ones, like `git config --add`. func (f *File) Add(key, value string) error { - k, section, sub, name, err := f.prepare(key, &value) + k, section, name, err := f.prepareValue(key, value) if err != nil { return err } @@ -139,14 +142,14 @@ func (f *File) Add(key, value string) error { } want = append(want, value) // Implicit values are kept: only the new one must not be. - return f.apply(key, []splice{f.insert(k, section, sub, name, value)}, checkKey(k, want, len(want)-1)) + return f.apply(key, []splice{f.insert(k, section, name, value)}, checkKey(k, want, len(want)-1)) } // Unset removes the value of key, like `git config --unset `, and // reports whether there was one. It fails with ErrMultipleValues if key has // several values. func (f *File) Unset(key string) (removed bool, err error) { - k, _, _, _, err := f.prepare(key, nil) + k, _, _, err := f.prepare(key) if err != nil { return false, err } @@ -164,7 +167,7 @@ func (f *File) Unset(key string) (removed bool, err error) { // UnsetAll removes all values of key, like `git config --unset-all `, // and returns how many were removed. func (f *File) UnsetAll(key string) (removed int, err error) { - k, _, _, _, err := f.prepare(key, nil) + k, _, _, err := f.prepare(key) if err != nil { return 0, err } @@ -182,10 +185,7 @@ func (f *File) UnsetAll(key string) (removed int, err error) { // `git config --remove-section

`, and reports whether it was // present. Its subsections are kept. func (f *File) RemoveSection(section string) (removed bool, err error) { - if err := f.checkOpen(section); err != nil { - return false, err - } - if err := sectionArg(section); err != nil { + if err := f.prepareSection(section); err != nil { return false, err } return f.removeSection(section, sectionKey{section: lowerASCII(section)}) @@ -195,15 +195,9 @@ func (f *File) RemoveSection(section string) (removed bool, err error) { // like `git config --remove-section
.`, and reports whether // it was present. sub "" is the empty subsection [section ""]. func (f *File) RemoveSubsection(section, sub string) (removed bool, err error) { - if err := f.checkOpen(section); err != nil { - return false, err - } - if err := sectionArg(section); err != nil { + if err := f.prepareSection(section, sub); err != nil { return false, err } - if !validSubsection(sub) { - return false, &KeyError{Key: sub, Err: ErrInvalidKey} - } return f.removeSection(section, sectionKey{lowerASCII(section), sub, true}) } @@ -215,10 +209,7 @@ func (f *File) RemoveSubsection(section, sub string) (removed bool, err error) { // it does, both sections remain and read as one, as with git. To refuse // instead, check f.Config() first, in the same Env.UpdateFile callback. func (f *File) RenameSection(oldName, newName string) error { - if err := f.checkOpen(oldName); err != nil { - return err - } - if err := sectionArg(oldName); err != nil { + if err := f.prepareSection(oldName); err != nil { return err } if err := sectionArg(newName); err != nil { @@ -235,17 +226,9 @@ func (f *File) RenameSection(oldName, newName string) error { // rename` refuses one, and a caller doing the same checks // f.Config().Subsections first. func (f *File) RenameSubsection(section, oldSub, newSub string) error { - if err := f.checkOpen(section); err != nil { - return err - } - if err := sectionArg(section); err != nil { + if err := f.prepareSection(section, oldSub, newSub); err != nil { return err } - for _, sub := range []string{oldSub, newSub} { - if !validSubsection(sub) { - return &KeyError{Key: sub, Err: ErrInvalidKey} - } - } sec := lowerASCII(section) return f.renameSection(section, sectionKey{sec, oldSub, true}, sectionKey{sec, newSub, true}, formatHeader(section, newSub, true)) } diff --git a/glob.go b/glob.go index 765c5c2..667ca29 100644 --- a/glob.go +++ b/glob.go @@ -148,14 +148,12 @@ var namedClasses = map[string][][2]byte{ } func (t globToken) inClass(c byte, fold bool) bool { - in := false for _, r := range t.ranges { if r[0] <= c && c <= r[1] || fold && r[0] <= swapCase(c) && swapCase(c) <= r[1] { - in = true - break + return !t.negate } } - return in != t.negate + return t.negate } func swapCase(c byte) byte { @@ -166,7 +164,7 @@ func swapCase(c byte) byte { } func sameByte(a, b byte, fold bool) bool { - return a == b || fold && isAlpha(a) && a^0x20 == b + return a == b || fold && swapCase(a) == b } // globMatch reports whether name matches pattern. With fold, the case of diff --git a/load.go b/load.go index f061f21..0e0db93 100644 --- a/load.go +++ b/load.go @@ -217,8 +217,7 @@ func (l *loader) config() *Config { func (l *loader) loadFile(path string, scope Scope, skipUnreadable bool) error { err := l.load(path, scope, 0) if skipUnreadable { - var fe *FileError - if errors.As(err, &fe) && fe.Path == path && errors.Is(fe.Err, fs.ErrPermission) { + if fe, ok := errors.AsType[*FileError](err); ok && fe.Path == path && errors.Is(fe.Err, fs.ErrPermission) { return nil } } diff --git a/parse.go b/parse.go index 06030b0..b903e9d 100644 --- a/parse.go +++ b/parse.go @@ -24,15 +24,14 @@ const ( // costs the garbage collector nothing to scan: the decoded data of headers // and entries is in the tables of parsed. type item struct { - kind itemKind - inSection bool // false for an entry before any header - implicit bool // entries only: no '=' - open openEnd // entries only - sec int32 // the section a header opens or an entry is in: index in parsed.secs - text int32 // entries only: index in parsed.texts - start int // bytes of the item: data[start:end] - end int - line int // line of start, 1-based + kind itemKind + implicit bool // entries only: no '=' + open openEnd // entries only + sec int32 // the section a header opens or an entry is in: index in parsed.secs, 0 before any header + text int32 // entries only: index in parsed.texts + start int // bytes of the item: data[start:end] + end int + line int // line of start, 1-based } // entryText is the key name and the value of an entry. @@ -44,17 +43,21 @@ type entryText struct { // parsed is a parsed file: its items, and the data they refer to. type parsed struct { items []item - secs []sectionKey // secs[0] is the zero sectionKey, for entries before any header + // secs[0] is the zero sectionKey, for entries before any header. No + // header has it: a header always has a section name or a subsection. + secs []sectionKey texts []entryText } func (p *parsed) secOf(it item) sectionKey { return p.secs[it.sec] } +func (p *parsed) nameOf(it item) string { return p.texts[it.text].name } +func (p *parsed) valueOf(it item) string { return p.texts[it.text].value } // entries appends the entries of the file, those before any header left // out, to out. func (p *parsed) entries(scope Scope, file string, out []Entry) []Entry { for _, it := range p.items { - if it.kind != itemEntry || !it.inSection { + if it.kind != itemEntry || it.sec == 0 { continue } sec := p.secs[it.sec] @@ -68,8 +71,6 @@ func (p *parsed) entries(scope Scope, file string, out []Entry) []Entry { } return out } -func (p *parsed) nameOf(it item) string { return p.texts[it.text].name } -func (p *parsed) valueOf(it item) string { return p.texts[it.text].value } // openEnd tells how an entry at the end of the file ends, for an edit that // adds a line after it. @@ -90,12 +91,11 @@ type parser struct { pos int line int - sec int32 // current section - inSection bool - secIndex map[sectionKey]int32 - headers map[string]int32 // the section of each header, by its bytes - names map[string]string // key names, interned - buf []byte // scratch for values and subsections + sec int32 // current section + secIndex map[sectionKey]int32 + headers map[string]int32 // the section of each header, by its bytes + names map[string]string // key names, interned + buf []byte // scratch for values and subsections } // parse splits data into items, or returns the *SyntaxError git would @@ -115,7 +115,7 @@ func (p *parser) errorAt(line int, msg string) error { } func (p *parser) add(kind itemKind, start, end int) *item { - p.items = append(p.items, item{kind: kind, start: start, end: end, line: p.line, sec: p.sec, inSection: p.inSection}) + p.items = append(p.items, item{kind: kind, start: start, end: end, line: p.line, sec: p.sec}) return &p.items[len(p.items)-1] } @@ -287,7 +287,6 @@ func (p *parser) header() error { p.headers[string(d[start:i])] = sec } p.sec = sec - p.inSection = true p.pos = i p.add(itemHeader, start, i) return nil @@ -362,14 +361,9 @@ func (p *parser) value(i int) (string, int, int, openEnd, error) { pending = -1 } } - for i < len(d) { +loop: + for i < len(d) && !isNewline(d, i) { c := d[i] - if isNewline(d, i) { - if inQuote { - return "", 0, 0, 0, p.errorAt(p.line+lines, "unterminated quote") - } - break - } switch { case c == '\\': if i+1 == len(d) { @@ -416,17 +410,18 @@ func (p *parser) value(i int) (string, int, int, openEnd, error) { } i++ case c == '#' || c == ';': - goto end + break loop default: flush(i) buf = append(buf, c) i++ } } + // A comment ends the value only outside quotes: the quote is open only + // at a newline or the end of the file. if inQuote { return "", 0, 0, 0, p.errorAt(p.line+lines, "unterminated quote") } -end: if n := bytes.IndexByte(buf, 0); n >= 0 { // git stops reading the value at a NUL byte. buf = buf[:n] From 9c8e024bd095a7a1ed45619e65c7908d4c035c7d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Michael=20Mur=C3=A9?= Date: Fri, 9 Oct 2026 17:22:57 +0200 Subject: [PATCH 08/10] consistent errors across the full API --- discover.go | 20 ++++++++++++-------- docs/REQUIREMENTS.md | 2 +- env.go | 5 +++-- env_test.go | 34 +++++++++++++++++++--------------- errors.go | 19 +++++++++++++++++++ errors_test.go | 12 ++++++++++++ 6 files changed, 66 insertions(+), 26 deletions(-) diff --git a/discover.go b/discover.go index 3e35734..4924bdb 100644 --- a/discover.go +++ b/discover.go @@ -51,7 +51,7 @@ func discover(gitDir string, env environ) (Env, error) { if v, ok := env.Lookup("GIT_CONFIG_NOSYSTEM"); ok { b, err := parseBool(v) if err != nil { - return Env{}, fmt.Errorf("gitconfig: bad boolean environment value %q for GIT_CONFIG_NOSYSTEM", v) + return Env{}, &EnvError{Var: "GIT_CONFIG_NOSYSTEM", Err: fmt.Errorf("bad boolean value %q", v)} } noSystem = b } @@ -69,7 +69,7 @@ func discover(gitDir string, env environ) (Env, error) { } params, err := parseParameters(get(env, "GIT_CONFIG_PARAMETERS")) if err != nil { - return Env{}, err + return Env{}, &EnvError{Var: "GIT_CONFIG_PARAMETERS", Err: err} } e.Command = append(cmd, params...) @@ -118,24 +118,28 @@ func countEntries(env environ) ([]CommandEntry, error) { } n, err := strconv.ParseInt(count, 10, 32) if err != nil || count[0] < '0' || count[0] > '9' { - return nil, fmt.Errorf("gitconfig: bogus count in GIT_CONFIG_COUNT: %q", count) + return nil, &EnvError{Var: "GIT_CONFIG_COUNT", Err: fmt.Errorf("bogus count %q", count)} } var entries []CommandEntry for i := range int(n) { - key, ok := env.Lookup("GIT_CONFIG_KEY_" + strconv.Itoa(i)) + keyVar, valueVar := "GIT_CONFIG_KEY_"+strconv.Itoa(i), "GIT_CONFIG_VALUE_"+strconv.Itoa(i) + key, ok := env.Lookup(keyVar) if !ok { - return nil, fmt.Errorf("gitconfig: missing config key GIT_CONFIG_KEY_%d", i) + return nil, &EnvError{Var: keyVar, Err: errMissingVar} } - value, ok := env.Lookup("GIT_CONFIG_VALUE_" + strconv.Itoa(i)) + value, ok := env.Lookup(valueVar) if !ok { - return nil, fmt.Errorf("gitconfig: missing config value GIT_CONFIG_VALUE_%d", i) + return nil, &EnvError{Var: valueVar, Err: errMissingVar} } entries = append(entries, CommandEntry{Key: key, Value: value}) } return entries, nil } -var errBogusParameters = errors.New("gitconfig: bogus format in GIT_CONFIG_PARAMETERS") +var ( + errMissingVar = errors.New("missing") + errBogusParameters = errors.New("bogus format") +) // parseParameters parses GIT_CONFIG_PARAMETERS, where git passes its -c // options to the commands it runs: items separated by whitespace, each a diff --git a/docs/REQUIREMENTS.md b/docs/REQUIREMENTS.md index 255eab6..12e6838 100644 --- a/docs/REQUIREMENTS.md +++ b/docs/REQUIREMENTS.md @@ -77,7 +77,7 @@ from git, and the principles that decide it, are in | N5 | Go version no newer than the oldest of git-bug's and go-git's `go.mod` (both `go 1.26.0` today). | MUST | | N6 | Works on Linux, macOS and Windows (path handling, CRLF, rename-over-existing). | MUST | | N7 | MIT licence, compatible with go-git (Apache-2.0) and git-bug. No code derived from git (GPL-2.0-only): see [CLEAN-ROOM.md](CLEAN-ROOM.md). | MUST | -| N8 | Errors are sentinel values wrapped in typed errors (`KeyError`, `FileError`, `SyntaxError`, `ValueError`) usable with `errors.Is`/`errors.As`, and carry file/line/key context like git's messages. Which method returns which is listed in `errors.go`. | MUST | +| N8 | Errors are sentinel values wrapped in typed errors (`KeyError`, `FileError`, `SyntaxError`, `ValueError`, `EnvError`) usable with `errors.Is`/`errors.As`, and carry file/line/key context like git's messages. Which method returns which is listed in `errors.go`. | MUST | ## 6. Security diff --git a/env.go b/env.go index 8080051..569e0ea 100644 --- a/env.go +++ b/env.go @@ -112,8 +112,9 @@ type CommandEntry struct { // Without a home directory, Home is "" and the global files are those git // reads then: the XDG file if XDG_CONFIG_HOME is set, no ~/.gitconfig. // -// It fails if a gitdir file is malformed, or if GIT_CONFIG_COUNT or -// GIT_CONFIG_PARAMETERS is malformed, as git does. +// It fails if a gitdir file is malformed (a *FileError), or if +// GIT_CONFIG_NOSYSTEM, GIT_CONFIG_COUNT or GIT_CONFIG_PARAMETERS is +// malformed (an *EnvError), as git does. // // It is the only function of this package that reads the process // environment. diff --git a/env_test.go b/env_test.go index 7313a7f..c8a5e7f 100644 --- a/env_test.go +++ b/env_test.go @@ -1083,23 +1083,25 @@ func TestDiscover(t *testing.T) { } }) - t.Run("malformed command line", func(t *testing.T) { + t.Run("malformed environment", func(t *testing.T) { for _, tc := range []struct { - name string - vars map[string]string + name string + vars map[string]string + envVar string // EnvError.Var }{ - {"bogus count", map[string]string{"GIT_CONFIG_COUNT": "x"}}, - {"negative count", map[string]string{"GIT_CONFIG_COUNT": "-1"}}, - {"sign only", map[string]string{"GIT_CONFIG_COUNT": "+"}}, - {"space only", map[string]string{"GIT_CONFIG_COUNT": " "}}, + {"bogus count", map[string]string{"GIT_CONFIG_COUNT": "x"}, "GIT_CONFIG_COUNT"}, + {"negative count", map[string]string{"GIT_CONFIG_COUNT": "-1"}, "GIT_CONFIG_COUNT"}, + {"sign only", map[string]string{"GIT_CONFIG_COUNT": "+"}, "GIT_CONFIG_COUNT"}, + {"space only", map[string]string{"GIT_CONFIG_COUNT": " "}, "GIT_CONFIG_COUNT"}, // Accepted by git. - {"plus sign", map[string]string{"GIT_CONFIG_COUNT": "+1", "GIT_CONFIG_KEY_0": "a.k", "GIT_CONFIG_VALUE_0": "v"}}, - {"leading space", map[string]string{"GIT_CONFIG_COUNT": " 1", "GIT_CONFIG_KEY_0": "a.k", "GIT_CONFIG_VALUE_0": "v"}}, - {"negative zero", map[string]string{"GIT_CONFIG_COUNT": "-0"}}, - {"too many", map[string]string{"GIT_CONFIG_COUNT": "2147483648"}}, - {"missing key", map[string]string{"GIT_CONFIG_COUNT": "1", "GIT_CONFIG_VALUE_0": "v"}}, - {"missing value", map[string]string{"GIT_CONFIG_COUNT": "1", "GIT_CONFIG_KEY_0": "a.k"}}, - {"bad parameters", map[string]string{"GIT_CONFIG_PARAMETERS": "'a.k"}}, + {"plus sign", map[string]string{"GIT_CONFIG_COUNT": "+1", "GIT_CONFIG_KEY_0": "a.k", "GIT_CONFIG_VALUE_0": "v"}, "GIT_CONFIG_COUNT"}, + {"leading space", map[string]string{"GIT_CONFIG_COUNT": " 1", "GIT_CONFIG_KEY_0": "a.k", "GIT_CONFIG_VALUE_0": "v"}, "GIT_CONFIG_COUNT"}, + {"negative zero", map[string]string{"GIT_CONFIG_COUNT": "-0"}, "GIT_CONFIG_COUNT"}, + {"too many", map[string]string{"GIT_CONFIG_COUNT": "2147483648"}, "GIT_CONFIG_COUNT"}, + {"missing key", map[string]string{"GIT_CONFIG_COUNT": "1", "GIT_CONFIG_VALUE_0": "v"}, "GIT_CONFIG_KEY_0"}, + {"missing value", map[string]string{"GIT_CONFIG_COUNT": "1", "GIT_CONFIG_KEY_0": "a.k"}, "GIT_CONFIG_VALUE_0"}, + {"bad parameters", map[string]string{"GIT_CONFIG_PARAMETERS": "'a.k"}, "GIT_CONFIG_PARAMETERS"}, + {"bad nosystem", map[string]string{"GIT_CONFIG_NOSYSTEM": "maybe"}, "GIT_CONFIG_NOSYSTEM"}, } { t.Run(tc.name, func(t *testing.T) { cleanGitEnv(t) @@ -1107,7 +1109,9 @@ func TestDiscover(t *testing.T) { t.Setenv(k, v) } _, err := gitconfig.Discover("") - require.Error(t, err) + envErr, ok := errors.AsType[*gitconfig.EnvError](err) + require.True(t, ok, "got %v", err) + assert.Equal(t, tc.envVar, envErr.Var) }) } }) diff --git a/errors.go b/errors.go index 2c784ed..f170b68 100644 --- a/errors.go +++ b/errors.go @@ -17,6 +17,8 @@ import ( // writing), a *KeyError for an invalid CommandEntry key, and ErrNoScope // unwrapped, as no file is concerned. The error returned by the // callback of Env.UpdateFile or Env.UpdateScope is returned as is. +// - Discover also returns an *EnvError for an environment variable it +// cannot interpret. var ( // ErrNotFound is returned when the section or subsection to rename is // absent. Removing something absent is not an error. @@ -98,6 +100,23 @@ func (e *FileError) Unwrap() error { return e.Err } +// EnvError reports an environment variable Discover cannot interpret, as +// git refuses it: a malformed GIT_CONFIG_NOSYSTEM, GIT_CONFIG_COUNT or +// GIT_CONFIG_PARAMETERS, or a missing GIT_CONFIG_KEY_ or +// GIT_CONFIG_VALUE_. +type EnvError struct { + Var string // the variable's name, e.g. "GIT_CONFIG_COUNT" + Err error // the reason +} + +func (e *EnvError) Error() string { + return fmt.Sprintf("gitconfig: %s: %v", e.Var, e.Err) +} + +func (e *EnvError) Unwrap() error { + return e.Err +} + // SyntaxError reports a file git refuses to parse. Msg describes the problem // but never quotes the file's content, which may be a file that is not a // configuration file at all, reached through an include. diff --git a/errors_test.go b/errors_test.go index 44e10cc..fb1ff0e 100644 --- a/errors_test.go +++ b/errors_test.go @@ -57,6 +57,18 @@ func TestErrorMessagesEscapeControlCharacters(t *testing.T) { assert.NotContains(t, err.Error(), "\x1b") assert.NotContains(t, err.Error(), "\r") }) + + t.Run("EnvError", func(t *testing.T) { + for _, name := range []string{"GIT_CONFIG_COUNT", "GIT_CONFIG_NOSYSTEM"} { + cleanGitEnv(t) + t.Setenv(name, evil) + _, err := gitconfig.Discover("") + require.Error(t, err) + assert.NotContains(t, err.Error(), "\x1b") + assert.NotContains(t, err.Error(), "\r") + assert.Contains(t, err.Error(), name) + } + }) } func TestErrorMessagesHaveContext(t *testing.T) { From 615edb9764cce161245a92b97188d975396b54b2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Michael=20Mur=C3=A9?= Date: Fri, 9 Oct 2026 17:38:10 +0200 Subject: [PATCH 09/10] improve comments/doc --- config.go | 48 ++++++++++++++++++++++++++++-------------------- discover.go | 8 ++++++++ doc.go | 14 ++++++++++---- edit.go | 28 ++++++++++++++++++++++++---- env.go | 43 +++++++++++++++++++++++++++---------------- errors.go | 1 + file.go | 34 ++++++++++++++++++++-------------- glob.go | 11 +++++++++-- key.go | 13 ++++++++++--- load.go | 16 ++++++++++++---- parse.go | 7 +++++++ update.go | 2 ++ value.go | 12 +++++++++--- 13 files changed, 167 insertions(+), 70 deletions(-) diff --git a/config.go b/config.go index 9e9a64a..5f1fdf6 100644 --- a/config.go +++ b/config.go @@ -15,9 +15,8 @@ import ( // treats it as absent. Keys are usually constants in the caller's code; // check them once with ParseKey, for example in a test. // -// Methods returning a small result the caller owns return a slice (GetAll, -// Subsections); methods walking the configuration return an iterator (All, -// Section, Subsection). +// When a key has several values, the last one wins, as in git: Get, Value, +// Bool, Int and Path use it, GetAll returns them all. type Config struct { entries []Entry index map[Key][]int // positions in entries, by key @@ -27,7 +26,7 @@ type Config struct { subsections map[string][]string } -// newConfig returns a Config of entries, which it keeps. +// newConfig returns a Config of entries. It takes ownership of the slice. func newConfig(entries []Entry) *Config { c := &Config{ entries: entries, @@ -164,13 +163,17 @@ func (c *Config) Int(key string, def int64) (int64, error) { return n, nil } -// Path returns the last value for key as a path, as Entry.Path does with -// home, usually Env.Home. If key is absent, def is expanded the same way. A -// value or a def that cannot be expanded is a *ValueError (for def, its Entry -// has the key, Value def and a zero Origin); the result is then def as given. +// Path returns the last value for key expanded as a path by Entry.Path, or +// def if key is absent, expanded the same way. home is the home directory, +// usually Env.Home. +// +// A value that cannot be expanded is a *ValueError, and the result is then +// def, unexpanded. This also holds for def itself: its error reports it +// with an empty Origin. func (c *Config) Path(key, home, def string) (string, error) { e, ok := c.Get(key) if !ok { + // Expand def as an entry of key, so that an error names the key. k, _ := parseKey(key) e = Entry{Key: k, Value: def} } @@ -212,11 +215,11 @@ type Origin struct { // Env.UpdateScope has that scope. Scope Scope - // File is the file that holds the entry, possibly an included one, as - // git opened it: an include's relative path is joined to the including - // file's directory and not cleaned. "" for git -c. On Windows, the - // separators are those of the paths given, where git writes some - // paths with '/'. + // File is the file that holds the entry, possibly an included one, or + // "" for the command line. Like git, an included file's relative path + // is appended to the including file's directory without cleaning it: + // "/home/u/.config/git/../work.inc". On Windows the separators are + // kept as given, where git shows some paths with '/'. File string Line int // 1-based; 0 for git -c @@ -236,9 +239,11 @@ func (e Entry) Bool() (bool, error) { return b, nil } -// Int interprets the value as git does, including the k, m and g suffixes. -// An invalid unit, an out-of-range value or an implicit value is a -// *ValueError. +// Int interprets the value as git does: a decimal number, or octal with a +// leading "0" and hexadecimal with a leading "0x" as in C (so "010" is 8), +// optionally followed by a unit k, m or g (×1024, ×1024², ×1024³), case +// ignored. An invalid number or unit, a value out of the int64 range or an +// implicit value is a *ValueError. func (e Entry) Int() (int64, error) { if e.Implicit { return 0, e.error("int", nil) @@ -251,10 +256,13 @@ func (e Entry) Int() (int64, error) { } // Path interprets the value as a path, as git does for `--type=path` and for -// include paths: a leading "~/" is replaced by home, usually Env.Home. A "~/" -// with an empty home, a leading "%(prefix)/" (the prefix of the git binary, -// which depends on how it was built) and an implicit value are a -// *ValueError. Config.Path does the same for a key. +// include paths: a leading "~/", or a value of "~" alone, is replaced by +// home, usually Env.Home. Other values are returned unchanged; relative +// paths are not resolved. +// +// These are a *ValueError: "~" or "~/" with an empty home, "~user/" (not +// supported), a leading "%(prefix)/" (the install prefix of the git binary, +// unknown to this package) and an implicit value. func (e Entry) Path(home string) (string, error) { if e.Implicit { return "", e.error("path", nil) diff --git a/discover.go b/discover.go index 4924bdb..c97fb54 100644 --- a/discover.go +++ b/discover.go @@ -33,6 +33,7 @@ func discover(gitDir string, env environ) (Env, error) { } if g, ok := env.Lookup("GIT_CONFIG_GLOBAL"); ok { + // Set but empty: no global file at all. if g != "" { e.GlobalConfig = []string{g} } @@ -62,6 +63,9 @@ func discover(gitDir string, env environ) (Env, error) { case runtime.GOOS != "windows": e.SystemConfig = "/etc/gitconfig" } + // On Windows the system file is under git's installation directory, + // which this package cannot know: there is none unless + // GIT_CONFIG_SYSTEM names it. cmd, err := countEntries(env) if err != nil { @@ -88,6 +92,8 @@ func resolveGitDir(gitDir string) (string, error) { if err != nil { return "", err } + // A directory is the git directory itself. One that does not exist (yet) + // is not an error here: loading finds no files in it. fi, err := os.Stat(gitDir) if err != nil || !fi.Mode().IsRegular() { return gitDir, nil @@ -160,6 +166,7 @@ func parseParameters(s string) ([]CommandEntry, error) { } var c CommandEntry if v, ok := strings.CutPrefix(rest, "="); ok { + // The current form: 'key'='value', or 'key'= for no value. c.Key = key if v == "" || isParamSpace(v[0]) { c.Implicit = true @@ -171,6 +178,7 @@ func parseParameters(s string) ([]CommandEntry, error) { } } } else if k, v, ok := strings.Cut(key, "="); ok { + // The older form: 'key=value'. c.Key, c.Value = k, v } else { c.Key, c.Implicit = key, true diff --git a/doc.go b/doc.go index 7cd8eca..d69dfaa 100644 --- a/doc.go +++ b/doc.go @@ -8,7 +8,8 @@ // - [File] is the lossless, editable form of a single file. // - [Env] says where git's configuration comes from, and is the only way // to the disk: it loads scopes or files (following includes) and -// edits them under git's lock. +// edits them with git's lock file protocol, so that git and this +// package can safely write the same file. // // Reading the effective configuration of a repository and changing a value: // @@ -26,8 +27,13 @@ // }) // // Nothing in this package reads the process environment or the home -// directory, except [Discover], and only the methods of [Env] touch the -// filesystem. An Env built by hand is fully described by its fields; -// [Parse], [File] and [Config] do no I/O, for callers that store +// directory, except [Discover], and only [Discover] and the methods of [Env] +// touch the filesystem. An Env built by hand is fully described by its +// fields. [Parse], [File] and [Config] do no I/O, for callers that store // configuration their own way. +// +// Errors wrap the sentinel errors of this package (ErrLocked, +// ErrInvalidKey, ...) in a typed error giving the key, file or value +// concerned; the documentation of the error variables says which function +// returns which type. package gitconfig diff --git a/edit.go b/edit.go index c790413..88cf669 100644 --- a/edit.go +++ b/edit.go @@ -70,9 +70,10 @@ func (f *File) entriesOf(k Key) []int { return idx } -// flatEntry is an entry as the checks of an edit compare them: entries -// before any header included, with the zero sec, origins left out. The keys -// and sections edits compare them with always have a section name. +// flatEntry is an entry as the checks of an edit compare them, origin left +// out. Unlike Config, the checks include the entries before any header, +// with the zero sec: an edit must not change them either. They never match +// the edited key or section, which always has a section name. type flatEntry struct { sec sectionKey name string @@ -135,6 +136,7 @@ func sameEntries(before, after *parsed, keepBefore, keepAfter func(flatEntry) bo // apply splices the bytes of the file, parses the result, and keeps it if // check accepts the entries before and after the edit. func (f *File) apply(key string, splices []splice, check func(before, after *parsed) bool) error { + // The splices never overlap; they are applied in order of position. slices.SortFunc(splices, func(a, b splice) int { return a.start - b.start }) data := make([]byte, 0, len(f.data)+64) at := 0 @@ -156,7 +158,8 @@ func (f *File) apply(key string, splices []splice, check func(before, after *par // checkKey returns a check that the entries of other keys are unchanged and // that k has the values want after the edit. Only the first implicitOK of -// them may be implicit. +// them may be implicit: those an edit keeps (Add) may be, a value it writes +// never is. func checkKey(k Key, want []string, implicitOK int) func(before, after *parsed) bool { return func(before, after *parsed) bool { other := func(e flatEntry) bool { return !e.is(k) } @@ -229,6 +232,8 @@ func (f *File) terminator() string { // A blank line ends the value. return "\n" case last.kind == itemEntry && last.open == backslashEOF: + // The first newline completes the continuation, the blank line + // after it ends the value. return "\n\n" } return "\n" @@ -242,6 +247,10 @@ func formatEntry(name, value string) string { // quoteValue quotes and escapes a value as git writes it: in quotes if it // starts or ends with a space or contains '#', ';' or a CR; backslash, // double quote, tab and newline escaped. +// +// Unquoted, an edge space would be trimmed, '#' and ';' would start a +// comment, and a CR could be trimmed or read as part of a CRLF. Tabs need +// no quotes: they are escaped. func quoteValue(v string) string { var sb strings.Builder quote := strings.HasPrefix(v, " ") || strings.HasSuffix(v, " ") || strings.ContainsAny(v, "#;\r") @@ -376,6 +385,8 @@ func (f *File) unsetEntry(i int, forward map[int]int, comments []int) splice { sec := f.items[i].sec sameHeader := func(it item) bool { return it.kind == itemHeader && f.secOf(it) == f.secs[sec] } + // Scan back to the previous entry or header of another section, b; + // headers tells whether a header of the entry's section was passed. headers := false b := i - 1 for ; b >= 0; b-- { @@ -387,6 +398,7 @@ func (f *File) unsetEntry(i int, forward map[int]int, comments []int) splice { headers = true } } + // Scan forward to the next entry or header of another section, fw. fw := i + 1 for ; fw < len(f.items); fw++ { if end, ok := forward[fw]; ok { @@ -401,9 +413,11 @@ func (f *File) unsetEntry(i int, forward map[int]int, comments []int) splice { } forward[i] = fw if !headers || fw < len(f.items) && f.items[fw].kind == itemEntry { + // The section keeps other entries: remove the entry's line only. return f.removeEntry(i) } + // The section's headers go too: remove from after b up to fw. start, text := 0, "" switch { case b < 0: @@ -437,6 +451,8 @@ func (f *File) insert(k Key, section, name, value string) splice { return splice{len(f.data), len(f.data), f.terminator() + formatHeader(section, k.Subsection, k.HasSubsection) + "\n" + line} } + // Insert after the last entry of the last matching section, or after + // its header if it has none. h := headers[len(headers)-1] last := h for i := h + 1; i < len(f.items) && f.items[i].kind != itemHeader; i++ { @@ -532,6 +548,10 @@ func (f *File) renameSection(name string, sk, to sectionKey, header string) erro if len(headers) == 0 { return &KeyError{Key: name, Err: ErrNotFound} } + // A header that does not start its line follows another header on the + // same line ("[b] [a]") and is rewritten in place. A header that starts + // its line has the whole line rewritten, the other headers of sk on it + // included. var splices []splice done := -1 // headers up to this index are rewritten with their line for _, h := range headers { diff --git a/env.go b/env.go index 569e0ea..e599919 100644 --- a/env.go +++ b/env.go @@ -66,9 +66,11 @@ type Env struct { // GitDir is the repository's git directory, "" outside a repository. // It must be absolute: includeIf "gitdir:" matches absolute paths, and // a relative GitDir makes Load fail with ErrNotAbsolute rather than - // silently not match. The common directory and the worktree - // configuration are derived from it. includeIf "onbranch:" reads - // /HEAD when such a condition is met. + // silently not match. For a linked worktree, this is the worktree's + // own git directory (.git/worktrees/): the shared config is found + // through its commondir file, and config.worktree is read from it. + // includeIf "onbranch:" reads /HEAD when such a condition is + // met. GitDir string // SystemConfig is the system configuration file, "" for none. @@ -112,6 +114,10 @@ type CommandEntry struct { // Without a home directory, Home is "" and the global files are those git // reads then: the XDG file if XDG_CONFIG_HOME is set, no ~/.gitconfig. // +// On Windows, SystemConfig is "" unless GIT_CONFIG_SYSTEM is set: the +// system file lives in git's installation directory, which Discover does +// not look for. Set the field to read it. +// // It fails if a gitdir file is malformed (a *FileError), or if // GIT_CONFIG_NOSYSTEM, GIT_CONFIG_COUNT or GIT_CONFIG_PARAMETERS is // malformed (an *EnvError), as git does. @@ -122,16 +128,19 @@ func Discover(gitDir string) (Env, error) { return discover(gitDir, osEnviron{}) } -// Load returns the effective configuration: every scope, in git's order of -// precedence, with includes followed. This is what git itself uses. The view -// of one scope is the entries with that Origin.Scope. +// Load returns the effective configuration: system, global, local, worktree +// and command-line scopes, in that order of precedence, with includes +// followed. This is what git itself uses. Each entry's Origin.Scope tells +// which scope it comes from. Missing files are skipped. // -// Includes are followed as git does (depth limit 10, ErrIncludeDepth), with -// two safety bounds git lacks: an include must be a regular file -// (ErrNotRegular, so a FIFO or a device cannot hang or exhaust the process), -// and one load reads at most 1000 files and 64 MiB in total (ErrLoadLimit, so -// a file including itself many times cannot multiply the work exponentially). -// These are reached only by files built to reach them. +// Includes are followed as git does (include.path and includeIf with the +// gitdir:, gitdir/i: and onbranch: conditions; hasconfig: is never +// true), up to 10 levels deep (ErrIncludeDepth). Two safety bounds git lacks +// are added: an include must be a regular file (ErrNotRegular, so a FIFO or a +// device cannot hang or exhaust the process), and one load reads at most +// 1000 files and 64 MiB in total (ErrLoadLimit, so a file including itself +// many times cannot multiply the work exponentially). Real configurations +// never come near these bounds. // // A global file that cannot be read for lack of permission is skipped, as // git does; LoadProtected skips such a system file too. @@ -212,7 +221,8 @@ func (e Env) LoadProtected() (*Config, error) { // SafeDirectory reports whether dir is allowed by the safe.directory values // of LoadProtected, with git's matching rules ("*", a trailing "/*", an empty // value resetting the list). dir is the repository's working tree, or its -// git directory for a bare repository, as git checks. +// git directory for a bare repository, as git checks. It may be relative to +// the working directory; symbolic links are resolved on both sides. // // The repository's configuration is not read. It does not check who owns // dir: git trusts a repository owned by the current user without consulting @@ -395,9 +405,10 @@ func scopeFile(r *repo, s Scope) (string, Scope, error) { return r.localConfig(), ScopeLocal, nil } -// UpdateScope edits the file of scope s, as UpdateFile does; the File's -// entries have the scope LoadScope gives them. Writes never go into an -// included file. +// UpdateScope edits the file of scope s, which WritePath gives, as +// UpdateFile does; it fails with ErrNoScope where WritePath does. The +// File's entries have the scope LoadScope gives them. Writes never go into +// an included file. func (e Env) UpdateScope(s Scope, fn func(*File) error) error { path, scope, err := e.writeTarget(s) if err != nil { diff --git a/errors.go b/errors.go index f170b68..171520a 100644 --- a/errors.go +++ b/errors.go @@ -90,6 +90,7 @@ type FileError struct { } func (e *FileError) Error() string { + // A syntax error already names the file: don't repeat it. if se, ok := errors.AsType[*SyntaxError](e.Err); ok && se.File == e.Path { return se.Error() } diff --git a/file.go b/file.go index 03ebb60..b35a608 100644 --- a/file.go +++ b/file.go @@ -6,17 +6,16 @@ import ( // File is the lossless, editable form of one configuration file. Edits // change only the lines `git config` would change, and produce the same -// bytes; everything else is kept byte for byte. -// -// A File is mutable and must not be used by several goroutines at once. Use -// Config to take an immutable snapshot. The zero value is an empty file. -// -// A File knows the scope it was opened for (Env.UpdateScope); a File from -// Parse or Env.UpdateFile has ScopeFile. +// bytes; everything else (comments, blank lines, indentation) is kept byte +// for byte. // // A File comes from Parse, for content that is not on disk (tests, in-memory // repositories, a .gitmodules blob), or from Env.UpdateScope and -// Env.UpdateFile, to edit a file on disk. +// Env.UpdateFile, to edit a file on disk. The zero value is an empty file. +// +// A File is mutable and must not be used by several goroutines at once. Use +// Config to take an immutable snapshot; its entries have the scope the File +// was opened for by Env.UpdateScope, and ScopeFile otherwise. // // Edits find keys, sections and subsections as Config does: section and name // case-insensitive, subsection exact, a legacy header [a.B] holding @@ -25,11 +24,14 @@ import ( // lowered, and it removes or renames a section only if the header is // spelled as given. // -// Edits fail with ErrInvalidKey if a key or section name is one git rejects, -// or a key with an empty section (".sub.name", which git reads from a -// header [ "sub"]), and with ErrInvalidValue if a value contains a NUL -// byte. Removing something that is absent is not an error: the methods -// report what they removed. +// A new key goes at the end of the last section that holds its section or +// subsection, or into a new section at the end of the file, as git does. +// +// Edits return a *KeyError wrapping ErrInvalidKey if a key or section name +// is one git rejects, or a key has an empty section (".sub.name", which git +// reads from a header [ "sub"]), and wrapping ErrInvalidValue if a value +// contains a NUL byte. Removing something that is absent is not an error: +// the methods report what they removed. // // An edit cannot inject anything: whatever the key, subsection and value, // the edited file parses to the entries before the edit with exactly that @@ -54,6 +56,8 @@ type File struct { // data may come from anyone (a .gitmodules blob from a remote): Parse never // panics, and its time and memory are linear in len(data). func Parse(name string, data []byte) (*File, error) { + // The File keeps data, which its items index: the caller must stay free + // to reuse its slice. data = bytes.Clone(data) p, err := parse(name, data) if err != nil { @@ -111,7 +115,8 @@ func (f *File) Set(key, value string) error { } // ReplaceAll replaces all values of key with a single value, or adds it if -// key is absent, like `git config --replace-all `. +// key is absent, like `git config --replace-all `. The new +// value takes the place of the last old one. func (f *File) ReplaceAll(key, value string) error { k, section, name, err := f.prepareValue(key, value) if err != nil { @@ -131,6 +136,7 @@ func (f *File) ReplaceAll(key, value string) error { } // Add adds a value to key, keeping existing ones, like `git config --add`. +// The new value is read last, so it is the one Config.Get returns. func (f *File) Add(key, value string) error { k, section, name, err := f.prepareValue(key, value) if err != nil { diff --git a/glob.go b/glob.go index 667ca29..e91f6e5 100644 --- a/glob.go +++ b/glob.go @@ -78,6 +78,8 @@ func compileGlob(p string) ([]globToken, bool) { toks = append(toks, globToken{kind: globLit, c: c}) i++ } + // "**" is special only at the start of a segment: at the start of the + // pattern or after a '/'. segStart = toks[len(toks)-1].kind == globLit && toks[len(toks)-1].c == '/' } return toks, true @@ -93,7 +95,7 @@ func compileClass(p string, start, lastColon int) (globToken, int, bool) { tok.negate = true i++ } - first := true + first := true // a ']' first in the class is a literal ']' for i < len(p) { c := p[i] if c == ']' && !first { @@ -116,6 +118,7 @@ func compileClass(p string, start, lastColon int) (globToken, int, bool) { i++ c = p[i] } + // A range "a-z"; a '-' before the closing ']' is a literal '-'. lo, hi := c, c if i+2 < len(p) && p[i+1] == '-' && p[i+2] != ']' { hi = p[i+2] @@ -236,14 +239,18 @@ func globMatch(pattern, name string, fold bool) bool { } } if len(next.list) == 0 { + // No position left: the rest of name cannot match. return false } cur, next = next, cur } + // Matched if the whole pattern is consumed. return cur.has(2 * n) } -// stateSet is a set of states, listed in the order they were added. +// stateSet is a set of states, listed in the order they were added. reset +// empties it in constant time by moving to a new generation instead of +// clearing mark. type stateSet struct { list []int32 mark []uint32 // mark[id] == gen if id is in the set diff --git a/key.go b/key.go index 12c10a7..72b3bbd 100644 --- a/key.go +++ b/key.go @@ -6,9 +6,11 @@ import ( // ParseKey parses "section.name" or "section.subsection.name" as git does: // the subsection is everything between the first and the last dot, section -// and name are lowered. A key git rejects is ErrInvalidKey, including a -// subsection containing a newline or a NUL byte. Reads treat an invalid key -// as absent; only ParseKey and edits report it. +// and name are lowered. A key git rejects is a *KeyError wrapping +// ErrInvalidKey: the section must hold only letters, digits and '-', the +// name must also start with a letter, and the subsection may hold anything +// but a newline or a NUL byte. Reads treat an invalid key as absent; only +// ParseKey and edits report it. func ParseKey(s string) (Key, error) { k, ok := parseKey(s) if !ok { @@ -23,6 +25,8 @@ func ParseKey(s string) (Key, error) { // (".sub.name", "..name"): git reads it from a header [ "sub"] or [.], and // every entry read must have a key ParseKey accepts. Edits refuse it. func parseKey(s string) (Key, bool) { + // The subsection may itself contain dots: only the first and the last + // dot are separators. first := strings.IndexByte(s, '.') last := strings.LastIndexByte(s, '.') if first < 0 { @@ -34,6 +38,7 @@ func parseKey(s string) (Key, bool) { } k := Key{Name: lowerASCII(name)} if first == last { + // No subsection: the section may not be empty (".name"). if !validSection(s[:first]) || first == 0 { return Key{}, false } @@ -113,6 +118,8 @@ func validSubsection(s string) bool { // lowerASCII lowers ASCII letters only: the format is ASCII, and Unicode // folding would accept names git rejects. func lowerASCII(s string) string { + // Most names are already lower case: return s itself unless a letter + // needs lowering, so that the common case does not allocate. for i := 0; i < len(s); i++ { if 'A' <= s[i] && s[i] <= 'Z' { b := []byte(s) diff --git a/load.go b/load.go index 0e0db93..f12e1f6 100644 --- a/load.go +++ b/load.go @@ -13,8 +13,9 @@ import ( "syscall" ) -// Limits of one load (X3): git's include depth, and bounds on the work a -// set of files built to multiply it can cause. +// Limits of one load (requirement X3 of docs/REQUIREMENTS.md): git's +// include depth, and bounds on the work a set of files built to multiply it +// can cause. const ( maxIncludeDepth = 10 maxLoadFiles = 1000 @@ -216,6 +217,7 @@ func (l *loader) config() *Config { // skipped, as git does for global files. func (l *loader) loadFile(path string, scope Scope, skipUnreadable bool) error { err := l.load(path, scope, 0) + // Only path itself is skipped: an unreadable include of it still fails. if skipUnreadable { if fe, ok := errors.AsType[*FileError](err); ok && fe.Path == path && errors.Is(fe.Err, fs.ErrPermission) { return nil @@ -229,6 +231,7 @@ func (l *loader) load(path string, scope Scope, depth int) error { if l.files > maxLoadFiles { return &FileError{Path: path, Err: ErrLoadLimit} } + // Read at most what remains of the byte budget of the load. data, err := readConfigFile(path, maxLoadBytes-l.bytes) if isMissing(err) { return nil @@ -244,8 +247,10 @@ func (l *loader) load(path string, scope Scope, depth int) error { } start := len(l.entries) l.entries = pf.entries(scope, path, l.entries) - // Includes are spliced in place: take the entries of this file out - // and put them back one by one. + // The entries of an include go right after its include.path entry, so + // that later entries of this file take precedence over them. Take the + // entries of this file out of l.entries, which include appends to, and + // put them back one by one. own := slices.Clone(l.entries[start:]) l.entries = l.entries[:start] for _, e := range own { @@ -278,6 +283,7 @@ func (l *loader) include(e Entry, from string, scope Scope, depth int) error { return l.fail(from, e, "missing value for include.path") } if e.Value == "" { + // An empty path includes nothing. return nil } path, err := e.Path(l.env.Home) @@ -388,6 +394,8 @@ func (l *loader) gitdir(pattern, from string, fold bool) (bool, error) { } pattern = strings.TrimSuffix(filepath.ToSlash(l.env.Home), "/") + pattern[1:] } + // Checked only now: a "./" pattern on the command line is an error even + // outside a repository. if l.repo == nil { return false, nil } diff --git a/parse.go b/parse.go index b903e9d..d07704f 100644 --- a/parse.go +++ b/parse.go @@ -221,9 +221,12 @@ func (p *parser) header() error { } nameEnd := i if i == len(d) { + // git counts the end of the line it stopped at, and so reports the + // next line for an unterminated header or value. return p.errorAt(p.line+1, "unterminated section header") } + // sub reuses the parser's scratch buffer, and gives it back grown. sub := p.buf[:0] defer func() { p.buf = sub[:0] }() hasSub := false @@ -322,6 +325,8 @@ func (p *parser) entry() error { j++ } if j == len(d) || isNewline(d, j) { + // No '=': an implicit value. The entry ends with its name; the + // whitespace after it is an item of its own. p.pos = i p.addEntry(start, i, name, "").implicit = true return nil @@ -367,6 +372,7 @@ loop: switch { case c == '\\': if i+1 == len(d) { + // A backslash ends the file. Outside quotes it is dropped. if inQuote { return "", 0, 0, 0, p.errorAt(p.line+lines+1, "unterminated quote") } @@ -405,6 +411,7 @@ loop: buf = append(buf, c) i++ case c == ' ' || c == '\t' || c == '\r': + // A CR here is a lone one: the loop stops at a CRLF. if len(buf) > 0 && pending < 0 { pending = i } diff --git a/update.go b/update.go index a2ffa8e..3d9e833 100644 --- a/update.go +++ b/update.go @@ -64,9 +64,11 @@ func updateFile(path string, scope Scope, fn func(*File) error) (err error) { return err } if bytes.Equal(f.data, data) { + // Unchanged: the deferred cleanup drops the lock. return nil } + // Windows has no permission bits to copy. if exists && runtime.GOOS != "windows" { fi, err := os.Stat(target) if err != nil { diff --git a/value.go b/value.go index 222bc53..8f28d92 100644 --- a/value.go +++ b/value.go @@ -23,6 +23,7 @@ func parseBool(v string) (bool, error) { if err != nil { return false, err } + // As in git, a numeric boolean must fit in 32 bits. if n < math.MinInt32 || n > math.MaxInt32 { return false, strconv.ErrRange } @@ -40,6 +41,8 @@ func parseInt(v string) (int64, error) { s = s[1:] } + // "0x" is a prefix only if a hex digit follows: "0x" alone is the octal + // number 0 followed by the invalid unit "x". base := uint64(10) switch { case len(s) > 2 && s[0] == '0' && s[1]|0x20 == 'x' && digitValue(s[2]) < 16: @@ -49,6 +52,8 @@ func parseInt(v string) (int64, error) { base = 8 } + // On overflow, the scan goes on to find where the digits end: an + // invalid unit after them is reported before the range error. var mag uint64 overflow := false n := 0 @@ -64,6 +69,7 @@ func parseInt(v string) (int64, error) { } } if n == 0 { + // No digits; git reports this as an invalid unit too. return 0, errInvalidUnit } @@ -107,8 +113,8 @@ func digitValue(c byte) int { return 36 } -// errPrefix and errUserHome are the reasons of a *ValueError for paths this -// package cannot expand. +// errPrefix, errNoHome and errUserHome are the reasons of a *ValueError for +// paths this package cannot expand. var ( errPrefix = errors.New("%(prefix)/ is not supported") errNoHome = errors.New("home directory unknown") @@ -116,7 +122,7 @@ var ( ) // expandPath interprets a value as a path: "~" and "~/" are replaced by -// home. +// home. "~user/" and "%(prefix)/" are refused. func expandPath(v, home string) (string, error) { switch { case strings.HasPrefix(v, "%(prefix)/"): From c0e0a7335ee0a6d3e047327f150940e61eebeccc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Michael=20Mur=C3=A9?= Date: Fri, 9 Oct 2026 17:40:26 +0200 Subject: [PATCH 10/10] improve an error case --- config.go | 2 +- config_test.go | 9 +++++++++ env.go | 7 ++++--- errors.go | 6 +++++- 4 files changed, 19 insertions(+), 5 deletions(-) diff --git a/config.go b/config.go index 5f1fdf6..31fc6ca 100644 --- a/config.go +++ b/config.go @@ -169,7 +169,7 @@ func (c *Config) Int(key string, def int64) (int64, error) { // // A value that cannot be expanded is a *ValueError, and the result is then // def, unexpanded. This also holds for def itself: its error reports it -// with an empty Origin. +// with an empty Origin, and a zero Key if key is invalid. func (c *Config) Path(key, home, def string) (string, error) { e, ok := c.Get(key) if !ok { diff --git a/config_test.go b/config_test.go index 5a03fdc..4b48a58 100644 --- a/config_test.go +++ b/config_test.go @@ -611,6 +611,15 @@ func TestConfigTypedGetters(t *testing.T) { assert.Equal(t, gitconfig.Key{Section: "a", Name: "missing"}, ve.Entry.Key) assert.Equal(t, gitconfig.Origin{}, ve.Entry.Origin) }) + + t.Run("Path with an invalid key and a default that cannot be expanded", func(t *testing.T) { + got, err := c.Path("a.k_y", "", "~/d") + var ve *gitconfig.ValueError + require.ErrorAs(t, err, &ve) + assert.Equal(t, "~/d", got) + assert.Equal(t, gitconfig.Key{}, ve.Entry.Key) + assert.Equal(t, `gitconfig: bad path value "~/d": home directory unknown`, err.Error()) + }) } // bigConfig returns a configuration of n remotes and n branches, the shape diff --git a/env.go b/env.go index e599919..c7ec6d4 100644 --- a/env.go +++ b/env.go @@ -3,6 +3,7 @@ package gitconfig import ( "os" "path/filepath" + "slices" "strconv" "strings" ) @@ -366,9 +367,9 @@ func (e Env) writeTarget(s Scope) (string, Scope, error) { if len(e.GlobalConfig) == 0 { return "", 0, ErrNoScope } - for i := len(e.GlobalConfig) - 1; i >= 0; i-- { - if _, err := os.Lstat(e.GlobalConfig[i]); err == nil { - return e.GlobalConfig[i], s, nil + for _, v := range slices.Backward(e.GlobalConfig) { + if _, err := os.Lstat(v); err == nil { + return v, s, nil } } return e.GlobalConfig[len(e.GlobalConfig)-1], s, nil diff --git a/errors.go b/errors.go index 171520a..7161373 100644 --- a/errors.go +++ b/errors.go @@ -145,7 +145,11 @@ func (e *ValueError) Error() string { if e.Entry.Implicit { msg = fmt.Sprintf("gitconfig: missing %s value for %q", e.Type, e.Entry.Key.String()) } else { - msg = fmt.Sprintf("gitconfig: bad %s value %q for %q", e.Type, e.Entry.Value, e.Entry.Key.String()) + msg = fmt.Sprintf("gitconfig: bad %s value %q", e.Type, e.Entry.Value) + // No key for the default of Config.Path given an invalid key. + if e.Entry.Key != (Key{}) { + msg += fmt.Sprintf(" for %q", e.Entry.Key.String()) + } } if e.Entry.Origin.File != "" { msg += fmt.Sprintf(" in file %s", e.Entry.Origin.File)