fix: load configured large solutions promptly

Author: govert

CHANGELOG.md

@@ -16,6 +16,17 @@ All notable changes to this project will be documented in this file.
 ### Known issues
 - _None yet._
 
+## 0.1.20
+
+### Fixed
+- Configured `vbnet.workspace.solutionPath` and `vbnet.workspace.projectPaths` are now honored before broad workspace `.vbproj` discovery, avoiding large-repository scans before loading the selected solution.
+- Workspace loads started by `workspace/didChangeConfiguration` now run in the same cancelable background path as initial startup loads, so configuration notifications cannot block later LSP requests during a long solution load.
+- Open documents no longer publish standalone missing-reference diagnostics while the initial workspace load is still pending; diagnostics are deferred until the document can be associated with the loaded Roslyn workspace.
+- Deferred project loading now preserves the workspace root so enabling `loadProjectsOnStart` from configuration can start the workspace load later.
+
+### Known issues
+- Very large solutions can still take time for Roslyn/MSBuildWorkspace to fully load; language features may be limited until the background workspace load completes.
+
 ## 0.1.19
 
 ### Fixed

src/VbNet.LanguageServer.Vb/Core/LanguageServer.vb

@@ -86,7 +86,7 @@ Namespace Core
         ''' <summary>
         ''' Server version reported in initialize response.
         ''' </summary>
-        Public Const ServerVersion As String = "0.1.19"
+        Public Const ServerVersion As String = "0.1.20"
 
         Public Sub New(transport As ITransport, loggerFactory As ILoggerFactory)
             If transport Is Nothing Then
@@ -488,18 +488,20 @@ Namespace Core
             _workspaceManager.Initialize()
             ApplyInitializationOptions()
 
+            If _initializeParams?.RootUri IsNot Nothing Then
+                _workspaceRootUri = _initializeParams.RootUri
+            ElseIf _initializeParams?.WorkspaceFolders IsNot Nothing AndAlso _initializeParams.WorkspaceFolders.Length > 0 Then
+                _workspaceRootUri = _initializeParams.WorkspaceFolders(0).Uri
+            End If
+
             If Not _loadProjectsOnStart Then
                 _logger.LogInformation("Project load deferred (vbnet.loadProjectsOnStart = false).")
                 _workspaceManager.SignalInitialLoadCompleted(False)
                 Return Task.CompletedTask
             End If
 
-            If _initializeParams?.RootUri IsNot Nothing Then
-                _workspaceRootUri = _initializeParams.RootUri
-                StartInitialWorkspaceLoad(_initializeParams.RootUri)
-            ElseIf _initializeParams?.WorkspaceFolders IsNot Nothing AndAlso _initializeParams.WorkspaceFolders.Length > 0 Then
-                _workspaceRootUri = _initializeParams.WorkspaceFolders(0).Uri
-                StartInitialWorkspaceLoad(_initializeParams.WorkspaceFolders(0).Uri)
+            If _workspaceRootUri IsNot Nothing Then
+                StartInitialWorkspaceLoad(_workspaceRootUri)
             Else
                 _logger.LogWarning("No workspace root provided, operating in single-file mode")
                 _workspaceManager.SignalInitialLoadCompleted(False)
@@ -509,20 +511,28 @@ Namespace Core
         End Function
 
         Private Sub StartInitialWorkspaceLoad(rootUri As String)
+            StartWorkspaceLoad(rootUri, "Initial workspace load", False)
+        End Sub
+
+        Private Sub StartWorkspaceLoad(rootUri As String, operationName As String, resetWorkspace As Boolean)
             CancelWorkspaceLoad()
 
             Dim loadCts = CancellationTokenSource.CreateLinkedTokenSource(_shutdownCts.Token)
             Dim loadTask = Task.Run(
                 Async Function()
                     Try
-                        _logger.LogInformation("Initial workspace load started in background")
+                        _logger.LogInformation("{Operation} started in background", operationName)
+                        If resetWorkspace Then
+                            Await _workspaceManager.ResetWorkspaceAsync(loadCts.Token).ConfigureAwait(False)
+                        End If
+
                         Await LoadWorkspaceAsync(rootUri, loadCts.Token).ConfigureAwait(False)
-                        _logger.LogInformation("Initial workspace load completed")
+                        _logger.LogInformation("{Operation} completed", operationName)
                     Catch ex As OperationCanceledException When loadCts.IsCancellationRequested
-                        _logger.LogInformation("Initial workspace load cancelled")
+                        _logger.LogInformation("{Operation} cancelled", operationName)
                         _workspaceManager.SignalInitialLoadCompleted(False)
                     Catch ex As Exception
-                        _logger.LogError(ex, "Initial workspace load failed")
+                        _logger.LogError(ex, "{Operation} failed", operationName)
                         _workspaceManager.SignalInitialLoadCompleted(False)
                     End Try
                 End Function)
@@ -538,6 +548,12 @@ Namespace Core
             End SyncLock
         End Sub
 
+        Private Function IsWorkspaceLoadRunning() As Boolean
+            SyncLock _workspaceLoadGate
+                Return _workspaceLoadTask IsNot Nothing AndAlso Not _workspaceLoadTask.IsCompleted
+            End SyncLock
+        End Function
+
         Private Sub CancelWorkspaceLoad()
             Dim loadCts As CancellationTokenSource = Nothing
 
@@ -574,18 +590,10 @@ Namespace Core
                     Return
                 End If
 
-                Dim projectSearchRoots = GetProjectSearchRoots(rootPath)
-                Dim vbprojFiles = CollectVbProjFiles(
-                    projectSearchRoots,
-                    _workspaceExcludePaths,
-                    _workspaceMaxProjectResults,
-                    ct)
-
-                Await ReportNetFxSupportWarningsAsync(vbprojFiles, ct).ConfigureAwait(False)
-
                 If Not String.IsNullOrWhiteSpace(_workspaceSolutionPathOverride) Then
                     Dim explicitSolutionPath = ResolvePath(_workspaceSolutionPathOverride, rootPath)
                     If Not String.IsNullOrEmpty(explicitSolutionPath) Then
+                        _logger.LogInformation("Using configured solution path: {Path}", explicitSolutionPath)
                         Dim explicitProjects = GetSolutionProjectPaths(explicitSolutionPath)
                         Await ReportNetFxSupportWarningsAsync(explicitProjects, ct).ConfigureAwait(False)
                         loadSucceeded = Await _workspaceManager.LoadSolutionAsync(explicitSolutionPath, ct).ConfigureAwait(False)
@@ -595,23 +603,19 @@ Namespace Core
 
                 If _workspaceProjectPathsOverride IsNot Nothing AndAlso _workspaceProjectPathsOverride.Length > 0 Then
                     Dim anyLoaded = False
-                    Await ReportNetFxSupportWarningsAsync(_workspaceProjectPathsOverride, ct).ConfigureAwait(False)
-                    Dim loadedCount = 0
-                    For Each projectPath In _workspaceProjectPathsOverride
-                        If String.IsNullOrWhiteSpace(projectPath) OrElse Not projectPath.EndsWith(".vbproj", StringComparison.OrdinalIgnoreCase) Then
-                            Continue For
-                        End If
+                    Dim resolvedProjectPaths = _workspaceProjectPathsOverride _
+                        .Select(Function(projectPath) ResolvePath(projectPath, rootPath)) _
+                        .Where(Function(projectPath) Not String.IsNullOrWhiteSpace(projectPath) AndAlso projectPath.EndsWith(".vbproj", StringComparison.OrdinalIgnoreCase)) _
+                        .ToList()
 
+                    Await ReportNetFxSupportWarningsAsync(resolvedProjectPaths, ct).ConfigureAwait(False)
+                    Dim loadedCount = 0
+                    For Each resolved In resolvedProjectPaths
                         If _workspaceMaxProjectCount > 0 AndAlso loadedCount >= _workspaceMaxProjectCount Then
                             _logger.LogWarning("Project load capped at {Max} projects (vbnet.maxProjectCount).", _workspaceMaxProjectCount)
                             Exit For
                         End If
 
-                        Dim resolved = ResolvePath(projectPath, rootPath)
-                        If String.IsNullOrEmpty(resolved) Then
-                            Continue For
-                        End If
-
                         Dim loaded = Await _workspaceManager.LoadProjectAsync(resolved, ct).ConfigureAwait(False)
                         anyLoaded = anyLoaded OrElse loaded
                         If loaded Then
@@ -626,6 +630,7 @@ Namespace Core
                     Return
                 End If
 
+                Dim vbprojFiles As List(Of String) = Nothing
                 If Not _ignoreSolutionFiles Then
                     Dim solutionCandidates = FindSolutionCandidates(rootPath)
                     If solutionCandidates.Count > 0 Then
@@ -645,6 +650,15 @@ Namespace Core
                     End If
                 End If
 
+                Dim projectSearchRoots = GetProjectSearchRoots(rootPath)
+                vbprojFiles = CollectVbProjFiles(
+                    projectSearchRoots,
+                    _workspaceExcludePaths,
+                    _workspaceMaxProjectResults,
+                    ct)
+
+                Await ReportNetFxSupportWarningsAsync(vbprojFiles, ct).ConfigureAwait(False)
+
                 If _workspaceMaxProjectResults > 0 AndAlso vbprojFiles.Count >= _workspaceMaxProjectResults Then
                     _logger.LogInformation("Project search capped at {Max} results", _workspaceMaxProjectResults)
                 End If
@@ -890,13 +904,16 @@ Namespace Core
 
             If _loadProjectsOnStart AndAlso needReload AndAlso _workspaceRootUri IsNot Nothing Then
                 _logger.LogInformation("Workspace configuration changed; reloading workspace")
-                Await _workspaceManager.ResetWorkspaceAsync(ct).ConfigureAwait(False)
-                Await LoadWorkspaceAsync(_workspaceRootUri, ct).ConfigureAwait(False)
+                StartWorkspaceLoad(_workspaceRootUri, "Workspace reload", True)
             End If
 
-            If _loadProjectsOnStart AndAlso Not _workspaceManager.IsLoaded AndAlso _workspaceRootUri IsNot Nothing Then
+            If _loadProjectsOnStart AndAlso
+               Not needReload AndAlso
+               Not _workspaceManager.IsLoaded AndAlso
+               Not IsWorkspaceLoadRunning() AndAlso
+               _workspaceRootUri IsNot Nothing Then
                 _logger.LogInformation("Project loading enabled after configuration change; loading workspace")
-                Await LoadWorkspaceAsync(_workspaceRootUri, ct).ConfigureAwait(False)
+                StartWorkspaceLoad(_workspaceRootUri, "Workspace load after configuration change", False)
             End If
         End Function
 

src/VbNet.LanguageServer.Vb/Services/DiagnosticsService.vb

@@ -180,6 +180,11 @@ Namespace Services
         Public Async Function GetDiagnosticsAsync(uri As String, Optional cancellationToken As CancellationToken = Nothing) As Task(Of Protocol.Diagnostic())
             Dim document = _documentManager.GetRoslynDocument(uri)
             If document Is Nothing Then
+                If _workspaceManager.IsInitialLoadPending Then
+                    _logger.LogTrace("No Roslyn document found for: {Uri}. Workspace is still loading; deferring diagnostics.", uri)
+                    Return Array.Empty(Of Protocol.Diagnostic)()
+                End If
+
                 _logger.LogTrace("No Roslyn document found for: {Uri}. Falling back to standalone diagnostics.", uri)
                 Return Await GetStandaloneDiagnosticsAsync(uri, cancellationToken).ConfigureAwait(False)
             End If

src/VbNet.LanguageServer.Vb/Workspace/WorkspaceManager.vb

@@ -68,6 +68,15 @@ Namespace Workspace
             End Get
         End Property
 
+        ''' <summary>
+        ''' Gets whether the initial workspace load has started but not completed.
+        ''' </summary>
+        Public ReadOnly Property IsInitialLoadPending As Boolean
+            Get
+                Return _workspace IsNot Nothing AndAlso Not _initialLoadTcs.Task.IsCompleted
+            End Get
+        End Property
+
         ''' <summary>
         ''' Gets the path of the loaded solution, if any.
         ''' </summary>

src/extension/CHANGELOG.md

@@ -16,6 +16,17 @@ All notable changes to this project will be documented in this file.
 ### Known issues
 - _None yet._
 
+## 0.1.20
+
+### Fixed
+- Configured `vbnet.workspace.solutionPath` and `vbnet.workspace.projectPaths` are now honored before broad workspace `.vbproj` discovery, avoiding large-repository scans before loading the selected solution.
+- Workspace loads started by `workspace/didChangeConfiguration` now run in the same cancelable background path as initial startup loads, so configuration notifications cannot block later LSP requests during a long solution load.
+- Open documents no longer publish standalone missing-reference diagnostics while the initial workspace load is still pending; diagnostics are deferred until the document can be associated with the loaded Roslyn workspace.
+- Deferred project loading now preserves the workspace root so enabling `loadProjectsOnStart` from configuration can start the workspace load later.
+
+### Known issues
+- Very large solutions can still take time for Roslyn/MSBuildWorkspace to fully load; language features may be limited until the background workspace load completes.
+
 ## 0.1.19
 
 ### Fixed

src/extension/package-lock.json

@@ -1,7 +1,7 @@
 {
   "name": "vbnet-language-support",
   "publisher": "dnakode",
-  "version": "0.1.19",
+  "version": "0.1.20",
   "description": "First-class VB.NET language support for VS Code",
   "displayName": "VB.NET Language Support",
   "icon": "images/vbnet-icon.png",

src/extension/package.json

@@ -142,6 +142,50 @@ Namespace VbNet.LanguageServer.Tests.Integration
             End Using
         End Function
 
+        <Fact>
+        Public Async Function DidChangeConfiguration_DoesNotBlockShutdownWhileWorkspaceLoads() As Task
+            Dim transport As New QueuedTransport()
+            Dim server As New LspServer(transport, NullLoggerFactory.Instance)
+            Dim loadStarted As New TaskCompletionSource(Of Object)(TaskCreationOptions.RunContinuationsAsynchronously)
+
+            server.TestBeforeWorkspaceLoadAsync =
+                Async Function(ct)
+                    loadStarted.TrySetResult(Nothing)
+                    Await Task.Delay(TimeSpan.FromSeconds(30), ct).ConfigureAwait(False)
+                End Function
+
+            Using runCts As New CancellationTokenSource()
+                Dim runTask = server.RunAsync(runCts.Token)
+
+                Try
+                    Dim rootUri = New Uri(TestProjectsRoot & Path.DirectorySeparatorChar).AbsoluteUri
+                    Dim initializeMessage =
+                        "{""jsonrpc"":""2.0"",""id"":1,""method"":""initialize"",""params"":{""rootUri"":" &
+                        JsonSerializer.Serialize(rootUri) &
+                        ",""clientInfo"":{""name"":""test"",""version"":""1.0""},""initializationOptions"":{""loadProjectsOnStart"":false}}}"
+
+                    transport.EnqueueMessage(initializeMessage)
+                    Await WaitForResponseIdAsync(transport, 1).ConfigureAwait(False)
+
+                    transport.EnqueueMessage("{""jsonrpc"":""2.0"",""method"":""initialized"",""params"":{}}")
+                    transport.EnqueueMessage("{""jsonrpc"":""2.0"",""method"":""workspace/didChangeConfiguration"",""params"":{""settings"":{""vbnet"":{""loadProjectsOnStart"":true}}}}")
+                    Await WaitWithTimeoutAsync(loadStarted.Task, TimeSpan.FromSeconds(3)).ConfigureAwait(False)
+
+                    transport.EnqueueMessage("{""jsonrpc"":""2.0"",""id"":2,""method"":""shutdown""}")
+                    Dim shutdownResponse = Await WaitForResponseIdAsync(transport, 2).ConfigureAwait(False)
+                    Assert.Contains("""id"":2", shutdownResponse)
+
+                    transport.EnqueueMessage("{""jsonrpc"":""2.0"",""method"":""exit""}")
+                    transport.Complete()
+                    Await WaitWithTimeoutAsync(runTask, TimeSpan.FromSeconds(3)).ConfigureAwait(False)
+                Finally
+                    transport.Complete()
+                    runCts.Cancel()
+                    server.DisposeAsync().AsTask().GetAwaiter().GetResult()
+                End Try
+            End Using
+        End Function
+
         Private Shared Async Function WaitForResponseIdAsync(transport As QueuedTransport, id As Integer) As Task(Of String)
             Using timeoutCts As New CancellationTokenSource(TimeSpan.FromSeconds(3))
                 While True

test/VbNet.LanguageServer.Tests.Vb/Integration/LanguageServerIntegrationTests.vb

@@ -105,6 +105,31 @@ Namespace VbNet.LanguageServer.Tests.Services
             Assert.Equal(uri, published.Uri)
         End Function
 
+        <Fact>
+        Public Async Function ComputeAndPublishDiagnosticsAsync_DefersStandaloneDiagnosticsWhileInitialLoadPending() As Task
+            Dim uri = "file:///c:/test/module1.vb"
+
+            _workspaceManager.Initialize()
+            _diagnosticsService.Enabled = False
+            _documentManager.HandleDidOpen(New DidOpenTextDocumentParams With {
+                .TextDocument = New TextDocumentItem With {
+                    .Uri = uri,
+                    .LanguageId = "vb",
+                    .Version = 1,
+                    .Text = "Imports MissingNamespace" & vbLf &
+                            "Module Module1" & vbLf &
+                            "End Module"
+                }
+            })
+
+            _diagnosticsService.Enabled = True
+            Await _diagnosticsService.ComputeAndPublishDiagnosticsAsync(uri)
+
+            Assert.Single(_publishedDiagnostics)
+            Assert.Equal(uri, _publishedDiagnostics(0).Uri)
+            Assert.Empty(_publishedDiagnostics(0).Diagnostics)
+        End Function
+
         <Fact>
         Public Async Function ComputeAndPublishDiagnosticsAsync_DoesNothingWhenDisabled() As Task
             Dim uri = "file:///c:/test/module1.vb"