Roslyn analyzers and code fixes

src/OmniSharp.Abstractions/Models/v1/AutoComplete/AutoCompleteResponse.cs

@@ -8,6 +8,7 @@ public class AutoCompleteResponse
         /// </summary>
         public string CompletionText { get; set; }
         public string Description { get; set; }
+
         /// <summary>
         /// The text that should be displayed in the auto-complete UI.
         /// </summary>

src/OmniSharp.Abstractions/Models/v1/Diagnostics/DiagnosticLocation.cs

@@ -1,8 +1,28 @@
-namespace OmniSharp.Models.Diagnostics
+using System.Collections.Generic;
+
+namespace OmniSharp.Models.Diagnostics
 {
     public class DiagnosticLocation : QuickFix
     {
         public string LogLevel { get; set; }
         public string Id { get; set; }
+
+        public override bool Equals(object obj)
+        {
+            var location = obj as DiagnosticLocation;
+            return location != null &&
+                   base.Equals(obj) &&
+                   LogLevel == location.LogLevel &&
+                   Id == location.Id;
+        }
+
+        public override int GetHashCode()
+        {
+            var hashCode = -1670479257;
+            hashCode = hashCode * -1521134295 + base.GetHashCode();
+            hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(LogLevel);
+            hashCode = hashCode * -1521134295 + EqualityComparer<string>.Default.GetHashCode(Id);
+            return hashCode;
+        }
     }
 }

src/OmniSharp.Abstractions/Models/v1/Diagnostics/DiagnosticResult.cs

@@ -6,5 +6,10 @@ public class DiagnosticResult
     {
         public string FileName { get; set; }
         public IEnumerable<DiagnosticLocation> QuickFixes { get; set; }
+
+        public override string ToString()
+        {
+            return $"{FileName} -> {string.Join(", ", QuickFixes)}";
+        }
     }
-}
+}

src/OmniSharp.Abstractions/Models/v1/QuickFix.cs

@@ -49,7 +49,7 @@ public override int GetHashCode()
         }
 
         public override string ToString()
