syntax: pipes are left-associative too

That is, the program:

	foo | bar | baz

Should parse with recursive pipes at the left, like:

	       |
	    |     baz
	foo   bar

We already did this for && and ||, but not pipes. This makes the syntax
parser more consistent and correct.

We noticed now because we added an optimization where a shell's pipe
would reuse copy buffers. With right associativity, the original shell
performs all pipes, so the same buffer was used by multiple copies at
the same time, resulting in bugs.

In other words, a shell pipe forks the left side into a subshell, so
nested pipes should go to the subshell.

syntax/filetests_test.go

@@ -637,12 +637,12 @@ var fileTests = []testCase{
 		Strs: []string{"foo | bar | extra"},
 		common: &BinaryCmd{
 			Op: Pipe,
-			X:  litStmt("foo"),
-			Y: stmt(&BinaryCmd{
+			X: stmt(&BinaryCmd{
 				Op: Pipe,
-				X:  litStmt("bar"),
-				Y:  litStmt("extra"),
+				X:  litStmt("foo"),
+				Y:  litStmt("bar"),
 			}),
+			Y: litStmt("extra"),
 		},
 	},
 	{

syntax/parser.go

@@ -1679,14 +1679,14 @@ func (p *Parser) getStmt(readEnd, binCmd, fnBody bool) *Stmt {
 			p.posErr(s.Pos(), `cannot negate a command multiple times`)
 		}
 	}
-	if s = p.gotStmtPipe(s); s == nil || p.err != nil {
+	if s = p.gotStmtPipe(s, false); s == nil || p.err != nil {
 		return nil
 	}
 	// instead of using recursion, iterate manually
 	for p.tok == andAnd || p.tok == orOr {
-		// left associativity: in a list of BinaryCmds, the
-		// right recursion should only read a single element
 		if binCmd {
+			// left associativity: in a list of BinaryCmds, the
+			// right recursion should only read a single element
 			return s
 		}
 		b := &BinaryCmd{
@@ -1730,7 +1730,7 @@ func (p *Parser) getStmt(readEnd, binCmd, fnBody bool) *Stmt {
 	return s
 }
 
-func (p *Parser) gotStmtPipe(s *Stmt) *Stmt {
+func (p *Parser) gotStmtPipe(s *Stmt, binCmd bool) *Stmt {
 	s.Comments, p.accComs = p.accComs, nil
 	switch p.tok {
 	case _LitWord:
@@ -1852,19 +1852,22 @@ func (p *Parser) gotStmtPipe(s *Stmt) *Stmt {
 	for p.peekRedir() {
 		p.doRedirect(s)
 	}
-	switch p.tok {
-	case orAnd:
-		if p.lang == LangMirBSDKorn {
+	// instead of using recursion, iterate manually
+	for p.tok == or || p.tok == orAnd {
+		if binCmd {
+			// left associativity: in a list of BinaryCmds, the
+			// right recursion should only read a single element
+			return s
+		}
+		if p.tok == orAnd && p.lang == LangMirBSDKorn {
 			// No need to check for LangPOSIX, as on that language
 			// we parse |& as two tokens.
 			break
 		}
-		fallthrough
-	case or:
 		b := &BinaryCmd{OpPos: p.pos, Op: BinCmdOperator(p.tok), X: s}
 		p.next()
 		p.got(_Newl)
-		if b.Y = p.gotStmtPipe(p.stmt(p.pos)); b.Y == nil || p.err != nil {
+		if b.Y = p.gotStmtPipe(p.stmt(p.pos), true); b.Y == nil || p.err != nil {
 			p.followErr(b.OpPos, b.Op.String(), "a statement")
 			break
 		}
@@ -2291,20 +2294,20 @@ func (p *Parser) timeClause(s *Stmt) {
 	if _, ok := p.gotRsrv("-p"); ok {
 		tc.PosixFormat = true
 	}
-	tc.Stmt = p.gotStmtPipe(p.stmt(p.pos))
+	tc.Stmt = p.gotStmtPipe(p.stmt(p.pos), false)
 	s.Cmd = tc
 }
 
 func (p *Parser) coprocClause(s *Stmt) {
 	cc := &CoprocClause{Coproc: p.pos}
 	if p.next(); isBashCompoundCommand(p.tok, p.val) {
 		// has no name
-		cc.Stmt = p.gotStmtPipe(p.stmt(p.pos))
+		cc.Stmt = p.gotStmtPipe(p.stmt(p.pos), false)
 		s.Cmd = cc
 		return
 	}
 	cc.Name = p.getLit()
-	cc.Stmt = p.gotStmtPipe(p.stmt(p.pos))
+	cc.Stmt = p.gotStmtPipe(p.stmt(p.pos), false)
 	if cc.Stmt == nil {
 		if cc.Name == nil {
 			p.posErr(cc.Coproc, "coproc clause requires a command")