Fix race condition in analyzer driver where multiple threads attempti…

src/Compilers/CSharp/CSharpAnalyzerDriver/CSharpDeclarationComputer.cs

@@ -14,14 +14,14 @@ namespace Microsoft.CodeAnalysis.CSharp
 {
     internal class CSharpDeclarationComputer : DeclarationComputer
     {
-        public static void ComputeDeclarationsInSpan(SemanticModel model, TextSpan span, bool getSymbol, List<DeclarationInfo> builder, CancellationToken cancellationToken)
+        public static void ComputeDeclarationsInSpan(SemanticModel model, TextSpan span, bool getSymbol, ImmutableArray<DeclarationInfo>.Builder builder, CancellationToken cancellationToken)
         {
             ComputeDeclarations(model, model.SyntaxTree.GetRoot(cancellationToken),
                 (node, level) => !node.Span.OverlapsWith(span) || InvalidLevel(level),
                 getSymbol, builder, null, cancellationToken);
         }
 
-        public static void ComputeDeclarationsInNode(SemanticModel model, SyntaxNode node, bool getSymbol, List<DeclarationInfo> builder, CancellationToken cancellationToken, int? levelsToCompute = null)
+        public static void ComputeDeclarationsInNode(SemanticModel model, SyntaxNode node, bool getSymbol, ImmutableArray<DeclarationInfo>.Builder builder, CancellationToken cancellationToken, int? levelsToCompute = null)
         {
             ComputeDeclarations(model, node, (n, level) => InvalidLevel(level), getSymbol, builder, levelsToCompute, cancellationToken);
         }
@@ -41,7 +41,7 @@ private static void ComputeDeclarations(
             SyntaxNode node,
             Func<SyntaxNode, int?, bool> shouldSkip,
             bool getSymbol,
-            List<DeclarationInfo> builder,
+            ImmutableArray<DeclarationInfo>.Builder builder,
             int? levelsToCompute,
             CancellationToken cancellationToken)
         {

src/Compilers/CSharp/Portable/Compilation/CSharpSemanticModel.cs

@@ -4751,12 +4751,12 @@ protected sealed override ISymbol GetDeclaredSymbolCore(SyntaxNode node, Cancell
             return ImmutableArray.Create<ISymbol>();
         }
 
-        internal override void ComputeDeclarationsInSpan(TextSpan span, bool getSymbol, List<DeclarationInfo> builder, CancellationToken cancellationToken)
+        internal override void ComputeDeclarationsInSpan(TextSpan span, bool getSymbol, ImmutableArray<DeclarationInfo>.Builder builder, CancellationToken cancellationToken)
         {
             CSharpDeclarationComputer.ComputeDeclarationsInSpan(this, span, getSymbol, builder, cancellationToken);
         }
 
-        internal override void ComputeDeclarationsInNode(SyntaxNode node, bool getSymbol, List<DeclarationInfo> builder, CancellationToken cancellationToken, int? levelsToCompute = null)
+        internal override void ComputeDeclarationsInNode(SyntaxNode node, bool getSymbol, ImmutableArray<DeclarationInfo>.Builder builder, CancellationToken cancellationToken, int? levelsToCompute = null)
         {
             CSharpDeclarationComputer.ComputeDeclarationsInNode(this, node, getSymbol, builder, cancellationToken, levelsToCompute);
         }

src/Compilers/Core/Portable/Compilation/SemanticModel.cs

@@ -859,12 +859,12 @@ public PreprocessingSymbolInfo GetPreprocessingSymbolInfo(SyntaxNode nameSyntax)
         /// If false, then <see cref="DeclarationInfo.DeclaredSymbol"/> is always null.</param>
         /// <param name="builder">Builder to add declarations.</param>
         /// <param name="cancellationToken">Cancellation token.</param>
-        internal abstract void ComputeDeclarationsInSpan(TextSpan span, bool getSymbol, List<DeclarationInfo> builder, CancellationToken cancellationToken);
+        internal abstract void ComputeDeclarationsInSpan(TextSpan span, bool getSymbol, ImmutableArray<DeclarationInfo>.Builder builder, CancellationToken cancellationToken);
 
         /// <summary>
         /// Takes a node and returns a set of declarations that overlap the node's span.
         /// </summary>
-        internal abstract void ComputeDeclarationsInNode(SyntaxNode node, bool getSymbol, List<DeclarationInfo> builder, CancellationToken cancellationToken, int? levelsToCompute = null);
+        internal abstract void ComputeDeclarationsInNode(SyntaxNode node, bool getSymbol, ImmutableArray<DeclarationInfo>.Builder builder, CancellationToken cancellationToken, int? levelsToCompute = null);
 
         /// <summary>
         /// Takes a Symbol and syntax for one of its declaring syntax reference and returns the topmost syntax node to be used by syntax analyzer.

src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalysisState.cs

@@ -169,7 +169,7 @@ private IEnumerable<ISymbol> GetDeclaredSymbolsInTree(
         {
             var model = getCachedSemanticModel(tree, compilation, cancellationToken);
             var fullSpan = tree.GetRoot(cancellationToken).FullSpan;
-            var declarationInfos = new List<DeclarationInfo>();
+            var declarationInfos = ImmutableArray.CreateBuilder<DeclarationInfo>();
             model.ComputeDeclarationsInSpan(fullSpan, getSymbol: true, builder: declarationInfos, cancellationToken: cancellationToken);
             return declarationInfos.Select(declInfo => declInfo.DeclaredSymbol).Distinct().WhereNotNull();
         }

src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerDriver.CompilationData.cs

@@ -21,14 +21,14 @@ internal class CompilationData
             private readonly Dictionary<SyntaxTree, SemanticModel> _semanticModelsMap;
 
             private readonly Dictionary<SyntaxReference, DeclarationAnalysisData> _declarationAnalysisDataMap;
-            private readonly ObjectPool<DeclarationAnalysisData> _declarationAnalysisDataPool;
+            private readonly ObjectPool<DeclarationAnalysisDataBuilder> _declarationAnalysisDataBuilderPool;
 
             public CompilationData(Compilation comp)
             {
                 _semanticModelsMap = new Dictionary<SyntaxTree, SemanticModel>();
                 this.SuppressMessageAttributeState = new SuppressMessageAttributeState(comp);
                 _declarationAnalysisDataMap = new Dictionary<SyntaxReference, DeclarationAnalysisData>();
-                _declarationAnalysisDataPool = new ObjectPool<DeclarationAnalysisData>(() => new DeclarationAnalysisData());
+                _declarationAnalysisDataBuilderPool = new ObjectPool<DeclarationAnalysisDataBuilder>(() => new DeclarationAnalysisDataBuilder());
             }
 
             public SuppressMessageAttributeState SuppressMessageAttributeState { get; }
@@ -64,31 +64,48 @@ public bool RemoveCachedSemanticModel(SyntaxTree tree)
 
             internal DeclarationAnalysisData GetOrComputeDeclarationAnalysisData(
                 SyntaxReference declaration,
-                Func<Func<DeclarationAnalysisData>, DeclarationAnalysisData> computeDeclarationAnalysisData,
+                Func<Func<DeclarationAnalysisDataBuilder>, DeclarationAnalysisDataBuilder> computeDeclarationAnalysisData,
                 bool cacheAnalysisData)
             {
-                if (!cacheAnalysisData)
+                DeclarationAnalysisDataBuilder dataBuilder = null;
+                try
                 {
-                    return computeDeclarationAnalysisData(_declarationAnalysisDataPool.Allocate);
-                }
+                    if (!cacheAnalysisData)
+                    {
+                        dataBuilder = computeDeclarationAnalysisData(_declarationAnalysisDataBuilderPool.Allocate);
+                        return DeclarationAnalysisData.CreateFrom(dataBuilder);
+                    }
 
-                DeclarationAnalysisData data;
-                lock (_declarationAnalysisDataMap)
-                {
-                    if (_declarationAnalysisDataMap.TryGetValue(declaration, out data))
+                    DeclarationAnalysisData data;
+                    lock (_declarationAnalysisDataMap)
                     {
-                        return data;
+                        if (_declarationAnalysisDataMap.TryGetValue(declaration, out data))
+                        {
+                            return data;
+                        }
                     }
-                }
 
-                data = computeDeclarationAnalysisData(_declarationAnalysisDataPool.Allocate);
+                    dataBuilder = computeDeclarationAnalysisData(_declarationAnalysisDataBuilderPool.Allocate);
 
-                lock (_declarationAnalysisDataMap)
+                    lock (_declarationAnalysisDataMap)
+                    {
+                        if (!_declarationAnalysisDataMap.TryGetValue(declaration, out data))
+                        {
+                            data = DeclarationAnalysisData.CreateFrom(dataBuilder);
+                            _declarationAnalysisDataMap.Add(declaration, data);
+                        }
+                    }
+
+                    return data;
+                }
+                finally
                 {
-                    _declarationAnalysisDataMap[declaration] = data;
+                    if (dataBuilder != null)
+                    {
+                        dataBuilder.Free();
+                        _declarationAnalysisDataBuilderPool.Free(dataBuilder);
+                    }
                 }
-
-                return data;
             }
 
             internal void ClearDeclarationAnalysisData(SyntaxReference declaration)
@@ -102,54 +119,8 @@ internal void ClearDeclarationAnalysisData(SyntaxReference declaration)
                     }
 
                     _declarationAnalysisDataMap.Remove(declaration);
-
-                    declarationData.Free();
-                    _declarationAnalysisDataPool.Free(declarationData);
                 }
             }
         }
