core/state: remove unused error from prefetcher trie method

core/state/state_object.go

@@ -150,11 +150,11 @@ func (s *stateObject) getTrie() (Trie, error) {
 // trie in the state object. The caller might want to do that, but it's cleaner
 // to break the hidden interdependency between retrieving tries from the db or
 // from the prefetcher.
-func (s *stateObject) getPrefetchedTrie() (Trie, error) {
+func (s *stateObject) getPrefetchedTrie() Trie {
 	// If there's nothing to meaningfully return, let the user figure it out by
 	// pulling the trie from disk.
 	if s.data.Root == types.EmptyRootHash || s.db.prefetcher == nil {
-		return nil, nil
+		return nil
 	}
 	// Attempt to retrieve the trie from the pretecher
 	return s.db.prefetcher.trie(s.addrHash, s.data.Root)
@@ -313,25 +313,19 @@ func (s *stateObject) updateTrie() (Trie, error) {
 		return s.trie, nil
 	}
 	// Retrieve a pretecher populated trie, or fall back to the database
-	tr, err := s.getPrefetchedTrie()
-	switch {
-	case err != nil:
-		// Fetcher retrieval failed, something's very wrong, abort
-		s.db.setError(err)
-		return nil, err
-
-	case tr == nil:
+	tr := s.getPrefetchedTrie()
+	if tr == nil {
 		// Fetcher not running or empty trie, fallback to the database trie
-		tr, err = s.getTrie()
+		_, err := s.getTrie()
 		if err != nil {
 			s.db.setError(err)
 			return nil, err
 		}
-
-	default:
+	} else {
 		// Prefetcher returned a live trie, swap it out for the current one
 		s.trie = tr
 	}
+
 	// The snapshot storage map for the object
 	var (
 		storage map[common.Hash][]byte

core/state/statedb.go

@@ -878,9 +878,9 @@ func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash {
 	start = time.Now()
 
 	if s.prefetcher != nil {
-		if trie, err := s.prefetcher.trie(common.Hash{}, s.originalRoot); err != nil {
-			log.Error("Failed to retrieve account pre-fetcher trie", "err", err)
-		} else if trie != nil {
+		if trie := s.prefetcher.trie(common.Hash{}, s.originalRoot); trie == nil {
+			log.Error("Failed to retrieve account pre-fetcher trie")
+		} else {
 			s.trie = trie
 		}
 	}

core/state/trie_prefetcher.go

@@ -145,16 +145,16 @@ func (p *triePrefetcher) prefetch(owner common.Hash, root common.Hash, addr comm
 // trie returns the trie matching the root hash, blocking until the fetcher of
 // the given trie terminates. If no fetcher exists for the request, nil will be
 // returned.
-func (p *triePrefetcher) trie(owner common.Hash, root common.Hash) (Trie, error) {
+func (p *triePrefetcher) trie(owner common.Hash, root common.Hash) Trie {
 	// Bail if no trie was prefetched for this root
 	fetcher := p.fetchers[p.trieID(owner, root)]
 	if fetcher == nil {
 		log.Error("Prefetcher missed to load trie", "owner", owner, "root", root)
 		p.deliveryMissMeter.Mark(1)
-		return nil, nil
+		return nil
 	}
 	// Subfetcher exists, retrieve its trie
-	return fetcher.peek(), nil
+	return fetcher.peek()
 }
 
 // used marks a batch of state items used to allow creating statistics as to

core/state/trie_prefetcher_test.go

@@ -58,7 +58,7 @@ func TestUseAfterTerminate(t *testing.T) {
 	if err := prefetcher.prefetch(common.Hash{}, db.originalRoot, common.Address{}, [][]byte{skey.Bytes()}); err == nil {
 		t.Errorf("Prefetch succeeded after terminate: %v", err)
 	}
-	if _, err := prefetcher.trie(common.Hash{}, db.originalRoot); err != nil {
-		t.Errorf("Trie retrieval failed after terminate: %v", err)
+	if tr := prefetcher.trie(common.Hash{}, db.originalRoot); tr == nil {
+		t.Errorf("Prefetcher returned nil trie after terminate")
 	}
 }