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"
@@ skipping 55 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.
+// LazyMultiError is a lazily-constructed MultiError.
+//
+// LazyMultiError is like MultiError, except that you know the ultimate size up
+// front, and then you call Assign for each error encountered, and it's
+// potential index. The underlying 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.
+// Build one with NewLazy.
 type LazyMultiError struct {

[M-A Ruel, 2015/08/12 19:13:50]

Why doesn't LazyMultiError have method Error() so it would fit the error
interface?

[dnj (Google), 2015/08/14 16:40:00]

If your goal is "only constructable", then LazyMultiError should be an interface
w/ an implementing private struct. Currently, I can instantiate a (admittedly
not so useful) one via LazyMultiError{}.

[iannucci, 2015/08/14 17:00:26]

Done

         sync.Mutex
 
-        Size int
+        size int

[tandrii_google, 2015/08/14 08:50:36]

wait, this doesn't make what CL description says. ie I can still do:
v := NewLazyMultiError{}

and I tested just that here (pcg is happy):
https://codereview.chromium.org/1297573002 .

So, either fix description, or make LazyMultiError an interface.

[iannucci, 2015/08/14 17:00:26]

done

         me   MultiError
 }
 
+// NewLazyMultiError makes a new LazyMultiError of the provided size.
+func NewLazyMultiError(size int) *LazyMultiError {
+        return &LazyMultiError{size: size}
+}
+
 // 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 = 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()
@@ skipping 20 matching lines @@
                 // 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
 }