diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Await.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Await.cs
index f1aa5cb04749e85c89dc1d9b29841dcffe82232d..7dc31ba7efffd79852dfdde18fe353ada84e2302 100644
--- a/src/Compilers/CSharp/Portable/Binder/Binder_Await.cs
+++ b/src/Compilers/CSharp/Portable/Binder/Binder_Await.cs
@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 
@@ -134,9 +135,8 @@ private bool ContextForbidsAwait
         /// Reports an error if the await expression did not occur in an async context.
         /// </summary>
         /// <returns>True if the expression contains errors.</returns>
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "'await without async' refers to the error scenario.")]
         private bool ReportBadAwaitWithoutAsync(Location location, DiagnosticBag diagnostics)
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
         {
             DiagnosticInfo info = null;
             var containingMemberOrLambda = this.ContainingMemberOrLambda;
diff --git a/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncRewriter.AsyncIteratorRewriter.cs b/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncRewriter.AsyncIteratorRewriter.cs
index 6907b436ce5836c267050698f6cb24625d47505f..24d39b479e8af77745f6197f16977d93078bb85c 100644
--- a/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncRewriter.AsyncIteratorRewriter.cs
+++ b/src/Compilers/CSharp/Portable/Lowering/AsyncRewriter/AsyncRewriter.AsyncIteratorRewriter.cs
@@ -4,6 +4,7 @@
 
 using System.Collections.Immutable;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using Microsoft.CodeAnalysis.CodeGen;
 using Microsoft.CodeAnalysis.CSharp.Symbols;
@@ -256,9 +257,8 @@ protected override BoundStatement GenerateStateMachineCreation(LocalSymbol state
             /// <summary>
             /// Generates the `ValueTask&lt;bool> MoveNextAsync()` method.
             /// </summary>
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+            [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "Standard naming convention for generating 'IAsyncEnumerator.MoveNextAsync'")]
             private void GenerateIAsyncEnumeratorImplementation_MoveNextAsync()
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
             {
                 // Produce:
                 //  if (state == StateMachineStates.FinishedStateMachine)
@@ -386,9 +386,8 @@ private void GenerateIAsyncEnumeratorImplementation_MoveNextAsync()
             /// Generates the `ValueTask IAsyncDisposable.DisposeAsync()` method.
             /// The DisposeAsync method should not be called from states -1 (running) or 0-and-up (awaits).
             /// </summary>
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+            [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "Standard naming convention for generating 'IAsyncDisposable.DisposeAsync'")]
             private void GenerateIAsyncDisposable_DisposeAsync()
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
             {
                 // Produce:
                 //  if (state >= StateMachineStates.NotStartedStateMachine /* -3 */)
diff --git a/src/Compilers/Core/Portable/Syntax/SyntaxTree.cs b/src/Compilers/Core/Portable/Syntax/SyntaxTree.cs
index 2ac12ec332d9b95150c94a6b7d1bcf6f6866c3e6..6a23d7f7fc4dde0b07e2c643290008be65247647 100644
--- a/src/Compilers/Core/Portable/Syntax/SyntaxTree.cs
+++ b/src/Compilers/Core/Portable/Syntax/SyntaxTree.cs
@@ -6,6 +6,7 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
 using System.Text;
 using System.Threading;
@@ -152,9 +153,8 @@ public Task<SyntaxNode> GetRootAsync(CancellationToken cancellationToken = defau
         /// <summary>
         /// Gets the root node of the syntax tree asynchronously.
         /// </summary>
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "Public API.")]
         protected abstract Task<SyntaxNode> GetRootAsyncCore(CancellationToken cancellationToken);
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
 
         /// <summary>
         /// Create a new syntax tree based off this tree using a new source text.
diff --git a/src/EditorFeatures/Core/Implementation/SmartIndent/IIndentationService.cs b/src/EditorFeatures/Core/Implementation/SmartIndent/IIndentationService.cs
index 3a149deb886629ec72f62e1a40ca5e265bd76bf7..157c7f511e21bea3051f6adb50068a335fd8a278 100644
--- a/src/EditorFeatures/Core/Implementation/SmartIndent/IIndentationService.cs
+++ b/src/EditorFeatures/Core/Implementation/SmartIndent/IIndentationService.cs
@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Host;
@@ -49,9 +50,8 @@ public IndentationResult(int basePosition, int offset) : this()
     [Obsolete("Use Microsoft.CodeAnalysis.Indentation.IIndentationService instead.")]
     internal interface IIndentationService : ILanguageService
     {
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This service is obsolete.")]
         Task<IndentationResult?> GetDesiredIndentation(Document document, int lineNumber, CancellationToken cancellationToken);
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
     }
 
     // Removal of this interface tracked with https://github.com/dotnet/roslyn/issues/35872
diff --git a/src/Features/Core/Portable/EditAndContinue/AbstractEditAndContinueAnalyzer.cs b/src/Features/Core/Portable/EditAndContinue/AbstractEditAndContinueAnalyzer.cs
index d5a8fd5e7e6f501636f952889f4623db6fbed11d..99432b2836ab2e07d7dd913a8203e00e413a1ad0 100644
--- a/src/Features/Core/Portable/EditAndContinue/AbstractEditAndContinueAnalyzer.cs
+++ b/src/Features/Core/Portable/EditAndContinue/AbstractEditAndContinueAnalyzer.cs
@@ -594,9 +594,8 @@ protected virtual string GetSuspensionPointDisplayName(SyntaxNode node, EditKind
         // so we stash them here in plain array (can't use immutable, see the bug) just before we report NFW.
         private static ActiveStatement[]? s_fatalErrorBaseActiveStatements;
 
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "'AnalyzeDocumentAsync' is the name of the method where an error occurred.")]
         private static bool ReportFatalErrorAnalyzeDocumentAsync(ImmutableArray<ActiveStatement> baseActiveStatements, Exception e)
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
         {
             if (!(e is OperationCanceledException))
             {
diff --git a/src/Workspaces/Core/Portable/Editing/DeclarationModifiers.cs b/src/Workspaces/Core/Portable/Editing/DeclarationModifiers.cs
index 67d66d70c01dd012dadab407310d139110fb1949..211f38b6a3fecb801b8b2358f1d399698e3ff073 100644
--- a/src/Workspaces/Core/Portable/Editing/DeclarationModifiers.cs
+++ b/src/Workspaces/Core/Portable/Editing/DeclarationModifiers.cs
@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 
 namespace Microsoft.CodeAnalysis.Editing
 {
@@ -147,9 +148,8 @@ public DeclarationModifiers WithPartial(bool isPartial)
             return new DeclarationModifiers(SetFlag(_modifiers, Modifiers.Partial, isPartial));
         }
 
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "Public API.")]
         public DeclarationModifiers WithAsync(bool isAsync)
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
         {
             return new DeclarationModifiers(SetFlag(_modifiers, Modifiers.Async, isAsync));
         }
