[errors] Greatly simplify common/errors package.

vpython/venv/config.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 venv
 
 import (
         "fmt"
         "os"
         "path/filepath"
@@ skipping 122 matching lines @@
                 return nil, errors.New("no package loader provided")
         }
 
         // Resolve our base directory, if one is not supplied.
         if cfg.BaseDir == "" {
                 // Use one in a temporary directory.
                 cfg.BaseDir = filepath.Join(os.TempDir(), "vpython")
                 logging.Debugf(c, "Using tempdir-relative environment root: %s", cfg.BaseDir)
         }
         if err := filesystem.AbsPath(&cfg.BaseDir); err != nil {
-                return nil, errors.Annotate(err).Reason("failed to resolve absolute path of base directory").Err()
+                return nil, errors.Annotate(err, "failed to resolve absolute path of base directory").Err()
         }
 
         // Enforce maximum path length.
         if cfg.MaxScriptPathLen > 0 {
                 if longestPath := longestGeneratedScriptPath(cfg.BaseDir); longestPath != "" {
                         longestPathLen := utf8.RuneCountInString(longestPath)
                         if longestPathLen > cfg.MaxScriptPathLen {
-                                return nil, errors.Reason("expected deepest path length (%(len)d) exceeds threshold (%(threshold)d)").
-                                        D("len", longestPathLen).
-                                        D("threshold", cfg.MaxScriptPathLen).
-                                        D("longestPath", longestPath).
-                                        Err()
+                                return nil, errors.Reason(
+                                        "expected deepest path length (%d) exceeds threshold (%d)",
+                                        longestPathLen, cfg.MaxScriptPathLen,
+                                ).InternalReason("longestPath(%q)", longestPath).Err()
                         }
                 }
         }
 
         // Construct a new, independent Environment for this Env.
         e = e.Clone()
         if cfg.Spec != nil {
                 e.Spec = cfg.Spec.Clone()
         }
         if err := spec.NormalizeEnvironment(e); err != nil {
-                return nil, errors.Annotate(err).Reason("invalid environment").Err()
+                return nil, errors.Annotate(err, "invalid environment").Err()
         }
 
         // If the environment doesn't specify a VirtualEnv package (expected), use
         // our default.
         if e.Spec.Virtualenv == nil {
                 e.Spec.Virtualenv = &cfg.Package
         }
 
         if err := cfg.Loader.Resolve(c, e); err != nil {
-                return nil, errors.Annotate(err).Reason("failed to resolve packages").Err()
+                return nil, errors.Annotate(err, "failed to resolve packages").Err()
         }
 
         if err := cfg.resolvePythonInterpreter(c, e.Spec); err != nil {
-                return nil, errors.Annotate(err).Reason("failed to resolve system Python interpreter").Err()
+                return nil, errors.Annotate(err, "failed to resolve system Python interpreter").Err()
         }
         e.Runtime.Path = cfg.si.Python
         e.Runtime.Version = e.Spec.PythonVersion
 
         var err error
         if e.Runtime.Hash, err = cfg.si.Hash(); err != nil {
                 return nil, err
         }
         logging.Debugf(c, "Resolved system Python runtime (%s @ %s): %s",
                 e.Runtime.Version, e.Runtime.Hash, e.Runtime.Path)
 
         // Ensure that our base directory exists.
         if err := filesystem.MakeDirs(cfg.BaseDir); err != nil {
-                return nil, errors.Annotate(err).Reason("could not create environment root: %(root)s").
-                        D("root", cfg.BaseDir).
-                        Err()
+                return nil, errors.Annotate(err, "could not create environment root: %s", cfg.BaseDir).Err()
         }
 
         // Generate our environment name based on the deterministic hash of its
         // fully-resolved specification.
         envName := cfg.OverrideName
         if envName == "" {
                 envName = cfg.envNameForSpec(e.Spec, e.Runtime)
         }
         env := cfg.envForName(envName, e)
         return env, nil
 }
 
 // EnvName returns the VirtualEnv environment name for the environment that cfg
 // describes.
 func (cfg *Config) envNameForSpec(s *vpython.Spec, rt *vpython.Runtime) string {
         name := spec.Hash(s, rt, EnvironmentVersion)
         if cfg.MaxHashLen > 0 && len(name) > cfg.MaxHashLen {
                 name = name[:cfg.MaxHashLen]
         }
         return name
 }
 
 // Prune performs a pruning round on the environment set described by this
 // Config.
 func (cfg *Config) Prune(c context.Context) error {
         if err := prune(c, cfg, nil); err != nil {
-                return errors.Annotate(err).Err()
+                return errors.Annotate(err, "").Err()
         }
         return nil
 }
 
 // envForName creates an Env for a named directory.
 //
 // The Environment, e, can be nil; however, code paths that require it may not
 // be called.
 func (cfg *Config) envForName(name string, e *vpython.Environment) *Env {
         // Env-specific root directory: <BaseDir>/<name>
         venvRoot := filepath.Join(cfg.BaseDir, name)
         binDir := venvBinDir(venvRoot)
         return &Env{
                 Config:               cfg,
                 Root:                 venvRoot,
                 Name:                 name,
                 Python:               filepath.Join(binDir, "python"),
                 Environment:          e,
                 BinDir:               binDir,
                 EnvironmentStampPath: filepath.Join(venvRoot, fmt.Sprintf("environment.%s.pb.txt", vpython.Version)),
 
                 lockPath:         filepath.Join(cfg.BaseDir, fmt.Sprintf(".%s.lock", name)),
                 completeFlagPath: filepath.Join(venvRoot, "complete.flag"),
         }
 }
 
 func (cfg *Config) resolvePythonInterpreter(c context.Context, s *vpython.Spec) error {
         specVers, err := python.ParseVersion(s.PythonVersion)
         if err != nil {
-                return errors.Annotate(err).Reason("failed to parse Python version from: %(value)q").
-                        D("value", s.PythonVersion).
-                        Err()
+                return errors.Annotate(err, "failed to parse Python version from: %q", s.PythonVersion).Err()
         }
 
         if cfg.Python == "" {
                 // No explicitly-specified Python path. Determine one based on the
                 // specification.
                 if cfg.si, err = python.Find(c, specVers, cfg.LookPathFunc); err != nil {
-                        return errors.Annotate(err).Reason("could not find Python for: %(vers)s").
-                                D("vers", specVers).
-                                Err()
+                        return errors.Annotate(err, "could not find Python for: %s", specVers).Err()
                 }
                 cfg.Python = cfg.si.Python
         } else {
                 cfg.si = &python.Interpreter{
                         Python: cfg.Python,
                 }
         }
         if err := cfg.si.Normalize(); err != nil {
                 return err
         }
 
         // Confirm that the version of the interpreter matches that which is
         // expected.
         interpreterVers, err := cfg.si.GetVersion(c)
         if err != nil {
-                return errors.Annotate(err).Reason("failed to determine Python version for: %(python)s").
-                        D("python", cfg.Python).
-                        Err()
+                return errors.Annotate(err, "failed to determine Python version for: %s", cfg.Python).Err()
         }
         if !specVers.IsSatisfiedBy(interpreterVers) {
-                return errors.Reason("supplied Python version (%(supplied)s) doesn't match specification (%(spec)s)").
-                        D("supplied", interpreterVers).
-                        D("spec", specVers).
-                        Err()
+                return errors.Reason("supplied Python version (%s) doesn't match specification (%s)", interpreterVers, specVers).Err()
         }
         s.PythonVersion = interpreterVers.String()
 
         // Resolve to absolute path.
         if err := filesystem.AbsPath(&cfg.Python); err != nil {
-                return errors.Annotate(err).Reason("could not get absolute path for: %(python)s").
-                        D("python", cfg.Python).
-                        Err()
+                return errors.Annotate(err, "could not get absolute path for: %s", cfg.Python).Err()
         }
         return nil
 }
 
 func (cfg *Config) systemInterpreter() *python.Interpreter { return cfg.si }