Merge pull request #1805 from sharwell/cache-settings

StyleCopSettings cache

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers/AnalyzerExtensions.cs

@@ -6,9 +6,11 @@ namespace StyleCop.Analyzers
     using System;
     using System.Collections.Concurrent;
     using System.Collections.Immutable;
+    using System.Runtime.CompilerServices;
     using System.Threading;
     using Microsoft.CodeAnalysis;
     using Microsoft.CodeAnalysis.Diagnostics;
+    using Settings.ObjectModel;
 
     /// <summary>
     /// Provides extension methods to deal for analyzers.
@@ -25,6 +27,9 @@ internal static class AnalyzerExtensions
         private static Tuple<WeakReference<Compilation>, ConcurrentDictionary<SyntaxTree, bool>> generatedHeaderCache
             = Tuple.Create(new WeakReference<Compilation>(null), default(ConcurrentDictionary<SyntaxTree, bool>));
 
+        private static Tuple<WeakReference<Compilation>, StrongBox<StyleCopSettings>> settingsCache
+            = Tuple.Create(new WeakReference<Compilation>(null), default(StrongBox<StyleCopSettings>));
+
         /// <summary>
         /// Register an action to be executed at completion of parsing of a code document. A syntax tree action reports
         /// diagnostics about the <see cref="SyntaxTree"/> of a document.
@@ -53,6 +58,43 @@ public static void RegisterSyntaxTreeActionHonorExclusions(this CompilationStart
                 });
         }
 
+        /// <summary>
+        /// Register an action to be executed at completion of parsing of a code document. A syntax tree action reports
+        /// diagnostics about the <see cref="SyntaxTree"/> of a document.
+        /// </summary>
+        /// <remarks>This method honors exclusions.</remarks>
+        /// <param name="context">The analysis context.</param>
+        /// <param name="action">Action to be executed at completion of parsing of a document.</param>
+        public static void RegisterSyntaxTreeActionHonorExclusions(this CompilationStartAnalysisContext context, Action<SyntaxTreeAnalysisContext, StyleCopSettings> action)
+        {
+            Compilation compilation = context.Compilation;
+            ConcurrentDictionary<SyntaxTree, bool> cache = GetOrCreateGeneratedDocumentCache(compilation);
+            StrongBox<StyleCopSettings> settingsCache = GetOrCreateStyleCopSettingsCache(compilation);
+
+            context.RegisterSyntaxTreeAction(
+                c =>
+                {
+                    if (c.IsGeneratedDocument(cache))
+                    {
+                        return;
+                    }
+
+                    // Honor the containing document item's ExcludeFromStylecop=True
+                    // MSBuild metadata, if analyzers have access to it.
+                    //// TODO: code here
+
+                    StyleCopSettings settings = settingsCache.Value;
+                    if (settings == null)
+                    {
+                        StyleCopSettings updatedSettings = SettingsHelper.GetStyleCopSettings(c.Options, c.CancellationToken);
+                        StyleCopSettings previous = Interlocked.CompareExchange(ref settingsCache.Value, updatedSettings, null);
+                        settings = previous ?? updatedSettings;
+                    }
+
+                    action(c, settings);
+                });
+        }
+
         /// <summary>
         /// Gets or creates a cache which can be used with <see cref="GeneratedCodeAnalysisExtensions"/> methods to
         /// efficiently determine whether or not a source file is considered generated.
@@ -87,6 +129,40 @@ public static ConcurrentDictionary<SyntaxTree, bool> GetOrCreateGeneratedDocumen
             return headerCache.Item2;
         }
 
+        /// <summary>
+        /// Gets a <see cref="StrongBox{T}"/> which can store a <see cref="StyleCopSettings"/> instance to improve
+        /// efficiency across multiple analyzers which examine settings.
+        /// </summary>
+        /// <param name="compilation">The compilation which the cache applies to.</param>
+        /// <returns>A <see cref="StrongBox{T}"/> which can store a <see cref="StyleCopSettings"/> instance.</returns>
+        public static StrongBox<StyleCopSettings> GetOrCreateStyleCopSettingsCache(this Compilation compilation)
+        {
+            var currentSettingsCache = settingsCache;
+
+            Compilation cachedCompilation;
+            if (!currentSettingsCache.Item1.TryGetTarget(out cachedCompilation) || cachedCompilation != compilation)
+            {
+                var replacementCache = Tuple.Create(new WeakReference<Compilation>(compilation), new StrongBox<StyleCopSettings>(null));
+                while (true)
+                {
+                    var prior = Interlocked.CompareExchange(ref settingsCache, replacementCache, currentSettingsCache);
+                    if (prior == currentSettingsCache)
+                    {
+                        currentSettingsCache = replacementCache;
+                        break;
+                    }
+
+                    currentSettingsCache = prior;
+                    if (currentSettingsCache.Item1.TryGetTarget(out cachedCompilation) && cachedCompilation == compilation)
+                    {
+                        break;
+                    }
+                }
+            }
+
+            return currentSettingsCache.Item2;
+        }
+
         /// <summary>
         /// Register an action to be executed at completion of semantic analysis of a <see cref="SyntaxNode"/> with an
         /// appropriate kind. A syntax node action can report diagnostics about a <see cref="SyntaxNode"/>, and can also
