From ac635be76b9068806c8ea475d3237dddc2e7dba7 Mon Sep 17 00:00:00 2001
From: David Kean <davkean@microsoft.com>
Date: Mon, 29 Oct 2018 16:56:56 +1100
Subject: [PATCH] Remove thread-safeness from ApplyChangesToWorkspaceContext

This class needs to be made async, which prevents lock from being used in async methods. It does not need to be thread-safe as the only consumer of it, WorkspaceContextHostInstance, prevents overlap.
---
 .../ApplyChangesToWorkspaceContext.cs         | 70 ++++++++-----------
 1 file changed, 30 insertions(+), 40 deletions(-)

diff --git a/src/Microsoft.VisualStudio.ProjectSystem.Managed/ProjectSystem/LanguageServices/ApplyChangesToWorkspaceContext.cs b/src/Microsoft.VisualStudio.ProjectSystem.Managed/ProjectSystem/LanguageServices/ApplyChangesToWorkspaceContext.cs
index c9d50fa1c96..1d98de701c6 100644
--- a/src/Microsoft.VisualStudio.ProjectSystem.Managed/ProjectSystem/LanguageServices/ApplyChangesToWorkspaceContext.cs
+++ b/src/Microsoft.VisualStudio.ProjectSystem.Managed/ProjectSystem/LanguageServices/ApplyChangesToWorkspaceContext.cs
@@ -16,6 +16,11 @@ namespace Microsoft.VisualStudio.ProjectSystem.LanguageServices
     /// <summary>
     ///     Applies <see cref="IProjectVersionedValue{T}"/> values to a <see cref="IWorkspaceProjectContext"/>.
     /// </summary>
+    /// <remarks>
+    ///     This class is not thread-safe and it is up to callers to prevent overlapping of calls to 
+    ///     <see cref="ApplyProjectBuild(IProjectVersionedValue{IProjectSubscriptionUpdate}, bool, CancellationToken)"/> and
+    ///     <see cref="ApplyProjectEvaluation(IProjectVersionedValue{IProjectSubscriptionUpdate}, bool, CancellationToken)"/>.
+    /// </remarks>
     [Export(typeof(IApplyChangesToWorkspaceContext))]
     internal class ApplyChangesToWorkspaceContext : OnceInitializedOnceDisposed, IApplyChangesToWorkspaceContext
     {
@@ -46,35 +51,29 @@ public void Initialize(IWorkspaceProjectContext context)
         {
             Requires.NotNull(context, nameof(context));
 
-            lock (SyncObject)
-            {
-                if (_context != null)
-                    throw new InvalidOperationException("Already initialized.");
+            if (_context != null)
+                throw new InvalidOperationException("Already initialized.");
 
-                _context = context;
+            _context = context;
 
-                EnsureInitialized();
-            }
+            EnsureInitialized();
         }
 
         public void ApplyProjectBuild(IProjectVersionedValue<IProjectSubscriptionUpdate> update, bool isActiveContext, CancellationToken cancellationToken)
         {
             Requires.NotNull(update, nameof(update));
-            
-            lock (SyncObject)
-            {
-                VerifyInitializedAndNotDisposed();
 
-                IProjectChangeDescription projectChange = update.Value.ProjectChanges[ProjectBuildRuleName];
+            VerifyInitializedAndNotDisposed();
 
-                if (projectChange.Difference.AnyChanges)
-                {
-                    IComparable version = GetConfiguredProjectVersion(update);
+            IProjectChangeDescription projectChange = update.Value.ProjectChanges[ProjectBuildRuleName];
 
-                    ProcessOptions(projectChange.After);
-                    ProcessCommandLine(version, projectChange.Difference, isActiveContext, cancellationToken);
-                    ProcessProjectBuildFailure(projectChange.After);
-                }
+            if (projectChange.Difference.AnyChanges)
+            {
+                IComparable version = GetConfiguredProjectVersion(update);
+
+                ProcessOptions(projectChange.After);
+                ProcessCommandLine(version, projectChange.Difference, isActiveContext, cancellationToken);
+                ProcessProjectBuildFailure(projectChange.After);
             }
         }
 
@@ -82,38 +81,29 @@ public void ApplyProjectEvaluation(IProjectVersionedValue<IProjectSubscriptionUp
         {
             Requires.NotNull(update, nameof(update));
 
-            lock (SyncObject)
-            {
-                VerifyInitializedAndNotDisposed();
+            VerifyInitializedAndNotDisposed();
 
-                IComparable version = GetConfiguredProjectVersion(update);
+            IComparable version = GetConfiguredProjectVersion(update);
 
-                ProcessProjectEvaluationHandlers(version, update, isActiveContext, cancellationToken);
-            }
+            ProcessProjectEvaluationHandlers(version, update, isActiveContext, cancellationToken);
         }
 
         public IEnumerable<string> GetProjectEvaluationRules()
         {
-            lock (SyncObject)
-            {
-                VerifyInitializedAndNotDisposed();
+            VerifyInitializedAndNotDisposed();
 
-                return _handlers.Select(e => e.Value)
-                                .OfType<IProjectEvaluationHandler>()
-                                .Select(e => e.ProjectEvaluationRule)
-                                .Distinct(StringComparers.RuleNames)
-                                .ToArray();
-            }
+            return _handlers.Select(e => e.Value)
+                            .OfType<IProjectEvaluationHandler>()
+                            .Select(e => e.ProjectEvaluationRule)
+                            .Distinct(StringComparers.RuleNames)
+                            .ToArray();
         }
 
         public IEnumerable<string> GetProjectBuildRules()
         {
-            lock (SyncObject)
-            {
-                VerifyInitializedAndNotDisposed();
+            VerifyInitializedAndNotDisposed();
 
-                return new string[] { ProjectBuildRuleName };
-            }
+            return new string[] { ProjectBuildRuleName };
         }
 
         protected override void Dispose(bool disposing)
@@ -198,7 +188,7 @@ private void ProcessProjectEvaluationHandlers(IComparable version, IProjectVersi
                     IProjectChangeDescription projectChange = update.Value.ProjectChanges[evaluationHandler.ProjectEvaluationRule];
                     if (!projectChange.Difference.AnyChanges)
                         continue;
-                    
+
                     evaluationHandler.Handle(version, projectChange, isActiveContext, _logger);
                 }
             }