Refactor void handling: add specialized encoder/decoder/type logic, update void-based operations for clarity and correctness

proto_generator/main.go

@@ -226,8 +226,8 @@ func (g *Generator) GenerateTypes(prefix string, types Types) error {
 		AppendDecl(g.File, TypeDecl(tName, e))
 
 		args := []NameAndType{{"r", Ident("io.Reader")}}
-		rets := []NameAndType{{"ret", Ident(tName)}, {"err", Ident("error")}}
-		decodeFunction := NewFuncWithReceiver("Decode", "_", tName, args, rets)
+		rets := []NameAndType{{"err", Ident("error")}}
+		decodeFunction := NewFuncWithReceiver("Decode", "ret", Pointer(Ident(tName)), args, rets)
 		g.Depth = 0
 		s, err := g.VisitDecoder(retExpr, v, tName)
 		if err != nil {
@@ -241,7 +241,7 @@ func (g *Generator) GenerateTypes(prefix string, types Types) error {
 
 		args = []NameAndType{{"w", Ident("io.Writer")}}
 		rets = []NameAndType{{"err", Ident("error")}}
-		encodeFunction := NewFuncWithReceiver("Encode", "ret", tName, args, rets)
+		encodeFunction := NewFuncWithReceiver("Encode", "ret", Pointer(Ident(tName)), args, rets)
 		g.Depth = 0
 		s, err = g.VisitEncoder(retExpr, v, tName)
 		if err != nil {

proto_generator/native_decoder.go

@@ -12,7 +12,7 @@ import (
 func DefaultDecoder(_ *Generator, varToSet ast.Expr, _ any, _ string) (s []ast.Stmt, err error) {
 	s = Stmts(
 		Assign(
-			Exprs(varToSet, Ident("err")),
+			Exprs(Ident("err")),
 			Exprs(Call(SelectorExprAndStr(varToSet, "Decode"), Ident("r"))),
 		),
 		IfErrNil(),
@@ -511,6 +511,10 @@ func VarLongDecoder(g *Generator, varToSet ast.Expr, dataRaw any, name string) (
 	return
 }
 
+func VoidDecoder(g *Generator, varToSet ast.Expr, dataRaw any, name string) (s []ast.Stmt, err error) {
+	return
+}
+
 func (g *Generator) RegisterDecoderNatives() {
 	g.DecoderNatives = map[string]FunctionGeneratorFunc{
 		"container": ContainerDecoder,
@@ -523,7 +527,7 @@ func (g *Generator) RegisterDecoderNatives() {
 		"bitfield":  BitFieldDecoder,
 		"string":    StringDecoder,
 
-		"void":            DefaultDecoder,
+		"void":            VoidDecoder,
 		"varint":          VarIntDecoder,
 		"varlong":         VarLongDecoder,
 		"anonymousNbt":    DefaultDecoder,

proto_generator/native_encoder.go

@@ -192,7 +192,11 @@ func SwitchEncoder(g *Generator, varToSet ast.Expr, dataRaw any, name string) (s
 		if err != nil {
 			return
 		}
-		s1 := Define(Exprs(Ident(name), Ident("ok")), Exprs(TypeAssert(varToSet, tType)))
+		varName := name
+		if fType == "void" {
+			varName = "_"
+		}
+		s1 := Define(Exprs(Ident(varName), Ident("ok")), Exprs(TypeAssert(varToSet, tType)))
 		s2 := If(Not(Ident("ok")), NewBlockEllipsis(Assign121(Ident("err"), Selector("proto_base", "BadTypeError")), Return()))
 		var caseDecodeValueStmts []ast.Stmt
 		caseDecodeValueStmts, err = g.VisitEncoder(Ident(name), fType, name)
@@ -333,6 +337,10 @@ func VarLongEncoder(g *Generator, varToSet ast.Expr, dataRaw any, name string) (
 	return
 }
 
+func VoidEncoder(_ *Generator, _ ast.Expr, _ any, _ string) (s []ast.Stmt, err error) {
+	return
+}
+
 func (g *Generator) RegisterEncoderNatives() {
 	g.EncoderNatives = map[string]FunctionGeneratorFunc{
 		"container": ContainerEncoder,
@@ -344,7 +352,7 @@ func (g *Generator) RegisterEncoderNatives() {
 		"buffer":    BufferEncoder,
 		"bitfield":  BitFieldEncoder,
 
-		"void":            DefaultEncoder,
+		"void":            VoidEncoder,
 		"varint":          VarIntEncoder,
 		"varlong":         VarLongEncoder,
 		"anonymousNbt":    DefaultEncoder,

proto_generator/native_type.go

@@ -153,6 +153,11 @@ func MakeSelectorVisitor(x, sel string) func(g *Generator, dataRaw any) (e ast.E
 	}
 }
 
+func VoidType(_ *Generator, _ any) (e ast.Expr, err error) {
+	e = NewStruct()
+	return
+}
+
 func (g *Generator) RegisterNatives() {
 	g.Natives = map[string]ExprGeneratorFunc{
 		"container":                VisitContainerType,
@@ -164,7 +169,7 @@ func (g *Generator) RegisterNatives() {
 		"native":                   VisitDontGenerateType,
 		"anonymousNbt":             MakeSelectorVisitor("nbt", "Anon"),
 		"anonOptionalNbt":          MakeSelectorVisitor("nbt", "Anon"), // I have no idea what the difference is between these two
-		"void":                     MakeSelectorVisitor("proto_base", "Void"),
+		"void":                     VoidType,
 		"bool":                     MakeIdentVisitor("bool"),
 		"u8":                       MakeIdentVisitor("uint8"),
 		"u16":                      MakeIdentVisitor("uint16"),

proto_generator/printer.go

@@ -269,13 +269,13 @@ func NewFunc(name string, arguments []NameAndType, returns []NameAndType) *ast.F
 	}
 }
 
-func NewFuncWithReceiver(name, receiverName, receiver string, arguments []NameAndType, returns []NameAndType) *ast.FuncDecl {
+func NewFuncWithReceiver(name, receiverName string, receiver ast.Expr, arguments []NameAndType, returns []NameAndType) *ast.FuncDecl {
 	f := NewFunc(name, arguments, returns)
 	f.Recv = &ast.FieldList{
 		List: []*ast.Field{
 			{
 				Names: []*ast.Ident{{Name: receiverName}},
-				Type:  &ast.Ident{Name: receiver},
+				Type:  receiver,
 			},
 		},
 	}