Tolerate missing semicolons in the service body

ast/file.go

@@ -181,10 +181,12 @@ func NewSyntaxNode(keyword *KeywordNode, equals *RuneNode, syntax StringValueNod
 	if syntax == nil {
 		panic("syntax is nil")
 	}
+	var children []Node
 	if semicolon == nil {
-		panic("semicolon is nil")
+		children = []Node{keyword, equals, syntax}
+	} else {
+		children = []Node{keyword, equals, syntax, semicolon}
 	}
-	children := []Node{keyword, equals, syntax, semicolon}
 	return &SyntaxNode{
 		compositeNode: compositeNode{
 			children: children,

ast/options.go

@@ -71,10 +71,13 @@ func NewOptionNode(keyword *KeywordNode, name *OptionNameNode, equals *RuneNode,
 	if val == nil {
 		panic("val is nil")
 	}
+	var children []Node
 	if semicolon == nil {
-		panic("semicolon is nil")
+		children = []Node{keyword, name, equals, val}
+	} else {
+		children = []Node{keyword, name, equals, val, semicolon}
 	}
-	children := []Node{keyword, name, equals, val, semicolon}
+
 	return &OptionNode{
 		compositeNode: compositeNode{
 			children: children,

ast/service.go

@@ -141,10 +141,12 @@ func NewRPCNode(keyword *KeywordNode, name *IdentNode, input *RPCTypeNode, retur
 	if output == nil {
 		panic("output is nil")
 	}
+	var children []Node
 	if semicolon == nil {
-		panic("semicolon is nil")
+		children = []Node{keyword, name, input, returns, output}
+	} else {
+		children = []Node{keyword, name, input, returns, output, semicolon}
 	}
-	children := []Node{keyword, name, input, returns, output, semicolon}
 	return &RPCNode{
 		compositeNode: compositeNode{
 			children: children,

parser/ast.go

@@ -90,3 +90,40 @@ func (list *messageFieldList) toNodes() ([]*ast.MessageFieldNode, []*ast.RuneNod
 	}
 	return fields, delimiters
 }
+
+func newEmptyDeclNodes(semicolons []*ast.RuneNode) []*ast.EmptyDeclNode {
+	emptyDecls := make([]*ast.EmptyDeclNode, len(semicolons))
+	for i, semicolon := range semicolons {
+		emptyDecls[i] = ast.NewEmptyDeclNode(semicolon)
+	}
+	return emptyDecls
+}
+
+func newEmptyServiceElements(semicolons []*ast.RuneNode) []ast.ServiceElement {
+	emptyDecls := make([]ast.ServiceElement, len(semicolons))
+	for i, semicolon := range semicolons {
+		emptyDecls[i] = ast.NewEmptyDeclNode(semicolon)
+	}
+	return emptyDecls
+}
+
+type nodeWithEmptyDecls[T ast.Node] struct {
+	Node       T
+	EmptyDecls []*ast.EmptyDeclNode
+}
+
+func newNodeWithEmptyDecls[T ast.Node](node T, extraSemicolons []*ast.RuneNode) nodeWithEmptyDecls[T] {
+	return nodeWithEmptyDecls[T]{
+		Node:       node,
+		EmptyDecls: newEmptyDeclNodes(extraSemicolons),
+	}
+}
+
+func toServiceElements[T ast.ServiceElement](nodes nodeWithEmptyDecls[T]) []ast.ServiceElement {
+	serviceElements := make([]ast.ServiceElement, 1+len(nodes.EmptyDecls))
+	serviceElements[0] = nodes.Node
+	for i, emptyDecl := range nodes.EmptyDecls {
+		serviceElements[i+1] = emptyDecl
+	}
+	return serviceElements
+}

parser/lexer.go

@@ -761,3 +761,11 @@ func (l *protoLex) errWithCurrentPos(err error, offset int) reporter.ErrorWithPo
 	pos := l.info.SourcePos(l.input.offset() + offset)
 	return reporter.Error(ast.NewSourceSpan(pos, pos), err)
 }
+
+func (l *protoLex) requireSemicolon(semicolons []*ast.RuneNode) (*ast.RuneNode, []*ast.RuneNode) {
+	if len(semicolons) == 0 {
+		l.Error("expected ';'")
+		return nil, nil
+	}
+	return semicolons[0], semicolons[1:]
+}

parser/parser_test.go

@@ -82,6 +82,51 @@ func TestJunkParse(t *testing.T) {
 	}
 }
 
+func TestLenientParse_SemicolonLess(t *testing.T) {
+	t.Parallel()
+	inputs := map[string]struct {
+		Error   string
+		NoError string
+	}{
+		"method": {
+			Error: `syntax = "proto3";
+							service Foo {
+								;
+								rpc Bar (Baz) returns (Qux)
+								rpc Qux (Baz) returns (Qux);;
+							}`,
+			NoError: `syntax = "proto3";
+									service Foo {
+										;
+										rpc Bar (Baz) returns (Qux);
+										rpc Qux (Baz) returns (Qux);;
+									}`,
+		},
+		"service-options": {
+			Error: `syntax = "proto3";
+							service Foo {
+								option (foo) = { bar: 1 }
+							}`,
+			NoError: `syntax = "proto3";
+								service Foo {
+								  option (foo) = { bar: 1 };
+								}`,
+		},
+	}
+	for name, input := range inputs {
+		name, input := name, input
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+			errHandler := reporter.NewHandler(nil)
+			protoName := fmt.Sprintf("%s.proto", name)
+			_, err := Parse(protoName, strings.NewReader(input.NoError), errHandler)
+			require.NoError(t, err)
+			_, err = Parse(protoName, strings.NewReader(input.Error), errHandler)
+			require.ErrorContains(t, err, "expected ';'")
+		})
+	}
+}
+
 func TestSimpleParse(t *testing.T) {
 	t.Parallel()
 	protos := map[string]Result{}

parser/proto.y

@@ -43,11 +43,12 @@ import (
 	svc          *ast.ServiceNode
 	svcElement   ast.ServiceElement
 	svcElements  []ast.ServiceElement
-	mtd          *ast.RPCNode
+	mtd          nodeWithEmptyDecls[*ast.RPCNode]
 	mtdMsgType   *ast.RPCTypeNode
 	mtdElement   ast.RPCElement
 	mtdElements  []ast.RPCElement
 	opt          *ast.OptionNode
+	optN         nodeWithEmptyDecls[*ast.OptionNode]
 	opts         *compactOptionSlices
 	ref          *ast.FieldReferenceNode
 	optNms       *fieldRefSlices
@@ -68,6 +69,7 @@ import (
 	f            *ast.FloatLiteralNode
 	id           *ast.IdentNode
 	b            *ast.RuneNode
+	bs           []*ast.RuneNode
 	err          error
 }
 
@@ -81,6 +83,7 @@ import (
 %type <imprt>        importDecl
 %type <pkg>          packageDecl
 %type <opt>          optionDecl compactOption
+%type <optN>         optionDeclNew
 %type <opts>         compactOptionDecls
 %type <ref>          extensionName messageLiteralFieldName
 %type <optNms>       optionName
@@ -117,12 +120,12 @@ import (
 %type <extElements>  extensionElements extensionBody
 %type <str>          stringLit
 %type <svc>          serviceDecl
-%type <svcElement>   serviceElement
-%type <svcElements>  serviceElements serviceBody
+%type <svcElements>  serviceElement serviceElements serviceBody
 %type <mtd>          methodDecl
 %type <mtdElement>   methodElement
 %type <mtdElements>  methodElements methodBody
 %type <mtdMsgType>   methodMessageType
+%type <bs>           semicolon semicolons
 
 // same for terminals
 %token <s>   _STRING_LIT
@@ -214,6 +217,20 @@ fileElement : importDecl {
 		$$ = nil
 	}
 
+semicolons : ';' {
+		$$ = []*ast.RuneNode{$1}
+	}
+	| semicolons ';' {
+		$$ = append($1, $2)
+	}
+
+semicolon : semicolons {
+		$$ = $1
+	}
+	| {
+		$$ = nil
+	}
+
 syntaxDecl : _SYNTAX '=' stringLit ';' {
 		$$ = ast.NewSyntaxNode($1.ToKeyword(), $2, toStringValueNode($3), $4)
 	}
@@ -299,6 +316,12 @@ optionDecl : _OPTION optionName '=' optionValue ';' {
 		$$ = ast.NewOptionNode($1.ToKeyword(), optName, $3, $4, $5)
 	}
 
+optionDeclNew : _OPTION optionName '=' optionValue semicolon {
+		optName := ast.NewOptionNameNode($2.refs, $2.dots)
+		semi, extra := protolex.(*protoLex).requireSemicolon($5)
+		$$ = newNodeWithEmptyDecls(ast.NewOptionNode($1.ToKeyword(), optName, $3, $4, semi), extra)
+	}
+
 optionName : identifier {
 		fieldReferenceNode := ast.NewFieldReferenceNode($1)
 		$$ = &fieldRefSlices{refs: []*ast.FieldReferenceNode{fieldReferenceNode}}
@@ -937,47 +960,45 @@ serviceDecl : _SERVICE identifier '{' serviceBody '}' {
 		$$ = ast.NewServiceNode($1.ToKeyword(), $2, $3, $4, $5)
 	}
 
-serviceBody : {
-		$$ = nil
+serviceBody : semicolon {
+	  $$ = newEmptyServiceElements($1)
+	}
+	| semicolon serviceElements {
+	  $$ = make([]ast.ServiceElement, len($1) + len($2))
+		for i, s := range $1 {
+			$$[i] = ast.NewEmptyDeclNode(s)
+		}
+		for i, s := range $2 {
+			$$[i + len($1)] = s
+		}
 	}
-	| serviceElements
 
 serviceElements : serviceElements serviceElement {
-		if $2 != nil {
-			$$ = append($1, $2)
-		} else {
-			$$ = $1
-		}
+		$$ = append($1, $2...)
 	}
 	| serviceElement {
-		if $1 != nil {
-			$$ = []ast.ServiceElement{$1}
-		} else {
-			$$ = nil
-		}
+		$$ = $1
 	}
 
 // NB: doc suggests support for "stream" declaration, separate from "rpc", but
 // it does not appear to be supported in protoc (doc is likely from grammar for
 // Google-internal version of protoc, with support for streaming stubby)
-serviceElement : optionDecl {
-		$$ = $1
+serviceElement : optionDeclNew {
+		$$ = toServiceElements($1)
 	}
 	| methodDecl {
-		$$ = $1
-	}
-	| ';' {
-		$$ = ast.NewEmptyDeclNode($1)
+		$$ = toServiceElements($1)
 	}
 	| error {
 		$$ = nil
 	}
 
-methodDecl : _RPC identifier methodMessageType _RETURNS methodMessageType ';' {
-		$$ = ast.NewRPCNode($1.ToKeyword(), $2, $3, $4.ToKeyword(), $5, $6)
+methodDecl : _RPC identifier methodMessageType _RETURNS methodMessageType semicolon {
+	  semi, extra := protolex.(*protoLex).requireSemicolon($6)
+		$$ = newNodeWithEmptyDecls(ast.NewRPCNode($1.ToKeyword(), $2, $3, $4.ToKeyword(), $5, semi), extra)
 	}
-	| _RPC identifier methodMessageType _RETURNS methodMessageType '{' methodBody '}' {
-		$$ = ast.NewRPCNodeWithBody($1.ToKeyword(), $2, $3, $4.ToKeyword(), $5, $6, $7, $8)
+	| _RPC identifier methodMessageType _RETURNS methodMessageType '{' methodBody '}' semicolon {
+		$$ = newNodeWithEmptyDecls(ast.NewRPCNodeWithBody($1.ToKeyword(), $2, $3, $4.ToKeyword(), $5, $6, $7, $8), $9)
 	}
 
 methodMessageType : '(' _STREAM typeName ')' {