-
-        internal class DeclarationAnalysisData
-        {
-            /// <summary>
-            /// GetSyntax() for the given SyntaxReference.
-            /// </summary>
-            public SyntaxNode DeclaringReferenceSyntax { get; set; }
-
-            /// <summary>
-            /// Topmost declaration node for analysis.
-            /// </summary>
-            public SyntaxNode TopmostNodeForAnalysis { get; set; }
-
-            /// <summary>
-            /// All member declarations within the declaration.
-            /// </summary>
-            public List<DeclarationInfo> DeclarationsInNode { get; }
-
-            /// <summary>
-            /// All descendant nodes for syntax node actions.
-            /// </summary>
-            public List<SyntaxNode> DescendantNodesToAnalyze { get; }
-
-            /// <summary>
-            /// Flag indicating if this is a partial analysis.
-            /// </summary>
-            public bool IsPartialAnalysis { get; set; }
-
-            public DeclarationAnalysisData()
-            {
-                this.DeclarationsInNode = new List<DeclarationInfo>();
-                this.DescendantNodesToAnalyze = new List<SyntaxNode>();
-            }
-
-            public void Free()
-            {
-                DeclaringReferenceSyntax = null;
-                TopmostNodeForAnalysis = null;
-                DeclarationsInNode.Clear();
-                DescendantNodesToAnalyze.Clear();
-                IsPartialAnalysis = false;
-            }
-        }
     }
 }

