diff --git a/compiler/rustc_query_system/src/query/caches.rs b/compiler/rustc_query_system/src/query/caches.rs
index c3fc036aed3..acc29b67ccc 100644
--- a/compiler/rustc_query_system/src/query/caches.rs
+++ b/compiler/rustc_query_system/src/query/caches.rs
@@ -101,7 +101,7 @@ fn iter(&self, f: &mut dyn FnMut(&Self::Key, &Self::Value, DepNodeIndex)) {
 }
 
 pub struct VecCache<K: Idx, V> {
-    cache: Sharded<IndexVec<K, Option<(V, DepNodeIndex)>>>,
+    cache: Lock<IndexVec<K, Option<(V, DepNodeIndex)>>>,
 }
 
 impl<K: Idx, V> Default for VecCache<K, V> {
@@ -120,24 +120,20 @@ impl<K, V> QueryCache for VecCache<K, V>
 
     #[inline(always)]
     fn lookup(&self, key: &K) -> Option<(V, DepNodeIndex)> {
-        // FIXME: lock_shard_by_hash will use high bits which are usually zero in the index() passed
-        // here. This makes sharding essentially useless, always selecting the zero'th shard.
-        let lock = self.cache.lock_shard_by_hash(key.index() as u64);
+        let lock = self.cache.lock();
         if let Some(Some(value)) = lock.get(*key) { Some(*value) } else { None }
     }
 
     #[inline]
     fn complete(&self, key: K, value: V, index: DepNodeIndex) {
-        let mut lock = self.cache.lock_shard_by_hash(key.index() as u64);
+        let mut lock = self.cache.lock();
         lock.insert(key, (value, index));
     }
 
     fn iter(&self, f: &mut dyn FnMut(&Self::Key, &Self::Value, DepNodeIndex)) {
-        for shard in self.cache.lock_shards() {
-            for (k, v) in shard.iter_enumerated() {
-                if let Some(v) = v {
-                    f(&k, &v.0, v.1);
-                }
+        for (k, v) in self.cache.lock().iter_enumerated() {
+            if let Some(v) = v {
+                f(&k, &v.0, v.1);
             }
         }
     }
@@ -149,9 +145,6 @@ pub struct DefIdCache<V> {
     ///
     /// The second element of the tuple is the set of keys actually present in the IndexVec, used
     /// for faster iteration in `iter()`.
-    // FIXME: This may want to be sharded, like VecCache. However *how* to shard an IndexVec isn't
-    // super clear; VecCache is effectively not sharded today (see FIXME there). For now just omit
-    // that complexity here.
     local: Lock<(IndexVec<DefIndex, Option<(V, DepNodeIndex)>>, Vec<DefIndex>)>,
     foreign: DefaultCache<DefId, V>,
 }