Remove workarounds that are no longer required with Roslyn 1.1

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/Helpers/FixAllContextHelper.cs

@@ -3,44 +3,18 @@
 
 namespace StyleCop.Analyzers.Helpers
 {
-    using System;
     using System.Collections.Concurrent;
     using System.Collections.Generic;
     using System.Collections.Immutable;
     using System.Linq;
-    using System.Reflection;
     using System.Threading;
     using System.Threading.Tasks;
     using Microsoft.CodeAnalysis;
     using Microsoft.CodeAnalysis.CodeFixes;
     using Microsoft.CodeAnalysis.Diagnostics;
-    using Microsoft.CodeAnalysis.Text;
 
     internal static class FixAllContextHelper
     {
-        private static readonly ImmutableDictionary<string, ImmutableArray<Type>> DiagnosticAnalyzers = GetAllAnalyzers();
-
-        private static readonly Func<CompilationWithAnalyzers, SyntaxTree, CancellationToken, Task<ImmutableArray<Diagnostic>>> GetAnalyzerSyntaxDiagnosticsAsync;
-        private static readonly Func<CompilationWithAnalyzers, SemanticModel, TextSpan?, CancellationToken, Task<ImmutableArray<Diagnostic>>> GetAnalyzerSemanticDiagnosticsAsync;
-        private static readonly Func<CompilationWithAnalyzers, ImmutableArray<DiagnosticAnalyzer>, CancellationToken, Task<ImmutableArray<Diagnostic>>> GetAnalyzerCompilationDiagnosticsAsync;
-
-        static FixAllContextHelper()
-        {
-            Version roslynVersion = typeof(AdditionalText).GetTypeInfo().Assembly.GetName().Version;
-            bool avoidGetAnalyzerDiagnosticsAsync = roslynVersion >= new Version(1, 1, 0, 0) && roslynVersion < new Version(1, 2, 0, 0);
-            if (avoidGetAnalyzerDiagnosticsAsync)
-            {
-                var methodInfo = typeof(CompilationWithAnalyzers).GetRuntimeMethod(nameof(GetAnalyzerSyntaxDiagnosticsAsync), new[] { typeof(SyntaxTree), typeof(CancellationToken) });
-                GetAnalyzerSyntaxDiagnosticsAsync = (Func<CompilationWithAnalyzers, SyntaxTree, CancellationToken, Task<ImmutableArray<Diagnostic>>>)methodInfo?.CreateDelegate(typeof(Func<CompilationWithAnalyzers, SyntaxTree, CancellationToken, Task<ImmutableArray<Diagnostic>>>));
-
-                methodInfo = typeof(CompilationWithAnalyzers).GetRuntimeMethod(nameof(GetAnalyzerSemanticDiagnosticsAsync), new[] { typeof(SemanticModel), typeof(TextSpan?), typeof(CancellationToken) });
-                GetAnalyzerSemanticDiagnosticsAsync = (Func<CompilationWithAnalyzers, SemanticModel, TextSpan?, CancellationToken, Task<ImmutableArray<Diagnostic>>>)methodInfo?.CreateDelegate(typeof(Func<CompilationWithAnalyzers, SemanticModel, TextSpan?, CancellationToken, Task<ImmutableArray<Diagnostic>>>));
-
-                methodInfo = typeof(CompilationWithAnalyzers).GetRuntimeMethod(nameof(GetAnalyzerCompilationDiagnosticsAsync), new[] { typeof(ImmutableArray<DiagnosticAnalyzer>), typeof(CancellationToken) });
-                GetAnalyzerCompilationDiagnosticsAsync = (Func<CompilationWithAnalyzers, ImmutableArray<DiagnosticAnalyzer>, CancellationToken, Task<ImmutableArray<Diagnostic>>>)methodInfo?.CreateDelegate(typeof(Func<CompilationWithAnalyzers, ImmutableArray<DiagnosticAnalyzer>, CancellationToken, Task<ImmutableArray<Diagnostic>>>));
-            }
-        }
-
         public static async Task<ImmutableDictionary<Document, ImmutableArray<Diagnostic>>> GetDocumentDiagnosticsToFixAsync(FixAllContext fixAllContext)
         {
             var allDiagnostics = ImmutableArray<Diagnostic>.Empty;
@@ -132,87 +106,7 @@ public static async Task<ImmutableDictionary<Project, ImmutableArray<Diagnostic>
 
         public static async Task<ImmutableArray<Diagnostic>> GetAllDiagnosticsAsync(Compilation compilation, CompilationWithAnalyzers compilationWithAnalyzers, ImmutableArray<DiagnosticAnalyzer> analyzers, IEnumerable<Document> documents, bool includeCompilerDiagnostics, CancellationToken cancellationToken)
         {
-            if (GetAnalyzerSyntaxDiagnosticsAsync == null || GetAnalyzerSemanticDiagnosticsAsync == null)
-            {
-                // In everything except Roslyn 1.1, we use GetAllDiagnosticsAsync and return the result.
-                var allDiagnostics = await compilationWithAnalyzers.GetAllDiagnosticsAsync().ConfigureAwait(false);
-                return allDiagnostics;
-            }
-
-            compilationWithAnalyzers.Compilation.GetDeclarationDiagnostics(cancellationToken);
-
-            // Note that the following loop to obtain syntax and semantic diagnostics for each document cannot operate
-            // on parallel due to our use of a single CompilationWithAnalyzers instance.
-            var diagnostics = ImmutableArray.CreateBuilder<Diagnostic>();
-            foreach (var document in documents)
-            {
-                var syntaxTree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
-                var syntaxDiagnostics = await GetAnalyzerSyntaxDiagnosticsAsync(compilationWithAnalyzers, syntaxTree, cancellationToken).ConfigureAwait(false);
-                diagnostics.AddRange(syntaxDiagnostics);
-
-                var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
-                var semanticDiagnostics = await GetAnalyzerSemanticDiagnosticsAsync(compilationWithAnalyzers, semanticModel, default(TextSpan?), cancellationToken).ConfigureAwait(false);
-                diagnostics.AddRange(semanticDiagnostics);
-            }
-
-            foreach (var analyzer in analyzers)
-            {
-                diagnostics.AddRange(await GetAnalyzerCompilationDiagnosticsAsync(compilationWithAnalyzers, ImmutableArray.Create(analyzer), cancellationToken).ConfigureAwait(false));
-            }
-
-            if (includeCompilerDiagnostics)
-            {
-                // This is the special handling for cases where code fixes operate on warnings produced by the C#
-                // compiler, as opposed to being created by specific analyzers.
-                var compilerDiagnostics = compilation.GetDiagnostics(cancellationToken);
-                diagnostics.AddRange(compilerDiagnostics);
-            }
-
-            return diagnostics.ToImmutable();
-        }
-
-        private static ImmutableDictionary<string, ImmutableArray<Type>> GetAllAnalyzers()
-        {
-            Assembly assembly = typeof(NoCodeFixAttribute).GetTypeInfo().Assembly;
-
-            var diagnosticAnalyzerType = typeof(DiagnosticAnalyzer);
-
-            var analyzers = ImmutableDictionary.CreateBuilder<string, ImmutableArray<Type>>();
-
-            foreach (var type in assembly.DefinedTypes)
-            {
-                if (type.IsSubclassOf(diagnosticAnalyzerType) && !type.IsAbstract)
-                {
-                    Type analyzerType = type.AsType();
-                    DiagnosticAnalyzer analyzer = (DiagnosticAnalyzer)Activator.CreateInstance(analyzerType);
-                    foreach (var descriptor in analyzer.SupportedDiagnostics)
-                    {
-                        ImmutableArray<Type> types;
-                        if (analyzers.TryGetValue(descriptor.Id, out types))
-                        {
-                            types = types.Add(analyzerType);
-                        }
-                        else
-                        {
-                            types = ImmutableArray.Create(analyzerType);
-                        }
-
-                        analyzers[descriptor.Id] = types;
-                    }
-                }
-            }
-
-            return analyzers.ToImmutable();
-        }
-
-        private static ImmutableArray<DiagnosticAnalyzer> GetDiagnosticAnalyzersForContext(FixAllContext fixAllContext)
-        {
-            return DiagnosticAnalyzers
-                .Where(x => fixAllContext.DiagnosticIds.Contains(x.Key))
-                .SelectMany(x => x.Value)
-                .Distinct()
-                .Select(type => (DiagnosticAnalyzer)Activator.CreateInstance(type))
-                .ToImmutableArray();
+            return await compilationWithAnalyzers.GetAllDiagnosticsAsync().ConfigureAwait(false);
         }
 
         /// <summary>
@@ -225,32 +119,7 @@ private static ImmutableArray<DiagnosticAnalyzer> GetDiagnosticAnalyzersForConte
         /// successfully, the <see cref="Task{TResult}.Result"/> will contain the requested diagnostics.</returns>
         private static async Task<ImmutableArray<Diagnostic>> GetAllDiagnosticsAsync(FixAllContext fixAllContext, Project project)
         {
-            if (GetAnalyzerSyntaxDiagnosticsAsync == null || GetAnalyzerSemanticDiagnosticsAsync == null)
-            {
-                return await fixAllContext.GetAllDiagnosticsAsync(project).ConfigureAwait(false);
-            }
-
-            /*
-             * The rest of this method is workaround code for issues with Roslyn 1.1...
-             */
-
-            var analyzers = GetDiagnosticAnalyzersForContext(fixAllContext);
-
-            // Most code fixes in this project operate on diagnostics reported by analyzers in this project. However, a
-            // few code fixes also operate on standard warnings produced by the C# compiler. Special handling is
-            // required for the latter case since these warnings are not considered "analyzer diagnostics".
-            bool includeCompilerDiagnostics = fixAllContext.DiagnosticIds.Any(x => x.StartsWith("CS", StringComparison.Ordinal));
-
-            // Use a single CompilationWithAnalyzers for the entire operation. This allows us to use the
-            // GetDeclarationDiagnostics workaround for dotnet/roslyn#7446 a single time, rather than once per document.
-            var compilation = await project.GetCompilationAsync(fixAllContext.CancellationToken).ConfigureAwait(false);
-            var compilationWithAnalyzers = compilation.WithAnalyzers(analyzers, project.AnalyzerOptions, fixAllContext.CancellationToken);
-            ImmutableArray<Diagnostic> diagnostics = await GetAllDiagnosticsAsync(compilation, compilationWithAnalyzers, analyzers, project.Documents, includeCompilerDiagnostics, fixAllContext.CancellationToken).ConfigureAwait(false);
-
-            // Make sure to filter the results to the set requested for the Fix All operation, since analyzers can
-            // report diagnostics with different IDs.
-            diagnostics = diagnostics.RemoveAll(x => !fixAllContext.DiagnosticIds.Contains(x.Id));
-            return diagnostics;
+            return await fixAllContext.GetAllDiagnosticsAsync(project).ConfigureAwait(false);
         }
 
         private static async Task<ImmutableDictionary<Document, ImmutableArray<Diagnostic>>> GetDocumentDiagnosticsToFixAsync(

StyleCop.Analyzers/StyleCop.Analyzers/Settings/SettingsHelper.cs

@@ -3,13 +3,8 @@
 
 namespace StyleCop.Analyzers
 {
-    using System;
-    using System.Collections.Concurrent;
     using System.Collections.Immutable;
     using System.IO;
-    using System.Linq;
-    using System.Reflection;
-    using System.Runtime.ExceptionServices;
     using System.Threading;
     using Microsoft.CodeAnalysis;
     using Microsoft.CodeAnalysis.Diagnostics;
@@ -28,20 +23,6 @@ internal static class SettingsHelper
             new SourceTextValueProvider<StyleCopSettings>(
                 text => GetStyleCopSettings(text, DeserializationFailureBehavior.ReturnDefaultSettings));
 
-        private static readonly bool AvoidAdditionalTextGetText;
-
-        private static readonly ConcurrentDictionary<Type, ConcurrentDictionary<string, FieldInfo>> FieldInfos =
-            new ConcurrentDictionary<Type, ConcurrentDictionary<string, FieldInfo>>();
-
-        private static readonly ConcurrentDictionary<Type, ConcurrentDictionary<string, PropertyInfo>> PropertyInfos =
-            new ConcurrentDictionary<Type, ConcurrentDictionary<string, PropertyInfo>>();
-
-        static SettingsHelper()
-        {
-            // dotnet/roslyn#6596 was fixed for Roslyn 1.2
-            AvoidAdditionalTextGetText = typeof(AdditionalText).GetTypeInfo().Assembly.GetName().Version < new Version(1, 2, 0, 0);
-        }
-
         /// <summary>
         /// Gets the StyleCop settings.
         /// </summary>
@@ -162,7 +143,7 @@ private static SourceText TryGetStyleCopSettingsText(this AnalyzerOptions option
             {
                 if (Path.GetFileName(additionalFile.Path).ToLowerInvariant() == SettingsFileName)
                 {
-                    return GetText(additionalFile, cancellationToken);
+                    return additionalFile.GetText(cancellationToken);
                 }
             }
 
@@ -177,7 +158,7 @@ private static StyleCopSettings GetStyleCopSettings(ImmutableArray<AdditionalTex
                 {
                     if (Path.GetFileName(additionalFile.Path).ToLowerInvariant() == SettingsFileName)
                     {
-                        SourceText additionalTextContent = GetText(additionalFile, cancellationToken);
+                        SourceText additionalTextContent = additionalFile.GetText(cancellationToken);
                         var root = JsonConvert.DeserializeObject<SettingsFile>(additionalTextContent.ToString());
                         return root.Settings;
                     }
@@ -190,95 +171,5 @@ private static StyleCopSettings GetStyleCopSettings(ImmutableArray<AdditionalTex
 
             return new StyleCopSettings();
         }
-
-        /// <summary>
-        /// This code works around dotnet/roslyn#6596 by using reflection APIs to bypass the problematic method while
-        /// reading the content of an <see cref="AdditionalText"/> file. If the reflection approach fails, the code
-        /// falls back to the previous behavior.
-        /// </summary>
-        /// <param name="additionalText">The additional text to read.</param>
-        /// <param name="cancellationToken">The cancellation token that the operation will observe.</param>
-        /// <returns>The content of the additional text file.</returns>
-        private static SourceText GetText(AdditionalText additionalText, CancellationToken cancellationToken)
-        {
-            if (AvoidAdditionalTextGetText)
-            {
-                object document = GetField(additionalText, "_document");
-                if (document != null)
-                {
-                    object textSource = GetField(document, "textSource");
-                    if (textSource != null)
-                    {
-                        object textAndVersion = CallMethod(textSource, "GetValue", new[] { typeof(CancellationToken) }, cancellationToken);
-                        if (textAndVersion != null)
-                        {
-                            SourceText text = GetProperty(textAndVersion, "Text") as SourceText;
-                            if (text != null)
-                            {
-                                return text;
-                            }
-                        }
-                    }
-                }
-            }
-
-            return additionalText.GetText(cancellationToken);
-        }
-
-        private static object GetField(object obj, string name)
-        {
-            if (obj == null)
-            {
-                return null;
-            }
-
-            ConcurrentDictionary<string, FieldInfo> fieldsForType = FieldInfos.GetOrAdd(obj.GetType(), _ => new ConcurrentDictionary<string, FieldInfo>());
-            FieldInfo fieldInfo;
-            if (!fieldsForType.TryGetValue(name, out fieldInfo))
-            {
-                fieldInfo = fieldsForType.GetOrAdd(name, _ => obj.GetType().GetRuntimeFields().FirstOrDefault(i => i.Name == name));
-            }
-
-            return fieldInfo?.GetValue(obj);
-        }
-
-        private static object CallMethod(object obj, string name, Type[] parameters, params object[] arguments)
-        {
-            try
-            {
-                MethodInfo methodInfo = obj?.GetType().GetRuntimeMethod(name, parameters);
-                return methodInfo?.Invoke(obj, arguments);
-            }
-            catch (TargetInvocationException ex)
-            {
-                ExceptionDispatchInfo.Capture(ex.InnerException).Throw();
-                throw;
-            }
-        }
-
-        private static object GetProperty(object obj, string name)
-        {
-            if (obj == null)
-            {
-                return null;
-            }
-
-            ConcurrentDictionary<string, PropertyInfo> propertiesForType = PropertyInfos.GetOrAdd(obj.GetType(), _ => new ConcurrentDictionary<string, PropertyInfo>());
-            PropertyInfo propertyInfo;
-            if (!propertiesForType.TryGetValue(name, out propertyInfo))
-            {
-                propertyInfo = propertiesForType.GetOrAdd(name, _ => obj.GetType().GetRuntimeProperty(name));
-            }
-
-            try
-            {
-                return propertyInfo?.GetValue(obj);
-            }
-            catch (TargetInvocationException ex)
-            {
-                ExceptionDispatchInfo.Capture(ex.InnerException).Throw();
-                throw;
-            }
-        }
     }
 }