src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerDriver.DeclarationAnalysisData.cs

@@ -0,0 +1,48 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Immutable;
+
+namespace Microsoft.CodeAnalysis.Diagnostics
+{
+    internal abstract partial class AnalyzerDriver : IDisposable
+    {
+        internal sealed class DeclarationAnalysisData
+        {
+            public static DeclarationAnalysisData CreateFrom(DeclarationAnalysisDataBuilder builder) => new DeclarationAnalysisData(builder);
+            private DeclarationAnalysisData(DeclarationAnalysisDataBuilder builder)
+            {
+                DeclaringReferenceSyntax = builder.DeclaringReferenceSyntax;
+                TopmostNodeForAnalysis = builder.TopmostNodeForAnalysis;
+                DeclarationsInNode = builder.DeclarationsInNode.ToImmutable();
+                DescendantNodesToAnalyze = builder.DescendantNodesToAnalyze.ToImmutable();
+                IsPartialAnalysis = builder.IsPartialAnalysis;
+            }
+
+            /// <summary>
+            /// GetSyntax() for the given SyntaxReference.
+            /// </summary>
+            public SyntaxNode DeclaringReferenceSyntax { get; }
+
+            /// <summary>
+            /// Topmost declaration node for analysis.
+            /// </summary>
+            public SyntaxNode TopmostNodeForAnalysis { get; }
+
+            /// <summary>
+            /// All member declarations within the declaration.
+            /// </summary>
+            public ImmutableArray<DeclarationInfo> DeclarationsInNode { get; }
+
+            /// <summary>
+            /// All descendant nodes for syntax node actions.
+            /// </summary>
+            public ImmutableArray<SyntaxNode> DescendantNodesToAnalyze { get; }
+
+            /// <summary>
+            /// Flag indicating if this is a partial analysis.
+            /// </summary>
+            public bool IsPartialAnalysis { get; }
+        }
+    }
+}

