Auto merge of #120151 - Nilstrieb:hashmap-testing, r=<try>

[PERF EXPERIMENTS] Hashmap experiment

I've been thinking about some sort of more efficient way of dealing with small hashmaps, since the vast majority of hashmaps are small..

(non-empty maps only)
```
    0.5..=      1:       0 (0.0%)
      1..=      2:      15 (0.0061269%)
      2..=      4:  176617 (72.14%)
      4..=      8:  203093 (82.955%)
      8..=     16:  232412 (94.93%)
     16..=     32:  240221 (98.12%)
     32..=     64:  243007 (99.258%)
     64..=    128:  244165 (99.731%)
    128..=    256:  244512 (99.873%)
    256..=    512:  244692 (99.946%)
    512..=   1024:  244734 (99.963%)
   1024..=   2048:  244763 (99.975%)
   2048..=   4096:  244780 (99.982%)
   4096..=   8192:  244795 (99.988%)
   8192..=  16384:  244808 (99.993%)
  16384..=  32768:  244816 (99.997%)
```

let's try something with the most popular small map

r? `@ghost`

Author: bors

compiler/rustc_infer/src/infer/freshen.rs

@@ -41,8 +41,10 @@ pub struct TypeFreshener<'a, 'tcx> {
     infcx: &'a InferCtxt<'tcx>,
     ty_freshen_count: u32,
     const_freshen_count: u32,
-    ty_freshen_map: FxHashMap<ty::InferTy, Ty<'tcx>>,
-    const_freshen_map: FxHashMap<ty::InferConst, ty::Const<'tcx>>,
+    ty_freshen_key_vec: Vec<ty::InferTy>,
+    ty_freshen_value_vec: Vec<Ty<'tcx>>,
+    const_freshen_key_vec: Vec<ty::InferConst>,
+    const_freshen_value_vec: Vec<ty::Const<'tcx>>,
 }
 
 impl<'a, 'tcx> TypeFreshener<'a, 'tcx> {
@@ -51,8 +53,10 @@ impl<'a, 'tcx> TypeFreshener<'a, 'tcx> {
             infcx,
             ty_freshen_count: 0,
             const_freshen_count: 0,
-            ty_freshen_map: Default::default(),
-            const_freshen_map: Default::default(),
+            ty_freshen_key_vec: Vec::new(),
+            ty_freshen_value_vec: Vec::new(),
+            const_freshen_key_vec: Vec::new(),
+            const_freshen_value_vec: Vec::new(),
         }
     }
 
@@ -64,15 +68,15 @@ impl<'a, 'tcx> TypeFreshener<'a, 'tcx> {
             return ty.fold_with(self);
         }
 
-        match self.ty_freshen_map.entry(key) {
-            Entry::Occupied(entry) => *entry.get(),
-            Entry::Vacant(entry) => {
-                let index = self.ty_freshen_count;
-                self.ty_freshen_count += 1;
-                let t = mk_fresh(index);
-                entry.insert(t);
-                t
-            }
+        if let Some(idx) = self.ty_freshen_key_vec.iter().position(|infty| *infty == key) {
+            unsafe { self.ty_freshen_value_vec[idx] }
+        } else {
+            let index = self.ty_freshen_count;
+            self.ty_freshen_count += 1;
+            let t = mk_fresh(index);
+            self.ty_freshen_key_vec.push(key);
+            self.ty_freshen_value_vec.push(t);
+            t
         }
     }
 
@@ -90,15 +94,15 @@ impl<'a, 'tcx> TypeFreshener<'a, 'tcx> {
             return ct.fold_with(self);
         }
 
-        match self.const_freshen_map.entry(key) {
-            Entry::Occupied(entry) => *entry.get(),
-            Entry::Vacant(entry) => {
-                let index = self.const_freshen_count;
-                self.const_freshen_count += 1;
-                let ct = ty::Const::new_infer(self.infcx.tcx, freshener(index), ty);
-                entry.insert(ct);
-                ct
-            }
+        if let Some(idx) = self.const_freshen_key_vec.iter().position(|infty| *infty == key) {
+            unsafe { self.const_freshen_value_vec[idx] }
+        } else {
+            let index: u32 = self.const_freshen_count;
+            self.const_freshen_count += 1;
+            let ct = ty::Const::new_infer(self.infcx.tcx, freshener(index), ty);
+            self.const_freshen_key_vec.push(key);
+            self.const_freshen_value_vec.push(ct);
+            ct
         }
     }
 }