Windows CI exposing some problems, try to fix...

Author: Thorium

.github/workflows/CI.yml

@@ -6,6 +6,7 @@ on:
 
 env:
   DOTNET_VERSION: '6.0.428'
+  DOTNET_SDK_VERSION: '10.0.x'
 
 jobs:
   buildAndTestWindows:
@@ -16,9 +17,13 @@ jobs:
     steps:
     - uses: actions/checkout@v4
     - name: Setup .NET
-      uses: actions/setup-dotnet@v3
+      uses: actions/setup-dotnet@v4
       with:
-        dotnet-version: ${{ env.DOTNET_VERSION }}
+        # .NET 6 runtime for the FAKE build tool (net6.0); .NET 10 SDK for the net10.0 targets
+        # and to satisfy global.json. Installed explicitly rather than relying on the runner image.
+        dotnet-version: |
+          ${{ env.DOTNET_VERSION }}
+          ${{ env.DOTNET_SDK_VERSION }}
     - name: Build & Run Tests
       run: |
         .\build.cmd
@@ -41,9 +46,13 @@ jobs:
     steps:
     - uses: actions/checkout@v4
     - name: Setup .NET
-      uses: actions/setup-dotnet@v3
+      uses: actions/setup-dotnet@v4
       with:
-        dotnet-version: ${{ env.DOTNET_VERSION }}
+        # .NET 6 runtime for the FAKE build tool (net6.0); .NET 10 SDK for the net10.0 targets
+        # and to satisfy global.json. Installed explicitly rather than relying on the runner image.
+        dotnet-version: |
+          ${{ env.DOTNET_VERSION }}
+          ${{ env.DOTNET_SDK_VERSION }}
     - name: Build & Run Tests
       run: |
         ./build.sh
@@ -66,9 +75,13 @@ jobs:
     steps:
     - uses: actions/checkout@v4
     - name: Setup .NET
-      uses: actions/setup-dotnet@v3
+      uses: actions/setup-dotnet@v4
       with:
-        dotnet-version: ${{ env.DOTNET_VERSION }}
+        # .NET 6 runtime for the FAKE build tool (net6.0); .NET 10 SDK for the net10.0 targets
+        # and to satisfy global.json. Installed explicitly rather than relying on the runner image.
+        dotnet-version: |
+          ${{ env.DOTNET_VERSION }}
+          ${{ env.DOTNET_SDK_VERSION }}
     - name: Build & Run Tests
       run: |
         ./build.sh

src/SQLProvider.DesignTime/SqlDesignTime.fs

@@ -1288,23 +1288,22 @@ type SqlRuntimeInfo (config : TypeProviderConfig) =
         //| Choice2Of2(paths, errors) -> Assembly.GetExecutingAssembly()
     member __.RuntimeAssembly = runtimeAssembly
 
-/// One generation of provided types for one set of static parameters.
-/// Reference equality so that ConcurrentDictionary.TryUpdate swaps compare generations,
-/// not their (concurrently mutated) field values.
-[<ReferenceEquality>]
-type DesignCacheEntry =
-    { /// The provided root type, when it was built, and how old the build may get before a
-      /// background refresh is started (adapted to build duration on slow systems).
-      Root : Lazy<ProvidedTypeDefinition * DateTime * TimeSpan>
-      /// Last access in UTC ticks. Updated lock-free on every instantiation request;
-      /// entries idle longer than the expiration are dropped to free memory.
-      mutable LastAccess : int64
-      /// 1 while a background refresh build is in flight: at most one refresh per entry,
-      /// no matter how many Visual Studio threads request the type concurrently.
-      mutable Refreshing : int }
-
 module DesignTimeCache =