src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerDriver.DeclarationAnalysisDataBuilder.cs

@@ -0,0 +1,53 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Immutable;
+
+namespace Microsoft.CodeAnalysis.Diagnostics
+{
+    internal abstract partial class AnalyzerDriver : IDisposable
+    {
+        internal sealed class DeclarationAnalysisDataBuilder
+        {
+            public DeclarationAnalysisDataBuilder()
+            {
+                this.DeclarationsInNode = ImmutableArray.CreateBuilder<DeclarationInfo>();
+                this.DescendantNodesToAnalyze = ImmutableArray.CreateBuilder<SyntaxNode>();
+            }
+
+            /// <summary>
+            /// GetSyntax() for the given SyntaxReference.
+            /// </summary>
+            public SyntaxNode DeclaringReferenceSyntax { get; set; }
+
+            /// <summary>
+            /// Topmost declaration node for analysis.
+            /// </summary>
+            public SyntaxNode TopmostNodeForAnalysis { get; set; }
+
+            /// <summary>
+            /// All member declarations within the declaration.
+            /// </summary>
+            public ImmutableArray<DeclarationInfo>.Builder DeclarationsInNode { get; }
+
+            /// <summary>
+            /// All descendant nodes for syntax node actions.
+            /// </summary>
+            public ImmutableArray<SyntaxNode>.Builder DescendantNodesToAnalyze { get; }
+
+            /// <summary>
+            /// Flag indicating if this is a partial analysis.
+            /// </summary>
+            public bool IsPartialAnalysis { get; set; }
+
+            public void Free()
+            {
+                DeclaringReferenceSyntax = null;
+                TopmostNodeForAnalysis = null;
+                DeclarationsInNode.Clear();
+                DescendantNodesToAnalyze.Clear();
+                IsPartialAnalysis = false;
+            }
+        }
+    }
+}

src/Compilers/Core/Portable/DiagnosticAnalyzer/AnalyzerDriver.cs

