io: revert: add an Err field to LimitedReader

We are having a hard time deciding the exact semantics
of the Err field, and we need to ship the beta.
So revert the Err field change; it can wait for Go 1.20.

For #51115.

This reverts CL 396215.

Change-Id: I7719386567d3da10a614058a11f19dbccf304b4d
Reviewed-on: https://go-review.googlesource.com/c/go/+/410133
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Bryan Mills <bcmills@google.com>
Auto-Submit: Russ Cox <rsc@golang.org>

diff --git a/api/next/51115.txt b/api/next/51115.txt
deleted file mode 100644 (file)
index 0ce24b4..0000000
--- a/api/next/51115.txt
+++ /dev/null
@@ -1 +0,0 @@
-pkg io, type LimitedReader struct, Err error #51115

diff --git a/src/io/example_test.go b/src/io/example_test.go
index e4b20bd9819219d0268c55ec337f15bd94e9361c..419e449982ad5cabc16b92aa628b22897b9f5848 100644 (file)
--- a/src/io/example_test.go
+++ b/src/io/example_test.go
@@ -6,7 +6,6 @@ package io_test
 
 import (
        "bytes"
-       "errors"
        "fmt"
        "io"
        "log"
@@ -284,16 +283,3 @@ func ExampleReadAll() {
        // Output:
        // Go is a general-purpose language designed with systems programming in mind.
 }
-
-func ExampleLimitedReader() {
-       r := strings.NewReader("some io.Reader stream to be read\n")
-       sentinel := errors.New("reached read limit")
-       lr := &io.LimitedReader{R: r, N: 4, Err: sentinel}
-
-       if _, err := io.Copy(os.Stdout, lr); err != sentinel {
-               log.Fatal(err)
-       }
-
-       // Output:
-       // some
-}

diff --git a/src/io/io.go b/src/io/io.go
index 830779e79d198423d4be604ee31cbad10eb81132..db88125f507799dafbb619e638ec846480784bf4 100644 (file)
--- a/src/io/io.go
+++ b/src/io/io.go
@@ -455,26 +455,20 @@ func copyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error) {
 // LimitReader returns a Reader that reads from r
 // but stops with EOF after n bytes.
 // The underlying implementation is a *LimitedReader.
-func LimitReader(r Reader, n int64) Reader { return &LimitedReader{r, n, nil} }
+func LimitReader(r Reader, n int64) Reader { return &LimitedReader{r, n} }
 
 // A LimitedReader reads from R but limits the amount of
 // data returned to just N bytes. Each call to Read
 // updates N to reflect the new amount remaining.
-// Read returns Err when N <= 0.
-// If Err is nil, it returns EOF instead.
+// Read returns EOF when N <= 0 or when the underlying R returns EOF.
 type LimitedReader struct {
-       R   Reader // underlying reader
-       N   int64  // max bytes remaining
-       Err error  // error to return on reaching the limit
+       R Reader // underlying reader
+       N int64  // max bytes remaining
 }
 
 func (l *LimitedReader) Read(p []byte) (n int, err error) {
        if l.N <= 0 {
-               err := l.Err
-               if err == nil {
-                       err = EOF
-               }
-               return 0, err
+               return 0, EOF
        }
        if int64(len(p)) > l.N {
                p = p[0:l.N]