bufio: realign struct Reader

This reduce the Reader allocation size from 72 to 40 bytes and
Writer allocation size from 64 to 40 bytes.

1 files changed, 50 insertions, 47 deletions

diff --git a/src/bufio/bufio_test.go b/src/bufio/bufio_test.go
index a8c1e50397..a4841e8230 100644
--- a/src/bufio/bufio_test.go
+++ b/src/bufio/bufio_test.go
@@ -76,16 +76,16 @@ func TestReaderSimple(t *testing.T) {
 }
 
 type readMaker struct {
-	name string
 	fn   func(io.Reader) io.Reader
+	name string
 }
 
 var readMakers = []readMaker{
-	{"full", func(r io.Reader) io.Reader { return r }},
-	{"byte", iotest.OneByteReader},
-	{"half", iotest.HalfReader},
-	{"data+err", iotest.DataErrReader},
-	{"timeout", iotest.TimeoutReader},
+	{name: "full", fn: func(r io.Reader) io.Reader { return r }},
+	{name: "byte", fn: iotest.OneByteReader},
+	{name: "half", fn: iotest.HalfReader},
+	{name: "data+err", fn: iotest.DataErrReader},
+	{name: "timeout", fn: iotest.TimeoutReader},
 }
 
 // Call ReadString (which ends up calling everything else)
@@ -120,19 +120,19 @@ func reads(buf *Reader, m int) string {
 }
 
 type bufReader struct {
-	name string
 	fn   func(*Reader) string
+	name string
 }
 
 var bufreaders = []bufReader{
-	{"1", func(b *Reader) string { return reads(b, 1) }},
-	{"2", func(b *Reader) string { return reads(b, 2) }},
-	{"3", func(b *Reader) string { return reads(b, 3) }},
-	{"4", func(b *Reader) string { return reads(b, 4) }},
-	{"5", func(b *Reader) string { return reads(b, 5) }},
-	{"7", func(b *Reader) string { return reads(b, 7) }},
-	{"bytes", readBytes},
-	{"lines", readLines},
+	{name: "1", fn: func(b *Reader) string { return reads(b, 1) }},
+	{name: "2", fn: func(b *Reader) string { return reads(b, 2) }},
+	{name: "3", fn: func(b *Reader) string { return reads(b, 3) }},
+	{name: "4", fn: func(b *Reader) string { return reads(b, 4) }},
+	{name: "5", fn: func(b *Reader) string { return reads(b, 5) }},
+	{name: "7", fn: func(b *Reader) string { return reads(b, 7) }},
+	{name: "bytes", fn: readBytes},
+	{name: "lines", fn: readLines},
 }
 
 const minReadBufferSize = 16
