defer b.exec.Unlock()
if err != nil {
- if b.AllowErrors {
+ if b.AllowErrors && a.Package != nil {
if a.Package.Error == nil {
a.Package.Error = &load.PackageError{Err: err}
}
} else {
+ var ipe load.ImportPathError
+ if a.Package != nil && (!errors.As(err, &ipe) || ipe.ImportPath() != a.Package.ImportPath) {
+ err = fmt.Errorf("%s: %v", a.Package.ImportPath, err)
+ }
base.Errorf("%s", err)
}
a.Failed = true
}
defer func() {
- if err != nil {
- err = fmt.Errorf("go build %s: %v", p.ImportPath, err)
- }
if err != nil && b.IsCmdList && b.NeedError && p.Error == nil {
p.Error = &load.PackageError{Err: err}
}
}
if err != nil {
- return errors.New(fmt.Sprint(formatOutput(b.WorkDir, p.Dir, p.Desc(), output)))
+ return formatOutput(b.WorkDir, p.Dir, p.ImportPath, p.Desc(), output)
} else {
b.showOutput(a, p.Dir, p.Desc(), output)
}
var out []byte
out, err = b.runOut(nil, p.Dir, nil, b.PkgconfigCmd(), "--cflags", pcflags, "--", pkgs)
if err != nil {
- prefix, suffix := formatOutput(b.WorkDir, p.Dir, b.PkgconfigCmd()+" --cflags "+strings.Join(pcflags, " ")+" -- "+strings.Join(pkgs, " "), string(out))
- return nil, nil, errors.New(fmt.Sprint(prefix, suffix+err.Error()))
+ err = formatOutput(b.WorkDir, p.Dir, p.ImportPath, b.PkgconfigCmd()+" --cflags "+strings.Join(pcflags, " ")+" -- "+strings.Join(pkgs, " "), string(out)+err.Error())
+ return nil, nil, err
}
if len(out) > 0 {
cflags, err = splitPkgConfigOutput(out)
}
out, err = b.runOut(nil, p.Dir, nil, b.PkgconfigCmd(), "--libs", pcflags, "--", pkgs)
if err != nil {
- prefix, suffix := formatOutput(b.WorkDir, p.Dir, b.PkgconfigCmd()+" --libs "+strings.Join(pcflags, " ")+" -- "+strings.Join(pkgs, " "), string(out))
- return nil, nil, errors.New(fmt.Sprint(prefix, suffix+err.Error()))
+ err = formatOutput(b.WorkDir, p.Dir, p.ImportPath, b.PkgconfigCmd()+" --libs "+strings.Join(pcflags, " ")+" -- "+strings.Join(pkgs, " "), string(out)+err.Error())
+ return nil, nil, err
}
if len(out) > 0 {
// NOTE: we don't attempt to parse quotes and unescapes here. pkg-config
// If a is not nil and a.output is not nil, showOutput appends to that slice instead of
// printing to b.Print.
func (b *Builder) showOutput(a *Action, dir, desc, out string) {
- prefix, suffix := formatOutput(b.WorkDir, dir, desc, out)
+ importPath := ""
+ if a != nil && a.Package != nil {
+ importPath = a.Package.ImportPath
+ }
+ psErr := formatOutput(b.WorkDir, dir, importPath, desc, out)
if a != nil && a.output != nil {
- a.output = append(a.output, prefix...)
- a.output = append(a.output, suffix...)
+ a.output = append(a.output, psErr.prefix...)
+ a.output = append(a.output, psErr.suffix...)
return
}
b.output.Lock()
defer b.output.Unlock()
- b.Print(prefix, suffix)
+ b.Print(psErr.prefix, psErr.suffix)
+}
+
+// A prefixSuffixError is an error formatted by formatOutput.
+type prefixSuffixError struct {
+ importPath string
+ prefix, suffix string
+}
+
+func (e *prefixSuffixError) Error() string {
+ if e.importPath != "" && !strings.HasPrefix(strings.TrimPrefix(e.prefix, "# "), e.importPath) {
+ return fmt.Sprintf("go build %s:\n%s%s", e.importPath, e.prefix, e.suffix)
+ }
+ return e.prefix + e.suffix
+}
+
+func (e *prefixSuffixError) ImportPath() string {
+ return e.importPath
}
// formatOutput prints "# desc" followed by the given output.
// formatOutput also replaces references to the work directory with $WORK.
// formatOutput returns the output in a prefix with the description and a
// suffix with the actual output.
-func formatOutput(workDir, dir, desc, out string) (prefix, suffix string) {
- prefix = "# " + desc
- suffix = "\n" + out
+func formatOutput(workDir, dir, importPath, desc, out string) *prefixSuffixError {
+ prefix := "# " + desc
+ suffix := "\n" + out
if reldir := base.ShortPath(dir); reldir != dir {
suffix = strings.ReplaceAll(suffix, " "+dir, " "+reldir)
suffix = strings.ReplaceAll(suffix, "\n"+dir, "\n"+reldir)
}
suffix = strings.ReplaceAll(suffix, " "+workDir, " $WORK")
- return prefix, suffix
+ return &prefixSuffixError{importPath: importPath, prefix: prefix, suffix: suffix}
}
var cgoLine = lazyregexp.New(`\[[^\[\]]+\.(cgo1|cover)\.go:[0-9]+(:[0-9]+)?\]`)
desc = b.fmtcmd(dir, "%s", strings.Join(str.StringList(cmdargs...), " "))
}
if err != nil {
- err = errors.New(fmt.Sprint(formatOutput(b.WorkDir, dir, desc, b.processOutput(out))))
+ err = formatOutput(b.WorkDir, dir, a.Package.ImportPath, desc, b.processOutput(out))
} else {
b.showOutput(a, dir, desc, b.processOutput(out))
}
// ccompile runs the given C or C++ compiler and creates an object from a single source file.
func (b *Builder) ccompile(a *Action, p *load.Package, outfile string, flags []string, file string, compiler []string) error {
file = mkAbs(p.Dir, file)
- desc := p.ImportPath
outfile = mkAbs(p.Dir, outfile)
// Elide source directory paths if -trimpath or GOROOT_FINAL is set.
}
if err != nil || os.Getenv("GO_BUILDER_NAME") != "" {
- err = errors.New(fmt.Sprintf(formatOutput(b.WorkDir, p.Dir, desc, b.processOutput(output))))
+ err = formatOutput(b.WorkDir, p.Dir, p.ImportPath, p.Desc(), b.processOutput(output))
} else {
- b.showOutput(a, p.Dir, desc, b.processOutput(output))
+ b.showOutput(a, p.Dir, p.Desc(), b.processOutput(output))
}
}
return err
cgoflags = append(cgoflags, "-exportheader="+objdir+"_cgo_install.h")
}
- execdir := p.Dir
-
// Rewrite overlaid paths in cgo files.
// cgo adds //line and #line pragmas in generated files with these paths.
var trimpath []string
cgoflags = append(cgoflags, "-trimpath", strings.Join(trimpath, ";"))
}
- if err := b.run(a, execdir, p.ImportPath, cgoenv, cfg.BuildToolexec, cgoExe, "-objdir", objdir, "-importpath", p.ImportPath, cgoflags, "--", cgoCPPFLAGS, cgoCFLAGS, cgofiles); err != nil {
+ if err := b.run(a, p.Dir, p.ImportPath, cgoenv, cfg.BuildToolexec, cgoExe, "-objdir", objdir, "-importpath", p.ImportPath, cgoflags, "--", cgoCPPFLAGS, cgoCFLAGS, cgofiles); err != nil {
return nil, nil, err
}
outGo = append(outGo, gofiles...)
return "", "", errors.New("must have SWIG version >= 3.0.6")
}
// swig error
- return "", "", errors.New(fmt.Sprint(formatOutput(b.WorkDir, p.Dir, p.Desc(), b.processOutput(out))))
+ err = formatOutput(b.WorkDir, p.Dir, p.ImportPath, p.Desc(), b.processOutput(out))
}
return "", "", err
}