added a way to specify ordering of Document/ProjectDiagnosticAnalyzers

src/EditorFeatures/Test/Diagnostics/DiagnosticAnalyzerServiceTests.cs

@@ -1,12 +1,14 @@
 // 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.Generic;
 using System.Collections.Immutable;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Diagnostics.CSharp;
+using Microsoft.CodeAnalysis.Diagnostics.EngineV2;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Shared.Options;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
@@ -242,6 +244,43 @@ await service.SynchronizeWithBuildAsync(
             // we should reach here without crashing
         }
 
+        [Fact]
+        public void TestHostAnalyzerOrdering()
+        {
+            var workspace = new AdhocWorkspace(MefV1HostServices.Create(TestExportProvider.ExportProviderWithCSharpAndVisualBasic.AsExportProvider()));
+
+            var project = workspace.AddProject(
+                          ProjectInfo.Create(
+                              ProjectId.CreateNewId(),
+                              VersionStamp.Create(), 
+                              "Dummy",
+                              "Dummy",
+                              LanguageNames.CSharp));
+
+            // create listener/service/analyzer
+            var listener = new AsynchronousOperationListener();
+            var service = new MyDiagnosticAnalyzerService(new DiagnosticAnalyzer[] {
+                new Priority20Analyzer(),
+                new Priority15Analyzer(),
+                new Priority10Analyzer(),
+                new Priority1Analyzer(),
+                new Priority0Analyzer(),
+                new CSharpCompilerDiagnosticAnalyzer(),
+                new Analyzer(),
+            }, listener, project.Language);
+
+            var incrementalAnalyzer = (DiagnosticIncrementalAnalyzer)service.CreateIncrementalAnalyzer(workspace);
+            var analyzers = incrementalAnalyzer.GetAnalyzersTestOnly(project).ToArray();
+
+            Assert.Equal(analyzers[0].GetType(), typeof(CSharpCompilerDiagnosticAnalyzer));
+            Assert.Equal(analyzers[1].GetType(), typeof(Analyzer));
+            Assert.Equal(analyzers[2].GetType(), typeof(Priority0Analyzer));
+            Assert.Equal(analyzers[3].GetType(), typeof(Priority1Analyzer));
+            Assert.Equal(analyzers[4].GetType(), typeof(Priority10Analyzer));
+            Assert.Equal(analyzers[5].GetType(), typeof(Priority15Analyzer));
+            Assert.Equal(analyzers[6].GetType(), typeof(Priority20Analyzer));
+        }
+
         private static Document GetDocumentFromIncompleteProject(AdhocWorkspace workspace)
         {
             var project = workspace.AddProject(
@@ -291,10 +330,15 @@ private static async Task RunAllAnalysisAsync(IIncrementalAnalyzer analyzer, Doc
         private class MyDiagnosticAnalyzerService : DiagnosticAnalyzerService
         {
             internal MyDiagnosticAnalyzerService(DiagnosticAnalyzer analyzer, IAsynchronousOperationListener listener, string language = LanguageNames.CSharp)
+                : this(SpecializedCollections.SingletonEnumerable(analyzer), listener, language)
+            {
+            }
+
+            internal MyDiagnosticAnalyzerService(IEnumerable<DiagnosticAnalyzer> analyzers, IAsynchronousOperationListener listener, string language = LanguageNames.CSharp)
                 : base(new HostAnalyzerManager(
                             ImmutableArray.Create<AnalyzerReference>(
                                 new TestAnalyzerReferenceByLanguage(
-                                    ImmutableDictionary<string, ImmutableArray<DiagnosticAnalyzer>>.Empty.Add(language, ImmutableArray.Create(analyzer)))),
+                                    ImmutableDictionary<string, ImmutableArray<DiagnosticAnalyzer>>.Empty.Add(language, ImmutableArray.CreateRange(analyzers)))),
                             hostDiagnosticUpdateSource: null),
                       hostDiagnosticUpdateSource: null,
                       registrationService: new MockDiagnosticUpdateSourceRegistrationService(),
@@ -358,5 +402,58 @@ public override Task<ImmutableArray<Diagnostic>> AnalyzeSemanticsAsync(Document
                 return SpecializedTasks.Default<ImmutableArray<Diagnostic>>();
             }
         }
+
+        private class Priority20Analyzer : PriorityTestDocumentDiagnosticAnalyzer
+        {
+            public Priority20Analyzer() : base(priority: 20) { }
+        }
+
+        private class Priority15Analyzer : PriorityTestProjectDiagnosticAnalyzer
+        {
+            public Priority15Analyzer() : base(priority: 15) { }
+        }
+
+        private class Priority10Analyzer : PriorityTestDocumentDiagnosticAnalyzer
+        {
+            public Priority10Analyzer() : base(priority: 10) { }
+        }
+
+        private class Priority1Analyzer : PriorityTestProjectDiagnosticAnalyzer
+        {
+            public Priority1Analyzer() : base(priority: 1) { }
+        }
+
+        private class Priority0Analyzer : PriorityTestDocumentDiagnosticAnalyzer
+        {
+            public Priority0Analyzer() : base(priority: -1) { }
+        }
+
+        private class PriorityTestDocumentDiagnosticAnalyzer : DocumentDiagnosticAnalyzer
+        {
+            protected PriorityTestDocumentDiagnosticAnalyzer(int priority)
+            {
+                Priority = priority;
+            }
+
+            public override int Priority { get; }
+            public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray<DiagnosticDescriptor>.Empty;
+            public override Task<ImmutableArray<Diagnostic>> AnalyzeSemanticsAsync(Document document, CancellationToken cancellationToken)
+                => Task.FromResult(ImmutableArray<Diagnostic>.Empty);
+            public override Task<ImmutableArray<Diagnostic>> AnalyzeSyntaxAsync(Document document, CancellationToken cancellationToken)
+                => Task.FromResult(ImmutableArray<Diagnostic>.Empty);
+        }
+
+        private class PriorityTestProjectDiagnosticAnalyzer : ProjectDiagnosticAnalyzer
+        {
+            protected PriorityTestProjectDiagnosticAnalyzer(int priority)
+            {
+                Priority = priority;
+            }
+
+            public override int Priority { get; }
+            public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray<DiagnosticDescriptor>.Empty;
+            public override Task<ImmutableArray<Diagnostic>> AnalyzeProjectAsync(Project project, CancellationToken cancellationToken)
+                => Task.FromResult(ImmutableArray<Diagnostic>.Empty);
+        }
     }
 }

