/// <summary> /// Executes the compilation start actions and returns the per-compilation analyzer actions added by these actions. /// </summary> /// <param name="actions"><see cref="AnalyzerActions"/> whose compilation start actions are to be executed.</param> /// <param name="analyzer">Analyzer on which compilation start actions have to be executed.</param> /// <param name="compilation">Compilation to be used in the analysis.</param> /// <param name="analyzerOptions">Analyzer options.</param> /// <param name="addDiagnostic">Delegate to add diagnostics.</param> /// <param name="continueOnAnalyzerException">Predicate to decide if exceptions from the action should be handled or not.</param> /// <param name="cancellationToken">Cancellation token.</param> public static AnalyzerActions ExecuteCompilationStartActions( AnalyzerActions actions, DiagnosticAnalyzer analyzer, Compilation compilation, AnalyzerOptions analyzerOptions, Action <Diagnostic> addDiagnostic, Func <Exception, DiagnosticAnalyzer, bool> continueOnAnalyzerException, CancellationToken cancellationToken) { VerifyArguments(compilation, actions, analyzerOptions, analyzer, addDiagnostic, continueOnAnalyzerException); HostCompilationStartAnalysisScope compilationScope = new HostCompilationStartAnalysisScope(new HostSessionStartAnalysisScope()); foreach (var startAction in actions.CompilationStartActions) { if (startAction.Analyzer == analyzer) { cancellationToken.ThrowIfCancellationRequested(); ExecuteAndCatchIfThrows(analyzer, addDiagnostic, continueOnAnalyzerException, () => { startAction.Action(new AnalyzerCompilationStartAnalysisContext(analyzer, compilationScope, compilation, analyzerOptions, cancellationToken)); }, cancellationToken); } } return(compilationScope.GetAnalyzerActions(analyzer)); }
public AnalyzerCompilationStartAnalysisContext( DiagnosticAnalyzer analyzer, HostCompilationStartAnalysisScope scope, Compilation compilation, AnalyzerOptions options, CompilationAnalysisValueProviderFactory compilationAnalysisValueProviderFactory, CancellationToken cancellationToken) : base(compilation, options, cancellationToken) { _analyzer = analyzer; _scope = scope; _compilationAnalysisValueProviderFactory = compilationAnalysisValueProviderFactory; }
/// <summary> /// Get all the analyzer actions to execute for the given analyzer against a given compilation. /// The returned actions include the actions registered during <see cref="DiagnosticAnalyzer.Initialize(AnalysisContext)"/> method as well as /// the actions registered during <see cref="CompilationStartAnalyzerAction"/> for the given compilation. /// </summary> public async Task <AnalyzerActions> GetAnalyzerActionsAsync(DiagnosticAnalyzer analyzer, AnalyzerExecutor analyzerExecutor) { HostSessionStartAnalysisScope sessionScope = await GetSessionAnalysisScopeAsync(analyzer, analyzerExecutor).ConfigureAwait(false); if (sessionScope.CompilationStartActions.Length > 0 && analyzerExecutor.Compilation != null) { HostCompilationStartAnalysisScope compilationScope = await GetCompilationAnalysisScopeAsync(analyzer, sessionScope, analyzerExecutor).ConfigureAwait(false); return(compilationScope.GetAnalyzerActions(analyzer)); } return(sessionScope.GetAnalyzerActions(analyzer)); }
private Task <HostCompilationStartAnalysisScope> GetCompilationAnalysisScopeCoreAsync( DiagnosticAnalyzer analyzer, HostSessionStartAnalysisScope sessionScope, AnalyzerExecutor analyzerExecutor) { Func <DiagnosticAnalyzer, Task <HostCompilationStartAnalysisScope> > getTask = a => { return(Task.Run(() => { var compilationAnalysisScope = new HostCompilationStartAnalysisScope(sessionScope); analyzerExecutor.ExecuteCompilationStartActions(sessionScope.CompilationStartActions, compilationAnalysisScope); return compilationAnalysisScope; }, analyzerExecutor.CancellationToken)); }; var compilationActionsMap = _compilationScopeMap.GetOrCreateValue(analyzerExecutor.Compilation); return(compilationActionsMap.GetOrAdd(analyzer, getTask)); }
public Task <HostCompilationStartAnalysisScope> GetCompilationAnalysisScopeAsync( HostSessionStartAnalysisScope sessionScope, AnalyzerExecutor analyzerExecutor) { lock (_gate) { if (_lazyCompilationScopeTask == null) { _lazyCompilationScopeTask = Task.Run(() => { var compilationAnalysisScope = new HostCompilationStartAnalysisScope(sessionScope); analyzerExecutor.ExecuteCompilationStartActions(sessionScope.GetAnalyzerActions(_analyzer).CompilationStartActions, compilationAnalysisScope); return(compilationAnalysisScope); }, analyzerExecutor.CancellationToken); } return(_lazyCompilationScopeTask); } }
private Task <HostCompilationStartAnalysisScope> GetCompilationAnalysisScopeCoreAsync( AnalyzerAndOptions analyzerAndOptions, HostSessionStartAnalysisScope sessionScope, AnalyzerExecutor analyzerExecutor) { Func <AnalyzerAndOptions, Task <HostCompilationStartAnalysisScope> > getTask = a => { return(Task.Run(() => { var compilationAnalysisScope = new HostCompilationStartAnalysisScope(sessionScope); analyzerExecutor.ExecuteCompilationStartActions(sessionScope.CompilationStartActions, compilationAnalysisScope); return compilationAnalysisScope; }, analyzerExecutor.CancellationToken)); }; var compilationActionsMap = _compilationScopeMap.GetValue(analyzerExecutor.Compilation, _compilationScopeMapCallback); return(compilationActionsMap.GetOrAdd(analyzerAndOptions, getTask)); }
public Task <HostCompilationStartAnalysisScope> GetCompilationAnalysisScopeAsync( HostSessionStartAnalysisScope sessionScope, AnalyzerExecutor analyzerExecutor) { Func <Compilation, Task <HostCompilationStartAnalysisScope> > getTask = comp => { return(Task.Run(() => { var compilationAnalysisScope = new HostCompilationStartAnalysisScope(sessionScope); analyzerExecutor.ExecuteCompilationStartActions(sessionScope.CompilationStartActions, compilationAnalysisScope); return compilationAnalysisScope; }, analyzerExecutor.CancellationToken)); }; var callback = new ConditionalWeakTable <Compilation, Task <HostCompilationStartAnalysisScope> > .CreateValueCallback(getTask); var compilationActionsCache = GetOrCreateCompilationActionsCache(analyzerExecutor.AnalyzerOptions); return(compilationActionsCache.GetValue(analyzerExecutor.Compilation, callback)); }
private Task <HostCompilationStartAnalysisScope> GetCompilationAnalysisScopeCoreAsync( AnalyzerAndOptions analyzerAndOptions, HostSessionStartAnalysisScope sessionScope, AnalyzerExecutor analyzerExecutor) { Func <Compilation, Task <HostCompilationStartAnalysisScope> > getTask = comp => { return(Task.Run(() => { var compilationAnalysisScope = new HostCompilationStartAnalysisScope(sessionScope); analyzerExecutor.ExecuteCompilationStartActions(sessionScope.CompilationStartActions, compilationAnalysisScope); return compilationAnalysisScope; }, analyzerExecutor.CancellationToken)); }; var callback = new ConditionalWeakTable <Compilation, Task <HostCompilationStartAnalysisScope> > .CreateValueCallback(getTask); var compilationActionsMap = _compilationScopeMap.GetOrAdd(analyzerAndOptions, new ConditionalWeakTable <Compilation, Task <HostCompilationStartAnalysisScope> >()); return(compilationActionsMap.GetValue(analyzerExecutor.Compilation, callback)); }
/// <summary> /// Executes the compilation end actions. /// </summary> /// <param name="actions"><see cref="AnalyzerActions"/> whose compilation end actions are to be executed.</param> /// <param name="compilation">Compilation to be used in the analysis.</param> /// <param name="analyzerOptions">Analyzer options.</param> /// <param name="addDiagnostic">Delegate to add diagnostics.</param> /// <param name="continueOnAnalyzerException">Predicate to decide if exceptions from the action should be handled or not.</param> /// <param name="cancellationToken">Cancellation token.</param> public static void ExecuteCompilationEndActions( AnalyzerActions actions, Compilation compilation, AnalyzerOptions analyzerOptions, Action <Diagnostic> addDiagnostic, Func <Exception, DiagnosticAnalyzer, bool> continueOnAnalyzerException, CancellationToken cancellationToken) { VerifyArguments(compilation, actions, analyzerOptions, addDiagnostic, continueOnAnalyzerException); HostCompilationStartAnalysisScope compilationScope = new HostCompilationStartAnalysisScope(new HostSessionStartAnalysisScope()); foreach (var endAction in actions.CompilationEndActions) { cancellationToken.ThrowIfCancellationRequested(); ExecuteAndCatchIfThrows(endAction.Analyzer, addDiagnostic, continueOnAnalyzerException, () => { var context = new CompilationEndAnalysisContext(compilation, analyzerOptions, addDiagnostic, cancellationToken); endAction.Action(context); }, cancellationToken); } }
public Task <HostCompilationStartAnalysisScope> GetCompilationAnalysisScopeAsync( HostSessionStartAnalysisScope sessionScope, AnalyzerExecutor analyzerExecutor) { lock (_gate) { _lazyCompilationScopeCache = _lazyCompilationScopeCache ?? new ConditionalWeakTable <Compilation, Dictionary <AnalyzerOptions, Task <HostCompilationStartAnalysisScope> > >(); var compilationActionsMap = _lazyCompilationScopeCache.GetOrCreateValue(analyzerExecutor.Compilation); Task <HostCompilationStartAnalysisScope> task; if (!compilationActionsMap.TryGetValue(analyzerExecutor.AnalyzerOptions, out task)) { task = Task.Run(() => { var compilationAnalysisScope = new HostCompilationStartAnalysisScope(sessionScope); analyzerExecutor.ExecuteCompilationStartActions(sessionScope.CompilationStartActions, compilationAnalysisScope); return(compilationAnalysisScope); }, analyzerExecutor.CancellationToken); compilationActionsMap.Add(analyzerExecutor.AnalyzerOptions, task); } return(task); } }
public AnalyzerCompilationStartAnalysisContext(DiagnosticAnalyzer analyzer, HostCompilationStartAnalysisScope scope, Compilation compilation, AnalyzerOptions options, CancellationToken cancellationToken) : base(compilation, options, cancellationToken) { _analyzer = analyzer; _scope = scope; }
/// <summary> /// Executes the compilation start actions. /// </summary> /// <param name="actions"><see cref="AnalyzerActions"/> whose compilation start actions are to be executed.</param> /// <param name="compilationScope">Compilation scope to store the analyzer actions.</param> public void ExecuteCompilationStartActions(ImmutableArray <CompilationStartAnalyzerAction> actions, HostCompilationStartAnalysisScope compilationScope) { foreach (var startAction in actions) { _cancellationToken.ThrowIfCancellationRequested(); ExecuteAndCatchIfThrows(startAction.Analyzer, () => startAction.Action(new AnalyzerCompilationStartAnalysisContext(startAction.Analyzer, compilationScope, _compilation, _analyzerOptions, _cancellationToken))); } }