diff --git a/src/Workspaces/Core/Portable/Shared/TestHooks/IExpeditableDelaySource.cs b/src/Workspaces/Core/Portable/Shared/TestHooks/IExpeditableDelaySource.cs
index 4bd255d7cd7305e8e143bce503d5f803d49b448b..0629cfcae9e17917efb99cc979a5be1d5a41975d 100644
--- a/src/Workspaces/Core/Portable/Shared/TestHooks/IExpeditableDelaySource.cs
+++ b/src/Workspaces/Core/Portable/Shared/TestHooks/IExpeditableDelaySource.cs
@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -23,8 +24,7 @@ internal interface IExpeditableDelaySource
         /// <para>The <paramref name="delay"/> argument's <see cref="TimeSpan.TotalMilliseconds"/> property is greater than <see cref="int.MaxValue"/>.</para>
         /// </exception>
         /// <exception cref="OperationCanceledException">The delay has been canceled.</exception>
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "Named after 'Task.Delay'")]
         Task<bool> Delay(TimeSpan delay, CancellationToken cancellationToken);
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
     }
 }
diff --git a/src/Workspaces/Core/Portable/Shared/TestHooks/TaskExtensions.cs b/src/Workspaces/Core/Portable/Shared/TestHooks/TaskExtensions.cs
index 54dbfede7287f06e39e0977cfbced5adc3726089..2ce99ac285c07ae06eb9e5d24ed3d25de0b08f87 100644
--- a/src/Workspaces/Core/Portable/Shared/TestHooks/TaskExtensions.cs
+++ b/src/Workspaces/Core/Portable/Shared/TestHooks/TaskExtensions.cs
@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Threading;
 using System.Threading.Tasks;
 using Roslyn.Utilities;