src/Features/Core/Portable/Diagnostics/Analyzers/DocumentDiagnosticAnalyzer.cs

@@ -11,6 +11,8 @@ namespace Microsoft.CodeAnalysis.Diagnostics
     /// </summary>
     internal abstract class DocumentDiagnosticAnalyzer : DiagnosticAnalyzer
     {
+        public const int DefaultPriority = 50;
+
         public abstract Task<ImmutableArray<Diagnostic>> AnalyzeSyntaxAsync(Document document, CancellationToken cancellationToken);
 
         public abstract Task<ImmutableArray<Diagnostic>> AnalyzeSemanticsAsync(Document document, CancellationToken cancellationToken);
@@ -21,5 +23,13 @@ internal abstract class DocumentDiagnosticAnalyzer : DiagnosticAnalyzer
         public sealed override void Initialize(AnalysisContext context)
         {
         }
+
+        /// <summary>
+        /// This lets vsix installed <see cref="DocumentDiagnosticAnalyzer"/> or <see cref="ProjectDiagnosticAnalyzer"/> to
+        /// specify priority of the analyzer. Regular <see cref="DiagnosticAnalyzer"/> always comes before those 2 different types.
+        /// Priority is ascending order and this only works on HostDiagnosticAnalyzer meaning Vsix installed analyzers in VS.
+        /// This is to support partner teams (such as typescript and F#) who want to order their analyzer's execution order.
+        /// </summary>
+        public virtual int Priority => DefaultPriority;
     }
 }

src/Features/Core/Portable/Diagnostics/Analyzers/ProjectDiagnosticAnalyzer.cs

