WalkUtils: add two inline elements into the WalkerCache to avoid memory allocations in the common case.

If there are no more than 2 elements in the cache, we can avoid using the `cache` Dictionary, which avoids memory allocations.
Fortunately this is the common case by far (about 97% of all walker invocations).

Author: eeckstein

SwiftCompilerSources/Sources/Optimizer/Utilities/WalkUtils.swift

@@ -111,12 +111,46 @@ extension SmallProjectionWalkingPath {
 /// A client must provide this cache in a `walkUpCache` or `walkDownCache` property.
 struct WalkerCache<Path : WalkingPath> {
   mutating func needWalk(for value: Value, path: Path) -> Path? {
+  
+    // Handle the first inline entry.
+    guard let e = inlineEntry0 else {
+      inlineEntry0 = (value, path)
+      return path
+    }
+    if e.value == value {
+      let newPath = e.path.merge(with: path)
+      if newPath != e.path {
+        inlineEntry0 = (value, newPath)
+        return newPath
+      }
+      return nil
+    }
+    
+    // Handle the second inline entry.
+    guard let e = inlineEntry1 else {
+      inlineEntry1 = (value, path)
+      return path
+    }
+    if e.value == value {
+      let newPath = e.path.merge(with: path)
+      if newPath != e.path {
+        inlineEntry1 = (value, newPath)
+        return newPath
+      }
+      return nil
+    }
+    
+    // If there are more than two elements, it goes into the `cache` Dictionary.
     return cache[value.hashable, default: CacheEntry()].needWalk(path: path)
   }
 
   var isEmpty: Bool { cache.isEmpty }
 
-  mutating func clear() { cache.removeAll(keepingCapacity: true) }
+  mutating func clear() {
+    inlineEntry0 = nil
+    inlineEntry1 = nil
+    cache.removeAll(keepingCapacity: true)
+  }
 
   private struct CacheEntry {
     var cachedPath: Path?
@@ -135,6 +169,13 @@ struct WalkerCache<Path : WalkingPath> {
     }
   }
 
+  // If there are no more than 2 elements in the cache, we can avoid using the `cache` Dictionary,
+  // which avoids memory allocations.
+  // Fortunately this is the common case by far (about 97% of all walker invocations).
+  private var inlineEntry0: (value: Value, path: Path)?
+  private var inlineEntry1: (value: Value, path: Path)?
+
+  // All elements, which don't fit into the inline entries.
   private var cache = Dictionary<HashableValue, CacheEntry>()
 }