Make LazyMultiError only constructable via function

common/errors/multierror.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package errors
 
 import (
         "fmt"
         "reflect"
-        "sync"
 )
 
 var (
         multiErrorType = reflect.TypeOf(MultiError(nil))
 )
 
 // MultiError is a simple `error` implementation which represents multiple
 // `error` objects in one.
 type MultiError []error
 
@@ skipping 45 matching lines @@
                         continue
                 }
                 ret = append(ret, e)
         }
         if len(ret) == 0 {
                 return nil
         }
         return ret
 }
 
-// LazyMultiError is a lazily-constructed MultiError. You specify the target
-// MultiError size up front (as Size), and then you call Assign for each error
-// encountered, and it's potential index. The MultiError will only be allocated
-// if one of the Assign'd errors is non-nil. Similarly, Get will retrieve either
-// the allocated MultiError, or nil if no error was encountered.
-type LazyMultiError struct {
-        sync.Mutex
-
-        Size int
-        me   MultiError
-}
-
-// Assign semantically assigns the error to the given index in the MultiError.
-// If the error is nil, no action is taken. Otherwise the MultiError is
-// allocated to its full size (if not already), and the error assigned into it.
-//
-// It returns true iff err != nil.
-func (e *LazyMultiError) Assign(i int, err error) bool {
-        if err == nil {
-                return false
-        }
-        e.Lock()
-        defer e.Unlock()
-        if e.me == nil {
-                e.me = make(MultiError, e.Size)
-        }
-        e.me[i] = err
-        return true
-}
-
-// GetOne returns the error at the given index, or nil, if no non-nil error
-// was Assign'd.
-func (e *LazyMultiError) GetOne(i int) error {
-        e.Lock()
-        defer e.Unlock()
-        if e.me == nil {
-                return nil
-        }
-        return e.me[i]
-}
-
-// Get returns the MultiError, or nil, if no non-nil error was Assign'd.
-func (e *LazyMultiError) Get() error {
-        e.Lock()
-        defer e.Unlock()
-        if e.me == nil {
-                return nil
-        }
-        return e.me
-}
-
 // Fix will convert a MultiError compatible type (e.g. []error) to this
 // version of MultiError.
 func Fix(err error) error {
         if err != nil {
                 // we know that err already conforms to the error interface (or the caller's
                 // method wouldn't compile), so check to see if the error's underlying type
                 // looks like one of the special error types we implement.
                 v := reflect.ValueOf(err)
                 if v.Type().ConvertibleTo(multiErrorType) {
                         err = v.Convert(multiErrorType).Interface().(error)
                 }
         }
         return err
 }