Enable TypeSubsumptionCache for IDE use

src/Compiler/Checking/import.fs

@@ -108,7 +108,9 @@ let createTypeSubsumptionCache (g: TcGlobals) =
                 MaximumCapacity = 4 * 32768 }
     Cache.Create<TTypeCacheKey, bool>(options)
 
-let typeSubsumptionCaches = ConditionalWeakTable<TcGlobals, Cache<TTypeCacheKey, bool>>()
+let typeSubsumptionCaches = Cache.Create<TcGlobals, Cache<TTypeCacheKey, bool>>({ CacheOptions.Default with MaximumCapacity = 16 })
+
+do typeSubsumptionCaches.ValueEvicted.Add <| _.Dispose()
 
 //-------------------------------------------------------------------------
 // Import an IL types as F# types.
@@ -132,7 +134,8 @@ type ImportMap(g: TcGlobals, assemblyLoader: AssemblyLoader) =
 
     member _.ILTypeRefToTyconRefCache = typeRefToTyconRefCache
 
-    member val TypeSubsumptionCache: Cache<TTypeCacheKey, bool> = typeSubsumptionCaches.GetValue(g, createTypeSubsumptionCache)
+    member val TypeSubsumptionCache: Cache<TTypeCacheKey, bool> =
+        typeSubsumptionCaches.GetOrCreate(g, createTypeSubsumptionCache)
 
 let CanImportILScopeRef (env: ImportMap) m scoref =
 

src/Compiler/Utilities/Caches.fs

@@ -5,9 +5,12 @@ open System
 open System.Collections.Generic
 open System.Collections.Concurrent
 open System.Threading
+open System.Threading.Tasks
 open System.Diagnostics
 open System.Diagnostics.Metrics
 
+open FSharp.Compiler.Diagnostics
+
 [<Struct; RequireQualifiedAccess; NoComparison>]
 type EvictionMethod =
     | Background
@@ -154,7 +157,7 @@ type Cache<'Key, 'Value when 'Key: not null and 'Key: equality> internal (option
 
     let cacheHit = Event<unit>()
     let cacheMiss = Event<unit>()
-    let eviction = Event<unit>()
+    let eviction = Event<'Value>()
     let evictionFail = Event<unit>()
     let overCapacity = Event<unit>()
 
@@ -181,7 +184,7 @@ type Cache<'Key, 'Value when 'Key: not null and 'Key: equality> internal (option
             | true, removed ->
                 evictionQueue.Remove(removed)
                 pool.Reclaim(removed)
-                eviction.Trigger()
+                eviction.Trigger(removed.Value)
             | _ ->
                 failwith "eviction fail"
                 evictionFail.Trigger()
@@ -230,6 +233,17 @@ type Cache<'Key, 'Value when 'Key: not null and 'Key: equality> internal (option
             pool.Reclaim(cachedEntity)
             false
 
+    member this.GetOrCreate(key: 'Key, valueFactory: 'Key -> 'Value) =
+        match this.TryGetValue(key) with
+        | true, value -> value
+        | _ ->
+            let value = valueFactory key
+            this.TryAdd(key, value) |> ignore
+            value
+
+    [<CLIEvent>]
+    member val ValueEvicted = eviction.Publish
+
     interface ICacheEvents with
 
         [<CLIEvent>]
@@ -239,7 +253,7 @@ type Cache<'Key, 'Value when 'Key: not null and 'Key: equality> internal (option
         member val CacheMiss = cacheMiss.Publish
 
         [<CLIEvent>]
-        member val Eviction = eviction.Publish
+        member val Eviction = eviction.Publish |> Event.map ignore
 
         [<CLIEvent>]
         member val EvictionFail = evictionFail.Publish
@@ -249,14 +263,12 @@ type Cache<'Key, 'Value when 'Key: not null and 'Key: equality> internal (option
 
     interface IDisposable with
         member this.Dispose() =
+            store.Clear()
             cts.Cancel()
             CacheInstrumentation.RemoveInstrumentation(this)
-            GC.SuppressFinalize(this)
 
     member this.Dispose() = (this :> IDisposable).Dispose()
 
-    override this.Finalize() : unit = this.Dispose()
-
     member this.GetStats() = CacheInstrumentation.GetStats(this)
 
 and CacheInstrumentation(cache: ICacheEvents) =
@@ -367,8 +379,8 @@ module Cache =
 
         let options =
             match Environment.GetEnvironmentVariable(overrideVariable) with
-            | null -> options
-            | _ -> { options with MaximumCapacity = 1024 }
+            | NonNull _ when options.MaximumCapacity > 1024 -> { options with MaximumCapacity = 1024 }
+            | _ -> options
 
         // Increase expected capacity by the percentage to evict, since we want to not resize the dictionary.
         let capacity =

src/Compiler/Utilities/Caches.fsi

@@ -58,8 +58,12 @@ type internal Cache<'Key, 'Value when 'Key: not null and 'Key: equality> =
     new: options: CacheOptions * capacity: int * cts: CancellationTokenSource -> Cache<'Key, 'Value>
     member TryGetValue: key: 'Key * value: outref<'Value> -> bool
     member TryAdd: key: 'Key * value: 'Value -> bool
-    member Dispose: unit -> unit
+    member GetOrCreate: key: 'Key * valueFactory: ('Key -> 'Value) -> 'Value
     member GetStats: unit -> string
+    member Dispose: unit -> unit
+
+    [<CLIEvent>]
+    member ValueEvicted: IEvent<'Value>
 
     interface ICacheEvents
     interface IDisposable