@@ -11,9 +12,8 @@ namespace Microsoft.CodeAnalysis.Shared.TestHooks
 {
     internal static class TaskExtensions
     {
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         public static Task CompletesAsyncOperation(this Task task, IAsyncToken asyncToken)
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
         {
             if (asyncToken is AsynchronousOperationListener.DiagnosticAsyncToken diagnosticToken)
             {
@@ -26,9 +26,8 @@ public static Task CompletesAsyncOperation(this Task task, IAsyncToken asyncToke
         [PerformanceSensitive(
             "https://developercommunity.visualstudio.com/content/problem/854696/changing-target-framework-takes-10-minutes-with-10.html",
             AllowCaptures = false)]
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         public static Task CompletesTrackingOperation(this Task task, IDisposable token)
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
         {
             if (token == null || token == EmptyAsyncToken.Instance)
             {
diff --git a/src/Workspaces/Core/Portable/Utilities/AsyncLazy`1.cs b/src/Workspaces/Core/Portable/Utilities/AsyncLazy`1.cs
index 1cfbbb4bd8bbd827b7df3d40dc79bdae03c71fdb..c3cea313602d9796adcfb31e98a846bd2d8cb103 100644
--- a/src/Workspaces/Core/Portable/Utilities/AsyncLazy`1.cs
+++ b/src/Workspaces/Core/Portable/Utilities/AsyncLazy`1.cs
@@ -480,9 +480,8 @@ private void CompleteWithTask(Task<T> task, CancellationToken cancellationToken)
             }
         }
 
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         private Task<T> GetCachedValueAndCacheThisValueIfNoneCached_NoLock(Task<T> task)
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
         {
             if (_cachedResult != null)
             {
diff --git a/src/Workspaces/Core/Portable/Utilities/SimpleTaskQueue.cs b/src/Workspaces/Core/Portable/Utilities/SimpleTaskQueue.cs
index 7061c189c473f95eeb20feaa9c9cdb15ac3b3760..a4087efb1754aaeb1015509864880c24c553ecca 100644
--- a/src/Workspaces/Core/Portable/Utilities/SimpleTaskQueue.cs
+++ b/src/Workspaces/Core/Portable/Utilities/SimpleTaskQueue.cs
@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -50,9 +51,8 @@ public SimpleTaskQueue(TaskScheduler taskScheduler)
         [PerformanceSensitive(
             "https://developercommunity.visualstudio.com/content/problem/854696/changing-target-framework-takes-10-minutes-with-10.html",
             AllowCaptures = false)]
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         public Task ScheduleTask(Action taskAction, CancellationToken cancellationToken = default)
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
         {
             return ScheduleTaskWorker(
                 (delay, arg) => arg.Item1._latestTask.ContinueWithAfterDelay(arg.taskAction, arg.cancellationToken, delay, TaskContinuationOptions.None, arg.Item1._taskScheduler),
@@ -62,9 +62,8 @@ public Task ScheduleTask(Action taskAction, CancellationToken cancellationToken
         [PerformanceSensitive(
             "https://developercommunity.visualstudio.com/content/problem/854696/changing-target-framework-takes-10-minutes-with-10.html",
             AllowCaptures = false)]
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         public Task<T> ScheduleTask<T>(Func<T> taskFunc, CancellationToken cancellationToken = default)
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
         {
             return ScheduleTaskWorker(
                 (delay, arg) => arg.Item1._latestTask.ContinueWithAfterDelay(arg.taskFunc, arg.cancellationToken, delay, TaskContinuationOptions.None, arg.Item1._taskScheduler),
@@ -74,9 +73,8 @@ public Task<T> ScheduleTask<T>(Func<T> taskFunc, CancellationToken cancellationT
         [PerformanceSensitive(
             "https://developercommunity.visualstudio.com/content/problem/854696/changing-target-framework-takes-10-minutes-with-10.html",
             AllowCaptures = false)]
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         public Task ScheduleTask(Func<Task> taskFuncAsync, CancellationToken cancellationToken = default)
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
         {
             return ScheduleTaskWorker(
                 (delay, arg) => arg.Item1._latestTask.ContinueWithAfterDelayFromAsync(arg.taskFuncAsync, arg.cancellationToken, delay, TaskContinuationOptions.None, arg.Item1._taskScheduler),
@@ -86,9 +84,8 @@ public Task ScheduleTask(Func<Task> taskFuncAsync, CancellationToken cancellatio
         [PerformanceSensitive(
             "https://developercommunity.visualstudio.com/content/problem/854696/changing-target-framework-takes-10-minutes-with-10.html",
             AllowCaptures = false)]
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         public Task<T> ScheduleTask<T>(Func<Task<T>> taskFuncAsync, CancellationToken cancellationToken = default)
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
         {
             return ScheduleTaskWorker(
                 (delay, arg) => arg.Item1._latestTask.ContinueWithAfterDelayFromAsync(arg.taskFuncAsync, arg.cancellationToken, delay, TaskContinuationOptions.None, arg.Item1._taskScheduler),
diff --git a/src/Workspaces/Core/Portable/Utilities/SpecializedTasks.cs b/src/Workspaces/Core/Portable/Utilities/SpecializedTasks.cs
index 5fa55e02f7565a8674bfaa72501a7ace0fdcf7e2..e07b994f521bb3b75594387f63644ae378896939 100644
--- a/src/Workspaces/Core/Portable/Utilities/SpecializedTasks.cs
+++ b/src/Workspaces/Core/Portable/Utilities/SpecializedTasks.cs
@@ -7,6 +7,7 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Immutable;
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
 
@@ -21,44 +22,36 @@ internal static class SpecializedTasks
         [Obsolete("Use Task.CompletedTask instead which is available in the framework.")]
         public static readonly Task EmptyTask = Task.CompletedTask;
 
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         public static Task<T?> AsNullable<T>(this Task<T> task) where T : class
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
             => task!;
 
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         public static Task<T> Default<T>() where T : struct
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
             => TasksOfStruct<T>.Default;
 
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         public static Task<T?> Null<T>() where T : class
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
             => TasksOfClass<T>.Null;
 
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         public static Task<IReadOnlyList<T>> EmptyReadOnlyList<T>()
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
             => EmptyTasks<T>.EmptyReadOnlyList;
 
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         public static Task<IList<T>> EmptyList<T>()
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
             => EmptyTasks<T>.EmptyList;
 
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         public static Task<ImmutableArray<T>> EmptyImmutableArray<T>()
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
             => EmptyTasks<T>.EmptyImmutableArray;
 
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         public static Task<IEnumerable<T>> EmptyEnumerable<T>()
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
             => EmptyTasks<T>.EmptyEnumerable;
 
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         public static Task<T> FromResult<T>(T t) where T : class
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
             => FromResultCache<T>.FromResult(t);
 
         private static class TasksOfStruct<T> where T : struct
@@ -84,9 +77,8 @@ private static class FromResultCache<T> where T : class
             private static readonly ConditionalWeakTable<T, Task<T>> s_fromResultCache = new ConditionalWeakTable<T, Task<T>>();
             private static readonly ConditionalWeakTable<T, Task<T>>.CreateValueCallback s_taskCreationCallback = Task.FromResult<T>;
 
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+            [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
             public static Task<T> FromResult(T t)
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
             {
                 return s_fromResultCache.GetValue(t, s_taskCreationCallback);
             }
diff --git a/src/Workspaces/Core/Portable/Utilities/TaskExtensions.cs b/src/Workspaces/Core/Portable/Utilities/TaskExtensions.cs
index ab8f74ed020fb397105890cf1c0a3a4a96467d54..52cce5b5f2821406b0ec2df02dda150d74b2a38f 100644
--- a/src/Workspaces/Core/Portable/Utilities/TaskExtensions.cs
+++ b/src/Workspaces/Core/Portable/Utilities/TaskExtensions.cs
@@ -110,9 +110,8 @@ public static T WaitAndGetResult_CanCallOnBackground<T>(this Task<T> task, Cance
         // simply changing the default underlying behavior, but rejected that idea because there was
         // a good chance that existing users had already drawn a dependency on the current behavior.
 
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         public static Task SafeContinueWith(
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
             this Task task,
             Action<Task> continuationAction,
             CancellationToken cancellationToken,
@@ -130,9 +129,8 @@ bool continuationFunction(Task antecedent)
             return task.SafeContinueWith(continuationFunction, cancellationToken, continuationOptions, scheduler);
         }
 
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         public static Task<TResult> SafeContinueWith<TInput, TResult>(
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
             this Task<TInput> task,
             Func<Task<TInput>, TResult> continuationFunction,
             CancellationToken cancellationToken,
@@ -142,9 +140,8 @@ bool continuationFunction(Task antecedent)
                 task, continuationFunction, cancellationToken, TaskContinuationOptions.None, scheduler);
         }
 
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         public static Task<TResult> SafeContinueWith<TInput, TResult>(
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
             this Task<TInput> task,
             Func<Task<TInput>, TResult> continuationFunction,
             CancellationToken cancellationToken,
@@ -157,9 +154,8 @@ bool continuationFunction(Task antecedent)
                 (Task antecedent) => continuationFunction((Task<TInput>)antecedent), cancellationToken, continuationOptions, scheduler);
         }
 
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         public static Task SafeContinueWith<TInput>(
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
             this Task<TInput> task,
             Action<Task<TInput>> continuationAction,
             CancellationToken cancellationToken,
@@ -172,9 +168,8 @@ bool continuationFunction(Task antecedent)
                 (Task antecedent) => continuationAction((Task<TInput>)antecedent), cancellationToken, continuationOptions, scheduler);
         }
 
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         public static Task<TResult> SafeContinueWith<TResult>(
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
             this Task task,
             Func<Task, TResult> continuationFunction,
             CancellationToken cancellationToken,
@@ -217,9 +212,8 @@ TResult outerFunction(Task t)
             return task.ContinueWith(outerFunction, cancellationToken, continuationOptions | TaskContinuationOptions.LazyCancellation, scheduler);
         }
 
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         public static Task<TResult> SafeContinueWith<TResult>(
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
             this Task task,
             Func<Task, TResult> continuationFunction,
             CancellationToken cancellationToken,
@@ -228,9 +222,8 @@ TResult outerFunction(Task t)
             return task.SafeContinueWith(continuationFunction, cancellationToken, TaskContinuationOptions.None, scheduler);
         }
 
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         public static Task SafeContinueWith(
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
             this Task task,
             Action<Task> continuationAction,
             TaskScheduler scheduler)
@@ -238,9 +231,8 @@ TResult outerFunction(Task t)
             return task.SafeContinueWith(continuationAction, CancellationToken.None, TaskContinuationOptions.None, scheduler);
         }
 
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         public static Task SafeContinueWith<TInput>(
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
             this Task<TInput> task,
             Action<Task<TInput>> continuationFunction,
             TaskScheduler scheduler)
@@ -248,9 +240,8 @@ TResult outerFunction(Task t)
             return task.SafeContinueWith(continuationFunction, CancellationToken.None, TaskContinuationOptions.None, scheduler);
         }
 
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         public static Task<TResult> SafeContinueWith<TInput, TResult>(
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
             this Task<TInput> task,
             Func<Task<TInput>, TResult> continuationFunction,
             TaskScheduler scheduler)
@@ -258,9 +249,8 @@ TResult outerFunction(Task t)
             return task.SafeContinueWith(continuationFunction, CancellationToken.None, TaskContinuationOptions.None, scheduler);
         }
 
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         public static Task SafeContinueWith(
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
             this Task task,
             Action<Task> continuationAction,
             CancellationToken cancellationToken,
@@ -270,9 +260,8 @@ TResult outerFunction(Task t)
         }
 
         // Code provided by Stephen Toub.
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         public static Task<TResult> ContinueWithAfterDelay<TInput, TResult>(
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
             this Task<TInput> task,
             Func<Task<TInput>, TResult> continuationFunction,
             CancellationToken cancellationToken,
@@ -288,9 +277,8 @@ TResult outerFunction(Task t)
                 cancellationToken, taskContinuationOptions, scheduler).Unwrap();
         }
 
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         public static Task<TNResult> ContinueWithAfterDelay<TNResult>(
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
             this Task task,
             Func<TNResult> continuationFunction,
             CancellationToken cancellationToken,
@@ -306,9 +294,8 @@ TResult outerFunction(Task t)
                 cancellationToken, taskContinuationOptions, scheduler).Unwrap();
         }
 
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         public static Task<TNResult> ContinueWithAfterDelay<TNResult>(
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
             this Task task,
             Func<Task, TNResult> continuationFunction,
             CancellationToken cancellationToken,
@@ -324,9 +311,8 @@ TResult outerFunction(Task t)
                 cancellationToken, taskContinuationOptions, scheduler).Unwrap();
         }
 
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         public static Task ContinueWithAfterDelay(
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
             this Task task,
             Action continuationAction,
             CancellationToken cancellationToken,
diff --git a/src/Workspaces/Core/Portable/Utilities/TaskFactoryExtensions.cs b/src/Workspaces/Core/Portable/Utilities/TaskFactoryExtensions.cs
index f06b7a52ee91e32444ca34ec68819bf8eb7737b3..6e13a29b4eaaa8b7a8b970cbaa38f8b16e51c1a7 100644
--- a/src/Workspaces/Core/Portable/Utilities/TaskFactoryExtensions.cs
+++ b/src/Workspaces/Core/Portable/Utilities/TaskFactoryExtensions.cs
@@ -12,12 +12,11 @@ namespace Roslyn.Utilities
 {
     // TODO: revisit https://github.com/dotnet/roslyn/issues/39222
 
-    [SuppressMessage("ApiDesign", "CA1068", Justification = "Matching TPL Signatures")]
+    [SuppressMessage("ApiDesign", "CA1068:CancellationToken parameters must come last", Justification = "Matching TPL Signatures")]
     internal static partial class TaskFactoryExtensions
     {
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         public static Task SafeStartNew(this TaskFactory factory, Action action, CancellationToken cancellationToken, TaskScheduler scheduler)
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
         {
             void wrapped()
             {
@@ -34,9 +33,8 @@ void wrapped()
             return factory.StartNew(wrapped, cancellationToken, TaskCreationOptions.None, scheduler);
         }
 
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         public static Task<TResult> SafeStartNew<TResult>(this TaskFactory factory, Func<TResult> func, CancellationToken cancellationToken, TaskScheduler scheduler)
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
         {
             TResult wrapped()
             {
diff --git a/src/Workspaces/Core/Portable/Workspace/Host/TaskScheduler/IWorkspaceTaskScheduler.cs b/src/Workspaces/Core/Portable/Workspace/Host/TaskScheduler/IWorkspaceTaskScheduler.cs
index 4d68bdd4f2db624583ada04e9033d75a0340da05..f12e619e6f62057affee49f4aa2d8666266681b9 100644
--- a/src/Workspaces/Core/Portable/Workspace/Host/TaskScheduler/IWorkspaceTaskScheduler.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Host/TaskScheduler/IWorkspaceTaskScheduler.cs
@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -16,32 +17,28 @@ internal interface IWorkspaceTaskScheduler
         /// <summary>
         /// Execute the task action on a thread owned by a task scheduler.
         /// </summary>
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         Task ScheduleTask(Action taskAction, string taskName, CancellationToken cancellationToken = default);
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
 
         /// <summary>
         /// Execute the task function on a thread owned by a task scheduler and return the schedule
         /// task that can be used to wait for the result.
         /// </summary>
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         Task<T> ScheduleTask<T>(Func<T> taskFunc, string taskName, CancellationToken cancellationToken = default);
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
 
         /// <summary>
         /// Execute the task function on a thread owned by a task scheduler and return the schedule
         /// task that can be used to wait for the result.
         /// </summary>
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         Task ScheduleTask(Func<Task> taskFunc, string taskName, CancellationToken cancellationToken = default);
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
 
         /// <summary>
         /// Execute the task function on a thread owned by a task scheduler and return the schedule
         /// task that can be used to wait for the result.
         /// </summary>
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         Task<T> ScheduleTask<T>(Func<Task<T>> taskFunc, string taskName, CancellationToken cancellationToken = default);
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
     }
 }
diff --git a/src/Workspaces/Core/Portable/Workspace/Workspace.cs b/src/Workspaces/Core/Portable/Workspace/Workspace.cs
index d85551735a0e9dbe9a558b59947ba229c0767559..3c25f926e3423771866ab48f115205a24142b32f 100644
--- a/src/Workspaces/Core/Portable/Workspace/Workspace.cs
+++ b/src/Workspaces/Core/Portable/Workspace/Workspace.cs
@@ -8,6 +8,7 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -233,9 +234,8 @@ internal void UpdateCurrentSolutionOnOptionsChanged()
         /// <summary>
         /// Executes an action as a background task, as part of a sequential queue of tasks.
         /// </summary>
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         protected internal Task ScheduleTask(Action action, string taskName = "Workspace.Task")
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
         {
             return _taskQueue.ScheduleTask(action, taskName);
         }
@@ -243,9 +243,8 @@ protected internal Task ScheduleTask(Action action, string taskName = "Workspace
         /// <summary>
         /// Execute a function as a background task, as part of a sequential queue of tasks.
         /// </summary>
-#pragma warning disable VSTHRD200 // Use "Async" suffix for async methods
+        [SuppressMessage("Style", "VSTHRD200:Use \"Async\" suffix for async methods", Justification = "This is a Task wrapper, not an asynchronous method.")]
         protected internal Task<T> ScheduleTask<T>(Func<T> func, string taskName = "Workspace.Task")
-#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
         {
             return _taskQueue.ScheduleTask(func, taskName);
         }