reencode: Wrapping the handleRune state is no longer necessary

1 files changed, 49 insertions, 52 deletions

diff --git a/reencode.go b/reencode.go
index b3f4d20..d588b1b 100644
--- a/reencode.go
+++ b/reencode.go
@@ -98,16 +98,13 @@ type ReEncoder struct {
 	inputPos int64
 
 	// state: .handleRune
-	handleRuneState struct {
-		lastNonSpace internal.RuneType
-		wasNumber    bool
-		curIndent    int
-		uhex         [4]byte // "\uABCD"-encoded characters in strings
-		fracZeros    int64
-		expZero      bool
-
-		specu *speculation
-	}
+	lastNonSpace internal.RuneType
+	wasNumber    bool
+	curIndent    int
+	uhex         [4]byte // "\uABCD"-encoded characters in strings
+	fracZeros    int64
+	expZero      bool
+	specu        *speculation
 }
 
 type speculation struct {
@@ -281,7 +278,7 @@ func (enc *ReEncoder) handleRune(c rune, t internal.RuneType, stackSize int) err
 	}
 
 	// main
-	if enc.handleRuneState.specu == nil { // not speculating
+	if enc.specu == nil { // not speculating
 		switch t {
 		case internal.RuneTypeObjectBeg, internal.RuneTypeArrayBeg: // start speculating
 			if err, _ := enc.handleRunePre(c, t); err != nil {
@@ -295,8 +292,8 @@ func (enc *ReEncoder) handleRune(c rune, t internal.RuneType, stackSize int) err
 			}
 			specu.fmt.Compact = true
 			specu.fmt.out = &specu.compact
-			enc.handleRuneState.specu = specu
-			enc.handleRuneState.specu.buf = append(enc.handleRuneState.specu.buf, inputTuple{
+			enc.specu = specu
+			enc.specu.buf = append(enc.specu.buf, inputTuple{
 				c:         c,
 				t:         t,
 				stackSize: stackSize,
@@ -310,18 +307,18 @@ func (enc *ReEncoder) handleRune(c rune, t internal.RuneType, stackSize int) err
 			}
 		}
 	} else { // speculating
-		enc.handleRuneState.specu.buf = append(enc.handleRuneState.specu.buf, inputTuple{
+		enc.specu.buf = append(enc.specu.buf, inputTuple{
 			c:         c,
 			t:         t,
 			stackSize: stackSize,
 		})
-		if err := enc.handleRuneState.specu.fmt.handleRune(c, t, stackSize); err != nil {
+		if err := enc.specu.fmt.handleRune(c, t, stackSize); err != nil {
 			return err
 		}
 		switch {
-		case enc.handleRuneState.specu.compact.Len() >= enc.CompactIfUnder: // stop speculating; use indent
-			buf := enc.handleRuneState.specu.buf
-			enc.handleRuneState.specu = nil
+		case enc.specu.compact.Len() >= enc.CompactIfUnder: // stop speculating; use indent
+			buf := enc.specu.buf
+			enc.specu = nil
 			if err := enc.handleRuneMain(buf[0].c, buf[0].t); err != nil {
 				return err
 			}
@@ -330,13 +327,13 @@ func (enc *ReEncoder) handleRune(c rune, t internal.RuneType, stackSize int) err
 					return err
 				}
 			}
-		case stackSize == enc.handleRuneState.specu.endWhenStackSize: // stop speculating; use compact
-			if _, err := enc.handleRuneState.specu.compact.WriteTo(enc.out); err != nil {
+		case stackSize == enc.specu.endWhenStackSize: // stop speculating; use compact
+			if _, err := enc.specu.compact.WriteTo(enc.out); err != nil {
 				return err
 			}
-			enc.handleRuneState.lastNonSpace = t
-			enc.handleRuneState.curIndent--
-			enc.handleRuneState.specu = nil
+			enc.lastNonSpace = t
+			enc.curIndent--
+			enc.specu = nil
 		}
 	}
 
@@ -358,9 +355,9 @@ func (enc *ReEncoder) handleRuneNoSpeculation(c rune, t internal.RuneType) error
 // the new rune itself is handled.
 func (enc *ReEncoder) handleRunePre(c rune, t internal.RuneType) (error, bool) {
 	// emit newlines between top-level values
-	if enc.handleRuneState.lastNonSpace == internal.RuneTypeEOF {
+	if enc.lastNonSpace == internal.RuneTypeEOF {
 		switch {
-		case enc.handleRuneState.wasNumber && t.IsNumber():
+		case enc.wasNumber && t.IsNumber():
 			if err := enc.emitByte('\n'); err != nil {
 				return err, false
 			}
@@ -374,35 +371,35 @@ func (enc *ReEncoder) handleRunePre(c rune, t internal.RuneType) (error, bool) {
 	// shorten numbers
 	switch t { // trim trailing '0's from the fraction-part, but don't remove all digits
 	case internal.RuneTypeNumberFracDot:
-		enc.handleRuneState.fracZeros = 0
+		enc.fracZeros = 0
 	case internal.RuneTypeNumberFracDig:
-		if c == '0' && enc.handleRuneState.lastNonSpace == internal.RuneTypeNumberFracDig {
-			enc.handleRuneState.fracZeros++
+		if c == '0' && enc.lastNonSpace == internal.RuneTypeNumberFracDig {
+			enc.fracZeros++
 			return nil, false
 		}
 		fallthrough
 	default:
-		for enc.handleRuneState.fracZeros > 0 {
+		for enc.fracZeros > 0 {
 			if err := enc.emitByte('0'); err != nil {
 				return err, false
 			}
-			enc.handleRuneState.fracZeros--
+			enc.fracZeros--
 		}
 	}
 	switch t { // trim leading '0's from the exponent-part, but don't remove all digits
 	case internal.RuneTypeNumberExpE, internal.RuneTypeNumberExpSign:
-		enc.handleRuneState.expZero = true
+		enc.expZero = true
 	case internal.RuneTypeNumberExpDig:
-		if c == '0' && enc.handleRuneState.expZero {
+		if c == '0' && enc.expZero {
 			return nil, false
 		}
-		enc.handleRuneState.expZero = false
+		enc.expZero = false
 	default:
-		if enc.handleRuneState.expZero {
+		if enc.expZero {
 			if err := enc.emitByte('0'); err != nil {
 				return err, false
 			}
-			enc.handleRuneState.expZero = false
+			enc.expZero = false
 		}
 	}
 
@@ -418,8 +415,8 @@ func (enc *ReEncoder) handleRunePre(c rune, t internal.RuneType) (error, bool) {
 			// let us manage whitespace, don't pass it through
 			return nil, false
 		case internal.RuneTypeObjectEnd, internal.RuneTypeArrayEnd:
-			enc.handleRuneState.curIndent--
-			switch enc.handleRuneState.lastNonSpace {
+			enc.curIndent--
+			switch enc.lastNonSpace {
 			case internal.RuneTypeObjectBeg, internal.RuneTypeArrayBeg:
 				// collapse
 			default:
@@ -428,7 +425,7 @@ func (enc *ReEncoder) handleRunePre(c rune, t internal.RuneType) (error, bool) {
 				}
 			}
 		default:
-			switch enc.handleRuneState.lastNonSpace {
+			switch enc.lastNonSpace {
 			case internal.RuneTypeObjectBeg, internal.RuneTypeObjectComma, internal.RuneTypeArrayBeg, internal.RuneTypeArrayComma:
 				if err := enc.emitNlIndent(); err != nil {
 					return err, false
@@ -440,7 +437,7 @@ func (enc *ReEncoder) handleRunePre(c rune, t internal.RuneType) (error, bool) {
 			}
 			switch t {
 			case internal.RuneTypeObjectBeg, internal.RuneTypeArrayBeg:
-				enc.handleRuneState.curIndent++
+				enc.curIndent++
 			}
 		}
 	}
@@ -452,7 +449,7 @@ func (enc *ReEncoder) handleRunePre(c rune, t internal.RuneType) (error, bool) {
 func (enc *ReEncoder) handleRuneMain(c rune, t internal.RuneType) error {
 	defer func() {
 		if t != internal.RuneTypeSpace {
-			enc.handleRuneState.lastNonSpace = t
+			enc.lastNonSpace = t
 		}
 	}()
 
@@ -484,33 +481,33 @@ func (enc *ReEncoder) handleRuneMain(c rune, t internal.RuneType) error {
 			panic("should not happen")
 		}
 	case internal.RuneTypeStringEscUA:
-		enc.handleRuneState.uhex[0], _ = internal.HexToInt(c)
+		enc.uhex[0], _ = internal.HexToInt(c)
 		return nil
 	case internal.RuneTypeStringEscUB:
-		enc.handleRuneState.uhex[1], _ = internal.HexToInt(c)
+		enc.uhex[1], _ = internal.HexToInt(c)
 		return nil
 	case internal.RuneTypeStringEscUC:
-		enc.handleRuneState.uhex[2], _ = internal.HexToInt(c)
+		enc.uhex[2], _ = internal.HexToInt(c)
 		return nil
 	case internal.RuneTypeStringEscUD:
-		enc.handleRuneState.uhex[3], _ = internal.HexToInt(c)
+		enc.uhex[3], _ = internal.HexToInt(c)
 		c := 0 |
-			rune(enc.handleRuneState.uhex[0])<<12 |
-			rune(enc.handleRuneState.uhex[1])<<8 |
-			rune(enc.handleRuneState.uhex[2])<<4 |
-			rune(enc.handleRuneState.uhex[3])<<0
+			rune(enc.uhex[0])<<12 |
+			rune(enc.uhex[1])<<8 |
+			rune(enc.uhex[2])<<4 |
+			rune(enc.uhex[3])<<0
 		return enc.emit(writeStringChar(enc.out, c, BackslashEscapeUnicode, enc.BackslashEscape))
 
 	case internal.RuneTypeError: // EOF explicitly stated by .Close()
 		fallthrough
 	case internal.RuneTypeEOF: // EOF implied by the start of the next top-level value
-		enc.handleRuneState.wasNumber = enc.handleRuneState.lastNonSpace.IsNumber()
+		enc.wasNumber = enc.lastNonSpace.IsNumber()
 		switch {
 		case enc.ForceTrailingNewlines:
-			t = internal.RuneTypeError // enc.handleRuneState.lastNonSpace : an NL isn't needed (we already printed one)
+			t = internal.RuneTypeError // enc.lastNonSpace : an NL isn't needed (we already printed one)
 			return enc.emitByte('\n')
 		default:
-			t = internal.RuneTypeEOF // enc.handleRuneState.lastNonSpace : an NL *might* be needed
+			t = internal.RuneTypeEOF // enc.lastNonSpace : an NL *might* be needed
 			return nil
 		}
 	default:
@@ -540,7 +537,7 @@ func (enc *ReEncoder) emitNlIndent() error {
 			return err
 		}
 	}
-	for i := 0; i < enc.handleRuneState.curIndent; i++ {
+	for i := 0; i < enc.curIndent; i++ {
 		if err := enc.emit(enc.out.WriteString(enc.Indent)); err != nil {
 			return err
 		}