types: stop panicking in generated decode constructors

3 files changed, 34 insertions, 20 deletions

diff --git a/internal/generate/typesgo.go b/internal/generate/typesgo.go
index 06ed49a..dca40fc 100644
--- a/internal/generate/typesgo.go
+++ b/internal/generate/typesgo.go
@@ -299,8 +299,9 @@ func writeSyncPool(b *strings.Builder, goName, selfRef string) {
 	fmt.Fprintf(b, "func New%s(raw []byte) *%s {\n", goName, goName)
 	fmt.Fprintf(b, "\t%s := poolOf%ss.Get().(*%s)\n", selfRef, goName, goName)
 	fmt.Fprintf(b, "\tif err := binary.Read(bytes.NewReader(raw), binary.LittleEndian, %s); err != nil {\n", selfRef)
-	fmt.Fprintf(b, "\t\tfmt.Println(%s, raw, len(raw), err)\n", selfRef)
-	b.WriteString("\t\tpanic(raw)\n\t}\n")
+	fmt.Fprintf(b, "\t\t*%s = %s{}\n", selfRef, goName)
+	fmt.Fprintf(b, "\t\tpoolOf%ss.Put(%s)\n", goName, selfRef)
+	b.WriteString("\t\treturn nil\n\t}\n")
 	fmt.Fprintf(b, "\treturn %s\n}\n\n", selfRef)
 
 	fmt.Fprintf(b, "func (%s *%s) Bytes() ([]byte, error) {\n", selfRef, goName)
diff --git a/internal/generate/typesgo_test.go b/internal/generate/typesgo_test.go
index f600582..76c0521 100644
--- a/internal/generate/typesgo_test.go
+++ b/internal/generate/typesgo_test.go
@@ -186,9 +186,13 @@ func TestGenerateTypesGoSyncPool(t *testing.T) {
 
 	requireContains(t, output, "var poolOfOpenEvents = sync.Pool{")
 	requireContains(t, output, "func NewOpenEvent(raw []byte) *OpenEvent")
+	requireContains(t, output, "return nil")
 	requireContains(t, output, "func (o *OpenEvent) Bytes() ([]byte, error)")
 	requireContains(t, output, "func (o *OpenEvent) Recycle()")
 	requireContains(t, output, "poolOfOpenEvents.Put(o)")
+	if strings.Contains(output, "panic(raw)") {
+		t.Fatalf("generated constructors must not panic on decode errors")
+	}
 
 	requireContains(t, output, "var poolOfNullEvents = sync.Pool{")
 	requireContains(t, output, "func NewNullEvent(raw []byte) *NullEvent")
diff --git a/internal/types/generated_types.go b/internal/types/generated_types.go
index 1f4b9d8..63c4319 100644
--- a/internal/types/generated_types.go
+++ b/internal/types/generated_types.go
@@ -344,8 +344,9 @@ var poolOfOpenEvents = sync.Pool{
 func NewOpenEvent(raw []byte) *OpenEvent {
 	o := poolOfOpenEvents.Get().(*OpenEvent)
 	if err := binary.Read(bytes.NewReader(raw), binary.LittleEndian, o); err != nil {
-		fmt.Println(o, raw, len(raw), err)
-		panic(raw)
+		*o = OpenEvent{}
+		poolOfOpenEvents.Put(o)
+		return nil
 	}
 	return o
 }
@@ -410,8 +411,9 @@ var poolOfNullEvents = sync.Pool{
 func NewNullEvent(raw []byte) *NullEvent {
 	n := poolOfNullEvents.Get().(*NullEvent)
 	if err := binary.Read(bytes.NewReader(raw), binary.LittleEndian, n); err != nil {
-		fmt.Println(n, raw, len(raw), err)
-		panic(raw)
+		*n = NullEvent{}
+		poolOfNullEvents.Put(n)
+		return nil
 	}
 	return n
 }
@@ -477,8 +479,9 @@ var poolOfFdEvents = sync.Pool{
 func NewFdEvent(raw []byte) *FdEvent {
 	f := poolOfFdEvents.Get().(*FdEvent)
 	if err := binary.Read(bytes.NewReader(raw), binary.LittleEndian, f); err != nil {
-		fmt.Println(f, raw, len(raw), err)
-		panic(raw)
+		*f = FdEvent{}
+		poolOfFdEvents.Put(f)
+		return nil
 	}
 	return f
 }
@@ -545,8 +548,9 @@ var poolOfRetEvents = sync.Pool{
 func NewRetEvent(raw []byte) *RetEvent {
 	r := poolOfRetEvents.Get().(*RetEvent)
 	if err := binary.Read(bytes.NewReader(raw), binary.LittleEndian, r); err != nil {
-		fmt.Println(r, raw, len(raw), err)
-		panic(raw)
+		*r = RetEvent{}
+		poolOfRetEvents.Put(r)
+		return nil
 	}
 	return r
 }
@@ -613,8 +617,9 @@ var poolOfNameEvents = sync.Pool{
 func NewNameEvent(raw []byte) *NameEvent {
 	n := poolOfNameEvents.Get().(*NameEvent)
 	if err := binary.Read(bytes.NewReader(raw), binary.LittleEndian, n); err != nil {
-		fmt.Println(n, raw, len(raw), err)
-		panic(raw)
+		*n = NameEvent{}
+		poolOfNameEvents.Put(n)
+		return nil
 	}
 	return n
 }
@@ -680,8 +685,9 @@ var poolOfPathEvents = sync.Pool{
 func NewPathEvent(raw []byte) *PathEvent {
 	p := poolOfPathEvents.Get().(*PathEvent)
 	if err := binary.Read(bytes.NewReader(raw), binary.LittleEndian, p); err != nil {
-		fmt.Println(p, raw, len(raw), err)
-		panic(raw)
+		*p = PathEvent{}
+		poolOfPathEvents.Put(p)
+		return nil
 	}
 	return p
 }
@@ -749,8 +755,9 @@ var poolOfFcntlEvents = sync.Pool{
 func NewFcntlEvent(raw []byte) *FcntlEvent {
 	f := poolOfFcntlEvents.Get().(*FcntlEvent)
 	if err := binary.Read(bytes.NewReader(raw), binary.LittleEndian, f); err != nil {
-		fmt.Println(f, raw, len(raw), err)
-		panic(raw)
+		*f = FcntlEvent{}
+		poolOfFcntlEvents.Put(f)
+		return nil
 	}
 	return f
 }
@@ -817,8 +824,9 @@ var poolOfDup3Events = sync.Pool{
 func NewDup3Event(raw []byte) *Dup3Event {
 	d := poolOfDup3Events.Get().(*Dup3Event)
 	if err := binary.Read(bytes.NewReader(raw), binary.LittleEndian, d); err != nil {
-		fmt.Println(d, raw, len(raw), err)
-		panic(raw)
+		*d = Dup3Event{}
+		poolOfDup3Events.Put(d)
+		return nil
 	}
 	return d
 }
@@ -884,8 +892,9 @@ var poolOfOpenByHandleAtEvents = sync.Pool{
 func NewOpenByHandleAtEvent(raw []byte) *OpenByHandleAtEvent {
 	o := poolOfOpenByHandleAtEvents.Get().(*OpenByHandleAtEvent)
 	if err := binary.Read(bytes.NewReader(raw), binary.LittleEndian, o); err != nil {
-		fmt.Println(o, raw, len(raw), err)
-		panic(raw)
+		*o = OpenByHandleAtEvent{}
+		poolOfOpenByHandleAtEvents.Put(o)
+		return nil
 	}
 	return o
 }