@@ -684,7 +684,7 @@ private ImmutableHashSet<ISymbol> ComputeGeneratedCodeSymbolsInTree(SyntaxTree t
             var model = compilation.GetSemanticModel(tree);
             var root = tree.GetRoot(cancellationToken);
             var span = root.FullSpan;
-            var builder = new List<DeclarationInfo>();
+            var builder = ImmutableArray.CreateBuilder<DeclarationInfo>();
             model.ComputeDeclarationsInSpan(span, getSymbol: true, builder: builder, cancellationToken: cancellationToken);
 
             ImmutableHashSet<ISymbol>.Builder generatedSymbolsBuilderOpt = null;
@@ -1391,8 +1391,6 @@ internal class AnalyzerDriver<TLanguageKindEnum> : AnalyzerDriver where TLanguag
         private ImmutableDictionary<DiagnosticAnalyzer, ImmutableArray<OperationBlockAnalyzerAction>> _lazyOperationBlockActionsByAnalyzer;
         private ImmutableDictionary<DiagnosticAnalyzer, ImmutableArray<OperationBlockAnalyzerAction>> _lazyOperationBlockEndActionsByAnalyzer;
 
-        private static readonly ObjectPool<DeclarationAnalysisData> s_declarationAnalysisDataPool = new ObjectPool<DeclarationAnalysisData>(() => new DeclarationAnalysisData());
-
         /// <summary>
         /// Create an analyzer driver.
         /// </summary>
@@ -1670,17 +1668,17 @@ private void ClearCachedAnalysisDataIfAnalyzed(SyntaxReference declaration, ISym
             compilationData.ClearDeclarationAnalysisData(declaration);
         }
 
-        private DeclarationAnalysisData ComputeDeclarationAnalysisData(
+        private DeclarationAnalysisDataBuilder ComputeDeclarationAnalysisData(
             ISymbol symbol,
             SyntaxReference declaration,
             SemanticModel semanticModel,
             AnalysisScope analysisScope,
-            Func<DeclarationAnalysisData> allocateData,
+            Func<DeclarationAnalysisDataBuilder> allocateData,
             CancellationToken cancellationToken)
         {
             cancellationToken.ThrowIfCancellationRequested();
 
-            var declarationAnalysisData = allocateData();
+            DeclarationAnalysisDataBuilder declarationAnalysisData = allocateData();
             var builder = declarationAnalysisData.DeclarationsInNode;
 
             var declaringReferenceSyntax = declaration.GetSyntax(cancellationToken);
@@ -1698,7 +1696,7 @@ private DeclarationAnalysisData ComputeDeclarationAnalysisData(
             return declarationAnalysisData;
         }
 
-        private static void ComputeDeclarationsInNode(SemanticModel semanticModel, ISymbol declaredSymbol, SyntaxNode declaringReferenceSyntax, SyntaxNode topmostNodeForAnalysis, List<DeclarationInfo> builder, CancellationToken cancellationToken)
+        private static void ComputeDeclarationsInNode(SemanticModel semanticModel, ISymbol declaredSymbol, SyntaxNode declaringReferenceSyntax, SyntaxNode topmostNodeForAnalysis, ImmutableArray<DeclarationInfo>.Builder builder, CancellationToken cancellationToken)
         {
             // We only care about the top level symbol declaration and its immediate member declarations.
             int? levelsToCompute = 2;

src/Compilers/VisualBasic/BasicAnalyzerDriver/VisualBasicDeclarationComputer.vb

@@ -9,13 +9,13 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
     Friend Class VisualBasicDeclarationComputer
         Inherits DeclarationComputer
 
-        Public Shared Sub ComputeDeclarationsInSpan(model As SemanticModel, span As TextSpan, getSymbol As Boolean, builder As List(Of DeclarationInfo), cancellationToken As CancellationToken)
+        Public Shared Sub ComputeDeclarationsInSpan(model As SemanticModel, span As TextSpan, getSymbol As Boolean, builder As ImmutableArray(Of DeclarationInfo).Builder, cancellationToken As CancellationToken)
             ComputeDeclarationsCore(model, model.SyntaxTree.GetRoot(),
                                     Function(node, level) Not node.Span.OverlapsWith(span) OrElse InvalidLevel(level),
                                     getSymbol, builder, Nothing, cancellationToken)
         End Sub
 
-        Public Shared Sub ComputeDeclarationsInNode(model As SemanticModel, node As SyntaxNode, getSymbol As Boolean, builder As List(Of DeclarationInfo), cancellationToken As CancellationToken, Optional levelsToCompute As Integer? = Nothing)
+        Public Shared Sub ComputeDeclarationsInNode(model As SemanticModel, node As SyntaxNode, getSymbol As Boolean, builder As ImmutableArray(Of DeclarationInfo).Builder, cancellationToken As CancellationToken, Optional levelsToCompute As Integer? = Nothing)
             ComputeDeclarationsCore(model, node, Function(n, level) InvalidLevel(level), getSymbol, builder, levelsToCompute, cancellationToken)
         End Sub
 
@@ -28,7 +28,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             Return If(level.HasValue, level.Value - 1, level)
         End Function
 
-        Private Shared Sub ComputeDeclarationsCore(model As SemanticModel, node As SyntaxNode, shouldSkip As Func(Of SyntaxNode, Integer?, Boolean), getSymbol As Boolean, builder As List(Of DeclarationInfo), levelsToCompute As Integer?, cancellationToken As CancellationToken)
+        Private Shared Sub ComputeDeclarationsCore(model As SemanticModel, node As SyntaxNode, shouldSkip As Func(Of SyntaxNode, Integer?, Boolean), getSymbol As Boolean, builder As ImmutableArray(Of DeclarationInfo).Builder, levelsToCompute As Integer?, cancellationToken As CancellationToken)
             cancellationToken.ThrowIfCancellationRequested()
 
             If shouldSkip(node, levelsToCompute) Then