[dev.power64] code review 160200044: build: merge default into dev.power64

src/pkg/io/io.go

 // Copyright 2009 The Go 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 io provides basic interfaces to I/O primitives.
 // Its primary job is to wrap existing implementations of such primitives,
 // such as those in package os, into shared public interfaces that
 // abstract the functionality, plus some other related primitives.
 //
 // Because these interfaces and primitives wrap lower-level operations with
@@ skipping 45 matching lines @@
 // return either err == EOF or err == nil.  The next Read should
 // return 0, EOF regardless.
 //
 // Callers should always process the n > 0 bytes returned before
 // considering the error err.  Doing so correctly handles I/O errors
 // that happen after reading some bytes and also both of the
 // allowed EOF behaviors.
 //
 // Implementations of Read are discouraged from returning a
 // zero byte count with a nil error, and callers should treat
-// that situation as a no-op.
+// that situation as a no-op. Implementations must not retain p.
 type Reader interface {
         Read(p []byte) (n int, err error)
 }
 
 // Writer is the interface that wraps the basic Write method.
 //
 // Write writes len(p) bytes from p to the underlying data stream.
 // It returns the number of bytes written from p (0 <= n <= len(p))
 // and any error encountered that caused the write to stop early.
 // Write must return a non-nil error if it returns n < len(p).
 // Write must not modify the slice data, even temporarily.
+//
+// Implementations must not retain p.
 type Writer interface {
         Write(p []byte) (n int, err error)
 }
 
 // Closer is the interface that wraps the basic Close method.
 //
 // The behavior of Close after the first call is undefined.
 // Specific implementations may document their own behavior.
 type Closer interface {
         Close() error
@@ skipping 97 matching lines @@
 //
 // If the n = len(p) bytes returned by ReadAt are at the end of the
 // input source, ReadAt may return either err == EOF or err == nil.
 //
 // If ReadAt is reading from an input source with a seek offset,
 // ReadAt should not affect nor be affected by the underlying
 // seek offset.
 //
 // Clients of ReadAt can execute parallel ReadAt calls on the
 // same input source.
+//
+// Implementations must not retain p.
 type ReaderAt interface {
         ReadAt(p []byte, off int64) (n int, err error)
 }
 
 // WriterAt is the interface that wraps the basic WriteAt method.
 //
 // WriteAt writes len(p) bytes from p to the underlying data stream
 // at offset off.  It returns the number of bytes written from p (0 <= n <= len(p))
 // and any error encountered that caused the write to stop early.
 // WriteAt must return a non-nil error if it returns n < len(p).
 //
 // If WriteAt is writing to a destination with a seek offset,
 // WriteAt should not affect nor be affected by the underlying
 // seek offset.
 //
 // Clients of WriteAt can execute parallel WriteAt calls on the same
 // destination if the ranges do not overlap.
+//
+// Implementations must not retain p.
 type WriterAt interface {
         WriteAt(p []byte, off int64) (n int, err error)
 }
 
 // ByteReader is the interface that wraps the ReadByte method.
 //
 // ReadByte reads and returns the next byte from the input.
 // If no byte is available, err will be set.
 type ByteReader interface {
         ReadByte() (c byte, err error)
@@ skipping 262 matching lines @@
 
 func (t *teeReader) Read(p []byte) (n int, err error) {
         n, err = t.r.Read(p)
         if n > 0 {
                 if n, err := t.w.Write(p[:n]); err != nil {
                         return n, err
                 }
         }
         return
 }