btf: move Builder.EnableDeduplication() to new btf.BuilderOptions

This commit adds an extra argument to NewBuilder to allow configuring the
Builder during instantiation. This makes enabling duplication a bit more
straightforward and harder to misuse.

Signed-off-by: Timo Beckers <timo@isovalent.com>

Author: ti-mo

btf/btf_test.go

@@ -304,7 +304,7 @@ func TestLoadSpecFromElf(t *testing.T) {
 }
 
 func TestVerifierError(t *testing.T) {
-	b, err := NewBuilder([]Type{&Int{Encoding: 255}})
+	b, err := NewBuilder([]Type{&Int{Encoding: 255}}, nil)
 	qt.Assert(t, qt.IsNil(err))
 	_, err = NewHandle(b)
 	testutils.SkipIfNotSupported(t, err)
@@ -391,7 +391,7 @@ func ExampleSpec_TypeByName() {
 func TestTypesIterator(t *testing.T) {
 	types := []Type{(*Void)(nil), &Int{Size: 4}, &Int{Size: 2}}
 
-	b, err := NewBuilder(types[1:])
+	b, err := NewBuilder(types[1:], nil)
 	if err != nil {
 		t.Fatal(err)
 	}

btf/feature.go

@@ -135,7 +135,7 @@ var haveEnum64 = internal.NewFeatureTest("ENUM64", func() error {
 }, "6.0")
 
 func probeBTF(typ Type) error {
-	b, err := NewBuilder([]Type{typ})
+	b, err := NewBuilder([]Type{typ}, nil)
 	if err != nil {
 		return err
 	}

btf/marshal.go

@@ -82,19 +82,32 @@ type Builder struct {
 	deduper *deduper
 }
 
+type BuilderOptions struct {
+	// Deduplicate enables type deduplication.
+	Deduplicate bool
+}
+
 // NewBuilder creates a Builder from a list of types.
 //
 // It is more efficient than calling [Add] individually.
 //
 // Returns an error if adding any of the types fails.
-func NewBuilder(types []Type) (*Builder, error) {
+func NewBuilder(types []Type, opts *BuilderOptions) (*Builder, error) {
+	if opts == nil {
+		opts = &BuilderOptions{}
+	}
+
 	b := &Builder{
 		make([]Type, 0, len(types)),
 		make(map[Type]TypeID, len(types)),
 		nil,
 		nil,
 	}
 
+	if opts.Deduplicate {
+		b.deduper = newDeduper()
+	}
+
 	for _, typ := range types {
 		_, err := b.Add(typ)
 		if err != nil {
@@ -110,22 +123,6 @@ func (b *Builder) Empty() bool {
 	return len(b.types) == 0 && (b.strings == nil || b.strings.Length() == 0)
 }
 
-// EnableDeduplication enables type deduplication for subsequently added types.
-// Type deduplication cannot be enabled after types have been added and cannot
-// be disabled once enabled.
-func (b *Builder) EnableDeduplication() error {
-	if b.deduper != nil {
-		return errors.New("deduplication already enabled")
-	}
-
-	if len(b.stableIDs) > 0 {
-		return errors.New("cannot enable deduplication after adding types")
-	}
-
-	b.deduper = newDeduper()
-	return nil
-}
-
 // Add a Type and allocate a stable ID for it.
 //
 // Adding the identical Type multiple times is valid and will return the same ID.

btf/marshal_test.go

@@ -25,7 +25,7 @@ func TestBuilderMarshal(t *testing.T) {
 		&Typedef{"baz", typ, nil},
 	}
 
-	b, err := NewBuilder(want)
+	b, err := NewBuilder(want, nil)
 	qt.Assert(t, qt.IsNil(err))
 
 	cpy := *b
@@ -91,7 +91,7 @@ limitTypes:
 		}
 	}
 
-	b, err := NewBuilder(types)
+	b, err := NewBuilder(types, nil)
 	qt.Assert(t, qt.IsNil(err))
 	buf, err := b.Marshal(nil, KernelMarshalOptions())
 	qt.Assert(t, qt.IsNil(err))
@@ -120,7 +120,7 @@ func TestMarshalEnum64(t *testing.T) {
 		},
 	}
 
-	b, err := NewBuilder([]Type{enum})
+	b, err := NewBuilder([]Type{enum}, nil)
 	qt.Assert(t, qt.IsNil(err))
 	buf, err := b.Marshal(nil, &MarshalOptions{
 		Order:         internal.NativeEndian,
@@ -156,7 +156,7 @@ func TestMarshalDeclTags(t *testing.T) {
 		},
 	}
 
-	b, err := NewBuilder(types)
+	b, err := NewBuilder(types, nil)
 	qt.Assert(t, qt.IsNil(err))
 	buf, err := b.Marshal(nil, &MarshalOptions{
 		Order:           internal.NativeEndian,
@@ -187,7 +187,7 @@ func TestMarshalTypeTags(t *testing.T) {
 		},
 	}
 
-	b, err := NewBuilder(types)
+	b, err := NewBuilder(types, nil)
 	qt.Assert(t, qt.IsNil(err))
 	buf, err := b.Marshal(nil, &MarshalOptions{
 		Order:           internal.NativeEndian,
@@ -237,7 +237,7 @@ func BenchmarkBuildVmlinux(b *testing.B) {
 func marshalNativeEndian(tb testing.TB, types []Type) []byte {
 	tb.Helper()
 
-	b, err := NewBuilder(types)
+	b, err := NewBuilder(types, nil)
 	qt.Assert(tb, qt.IsNil(err))
 	buf, err := b.Marshal(nil, nil)
 	qt.Assert(tb, qt.IsNil(err))

btf/workarounds_test.go

@@ -49,7 +49,7 @@ func TestDatasecResolveWorkaround(t *testing.T) {
 				},
 			}
 
-			b, err := NewBuilder([]Type{ds})
+			b, err := NewBuilder([]Type{ds}, nil)
 			if err != nil {
 				t.Fatal(err)
 			}