// Like ast.CommentGroup's Text method but preserves
// leading blank lines, so that line numbers line up.
func commentText(g *ast.CommentGroup) string {
- var pieces []string
+ pieces := make([]string, 0, len(g.List))
for _, com := range g.List {
c := com.Text
// Remove comment markers.
}
func nameKeys(m map[string]*Name) []string {
- var ks []string
+ ks := make([]string, 0, len(m))
for k := range m {
ks = append(ks, k)
}
// RelPaths returns a copy of paths with absolute paths
// made relative to the current directory if they would be shorter.
func RelPaths(paths []string) []string {
- var out []string
+ out := make([]string, 0, len(paths))
for _, p := range paths {
rel, err := relConservative(Cwd(), p)
if err == nil && len(rel) < len(p) {
// Show only the named vars.
if !*envChanged {
if *envJson {
- var es []cfg.EnvVar
+ es := make([]cfg.EnvVar, 0, len(args))
for _, name := range args {
e := cfg.EnvVar{Name: name, Value: findEnv(env, name)}
es = append(es, e)
return // ignore I/O error
}
- var names []string
+ names := make([]string, 0, len(list))
for _, info := range list {
names = append(names, info.Name())
}
var ErrNoGo = fmt.Errorf("no Go source files")
func keys(m map[string]bool) []string {
- var list []string
+ list := make([]string, 0, len(m))
for k := range m {
list = append(list, k)
}
}
func (v *jsonFlag) String() string {
- var fields []string
+ fields := make([]string, 0, len(*v))
for f := range *v {
fields = append(fields, f)
}
m = defaults
}
- var keys []string
+ keys := make([]string, 0, len(m))
for k := range m {
keys = append(keys, k)
}
// the absence of a specific module version.
// The caller must supply refs, the result of a successful r.loadRefs.
func (r *gitRepo) repoSum(refs map[string]string) string {
- var list []string
+ list := make([]string, 0, len(refs))
for ref := range refs {
list = append(list, ref)
}
}
}
- var mods []module.Version
+ mods := make([]module.Version, 0, len(goSum.m))
for m := range goSum.m {
mods = append(mods, m)
}
pkgPattern, mainModule := modload.MainModules.DirImportPath(ctx, q.pattern)
if pkgPattern == "." {
modload.MustHaveModRoot()
- var modRoots []string
- for _, m := range modload.MainModules.Versions() {
+ versions := modload.MainModules.Versions()
+ modRoots := make([]string, 0, len(versions))
+ for _, m := range versions {
modRoots = append(modRoots, modload.MainModules.ModRoot(m))
}
var plural string
if cfg.BuildMod == "vendor" {
readVendorList(VendorDir())
- var indexes []*modFileIndex
- var modFiles []*modfile.File
- var modRoots []string
- for _, m := range MainModules.Versions() {
+ versions := MainModules.Versions()
+ indexes := make([]*modFileIndex, 0, len(versions))
+ modFiles := make([]*modfile.File, 0, len(versions))
+ modRoots := make([]string, 0, len(versions))
+ for _, m := range versions {
indexes = append(indexes, MainModules.Index(m))
modFiles = append(modFiles, MainModules.ModFile(m))
modRoots = append(modRoots, MainModules.ModRoot(m))
base.Fatalf("go: no packages loaded from %s", arg)
}
if len(pkgs) > 1 {
- var names []string
+ names := make([]string, 0, len(pkgs))
for _, p := range pkgs {
names = append(names, p.ImportPath)
}
// ImportPathsQuiet is like ImportPaths but does not warn about patterns with no matches.
func ImportPathsQuiet(patterns, modRoots []string) []*Match {
- var out []*Match
- for _, a := range CleanPatterns(patterns) {
+ patterns = CleanPatterns(patterns)
+ out := make([]*Match, 0, len(patterns))
+ for _, a := range patterns {
m := NewMatch(a)
if m.IsLocal() {
m.MatchDirs(modRoots)
if len(patterns) == 0 {
return []string{"."}
}
- var out []string
+ out := make([]string, 0, len(patterns))
for _, a := range patterns {
var p, v string
if build.IsLocalImport(a) || filepath.IsAbs(a) {
vcs.VCSTestRepoURL = srv.HTTP.URL
vcs.VCSTestHosts = Hosts
- var interceptors []web.Interceptor
+ interceptors := make([]web.Interceptor, 0, 2*len(Hosts))
for _, host := range Hosts {
interceptors = append(interceptors,
web.Interceptor{Scheme: "http", FromHost: host, ToHost: httpURL.Host, Client: srv.HTTP.Client()},
}
}
- var list []*actionJSON
+ list := make([]*actionJSON, 0, len(workq))
for id, a := range workq {
if a.json == nil {
a.json = &actionJSON{
}
func (gcToolchain) pack(b *Builder, a *Action, afile string, ofiles []string) error {
- var absOfiles []string
+ absOfiles := make([]string, 0, len(ofiles))
for _, f := range ofiles {
absOfiles = append(absOfiles, mkAbs(a.Objdir, f))
}
p := a.Package
sh := b.Shell(a)
objdir := a.Objdir
- var absOfiles []string
+ absOfiles := make([]string, 0, len(ofiles))
for _, f := range ofiles {
absOfiles = append(absOfiles, mkAbs(objdir, f))
}