internal static async Task <List <DiagnosticAnalyzer> > GetProviders(Project project)
{
var providers = new List <DiagnosticAnalyzer> ();
var alreadyAdded = new HashSet <Type> ();
var diagnostics = await CodeRefactoringService.GetCodeDiagnosticsAsync(new EmptyDocumentContext (project), LanguageNames.CSharp, default(CancellationToken));
var diagnosticTable = new Dictionary <string, CodeDiagnosticDescriptor> ();
foreach (var diagnostic in diagnostics)
{
if (alreadyAdded.Contains(diagnostic.DiagnosticAnalyzerType))
{
continue;
}
if (!diagnostic.IsEnabled)
{
continue;
}
alreadyAdded.Add(diagnostic.DiagnosticAnalyzerType);
var provider = diagnostic.GetProvider();
if (provider == null)
{
continue;
}
foreach (var diag in provider.SupportedDiagnostics)
{
diagnosticTable [diag.Id] = diagnostic;
}
providers.Add(provider);
}
return(providers);
}
static async Task GetDescriptorTable(AnalysisDocument analysisDocument, CancellationToken cancellationToken)
{
if (diagnosticTable != null)
{
return;
}
bool locked = await diagnosticLock.WaitAsync(Timeout.Infinite, cancellationToken).ConfigureAwait(false);
if (diagnosticTable != null)
{
return;
}
try {
var language = CodeRefactoringService.MimeTypeToLanguage(analysisDocument.Editor.MimeType);
var alreadyAdded = new HashSet <Type> ();
var table = new Dictionary <string, CodeDiagnosticDescriptor> ();
diagnostics = await CodeRefactoringService.GetCodeDiagnosticsAsync(analysisDocument.DocumentContext, language, cancellationToken);
foreach (var diagnostic in diagnostics)
{
if (!alreadyAdded.Add(diagnostic.DiagnosticAnalyzerType))
{
continue;
}
var provider = diagnostic.GetProvider();
if (provider == null)
{
continue;
}
foreach (var diag in provider.SupportedDiagnostics)
{
table [diag.Id] = diagnostic;
}
providers.Add(provider);
}
diagnosticTable = table;
} finally {
if (locked)
{
diagnosticLock.Release();
}
}
}
void GetAllSeverities()
{
var language = CodeRefactoringService.MimeTypeToLanguage(mimeType);
foreach (var node in options.AllDiagnostics)
{
if (!node.Languages.Contains(language))
{
continue;
}
foreach (var subIssue in node.GetProvider().SupportedDiagnostics.Where(IsConfigurable).ToList())
{
var sub = new Tuple <CodeDiagnosticDescriptor, DiagnosticDescriptor> (node, subIssue);
severities [sub] = node.GetSeverity(subIssue);
enableState [sub] = node.GetIsEnabled(subIssue);
}
}
}
void GetAllSeverities()
{
var language = CodeRefactoringService.MimeTypeToLanguage(mimeType);
var options = ((MonoDevelopWorkspaceDiagnosticAnalyzerProviderService)Ide.Composition.CompositionManager.GetExportedValue <IWorkspaceDiagnosticAnalyzerProviderService> ()).GetOptionsAsync().Result;
foreach (var node in options.AllDiagnostics)
{
if (!node.Languages.Contains(language))
{
continue;
}
foreach (var subIssue in node.GetProvider().SupportedDiagnostics.Where(IsConfigurable).ToList())
{
var sub = new Tuple <CodeDiagnosticDescriptor, DiagnosticDescriptor> (node, subIssue);
severities [sub] = node.GetSeverity(subIssue);
enableState [sub] = node.GetIsEnabled(subIssue);
}
}
}
void GetAllSeverities()
{
foreach (var node in BuiltInCodeDiagnosticProvider.GetBuiltInCodeDiagnosticDecsriptorsAsync(CodeRefactoringService.MimeTypeToLanguage(mimeType), true).Result)
{
var root = new Tuple <CodeDiagnosticDescriptor, DiagnosticDescriptor> (node, null);
severities [root] = node.DiagnosticSeverity;
enableState [root] = node.IsEnabled;
if (node.GetProvider().SupportedDiagnostics.Length > 1)
{
foreach (var subIssue in node.GetProvider().SupportedDiagnostics)
{
var sub = new Tuple <CodeDiagnosticDescriptor, DiagnosticDescriptor> (node, subIssue);
severities [sub] = node.GetSeverity(subIssue);
enableState [sub] = node.GetIsEnabled(subIssue);
}
}
}
}
public static IEnumerable <Result> Check(AnalysisDocument analysisDocument, CancellationToken cancellationToken)
{
var input = analysisDocument.DocumentContext;
if (!AnalysisOptions.EnableFancyFeatures || input.Project == null || !input.IsCompileableInProject || input.AnalysisDocument == null)
{
return(Enumerable.Empty <Result> ());
}
try {
var model = input.ParsedDocument.GetAst <SemanticModel> ();
if (model == null)
{
return(Enumerable.Empty <Result> ());
}
var compilation = model.Compilation;
var language = CodeRefactoringService.MimeTypeToLanguage(analysisDocument.Editor.MimeType);
var providers = new List <DiagnosticAnalyzer> ();
var alreadyAdded = new HashSet <Type>();
if (diagnostics == null)
{
diagnostics = CodeRefactoringService.GetCodeDiagnosticsAsync(analysisDocument.DocumentContext, language, cancellationToken).Result.ToList();
}
foreach (var diagnostic in diagnostics)
{
if (alreadyAdded.Contains(diagnostic.DiagnosticAnalyzerType))
{
continue;
}
alreadyAdded.Add(diagnostic.DiagnosticAnalyzerType);
var provider = diagnostic.GetProvider();
if (provider == null)
{
continue;
}
providers.Add(provider);
}
if (providers.Count == 0 || cancellationToken.IsCancellationRequested)
{
return(Enumerable.Empty <Result> ());
}
CompilationWithAnalyzers compilationWithAnalyzer;
var analyzers = System.Collections.Immutable.ImmutableArray <DiagnosticAnalyzer> .Empty.AddRange(providers);
var diagnosticList = new List <Diagnostic> ();
try {
compilationWithAnalyzer = compilation.WithAnalyzers(analyzers, null, cancellationToken);
if (input.ParsedDocument == null || cancellationToken.IsCancellationRequested)
{
return(Enumerable.Empty <Result> ());
}
diagnosticList.AddRange(compilationWithAnalyzer.GetAnalyzerSemanticDiagnosticsAsync(model, null, cancellationToken).Result);
} catch (Exception) {
return(Enumerable.Empty <Result> ());
} finally {
CompilationWithAnalyzers.ClearAnalyzerState(analyzers);
}
return(diagnosticList
.Where(d => !d.Id.StartsWith("CS", StringComparison.Ordinal))
.Select(diagnostic => {
var res = new DiagnosticResult(diagnostic);
// var line = analysisDocument.Editor.GetLineByOffset (res.Region.Start);
// Console.WriteLine (diagnostic.Id + "/" + res.Region +"/" + analysisDocument.Editor.GetTextAt (line));
return res;
}));
} catch (OperationCanceledException) {
return(Enumerable.Empty <Result> ());
} catch (AggregateException ae) {
ae.Flatten().Handle(ix => ix is OperationCanceledException);
return(Enumerable.Empty <Result> ());
} catch (Exception e) {
LoggingService.LogError("Error while running diagnostics.", e);
return(Enumerable.Empty <Result> ());
}
}
protected override async void Run()
{
var lang = "text/x-csharp";
OpenFileDialog dlg = new OpenFileDialog("Export Rules", MonoDevelop.Components.FileChooserAction.Save);
dlg.InitialFileName = "rules.html";
if (!dlg.Run())
{
return;
}
Dictionary <CodeDiagnosticDescriptor, DiagnosticSeverity?> severities = new Dictionary <CodeDiagnosticDescriptor, DiagnosticSeverity?> ();
var options = await((MonoDevelopWorkspaceDiagnosticAnalyzerProviderService)Ide.Composition.CompositionManager.GetExportedValue <IWorkspaceDiagnosticAnalyzerProviderService> ()).GetOptionsAsync();
var language = CodeRefactoringService.MimeTypeToLanguage(lang);
foreach (var node in options.AllDiagnostics.Where(x => x.Languages.Contains(language)))
{
severities [node] = node.DiagnosticSeverity;
// if (node.GetProvider ().SupportedDiagnostics.Length > 1) {
// foreach (var subIssue in node.GetProvider ().SupportedDiagnostics) {
// severities [subIssue] = node.GetSeverity (subIssue);
// }
// }
}
var grouped = severities.Keys.OfType <CodeDiagnosticDescriptor> ()
.GroupBy(node => node.GetProvider().SupportedDiagnostics.First().Category)
.OrderBy(g => g.Key, StringComparer.Ordinal);
using (var sw = new StreamWriter(dlg.SelectedFile)) {
sw.WriteLine("<h1>Code Rules</h1>");
foreach (var g in grouped)
{
sw.WriteLine("<h2>" + g.Key + "</h2>");
sw.WriteLine("<table border='1'>");
foreach (var node in g.Select(n => new { Descriptor = n, Provider = n.GetProvider() }).OrderBy(n => n.Provider.GetAnalyzerId(), StringComparer.Ordinal))
{
var title = node.Provider.GetAnalyzerId();
var desc = node.Provider.SupportedDiagnostics.First().Description.ToString() != title?node.Provider.SupportedDiagnostics.First().Description : "";
sw.WriteLine("<tr><td>" + title + "</td><td>" + desc + "</td><td>" + node.Descriptor.DiagnosticSeverity + "</td></tr>");
if (node.Provider.SupportedDiagnostics.Length > 1)
{
foreach (var subIssue in node.Provider.SupportedDiagnostics)
{
title = subIssue.Description.ToString();
desc = subIssue.Description.ToString() != title ? subIssue.Description : "";
sw.WriteLine("<tr><td> - " + title + "</td><td>" + desc + "</td><td>" + node.Descriptor.GetSeverity(subIssue) + "</td></tr>");
}
}
}
sw.WriteLine("</table>");
}
var providerStates = new Dictionary <CodeRefactoringDescriptor, bool> ();
foreach (var node in options.AllRefactorings.Where(x => x.Language.Contains(language)))
{
providerStates [node] = node.IsEnabled;
}
sw.WriteLine("<h1>Code Actions</h1>");
sw.WriteLine("<table border='1'>");
var sortedAndFiltered = providerStates.Keys.OrderBy(n => n.Name, StringComparer.Ordinal);
foreach (var node in sortedAndFiltered)
{
sw.WriteLine("<tr><td>" + node.IdString + "</td><td>" + node.Name + "</td></tr>");
}
sw.WriteLine("</table>");
}
}
public static async Task <IEnumerable <Result> > Check(AnalysisDocument analysisDocument, CancellationToken cancellationToken)
{
var input = analysisDocument.DocumentContext;
if (!AnalysisOptions.EnableFancyFeatures || input.Project == null || !input.IsCompileableInProject || input.AnalysisDocument == null)
{
return(Enumerable.Empty <Result> ());
}
if (SkipContext(input))
{
return(Enumerable.Empty <Result> ());
}
try {
var model = await analysisDocument.DocumentContext.AnalysisDocument.GetSemanticModelAsync(cancellationToken);
if (model == null)
{
return(Enumerable.Empty <Result> ());
}
var compilation = model.Compilation;
var language = CodeRefactoringService.MimeTypeToLanguage(analysisDocument.Editor.MimeType);
var providers = new List <DiagnosticAnalyzer> ();
var alreadyAdded = new HashSet <Type>();
if (diagnostics == null)
{
diagnostics = await CodeRefactoringService.GetCodeDiagnosticsAsync(analysisDocument.DocumentContext, language, cancellationToken);
}
var diagnosticTable = new Dictionary <string, CodeDiagnosticDescriptor> ();
foreach (var diagnostic in diagnostics)
{
if (alreadyAdded.Contains(diagnostic.DiagnosticAnalyzerType))
{
continue;
}
if (!diagnostic.IsEnabled)
{
continue;
}
alreadyAdded.Add(diagnostic.DiagnosticAnalyzerType);
var provider = diagnostic.GetProvider();
if (provider == null)
{
continue;
}
foreach (var diag in provider.SupportedDiagnostics)
{
diagnosticTable [diag.Id] = diagnostic;
}
providers.Add(provider);
}
if (providers.Count == 0 || cancellationToken.IsCancellationRequested)
{
return(Enumerable.Empty <Result> ());
}
#if DEBUG
Debug.Listeners.Add(consoleTraceListener);
#endif
CompilationWithAnalyzers compilationWithAnalyzer;
var analyzers = ImmutableArray <DiagnosticAnalyzer> .Empty.AddRange(providers);
var diagnosticList = new List <Diagnostic> ();
try {
var sol = analysisDocument.DocumentContext.AnalysisDocument.Project.Solution;
var options = new CompilationWithAnalyzersOptions(
new WorkspaceAnalyzerOptions(
new AnalyzerOptions(ImmutableArray <AdditionalText> .Empty),
sol.Options,
sol),
delegate(Exception exception, DiagnosticAnalyzer analyzer, Diagnostic diag) {
LoggingService.LogError("Exception in diagnostic analyzer " + diag.Id + ":" + diag.GetMessage(), exception);
},
false,
false
);
compilationWithAnalyzer = compilation.WithAnalyzers(analyzers, options);
if (input.ParsedDocument == null || cancellationToken.IsCancellationRequested)
{
return(Enumerable.Empty <Result> ());
}
diagnosticList.AddRange(await compilationWithAnalyzer.GetAnalyzerSemanticDiagnosticsAsync(model, null, cancellationToken).ConfigureAwait(false));
diagnosticList.AddRange(await compilationWithAnalyzer.GetAnalyzerSyntaxDiagnosticsAsync(model.SyntaxTree, cancellationToken).ConfigureAwait(false));
} catch (OperationCanceledException) {
} catch (AggregateException ae) {
ae.Flatten().Handle(ix => ix is OperationCanceledException);
} catch (Exception ex) {
LoggingService.LogError("Error creating analyzer compilation", ex);
return(Enumerable.Empty <Result> ());
} finally {
#if DEBUG
Debug.Listeners.Remove(consoleTraceListener);
#endif
CompilationWithAnalyzers.ClearAnalyzerState(analyzers);
}
return(diagnosticList
.Where(d => !d.Id.StartsWith("CS", StringComparison.Ordinal))
.Where(d => diagnosticTable[d.Id].GetIsEnabled(d.Descriptor))
.Select(diagnostic => {
var res = new DiagnosticResult(diagnostic);
// var line = analysisDocument.Editor.GetLineByOffset (res.Region.Start);
// Console.WriteLine (diagnostic.Id + "/" + res.Region +"/" + analysisDocument.Editor.GetTextAt (line));
return res;
}));
} catch (OperationCanceledException) {
return(Enumerable.Empty <Result> ());
} catch (AggregateException ae) {
ae.Flatten().Handle(ix => ix is OperationCanceledException);
return(Enumerable.Empty <Result> ());
} catch (Exception e) {
LoggingService.LogError("Error while running diagnostics.", e);
return(Enumerable.Empty <Result> ());
}
}
private IEnumerable <CodeRefactoringProvider> GetProviders(Document document)
{
return(CodeRefactoringService.GetDefaultCodeRefactoringProviders(document));
}
void GetAllSeverities()
{
foreach (var node in BuiltInCodeDiagnosticProvider.GetBuiltInCodeDiagnosticDescriptorsAsync(CodeRefactoringService.MimeTypeToLanguage(mimeType), true).Result)
{
foreach (var subIssue in node.GetProvider().SupportedDiagnostics.Where(IsConfigurable).ToList())
{
var sub = new Tuple <CodeDiagnosticDescriptor, DiagnosticDescriptor> (node, subIssue);
severities [sub] = node.GetSeverity(subIssue);
enableState [sub] = node.GetIsEnabled(subIssue);
}
}
}
protected override void Run()
{
var lang = "text/x-csharp";
OpenFileDialog dlg = new OpenFileDialog("Export Rules", MonoDevelop.Components.FileChooserAction.Save);
dlg.InitialFileName = "rules.html";
if (!dlg.Run())
{
return;
}
Dictionary <CodeDiagnosticDescriptor, DiagnosticSeverity?> severities = new Dictionary <CodeDiagnosticDescriptor, DiagnosticSeverity?> ();
foreach (var node in BuiltInCodeDiagnosticProvider.GetBuiltInCodeDiagnosticDecsriptorsAsync(CodeRefactoringService.MimeTypeToLanguage(lang), true).Result)
{
severities [node] = node.DiagnosticSeverity;
// if (node.GetProvider ().SupportedDiagnostics.Length > 1) {
// foreach (var subIssue in node.GetProvider ().SupportedDiagnostics) {
// severities [subIssue] = node.GetSeverity (subIssue);
// }
// }
}
var grouped = severities.Keys.OfType <CodeDiagnosticDescriptor> ()
.GroupBy(node => node.GetProvider().SupportedDiagnostics.First().Category)
.OrderBy(g => g.Key, StringComparer.Ordinal);
using (var sw = new StreamWriter(dlg.SelectedFile)) {
sw.WriteLine("<h1>Code Rules</h1>");
foreach (var g in grouped)
{
sw.WriteLine("<h2>" + g.Key + "</h2>");
sw.WriteLine("<table border='1'>");
foreach (var node in g.OrderBy(n => n.Name, StringComparer.Ordinal))
{
var title = node.Name;
var desc = node.GetProvider().SupportedDiagnostics.First().Description.ToString() != title?node.GetProvider().SupportedDiagnostics.First().Description : "";
sw.WriteLine("<tr><td>" + title + "</td><td>" + desc + "</td><td>" + node.DiagnosticSeverity + "</td></tr>");
if (node.GetProvider().SupportedDiagnostics.Length > 1)
{
foreach (var subIssue in node.GetProvider().SupportedDiagnostics)
{
title = subIssue.Description.ToString();
desc = subIssue.Description.ToString() != title ? subIssue.Description : "";
sw.WriteLine("<tr><td> - " + title + "</td><td>" + desc + "</td><td>" + node.GetSeverity(subIssue) + "</td></tr>");
}
}
}
sw.WriteLine("</table>");
}
var providerStates = new Dictionary <CodeRefactoringDescriptor, bool> ();
foreach (var node in BuiltInCodeDiagnosticProvider.GetBuiltInCodeRefactoringDescriptorsAsync(CodeRefactoringService.MimeTypeToLanguage(lang), true).Result)
{
providerStates [node] = node.IsEnabled;
}
sw.WriteLine("<h1>Code Actions</h1>");
sw.WriteLine("<table border='1'>");
var sortedAndFiltered = providerStates.Keys.OrderBy(n => n.Name, StringComparer.Ordinal);
foreach (var node in sortedAndFiltered)
{
sw.WriteLine("<tr><td>" + node.IdString + "</td><td>" + node.Name + "</td></tr>");
}
sw.WriteLine("</table>");
}
}
