[errors] Greatly simplify common/errors package.

vpython/python/find.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 python
 
 import (
         "os/exec"
 
         "github.com/luci/luci-go/common/errors"
@@ skipping 51 matching lines @@
                 interp, err := findInterpreter(c, s, vers, lookPath)
                 if err == nil {
                         return interp, nil
                 }
 
                 logging.WithError(err).Debugf(c, "Could not find Python for: %q.", s)
                 lookErrs.Assign(i, err)
         }
 
         // No Python interpreter could be identified.
-        return nil, errors.Annotate(lookErrs.Get()).Reason("no Python found").Err()
+        return nil, errors.Annotate(lookErrs.Get(), "no Python found").Err()
 }
 
 func findInterpreter(c context.Context, name string, vers Version, lookPath LookPathFunc) (*Interpreter, error) {
         if lookPath == nil {
                 lookPath = osExecLookPath
         }
         lpr, err := lookPath(c, name)
         if err != nil {
-                return nil, errors.Annotate(err).Reason("could not find executable for: %(name)q").
-                        D("name", name).
-                        Err()
+                return nil, errors.Annotate(err, "could not find executable for: %q", name).Err()
         }
 
         i := Interpreter{
                 Python: lpr.Path,
         }
 
         // If our LookPathResult included a target version, install that into the
         // Interpreter, allowing it to use this cached value when GetVersion is
         // called instead of needing to perform an additional lookup.
         //
         // Note that our LookPathResult may not populate Version, in which case we
         // will not pre-cache it.
         if !lpr.Version.IsZero() {
                 i.cachedVersion = &lpr.Version
         }
         if err := i.Normalize(); err != nil {
                 return nil, err
         }
 
         iv, err := i.GetVersion(c)
         if err != nil {
-                return nil, errors.Annotate(err).Reason("failed to get version for: %(interp)q").
-                        D("interp", i.Python).
-                        Err()
+                return nil, errors.Annotate(err, "failed to get version for: %q", i.Python).Err()
         }
         if !vers.IsSatisfiedBy(iv) {
-                return nil, errors.Reason("interpreter %(interp)q version %(interpVersion)q does not satisfy %(version)q").
-                        D("interp", i.Python).
-                        D("interpVersion", iv).
-                        D("version", vers).
-                        Err()
+                return nil, errors.Reason("interpreter %q version %q does not satisfy %q", i.Python, iv, vers).Err()
         }
 
         return &i, nil
 }
 
 func osExecLookPath(c context.Context, target string) (*LookPathResult, error) {
         v, err := exec.LookPath(target)
         if err != nil {
                 return nil, err
         }
         return &LookPathResult{Path: v}, nil
 }