@@ -11,6 +11,8 @@ namespace Microsoft.CodeAnalysis.Diagnostics
     /// </summary>
     internal abstract class ProjectDiagnosticAnalyzer : DiagnosticAnalyzer
     {
+        public const int DefaultPriority = 50;
+
         public abstract Task<ImmutableArray<Diagnostic>> AnalyzeProjectAsync(Project project, CancellationToken cancellationToken);
 
         /// <summary>
@@ -19,5 +21,13 @@ internal abstract class ProjectDiagnosticAnalyzer : DiagnosticAnalyzer
         public sealed override void Initialize(AnalysisContext context)
         {
         }
+
+        /// <summary>
+        /// This lets vsix installed <see cref="DocumentDiagnosticAnalyzer"/> or <see cref="ProjectDiagnosticAnalyzer"/> to
+        /// specify priority of the analyzer. Regular <see cref="DiagnosticAnalyzer"/> always comes before those 2 different types.
+        /// Priority is ascending order and this only works on HostDiagnosticAnalyzer meaning Vsix installed analyzers in VS.
+        /// This is to support partner teams (such as typescript and F#) who want to order their analyzer's execution order.
+        /// </summary>
+        public virtual int Priority => DefaultPriority;
     }
 }

src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.StateManager.HostStates.cs

@@ -1,5 +1,6 @@
 // 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.Generic;
 using System.Collections.Immutable;
 using System.Linq;
@@ -36,12 +37,6 @@ public IEnumerable<StateSet> GetOrCreateStateSets(string language)
                     return GetAnalyzerMap(language).GetStateSets();
                 }
 
-                public IEnumerable<DiagnosticAnalyzer> GetAnalyzers(string language)
-                {
-                    var map = GetAnalyzerMap(language);
-                    return map.GetAnalyzers();
-                }
-
                 public StateSet GetOrCreateStateSet(string language, DiagnosticAnalyzer analyzer)
                 {
                     return GetAnalyzerMap(language).GetStateSet(analyzer);
@@ -64,73 +59,68 @@ private DiagnosticAnalyzerMap CreateLanguageSpecificAnalyzerMap(string language,
 
                 private class DiagnosticAnalyzerMap
                 {
-                    private readonly DiagnosticAnalyzer _compilerAnalyzer;
+                    private const int BuiltInCompilerPriority = -2;
+                    private const int RegularDiagnosticAnalyzerPriority = -1;
+
                     private readonly StateSet _compilerStateSet;
 
+                    private readonly ImmutableArray<StateSet> _orderedSet;
                     private readonly ImmutableDictionary<DiagnosticAnalyzer, StateSet> _map;
 
                     public DiagnosticAnalyzerMap(HostAnalyzerManager analyzerManager, string language, ImmutableDictionary<DiagnosticAnalyzer, StateSet> analyzerMap)
                     {
-                        // hold directly on to compiler analyzer
-                        _compilerAnalyzer = analyzerManager.GetCompilerDiagnosticAnalyzer(language);
+                        _map = analyzerMap;
+
+                        var compilerAnalyzer = analyzerManager.GetCompilerDiagnosticAnalyzer(language);
 
                         // in test case, we might not have the compiler analyzer.
-                        if (_compilerAnalyzer == null)
+                        if (compilerAnalyzer != null)
                         {
-                            _map = analyzerMap;
-                            return;
+                            // hold onto stateSet for compiler analyzer
+                            _compilerStateSet = analyzerMap[compilerAnalyzer];
                         }
 
-                        _compilerStateSet = analyzerMap[_compilerAnalyzer];
-
-                        // hold rest of analyzers
-                        _map = analyzerMap.Remove(_compilerAnalyzer);
+                        // order statesets
+                        // order will be in this order
+                        // BuiltIn Compiler Analyzer (C#/VB) < Regular DiagnosticAnalyzers < Document/ProjectDiagnosticAnalyzers
+                        _orderedSet = _map.Values.OrderBy(PriorityComparison).ToImmutableArray();
                     }
 
-                    public IEnumerable<DiagnosticAnalyzer> GetAnalyzers()
+                    public ImmutableArray<StateSet> GetStateSets() => _orderedSet;
+
+                    public StateSet GetStateSet(DiagnosticAnalyzer analyzer)
                     {
-                        // always return compiler one first if it exists.
-                        // it might not exist in test environment.
-                        if (_compilerAnalyzer != null)
+                        if (_map.TryGetValue(analyzer, out var stateSet))
                         {
-                            yield return _compilerAnalyzer;
+                            return stateSet;
                         }
 
-                        foreach (var (analyzer, _) in _map)
-                        {
-                            yield return analyzer;
-                        }
+                        return null;
                     }
 
-                    public IEnumerable<StateSet> GetStateSets()
+                    private int PriorityComparison(StateSet state1, StateSet state2)
                     {
-                        // always return compiler one first if it exists.
-                        // it might not exist in test environment.
-                        if (_compilerAnalyzer != null)
-                        {
-                            yield return _compilerStateSet;
-                        }
-
-                        // TODO: for now, this is static, but in future, we might consider making this a dynamic so that we process cheaper analyzer first.
-                        foreach (var (_, set) in _map)
-                        {
-                            yield return set;
-                        }
+                        return GetPriority(state1) - GetPriority(state2);
                     }
 
-                    public StateSet GetStateSet(DiagnosticAnalyzer analyzer)
+                    private int GetPriority(StateSet state)
                     {
-                        if (_compilerAnalyzer == analyzer)
+                        // compiler gets highest priority
+                        if (state == _compilerStateSet)
                         {
-                            return _compilerStateSet;
+                            return BuiltInCompilerPriority;
                         }
 
-                        if (_map.TryGetValue(analyzer, out var set))
+                        switch (state.Analyzer)
                         {
-                            return set;
+                            case DocumentDiagnosticAnalyzer analyzer:
+                                return Math.Max(0, analyzer.Priority);
+                            case ProjectDiagnosticAnalyzer analyzer:
+                                return Math.Max(0, analyzer.Priority);
+                            default:
+                                // regular analyzer get next priority after compiler analyzer
+                                return RegularDiagnosticAnalyzerPriority;
                         }
-
-                        return null;
                     }
                 }
             }

src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.StateManager.cs

@@ -39,14 +39,6 @@ public StateManager(HostAnalyzerManager analyzerManager)
             /// </summary>
             public event EventHandler<ProjectAnalyzerReferenceChangedEventArgs> ProjectAnalyzerReferenceChanged;
 
-            /// <summary>
-            /// Return existing or new <see cref="DiagnosticAnalyzer"/>s for the given <see cref="Project"/>.
-            /// </summary>
-            public IEnumerable<DiagnosticAnalyzer> GetOrCreateAnalyzers(Project project)
-            {
-                return _hostStates.GetAnalyzers(project.Language).Concat(_projectStates.GetOrCreateAnalyzers(project));
-            }
-
             /// <summary>
             /// Return all <see cref="StateSet"/>.
             /// This will never create new <see cref="StateSet"/> but will return ones already created.

src/Features/Core/Portable/Diagnostics/EngineV2/DiagnosticIncrementalAnalyzer.cs

@@ -282,6 +282,11 @@ internal Action<Exception, DiagnosticAnalyzer, Diagnostic> GetOnAnalyzerExceptio
             return Owner.GetOnAnalyzerException(projectId, DiagnosticLogAggregator);
         }
 
