private async Task <IEnumerable <Diagnostic> > ComputeDocumentDiagnosticAnalyzerDiagnosticsAsync( Document document, DocumentDiagnosticAnalyzer analyzer, AnalysisKind kind, Compilation compilationOpt, CancellationToken cancellationToken) { using (var pooledObject = SharedPools.Default <List <Diagnostic> >().GetPooledObject()) { var diagnostics = pooledObject.Object; cancellationToken.ThrowIfCancellationRequested(); try { switch (kind) { case AnalysisKind.Syntax: await analyzer.AnalyzeSyntaxAsync(document, diagnostics.Add, cancellationToken).ConfigureAwait(false); return(compilationOpt == null?diagnostics.ToImmutableArrayOrEmpty() : CompilationWithAnalyzers.GetEffectiveDiagnostics(diagnostics, compilationOpt)); case AnalysisKind.Semantic: await analyzer.AnalyzeSemanticsAsync(document, diagnostics.Add, cancellationToken).ConfigureAwait(false); return(compilationOpt == null?diagnostics.ToImmutableArrayOrEmpty() : CompilationWithAnalyzers.GetEffectiveDiagnostics(diagnostics, compilationOpt)); default: return(Contract.FailWithReturn <ImmutableArray <Diagnostic> >("shouldn't reach here")); } } catch (Exception e) when(!IsCanceled(e, cancellationToken)) { OnAnalyzerException(analyzer, document.Project.Id, compilationOpt, e); return(ImmutableArray <Diagnostic> .Empty); } } }
private async Task <IEnumerable <Diagnostic> > ComputeDocumentDiagnosticAnalyzerDiagnosticsAsync( Document document, DocumentDiagnosticAnalyzer analyzer, AnalysisKind kind, Compilation compilationOpt, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); try { Task <ImmutableArray <Diagnostic> > analyzeAsync; switch (kind) { case AnalysisKind.Syntax: analyzeAsync = analyzer.AnalyzeSyntaxAsync(document, cancellationToken); break; case AnalysisKind.Semantic: analyzeAsync = analyzer.AnalyzeSemanticsAsync(document, cancellationToken); break; default: throw ExceptionUtilities.UnexpectedValue(kind); } var diagnostics = (await analyzeAsync.ConfigureAwait(false)).NullToEmpty(); if (compilationOpt != null) { return(CompilationWithAnalyzers.GetEffectiveDiagnostics(diagnostics, compilationOpt)); } #if DEBUG // since all DocumentDiagnosticAnalyzers are from internal users, we only do debug check. also this can be expensive at runtime // since it requires await. if we find any offender through NFW, we should be able to fix those since all those should // from intern teams. await VerifyDiagnosticLocationsAsync(diagnostics, document.Project, cancellationToken).ConfigureAwait(false); #endif return(diagnostics); } catch (Exception e) when(!IsCanceled(e, cancellationToken)) { OnAnalyzerException(analyzer, document.Project.Id, compilationOpt, e); return(ImmutableArray <Diagnostic> .Empty); } }
private async Task <IEnumerable <Diagnostic> > ComputeDocumentDiagnosticAnalyzerDiagnosticsAsync( Document document, DocumentDiagnosticAnalyzer analyzer, AnalysisKind kind, Compilation compilationOpt, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); try { Task <ImmutableArray <Diagnostic> > analyzeAsync; switch (kind) { case AnalysisKind.Syntax: analyzeAsync = analyzer.AnalyzeSyntaxAsync(document, cancellationToken); break; case AnalysisKind.Semantic: analyzeAsync = analyzer.AnalyzeSemanticsAsync(document, cancellationToken); break; default: throw ExceptionUtilities.UnexpectedValue(kind); } var diagnostics = (await analyzeAsync.ConfigureAwait(false)).NullToEmpty(); if (compilationOpt != null) { return(CompilationWithAnalyzers.GetEffectiveDiagnostics(diagnostics, compilationOpt)); } return(diagnostics); } catch (Exception e) when(!IsCanceled(e, cancellationToken)) { OnAnalyzerException(analyzer, document.Project.Id, compilationOpt, e); return(ImmutableArray <Diagnostic> .Empty); } }
private async Task<IEnumerable<Diagnostic>> ComputeDocumentDiagnosticAnalyzerDiagnosticsAsync( Document document, DocumentDiagnosticAnalyzer analyzer, AnalysisKind kind, Compilation compilationOpt, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); try { Task<ImmutableArray<Diagnostic>> analyzeAsync; switch (kind) { case AnalysisKind.Syntax: analyzeAsync = analyzer.AnalyzeSyntaxAsync(document, cancellationToken); break; case AnalysisKind.Semantic: analyzeAsync = analyzer.AnalyzeSemanticsAsync(document, cancellationToken); break; default: throw ExceptionUtilities.UnexpectedValue(kind); } var diagnostics = (await analyzeAsync.ConfigureAwait(false)).NullToEmpty(); if (compilationOpt != null) { return CompilationWithAnalyzers.GetEffectiveDiagnostics(diagnostics, compilationOpt); } return diagnostics; } catch (Exception e) when (!IsCanceled(e, cancellationToken)) { OnAnalyzerException(analyzer, document.Project.Id, compilationOpt, e); return ImmutableArray<Diagnostic>.Empty; } }
private async Task<IEnumerable<Diagnostic>> ComputeDocumentDiagnosticAnalyzerDiagnosticsAsync( Document document, DocumentDiagnosticAnalyzer analyzer, AnalysisKind kind, Compilation compilationOpt, CancellationToken cancellationToken) { using (var pooledObject = SharedPools.Default<List<Diagnostic>>().GetPooledObject()) { var diagnostics = pooledObject.Object; cancellationToken.ThrowIfCancellationRequested(); try { switch (kind) { case AnalysisKind.Syntax: await analyzer.AnalyzeSyntaxAsync(document, diagnostics.Add, cancellationToken).ConfigureAwait(false); return compilationOpt == null ? diagnostics.ToImmutableArrayOrEmpty() : CompilationWithAnalyzers.GetEffectiveDiagnostics(diagnostics, compilationOpt); case AnalysisKind.Semantic: await analyzer.AnalyzeSemanticsAsync(document, diagnostics.Add, cancellationToken).ConfigureAwait(false); return compilationOpt == null ? diagnostics.ToImmutableArrayOrEmpty() : CompilationWithAnalyzers.GetEffectiveDiagnostics(diagnostics, compilationOpt); default: return Contract.FailWithReturn<ImmutableArray<Diagnostic>>("shouldn't reach here"); } } catch (Exception e) when (!IsCanceled(e, cancellationToken)) { OnAnalyzerException(analyzer, document.Project.Id, compilationOpt, e); return ImmutableArray<Diagnostic>.Empty; } } }