[errors] Greatly simplify common/errors package.

vpython/run.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 vpython
 
 import (
         "os"
         "os/exec"
         "os/signal"
@@ skipping 32 matching lines @@
 //      - Identifying the Python interpreter to use.
 //      - Composing the environment specification.
 //      - Constructing the virtual environment (download, install).
 //      - Execute the Python process with the supplied arguments.
 //
 // The Python subprocess is bound to the lifetime of ctx, and will be terminated
 // if ctx is cancelled.
 func Run(c context.Context, opts Options) error {
         // Resolve our Options.
         if err := opts.resolve(c); err != nil {
-                return errors.Annotate(err).Reason("could not resolve options").Err()
+                return errors.Annotate(err, "could not resolve options").Err()
         }
 
         // Create a local cancellation option (signal handling).
         c, cancelFunc := context.WithCancel(c)
         defer cancelFunc()
 
         // Create our virtual environment root directory.
         err := venv.With(c, opts.EnvConfig, opts.WaitForEnv, func(c context.Context, ve *venv.Env) error {
                 // Build the augmented environment variables.
                 e := opts.Environ
@@ skipping 28 matching lines @@
                 cmd.Dir = opts.WorkDir
                 cmd.Env = e.Sorted()
                 cmd.Stdin = os.Stdin
                 cmd.Stdout = os.Stdout
                 cmd.Stderr = os.Stderr
 
                 logging.Debugf(c, "Running Python command: %s\nWorkDir: %s\nEnv: %s", cmd.Args, cmd.Dir, cmd.Env)
 
                 // Output the Python command being executed.
                 if err := runAndForwardSignals(c, cmd, cancelFunc); err != nil {
-                        return errors.Annotate(err).Reason("failed to execute bootstrapped Python").Err()
+                        return errors.Annotate(err, "failed to execute bootstrapped Python").Err()
                 }
                 return nil
         })
         if err != nil {
-                return errors.Annotate(err).Err()
+                return errors.Annotate(err, "").Err()
         }
         return nil
 }
 
 func runAndForwardSignals(c context.Context, cmd *exec.Cmd, cancelFunc context.CancelFunc) error {
         signalC := make(chan os.Signal, 1)
         signalDoneC := make(chan struct{})
         signal.Notify(signalC, forwardedSignals...)
         defer func() {
                 signal.Stop(signalC)
 
                 close(signalC)
                 <-signalDoneC
         }()
 
         if err := cmd.Start(); err != nil {
-                return errors.Annotate(err).Reason("failed to start process").Err()
+                return errors.Annotate(err, "failed to start process").Err()
         }
 
         logging.Fields{
                 "pid": cmd.Process.Pid,
         }.Debugf(c, "Python subprocess has started!")
 
         // Start our signal forwarding goroutine, now that the process is running.
         go func() {
                 defer func() {
                         close(signalDoneC)
                 }()
 
                 for sig := range signalC {
                         logging.Debugf(c, "Forwarding signal: %v", sig)
                         if err := cmd.Process.Signal(sig); err != nil {
                                 logging.Fields{
                                         logging.ErrorKey: err,
                                         "signal":         sig,
                                 }.Errorf(c, "Failed to forward signal; terminating immediately.")
                                 cancelFunc()
                         }
                 }
         }()
 
         err := cmd.Wait()
         logging.Debugf(c, "Python subprocess has terminated: %v", err)
         if err != nil {
-                return errors.Annotate(err).Err()
+                return errors.Annotate(err, "").Err()
         }
         return nil
 }
 
 func prefixPATH(env environ.Env, components ...string) {
         if len(components) == 0 {
                 return
         }
 
         // Clone "components" so we don't mutate our caller's array.
         components = append([]string(nil), components...)
 
         // If there is a current PATH (likely), add that to the end.
         cur, _ := env.Get("PATH")
         if len(cur) > 0 {
                 components = append(components, cur)
         }
 
         env.Set("PATH", strings.Join(components, string(os.PathListSeparator)))
 }