syntax: avoid a slice bounds check on every input byte

When our lexer peeks one byte or consumes one rune,
we do a check like `p.bsp < len(p.bs)` followed by `p.bs[p.bsp]`.
In practice this made a bounds check unnecessary, as we knew we had
enough input bytes in p.bs to grab the byte at p.bsp,
but since p.bsp was a signed integer, the compiler knew that in theory
p.bsp could have overflowed to a negative value and caused a panic.

In the past I tried swapping p.bsp from an int to an uint to solve
this issue, but the compiler wasn't yet clever enough to take note.
It seems like it now is:

            │     old     │                new                 │
            │   sec/op    │   sec/op     vs base               │
    Parse-8   14.86µ ± 1%   14.46µ ± 1%  -2.74% (p=0.000 n=10)

syntax/lexer.go

@@ -67,7 +67,7 @@ func (p *Parser) rune() rune {
  p.col += int64(p.w)
  bquotes := 0
 retry:
- if p.bsp < len(p.bs) {
+ if p.bsp < uint(len(p.bs)) {
  if b := p.bs[p.bsp]; b < utf8.RuneSelf {
  p.bsp++
  if b == '\x00' {
@@ -86,7 +86,7 @@ retry:
  return escNewl
  }
  if p.openBquotes > 0 && bquotes < p.openBquotes &&
- p.bsp < len(p.bs) && bquoteEscaped(p.bs[p.bsp]) {
+ p.bsp < uint(len(p.bs)) && bquoteEscaped(p.bs[p.bsp]) {
  // We turn backquote command substitutions into $(),
  // so we remove the extra backslashes needed by the backquotes.
  // For good position information, we still include them in p.w.
@@ -110,9 +110,9 @@ retry:
  var w int
  p.r, w = utf8.DecodeRune(p.bs[p.bsp:])
  if p.litBs != nil {
- p.litBs = append(p.litBs, p.bs[p.bsp:p.bsp+w]...)
+ p.litBs = append(p.litBs, p.bs[p.bsp:p.bsp+uint(w)]...)
  }
- p.bsp += w
+ p.bsp += uint(w)
  if p.r == utf8.RuneError && w == 1 {
  p.posErr(p.nextPos(), "invalid UTF-8 encoding")
  }
@@ -135,7 +135,7 @@ retry:
 // beginning of the buffer.
 func (p *Parser) fill() {
  p.offs += int64(p.bsp)
- left := len(p.bs) - p.bsp
+ left := len(p.bs) - int(p.bsp)
  copy(p.readBuf[:left], p.readBuf[p.bsp:])
 readAgain:
  n, err := 0, p.readErr
@@ -254,7 +254,7 @@ skipSpace:
  }
  if p.stopAt != nil && (p.spaced || p.tok == illegalTok || p.stopToken()) {
  w := utf8.RuneLen(r)
- if bytes.HasPrefix(p.bs[p.bsp-w:], p.stopAt) {
+ if bytes.HasPrefix(p.bs[p.bsp-uint(w):], p.stopAt) {
  p.r = utf8.RuneSelf
  p.w = 1
  p.tok = _EOF
@@ -388,7 +388,7 @@ func (p *Parser) extendedGlob() bool {
 }
 
 func (p *Parser) peekBytes(s string) bool {
- peekEnd := p.bsp + len(s)
+ peekEnd := int(p.bsp) + len(s)
  // TODO: This should loop for slow readers, e.g. those providing one byte at
  // a time. Use a loop and test it with testing/iotest.OneByteReader.
  if peekEnd > len(p.bs) {
@@ -398,10 +398,10 @@ func (p *Parser) peekBytes(s string) bool {
 }
 
 func (p *Parser) peekByte(b byte) bool {
- if p.bsp == len(p.bs) {
+ if p.bsp == uint(len(p.bs)) {
  p.fill()
  }
- return p.bsp < len(p.bs) && p.bs[p.bsp] == b
+ return p.bsp < uint(len(p.bs)) && p.bs[p.bsp] == b
 }
 
 func (p *Parser) regToken(r rune) token {
@@ -809,7 +809,7 @@ func (p *Parser) newLit(r rune) {
  p.litBs[0] = byte(r)
  case r > escNewl:
  w := utf8.RuneLen(r)
- p.litBs = append(p.litBuf[:0], p.bs[p.bsp-w:p.bsp]...)
+ p.litBs = append(p.litBuf[:0], p.bs[p.bsp-uint(w):p.bsp]...)
  default:
  // don't let r == utf8.RuneSelf go to the second case as RuneLen
  // would return -1

syntax/parser.go

@@ -338,7 +338,7 @@ func (p *Parser) Arithmetic(r io.Reader) (ArithmExpr, error) {
 type Parser struct {
  src io.Reader
  bs []byte // current chunk of read bytes
- bsp int  // pos within chunk for the rune after r
+ bsp uint // pos within chunk for the rune after r; uint helps eliminate bounds checks
  r rune // next rune
  w int // width of r
 
@@ -733,7 +733,7 @@ func (p *Parser) matched(lpos Pos, left, right token) Pos {
 func (p *Parser) errPass(err error) {
  if p.err == nil {
  p.err = err
- p.bsp = len(p.bs) + 1
+ p.bsp = uint(len(p.bs)) + 1
  p.r = utf8.RuneSelf
  p.w = 1
  p.tok = _EOF