syntax: add ParseError.Incomplete

During read calls, it was already possible to check if more bytes were
required to finish parsing without errors, via the Parser.Incomplete
method.

However, once an error was returned, that information was not easily
available. Add a field to the error type, and add an IsIncomplete
function to quickly check errors for that property.

syntax/parser.go

@@ -314,6 +314,11 @@ type Parser struct {
 	litBs   []byte
 }
 
+// Incomplete reports whether the parser is waiting to read more bytes because
+// it needs to finish properly parsing a statement.
+//
+// It is only safe to call while the parser is blocked on a read. For an example
+// use case, see the documentation for Parser.Interactive.
 func (p *Parser) Incomplete() bool {
 	// If we're in a quote state other than noState, we're parsing a node
 	// such as a double-quoted string.
@@ -642,12 +647,22 @@ func (p *Parser) errPass(err error) {
 	}
 }
 
+// IsIncomplete reports whether a Parser error could have been avoided with
+// extra input bytes. For example, if an io.EOF was encountered while there was
+// an unclosed quote or parenthesis.
+func IsIncomplete(err error) bool {
+	perr, ok := err.(ParseError)
+	return ok && perr.Incomplete
+}
+
 // ParseError represents an error found when parsing a source file, from which
 // the parser cannot recover.
 type ParseError struct {
 	Filename string
 	Pos
 	Text string
+
+	Incomplete bool
 }
 
 func (e ParseError) Error() string {
@@ -691,9 +706,10 @@ func (e LangError) Error() string {
 
 func (p *Parser) posErr(pos Pos, format string, a ...interface{}) {
 	p.errPass(ParseError{
-		Filename: p.f.Name,
-		Pos:      pos,
-		Text:     fmt.Sprintf(format, a...),
+		Filename:   p.f.Name,
+		Pos:        pos,
+		Text:       fmt.Sprintf(format, a...),
+		Incomplete: p.tok == _EOF && p.Incomplete(),
 	})
 }
 
@@ -978,7 +994,8 @@ func (p *Parser) wordPart() WordPart {
 				p.next()
 				return sq
 			case utf8.RuneSelf:
-				p.posErr(sq.Pos(), "reached EOF without closing quote %s", sglQuote)
+				p.tok = _EOF
+				p.quoteErr(sq.Pos(), sglQuote)
 				return nil
 			}
 		}

syntax/parser_test.go

@@ -2143,3 +2143,39 @@ func TestValidName(t *testing.T) {
 		})
 	}
 }
+
+func TestIsIncomplete(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		in   string
+		want bool
+	}{
+		{"foo\n", false},
+		{"foo;", false},
+		{"\n", false},
+		{"'incomp", true},
+		{"foo; 'incomp", true},
+		{" (incomp", true},
+		{"badsyntax)", false},
+	}
+	p := NewParser()
+	for i, tc := range tests {
+		t.Run(fmt.Sprintf("Parse%02d", i), func(t *testing.T) {
+			r := strings.NewReader(tc.in)
+			_, err := p.Parse(r, "")
+			if got := IsIncomplete(err); got != tc.want {
+				t.Fatalf("%q got %t, wanted %t", tc.in, got, tc.want)
+			}
+		})
+		t.Run(fmt.Sprintf("Interactive%02d", i), func(t *testing.T) {
+			r := strings.NewReader(tc.in)
+			err := p.Interactive(r, func([]*Stmt) bool {
+				return false
+			})
+			if got := IsIncomplete(err); got != tc.want {
+				t.Fatalf("%q got %t, wanted %t", tc.in, got, tc.want)
+			}
+		})
+	}
+}