refactor: don't return an error from NewImmutableTree[WithOpts]

Tree construction never fails, so don't return an error.

Fixes #756

basic_test.go

@@ -15,8 +15,7 @@ import (
 )
 
 func TestBasic(t *testing.T) {
-	tree, err := getTestTree(0)
-	require.NoError(t, err)
+	tree := getTestTree(0)
 	up, err := tree.Set([]byte("1"), []byte("one"))
 	require.NoError(t, err)
 	if up {
@@ -241,8 +240,7 @@ func TestRemove(t *testing.T) {
 	keyLen, dataLen := 16, 40
 
 	size := 10000
-	t1, err := getTestTree(size)
-	require.NoError(t, err)
+	t1 := getTestTree(size)
 
 	// insert a bunch of random nodes
 	keys := make([][]byte, size)
@@ -271,8 +269,7 @@ func TestIntegration(t *testing.T) {
 	}
 
 	records := make([]*record, 400)
-	tree, err := getTestTree(0)
-	require.NoError(t, err)
+	tree := getTestTree(0)
 
 	randomRecord := func() *record {
 		return &record{randstr(20), randstr(20)}
@@ -324,7 +321,6 @@ func TestIntegration(t *testing.T) {
 		} else if string(val) != x.value {
 			t.Error("Wrong value")
 		}
-		require.NoError(t, err)
 		for _, r := range records[i+1:] {
 			has, err := tree.Has([]byte(r.key))
 			require.NoError(t, err)
@@ -374,8 +370,7 @@ func TestIterateRange(t *testing.T) {
 	}
 	sort.Strings(keys)
 
-	tree, err := getTestTree(0)
-	require.NoError(t, err)
+	tree := getTestTree(0)
 
 	// insert all the data
 	for _, r := range records {
@@ -446,16 +441,14 @@ func TestPersistence(t *testing.T) {
 	}
 
 	// Construct some tree and save it
-	t1, err := NewMutableTree(db, 0, false, log.NewNopLogger())
-	require.NoError(t, err)
+	t1 := NewMutableTree(db, 0, false, log.NewNopLogger())
 	for key, value := range records {
 		t1.Set([]byte(key), []byte(value))
 	}
 	t1.SaveVersion()
 
 	// Load a tree
-	t2, err := NewMutableTree(db, 0, false, log.NewNopLogger())
-	require.NoError(t, err)
+	t2 := NewMutableTree(db, 0, false, log.NewNopLogger())
 	t2.Load()
 	for key, value := range records {
 		t2value, err := t2.Get([]byte(key))
@@ -468,8 +461,7 @@ func TestPersistence(t *testing.T) {
 
 func TestProof(t *testing.T) {
 	// Construct some random tree
-	tree, err := getTestTree(100)
-	require.NoError(t, err)
+	tree := getTestTree(100)
 	for i := 0; i < 10; i++ {
 		key, value := randstr(20), randstr(20)
 		tree.Set([]byte(key), []byte(value))
@@ -504,13 +496,12 @@ func TestProof(t *testing.T) {
 
 func TestTreeProof(t *testing.T) {
 	db := db.NewMemDB()
-	tree, err := NewMutableTree(db, 100, false, log.NewNopLogger())
-	require.NoError(t, err)
+	tree := NewMutableTree(db, 100, false, log.NewNopLogger())
 	hash := tree.Hash()
 	assert.Equal(t, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855", hex.EncodeToString(hash))
 
 	// should get false for proof with nil root
-	_, err = tree.GetProof([]byte("foo"))
+	_, err := tree.GetProof([]byte("foo"))
 	require.Error(t, err)
 
 	// insert lots of info and store the bytes

benchmarks/bench_test.go

@@ -27,13 +27,12 @@ func randBytes(length int) []byte {
 }
 
 func prepareTree(b *testing.B, db db.DB, size, keyLen, dataLen int) (*iavl.MutableTree, [][]byte) {
-	t, err := iavl.NewMutableTreeWithOpts(db, size, nil, false, log.NewNopLogger())
-	require.NoError(b, err)
+	t := iavl.NewMutableTreeWithOpts(db, size, nil, false, log.NewNopLogger())
 	keys := make([][]byte, size)
 
 	for i := 0; i < size; i++ {
 		key := randBytes(keyLen)
-		_, err = t.Set(key, randBytes(dataLen))
+		_, err := t.Set(key, randBytes(dataLen))
 		require.NoError(b, err)
 		keys[i] = key
 	}

benchmarks/cosmos-exim/main.go

@@ -91,10 +91,7 @@ func runExport(dbPath string) (int64, map[string][]*iavl.ExportNode, error) {
 	if err != nil {
 		return 0, nil, err
 	}
-	tree, err := iavl.NewMutableTree(tmdb.NewPrefixDB(ldb, []byte("s/k:main/")), 0, false, log.NewNopLogger())
-	if err != nil {
-		return 0, nil, err
-	}
+	tree := iavl.NewMutableTree(tmdb.NewPrefixDB(ldb, []byte("s/k:main/")), 0, false, log.NewNopLogger())
 	version, err := tree.LoadVersion(0)
 	if err != nil {
 		return 0, nil, err
@@ -106,10 +103,7 @@ func runExport(dbPath string) (int64, map[string][]*iavl.ExportNode, error) {
 	totalStats := Stats{}
 	for _, name := range stores {
 		db := tmdb.NewPrefixDB(ldb, []byte("s/k:"+name+"/"))
-		tree, err := iavl.NewMutableTree(db, 0, false, log.NewNopLogger())
-		if err != nil {
-			return 0, nil, err
-		}
+		tree := iavl.NewMutableTree(db, 0, false, log.NewNopLogger())
 
 		stats := Stats{}
 		export := make([]*iavl.ExportNode, 0, 100000)
@@ -174,10 +168,7 @@ func runImport(version int64, exports map[string][]*iavl.ExportNode) error {
 		if err != nil {
 			return err
 		}
-		newTree, err := iavl.NewMutableTree(newDB, 0, false, log.NewNopLogger())
-		if err != nil {
-			return err
-		}
+		newTree := iavl.NewMutableTree(newDB, 0, false, log.NewNopLogger())
 		importer, err := newTree.Import(version)
 		if err != nil {
 			return err

cmd/iaviewer/main.go

@@ -122,10 +122,7 @@ func ReadTree(dir string, version int, prefix []byte) (*iavl.MutableTree, error)
 		db = dbm.NewPrefixDB(db, prefix)
 	}
 
-	tree, err := iavl.NewMutableTree(db, DefaultCacheSize, false, log.NewLogger(os.Stdout))
-	if err != nil {
-		return nil, err
-	}
+	tree := iavl.NewMutableTree(db, DefaultCacheSize, false, log.NewLogger(os.Stdout))
 	ver, err := tree.LoadVersion(int64(version))
 	fmt.Printf("Got version: %d\n", ver)
 	return tree, err

diff_test.go

@@ -20,8 +20,7 @@ func TestDiffRoundTrip(t *testing.T) {
 
 	// apply changeSets to tree
 	db := db.NewMemDB()
-	tree, err := NewMutableTree(db, 0, true, log.NewNopLogger())
-	require.NoError(t, err)
+	tree := NewMutableTree(db, 0, true, log.NewNopLogger())
 	for i := range changeSets {
 		v, err := tree.SaveChangeSet(changeSets[i])
 		require.NoError(t, err)
@@ -31,7 +30,7 @@ func TestDiffRoundTrip(t *testing.T) {
 	// extract change sets from db
 	var extractChangeSets []*ChangeSet
 	tree2 := NewImmutableTree(db, 0, true, log.NewNopLogger())
-	err = tree2.TraverseStateChanges(0, math.MaxInt64, func(version int64, changeSet *ChangeSet) error {
+	err := tree2.TraverseStateChanges(0, math.MaxInt64, func(version int64, changeSet *ChangeSet) error {
 		extractChangeSets = append(extractChangeSets, changeSet)
 		return nil
 	})

export_test.go

@@ -15,10 +15,9 @@ import (
 // setupExportTreeBasic sets up a basic tree with a handful of
 // create/update/delete operations over a few versions.
 func setupExportTreeBasic(t require.TestingT) *ImmutableTree {
-	tree, err := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
-	require.NoError(t, err)
+	tree := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
 
-	_, err = tree.Set([]byte("x"), []byte{255})
+	_, err := tree.Set([]byte("x"), []byte{255})
 	require.NoError(t, err)
 	_, err = tree.Set([]byte("z"), []byte{255})
 	require.NoError(t, err)
@@ -75,8 +74,7 @@ func setupExportTreeRandom(t *testing.T) *ImmutableTree {
 	)
 
 	r := rand.New(rand.NewSource(randSeed))
-	tree, err := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
-	require.NoError(t, err)
+	tree := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
 
 	var version int64
 	keys := make([][]byte, 0, versionOps)
@@ -113,6 +111,7 @@ func setupExportTreeRandom(t *testing.T) *ImmutableTree {
 				keys = append(keys, key)
 			}
 		}
+		var err error
 		_, version, err = tree.SaveVersion()
 		require.NoError(t, err)
 	}
@@ -135,8 +134,7 @@ func setupExportTreeSized(t require.TestingT, treeSize int) *ImmutableTree { //n
 	)
 
 	r := rand.New(rand.NewSource(randSeed))
-	tree, err := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
-	require.NoError(t, err)
+	tree := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
 
 	for i := 0; i < treeSize; i++ {
 		key := make([]byte, keySize)
@@ -257,8 +255,7 @@ func TestExporter_Import(t *testing.T) {
 					exporter = NewCompressExporter(innerExporter)
 				}
 
-				newTree, err := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
-				require.NoError(t, err)
+				newTree := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
 				innerImporter, err := newTree.Import(tree.Version())
 				require.NoError(t, err)
 				defer innerImporter.Close()
@@ -326,10 +323,9 @@ func TestExporter_Close(t *testing.T) {
 }
 
 func TestExporter_DeleteVersionErrors(t *testing.T) {
-	tree, err := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
-	require.NoError(t, err)
+	tree := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
 
-	_, err = tree.Set([]byte("a"), []byte{1})
+	_, err := tree.Set([]byte("a"), []byte{1})
 	require.NoError(t, err)
 	_, _, err = tree.SaveVersion()
 	require.NoError(t, err)

import_test.go

@@ -11,12 +11,9 @@ import (
 )
 
 func ExampleImporter() {
-	tree, err := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
-	if err != nil {
-		panic(err)
-	}
+	tree := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
 
-	_, err = tree.Set([]byte("a"), []byte{1})
+	_, err := tree.Set([]byte("a"), []byte{1})
 	if err != nil {
 		panic(err)
 	}
@@ -55,10 +52,7 @@ func ExampleImporter() {
 		exported = append(exported, node)
 	}
 
-	newTree, err := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
-	if err != nil {
-		panic(err)
-	}
+	newTree := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
 	importer, err := newTree.Import(version)
 	if err != nil {
 		panic(err)
@@ -77,16 +71,14 @@ func ExampleImporter() {
 }
 
 func TestImporter_NegativeVersion(t *testing.T) {
-	tree, err := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
-	require.NoError(t, err)
-	_, err = tree.Import(-1)
+	tree := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
+	_, err := tree.Import(-1)
 	require.Error(t, err)
 }
 
 func TestImporter_NotEmpty(t *testing.T) {
-	tree, err := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
-	require.NoError(t, err)
-	_, err = tree.Set([]byte("a"), []byte{1})
+	tree := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
+	_, err := tree.Set([]byte("a"), []byte{1})
 	require.NoError(t, err)
 	_, _, err = tree.SaveVersion()
 	require.NoError(t, err)
@@ -98,15 +90,13 @@ func TestImporter_NotEmpty(t *testing.T) {
 func TestImporter_NotEmptyDatabase(t *testing.T) {
 	db := db.NewMemDB()
 
-	tree, err := NewMutableTree(db, 0, false, log.NewNopLogger())
-	require.NoError(t, err)
-	_, err = tree.Set([]byte("a"), []byte{1})
+	tree := NewMutableTree(db, 0, false, log.NewNopLogger())
+	_, err := tree.Set([]byte("a"), []byte{1})
 	require.NoError(t, err)
 	_, _, err = tree.SaveVersion()
 	require.NoError(t, err)
 
-	tree, err = NewMutableTree(db, 0, false, log.NewNopLogger())
-	require.NoError(t, err)
+	tree = NewMutableTree(db, 0, false, log.NewNopLogger())
 	_, err = tree.Load()
 	require.NoError(t, err)
 
@@ -115,9 +105,8 @@ func TestImporter_NotEmptyDatabase(t *testing.T) {
 }
 
 func TestImporter_NotEmptyUnsaved(t *testing.T) {
-	tree, err := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
-	require.NoError(t, err)
-	_, err = tree.Set([]byte("a"), []byte{1})
+	tree := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
+	_, err := tree.Set([]byte("a"), []byte{1})
 	require.NoError(t, err)
 
 	_, err = tree.Import(1)
@@ -143,8 +132,7 @@ func TestImporter_Add(t *testing.T) {
 	for desc, tc := range testcases {
 		tc := tc // appease scopelint
 		t.Run(desc, func(t *testing.T) {
-			tree, err := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
-			require.NoError(t, err)
+			tree := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
 			importer, err := tree.Import(1)
 			require.NoError(t, err)
 			defer importer.Close()
@@ -163,8 +151,7 @@ func TestImporter_Add(t *testing.T) {
 }
 
 func TestImporter_Add_Closed(t *testing.T) {
-	tree, err := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
-	require.NoError(t, err)
+	tree := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
 	importer, err := tree.Import(1)
 	require.NoError(t, err)
 
@@ -175,8 +162,7 @@ func TestImporter_Add_Closed(t *testing.T) {
 }
 
 func TestImporter_Close(t *testing.T) {
-	tree, err := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
-	require.NoError(t, err)
+	tree := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
 	importer, err := tree.Import(1)
 	require.NoError(t, err)
 
@@ -192,8 +178,7 @@ func TestImporter_Close(t *testing.T) {
 }
 
 func TestImporter_Commit(t *testing.T) {
-	tree, err := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
-	require.NoError(t, err)
+	tree := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
 	importer, err := tree.Import(1)
 	require.NoError(t, err)
 
@@ -208,8 +193,7 @@ func TestImporter_Commit(t *testing.T) {
 }
 
 func TestImporter_Commit_ForwardVersion(t *testing.T) {
-	tree, err := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
-	require.NoError(t, err)
+	tree := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
 	importer, err := tree.Import(2)
 	require.NoError(t, err)
 
@@ -224,8 +208,7 @@ func TestImporter_Commit_ForwardVersion(t *testing.T) {
 }
 
 func TestImporter_Commit_Closed(t *testing.T) {
-	tree, err := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
-	require.NoError(t, err)
+	tree := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
 	importer, err := tree.Import(1)
 	require.NoError(t, err)
 
@@ -239,8 +222,7 @@ func TestImporter_Commit_Closed(t *testing.T) {
 }
 
 func TestImporter_Commit_Empty(t *testing.T) {
-	tree, err := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
-	require.NoError(t, err)
+	tree := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
 	importer, err := tree.Import(3)
 	require.NoError(t, err)
 	defer importer.Close()
@@ -269,8 +251,7 @@ func BenchmarkImport(b *testing.B) {
 	b.StartTimer()
 
 	for n := 0; n < b.N; n++ {
-		newTree, err := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
-		require.NoError(b, err)
+		newTree := NewMutableTree(db.NewMemDB(), 0, false, log.NewNopLogger())
 		importer, err := newTree.Import(tree.Version())
 		require.NoError(b, err)
 		for _, item := range exported {