+        internal IEnumerable<DiagnosticAnalyzer> GetAnalyzersTestOnly(Project project)
+        {
+            return _stateManager.GetOrCreateStateSets(project).Select(s => s.Analyzer);
+        }
+
         private static string GetDocumentLogMessage(string title, Document document, DiagnosticAnalyzer analyzer)
         {
             return $"{title}: ({document.FilePath ?? document.Name}), ({analyzer.ToString()})";

src/Features/Core/Portable/Diagnostics/HostAnalyzerManager.cs

@@ -221,15 +221,6 @@ public ImmutableDictionary<object, ImmutableArray<DiagnosticAnalyzer>> CreatePro
             return CreateDiagnosticAnalyzersPerReferenceMap(CreateProjectAnalyzerReferencesMap(project), project.Language);
         }
 
-        /// <summary>
-        /// Create <see cref="DiagnosticAnalyzer"/>s collection for given <paramref name="project"/>
-        /// </summary>
-        public ImmutableArray<DiagnosticAnalyzer> CreateDiagnosticAnalyzers(Project project)
-        {
-            var analyzersPerReferences = CreateDiagnosticAnalyzersPerReference(project);
-            return analyzersPerReferences.SelectMany(kv => kv.Value).ToImmutableArray();
-        }
-
         /// <summary>
         /// Check whether given <see cref="DiagnosticData"/> belong to compiler diagnostic analyzer
         /// </summary>