@@ -106,6 +182,25 @@ public static void RegisterSyntaxNodeActionHonorExclusions<TLanguageKindEnum>(th
             context.RegisterSyntaxNodeActionHonorExclusions(action, LanguageKindArrays<TLanguageKindEnum>.GetOrCreateArray(syntaxKind));
         }
 
+        /// <summary>
+        /// Register an action to be executed at completion of semantic analysis of a <see cref="SyntaxNode"/> with an
+        /// appropriate kind. A syntax node action can report diagnostics about a <see cref="SyntaxNode"/>, and can also
+        /// collect state information to be used by other syntax node actions or code block end actions.
+        /// </summary>
+        /// <remarks>This method honors exclusions.</remarks>
+        /// <param name="context">Action will be executed only if the kind of a <see cref="SyntaxNode"/> matches
+        /// <paramref name="syntaxKind"/>.</param>
+        /// <param name="action">Action to be executed at completion of semantic analysis of a
+        /// <see cref="SyntaxNode"/>.</param>
+        /// <param name="syntaxKind">The kind of syntax that should be analyzed.</param>
+        /// <typeparam name="TLanguageKindEnum">Enum type giving the syntax node kinds of the source language for which
+        /// the action applies.</typeparam>
+        public static void RegisterSyntaxNodeActionHonorExclusions<TLanguageKindEnum>(this CompilationStartAnalysisContext context, Action<SyntaxNodeAnalysisContext, StyleCopSettings> action, TLanguageKindEnum syntaxKind)
+            where TLanguageKindEnum : struct
+        {
+            context.RegisterSyntaxNodeActionHonorExclusions(action, LanguageKindArrays<TLanguageKindEnum>.GetOrCreateArray(syntaxKind));
+        }
+
         /// <summary>
         /// Register an action to be executed at completion of semantic analysis of a <see cref="SyntaxNode"/> with an
         /// appropriate kind. A syntax node action can report diagnostics about a <see cref="SyntaxNode"/>, and can also
@@ -142,6 +237,51 @@ public static void RegisterSyntaxNodeActionHonorExclusions<TLanguageKindEnum>(th
                 syntaxKinds);
         }
 
+        /// <summary>
+        /// Register an action to be executed at completion of semantic analysis of a <see cref="SyntaxNode"/> with an
+        /// appropriate kind. A syntax node action can report diagnostics about a <see cref="SyntaxNode"/>, and can also
+        /// collect state information to be used by other syntax node actions or code block end actions.
+        /// </summary>
+        /// <remarks>This method honors exclusions.</remarks>
+        /// <param name="context">Action will be executed only if the kind of a <see cref="SyntaxNode"/> matches one of
+        /// the <paramref name="syntaxKinds"/> values.</param>
+        /// <param name="action">Action to be executed at completion of semantic analysis of a
+        /// <see cref="SyntaxNode"/>.</param>
+        /// <param name="syntaxKinds">The kinds of syntax that should be analyzed.</param>
+        /// <typeparam name="TLanguageKindEnum">Enum type giving the syntax node kinds of the source language for which
+        /// the action applies.</typeparam>
+        public static void RegisterSyntaxNodeActionHonorExclusions<TLanguageKindEnum>(this CompilationStartAnalysisContext context, Action<SyntaxNodeAnalysisContext, StyleCopSettings> action, ImmutableArray<TLanguageKindEnum> syntaxKinds)
+            where TLanguageKindEnum : struct
+        {
+            Compilation compilation = context.Compilation;
+            ConcurrentDictionary<SyntaxTree, bool> cache = GetOrCreateGeneratedDocumentCache(compilation);
+            StrongBox<StyleCopSettings> settingsCache = GetOrCreateStyleCopSettingsCache(compilation);
+
+            context.RegisterSyntaxNodeAction(
+                c =>
+                {
+                    if (c.IsGenerated(cache))
+                    {
+                        return;
+                    }
+
+                    // Honor the containing document item's ExcludeFromStylecop=True
+                    // MSBuild metadata, if analyzers have access to it.
+                    //// TODO: code here
+
+                    StyleCopSettings settings = settingsCache.Value;
+                    if (settings == null)
+                    {
+                        StyleCopSettings updatedSettings = SettingsHelper.GetStyleCopSettings(c.Options, c.CancellationToken);
+                        StyleCopSettings previous = Interlocked.CompareExchange(ref settingsCache.Value, updatedSettings, null);
+                        settings = previous ?? updatedSettings;
+                    }
+
+                    action(c, settings);
+                },
+                syntaxKinds);
+        }
+
         private static class LanguageKindArrays<TLanguageKindEnum>
             where TLanguageKindEnum : struct
         {