[errors] Greatly simplify common/errors package.

vpython/python/version.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 python
 
 import (
         "fmt"
         "regexp"
         "strconv"
@@ skipping 27 matching lines @@
 
 // ParseVersion parses a Python version from a version string (e.g., "1.2.3").
 func ParseVersion(s string) (Version, error) {
         var v Version
         if s == "" {
                 return v, nil
         }
 
         match := canonicalVersionRE.FindStringSubmatch(s)
         if match == nil {
-                return v, errors.Reason("non-canonical Python version string: %(value)q").
-                        D("value", s).
-                        Err()
+                return v, errors.Reason("non-canonical Python version string: %q", s).Err()
         }
         parts := strings.Split(match[2], ".")
 
         parseVersion := func(value string) (int, error) {
                 version, err := strconv.Atoi(value)
                 if err != nil {
-                        return 0, errors.Annotate(err).Reason("invalid number value: %(value)q").
-                                D("value", value).
-                                Err()
+                        return 0, errors.Annotate(err, "invalid number value: %q", value).Err()
                 }
                 return version, nil
         }
 
         // Regexp match guarantees that "parts" will have at least one component, and
         // that all components are well-formed numbers.
         var err error
         if len(parts) >= 3 {
                 if v.Patch, err = parseVersion(parts[2]); err != nil {
-                        return v, errors.Annotate(err).Reason("invalid patch value").Err()
+                        return v, errors.Annotate(err, "invalid patch value").Err()
                 }
         }
         if len(parts) >= 2 {
                 if v.Minor, err = parseVersion(parts[1]); err != nil {
-                        return v, errors.Annotate(err).Reason("invalid minor value").Err()
+                        return v, errors.Annotate(err, "invalid minor value").Err()
                 }
         }
         if v.Major, err = parseVersion(parts[0]); err != nil {
-                return v, errors.Annotate(err).Reason("invalid major value").Err()
+                return v, errors.Annotate(err, "invalid major value").Err()
         }
         if v.IsZero() {
                 return v, errors.Reason("version is incomplete").Err()
         }
         return v, nil
 }
 
 func (v Version) String() string {
         if v.IsZero() {
                 return ""
@@ skipping 57 matching lines @@
         case v.Major > other.Major:
                 return false
         case v.Minor < other.Minor:
                 return true
         case v.Minor > other.Minor:
                 return false
         default:
                 return (v.Patch < other.Patch)
         }
 }