[errors] de-specialize Transient in favor of Tags.

common/config/validation/validation.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 validation provides a helper for performing config validations.
 package validation
 
 import (
         "fmt"
         "strings"
@@ skipping 26 matching lines @@
 // now). Each file may have some internal nested structure. The logical path
 // inside this structure is captured through Enter and Exit calls.
 type Context struct {
         Logger logging.Logger // logs errors as they appear
 
         errors  errors.MultiError // all accumulated errors
         file    string            // the currently validated file
         element []string          // logical path of a sub-element we validate, see Enter
 }
 
+type fileTagType struct{ Key errors.TagKey }
+
+func (f fileTagType) With(name string) errors.TagValue { return errors.MkTagValue(f.Key, name) }
+func (f fileTagType) In(err error) (v string, ok bool) {
+        d, ok := errors.TagValueIn(f.Key, err)
+        if ok {
+                v = d.(string)
+        }
+        return
+}
+
+type elementTagType struct{ Key errors.TagKey }
+
+func (e elementTagType) With(elements []string) errors.TagValue {
+        return errors.MkTagValue(e.Key, append([]string(nil), elements...))
+}
+func (e elementTagType) In(err error) (v []string, ok bool) {
+        d, ok := errors.TagValueIn(e.Key, err)
+        if ok {
+                v = d.([]string)
+        }
+        return
+}
+
+var fileTag = fileTagType{errors.NewTagKey("holds the file name for tests")}
+var elementTag = elementTagType{errors.NewTagKey("holds the elements for tests")}
+
 // Error records a validation error.
 func (v *Context) Error(msg string, args ...interface{}) {
         ctx := ""
         if v.file != "" {
                 ctx = fmt.Sprintf("in %q", v.file)
         } else {
                 ctx = "in <unspecified file>"
         }
         if len(v.element) != 0 {
                 ctx += " (" + strings.Join(v.element, " / ") + ")"
         }
 
         // Prepending ctx to msg before passing it to fmt is not entirely correct,
         // since ctx may have format specifiers (like %s), that will be misunderstood.
         // So we put ctx in the argument list.
         msg = "%s: " + msg
         args = append([]interface{}{ctx}, args...)
         if v.Logger != nil {
                 v.Logger.Errorf(msg, args...)
         }
 
         // Make the file and the logical path also usable through error inspection.
         err := errors.Reason(fmt.Sprintf(msg, args...)).
-                D("file", v.file).
-                D("element", append([]string{}, v.element...)).Err()
+                Tag(fileTag.With(v.file), elementTag.With(v.element)).Err()
         v.errors = append(v.errors, err)
 }
 
 // SetFile records that what follows is errors for this particular file.
 //
 // Changing the file resets the current element (see Enter/Exit).
 func (v *Context) SetFile(path string) {
         if v.file != path {
                 v.file = path
                 v.element = nil
@@ skipping 25 matching lines @@
 //
 // Returns nil otherwise.
 func (v *Context) Finalize() error {
         if len(v.errors) == 0 {
                 return nil
         }
         return &Error{
                 Errors: append(errors.MultiError{}, v.errors...),
         }
 }