Don't block in library code.

src/EditorFeatures/Core/Implementation/IntelliSense/Completion/CompletionProviders/AbstractMemberInsertingCompletionProvider.cs

@@ -2,6 +2,7 @@
 
 using System.Linq;
 using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeGeneration;
 using Microsoft.CodeAnalysis.Completion;
 using Microsoft.CodeAnalysis.Editing;
@@ -25,7 +26,7 @@ internal abstract class AbstractMemberInsertingCompletionProvider : CompletionLi
 
         protected abstract SyntaxToken GetToken(MemberInsertionCompletionItem completionItem, SyntaxTree tree, CancellationToken cancellationToken);
 
-        protected abstract ISymbol GenerateMember(ISymbol member, INamedTypeSymbol containingType, Document document, MemberInsertionCompletionItem item, CancellationToken cancellationToken);
+        protected abstract Task<ISymbol> GenerateMemberAsync(ISymbol member, INamedTypeSymbol containingType, Document document, MemberInsertionCompletionItem item, CancellationToken cancellationToken);
         protected abstract int GetTargetCaretPosition(SyntaxNode caretTarget);
         protected abstract SyntaxNode GetSyntax(SyntaxToken commonSyntaxToken);
 
@@ -44,12 +45,13 @@ public void Commit(CompletionItem completionItem, ITextView textView, ITextBuffe
                 allowCancel: true,
                 action: c =>
             {
-                var newDocument = DetermineNewDocument((MemberInsertionCompletionItem)completionItem, currentSnapshot, c.CancellationToken);
+                var cancellationToken = c.CancellationToken;
+                var newDocument = DetermineNewDocumentAsync((MemberInsertionCompletionItem)completionItem, currentSnapshot, cancellationToken).WaitAndGetResult(cancellationToken);
 
                 // Apply the new document to workspace
-                newDocument.Project.Solution.Workspace.ApplyDocumentChanges(newDocument, c.CancellationToken);
+                newDocument.Project.Solution.Workspace.ApplyDocumentChanges(newDocument, cancellationToken);
 
-                var newRoot = newDocument.GetSyntaxRootAsync(c.CancellationToken).WaitAndGetResult(c.CancellationToken);
+                var newRoot = newDocument.GetSyntaxRootAsync(cancellationToken).WaitAndGetResult(cancellationToken);
 
                 // Attempt to find the inserted node and move the caret appropriately
                 if (newRoot != null)
@@ -74,7 +76,7 @@ public void Commit(CompletionItem completionItem, ITextView textView, ITextBuffe
             });
         }
 
