[errors] Greatly simplify common/errors package.

luci_config/server/cfgclient/textproto/resolver.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 textproto implements a textproto config service Resolver.
 //
 // It uses the "luci-go" text protobuf multi-line extension. For more
 // information, see: github.com/luci/luci-go/common/proto
 //
 // The textproto protobuf Resolver internally formats its content as a binary
@@ skipping 63 matching lines @@
 //      var out []*MyProtoMessages
 //      TextProtoSlice(&out)
 func Slice(out interface{}) interface {
         cfgclient.MultiResolver
         cfgclient.FormattingResolver
 } {
         r := resolver{}
 
         v := reflect.ValueOf(out)
         if !r.loadMulti(v) {
-                panic(errors.Reason("%(type)s is not a pointer to a slice of protobuf message types").D("type", v.Type()).Err())
+                panic(errors.Reason("%s is not a pointer to a slice of protobuf message types", v.Type()).Err())
         }
         return &r
 }
 
 type resolver struct {
         messageName string
 
         single     proto.Message
         singleType reflect.Type
 
@@ skipping 42 matching lines @@
         }
         r.multiDest.Index(i).Set(msgV)
         return nil
 }
 
 func (r *resolver) resolveItem(out proto.Message, content string, format string) error {
         switch format {
         case "":
                 // Not formatted (text protobuf).
                 if err := luciProto.UnmarshalTextML(content, out); err != nil {
-                        return errors.Annotate(err).Reason("failed to unmarshal text protobuf").Err()
+                        return errors.Annotate(err, "failed to unmarshal text protobuf").Err()
                 }
                 return nil
 
         case BinaryFormat:
                 if err := parseBinaryContent(content, out); err != nil {
-                        return errors.Annotate(err).Reason("failed to unmarshal binary protobuf").Err()
+                        return errors.Annotate(err, "failed to unmarshal binary protobuf").Err()
                 }
                 return nil
 
         default:
-                return errors.Reason("unsupported content format: %(format)q").D("format", format).Err()
+                return errors.Reason("unsupported content format: %q", format).Err()
         }
 }
 
 func (r *resolver) Format() backend.FormatSpec {
         return backend.FormatSpec{BinaryFormat, r.messageName}
 }
 
 // Formatter is a cfgclient.Formatter implementation bound to a specific
 // protobuf message.
 //
 // It takes a text protobuf representation of that message as input and returns
 // a binary protobuf representation as output.
 type Formatter struct{}
 
 // FormatItem implements cfgclient.Formatter.
 func (f *Formatter) FormatItem(c, fd string) (string, error) {
         archetype := proto.MessageType(fd)
         if archetype == nil {
-                return "", errors.Reason("unknown proto.Message type %(type)q in formatter data").
-                        D("type", fd).Err()
+                return "", errors.Reason("unknown proto.Message type %q in formatter data", fd).Err()
         }
         msg := archetypeMessage(archetype)
 
         // Convert from config to protobuf.
         if err := luciProto.UnmarshalTextML(c, msg); err != nil {
-                return "", errors.Annotate(err).Reason("failed to unmarshal text protobuf content").Err()
+                return "", errors.Annotate(err, "failed to unmarshal text protobuf content").Err()
         }
 
         // Binary format.
         bc, err := makeBinaryContent(msg)
         if err != nil {
-                return "", errors.Annotate(err).Err()
+                return "", errors.Annotate(err, "").Err()
         }
         return bc, nil
 }
 
 // t is a pointer to a proto.Message instance.
 func archetypeInstance(t reflect.Type) reflect.Value {
         return reflect.New(t.Elem())
 }
 
 func archetypeMessage(t reflect.Type) proto.Message {
         return archetypeInstance(t).Interface().(proto.Message)
 }
 
 // makeBinaryContent constructs a binary content string from text protobuf
 // content.
 //
 // The binary content is formatted by concatenating two "cmpbin" binary values
 // together:
 // [Message Name] | [Marshaled Message Data]
 func makeBinaryContent(msg proto.Message) (string, error) {
         d, err := proto.Marshal(msg)
         if err != nil {
-                return "", errors.Annotate(err).Reason("failed to marshal message").Err()
+                return "", errors.Annotate(err, "failed to marshal message").Err()
         }
 
         var buf bytes.Buffer
         if _, err := cmpbin.WriteString(&buf, proto.MessageName(msg)); err != nil {
-                return "", errors.Annotate(err).Reason("failed to write message name").Err()
+                return "", errors.Annotate(err, "failed to write message name").Err()
         }
         if _, err := cmpbin.WriteBytes(&buf, d); err != nil {
-                return "", errors.Annotate(err).Reason("failed to write binary message content").Err()
+                return "", errors.Annotate(err, "failed to write binary message content").Err()
         }
         return buf.String(), nil
 }
 
 // parseBinaryContent parses a binary content string, pulling out the message
 // type and marshalled message data. It then unmarshals the specified type into
 // a new message based on the archetype.
 //
 // If the binary content's declared type doesn't match the archetype, or if the
 // binary content is invalid, an error will be returned.
 func parseBinaryContent(v string, msg proto.Message) error {
         r := strings.NewReader(v)
         encName, _, err := cmpbin.ReadString(r)
         if err != nil {
-                return errors.Annotate(err).Reason("failed to read message name").Err()
+                return errors.Annotate(err, "failed to read message name").Err()
         }
 
         // Construct a message for this.
         if name := proto.MessageName(msg); name != encName {
-                return errors.Reason("message name %(name)q doesn't match encoded name %(enc)q").
-                        D("name", name).D("enc", encName).Err()
+                return errors.Reason("message name %q doesn't match encoded name %q", name, encName).Err()
         }
 
         // We have the right message, unmarshal.
         d, _, err := cmpbin.ReadBytes(r)
         if err != nil {
-                return errors.Annotate(err).Reason("failed to read binary message content").Err()
+                return errors.Annotate(err, "failed to read binary message content").Err()
         }
         if err := proto.Unmarshal(d, msg); err != nil {
-                return errors.Annotate(err).Reason("failed to unmarshal message").Err()
+                return errors.Annotate(err, "failed to unmarshal message").Err()
         }
         return nil
 }