Disallow empty root struct

Resolves #341

Emptry root struct cannot work since decoding it is a noop
and never reaches the end of column, thus potentially allowing
a very large number of such empty records to be "decoded" by
Reader without making any progress. This makes protecting from
invalid inputs hard.

We now disallow this, since there is no plausible use case
for a schema like this.

We still allow empty non-root structs, which is a valid way to
have a schema that can evolve by adding fields to empty struct.
It does not suffer from the same problem since Reader will have
to make some progress for non-empty root struct and will eventually
reach end of column for root struct.

We also disallow this in stefc schema parser.

Author: tigrannajaryan

examples/ints/internal/ints/record.go

@@ -0,0 +1,2 @@
+go test fuzz v1
+[]byte("STEF\x0200\x00 \n\x01\x0000000000\x02\x040000\x00\x000000000000000\x010\xca\xd6\xcd\xc2\xf9\x7f\tA0\x03\xe800000")

examples/jsonl/internal/jsonstef/record.go

@@ -20,6 +20,7 @@ var ErrTotalColumnSizeLimitExceeded = NewDecodeError("total column size limit ex
 var ErrRecordAllocLimitExceeded = NewDecodeError("record allocation limit exceeded")
 
 var ErrTooManyFieldsToDecode = NewDecodeError("too many fields to decode")
+var ErrEmptyRootStructDisallowed = NewDecodeError("cannot decode empty root struct")
 
 type DecodeError struct {
 	msg string

examples/profile/internal/profile/sample.go

@@ -192,6 +192,10 @@ func (p *Parser) parseStruct(isOneOf bool) (*schema.Struct, error) {
 		return nil, err
 	}
 
+	if str.IsRoot && len(str.Fields) == 0 {
+		return nil, p.error("root struct must have at least one field")
+	}
+
 	if err := p.eat(tRBrace); err != nil {
 		return nil, err
 	}

go/otel/otelstef/metrics.go

@@ -82,6 +82,10 @@ func TestParserErrors(t *testing.T) {
 			input: "package abc oneof Oneof dict(abc) {}",
 			err:   "test.stef:1:25: oneof cannot have dict modifier",
 		},
+		{
+			input: "package abc struct Empty root {}",
+			err:   "test.stef:1:33: root struct must have at least one field",
+		},
 	}
 
 	for _, test := range tests {
@@ -99,30 +103,30 @@ func TestParserWarnings(t *testing.T) {
 		warn  []string
 	}{
 		{
-			input: "package abc struct R root {} struct U {}",
+			input: "package abc struct R root { x bool } struct U {}",
 			warn:  []string{`Warning: struct "U" is defined but not used`},
 		},
 		{
-			input: "package abc struct R root {} multimap M { key string value int64 }",
+			input: "package abc struct R root { x bool } multimap M { key string value int64 }",
 			warn:  []string{`Warning: multimap "M" is defined but not used`},
 		},
 		{
-			input: "package abc struct R root {} oneof O {}",
+			input: "package abc struct R root { x bool } oneof O {}",
 			warn:  []string{`Warning: oneof "O" is defined but not used`},
 		},
 		{
-			input: "package abc struct R root {} enum E {}",
+			input: "package abc struct R root { x bool } enum E {}",
 			warn:  []string{`Warning: enum "E" is defined but not used`},
 		},
 		{
-			input: "package abc struct R root {} struct A { B B optional } struct B { A A optional }",
+			input: "package abc struct R root { x bool } struct A { B B optional } struct B { A A optional }",
 			warn: []string{
 				`Warning: struct "A" is defined but not used`, `Warning: struct "B" is defined but not used`,
 			},
 		},
 		// Multiple unused types of different kinds
 		{
-			input: "package abc struct R root {} struct U1 {} struct U2 {} oneof O {} multimap M { key string value int64 } enum E {}",
+			input: "package abc struct R root { x bool } struct U1 {} struct U2 {} oneof O {} multimap M { key string value int64 } enum E {}",
 			warn: []string{
 				`Warning: oneof "O" is defined but not used`,
 				`Warning: struct "U1" is defined but not used`,
@@ -133,7 +137,7 @@ func TestParserWarnings(t *testing.T) {
 		},
 		// Chain of unused structs where one references another
 		{
-			input: "package abc struct R root {} struct A { b B } struct B { c C } struct C {}",
+			input: "package abc struct R root { x bool } struct A { b B } struct B { c C } struct C {}",
 			warn: []string{
 				`Warning: struct "A" is defined but not used`,
 				`Warning: struct "B" is defined but not used`,
@@ -142,7 +146,7 @@ func TestParserWarnings(t *testing.T) {
 		},
 		// Circular dependency that's unused
 		{
-			input: "package abc struct R root {} struct A { b []B c C } struct B { a A } struct C { name string }",
+			input: "package abc struct R root { x bool } struct A { b []B c C } struct B { a A } struct C { name string }",
 			warn: []string{
 				`Warning: struct "A" is defined but not used`,
 				`Warning: struct "B" is defined but not used`,
@@ -205,14 +209,14 @@ func TestParserWarnings(t *testing.T) {
 		},
 		// Self-referencing unused struct
 		{
-			input: "package abc struct R root {} struct SelfRef { next SelfRef optional }",
+			input: "package abc struct R root { x bool } struct SelfRef { next SelfRef optional }",
 			warn: []string{
 				`Warning: struct "SelfRef" is defined but not used`,
 			},
 		},
 		// Multiple levels of mutual references that are unused
 		{
-			input: "package abc struct R root {} struct A { b B } struct B { c C } struct C { a A optional }",
+			input: "package abc struct R root { x bool } struct A { b B } struct B { c C } struct C { a A optional }",
 			warn: []string{
 				`Warning: struct "A" is defined but not used`,
 				`Warning: struct "B" is defined but not used`,

go/otel/otelstef/spans.go

@@ -15,7 +15,12 @@ func ShrinkRandomly(r *rand.Rand, schem *Schema) bool {
 	var structNames []string
 	for structName := range schem.Structs {
 		structNames = append(structNames, structName)
-		totalFieldCount += len(schem.Structs[structName].Fields)
+		str := schem.Structs[structName]
+		shrinkableCount := len(str.Fields)
+		if str.IsRoot {
+			shrinkableCount-- // Do not remove the last field from the root struct
+		}
+		totalFieldCount += shrinkableCount
 	}
 	if totalFieldCount == 0 {
 		// Nothing to shrink
@@ -34,6 +39,11 @@ func ShrinkRandomly(r *rand.Rand, schem *Schema) bool {
 }
 
 func shrinkStruct(r *rand.Rand, schem *Schema, str *Struct) bool {
+	if str.IsRoot && len(str.Fields) <= 1 {
+		// Do not remove the last field from the root struct
+		return false
+	}
+
 	if r.IntN(10) == 0 && len(str.Fields) > 0 {
 		str.Fields = str.Fields[0 : len(str.Fields)-1]
 		return true