-            => $"({Line}:{Column}) - ({EndLine}:{EndColumn})";
+            => $"{Text} ({Line}:{Column}) - ({EndLine}:{EndColumn})";
 
         public bool Contains(int line, int column)
         {

src/OmniSharp.Abstractions/Options/RoslynExtensionsOptions.cs

@@ -7,6 +7,8 @@ namespace OmniSharp.Options
 {
     public class RoslynExtensionsOptions
     {
+        public bool EnableAnalyzersSupport { get; set; }
+
         public string[] LocationPaths { get; set; }
 
         public IEnumerable<string> GetNormalizedLocationPaths(IOmniSharpEnvironment env)

src/OmniSharp.Abstractions/Utilities/ReflectionExtensions.cs

@@ -113,6 +113,22 @@ public static object CreateInstance(this Lazy<Type> lazyType, params object[] ar
             return Activator.CreateInstance(lazyType.Value, args);
         }
 
+        public static T CreateInstance<T>(this Type type) where T : class
+        {
+            try
+            {
+                var defaultCtor = type.GetConstructor(new Type[] { });
+
+                return defaultCtor != null
+                    ? (T)Activator.CreateInstance(type)
+                    : null;
+            }
+            catch (Exception ex)
+            {
+                throw new InvalidOperationException($"Failed to create instrance of {type.FullName} in {type.AssemblyQualifiedName}.", ex);
+            }
+        }
+
         public static T Invoke<T>(this MethodInfo methodInfo, object obj, object[] args)
         {
             if (methodInfo == null)

src/OmniSharp.Host/CompositionHostBuilder.cs

@@ -4,6 +4,7 @@
 using System.Composition.Hosting.Core;
 using System.Linq;
 using System.Reflection;
+using Microsoft.CodeAnalysis;
 using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
@@ -42,6 +43,7 @@ public CompositionHost Build()
             var memoryCache = _serviceProvider.GetRequiredService<IMemoryCache>();
             var loggerFactory = _serviceProvider.GetRequiredService<ILoggerFactory>();
             var assemblyLoader = _serviceProvider.GetRequiredService<IAssemblyLoader>();
+            var analyzerAssemblyLoader = _serviceProvider.GetRequiredService<IAnalyzerAssemblyLoader>();
             var environment = _serviceProvider.GetRequiredService<IOmniSharpEnvironment>();
             var eventEmitter = _serviceProvider.GetRequiredService<IEventEmitter>();
             var dotNetCliService = _serviceProvider.GetRequiredService<IDotNetCliService>();
@@ -73,6 +75,7 @@ public CompositionHost Build()
                 .WithProvider(MefValueProvider.From(options.CurrentValue))
                 .WithProvider(MefValueProvider.From(options.CurrentValue.FormattingOptions))
                 .WithProvider(MefValueProvider.From(assemblyLoader))
+                .WithProvider(MefValueProvider.From(analyzerAssemblyLoader))
                 .WithProvider(MefValueProvider.From(dotNetCliService))
                 .WithProvider(MefValueProvider.From(metadataHelper))
                 .WithProvider(MefValueProvider.From(msbuildLocator))
@@ -121,6 +124,7 @@ public static IServiceProvider CreateDefaultServiceProvider(
             // Caching
             services.AddSingleton<IMemoryCache, MemoryCache>();
             services.AddSingleton<IAssemblyLoader, AssemblyLoader>();
+            services.AddSingleton<IAnalyzerAssemblyLoader, AssemblyLoader>();
             services.AddOptions();
 
             services.AddSingleton<IDotNetCliService, DotNetCliService>();

src/OmniSharp.Host/Services/AssemblyLoader.cs

@@ -5,10 +5,11 @@
 using System.IO;
 using System.Reflection;
 using Microsoft.Extensions.Logging;
+using Microsoft.CodeAnalysis;
 
 namespace OmniSharp.Services
 {
-    internal class AssemblyLoader : IAssemblyLoader
+    internal class AssemblyLoader : IAssemblyLoader, IAnalyzerAssemblyLoader
     {
         private static readonly ConcurrentDictionary<string, Assembly> AssemblyCache = new ConcurrentDictionary<string, Assembly>(StringComparer.OrdinalIgnoreCase);
         private readonly ILogger _logger;
@@ -18,6 +19,11 @@ public AssemblyLoader(ILoggerFactory loggerFactory)
             _logger = loggerFactory.CreateLogger<AssemblyLoader>();
         }
 
+        public void AddDependencyLocation(string fullPath)
+        {
+            LoadFrom(fullPath);
+        }
+
         public Assembly Load(AssemblyName name)
         {
             Assembly result = null;
@@ -90,5 +96,10 @@ public Assembly LoadFrom(string assemblyPath, bool dontLockAssemblyOnDisk = fals
             _logger.LogTrace($"Assembly loaded from path: {assemblyPath}");
             return assembly;
         }
+
+        public Assembly LoadFromPath(string fullPath)
+        {
+            return LoadFrom(fullPath);
+        }
     }
 }

src/OmniSharp.Http/HttpCommandLineApplication.cs

@@ -14,7 +14,6 @@ public HttpCommandLineApplication() : base()
             _serverInterface = Application.Option("-i | --interface", "Server interface address (defaults to 'localhost').", CommandOptionType.SingleValue);
         }
 
-
         public int Port => _port.GetValueOrDefault(2000);
         public string Interface => _serverInterface.GetValueOrDefault("localhost");
     }

src/OmniSharp.MSBuild/ProjectFile/ProjectFileInfo.ProjectData.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.IO;
+using System.Linq;
 using System.Runtime.Versioning;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
@@ -45,6 +46,7 @@ private class ProjectData
             public ImmutableArray<string> References { get; }
             public ImmutableArray<PackageReference> PackageReferences { get; }
             public ImmutableArray<string> Analyzers { get; }
+            public RuleSet RuleSet { get; }
 
             private ProjectData()
             {
@@ -74,7 +76,8 @@ private ProjectData(
                 ImmutableArray<string> preprocessorSymbolNames,
                 ImmutableArray<string> suppressedDiagnosticIds,
                 bool signAssembly,
-                string assemblyOriginatorKeyFile)
+                string assemblyOriginatorKeyFile,
+                RuleSet ruleset)
                 : this()
             {
                 Guid = guid;
@@ -100,6 +103,7 @@ private ProjectData(
 
                 SignAssembly = signAssembly;
                 AssemblyOriginatorKeyFile = assemblyOriginatorKeyFile;
+                RuleSet = ruleset;
             }
 
             private ProjectData(
@@ -121,10 +125,11 @@ private ProjectData(
                 ImmutableArray<string> projectReferences,
                 ImmutableArray<string> references,
                 ImmutableArray<PackageReference> packageReferences,
-                ImmutableArray<string> analyzers)
+                ImmutableArray<string> analyzers,
+                RuleSet ruleset)
                 : this(guid, name, assemblyName, targetPath, outputPath, intermediateOutputPath, projectAssetsFile,
                       configuration, platform, targetFramework, targetFrameworks, outputKind, languageVersion, allowUnsafeCode,
-                      documentationFile, preprocessorSymbolNames, suppressedDiagnosticIds, signAssembly, assemblyOriginatorKeyFile)
+                      documentationFile, preprocessorSymbolNames, suppressedDiagnosticIds, signAssembly, assemblyOriginatorKeyFile, ruleset)
             {
                 SourceFiles = sourceFiles.EmptyIfDefault();
                 ProjectReferences = projectReferences.EmptyIfDefault();
@@ -167,7 +172,7 @@ public static ProjectData Create(MSB.Evaluation.Project project)
                 return new ProjectData(
                     guid, name, assemblyName, targetPath, outputPath, intermediateOutputPath, projectAssetsFile,
                     configuration, platform, targetFramework, targetFrameworks, outputKind, languageVersion, allowUnsafeCode,
-                    documentationFile, preprocessorSymbolNames, suppressedDiagnosticIds, signAssembly, assemblyOriginatorKeyFile);
+                    documentationFile, preprocessorSymbolNames, suppressedDiagnosticIds, signAssembly, assemblyOriginatorKeyFile, ruleset: null);
             }
 
             public static ProjectData Create(MSB.Execution.ProjectInstance projectInstance)
@@ -201,6 +206,8 @@ public static ProjectData Create(MSB.Execution.ProjectInstance projectInstance)
                 var signAssembly = PropertyConverter.ToBoolean(projectInstance.GetPropertyValue(PropertyNames.SignAssembly), defaultValue: false);
                 var assemblyOriginatorKeyFile = projectInstance.GetPropertyValue(PropertyNames.AssemblyOriginatorKeyFile);
 
+                var ruleset = ResolveRulesetIfAny(projectInstance);
+
                 var sourceFiles = GetFullPaths(
                     projectInstance.GetItems(ItemNames.Compile), filter: FileNameIsNotGenerated);
 
@@ -234,7 +241,7 @@ public static ProjectData Create(MSB.Execution.ProjectInstance projectInstance)
                         references.Add(fullPath);
                     }
                 }
