[errors] Greatly simplify common/errors package.

deploytool/cmd/luci_deploy/staging.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 (
         "strings"
 
         "github.com/luci/luci-go/common/errors"
@@ skipping 18 matching lines @@
         dirs := make(map[string]struct{})
         build := make(map[string]string)
         for _, src := range comp.sources {
                 if src.InitResult == nil {
                         continue
                 }
 
                 for _, gopath := range src.InitResult.GoPath {
                         // Make sure our Go package isn't a directory.
                         if _, ok := dirs[gopath.GoPackage]; ok {
-                                return errors.Reason("GOPATH %(package)q is both a package and directory").
-                                        D("package", gopath.GoPackage).Err()
+                                return errors.Reason("GOPATH %q is both a package and directory", gopath.GoPackage).Err()
                         }
 
                         // Check intermediate paths to make sure there isn't a deployment
                         // conflict.
                         pkgParts := splitGoPackage(gopath.GoPackage)
                         for _, parentPkg := range pkgParts[:len(pkgParts)-1] {
                                 if _, ok := build[parentPkg]; ok {
-                                        return errors.Reason("GOPATH %(package)q is both a package and directory").
-                                                D("package", parentPkg).Err()
+                                        return errors.Reason("GOPATH %q is both a package and directory", parentPkg).Err()
                                 }
                                 dirs[parentPkg] = struct{}{}
                         }
 
                         // Everything checks out, add this link.
                         build[gopath.GoPackage] = src.pathTo(gopath.Path, "")
                 }
         }
 
         srcDir, err := root.EnsureDirectory("src")
         if err != nil {
                 return err
         }
 
         for pkg, src := range build {
                 var (
                         pkgComponents = strings.Split(pkg, "/")
                         d             = srcDir
                 )
                 for _, comp := range pkgComponents[:len(pkgComponents)-1] {
                         var err error
                         d, err = d.EnsureDirectory(comp)
                         if err != nil {
-                                return errors.Annotate(err).Reason("could not create GOPATH parent directory [%(path)s]").
-                                        D("path", d).Err()
+                                return errors.Annotate(err, "could not create GOPATH parent directory [%s]", d).Err()
                         }
                 }
                 link := d.File(pkgComponents[len(pkgComponents)-1])
                 if err := link.SymlinkFrom(src, true); err != nil {
-                        return errors.Annotate(err).Reason("failed to create GOPATH link").Err()
+                        return errors.Annotate(err, "failed to create GOPATH link").Err()
                 }
         }
         return nil
 }