async void OnDiagnosticsUpdated(object sender, DiagnosticsUpdatedArgs e)
{
if (!enabled)
{
return;
}
var doc = DocumentContext.ParsedDocument;
if (doc == null || DocumentContext.IsAdHocProject)
{
return;
}
if (DocumentContext.AnalysisDocument == null)
{
return;
}
if (e.DocumentId != DocumentContext.AnalysisDocument.Id || e.ProjectId != DocumentContext.AnalysisDocument.Project.Id)
{
return;
}
var token = CancelUpdateTimeout(e.Id);
var ad = new AnalysisDocument(Editor, DocumentContext);
try {
var result = await CodeDiagnosticRunner.Check(ad, token, e.Diagnostics).ConfigureAwait(false);
var updater = new ResultsUpdater(this, result, e.Id, token);
updater.Update();
} catch (Exception) {
}
}
async void OnDiagnosticsUpdated(object sender, DiagnosticsUpdatedArgs e)
{
if (!enabled)
{
return;
}
var doc = DocumentContext.ParsedDocument;
if (doc == null || DocumentContext.IsAdHocProject)
{
return;
}
var cad = DocumentContext.AnalysisDocument;
if (cad == null || cad.Project == null)
{
return;
}
if (e.DocumentId != cad.Id || e.ProjectId != cad.Project.Id)
{
return;
}
var token = CancelUpdateTimeout(e.Id);
var ad = new AnalysisDocument(Editor, DocumentContext);
try {
var result = await CodeDiagnosticRunner.Check(ad, token, e.Diagnostics).ConfigureAwait(false);
if (result is IReadOnlyList <Result> resultList)
{
await Runtime.RunInMainThread(delegate {
if (resultUpdaters.TryGetValue(e.Id, out var oldUpdater))
{
oldUpdater.Cancel();
}
var updater = new ResultsUpdater(this, resultList, e.Id);
updater.Start();
resultUpdaters [e.Id] = updater;
});
}
void UpdateInitialDiagnostics()
{
if (!AnalysisOptions.EnableFancyFeatures)
{
return;
}
var doc = DocumentContext.AnalysisDocument;
if (doc == null || DocumentContext.IsAdHocProject)
{
return;
}
var ad = new AnalysisDocument(Editor, DocumentContext);
Task.Run(() => {
var ws = DocumentContext.RoslynWorkspace;
var analysisDocument = DocumentContext.AnalysisDocument;
if (analysisDocument == null)
{
return;
}
var project = analysisDocument.Project.Id;
var document = analysisDocument.Id;
// Force an initial diagnostic update from the engine.
foreach (var updateArgs in diagService.GetDiagnosticsUpdatedEventArgs(ws, project, document, src.Token))
{
var diagnostics = AdjustInitialDiagnostics(analysisDocument.Project.Solution, updateArgs, src.Token);
if (diagnostics.Length == 0)
{
continue;
}
var e = DiagnosticsUpdatedArgs.DiagnosticsCreated(
updateArgs.Id, updateArgs.Workspace, analysisDocument.Project.Solution, updateArgs.ProjectId, updateArgs.DocumentId, diagnostics);
OnDiagnosticsUpdated(this, e);
}
});
}
void OnDocumentParsed(object sender, EventArgs args)
{
if (!AnalysisOptions.EnableFancyFeatures)
{
return;
}
CancelUpdateTimout();
var doc = DocumentContext.ParsedDocument;
if (doc == null)
{
return;
}
updateTimeout = GLib.Timeout.Add(250, delegate {
lock (updateLock) {
CancelTask();
src = new CancellationTokenSource();
var token = src.Token;
var ad = new AnalysisDocument(Editor, DocumentContext);
oldTask = Task.Run(() => {
try {
var result = CodeDiagnosticRunner.Check(ad, token);
if (token.IsCancellationRequested)
{
return;
}
var updater = new ResultsUpdater(this, result, token);
updater.Update();
} catch (OperationCanceledException) {
} catch (AggregateException) {
}
});
updateTimeout = 0;
return(false);
}
});
}
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> ();
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 = await CodeRefactoringService.GetCodeDiagnosticsAsync (analysisDocument.DocumentContext, language, cancellationToken);
}
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> ();
#if DEBUG
Debug.Listeners.Add (consoleTraceListener);
#endif
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 (await compilationWithAnalyzer.GetAnalyzerSemanticDiagnosticsAsync (model, null, cancellationToken).ConfigureAwait (false));
diagnosticList.AddRange (await compilationWithAnalyzer.GetAnalyzerSyntaxDiagnosticsAsync (model.SyntaxTree, cancellationToken).ConfigureAwait (false));
} catch (Exception) {
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))
.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> ();
}
}
void OnDocumentParsed (object sender, EventArgs args)
{
if (!AnalysisOptions.EnableFancyFeatures)
return;
CancelUpdateTimout ();
var doc = DocumentContext.ParsedDocument;
if (doc == null || DocumentContext.IsAdHocProject)
return;
updateTimeout = GLib.Timeout.Add (250, delegate {
lock (updateLock) {
CancelTask ();
src = new CancellationTokenSource ();
var token = src.Token;
var ad = new AnalysisDocument (Editor, DocumentContext);
Task.Run (() => {
try {
var result = CodeDiagnosticRunner.Check (ad, token).Result;
if (token.IsCancellationRequested)
return;
var updater = new ResultsUpdater (this, result, token);
updater.Update ();
} catch (OperationCanceledException) {
} catch (AggregateException) {
}
});
updateTimeout = 0;
return false;
}
});
}
