/// <summary>
/// Creates a new <see cref="CompilationWithAnalyzersOptions"/>.
/// </summary>
/// <param name="options">Options that are passed to analyzers.</param>
/// <param name="onAnalyzerException">Action to invoke if an analyzer throws an exception.</param>
/// <param name="concurrentAnalysis">Flag indicating whether analysis can be performed concurrently on multiple threads.</param>
/// <param name="logAnalyzerExecutionTime">Flag indicating whether analyzer execution time should be logged.</param>
public CompilationWithAnalyzersOptions(AnalyzerOptions options, Action<Exception, DiagnosticAnalyzer, Diagnostic> onAnalyzerException, bool concurrentAnalysis, bool logAnalyzerExecutionTime)
{
_options = options;
_onAnalyzerException = onAnalyzerException;
_concurrentAnalysis = concurrentAnalysis;
_logAnalyzerExecutionTime = logAnalyzerExecutionTime;
}
public IDiagnosticAnalyzer CreateAnalyzerWithinCompilation(Compilation compilation, AnalyzerOptions options, CancellationToken cancellationToken)
{
var eventHandler = WellKnownTypes.EventHandler(compilation);
if (eventHandler == null)
{
return null;
}
var genericEventHandler = WellKnownTypes.GenericEventHandler(compilation);
if (genericEventHandler == null)
{
return null;
}
var eventArgs = WellKnownTypes.EventArgs(compilation);
if (eventArgs == null)
{
return null;
}
var comSourceInterfacesAttribute = WellKnownTypes.ComSourceInterfaceAttribute(compilation);
if (comSourceInterfacesAttribute == null)
{
return null;
}
return GetAnalyzer(compilation, eventHandler, genericEventHandler, eventArgs, comSourceInterfacesAttribute);
}
/// <summary>
/// Create an analyzer driver.
/// </summary>
/// <param name="analyzers">The set of analyzers to include in the analysis</param>
/// <param name="options">Options that are passed to analyzers</param>
/// <param name="cancellationToken">a cancellation token that can be used to abort analysis</param>
/// <param name="continueOnAnalyzerException">Delegate which is invoked when an analyzer throws an exception.
/// If a non-null delegate is provided and it returns true, then the exception is handled and converted into a diagnostic and driver continues with other analyzers.
/// Otherwise if it returns false, then the exception is not handled by the driver.
/// If null, then the driver always handles the exception.
/// </param>
protected AnalyzerDriver(ImmutableArray<IDiagnosticAnalyzer> analyzers, AnalyzerOptions options, CancellationToken cancellationToken, Func<Exception, IDiagnosticAnalyzer, bool> continueOnAnalyzerException = null)
{
this.CompilationEventQueue = new AsyncQueue<CompilationEvent>();
this.DiagnosticQueue = new AsyncQueue<Diagnostic>();
this.addDiagnostic = GetDiagnosticSinkWithSuppression();
this.analyzerOptions = options;
Func<Exception, IDiagnosticAnalyzer, bool> defaultExceptionHandler = (exception, analyzer) => true;
this.continueOnAnalyzerException = continueOnAnalyzerException ?? defaultExceptionHandler;
// start the first task to drain the event queue. The first compilation event is to be handled before
// any other ones, so we cannot have more than one event processing task until the first event has been handled.
initialWorker = Task.Run(async () =>
{
try
{
await InitialWorkerAsync(analyzers, continueOnAnalyzerException, cancellationToken).ConfigureAwait(false);
}
catch (OperationCanceledException)
{
// If creation is cancelled we had better not use the driver any longer
this.Dispose();
}
});
}
public ICodeBlockEndedAnalyzer OnCodeBlockStarted(SyntaxNode codeBlock, ISymbol ownerSymbol, SemanticModel semanticModel, Action<Diagnostic> addDiagnostic, AnalyzerOptions options, CancellationToken cancellationToken)
{
var methodSymbol = ownerSymbol as IMethodSymbol;
if (methodSymbol == null ||
methodSymbol.ReturnsVoid ||
methodSymbol.ReturnType.Kind == SymbolKind.ArrayType ||
methodSymbol.Parameters.Length > 0 ||
!(methodSymbol.DeclaredAccessibility == Accessibility.Public || methodSymbol.DeclaredAccessibility == Accessibility.Protected) ||
methodSymbol.IsAccessorMethod() ||
!IsPropertyLikeName(methodSymbol.Name))
{
return null;
}
// Fxcop has a few additional checks to reduce the noise for this diagnostic:
// Ensure that the method is non-generic, non-virtual/override, has no overloads and doesn't have special names: 'GetHashCode' or 'GetEnumerator'.
// Also avoid generating this diagnostic if the method body has any invocation expressions.
if (methodSymbol.IsGenericMethod ||
methodSymbol.IsVirtual ||
methodSymbol.IsOverride ||
methodSymbol.ContainingType.GetMembers(methodSymbol.Name).Length > 1 ||
methodSymbol.Name == GetHashCodeName ||
methodSymbol.Name == GetEnumeratorName)
{
return null;
}
return GetCodeBlockEndedAnalyzer();
}
public void AnalyzeCompilation(Compilation compilation, Action<Diagnostic> addDiagnostic, AnalyzerOptions options, CancellationToken cancellationToken)
{
if (AssemblyHasPublicTypes(compilation.Assembly))
{
var comVisibleAttributeSymbol = WellKnownTypes.ComVisibleAttribute(compilation);
if (comVisibleAttributeSymbol == null)
{
return;
}
var attributeInstance = compilation.Assembly.GetAttributes().FirstOrDefault(a => a.AttributeClass.Equals(comVisibleAttributeSymbol));
if (attributeInstance != null)
{
if (attributeInstance.ConstructorArguments.Length > 0 &&
attributeInstance.ConstructorArguments[0].Kind == TypedConstantKind.Primitive &&
attributeInstance.ConstructorArguments[0].Value != null &
attributeInstance.ConstructorArguments[0].Value.Equals(true))
{
// Has the attribute, with the value 'true'.
addDiagnostic(Diagnostic.Create(Rule, Location.None, string.Format(FxCopRulesResources.CA1017_AttributeTrue, compilation.Assembly.Name)));
}
}
else
{
// No ComVisible attribute at all.
addDiagnostic(Diagnostic.Create(Rule, Location.None, string.Format(FxCopRulesResources.CA1017_NoAttribute, compilation.Assembly.Name)));
}
}
return;
}
public ICompilationEndedAnalyzer OnCompilationStarted(Compilation compilation, Action<Diagnostic> addDiagnostic, AnalyzerOptions options, CancellationToken cancellationToken)
{
var eventHandler = WellKnownTypes.EventHandler(compilation);
if (eventHandler == null)
{
return null;
}
var genericEventHandler = WellKnownTypes.GenericEventHandler(compilation);
if (genericEventHandler == null)
{
return null;
}
var eventArgs = WellKnownTypes.EventArgs(compilation);
if (eventArgs == null)
{
return null;
}
var comSourceInterfacesAttribute = WellKnownTypes.ComSourceInterfaceAttribute(compilation);
if (comSourceInterfacesAttribute == null)
{
return null;
}
return GetAnalyzer(compilation, eventHandler, genericEventHandler, eventArgs, comSourceInterfacesAttribute);
}
public IDiagnosticAnalyzer CreateAnalyzerWithinCompilation(Compilation compilation, AnalyzerOptions options, CancellationToken cancellationToken)
{
var iserializableTypeSymbol = compilation.GetTypeByMetadataName("System.Runtime.Serialization.ISerializable");
if (iserializableTypeSymbol == null)
{
return null;
}
var serializationInfoTypeSymbol = compilation.GetTypeByMetadataName("System.Runtime.Serialization.SerializationInfo");
if (serializationInfoTypeSymbol == null)
{
return null;
}
var streamingContextTypeSymbol = compilation.GetTypeByMetadataName("System.Runtime.Serialization.StreamingContext");
if (streamingContextTypeSymbol == null)
{
return null;
}
var serializableAttributeTypeSymbol = compilation.GetTypeByMetadataName("System.SerializableAttribute");
if (serializableAttributeTypeSymbol == null)
{
return null;
}
return new Analyzer(iserializableTypeSymbol, serializationInfoTypeSymbol, streamingContextTypeSymbol, serializableAttributeTypeSymbol);
}
public override void AnalyzeSymbol(INamedTypeSymbol symbol, Compilation compilation, Action<Diagnostic> addDiagnostic, AnalyzerOptions options, CancellationToken cancellationToken)
{
if (symbol.TypeKind != TypeKind.Enum)
{
return;
}
var flagsAttribute = WellKnownTypes.FlagsAttribute(compilation);
if (flagsAttribute == null)
{
return;
}
var zeroValuedFields = GetZeroValuedFields(symbol).ToImmutableArray();
bool hasFlagsAttribute = symbol.GetAttributes().Any(a => a.AttributeClass == flagsAttribute);
if (hasFlagsAttribute)
{
CheckFlags(symbol, zeroValuedFields, addDiagnostic);
}
else
{
CheckNonFlags(symbol, zeroValuedFields, addDiagnostic);
}
}
public override void AnalyzeSymbol(INamedTypeSymbol symbol, Compilation compilation, Action<Diagnostic> addDiagnostic, AnalyzerOptions options, CancellationToken cancellationToken)
{
if (symbol.GetMembers().Any(member => IsDllImport(member)) && !IsTypeNamedCorrectly(symbol.Name))
{
addDiagnostic(symbol.CreateDiagnostic(Rule));
}
}
public IDiagnosticAnalyzer CreateAnalyzerWithinCompilation(Compilation compilation, AnalyzerOptions options, CancellationToken cancellationToken)
{
var dllImportType = compilation.GetTypeByMetadataName("System.Runtime.InteropServices.DllImportAttribute");
if (dllImportType == null)
{
return null;
}
var marshalAsType = compilation.GetTypeByMetadataName("System.Runtime.InteropServices.MarshalAsAttribute");
if (marshalAsType == null)
{
return null;
}
var stringBuilderType = compilation.GetTypeByMetadataName("System.Text.StringBuilder");
if (stringBuilderType == null)
{
return null;
}
var unmanagedType = compilation.GetTypeByMetadataName("System.Runtime.InteropServices.UnmanagedType");
if (unmanagedType == null)
{
return null;
}
return new Analyzer(dllImportType, marshalAsType, stringBuilderType, unmanagedType);
}
public IDiagnosticAnalyzer CreateAnalyzerWithinCompilation(Compilation compilation, AnalyzerOptions options, CancellationToken cancellationToken)
{
var specializedCollectionsSymbol = compilation.GetTypeByMetadataName(SpecializedCollectionsMetadataName);
if (specializedCollectionsSymbol == null)
{
// TODO: In the future, we may want to run this analyzer even if the SpecializedCollections
// type cannot be found in this compilation. In some cases, we may want to add a reference
// to SpecializedCollections as a linked file or an assembly that contains it. With this
// check, we will not warn where SpecializedCollections is not yet referenced.
return null;
}
var genericEnumerableSymbol = compilation.GetTypeByMetadataName(IEnumerableMetadataName);
if (genericEnumerableSymbol == null)
{
return null;
}
var linqEnumerableSymbol = compilation.GetTypeByMetadataName(LinqEnumerableMetadataName);
if (linqEnumerableSymbol == null)
{
return null;
}
var genericEmptyEnumerableSymbol = linqEnumerableSymbol.GetMembers(EmptyMethodName).FirstOrDefault() as IMethodSymbol;
if (genericEmptyEnumerableSymbol == null ||
genericEmptyEnumerableSymbol.Arity != 1 ||
genericEmptyEnumerableSymbol.Parameters.Length != 0)
{
return null;
}
return GetCodeBlockStartedAnalyzer(genericEnumerableSymbol, genericEmptyEnumerableSymbol);
}
protected override void AnalyzeSymbol(INamedTypeSymbol namedTypeSymbol, Compilation compilation, Action<Diagnostic> addDiagnostic, AnalyzerOptions options, CancellationToken cancellationToken)
{
if (namedTypeSymbol.IsValueType && IsOverridesEquals(namedTypeSymbol) && !IsEqualityOperatorImplemented(namedTypeSymbol))
{
addDiagnostic(namedTypeSymbol.CreateDiagnostic(Rule));
}
}
public void AnalyzeCodeBlock(SyntaxNode codeBlock, ISymbol ownerSymbol, SemanticModel semanticModel, Action<Diagnostic> addDiagnostic, AnalyzerOptions options, CancellationToken cancellationToken)
{
if (IsEmptyFinalizer(codeBlock, semanticModel))
{
addDiagnostic(ownerSymbol.CreateDiagnostic(Rule));
}
}
public AnalyzerAndOptions(DiagnosticAnalyzer analyzer, AnalyzerOptions analyzerOptions)
{
Debug.Assert(analyzer != null);
Debug.Assert(analyzerOptions != null);
Analyzer = analyzer;
_analyzerOptions = analyzerOptions;
}
/// <summary>
/// Creates a new <see cref="CompilationWithAnalyzersOptions"/>.
/// </summary>
/// <param name="options">Options that are passed to analyzers.</param>
/// <param name="onAnalyzerException">Action to invoke if an analyzer throws an exception.</param>
/// <param name="concurrentAnalysis">Flag indicating whether analysis can be performed concurrently on multiple threads.</param>
/// <param name="logAnalyzerExecutionTime">Flag indicating whether analyzer execution time should be logged.</param>
/// <param name="reportDiagnosticsWithSourceSuppression">Flag indicating whether analyzer diagnostics with <see cref="Diagnostic.IsSuppressed"/> should be reported.</param>
public CompilationWithAnalyzersOptions(AnalyzerOptions options, Action<Exception, DiagnosticAnalyzer, Diagnostic> onAnalyzerException, bool concurrentAnalysis, bool logAnalyzerExecutionTime, bool reportDiagnosticsWithSourceSuppression)
{
_options = options;
_onAnalyzerException = onAnalyzerException;
_concurrentAnalysis = concurrentAnalysis;
_logAnalyzerExecutionTime = logAnalyzerExecutionTime;
_reportDiagnosticsWithSourceSuppression = reportDiagnosticsWithSourceSuppression;
}
/// <summary>
/// Creates a new <see cref="CompilationWithAnalyzersOptions"/>.
/// </summary>
/// <param name="options">Options that are passed to analyzers.</param>
/// <param name="onAnalyzerException">Action to invoke if an analyzer throws an exception.</param>
/// <param name="concurrentAnalysis">Flag indicating whether analysis can be performed concurrently on multiple threads.</param>
/// <param name="logAnalyzerExecutionTime">Flag indicating whether analyzer execution time should be logged.</param>
public CompilationWithAnalyzersOptions(
AnalyzerOptions options,
Action<Exception, DiagnosticAnalyzer, Diagnostic> onAnalyzerException,
bool concurrentAnalysis,
bool logAnalyzerExecutionTime)
: this(options, onAnalyzerException, concurrentAnalysis, logAnalyzerExecutionTime, reportSuppressedDiagnostics: false)
{
}
public static IOrderedEnumerable<Diagnostic> GetSortedDiagnostics(string filePath,
DiagnosticAnalyzer analyzer,
string settingsPath)
{
var options = new AnalyzerOptions(ImmutableArray.Create<AdditionalText>(new SettingsFile(settingsPath)));
return GetSortedDiagnosticsFromDocuments(analyzer,
DocumentSetCreator.CreateDocumentSetFromSources(filePath),
options);
}
public void AnalyzeCompilation(Compilation compilation, Action<Diagnostic> addDiagnostic, AnalyzerOptions options, CancellationToken cancellationToken)
{
foreach (var item in this.fieldDisposedMap)
{
if (!item.Value)
{
addDiagnostic(item.Key.CreateDiagnostic(Rule));
}
}
}
public override void AnalyzeSymbol(INamedTypeSymbol namedType, Compilation compilation, Action<Diagnostic> addDiagnostic, AnalyzerOptions options, CancellationToken cancellationToken)
{
if (namedType.IsAbstract || namedType.IsSealed || !namedType.IsAttribute())
{
return;
}
// Non-sealed non-abstract attribute type.
addDiagnostic(namedType.CreateDiagnostic(Rule));
}
public void AnalyzeCompilation(Compilation compilation, Action<Diagnostic> addDiagnostic, AnalyzerOptions options, CancellationToken cancellationToken)
{
var globalNamespaces = compilation.GlobalNamespace.GetNamespaceMembers()
.Where(item => item.ContainingAssembly == compilation.Assembly);
var globalTypes = compilation.GlobalNamespace.GetTypeMembers().Where(item =>
item.ContainingAssembly == compilation.Assembly &&
IsExternallyVisible(item));
CheckTypeNames(globalTypes, addDiagnostic);
CheckNamespaceMembers(globalNamespaces, compilation, addDiagnostic);
}
private static IOrderedEnumerable<Diagnostic> GetSortedDiagnosticsFromDocuments(DiagnosticAnalyzer analyzer,
TextDocument document,
AnalyzerOptions options)
{
var diagnostics = document.Project.GetCompilationAsync()
.Result
.WithAnalyzers(ImmutableArray.Create(analyzer),
options)
.GetAnalyzerDiagnosticsAsync().Result;
return SortDiagnostics(diagnostics);
}
public void AnalyzeCompilation(Compilation compilation, Action<Diagnostic> addDiagnostic, AnalyzerOptions options, CancellationToken cancellationToken)
{
var assemblyVersionAttributeSymbol = WellKnownTypes.AssemblyVersionAttribute(compilation);
var assemblyComplianceAttributeSymbol = WellKnownTypes.CLSCompliantAttribute(compilation);
if (assemblyVersionAttributeSymbol == null && assemblyComplianceAttributeSymbol == null)
{
return;
}
bool assemblyVersionAttributeFound = false;
bool assemblyComplianceAttributeFound = false;
// Check all assembly level attributes for the target attribute
foreach (var attribute in compilation.Assembly.GetAttributes())
{
if (attribute.AttributeClass.Equals(assemblyVersionAttributeSymbol))
{
// Mark the version attribute as found
assemblyVersionAttributeFound = true;
}
else if (attribute.AttributeClass.Equals(assemblyComplianceAttributeSymbol))
{
// Mark the compliance attribute as found
assemblyComplianceAttributeFound = true;
}
}
// Check for the case where we do not have the target attribute defined at all in our metadata references. If so, how can they reference it
if (assemblyVersionAttributeSymbol == null)
{
assemblyVersionAttributeFound = false;
}
if (assemblyComplianceAttributeSymbol == null)
{
assemblyComplianceAttributeFound = false;
}
// If there's at least one diagnostic to report, let's report them
if (!assemblyComplianceAttributeFound || !assemblyVersionAttributeFound)
{
if (!assemblyVersionAttributeFound)
{
addDiagnostic(Diagnostic.Create(CA1016Rule, Location.None));
}
if (!assemblyComplianceAttributeFound)
{
addDiagnostic(Diagnostic.Create(CA1014Rule, Location.None));
}
}
}
protected override void AnalyzeSymbol(INamedTypeSymbol symbol, Compilation compilation, Action<Diagnostic> addDiagnostic, AnalyzerOptions options, CancellationToken cancellationToken)
{
if (symbol != null && symbol.IsAttribute() && symbol.DeclaredAccessibility != Accessibility.Private)
{
IEnumerable<IParameterSymbol> parametersToCheck = GetAllPublicConstructorParameters(symbol);
if (parametersToCheck.Any())
{
IDictionary<string, IPropertySymbol> propertiesMap = GetAllPropertiesInTypeChain(symbol);
AnalyzeParameters(compilation, parametersToCheck, propertiesMap, symbol, addDiagnostic);
}
}
}
/// <summary>
/// Creates a new compilation by attaching diagnostic analyzers to an existing compilation.
/// </summary>
/// <param name="compilation">The original compilation.</param>
/// <param name="analyzers">The set of analyzers to include in future analyses.</param>
/// <param name="options">Options that are passed to analyzers.</param>
/// <param name="cancellationToken">A cancellation token that can be used to abort analysis.</param>
public CompilationWithAnalyzers(Compilation compilation, ImmutableArray<DiagnosticAnalyzer> analyzers, AnalyzerOptions options, CancellationToken cancellationToken)
{
if (compilation == null)
{
throw new ArgumentNullException(nameof(compilation));
}
VerifyAnalyzersArgument(analyzers);
_cancellationToken = cancellationToken;
_exceptionDiagnostics = new ConcurrentSet<Diagnostic>();
_driver = AnalyzerDriver.Create(compilation, analyzers, options, AnalyzerManager.Instance, AddExceptionDiagnostic, false, out _compilation, _cancellationToken);
}
public void AnalyzeSymbol(ISymbol symbol, Compilation compilation, Action<Diagnostic> addDiagnostic, AnalyzerOptions options, CancellationToken cancellationToken)
{
switch (symbol.Kind)
{
case SymbolKind.NamedType:
AnalyzeNamedTypeSymbol((INamedTypeSymbol)symbol, addDiagnostic);
break;
case SymbolKind.Method:
AnalyzeMethodSymbol((IMethodSymbol)symbol, addDiagnostic);
break;
}
}
public AnalyzerAndOptions(DiagnosticAnalyzer analyzer, AnalyzerOptions analyzerOptions)
{
Debug.Assert(analyzer != null);
Debug.Assert(analyzerOptions != null);
Analyzer = analyzer;
// _analyzerOptions is used only as a key for equality testing, and only the properties
// declared by AnalyzerOptions are appropriate for use in the comparison. (For example,
// two AnalyzersAndOptions that differ only by Workspace ought to be treated as equal.)
// If the supplied analyzerOptions is an instance of a derived type, holding on to that object
// can introduce a memory leak, as well as causing false negatives in comparison. Avoid these
// issues by creating a new object with only the desired properties.
_analyzerOptions = new AnalyzerOptions(analyzerOptions.AdditionalFiles);
}
public static void SetParameterValues(DiagnosticAnalyzer parameteredAnalyzer,
AnalyzerOptions options)
{
if (ProcessedAnalyzers.ContainsKey(parameteredAnalyzer))
{
return;
}
var additionalFile = options.AdditionalFiles
.FirstOrDefault(f => ConfigurationFilePathMatchesExpected(f.Path));
if (additionalFile == null)
{
return;
}
var filePath = additionalFile.Path;
var xml = XDocument.Load(filePath);
var parameters = ParseParameters(xml);
var propertyParameterPairs = parameteredAnalyzer.GetType()
.GetProperties()
.Select(p => new { Property = p, Descriptor = p.GetCustomAttributes<RuleParameterAttribute>().SingleOrDefault() })
.Where(p => p.Descriptor != null);
foreach (var propertyParameterPair in propertyParameterPairs)
{
var parameter = parameters
.FirstOrDefault(p => p.RuleId == parameteredAnalyzer.SupportedDiagnostics.Single().Id);
if (parameter == null)
{
return;
}
var parameterValue = parameter.ParameterValues
.FirstOrDefault(pv => pv.ParameterKey == propertyParameterPair.Descriptor.Key);
if (parameterValue == null)
{
return;
}
var value = parameterValue.ParameterValue;
var convertedValue = ChangeParameterType(value, propertyParameterPair.Descriptor.Type);
propertyParameterPair.Property.SetValue(parameteredAnalyzer, convertedValue);
}
ProcessedAnalyzers.AddOrUpdate(parameteredAnalyzer, 0, (a, b) => b);
}
protected override void AnalyzeSymbol(
INamedTypeSymbol symbol,
Compilation compilation,
Action<Diagnostic> addDiagnostic,
AnalyzerOptions options,
CancellationToken cancellationToken)
{
if (!symbol.IsStatic
&& (symbol.IsPublic() || symbol.IsProtected())
&& symbol.IsStaticHolderType())
{
addDiagnostic(symbol.CreateDiagnostic(Rule, symbol.Name));
}
}
public IDiagnosticAnalyzer CreateAnalyzerWithinCodeBlock(SyntaxNode codeBlock, ISymbol ownerSymbol, SemanticModel semanticModel, AnalyzerOptions options, CancellationToken cancellationToken)
{
var method = ownerSymbol as IMethodSymbol;
if (method == null)
{
return null;
}
if (!IsDestructor(method))
{
return null;
}
return GetCodeBlockEndedAnalyzer();
}
public ICodeBlockEndedAnalyzer OnCodeBlockStarted(SyntaxNode codeBlock, ISymbol ownerSymbol, SemanticModel semanticModel, Action<Diagnostic> addDiagnostic, AnalyzerOptions options, CancellationToken cancellationToken)
{
var method = ownerSymbol as IMethodSymbol;
if (method == null)
{
return null;
}
if (!IsDestructor(method))
{
return null;
}
return GetCodeBlockEndedAnalyzer();
}
internal static Compilation AttachAnalyzerDriverToCompilation(Compilation compilation, ImmutableArray <IDiagnosticAnalyzer> analyzers, out AnalyzerDriver3 analyzerDriver3, AnalyzerOptions options, CancellationToken cancellationToken)
{
analyzerDriver3 = compilation.AnalyzerForLanguage(analyzers, options, cancellationToken);
return(compilation.WithEventQueue(analyzerDriver3.CompilationEventQueue));
}
public WorkspaceAnalyzerOptions(AnalyzerOptions options, OptionSet optionSet, Solution solution)
: base(options.AdditionalFiles)
{
_solution = solution;
_optionSet = optionSet;
}
public SyntaxNodeAnalysisContext(SyntaxNode node, SemanticModel semanticModel, AnalyzerOptions options, Action <Diagnostic> reportDiagnostic, CancellationToken cancellationToken)
{
_node = node;
_semanticModel = semanticModel;
_options = options;
_reportDiagnostic = reportDiagnostic;
_cancellationToken = cancellationToken;
}
public CodeBlockAnalysisContext(SyntaxNode codeBlock, ISymbol owningSymbol, SemanticModel semanticModel, AnalyzerOptions options, Action <Diagnostic> reportDiagnostic, CancellationToken cancellationToken)
{
_codeBlock = codeBlock;
_owningSymbol = owningSymbol;
_semanticModel = semanticModel;
_options = options;
_reportDiagnostic = reportDiagnostic;
_cancellationToken = cancellationToken;
}
protected CodeBlockStartAnalysisContext(SyntaxNode codeBlock, ISymbol owningSymbol, SemanticModel semanticModel, AnalyzerOptions options, CancellationToken cancellationToken)
{
_codeBlock = codeBlock;
_owningSymbol = owningSymbol;
_semanticModel = semanticModel;
_options = options;
_cancellationToken = cancellationToken;
}
public static AnalyzerConfigOptions GetAnalyzerOptionSet(this AnalyzerOptions analyzerOptions, SyntaxTree syntaxTree, CancellationToken cancellationToken)
{
return(analyzerOptions.AnalyzerConfigOptionsProvider.GetOptions(syntaxTree));
}
/// <summary>
/// Creates a new <see cref="CompilationWithAnalyzersOptions"/>.
/// </summary>
/// <param name="options">Options that are passed to analyzers.</param>
/// <param name="onAnalyzerException">Action to invoke if an analyzer throws an exception.</param>
/// <param name="concurrentAnalysis">Flag indicating whether analysis can be performed concurrently on multiple threads.</param>
/// <param name="logAnalyzerExecutionTime">Flag indicating whether analyzer execution time should be logged.</param>
public CompilationWithAnalyzersOptions(AnalyzerOptions options, Action <Exception, DiagnosticAnalyzer, Diagnostic> onAnalyzerException, bool concurrentAnalysis, bool logAnalyzerExecutionTime)
: this(options, onAnalyzerException, concurrentAnalysis, logAnalyzerExecutionTime, reportDiagnosticsWithSourceSuppression : false)
{
}
/// <summary>
/// Creates a new compilation by attaching diagnostic analyzers to an existing compilation.
/// </summary>
/// <param name="compilation">The original compilation.</param>
/// <param name="analyzers">The set of analyzers to include in future analyses.</param>
/// <param name="options">Options that are passed to analyzers.</param>
/// <param name="cancellationToken">A cancellation token that can be used to abort analysis.</param>
public CompilationWithAnalyzers(Compilation compilation, ImmutableArray <DiagnosticAnalyzer> analyzers, AnalyzerOptions options, CancellationToken cancellationToken)
{
_cancellationToken = cancellationToken;
_exceptionDiagnostics = new ConcurrentSet <Diagnostic>();
_driver = AnalyzerDriver.Create(compilation, analyzers, options, AnalyzerManager.Instance, AddExceptionDiagnostic, out _compilation, _cancellationToken);
}
#pragma warning disable IDE0060 // Remove unused parameter - Needed to share this method signature between CodeStyle and Features layer.
public static AnalyzerConfigOptions GetAnalyzerOptionSet(this AnalyzerOptions analyzerOptions, SyntaxTree syntaxTree, CancellationToken cancellationToken)
#pragma warning restore IDE0060 // Remove unused parameter
=> analyzerOptions.AnalyzerConfigOptionsProvider.GetOptions(syntaxTree);
public static OptionSet GetOptionSet(this AnalyzerOptions analyzerOptions)
{
return((analyzerOptions as WorkspaceAnalyzerOptions)?.Workspace.Options);
}
public WorkspaceAnalyzerOptions(AnalyzerOptions options, Project project)
: this(options, project.Solution, IdeAnalyzerOptions.FromProject(project))
{
}
public WorkspaceAnalyzerOptions(AnalyzerOptions options, Solution solution)
: base(options.AdditionalFiles, options.AnalyzerConfigOptionsProvider)
{
_solution = solution;
}
/// <summary>
/// Returns a new compilation with attached diagnostic analyzers.
/// </summary>
/// <param name="compilation">Compilation to which analyzers are to be added.</param>
/// <param name="analyzers">The set of analyzers to include in future analyses.</param>
/// <param name="options">Options that are passed to analyzers.</param>
/// <param name="cancellationToken">A cancellation token that can be used to abort analysis.</param>
public static CompilationWithAnalyzers WithAnalyzers(this Compilation compilation, ImmutableArray <DiagnosticAnalyzer> analyzers, AnalyzerOptions options = null, CancellationToken cancellationToken = default(CancellationToken))
{
return(new CompilationWithAnalyzers(compilation, analyzers, options, cancellationToken));
}
/// <summary>
/// Creates a new compilation by attaching diagnostic analyzers to an existing compilation.
/// </summary>
/// <param name="compilation">The original compilation.</param>
/// <param name="analyzers">The set of analyzers to include in future analyses.</param>
/// <param name="options">Options that are passed to analyzers.</param>
/// <param name="cancellationToken">A cancellation token that can be used to abort analysis.</param>
public CompilationWithAnalyzers(Compilation compilation, ImmutableArray <DiagnosticAnalyzer> analyzers, AnalyzerOptions options, CancellationToken cancellationToken)
{
if (compilation == null)
{
throw new ArgumentNullException(nameof(compilation));
}
VerifyAnalyzersArgument(analyzers);
_cancellationToken = cancellationToken;
_exceptionDiagnostics = new ConcurrentSet <Diagnostic>();
_driver = AnalyzerDriver.Create(compilation, analyzers, options, AnalyzerManager.Instance, AddExceptionDiagnostic, false, out _compilation, _cancellationToken);
}
public CollectCompilationActionsContext(Compilation compilation, AnalyzerOptions analyzerOptions)
{
_compilation = compilation;
_analyzerOptions = analyzerOptions;
}
private static ImmutableArray <IDiagnosticAnalyzer> GetEffectiveAnalyzers(IEnumerable <IDiagnosticAnalyzer> analyzers, Compilation compilation, AnalyzerOptions analyzerOptions, Action <Diagnostic> addDiagnostic, bool continueOnError, CancellationToken cancellationToken)
{
var effectiveAnalyzers = ImmutableArray.CreateBuilder <IDiagnosticAnalyzer>();
foreach (var analyzer in analyzers)
{
cancellationToken.ThrowIfCancellationRequested();
if (!IsDiagnosticAnalyzerSuppressed(analyzer, compilation.Options, addDiagnostic, continueOnError, cancellationToken))
{
effectiveAnalyzers.Add(analyzer);
var startAnalyzer = analyzer as ICompilationStartedAnalyzer;
if (startAnalyzer != null)
{
ExecuteAndCatchIfThrows(startAnalyzer, addDiagnostic, continueOnError, cancellationToken, () =>
{
var compilationAnalyzer = startAnalyzer.OnCompilationStarted(compilation, addDiagnostic, analyzerOptions, cancellationToken);
if (compilationAnalyzer != null)
{
effectiveAnalyzers.Add(compilationAnalyzer);
}
});
}
}
}
return(effectiveAnalyzers.ToImmutable());
}
protected CompilationStartAnalysisContext(Compilation compilation, AnalyzerOptions options, CancellationToken cancellationToken)
{
_compilation = compilation;
_options = options;
_cancellationToken = cancellationToken;
}
public WorkspaceAnalyzerOptions(AnalyzerOptions options, Workspace workspace)
: base(options.AdditionalFiles)
{
this.Workspace = workspace;
}
public static T GetOption <T>(this AnalyzerOptions analyzerOptions, Option2 <T> option, SyntaxTree syntaxTree, CancellationToken cancellationToken) => GetOption <T>(analyzerOptions, option, language: null, syntaxTree, cancellationToken);
public static bool TryGetEditorConfigOption <T>(this AnalyzerOptions analyzerOptions, TOption option, SyntaxTree syntaxTree, out T value)
{
var configOptions = analyzerOptions.AnalyzerConfigOptionsProvider.GetOptions(syntaxTree);
return(configOptions.TryGetEditorConfigOption(option, out value));
}
public AnalyzerCompilationStartAnalysisContext(DiagnosticAnalyzer analyzer, HostCompilationStartAnalysisScope scope, Compilation compilation, AnalyzerOptions options, CancellationToken cancellationToken)
: base(compilation, options, cancellationToken)
{
_analyzer = analyzer;
_scope = scope;
}
public CollectNestedCompilationContext(Compilation compilation, AnalyzerOptions options, CancellationToken cancellationToken)
: base(compilation, options, cancellationToken)
{
}
private ConditionalWeakTable <Compilation, Task <HostCompilationStartAnalysisScope> > GetOrCreateCompilationActionsCache(AnalyzerOptions analyzerOptions)
{
lock (_gate)
{
ConditionalWeakTable <Compilation, Task <HostCompilationStartAnalysisScope> > compilationActionsCache;
if (_lazyCompilationScopeMap == null)
{
_lazyCompilationScopeMap = new Dictionary <AnalyzerOptions, ConditionalWeakTable <Compilation, Task <HostCompilationStartAnalysisScope> > >();
}
else if (_lazyCompilationScopeMap.TryGetValue(analyzerOptions, out compilationActionsCache))
{
return(compilationActionsCache);
}
compilationActionsCache = new ConditionalWeakTable <Compilation, Task <HostCompilationStartAnalysisScope> >();
_lazyCompilationScopeMap.Add(analyzerOptions, compilationActionsCache);
return(compilationActionsCache);
}
}
public static T GetOption <T>(this AnalyzerOptions analyzerOptions, PerLanguageOption2 <T> option, string?language, SyntaxTree syntaxTree, CancellationToken cancellationToken) => GetOption <T>(analyzerOptions, (IOption2)option, language, syntaxTree, cancellationToken);
/// <summary>
/// Creates a new compilation by attaching diagnostic analyzers to an existing compilation.
/// </summary>
/// <param name="compilation">The original compilation.</param>
/// <param name="analyzers">The set of analyzers to include in future analyses.</param>
/// <param name="options">Options that are passed to analyzers.</param>
/// <param name="cancellationToken">A cancellation token that can be used to abort analysis.</param>
public CompilationWithAnalyzers(Compilation compilation, ImmutableArray <DiagnosticAnalyzer> analyzers, AnalyzerOptions options, CancellationToken cancellationToken)
{
_cancellationToken = cancellationToken;
_driver = AnalyzerDriver.Create(compilation, analyzers, options, out _compilation, _cancellationToken);
}