-        private Document DetermineNewDocument(MemberInsertionCompletionItem completionItem, ITextSnapshot textSnapshot, CancellationToken cancellationToken)
+        private async Task<Document> DetermineNewDocumentAsync(MemberInsertionCompletionItem completionItem, ITextSnapshot textSnapshot, CancellationToken cancellationToken)
         {
             // The span we're going to replace
             var line = textSnapshot.GetLineFromLineNumber(completionItem.Line);
@@ -89,7 +91,7 @@ private Document DetermineNewDocument(MemberInsertionCompletionItem completionIt
             var annotatedRoot = tree.GetRoot(cancellationToken).ReplaceToken(token, token.WithAdditionalAnnotations(_otherAnnotation));
             document = document.WithSyntaxRoot(annotatedRoot);
 
-            Document memberContainingDocument = GenerateMemberAndUsings(document, completionItem, line, cancellationToken);
+            var memberContainingDocument = await GenerateMemberAndUsingsAsync(document, completionItem, line, cancellationToken).ConfigureAwait(false);
 
             var insertionRoot = PrepareTreeForMemberInsertion(memberContainingDocument, cancellationToken);
             var insertionText = GenerateInsertionText(memberContainingDocument, cancellationToken);
@@ -106,7 +108,7 @@ private Document DetermineNewDocument(MemberInsertionCompletionItem completionIt
             return Formatter.FormatAsync(document, _annotation, cancellationToken: cancellationToken).WaitAndGetResult(cancellationToken);
         }
 
-        private Document GenerateMemberAndUsings(
+        private async Task<Document> GenerateMemberAndUsingsAsync(
             Document document,
             MemberInsertionCompletionItem completionItem,
             ITextSnapshotLine line,
@@ -124,7 +126,7 @@ private Document DetermineNewDocument(MemberInsertionCompletionItem completionIt
             // CodeGenerationOptions containing before and after
             var options = new CodeGenerationOptions(contextLocation: semanticModel.SyntaxTree.GetLocation(TextSpan.FromBounds(line.Start, line.Start)));
 
-            var generatedMember = GenerateMember(overriddenMember, containingType, document, completionItem, cancellationToken);
+            var generatedMember = await GenerateMemberAsync(overriddenMember, containingType, document, completionItem, cancellationToken).ConfigureAwait(false);
             generatedMember = _annotation.AddAnnotationToSymbol(generatedMember);
 
             Document memberContainingDocument = null;

src/EditorFeatures/Core/Implementation/IntelliSense/Completion/CompletionProviders/AbstractOverrideCompletionProvider.cs

@@ -41,7 +41,7 @@ public override async Task ProduceCompletionListAsync(CompletionListContext cont
             }
         }
 
-        protected override ISymbol GenerateMember(ISymbol newOverriddenMember, INamedTypeSymbol newContainingType, Document newDocument, MemberInsertionCompletionItem completionItem, CancellationToken cancellationToken)
+        protected override async Task<ISymbol> GenerateMemberAsync(ISymbol newOverriddenMember, INamedTypeSymbol newContainingType, Document newDocument, MemberInsertionCompletionItem completionItem, CancellationToken cancellationToken)
         {
             // Figure out what to insert, and do it. Throw if we've somehow managed to get this far and can't.
             var syntaxFactory = newDocument.GetLanguageService<SyntaxGenerator>();
@@ -50,13 +50,13 @@ protected override ISymbol GenerateMember(ISymbol newOverriddenMember, INamedTyp
             var modifiers = completionItem.Modifiers.WithIsUnsafe(completionItem.Modifiers.IsUnsafe | newOverriddenMember.IsUnsafe());
             if (newOverriddenMember.Kind == SymbolKind.Method)
             {
-                return syntaxFactory.OverrideMethod((IMethodSymbol)newOverriddenMember,
-                    modifiers, newContainingType, newDocument, cancellationToken);
+                return await syntaxFactory.OverrideMethodAsync((IMethodSymbol)newOverriddenMember,
+                    modifiers, newContainingType, newDocument, cancellationToken).ConfigureAwait(false);
             }
             else if (newOverriddenMember.Kind == SymbolKind.Property)
             {
-                return syntaxFactory.OverrideProperty((IPropertySymbol)newOverriddenMember,
-                    modifiers, newContainingType, newDocument, cancellationToken);
+                return await syntaxFactory.OverridePropertyAsync((IPropertySymbol)newOverriddenMember,
+                    modifiers, newContainingType, newDocument, cancellationToken).ConfigureAwait(false);
             }
             else
             {

src/EditorFeatures/Core/Implementation/IntelliSense/Completion/CompletionProviders/AbstractPartialCompletionProvider.cs

@@ -63,10 +63,10 @@ public override async Task ProduceCompletionListAsync(CompletionListContext cont
             }
         }
 
-        protected override ISymbol GenerateMember(ISymbol member, INamedTypeSymbol containingType, Document document, MemberInsertionCompletionItem item, CancellationToken cancellationToken)
+        protected override async Task<ISymbol> GenerateMemberAsync(ISymbol member, INamedTypeSymbol containingType, Document document, MemberInsertionCompletionItem item, CancellationToken cancellationToken)
         {
             var syntaxFactory = document.GetLanguageService<SyntaxGenerator>();
-            var semanticModel = document.GetSemanticModelAsync(cancellationToken).WaitAndGetResult(cancellationToken);
+            var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
 
             return CodeGenerationSymbolFactory.CreateMethodSymbol(attributes: new List<AttributeData>(),
                 accessibility: Accessibility.NotApplicable,

src/Workspaces/Core/Portable/Shared/Extensions/ICodeDefinitionFactoryExtensions.cs

@@ -4,6 +4,7 @@
 using System.Collections.Immutable;
 using System.Linq;
 using System.Threading;
+using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeGeneration;
 using Microsoft.CodeAnalysis.Editing;
 using Microsoft.CodeAnalysis.FindSymbols;
@@ -208,7 +209,7 @@ private static bool TryGetValue(IDictionary<string, ISymbol> dictionary, string
             }
         }
 
-        public static IPropertySymbol OverrideProperty(
+        public static async Task<IPropertySymbol> OverridePropertyAsync(
             this SyntaxGenerator codeFactory,
             IPropertySymbol overriddenProperty,
             DeclarationModifiers modifiers,
@@ -225,7 +226,8 @@ private static bool TryGetValue(IDictionary<string, ISymbol> dictionary, string
             // Implement an abstract property by throwing not implemented in accessors.
             if (overriddenProperty.IsAbstract)
             {
-                getBody = codeFactory.CreateThrowNotImplementStatement(document.Project.GetCompilationAsync(cancellationToken).WaitAndGetResult(cancellationToken));
+                var compilation = await document.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);
+                getBody = codeFactory.CreateThrowNotImplementStatement(compilation);
                 setBody = getBody;
             }
             else if (overriddenProperty.IsIndexer() && document.Project.Language == LanguageNames.CSharp)
@@ -247,8 +249,8 @@ private static bool TryGetValue(IDictionary<string, ISymbol> dictionary, string
             {
                 // Call accessors directly if C# overriding VB
                 if (document.Project.Language == LanguageNames.CSharp
-                    && SymbolFinder.FindSourceDefinitionAsync(overriddenProperty, document.Project.Solution, cancellationToken)
-                                    .WaitAndGetResult(CancellationToken.None).Language == LanguageNames.VisualBasic)
+                    && (await SymbolFinder.FindSourceDefinitionAsync(overriddenProperty, document.Project.Solution, cancellationToken).ConfigureAwait(false))
+                        .Language == LanguageNames.VisualBasic)
                 {
                     var getName = overriddenProperty.GetMethod != null ? overriddenProperty.GetMethod.Name : null;
                     var setName = overriddenProperty.SetMethod != null ? overriddenProperty.SetMethod.Name : null;
@@ -351,7 +353,7 @@ private static bool TryGetValue(IDictionary<string, ISymbol> dictionary, string
                 name: overriddenEvent.Name);
         }
 
-        public static IMethodSymbol OverrideMethod(
+        public static async Task<IMethodSymbol> OverrideMethodAsync(
             this SyntaxGenerator codeFactory,
             IMethodSymbol overriddenMethod,
             DeclarationModifiers modifiers,
@@ -362,11 +364,12 @@ private static bool TryGetValue(IDictionary<string, ISymbol> dictionary, string
             // Abstract: Throw not implemented
             if (overriddenMethod.IsAbstract)
             {
+                var compilation = await newDocument.Project.GetCompilationAsync(cancellationToken).ConfigureAwait(false);
                 return CodeGenerationSymbolFactory.CreateMethodSymbol(
                     overriddenMethod,
                     accessibility: overriddenMethod.ComputeResultantAccessibility(newContainingType),
                     modifiers: modifiers,
-                    statements: new[] { codeFactory.CreateThrowNotImplementStatement(newDocument.Project.GetCompilationAsync(cancellationToken).WaitAndGetResult(cancellationToken)) });
+                    statements: new[] { codeFactory.CreateThrowNotImplementStatement(compilation) });
             }
             else
             {