Allow IndexVisitor to return errors (#315)

Author: efritz

CHANGELOG.md

@@ -9,6 +9,11 @@ Rust SCIP bindings:
   the latest release v3.7.2.
   (https://github.com/sourcegraph/scip/pull/313)
 
+Go bindings:
+
+- BREAKING CHANGE: IndexVisitor now accepts a context object and returns an error.
+  When an error is returned, the visitor short-circuits.
+
 ## v0.5.2
 
 SCIP schema:

bindings/go/scip/memtest/low_mem_test.go

@@ -1,6 +1,7 @@
 package memtest
 
 import (
+	"context"
 	"fmt"
 	"io"
 	"os"
@@ -52,12 +53,15 @@ func TestLowMemoryParsing(t *testing.T) {
 	debug.SetMemoryLimit(textSize * maxDocsInMemory)
 
 	curDoc := &scip.Document{}
-	indexVisitor := scip.IndexVisitor{VisitDocument: func(d *scip.Document) {
-		curDoc = d
-	}}
+	indexVisitor := scip.IndexVisitor{
+		VisitDocument: func(_ context.Context, d *scip.Document) error {
+			curDoc = d
+			return nil
+		},
+	}
 
 	// No OOM
-	err = indexVisitor.ParseStreaming(tmpFile)
+	err = indexVisitor.ParseStreaming(context.Background(), tmpFile)
 	_ = curDoc
 	require.NoError(t, err)
 }

bindings/go/scip/parse.go

@@ -1,6 +1,7 @@
 package scip
 
 import (
+	"context"
 	"io"
 
 	"github.com/cockroachdb/errors"
@@ -13,9 +14,9 @@ import (
 // implementations, so adding new functions here for new fields in
 // the SCIP schema would break clients. Individual functions may be nil.
 type IndexVisitor struct {
-	VisitMetadata       func(*Metadata)
-	VisitDocument       func(*Document)
-	VisitExternalSymbol func(*SymbolInformation)
+	VisitMetadata       func(ctx context.Context, m *Metadata) error
+	VisitDocument       func(ctx context.Context, d *Document) error
+	VisitExternalSymbol func(ctx context.Context, si *SymbolInformation) error
 }
 
 // See https://protobuf.dev/programming-guides/encoding/#varints
@@ -24,7 +25,7 @@ const maxVarintBytes = 10
 // ParseStreaming processes an index by incrementally reading input from the io.Reader.
 //
 // Parsing takes place at Document granularity for ease of use.
-func (pi *IndexVisitor) ParseStreaming(r io.Reader) error {
+func (pi *IndexVisitor) ParseStreaming(ctx context.Context, r io.Reader) error {
 	// The tag is encoded as a varint with value: (field_number << 3) | wire_type
 	// Varints < 128 fit in 1 byte, which means 4 bits are available for field
 	// numbers. The Index type has less than 15 fields, so the tag will fit in 1 byte.
@@ -84,23 +85,29 @@ func (pi *IndexVisitor) ParseStreaming(r io.Reader) error {
 					if err := proto.Unmarshal(dataBuf, &m); err != nil {
 						return errors.Wrapf(err, "failed to read %s", indexFieldName(fieldNumber))
 					}
-					pi.VisitMetadata(&m)
+					if err := pi.VisitMetadata(ctx, &m); err != nil {
+						return err
+					}
 				}
 			} else if fieldNumber == documentsFieldNumber {
 				if pi.VisitDocument != nil {
 					d := Document{}
 					if err := proto.Unmarshal(dataBuf, &d); err != nil {
 						return errors.Wrapf(err, "failed to read %s", indexFieldName(fieldNumber))
 					}
-					pi.VisitDocument(&d)
+					if err := pi.VisitDocument(ctx, &d); err != nil {
+						return err
+					}
 				}
 			} else if fieldNumber == externalSymbolsFieldNumber {
 				if pi.VisitExternalSymbol != nil {
 					s := SymbolInformation{}
 					if err := proto.Unmarshal(dataBuf, &s); err != nil {
 						return errors.Wrapf(err, "failed to read %s", indexFieldName(fieldNumber))
 					}
-					pi.VisitExternalSymbol(&s)
+					if err := pi.VisitExternalSymbol(ctx, &s); err != nil {
+						return err
+					}
 				}
 			} else {
 				return errors.Newf(

bindings/go/scip/parse_test.go

@@ -3,6 +3,7 @@ package scip
 import (
 	"bytes"
 	"compress/gzip"
+	"context"
 	"io"
 	"os"
 	"regexp"
@@ -60,15 +61,18 @@ func TestDocumentsOnly(t *testing.T) {
 
 		parsedIndex := Index{}
 
-		indexVisitor := IndexVisitor{VisitDocument: func(document *Document) {
-			parsedIndex.Documents = append(parsedIndex.Documents, document)
-		}}
+		indexVisitor := IndexVisitor{
+			VisitDocument: func(_ context.Context, document *Document) error {
+				parsedIndex.Documents = append(parsedIndex.Documents, document)
+				return nil
+			},
+		}
 
 		indexBytes, err := proto.Marshal(&index)
 		require.NoError(t, err)
 		bytesReader := bytes.NewReader(indexBytes)
 
-		if err := indexVisitor.ParseStreaming(bytesReader); err != nil {
+		if err := indexVisitor.ParseStreaming(context.Background(), bytesReader); err != nil {
 			t.Fatalf("got error parsing index %v", err)
 		}
 
@@ -102,15 +106,22 @@ func checkRoundtrip(t *testing.T, index *Index) {
 func parseStreaming(t *testing.T, reader io.Reader) *Index {
 	parsedIndex := Index{}
 
-	indexVisitor := IndexVisitor{func(metadata *Metadata) {
-		parsedIndex.Metadata = metadata
-	}, func(document *Document) {
-		parsedIndex.Documents = append(parsedIndex.Documents, document)
-	}, func(extSym *SymbolInformation) {
-		parsedIndex.ExternalSymbols = append(parsedIndex.ExternalSymbols, extSym)
-	}}
+	indexVisitor := IndexVisitor{
+		VisitMetadata: func(_ context.Context, metadata *Metadata) error {
+			parsedIndex.Metadata = metadata
+			return nil
+		},
+		VisitDocument: func(_ context.Context, document *Document) error {
+			parsedIndex.Documents = append(parsedIndex.Documents, document)
+			return nil
+		},
+		VisitExternalSymbol: func(_ context.Context, extSym *SymbolInformation) error {
+			parsedIndex.ExternalSymbols = append(parsedIndex.ExternalSymbols, extSym)
+			return nil
+		},
+	}
 
-	if err := indexVisitor.ParseStreaming(reader); err != nil {
+	if err := indexVisitor.ParseStreaming(context.Background(), reader); err != nil {
 		t.Fatalf("got error parsing index %v", err)
 	}
 	return &parsedIndex