@@ -678,9 +678,9 @@ func TestWriterAppend(t *testing.T) {
 // Check that write errors are returned properly.
 
 type errorWriterTest struct {
-	n, m   int
 	err    error
 	expect error
+	n, m   int
 }
 
 func (w errorWriterTest) Write(p []byte) (int, error) {
@@ -688,12 +688,12 @@ func (w errorWriterTest) Write(p []byte) (int, error) {
 }
 
 var errorWriterTests = []errorWriterTest{
-	{0, 1, nil, io.ErrShortWrite},
-	{1, 2, nil, io.ErrShortWrite},
-	{1, 1, nil, nil},
-	{0, 1, io.ErrClosedPipe, io.ErrClosedPipe},
-	{1, 2, io.ErrClosedPipe, io.ErrClosedPipe},
-	{1, 1, io.ErrClosedPipe, io.ErrClosedPipe},
+	{n: 0, m: 1, err: nil, expect: io.ErrShortWrite},
+	{n: 1, m: 2, err: nil, expect: io.ErrShortWrite},
+	{n: 1, m: 1, err: nil, expect: nil},
+	{n: 0, m: 1, err: io.ErrClosedPipe, expect: io.ErrClosedPipe},
+	{n: 1, m: 2, err: io.ErrClosedPipe, expect: io.ErrClosedPipe},
+	{n: 1, m: 1, err: io.ErrClosedPipe, expect: io.ErrClosedPipe},
 }
 
 func TestWriteErrors(t *testing.T) {
@@ -1051,9 +1051,9 @@ func TestReadLineNonNilLineOrError(t *testing.T) {
 }
 
 type readLineResult struct {
+	err      error
 	line     []byte
 	isPrefix bool
-	err      error
 }
 
 var readLineNewlinesTests = []struct {
@@ -1061,17 +1061,17 @@ var readLineNewlinesTests = []struct {
 	expect []readLineResult
 }{
 	{"012345678901234\r\n012345678901234\r\n", []readLineResult{
-		{[]byte("012345678901234"), true, nil},
-		{nil, false, nil},
-		{[]byte("012345678901234"), true, nil},
-		{nil, false, nil},
-		{nil, false, io.EOF},
+		{line: []byte("012345678901234"), isPrefix: true, err: nil},
+		{line: nil, isPrefix: false, err: nil},
+		{line: []byte("012345678901234"), isPrefix: true, err: nil},
+		{line: nil, isPrefix: false, err: nil},
+		{line: nil, isPrefix: false, err: io.EOF},
 	}},
 	{"0123456789012345\r012345678901234\r", []readLineResult{
-		{[]byte("0123456789012345"), true, nil},
-		{[]byte("\r012345678901234"), true, nil},
-		{[]byte("\r"), false, nil},
-		{nil, false, io.EOF},
+		{line: []byte("0123456789012345"), isPrefix: true, err: nil},
+		{line: []byte("\r012345678901234"), isPrefix: true, err: nil},
+		{line: []byte("\r"), isPrefix: false, err: nil},
+		{line: nil, isPrefix: false, err: io.EOF},
 	}},
 }
 
@@ -1130,9 +1130,9 @@ func TestReaderWriteTo(t *testing.T) {
 }
 
 type errorWriterToTest struct {
-	rn, wn     int
 	rerr, werr error
 	expected   error
+	rn, wn     int
 }
 
 func (r errorWriterToTest) Read(p []byte) (int, error) {
@@ -1144,10 +1144,10 @@ func (w errorWriterToTest) Write(p []byte) (int, error) {
 }
 
 var errorWriterToTests = []errorWriterToTest{
-	{1, 0, nil, io.ErrClosedPipe, io.ErrClosedPipe},
-	{0, 1, io.ErrClosedPipe, nil, io.ErrClosedPipe},
-	{0, 0, io.ErrUnexpectedEOF, io.ErrClosedPipe, io.ErrClosedPipe},
-	{0, 1, io.EOF, nil, nil},
+	{rn: 1, wn: 0, rerr: nil, werr: io.ErrClosedPipe, expected: io.ErrClosedPipe},
+	{rn: 0, wn: 1, rerr: io.ErrClosedPipe, werr: nil, expected: io.ErrClosedPipe},
+	{rn: 0, wn: 0, rerr: io.ErrUnexpectedEOF, werr: io.ErrClosedPipe, expected: io.ErrClosedPipe},
+	{rn: 0, wn: 1, rerr: io.EOF, werr: nil, expected: nil},
 }
 
 func TestReaderWriteToErrors(t *testing.T) {
@@ -1192,9 +1192,9 @@ func TestWriterReadFrom(t *testing.T) {
 }
 
 type errorReaderFromTest struct {
-	rn, wn     int
 	rerr, werr error
 	expected   error
+	rn, wn     int
 }
 
 func (r errorReaderFromTest) Read(p []byte) (int, error) {
@@ -1206,11 +1206,11 @@ func (w errorReaderFromTest) Write(p []byte) (int, error) {
 }
 
 var errorReaderFromTests = []errorReaderFromTest{
-	{0, 1, io.EOF, nil, nil},
-	{1, 1, io.EOF, nil, nil},
-	{0, 1, io.ErrClosedPipe, nil, io.ErrClosedPipe},
-	{0, 0, io.ErrClosedPipe, io.ErrShortWrite, io.ErrClosedPipe},
-	{1, 0, nil, io.ErrShortWrite, io.ErrShortWrite},
+	{rn: 0, wn: 1, rerr: io.EOF, werr: nil, expected: nil},
+	{rn: 1, wn: 1, rerr: io.EOF, werr: nil, expected: nil},
+	{rn: 0, wn: 1, rerr: io.ErrClosedPipe, werr: nil, expected: io.ErrClosedPipe},
+	{rn: 0, wn: 0, rerr: io.ErrClosedPipe, werr: io.ErrShortWrite, expected: io.ErrClosedPipe},
+	{rn: 1, wn: 0, rerr: nil, werr: io.ErrShortWrite, expected: io.ErrShortWrite},
 }
 
 func TestWriterReadFromErrors(t *testing.T) {
@@ -1561,15 +1561,18 @@ func TestWriterReset(t *testing.T) {
 
 func TestReaderDiscard(t *testing.T) {
 	tests := []struct {
-		name     string
-		r        io.Reader
+		r io.Reader
+
+		wantErr error // from Discard
+
+		name string
+
 		bufSize  int // 0 means 16
 		peekSize int
 
 		n int // input to Discard
 
-		want    int   // from Discard
-		wantErr error // from Discard
+		want int // from Discard
 
 		wantBuffered int
 	}{