-    let cache = System.Collections.Concurrent.ConcurrentDictionary<DesignCacheKey,DesignCacheEntry>()
+    /// One lazily-built generation of provided types per set of static parameters, memoized for the
+    /// life of the type-provider instance (the compilation, or the IDE session).
+    ///
+    /// It is deliberately NEVER rebuilt, swapped or evicted while the process lives. Erased provided
+    /// types are compared by reference identity, so if one compilation ever bound some sites to one
+    /// generation and later/other-thread sites to a rebuilt one, the two identical-looking types
+    /// (e.g. 'CustomersEntity', or 'dataContext.mainSchema' vs 'readDataContext.mainSchema') would
+    /// fail to unify (FS0001/FS0193). Both the old background "stale-while-revalidate" swap and the
+    /// idle eviction rebuilt the tree on a timer, and a slow compilation (Windows CI builds net48
+    /// and net10.0 in parallel) crossed that timer mid-build and produced a second generation that
+    /// parallel compiler threads then mixed. The pre-7ffdce22 provider avoided this by keeping its
+    /// provided types alive for the whole process too (DesignTimeCacheSchema); this restores that,
+    /// for the entire type tree. Schema refresh is explicit (ClearDatabaseSchemaCache), which is the
+    /// only way to guarantee a single stable generation per compilation.
+    let cache = System.Collections.Concurrent.ConcurrentDictionary<DesignCacheKey, Lazy<ProvidedTypeDefinition>>()
 
 /// The idea of this is trying to avoid case where compile-time has loaded non-runtime assembly. (Happens in .NET 8.0, not in .NET Framework.)
 /// So let's load compile-time (and design-time) manually the required runtime assembly.
@@ -1523,15 +1522,8 @@ type public SqlTypeProvider(config: TypeProviderConfig) as this =
             args.[12] :?> string,                   // SSDT Path
             typeName)
 
-        // Entries idle longer than this are dropped to free memory. An actively used entry is
-        // never dropped on a timer; instead it is refreshed in the background once its build is
-        // older than its staleness interval, so database schema changes are still picked up
-        // without IntelliSense ever stalling on a synchronous rebuild.
-        let idleExpiration = TimeSpan.FromMinutes 3.0
-
         let buildRoot (args:DesignCacheKey) =
             let struct(_,_,_,_,_,_,_,_,_,_,_,_,_, rootTypeName) = args
-            let buildStarted = DateTime.UtcNow
 
             let rootType = ProvidedTypeDefinition(sqlRuntimeInfo.RuntimeAssembly,FSHARP_DATA_SQL,rootTypeName,Some typeof<obj>, isErased=true)
             let serviceType = ProvidedTypeDefinition( "dataContext", Some typeof<obj>, isErased=true)
@@ -1540,100 +1532,26 @@ type public SqlTypeProvider(config: TypeProviderConfig) as this =
             createTypes rootType serviceType readServiceType config sqlRuntimeInfo invalidate registerDispose args
             createConstructors config (rootType, serviceType, readServiceType, args)
 
-            // Refresh no sooner than the idle expiration, and on a slow system no sooner than
-            // 10x the time a build takes. Fetching the full schema of a big database is heavy;
-            // the staleness window must stay well above the fetch time so a refresh always
-            // finishes long before the next one is due. Otherwise refreshes (each followed by a
-            // re-check) would overlap and build back-pressure that eventually stalls the UI.
-            // The window is derived from this build's own duration, so it adapts as the schema grows.
-            let buildDuration = DateTime.UtcNow - buildStarted
-            let staleAfter = max idleExpiration (TimeSpan.FromTicks(buildDuration.Ticks * 10L))
-            rootType, DateTime.UtcNow, staleAfter
-
-        let dropDesignTimeDcProvider (key:DesignCacheKey) =
-            // Release the design-time data context provider (used by the Individuals feature)
-            // together with its type tree generation, so it cannot pin stale schema in memory.
-            let struct(_,_,_,_,_,_,_,_,_,_,_,_,_, rootTypeName) = key
-            DcCache.providerCache.TryRemove rootTypeName |> ignore
-
-        let rec idleWatcher (key:DesignCacheKey) =
-            async {
-                do! Async.Sleep (int idleExpiration.TotalMilliseconds)
-                match DesignTimeCache.cache.TryGetValue key with
-                | true, entry ->
-                    let lastAccess = DateTime(System.Threading.Interlocked.Read(&entry.LastAccess), DateTimeKind.Utc)
-                    if DateTime.UtcNow - lastAccess >= idleExpiration then
-                        DesignTimeCache.cache.TryRemove key |> ignore
-                        dropDesignTimeDcProvider key
-                    else
-                        do! idleWatcher key
-                | _ -> ()
-            }
-
-        let addCache (key:DesignCacheKey) =
-            { Root =
-                lazy
-                    let generation = buildRoot key
-                    // Only reclaim idle entries in a live host (IDE). In a batch compile
-                    // (fsc/CI, IsInvalidationSupported=false) the process is short-lived and an
-                    // eviction+rebuild would hand out a second generation of erased provided
-                    // types, which then fail to unify against the first.
-                    if config.IsInvalidationSupported then idleWatcher key |> Async.Start
-                    generation
-              LastAccess = DateTime.UtcNow.Ticks
-              Refreshing = 0 }
+            rootType
 
