[errors] Greatly simplify common/errors package.

deploytool/cmd/luci_deploy/version.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"
         "os/user"
         "strings"
@@ skipping 33 matching lines @@
         switch vs := cp.VersionScheme; vs {
         case deploy.Deployment_CloudProject_DEFAULT:
                 cpv := structuredCloudProjectVersion{
                         minorSourceVersion: cloudVersionStringNormalize(src.MinorVersion),
                         majorSourceVersion: cloudVersionStringNormalize(src.MajorVersion),
                 }
 
                 if src.sg.Tainted {
                         username, err := b.getCurrentUser()
                         if err != nil {
-                                return nil, errors.Annotate(err).Reason("could not get tained user").Err()
+                                return nil, errors.Annotate(err, "could not get tained user").Err()
                         }
                         cpv.taintedUser = cloudVersionStringNormalize(username)
                 }
                 return &cpv, nil
 
         default:
-                return nil, errors.Reason("unknown version scheme %(scheme)v").D("scheme", vs).Err()
+                return nil, errors.Reason("unknown version scheme %v", vs).Err()
         }
 }
 
 func (b *cloudProjectVersionBuilder) getCurrentUser() (string, error) {
         if b.currentUser != nil {
                 return b.currentUser()
         }
 
         // Default "currentUser" function uses "os.User".
         user, err := user.Current()
         if err != nil {
-                return "", errors.Annotate(err).Reason("could not get tained user").Err()
+                return "", errors.Annotate(err, "could not get tained user").Err()
         }
         return user.Username, nil
 }
 
 func parseCloudProjectVersion(vs deploy.Deployment_CloudProject_VersionScheme, v string) (
         cloudProjectVersion, error) {
         var cpv structuredCloudProjectVersion
         switch vs {
         case deploy.Deployment_CloudProject_DEFAULT:
                 parts := strings.Split(v, "-")
 
                 switch len(parts) {
                 case 4:
                         // <min>-<maj>-tainted-<user>
                         cpv.taintedUser = parts[3]
                         fallthrough
 
                 case 2:
                         // <min>-<maj>
                         cpv.minorSourceVersion = parts[0]
                         cpv.majorSourceVersion = parts[1]
                         return &cpv, nil
 
                 default:
-                        return nil, errors.Reason("bad version %(version)q for scheme %(scheme)T").
-                                D("version", v).D("scheme", vs).Err()
+                        return nil, errors.Reason("bad version %q for scheme %T", v, vs).Err()
                 }
 
         default:
-                return nil, errors.Reason("unknown version scheme %(scheme)T").D("scheme", vs).Err()
+                return nil, errors.Reason("unknown version scheme %T", vs).Err()
         }
 }
 
 func (v *structuredCloudProjectVersion) String() string {
         var partsArray [5]string
         parts := partsArray[:0]
 
         parts = append(parts, []string{v.minorSourceVersion, v.majorSourceVersion}...)
         if tu := v.taintedUser; tu != "" {
                 parts = append(parts, []string{"tainted", tu}...)
@@ skipping 19 matching lines @@
 func cloudVersionStringNormalize(v string) string {
         return strings.Map(func(r rune) rune {
                 if (r >= 'a' && r <= 'z') ||
                         (r >= 'A' && r <= 'Z') ||
                         (r >= '0' && r <= '9') {
                         return r
                 }
                 return '_'
         }, v)
 }