Revert "Remove semantic model keep-alive code in completion (#73844)"

src/EditorFeatures/Core/IntelliSense/AsyncCompletion/CommitManager.cs

@@ -212,7 +212,7 @@ private AsyncCompletionData.CommitResult Commit(
 
         // This might be an item promoted by us, make sure we restore it to the original state first.
         roslynItem = Helpers.DemoteItem(roslynItem);
-        CompletionChange change = null!;
+        CompletionChange change;
 
         // We met an issue when external code threw an OperationCanceledException and the cancellationToken is not canceled.
         // Catching this scenario for further investigations.
@@ -229,10 +229,7 @@ private AsyncCompletionData.CommitResult Commit(
             if (_textView is IDebuggerTextView)
                 roslynItem = ImportCompletionItem.MarkItemToAlwaysFullyQualify(roslynItem);
 
-            _threadingContext.JoinableTaskFactory.Run(async () =>
-            {
-                change = await completionService.GetChangeAsync(document, roslynItem, commitCharacter, cancellationToken).ConfigureAwait(true);
-            });
+            change = completionService.GetChangeAsync(document, roslynItem, commitCharacter, cancellationToken).WaitAndGetResult(cancellationToken);
         }
         catch (OperationCanceledException e) when (e.CancellationToken != cancellationToken && FatalError.ReportAndCatch(e))
         {
@@ -322,11 +319,7 @@ private AsyncCompletionData.CommitResult Commit(
                 var spanToFormat = triggerSnapshotSpan.TranslateTo(subjectBuffer.CurrentSnapshot, SpanTrackingMode.EdgeInclusive);
 
                 // Note: C# always completes synchronously, TypeScript is async
-                var changes = ImmutableArray<TextChange>.Empty;
-                _threadingContext.JoinableTaskFactory.Run(async () =>
-                {
-                    changes = await formattingService.GetFormattingChangesAsync(currentDocument, subjectBuffer, spanToFormat.Span.ToTextSpan(), cancellationToken).ConfigureAwait(true);
-                });
+                var changes = formattingService.GetFormattingChangesAsync(currentDocument, subjectBuffer, spanToFormat.Span.ToTextSpan(), cancellationToken).WaitAndGetResult(cancellationToken);
                 subjectBuffer.ApplyChanges(changes);
             }
         }

src/Features/Core/Portable/Completion/CompletionService.cs

@@ -214,14 +214,14 @@ public virtual TextSpan GetDefaultCompletionListSpan(SourceText text, int caretP
 
         var extensionManager = document.Project.Solution.Workspace.Services.GetRequiredService<IExtensionManager>();
 
-        document = await GetDocumentWithFrozenPartialSemanticsAsync(document, cancellationToken).ConfigureAwait(false);
-
+        // We don't need SemanticModel here, just want to make sure it won't get GC'd before CompletionProviders are able to get it.
+        (document, var semanticModel) = await GetDocumentWithFrozenPartialSemanticsAsync(document, cancellationToken).ConfigureAwait(false);
         var description = await extensionManager.PerformFunctionAsync(
             provider,
             cancellationToken => provider.GetDescriptionAsync(document, item, options, displayOptions, cancellationToken),
             defaultValue: null,
             cancellationToken).ConfigureAwait(false);
-
+        GC.KeepAlive(semanticModel);
         return description;
     }
 
@@ -245,7 +245,8 @@ public virtual async Task<CompletionChange> GetChangeAsync(
         {
             var extensionManager = document.Project.Solution.Workspace.Services.GetRequiredService<IExtensionManager>();
 
-            document = await GetDocumentWithFrozenPartialSemanticsAsync(document, cancellationToken).ConfigureAwait(false);
+            // We don't need SemanticModel here, just want to make sure it won't get GC'd before CompletionProviders are able to get it.
+            (document, var semanticModel) = await GetDocumentWithFrozenPartialSemanticsAsync(document, cancellationToken).ConfigureAwait(false);
 
             var change = await extensionManager.PerformFunctionAsync(
                 provider,
@@ -255,6 +256,7 @@ public virtual async Task<CompletionChange> GetChangeAsync(
             if (change == null)
                 return CompletionChange.Create(new TextChange(new TextSpan(), ""));
 
+            GC.KeepAlive(semanticModel);
             Debug.Assert(item.Span == change.TextChange.Span || item.IsComplexTextEdit);
             return change;
         }

src/Features/Core/Portable/Completion/CompletionService_GetCompletions.cs

@@ -68,7 +68,8 @@ internal virtual async Task<CompletionList> GetCompletionsAsync(
          ImmutableHashSet<string>? roles = null,
          CancellationToken cancellationToken = default)
     {
-        document = await GetDocumentWithFrozenPartialSemanticsAsync(document, cancellationToken).ConfigureAwait(false);
+        // We don't need SemanticModel here, just want to make sure it won't get GC'd before CompletionProviders are able to get it.
+        (document, var semanticModel) = await GetDocumentWithFrozenPartialSemanticsAsync(document, cancellationToken).ConfigureAwait(false);
 
         var text = await document.GetValueTextAsync(cancellationToken).ConfigureAwait(false);
         var completionListSpan = GetDefaultCompletionListSpan(text, caretPosition);
@@ -114,6 +115,8 @@ internal virtual async Task<CompletionList> GetCompletionsAsync(
         var augmentingContexts = await ComputeNonEmptyCompletionContextsAsync(
             document, caretPosition, trigger, options, completionListSpan, augmentingProviders, sharedContext, cancellationToken).ConfigureAwait(false);
 
+        GC.KeepAlive(semanticModel);
+
         // Providers are ordered, but we processed them in our own order.  Ensure that the
         // groups are properly ordered based on the original providers.
         var completionProviderToIndex = GetCompletionProviderToIndex(providers);
@@ -169,20 +172,19 @@ static async Task<ImmutableArray<CompletionProvider>> GetAugmentingProvidersAsyn
     }
 
     /// <summary>
-    /// Returns a document with frozen partial semantic model unless caller is test code require full semantics.
+    /// Returns a document with frozen partial semantic unless we already have a complete compilation available.
     /// Getting full semantic could be costly in certain scenarios and would cause significant delay in completion. 
     /// In most cases we'd still end up with complete document, but we'd consider it an acceptable trade-off even when 
     /// we get into this transient state.
     /// </summary>
-    private async Task<Document> GetDocumentWithFrozenPartialSemanticsAsync(Document document, CancellationToken cancellationToken)
+    private async Task<(Document document, SemanticModel? semanticModel)> GetDocumentWithFrozenPartialSemanticsAsync(Document document, CancellationToken cancellationToken)
     {
         if (_suppressPartialSemantics)
         {
-            var _ = await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false);
-            return document;
+            return (document, await document.GetRequiredSemanticModelAsync(cancellationToken).ConfigureAwait(false));
         }
 
-        return document.WithFrozenPartialSemantics(cancellationToken);
+        return await document.GetFullOrPartialSemanticModelAsync(cancellationToken).ConfigureAwait(false);
     }
 
     private static bool ValidatePossibleTriggerCharacterSet(CompletionTriggerKind completionTriggerKind, IEnumerable<CompletionProvider> triggeredProviders,