-            
+
                 var packageReferences = GetPackageReferences(projectInstance.GetItems(ItemNames.PackageReference));
                 var analyzers = GetFullPaths(projectInstance.GetItems(ItemNames.Analyzer));
 
@@ -243,7 +250,17 @@ public static ProjectData Create(MSB.Execution.ProjectInstance projectInstance)
                     configuration, platform, targetFramework, targetFrameworks,
                     outputKind, languageVersion, allowUnsafeCode, documentationFile, preprocessorSymbolNames, suppressedDiagnosticIds,
                     signAssembly, assemblyOriginatorKeyFile,
-                    sourceFiles, projectReferences, references.ToImmutable(), packageReferences, analyzers);
+                    sourceFiles, projectReferences, references.ToImmutable(), packageReferences, analyzers, ruleset);
+            }
+
+            private static RuleSet ResolveRulesetIfAny(MSB.Execution.ProjectInstance projectInstance)
+            {
+                var rulesetIfAny = projectInstance.Properties.FirstOrDefault(x => x.Name == "ResolvedCodeAnalysisRuleSet");
+
+                if (rulesetIfAny != null)
+                    return RuleSet.LoadEffectiveRuleSetFromFile(Path.Combine(projectInstance.Directory, rulesetIfAny.EvaluatedValue));
+
+                return null;
             }
 
             private static bool IsCSharpProject(string filePath)

src/OmniSharp.MSBuild/ProjectFile/ProjectFileInfo.cs

@@ -42,6 +42,7 @@ internal partial class ProjectFileInfo
 
         public bool SignAssembly => _data.SignAssembly;
         public string AssemblyOriginatorKeyFile => _data.AssemblyOriginatorKeyFile;
+        public RuleSet RuleSet => _data.RuleSet;
 
         public ImmutableArray<string> SourceFiles => _data.SourceFiles;
         public ImmutableArray<string> References => _data.References;

src/OmniSharp.MSBuild/ProjectFile/ProjectFileInfoExtensions.cs

@@ -1,6 +1,10 @@
-using System.IO;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.Diagnostics;
 using OmniSharp.Helpers;
 
 namespace OmniSharp.MSBuild.ProjectFile
@@ -35,8 +39,10 @@ public static CSharpCompilationOptions CreateCompilationOptions(this ProjectFile
             return result;
         }
 
-        public static ProjectInfo CreateProjectInfo(this ProjectFileInfo projectFileInfo)
+        public static ProjectInfo CreateProjectInfo(this ProjectFileInfo projectFileInfo, IAnalyzerAssemblyLoader analyzerAssemblyLoader)
         {
+            var analyzerReferences = ResolveAnalyzerReferencesForProject(projectFileInfo, analyzerAssemblyLoader);
+
             return ProjectInfo.Create(
                 id: projectFileInfo.Id,
                 version: VersionStamp.Create(),
@@ -45,7 +51,18 @@ public static ProjectInfo CreateProjectInfo(this ProjectFileInfo projectFileInfo
                 language: LanguageNames.CSharp,
                 filePath: projectFileInfo.FilePath,
                 outputFilePath: projectFileInfo.TargetPath,
-                compilationOptions: projectFileInfo.CreateCompilationOptions());
+                compilationOptions: projectFileInfo.CreateCompilationOptions(),
+                analyzerReferences: analyzerReferences);
+        }
+
+        private static IEnumerable<AnalyzerReference> ResolveAnalyzerReferencesForProject(ProjectFileInfo projectFileInfo, IAnalyzerAssemblyLoader analyzerAssemblyLoader)
+        {
+            foreach(var analyzerAssemblyPath in projectFileInfo.Analyzers.Distinct())
+            {
+                analyzerAssemblyLoader.AddDependencyLocation(analyzerAssemblyPath);
+            }
+
+            return projectFileInfo.Analyzers.Select(analyzerCandicatePath => new AnalyzerFileReference(analyzerCandicatePath, analyzerAssemblyLoader));
         }
     }
 }