[errors] Greatly simplify common/errors package.

deploytool/cmd/luci_deploy/layout.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 (
         "io/ioutil"
         "os"
         "path/filepath"
@@ skipping 24 matching lines @@
 }
 
 // pathTo resolves a path, p, specified in a directory with source-root-relative
 // path relpath.
 //
 //      - If the path begins with "/", it is taken relative to the source root.
 //      - If the path does not begin with "/", it is taken relative to "relpath"
 //        within the source root (e.g., "relpath" is prepended to it).
 func (s *layoutSource) pathTo(p, relpath string) string {
         if s.Relpath == "" {
-                panic(errors.Reason("source %(source)q is not checked out").D("source", s).Err())
+                panic(errors.Reason("source %q is not checked out", s).Err())
         }
 
         // If this is absolute, take it relative to source root.
         if strings.HasPrefix(p, "/") {
                 relpath = ""
         }
 
         // Convert "p" to a source-relative absolute path.
         p = strings.Trim(p, "/")
         if relpath != "" {
@@ skipping 64 matching lines @@
         // cloudProject is the deployment cloud project, if one is specified.
         cloudProject *layoutDeploymentCloudProject
 }
 
 func (d *layoutDeployment) String() string { return string(d.title) }
 
 // substituteParams applies parameter substitution to the supplied string in a
 // left-to-right manner.
 func (d *layoutDeployment) substituteParams(vp *string) error {
         if err := substitute(vp, d.Parameter); err != nil {
-                return errors.Annotate(err).Err()
+                return errors.Annotate(err, "").Err()
         }
         return nil
 }
 
 type layoutDeploymentComponent struct {
         deploy.Component
 
         // reldir is the source-relative directory that relative paths in this
         // component will reference. This will be the parent directory of the
         // component's configuration file.
@@ skipping 31 matching lines @@
 }
 
 func (comp *layoutDeploymentComponent) pathTo(relpath string) string {
         return comp.source().pathTo(relpath, comp.reldir)
 }
 
 func (comp *layoutDeploymentComponent) buildPath(bp *deploy.BuildPath) (string, error) {
         if path, ok := comp.buildPathMap[bp]; ok {
                 return path, nil
         }
-        return "", errors.Reason("no build path resolved for: %(bp)+v").D("bp", bp, "%+v").Err()
+        return "", errors.Reason("no build path resolved for: %+v", bp).Err()
 }
 
 func (comp *layoutDeploymentComponent) loadSourceComponent(reg componentRegistrar) error {
         if err := unmarshalTextProtobuf(comp.source().pathTo(comp.comp.Path, ""), &comp.Component); err != nil {
-                return errors.Annotate(err).Reason("failed to load source component %(component)q").D("component", comp).Err()
+                return errors.Annotate(err, "failed to load source component %q", comp).Err()
         }
 
         // Referenced build paths.
         for i, p := range comp.BuildPath {
                 var msg deploy.Component_Build
                 if err := unmarshalTextProtobuf(comp.pathTo(p), &msg); err != nil {
-                        return errors.Annotate(err).Reason("failed to load component Build #%(index)d from [%(path)s]").
-                                D("index", i).D("path", p).Err()
+                        return errors.Annotate(err, "failed to load component Build #%d from [%s]", i, p).Err()
                 }
                 comp.Build = append(comp.Build, &msg)
         }
 
         // Load any referenced data and normalize it for internal usage.
         dep := comp.dep
         switch t := comp.GetComponent().(type) {
         case *deploy.Component_AppengineModule:
                 // Normalize AppEngine module:
                 // - Modules explicitly named "default" will have their ModuleName changed
                 //   to the empty string.
                 // - All referenced path parameters will be loaded and appended onto their
                 //   non-path members.
                 if dep.cloudProject == nil {
-                        return errors.Reason("AppEngine module %(comp)q requires a cloud project").
-                                D("comp", comp).Err()
+                        return errors.Reason("AppEngine module %q requires a cloud project", comp).Err()
                 }
 
                 aem := t.AppengineModule
                 if aem.ModuleName == "default" {
                         aem.ModuleName = ""
                 }
 
                 module := layoutDeploymentGAEModule{
                         AppEngineModule: aem,
                         comp:            comp,
                 }
 
                 // Referenced handler paths.
                 for i, p := range aem.HandlerPath {
                         var msg deploy.AppEngineModule_HandlerSet
                         if err := unmarshalTextProtobuf(comp.pathTo(p), &msg); err != nil {
-                                return errors.Annotate(err).Reason("failed to load HandlerSet #%(index)d for %(component)q").
-                                        D("index", i).D("component", comp).Err()
+                                return errors.Annotate(err, "failed to load HandlerSet #%d for %q", i, comp).Err()
                         }
                         module.Handlers.Handler = append(module.Handlers.Handler, msg.Handler...)
                 }
 
                 // If the module specifies a direct "index.yaml" path, load index entries
                 // from there and translate them to resources.
                 if p := module.IndexYamlPath; p != "" {
                         path := module.comp.pathTo(p)
                         res, err := loadIndexYAMLResource(path)
                         if err != nil {
-                                return errors.Annotate(err).Reason("failed to load 'index.yaml' from [%(path)s]").
-                                        D("path", path).Err()
+                                return errors.Annotate(err, "failed to load 'index.yaml' from [%s]", path).Err()
                         }
                         dep.cloudProject.appendResources(res, &module)
                 }
 
                 // Append GAE Resources.
                 if r := module.Resources; r != nil {
                         dep.cloudProject.appendResources(r, &module)
                 }
 
                 for i, p := range module.ResourcePath {
                         if err := comp.dep.substituteParams(&p); err != nil {
-                                return errors.Annotate(err).Reason("failed to substitute parameters for resource path").
-                                        D("path", p).Err()
+                                return errors.Annotate(err, "failed to substitute parameters for resource path").
+                                        InternalReason("path(%s)", p).Err()
                         }
 
                         var res deploy.AppEngineResources
                         if err := unmarshalTextProtobuf(comp.pathTo(p), &res); err != nil {
-                                return errors.Annotate(err).Reason("failed to load Resources #%(index)d for %(component)").
-                                        D("index", i).D("path", p).D("component", comp).Err()
+                                return errors.Annotate(err, "failed to load Resources #%d for %q", i, comp).
+                                        InternalReason("path(%s)", p).Err()
                         }
                         dep.cloudProject.appendResources(&res, &module)
                 }
 
                 // Add this module to our cloud project's AppEngine modules list.
                 dep.cloudProject.appEngineModules = append(dep.cloudProject.appEngineModules, &module)
                 if reg != nil {
                         reg.addGAEModule(&module)
                 }
 
         case *deploy.Component_GkePod:
                 if len(comp.gkePods) == 0 {
-                        return errors.Reason("GKE Container %(comp)q is not bound to a GKE cluster").
-                                D("comp", comp.String()).Err()
+                        return errors.Reason("GKE Container %q is not bound to a GKE cluster", comp).Err()
                 }
 
                 comp.gkePod = &layoutDeploymentGKEPod{
                         ContainerEnginePod: t.GkePod,
                         comp:               comp,
                 }
 
                 // None of the labels may use our "deploytool" prefix.
                 var invalidLabels []string
                 for k := range comp.gkePod.KubePod.Labels {
                         if isKubeDeployToolKey(k) {
                                 invalidLabels = append(invalidLabels, k)
                         }
                 }
                 if len(invalidLabels) > 0 {
                         sort.Strings(invalidLabels)
                         return errors.Reason("user-supplied labels may not use deploytool prefix").
-                                D("labels", invalidLabels).Err()
+                                InternalReason("labels(%v)", invalidLabels).Err()
                 }
 
                 for _, bp := range comp.gkePods {
                         bp.pod = comp.gkePod
                         if reg != nil {
                                 reg.addGKEPod(bp)
                         }
                 }
         }
 
         return nil
 }
 
 // expandPaths iterates through the Component-defined directory fields and
 // expands their paths into actual filesystem paths.
 //
 // This must be performed after the build instructions have been executed so
 // that the "build_dir" map will be available if needed by a Component.
 func (comp *layoutDeploymentComponent) expandPaths() error {
         resolveBuildPath := func(bp *deploy.BuildPath) error {
                 if _, ok := comp.buildPathMap[bp]; ok {
                         // Already resolved.
                         return nil
                 }
 
                 var resolved string
                 if bp.DirKey != "" {
                         dir, ok := comp.buildDirs[bp.DirKey]
                         if !ok {
-                                return errors.Reason("Invalid `dir_key` value: %(dirKey)q").D("dirKey", bp.DirKey).Err()
+                                return errors.Reason("Invalid `dir_key` value: %q", bp.DirKey).Err()
                         }
                         resolved = deployToNative(dir, bp.Path)
                 } else {
                         resolved = comp.pathTo(bp.Path)
                 }
 
                 if comp.buildPathMap == nil {
                         comp.buildPathMap = make(map[*deploy.BuildPath]string)
                 }
                 comp.buildPathMap[bp] = resolved
                 return nil
         }
 
         switch t := comp.Component.Component.(type) {
         case *deploy.Component_AppengineModule:
                 aem := t.AppengineModule
                 if aem.Handlers != nil {
                         for _, handler := range aem.Handlers.Handler {
                                 switch c := handler.Content.(type) {
                                 case *deploy.AppEngineModule_Handler_StaticFiles_:
                                         sf := c.StaticFiles
                                         switch bd := sf.BaseDir.(type) {
                                         case *deploy.AppEngineModule_Handler_StaticFiles_Path:
                                                 // Normalize our static files directory to a BuildPath rooted at our
                                                 // source.
                                                 sf.BaseDir = &deploy.AppEngineModule_Handler_StaticFiles_Build{
                                                         Build: &deploy.BuildPath{Path: bd.Path},
                                                 }
                                                 if err := resolveBuildPath(sf.GetBuild()); err != nil {
-                                                        return errors.Annotate(err).Err()
+                                                        return errors.Annotate(err, "").Err()
                                                 }
 
                                         case *deploy.AppEngineModule_Handler_StaticFiles_Build:
                                                 if err := resolveBuildPath(bd.Build); err != nil {
-                                                        return errors.Annotate(err).Err()
+                                                        return errors.Annotate(err, "").Err()
                                                 }
 
                                         default:
-                                                return errors.Reason("unknown `base_dir` type %(type)T").D("type", bd).Err()
+                                                return errors.Reason("unknown `base_dir` type %T", bd).Err()
                                         }
 
                                 case *deploy.AppEngineModule_Handler_StaticDir:
                                         // Normalize our static directory (source-relative) to a BuildPath
                                         // rooted at our source.
                                         handler.Content = &deploy.AppEngineModule_Handler_StaticBuildDir{
                                                 StaticBuildDir: &deploy.BuildPath{Path: c.StaticDir},
                                         }
                                         if err := resolveBuildPath(handler.GetStaticBuildDir()); err != nil {
-                                                return errors.Annotate(err).Err()
+                                                return errors.Annotate(err, "").Err()
                                         }
 
                                 case *deploy.AppEngineModule_Handler_StaticBuildDir:
                                         if err := resolveBuildPath(c.StaticBuildDir); err != nil {
-                                                return errors.Annotate(err).Err()
+                                                return errors.Annotate(err, "").Err()
                                         }
                                 }
                         }
                 }
 
         case *deploy.Component_GkePod:
                 for _, container := range t.GkePod.KubePod.Container {
                         switch df := container.Dockerfile.(type) {
                         case *deploy.KubernetesPod_Container_Path:
                                 // Convert to BuildPath.
                                 container.Dockerfile = &deploy.KubernetesPod_Container_Build{
                                         Build: &deploy.BuildPath{Path: df.Path},
                                 }
                                 if err := resolveBuildPath(container.GetBuild()); err != nil {
-                                        return errors.Annotate(err).Err()
+                                        return errors.Annotate(err, "").Err()
                                 }
 
                         case *deploy.KubernetesPod_Container_Build:
                                 if err := resolveBuildPath(df.Build); err != nil {
-                                        return errors.Annotate(err).Err()
+                                        return errors.Annotate(err, "").Err()
                                 }
 
                         default:
-                                return errors.Reason("unknown `dockerfile` type %(type)T").D("type", df).Err()
+                                return errors.Reason("unknown `dockerfile` type %T", df).Err()
                         }
                 }
         }
 
         return nil
 }
 
 // layoutDeploymentCloudProject tracks a cloud project element, as well as
 // any cloud project configurations referenced by this Deployment's Components.
 type layoutDeploymentCloudProject struct {
@@ skipping 111 matching lines @@
         cloudProjects map[string]*layoutDeploymentCloudProject
 }
 
 // workingFilesystem creates a new managed filesystem at our working directory
 // root.
 //
 // This adds layout-defined components to the filesystem.
 func (l *deployLayout) workingFilesystem() (*managedfs.Filesystem, error) {
         fs, err := managedfs.New(l.WorkingPath)
         if err != nil {
-                return nil, errors.Annotate(err).Err()
+                return nil, errors.Annotate(err, "").Err()
         }
         return fs, nil
 }
 
 func (l *deployLayout) workingPathTo(relpath string) string {
         return filepath.Join(l.WorkingPath, relpath)
 }
 
 func (l *deployLayout) getDeploymentComponent(v string) (*layoutDeployment, *layoutDeploymentComponent, error) {
         deployment, component := splitComponentPath(v)
 
         dep := l.deployments[deployment]
         if dep == nil {
-                return nil, nil, errors.Reason("unknown Deployment %(dep)q").
-                        D("value", v).D("dep", deployment).Err()
+                return nil, nil, errors.Reason("unknown Deployment %q", deployment).
+                        InternalReason("value(%s)", v).Err()
         }
 
         // If a component was specified, only add that component.
         if component != "" {
                 comp := dep.components[component]
                 if comp == nil {
-                        return nil, nil, errors.Reason("unknown Deployment Component %(value)q").
-                                D("value", v).D("dep", deployment).D("comp", component).Err()
+                        return nil, nil, errors.Reason("unknown Deployment Component %q", v).
+                                InternalReason("dep(%s)/comp(%s)", deployment, component).Err()
                 }
                 return dep, comp, nil
         }
         return dep, nil, nil
 }
 
 func (l *deployLayout) matchDeploymentComponent(m string, cb func(*layoutDeployment, *layoutDeploymentComponent)) error {
         for _, depName := range l.deploymentNames {
                 dep := l.deployments[depName]
 
                 matched, err := filepath.Match(m, dep.String())
                 if err != nil {
-                        return errors.Annotate(err).Reason("failed to match %(pattern)q").D("pattern", m).Err()
+                        return errors.Annotate(err, "failed to match %q", m).Err()
                 }
                 if matched {
                         // Matches entire deployment.
                         cb(dep, nil)
                         continue
                 }
 
                 // Try each of the deployment's components.
                 for _, compName := range dep.componentNames {
                         comp := dep.components[compName]
 
                         matched, err := filepath.Match(m, comp.String())
                         if err != nil {
-                                return errors.Annotate(err).Reason("failed to match %(pattern)q").D("pattern", m).Err()
+                                return errors.Annotate(err, "failed to match %q", m).Err()
                         }
                         if matched {
                                 cb(dep, comp)
                         }
                 }
         }
 
         return nil
 }
 
 func (l *deployLayout) load(c context.Context, path string) error {
         if path == "" {
                 wd, err := os.Getwd()
                 if err != nil {
                         return err
                 }
                 path, err = findLayout(defaultLayoutFilename, wd)
                 if err != nil {
                         return err
                 }
         }
 
         if err := unmarshalTextProtobuf(path, &l.Layout); err != nil {
                 return err
         }
 
         // Load the user config, if available.
         if err := loadUserConfig(c, &l.user); err != nil {
-                return errors.Annotate(err).Reason("failed to load user config").Err()
+                return errors.Annotate(err, "failed to load user config").Err()
         }
         if len(l.user.SourceOverride) > 0 {
                 l.userSourceOverrides = make(map[string]*deploy.Source, len(l.user.SourceOverride))
                 for k, v := range l.user.SourceOverride {
                         l.userSourceOverrides[k] = v
                 }
         }
 
         // Populate with defaults.
         l.basePath = filepath.Dir(path)
@@ skipping 10 matching lines @@
         if l.WorkingPath == "" {
                 l.WorkingPath = filepath.Join(l.basePath, ".working")
         } else {
                 if !filepath.IsAbs(l.WorkingPath) {
                         l.WorkingPath = filepath.Join(l.basePath, l.WorkingPath)
                 }
         }
 
         absWorkingPath, err := filepath.Abs(l.WorkingPath)
         if err != nil {
-                return errors.Annotate(err).Reason("failed to resolve absolute path for %(path)q").
-                        D("path", l.WorkingPath).Err()
+                return errors.Annotate(err, "failed to resolve absolute path for %q", l.WorkingPath).Err()
         }
         l.WorkingPath = absWorkingPath
         return nil
 }
 
 func (l *deployLayout) initFrozenCheckout(c context.Context) (*deploy.FrozenLayout, error) {
         fis, err := ioutil.ReadDir(l.SourcesPath)
         if err != nil {
-                return nil, errors.Annotate(err).Reason("failed to read directory").Err()
+                return nil, errors.Annotate(err, "failed to read directory").Err()
         }
 
         // Build internal and frozen layout in parallel.
         var frozen deploy.FrozenLayout
         frozen.SourceGroup = make(map[string]*deploy.FrozenLayout_SourceGroup, len(fis))
 
         for _, fi := range fis {
                 name := title(fi.Name())
                 path := filepath.Join(l.SourcesPath, string(name))
 
@@ skipping 27 matching lines @@
                 sg := deploy.FrozenLayout_SourceGroup{
                         Source: make(map[string]*deploy.FrozenLayout_Source, len(srcInfos)),
                 }
 
                 var srcBase deploy.Source
                 err = unmarshalTextProtobufDir(path, srcInfos, &srcBase, func(name string) error {
                         cpy := srcBase
 
                         t, err := titleFromConfigPath(name)
                         if err != nil {
-                                return errors.Annotate(err).Reason("invalid source title").Err()
+                                return errors.Annotate(err, "invalid source title").Err()
                         }
 
                         src := deploy.FrozenLayout_Source{
                                 Source: &cpy,
                         }
                         sg.Source[string(t)] = &src
                         return nil
                 })
                 if err != nil {
-                        return nil, errors.Annotate(err).Reason("failed to load source group %(name)q from [%(path)s]").
-                                D("name", name).D("path", path).Err()
+                        return nil, errors.Annotate(err, "failed to load source group %q from [%s]", name, path).Err()
                 }
 
                 frozen.SourceGroup[string(name)] = &sg
         }
 
         return &frozen, nil
 }
 
 func (l *deployLayout) loadFrozenLayout(c context.Context) error {
         // Load the frozen configuration file from disk.
         frozen, err := checkoutFrozen(l)
         if err != nil {
-                return errors.Annotate(err).Reason("failed to load frozen checkout").Err()
+                return errors.Annotate(err, "failed to load frozen checkout").Err()
         }
 
         // Load our source groups and sources.
         l.sourceGroups = make(map[title]*layoutSourceGroup, len(frozen.SourceGroup))
         for sgName, fsg := range frozen.SourceGroup {
                 sg := layoutSourceGroup{
                         FrozenLayout_SourceGroup: fsg,
                         layout:  l,
                         title:   title(sgName),
                         sources: make(map[title]*layoutSource, len(fsg.Source)),
                 }
 
                 for srcName, fs := range fsg.Source {
                         src := layoutSource{
                                 FrozenLayout_Source: fs,
                                 sg:                  &sg,
                                 title:               title(srcName),
                         }
                         sg.sources[src.title] = &src
                 }
 
                 l.sourceGroups[sg.title] = &sg
         }
 
         // Build our internally-connected structures from the frozen layout.
         if err := l.loadApps(c); err != nil {
-                return errors.Annotate(err).Reason("failed to load applications from [%(path)s]").
-                        D("path", l.ApplicationsPath).Err()
+                return errors.Annotate(err, "failed to load applications from [%s]", l.ApplicationsPath).Err()
         }
         if err := l.loadDeployments(c); err != nil {
-                return errors.Annotate(err).Reason("failed to load deployments from [%(path)s]").
-                        D("path", l.DeploymentsPath).Err()
+                return errors.Annotate(err, "failed to load deployments from [%s]", l.DeploymentsPath).Err()
         }
         return nil
 }
 
 func (l *deployLayout) loadApps(c context.Context) error {
         fis, err := ioutil.ReadDir(l.ApplicationsPath)
         if err != nil {
-                return errors.Annotate(err).Reason("failed to read directory").Err()
+                return errors.Annotate(err, "failed to read directory").Err()
         }
         apps := make(map[title]*deploy.Application, len(fis))
         var appBase deploy.Application
         err = unmarshalTextProtobufDir(l.ApplicationsPath, fis, &appBase, func(name string) error {
                 cpy := appBase
 
                 t, err := titleFromConfigPath(name)
                 if err != nil {
-                        return errors.Annotate(err).Reason("invalid application title").Err()
+                        return errors.Annotate(err, "invalid application title").Err()
                 }
 
                 apps[t] = &cpy
                 return nil
         })
         if err != nil {
                 return err
         }
 
         l.apps = make(map[title]*layoutApp, len(apps))
         for t, app := range apps {
                 proj := layoutApp{
                         Application: app,
                         title:       t,
                         components:  make(map[title]*layoutAppComponent, len(app.Component)),
                 }
 
                 // Initialize components. These can't actually be populated until we have
                 // loaded our sources.
                 for _, comp := range proj.Component {
                         compT := title(comp.Name)
                         if err := compT.validate(); err != nil {
-                                return errors.Annotate(err).Reason("application %(app)q component %(component)q is not a valid component title").
-                                        D("app", t).D("component", comp.Name).Err()
+                                return errors.Annotate(err, "application %q component %q is not a valid component title", t, comp.Name).Err()
                         }
                         proj.components[compT] = &layoutAppComponent{
                                 Application_Component: comp,
                                 proj:  &proj,
                                 title: compT,
                         }
                 }
 
                 l.apps[t] = &proj
         }
         return nil
 }
 
 func (l *deployLayout) loadDeployments(c context.Context) error {
         fis, err := ioutil.ReadDir(l.DeploymentsPath)
         if err != nil {
-                return errors.Annotate(err).Reason("failed to read directory").Err()
+                return errors.Annotate(err, "failed to read directory").Err()
         }
         deployments := make(map[title]*deploy.Deployment, len(fis))
         var deploymentBase deploy.Deployment
         err = unmarshalTextProtobufDir(l.DeploymentsPath, fis, &deploymentBase, func(name string) error {
                 cpy := deploymentBase
 
                 t, err := titleFromConfigPath(name)
                 if err != nil {
-                        return errors.Annotate(err).Reason("invalid deployment title").Err()
+                        return errors.Annotate(err, "invalid deployment title").Err()
                 }
 
                 deployments[t] = &cpy
                 return nil
         })
         if err != nil {
                 return err
         }
 
         l.deployments = make(map[title]*layoutDeployment, len(deployments))
         for t, d := range deployments {
                 dep, err := l.loadDeployment(t, d)
                 if err != nil {
-                        return errors.Annotate(err).Reason("failed to load deployment (%(deployment)q)").
-                                D("deployment", t).Err()
+                        return errors.Annotate(err, "failed to load deployment (%q)", t).Err()
                 }
                 l.deployments[t] = dep
                 l.deploymentNames = append(l.deploymentNames, dep.title)
         }
 
         return nil
 }
 
 func (l *deployLayout) loadDeployment(t title, d *deploy.Deployment) (*layoutDeployment, error) {
         dep := layoutDeployment{
                 Deployment: d,
                 l:          l,
                 title:      t,
                 sg:         l.sourceGroups[title(d.SourceGroup)],
         }
         if dep.sg == nil {
-                return nil, errors.Reason("unknown source group %(sourceGroup)q").
-                        D("sourceGroup", d.SourceGroup).Err()
+                return nil, errors.Reason("unknown source group %q", d.SourceGroup).Err()
         }
 
         // Resolve our application.
         dep.app = l.apps[title(dep.Application)]
         if dep.app == nil {
-                return nil, errors.Reason("unknown application %(app)q").D("app", dep.Application).Err()
+                return nil, errors.Reason("unknown application %q", dep.Application).Err()
         }
 
         // Initialize our Components. Their protobufs cannot not be loaded until
         // we have a checkout.
         dep.components = make(map[title]*layoutDeploymentComponent, len(dep.app.components))
         for compTitle, projComp := range dep.app.components {
                 comp := layoutDeploymentComponent{
                         reldir:  deployDirname(projComp.Path),
                         dep:     &dep,
                         comp:    projComp,
                         sources: []*layoutSource{dep.sg.sources[title(projComp.Source)]},
                 }
                 if comp.sources[0] == nil {
-                        return nil, errors.Reason("application references non-existent source %(source)q").
-                                D("source", projComp.Source).Err()
+                        return nil, errors.Reason("application references non-existent source %q", projComp.Source).Err()
                 }
                 for _, os := range projComp.OtherSource {
                         src := dep.sg.sources[title(os)]
                         if src == nil {
-                                return nil, errors.Reason("application references non-existent other source %(source)q").
-                                        D("source", os).Err()
+                                return nil, errors.Reason("application references non-existent other source %q", os).Err()
                         }
                         comp.sources = append(comp.sources, src)
                 }
 
                 dep.components[compTitle] = &comp
                 dep.componentNames = append(dep.componentNames, compTitle)
         }
 
         // Build a map of cloud project names.
         if dep.CloudProject != nil {
                 cp := layoutDeploymentCloudProject{
                         Deployment_CloudProject: dep.CloudProject,
                         dep: &dep,
                 }
                 if l.cloudProjects == nil {
                         l.cloudProjects = make(map[string]*layoutDeploymentCloudProject)
                 }
                 if cur, ok := l.cloudProjects[cp.Name]; ok {
-                        return nil, errors.Reason("cloud project %(name)q defined by both %(curDep)q and %(thisDep)q").
-                                D("name", cp.Name).D("curDep", cur.dep.title).D("thisDep", dep.title).Err()
+                        return nil, errors.Reason("cloud project %q defined by both %q and %q", cp.Name, cur.dep.title, dep.title).Err()
                 }
                 l.cloudProjects[cp.Name] = &cp
 
                 if len(dep.CloudProject.GkeCluster) > 0 {
                         cp.gkeClusters = make(map[string]*layoutDeploymentGKECluster, len(dep.CloudProject.GkeCluster))
                         for _, gke := range dep.CloudProject.GkeCluster {
                                 gkeCluster := layoutDeploymentGKECluster{
                                         Deployment_CloudProject_GKECluster: gke,
                                         cloudProject:                       &cp,
                                 }
 
                                 // Bind Components to their GKE cluster.
                                 for _, b := range gke.Pod {
                                         comp := dep.components[title(b.Name)]
                                         switch {
                                         case comp == nil:
-                                                return nil, errors.Reason("unknown component %(comp)q for cluster %(name)q").
-                                                        D("comp", b.Name).D("name", gke.Name).Err()
+                                                return nil, errors.Reason("unknown component %q for cluster %q", b.Name, gke.Name).Err()
 
                                         case b.Replicas <= 0:
-                                                return nil, errors.Reason("GKE component %(comp)q must have at least 1 replica").
-                                                        D("comp", b.Name).Err()
+                                                return nil, errors.Reason("GKE component %q must have at least 1 replica", b.Name).Err()
                                         }
 
                                         bp := &layoutDeploymentGKEPodBinding{
                                                 Deployment_CloudProject_GKECluster_PodBinding: b,
                                                 cluster: &gkeCluster,
                                         }
                                         comp.gkePods = append(comp.gkePods, bp)
                                         gkeCluster.pods = append(gkeCluster.pods, bp)
                                 }
 
@@ skipping 32 matching lines @@
                 switch st, err := os.Stat(path); {
                 case err == nil:
                         if !st.IsDir() {
                                 return path, nil
                         }
 
                 case isNotExist(err):
                         break
 
                 default:
-                        return "", errors.Annotate(err).Reason("failed to state %(path)q").
-                                D("path", path).Err()
+                        return "", errors.Annotate(err, "failed to state %q", path).Err()
                 }
 
                 // Walk up one directory.
                 oldDir := dir
                 dir, _ = filepath.Split(dir)
                 if oldDir == dir {
-                        return "", errors.Reason("could not find %(filename)q starting from %(dir)q").
-                                D("filename", filename).D("dir", dir).Err()
+                        return "", errors.Reason("could not find %q starting from %q", filename, dir).Err()
                 }
         }
 }
 
 type componentRegistrar interface {
         addGAEModule(*layoutDeploymentGAEModule)
         addGKEPod(*layoutDeploymentGKEPodBinding)
 }