-        try
-            let entry = DesignTimeCache.cache.GetOrAdd(arguments, addCache)
-            System.Threading.Interlocked.Exchange(&entry.LastAccess, DateTime.UtcNow.Ticks) |> ignore
-
-            // Stale-while-revalidate: always serve the current tree; if it has gone stale,
-            // rebuild it once in the background and swap the entry atomically. Callers never
-            // wait on a refresh, and concurrent VS threads can never start a second one.
-            //
-            // Only ever swap generations in a live host (IDE, IsInvalidationSupported=true).
-            // In a batch compile (fsc/CI) the swap is unsafe: erased provided types have
-            // reference identity, so if a long compilation binds some sites to the original
-            // generation and later sites to the swapped-in one, the two identical-looking
-            // 'CustomersEntity' types fail to unify (FS0001/FS0193). Windows CI builds two
-            // target frameworks and so is slow enough to cross the staleness window mid-build,
-            // which is why it fails there while Linux/Mac and warm local builds pass.
-            if config.IsInvalidationSupported && entry.Root.IsValueCreated then
-                let _, builtAt, staleAfter = entry.Root.Value
-                if DateTime.UtcNow - builtAt >= staleAfter
-                   && System.Threading.Interlocked.CompareExchange(&entry.Refreshing, 1, 0) = 0 then
-                    async {
-                        try
-                            try
-                                // 1. Fetch/build the new generation fully in the background. Nothing
-                                //    waits on it: on-demand callers keep getting the previous tree, so
-                                //    a slow big-database schema fetch never blocks the editor.
-                                let freshGeneration = buildRoot arguments
-                                let freshEntry =
-                                    { Root = Lazy<_>.CreateFromValue freshGeneration
-                                      LastAccess = DateTime.UtcNow.Ticks
-                                      Refreshing = 0 }
-                                // 2. Only now that the new generation is ready, invalidate. This makes
-                                //    the host re-check bind straight to the finished tree instead of
-                                //    driving a fresh blocking build on demand. It fires at most once per
-                                //    staleness window (>= 10x the build time), so it cannot churn.
-                                this.Invalidate()
-                                // 3. Publish it. Invalidate() only schedules a later re-check, so the
-                                //    atomic swap always lands before the host re-reads the cache; the
-                                //    re-check then finds a fresh (non-stale) entry and triggers no rebuild.
-                                if DesignTimeCache.cache.TryUpdate(arguments, freshEntry, entry) then
-                                    dropDesignTimeDcProvider arguments
-                            with
-                            | _ -> () // keep serving the previous generation; retried on a later access
-                        finally
-                            System.Threading.Interlocked.Exchange(&entry.Refreshing, 0) |> ignore
-                    } |> Async.Start
+        // Memoize one generation per set of static parameters and always return that same one.
+        // See DesignTimeCache for why it is never rebuilt/swapped/evicted while the process lives.
+        let addCache (key:DesignCacheKey) = lazy (buildRoot key)
 
-            let root, _, _ = entry.Root.Value
-            root
+        // GetOrAdd only allocates the entry (its Lazy is not forced here), so only the build below
+        // needs the poisoned-entry cleanup.
+        let entry = DesignTimeCache.cache.GetOrAdd(arguments, addCache)
+        try
+            entry.Value
         with
-        | e ->
-            DesignTimeCache.cache.TryRemove(arguments) |> ignore
+        | _ ->
+            // The build threw and its Lazy has cached that exception. Drop the poisoned entry so a
+            // genuine transient failure can be retried — but only if it is still the entry we hold,
+            // so we never evict a newer generation another thread has since rebuilt at this key.
+            match DesignTimeCache.cache.TryGetValue arguments with
+            | true, current when System.Object.ReferenceEquals(current, entry) ->
+                DesignTimeCache.cache.TryRemove arguments |> ignore
+            | _ -> ()
             reraise()
     )