[errors] Greatly simplify common/errors package.

vpython/application/application.go

 // Copyright 2017 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package application
 
 import (
         "flag"
         "fmt"
         "io/ioutil"
@@ skipping 149 matching lines @@
         a.logConfig.AddFlags(fs)
 }
 
 func (a *application) mainImpl(c context.Context, argv0 string, args []string) error {
         // Determine our VirtualEnv base directory.
         if v, ok := a.opts.Environ.Get(VirtualEnvRootENV); ok {
                 a.opts.EnvConfig.BaseDir = v
         } else {
                 hdir, err := homedir.Dir()
                 if err != nil {
-                        return errors.Annotate(err).Reason("failed to get user home directory").Err()
+                        return errors.Annotate(err, "failed to get user home directory").Err()
                 }
                 a.opts.EnvConfig.BaseDir = filepath.Join(hdir, ".vpython")
         }
 
         // Extract "vpython" arguments and parse them.
         fs := flag.NewFlagSet("", flag.ExitOnError)
         fs.SetOutput(os.Stdout) // Python uses STDOUT for help and flag information.
 
         a.addToFlagSet(fs)
         selfArgs, args := extractFlagsForSet(args, fs)
         if err := fs.Parse(selfArgs); err != nil && err != flag.ErrHelp {
-                return errors.Annotate(err).Reason("failed to parse flags").Err()
+                return errors.Annotate(err, "failed to parse flags").Err()
         }
 
         // Identify the "self" executable. Use this to construct a "lookPath", which
         // will be used to locate the base Python interpreter.
         lp := lookPath{
                 probeBase: prober.Probe{
                         RelativePathOverride: a.RelativePathOverride,
                 },
                 env: a.opts.Environ,
         }
@@ skipping 10 matching lines @@
 
         // If an spec path was manually specified, load and use it.
         if a.specPath != "" {
                 var sp vpythonAPI.Spec
                 if err := spec.Load(a.specPath, &sp); err != nil {
                         return err
                 }
                 a.opts.EnvConfig.Spec = &sp
         } else if specPath := a.opts.Environ.GetEmpty(DefaultSpecENV); specPath != "" {
                 if err := spec.Load(specPath, &a.opts.DefaultSpec); err != nil {
-                        return errors.Annotate(err).
-                                Reason("failed to load default specification file ("+DefaultSpecENV+"from: %(path)s").
-                                D("path", specPath).
-                                Err()
+                        return errors.Annotate(err, "failed to load default specification file (%s) from %s",
+                                DefaultSpecENV, specPath).Err()
                 }
         }
 
         // If an empty BaseDir was specified, use a temporary directory and clean it
         // up on completion.
         if a.opts.EnvConfig.BaseDir == "" {
                 tdir, err := ioutil.TempDir("", "vpython")
                 if err != nil {
-                        return errors.Annotate(err).Reason("failed to create temporary directory").Err()
+                        return errors.Annotate(err, "failed to create temporary directory").Err()
                 }
                 defer func() {
                         logging.Debugf(c, "Removing temporary directory: %s", tdir)
                         if terr := filesystem.RemoveAll(tdir); terr != nil {
                                 logging.WithError(terr).Warningf(c, "Failed to clean up temporary directory; leaking: %s", tdir)
                         }
                 }()
                 a.opts.EnvConfig.BaseDir = tdir
         }
 
         // Development mode (subcommands).
         if a.devMode {
                 return a.mainDev(c, args)
         }
 
         a.opts.Args = args
         if err := vpython.Run(c, a.opts); err != nil {
                 // If the process failed because of a non-zero return value, return that
                 // as our error.
                 if rc, has := exitcode.Get(errors.Unwrap(err)); has {
                         err = ReturnCodeError(rc)
                 }
 
-                return errors.Annotate(err).Err()
+                return errors.Annotate(err, "").Err()
         }
         return nil
 }
 
 func (a *application) showPythonHelp(c context.Context, fs *flag.FlagSet, lp *lookPath) error {
         self, err := os.Executable()
         if err != nil {
                 self = "vpython"
         }
         vers, err := cipdVersion.GetStartupVersion()
         if err == nil && vers.PackageName != "" && vers.InstanceID != "" {
                 self = fmt.Sprintf("%s (%s@%s)", self, vers.PackageName, vers.InstanceID)
         }
 
         fmt.Fprintf(os.Stdout, "Usage of %s:\n", self)
         fs.SetOutput(os.Stdout)
         fs.PrintDefaults()
 
         i, err := python.Find(c, python.Version{}, lp.look)
         if err != nil {
-                return errors.Annotate(err).Reason("could not find Python interpreter for help").Err()
+                return errors.Annotate(err, "could not find Python interpreter for help").Err()
         }
 
         // Redirect all "--help" to Stdout for consistency.
         fmt.Fprintf(os.Stdout, "\nPython help for %s:\n", i.Python)
         cmd := i.IsolatedCommand(c, "--help")
         cmd.Stdout = os.Stdout
         cmd.Stderr = os.Stdout
         if err := cmd.Run(); err != nil {
-                return errors.Annotate(err).Reason("failed to dump Python help from: %(interpreter)s").
-                        D("interpreter", i.Python).
-                        Err()
+                return errors.Annotate(err, "failed to dump Python help from: %s", i.Python).Err()
         }
         return nil
 }
 
 // Main is the main application entry point.
 func (cfg *Config) Main(c context.Context) int {
         // Implementation of "checkWrapper": if CheckWrapperENV is set, we immediately
         // exit with a non-zero value.
         env := environ.System()
         if wrapperCheck(env) {
@@ skipping 20 matching lines @@
                 },
                 logConfig: logging.Config{
                         Level: logging.Error,
                 },
         }
 
         return run(c, func(c context.Context) error {
                 return a.mainImpl(c, os.Args[0], os.Args[1:])
         })
 }