[errors] Greatly simplify common/errors package.

deploytool/cmd/luci_deploy/build.go

 // Copyright 2016 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 main
 
 import (
         "fmt"
         "strings"
 
@@ skipping 17 matching lines @@
         }, v)
 }
 
 // buildComponent runs the varuous build scripts defined by the specified
 // deployment component.
 //
 // After running the build scripts, variable substitution will occur on "c"
 // to update its directory.
 func buildComponent(w *work, c *layoutDeploymentComponent, root *managedfs.Dir) error {
         if src := c.source(); !src.Source.RunScripts {
-                return errors.Reason("refusing to run scripts (run_scripts is false for %(source)q)").
-                        D("source", src.title).Err()
+                return errors.Reason("refusing to run scripts (run_scripts is false for %q)", src.title).Err()
         }
 
         // Create our build directories and map them to variables.
         c.buildDirs = make(map[string]string, len(c.Build))
         dirs := make([]*managedfs.Dir, len(c.Build))
         for i, b := range c.Build {
                 if _, has := c.buildDirs[b.DirKey]; has {
-                        return errors.Reason("duplicate build key [%(key)s]").D("key", b.DirKey).Err()
+                        return errors.Reason("duplicate build key [%s]", b.DirKey).Err()
                 }
 
                 dir, err := root.EnsureDirectory(fmt.Sprintf("%d_%s", i, flattenVarToDir(b.DirKey)))
                 if err != nil {
-                        return errors.Annotate(err).Reason("failed to create build directory").Err()
+                        return errors.Annotate(err, "failed to create build directory").Err()
                 }
 
                 dirs[i] = dir
                 c.buildDirs[b.DirKey] = dir.String()
         }
 
         // Apply build directories.
         if err := c.expandPaths(); err != nil {
-                return errors.Annotate(err).Reason("failed to expand component paths").Err()
+                return errors.Annotate(err, "failed to expand component paths").Err()
         }
 
         // Run all of our build scripts in parallel.
         err := w.RunMulti(func(workC chan<- func() error) {
                 for i, b := range c.Build {
                         i, b := i, b
                         workC <- func() error {
                                 return runComponentBuild(w, c, b, dirs[i])
                         }
                 }
         })
         if err != nil {
-                return errors.Annotate(err).Reason("failed to run component builds").Err()
+                return errors.Annotate(err, "failed to run component builds").Err()
         }
         return nil
 }
 
 func runComponentBuild(w *work, c *layoutDeploymentComponent, b *deploy.Component_Build, root *managedfs.Dir) error {
         switch t := b.Operation.(type) {
         case *deploy.Component_Build_PythonScript_:
                 ps := t.PythonScript
 
                 python, err := w.python()
                 if err != nil {
                         return err
                 }
 
                 src := c.source()
                 scriptPath := src.pathTo(ps.Path, c.comp.Path)
                 buildDir := root.String()
 
                 args := append(make([]string, 0, 2+len(ps.ExtraArgs)),
                         src.checkoutPath(),
                         buildDir)
                 args = append(args, ps.ExtraArgs...)
 
                 if err := python.exec(scriptPath, args...).cwd(buildDir).check(w); err != nil {
-                        return errors.Annotate(err).Reason("failed to execute [%(scriptPath)s]").D("scriptPath", scriptPath).Err()
+                        return errors.Annotate(err, "failed to execute [%s]", scriptPath).Err()
                 }
                 return nil
 
         default:
-                return errors.Reason("unknown build type %(type)T").D("type", t).Err()
+                return errors.Reason("unknown build type %T", t).Err()
         }
 }