public static ValueContentAnalysisResult TryGetOrComputeResult(
ControlFlowGraph cfg,
ISymbol owningSymbol,
WellKnownTypeProvider wellKnownTypeProvider,
AnalyzerOptions analyzerOptions,
DiagnosticDescriptor rule,
CancellationToken cancellationToken,
out CopyAnalysisResult copyAnalysisResultOpt,
out PointsToAnalysisResult pointsToAnalysisResultOpt,
InterproceduralAnalysisKind interproceduralAnalysisKind = InterproceduralAnalysisKind.None,
bool pessimisticAnalysis = true,
bool performPointsToAnalysis = true,
bool performCopyAnalysisIfNotUserConfigured = false,
InterproceduralAnalysisPredicate interproceduralAnalysisPredicateOpt = null)
{
Debug.Assert(!owningSymbol.IsConfiguredToSkipAnalysis(analyzerOptions, rule, wellKnownTypeProvider.Compilation, cancellationToken));
var interproceduralAnalysisConfig = InterproceduralAnalysisConfiguration.Create(
analyzerOptions, rule, interproceduralAnalysisKind, cancellationToken);
return(TryGetOrComputeResult(cfg, owningSymbol, analyzerOptions, wellKnownTypeProvider,
interproceduralAnalysisConfig, out copyAnalysisResultOpt,
out pointsToAnalysisResultOpt, pessimisticAnalysis, performPointsToAnalysis,
performCopyAnalysis: analyzerOptions.GetCopyAnalysisOption(rule, defaultValue: performCopyAnalysisIfNotUserConfigured, cancellationToken),
interproceduralAnalysisPredicateOpt: interproceduralAnalysisPredicateOpt));
}
public static ImmutableDictionary <IParameterSymbol, SyntaxNode> GetOrComputeHazardousParameterUsages(
IBlockOperation topmostBlock,
Compilation compilation,
ISymbol owningSymbol,
AnalyzerOptions analyzerOptions,
DiagnosticDescriptor rule,
CancellationToken cancellationToken,
PointsToAnalysisKind defaultPointsToAnalysisKind = PointsToAnalysisKind.PartialWithoutTrackingFieldsAndProperties,
InterproceduralAnalysisKind interproceduralAnalysisKind = InterproceduralAnalysisKind.ContextSensitive,
uint defaultMaxInterproceduralMethodCallChain = 1, // By default, we only want to track method calls one level down.
bool pessimisticAnalysis = false)
{
Debug.Assert(!analyzerOptions.IsConfiguredToSkipAnalysis(rule, owningSymbol, compilation, cancellationToken));
var cfg = topmostBlock.GetEnclosingControlFlowGraph();
if (cfg == null)
{
return(ImmutableDictionary <IParameterSymbol, SyntaxNode> .Empty);
}
var interproceduralAnalysisConfig = InterproceduralAnalysisConfiguration.Create(
analyzerOptions, rule, cfg, compilation, interproceduralAnalysisKind, cancellationToken, defaultMaxInterproceduralMethodCallChain);
var performCopyAnalysis = analyzerOptions.GetCopyAnalysisOption(rule, topmostBlock.Syntax.SyntaxTree, compilation, defaultValue: false, cancellationToken);
var nullCheckValidationMethods = analyzerOptions.GetNullCheckValidationMethodsOption(rule, topmostBlock.Syntax.SyntaxTree, compilation, cancellationToken);
var pointsToAnalysisKind = analyzerOptions.GetPointsToAnalysisKindOption(rule, topmostBlock.Syntax.SyntaxTree, compilation, defaultPointsToAnalysisKind, cancellationToken);
return(GetOrComputeHazardousParameterUsages(cfg, compilation, owningSymbol, analyzerOptions,
nullCheckValidationMethods, pointsToAnalysisKind, interproceduralAnalysisConfig, performCopyAnalysis, pessimisticAnalysis));
}
public static DisposeAnalysisResult TryGetOrComputeResult(
ControlFlowGraph cfg,
ISymbol owningSymbol,
WellKnownTypeProvider wellKnownTypeProvider,
AnalyzerOptions analyzerOptions,
DiagnosticDescriptor rule,
ImmutableHashSet <INamedTypeSymbol> disposeOwnershipTransferLikelyTypes,
bool trackInstanceFields,
bool exceptionPathsAnalysis,
CancellationToken cancellationToken,
out PointsToAnalysisResult pointsToAnalysisResult,
InterproceduralAnalysisKind interproceduralAnalysisKind = InterproceduralAnalysisKind.ContextSensitive,
bool performCopyAnalysisIfNotUserConfigured = false,
InterproceduralAnalysisPredicate interproceduralAnalysisPredicateOpt = null,
bool defaultDisposeOwnershipTransferAtConstructor = false)
{
var interproceduralAnalysisConfig = InterproceduralAnalysisConfiguration.Create(
analyzerOptions, rule, interproceduralAnalysisKind, cancellationToken);
var disposeOwnershipTransferAtConstructor = analyzerOptions.GetDisposeOwnershipTransferAtConstructorOption(
rule, defaultValue: defaultDisposeOwnershipTransferAtConstructor, cancellationToken);
return(TryGetOrComputeResult(cfg, owningSymbol, wellKnownTypeProvider,
interproceduralAnalysisConfig, interproceduralAnalysisPredicateOpt,
disposeOwnershipTransferLikelyTypes, disposeOwnershipTransferAtConstructor, trackInstanceFields, exceptionPathsAnalysis,
performCopyAnalysis: analyzerOptions.GetCopyAnalysisOption(rule, defaultValue: performCopyAnalysisIfNotUserConfigured, cancellationToken),
out pointsToAnalysisResult));
}
public static InterproceduralAnalysisConfiguration Create(
AnalyzerOptions analyzerOptions,
ImmutableArray <DiagnosticDescriptor> rules,
SyntaxTree tree,
Compilation compilation,
InterproceduralAnalysisKind defaultInterproceduralAnalysisKind,
CancellationToken cancellationToken,
uint defaultMaxInterproceduralMethodCallChain = DefaultMaxInterproceduralMethodCallChain,
uint defaultMaxInterproceduralLambdaOrLocalFunctionCallChain = DefaultMaxInterproceduralLambdaOrLocalFunctionCallChain)
{
InterproceduralAnalysisKind maxKind = InterproceduralAnalysisKind.None;
uint maxMethodCallChain = 0;
uint maxLambdaorLocalFunctionCallChain = 0;
foreach (var rule in rules)
{
var interproceduralAnalysisConfig = Create(analyzerOptions, rule, tree, compilation, defaultInterproceduralAnalysisKind,
cancellationToken, defaultMaxInterproceduralMethodCallChain, defaultMaxInterproceduralLambdaOrLocalFunctionCallChain);
maxKind = (InterproceduralAnalysisKind)Math.Max((int)maxKind, (int)interproceduralAnalysisConfig.InterproceduralAnalysisKind);
maxMethodCallChain = Math.Max(maxMethodCallChain, interproceduralAnalysisConfig.MaxInterproceduralMethodCallChain);
maxLambdaorLocalFunctionCallChain = Math.Max(maxLambdaorLocalFunctionCallChain, interproceduralAnalysisConfig.MaxInterproceduralLambdaOrLocalFunctionCallChain);
}
return(new InterproceduralAnalysisConfiguration(maxKind, maxMethodCallChain, maxLambdaorLocalFunctionCallChain));
}
public override int GetHashCode()
{
return(RoslynHashCode.Combine(
InterproceduralAnalysisKind.GetHashCode(),
MaxInterproceduralMethodCallChain.GetHashCode(),
MaxInterproceduralLambdaOrLocalFunctionCallChain.GetHashCode()));
}
private static InterproceduralAnalysisConfiguration Create(
AnalyzerOptions analyzerOptions,
DiagnosticDescriptor rule,
SyntaxTree tree,
Compilation compilation,
InterproceduralAnalysisKind defaultInterproceduralAnalysisKind,
uint defaultMaxInterproceduralMethodCallChain = DefaultMaxInterproceduralMethodCallChain,
uint defaultMaxInterproceduralLambdaOrLocalFunctionCallChain = DefaultMaxInterproceduralLambdaOrLocalFunctionCallChain)
{
var kind = analyzerOptions.GetInterproceduralAnalysisKindOption(rule, tree, compilation, defaultInterproceduralAnalysisKind);
var maxInterproceduralMethodCallChain = analyzerOptions.GetUnsignedIntegralOptionValue(
optionName: EditorConfigOptionNames.MaxInterproceduralMethodCallChain,
rule: rule,
tree,
compilation,
defaultValue: defaultMaxInterproceduralMethodCallChain);
var maxInterproceduralLambdaOrLocalFunctionCallChain = analyzerOptions.GetUnsignedIntegralOptionValue(
optionName: EditorConfigOptionNames.MaxInterproceduralLambdaOrLocalFunctionCallChain,
rule: rule,
tree,
compilation,
defaultValue: defaultMaxInterproceduralLambdaOrLocalFunctionCallChain);
return(new InterproceduralAnalysisConfiguration(
kind, maxInterproceduralMethodCallChain, maxInterproceduralLambdaOrLocalFunctionCallChain));
}
public static InterproceduralAnalysisConfiguration Create(
AnalyzerOptions analyzerOptions,
DiagnosticDescriptor rule,
InterproceduralAnalysisKind defaultInterproceduralAnalysisKind,
CancellationToken cancellationToken,
uint defaultMaxInterproceduralMethodCallChain = DefaultMaxInterproceduralMethodCallChain,
uint defaultMaxInterproceduralLambdaOrLocalFunctionCallChain = DefaultMaxInterproceduralLambdaOrLocalFunctionCallChain)
{
var kind = analyzerOptions.GetInterproceduralAnalysisKindOption(rule, defaultInterproceduralAnalysisKind, cancellationToken);
var maxInterproceduralMethodCallChain = analyzerOptions.GetUnsignedIntegralOptionValue(
optionName: EditorConfigOptionNames.MaxInterproceduralMethodCallChain,
rule: rule,
defaultValue: defaultMaxInterproceduralMethodCallChain,
cancellationToken: cancellationToken);
var maxInterproceduralLambdaOrLocalFunctionCallChain = analyzerOptions.GetUnsignedIntegralOptionValue(
optionName: EditorConfigOptionNames.MaxInterproceduralLambdaOrLocalFunctionCallChain,
rule: rule,
defaultValue: defaultMaxInterproceduralLambdaOrLocalFunctionCallChain,
cancellationToken: cancellationToken);
return(new InterproceduralAnalysisConfiguration(
kind, maxInterproceduralMethodCallChain, maxInterproceduralLambdaOrLocalFunctionCallChain));
}
public bool TryGetOrComputeResult(
OperationBlockAnalysisContext context,
IMethodSymbol containingMethod,
DiagnosticDescriptor rule,
InterproceduralAnalysisKind interproceduralAnalysisKind,
bool trackInstanceFields,
out DisposeAnalysisResult disposeAnalysisResult,
out PointsToAnalysisResult pointsToAnalysisResult,
InterproceduralAnalysisPredicate interproceduralAnalysisPredicateOpt = null)
{
// Compute the dispose analysis result - skip Attribute blocks (OperationKind.None)
foreach (var operationBlock in context.OperationBlocks.Where(o => o.Kind != OperationKind.None))
{
var cfg = context.GetControlFlowGraph(operationBlock);
if (cfg != null)
{
var wellKnownTypeProvider = Analyzer.Utilities.WellKnownTypeProvider.GetOrCreate(context.Compilation);
disposeAnalysisResult = FlowAnalysis.DataFlow.DisposeAnalysis.DisposeAnalysis.TryGetOrComputeResult(cfg, containingMethod, wellKnownTypeProvider,
context.Options, rule, _disposeOwnershipTransferLikelyTypes, trackInstanceFields,
exceptionPathsAnalysis: false, context.CancellationToken, out pointsToAnalysisResult,
interproceduralAnalysisKind,
interproceduralAnalysisPredicateOpt: interproceduralAnalysisPredicateOpt,
defaultDisposeOwnershipTransferAtConstructor: true,
defaultDisposeOwnershipTransferAtMethodCall: true);
if (disposeAnalysisResult != null)
{
return(true);
}
}
}
disposeAnalysisResult = null;
pointsToAnalysisResult = null;
return(false);
}
public static FlightEnabledAnalysisResult?TryGetOrComputeResult(
ControlFlowGraph cfg,
ISymbol owningSymbol,
ImmutableArray <IMethodSymbol> flightEnablingMethods,
Func <FlightEnabledAnalysisCallbackContext, FlightEnabledAbstractValue> getValueForFlightEnablingMethodInvocation,
WellKnownTypeProvider wellKnownTypeProvider,
AnalyzerOptions analyzerOptions,
DiagnosticDescriptor rule,
bool performPointsToAnalysis,
bool performValueContentAnalysis,
CancellationToken cancellationToken,
out PointsToAnalysisResult?pointsToAnalysisResult,
out ValueContentAnalysisResult?valueContentAnalysisResult,
InterproceduralAnalysisKind interproceduralAnalysisKind = InterproceduralAnalysisKind.None,
bool pessimisticAnalysis = true,
InterproceduralAnalysisPredicate?interproceduralAnalysisPredicate = null)
{
RoslynDebug.Assert(!performValueContentAnalysis || performPointsToAnalysis);
var interproceduralAnalysisConfig = InterproceduralAnalysisConfiguration.Create(
analyzerOptions, rule, owningSymbol, wellKnownTypeProvider.Compilation, interproceduralAnalysisKind, cancellationToken);
if (interproceduralAnalysisConfig.InterproceduralAnalysisKind != InterproceduralAnalysisKind.None)
{
interproceduralAnalysisPredicate ??= new InterproceduralAnalysisPredicate(
skipAnalysisForInvokedMethodPredicateOpt: m => flightEnablingMethods.Contains(m),
skipAnalysisForInvokedLambdaOrLocalFunctionPredicateOpt: null,
skipAnalysisForInvokedContextPredicateOpt: null);
}
return(TryGetOrComputeResult(cfg, owningSymbol, flightEnablingMethods,
getValueForFlightEnablingMethodInvocation, wellKnownTypeProvider, analyzerOptions,
interproceduralAnalysisConfig, interproceduralAnalysisPredicate, pessimisticAnalysis,
performPointsToAnalysis, performValueContentAnalysis, out pointsToAnalysisResult, out valueContentAnalysisResult));
}
/// <summary>
/// Performs global flow state analysis and returns the analysis result.
/// </summary>
/// <param name="cfg">Control flow graph to analyze.</param>
/// <param name="owningSymbol">Owning symbol for the analyzed <paramref name="cfg"/>.</param>
/// <param name="createOperationVisitor">Delegate to create a <see cref="GlobalFlowStateDataFlowOperationVisitor"/> that performs the core analysis.</param>
/// <param name="wellKnownTypeProvider">Well-known type provider for the compilation.</param>
/// <param name="analyzerOptions">Analyzer options for analysis</param>
/// <param name="rule"><see cref="DiagnosticDescriptor"/> for fetching any rule specific analyzer option values from <paramref name="analyzerOptions"/>.</param>
/// <param name="performValueContentAnalysis">Flag to indicate if <see cref="ValueContentAnalysis.ValueContentAnalysis"/> should be performed.</param>
/// <param name="pessimisticAnalysis">
/// This boolean field determines if we should perform an optimistic OR a pessimistic analysis.
/// For example, invoking a lambda method for which we do not know the target method being invoked can change/invalidate the current global flow state.
/// An optimistic points to analysis assumes that the global flow state doesn't change for such scenarios.
/// A pessimistic points to analysis resets the global flow state to an unknown state for such scenarios.
/// </param>
/// <param name="cancellationToken">Token to cancel analysis.</param>
/// <param name="valueContentAnalysisResult">Optional value content analysis result, if <paramref name="performValueContentAnalysis"/> is true</param>
/// <param name="interproceduralAnalysisKind"><see cref="InterproceduralAnalysisKind"/> for the analysis.</param>
/// <param name="interproceduralAnalysisPredicate">Optional predicate for interprocedural analysis.</param>
/// <param name="additionalSupportedValueTypes">Additional value types for which the caller wants to track stored values during value content analysis.</param>
/// <param name="getValueContentValueForAdditionalSupportedValueTypeOperation">
/// Optional delegate to compute values for <paramref name="additionalSupportedValueTypes"/>.
/// Must be non-null if <paramref name="additionalSupportedValueTypes"/> is non-empty.
/// </param>
/// <returns>Global flow state analysis result, or null if analysis did not succeed.</returns>
public static GlobalFlowStateAnalysisResult?TryGetOrComputeResult(
ControlFlowGraph cfg,
ISymbol owningSymbol,
Func <GlobalFlowStateAnalysisContext, GlobalFlowStateDataFlowOperationVisitor> createOperationVisitor,
WellKnownTypeProvider wellKnownTypeProvider,
AnalyzerOptions analyzerOptions,
DiagnosticDescriptor rule,
bool performValueContentAnalysis,
bool pessimisticAnalysis,
CancellationToken cancellationToken,
out ValueContentAnalysisResult?valueContentAnalysisResult,
InterproceduralAnalysisKind interproceduralAnalysisKind = InterproceduralAnalysisKind.None,
InterproceduralAnalysisPredicate?interproceduralAnalysisPredicate = null,
ImmutableArray <INamedTypeSymbol> additionalSupportedValueTypes = default,
Func <IOperation, ValueContentAbstractValue>?getValueContentValueForAdditionalSupportedValueTypeOperation = null)
{
if (cfg == null)
{
throw new ArgumentNullException(nameof(cfg));
}
var interproceduralAnalysisConfig = InterproceduralAnalysisConfiguration.Create(
analyzerOptions, rule, cfg, wellKnownTypeProvider.Compilation, interproceduralAnalysisKind, cancellationToken);
var pointsToAnalysisKind = analyzerOptions.GetPointsToAnalysisKindOption(rule, owningSymbol, wellKnownTypeProvider.Compilation,
defaultValue: PointsToAnalysisKind.PartialWithoutTrackingFieldsAndProperties, cancellationToken);
return(TryGetOrComputeResult(cfg, owningSymbol, createOperationVisitor, wellKnownTypeProvider, analyzerOptions,
interproceduralAnalysisConfig, interproceduralAnalysisPredicate, pointsToAnalysisKind, pessimisticAnalysis,
performValueContentAnalysis, out valueContentAnalysisResult,
additionalSupportedValueTypes, getValueContentValueForAdditionalSupportedValueTypeOperation));
}
public static InterproceduralAnalysisKind GetInterproceduralAnalysisKindOption(
this AnalyzerOptions options,
DiagnosticDescriptor rule,
SyntaxTree tree,
Compilation compilation,
InterproceduralAnalysisKind defaultValue)
=> options.GetNonFlagsEnumOptionValue(EditorConfigOptionNames.InterproceduralAnalysisKind, rule, tree, compilation, defaultValue);
public static ValueContentAnalysisResult?TryGetOrComputeResult(
ControlFlowGraph cfg,
ISymbol owningSymbol,
WellKnownTypeProvider wellKnownTypeProvider,
AnalyzerOptions analyzerOptions,
DiagnosticDescriptor rule,
PointsToAnalysisKind defaultPointsToAnalysisKind,
CancellationToken cancellationToken,
out CopyAnalysisResult?copyAnalysisResult,
out PointsToAnalysisResult?pointsToAnalysisResult,
InterproceduralAnalysisKind interproceduralAnalysisKind = InterproceduralAnalysisKind.None,
bool pessimisticAnalysis = true,
bool performCopyAnalysisIfNotUserConfigured = false,
InterproceduralAnalysisPredicate?interproceduralAnalysisPredicate = null,
ImmutableArray <INamedTypeSymbol> additionalSupportedValueTypes = default,
Func <IOperation, ValueContentAbstractValue>?getValueContentValueForAdditionalSupportedValueTypeOperation = null)
{
Debug.Assert(!owningSymbol.IsConfiguredToSkipAnalysis(analyzerOptions, rule, wellKnownTypeProvider.Compilation, cancellationToken));
var interproceduralAnalysisConfig = InterproceduralAnalysisConfiguration.Create(
analyzerOptions, rule, owningSymbol, wellKnownTypeProvider.Compilation, interproceduralAnalysisKind, cancellationToken);
return(TryGetOrComputeResult(cfg, owningSymbol, analyzerOptions, wellKnownTypeProvider,
pointsToAnalysisKind: analyzerOptions.GetPointsToAnalysisKindOption(rule, owningSymbol, wellKnownTypeProvider.Compilation, defaultPointsToAnalysisKind, cancellationToken),
interproceduralAnalysisConfig, out copyAnalysisResult,
out pointsToAnalysisResult, pessimisticAnalysis,
performCopyAnalysis: analyzerOptions.GetCopyAnalysisOption(rule, owningSymbol, wellKnownTypeProvider.Compilation, defaultValue: performCopyAnalysisIfNotUserConfigured, cancellationToken),
interproceduralAnalysisPredicate,
additionalSupportedValueTypes,
getValueContentValueForAdditionalSupportedValueTypeOperation));
}
public static InterproceduralAnalysisKind GetInterproceduralAnalysisKindOption(
this AnalyzerOptions options,
DiagnosticDescriptor rule,
ISymbol symbol,
Compilation compilation,
InterproceduralAnalysisKind defaultValue,
CancellationToken cancellationToken)
=> options.GetInterproceduralAnalysisKindOption(rule, symbol.Locations[0].SourceTree, compilation, defaultValue, cancellationToken);
public static InterproceduralAnalysisKind GetInterproceduralAnalysisKindOption(
this AnalyzerOptions options,
DiagnosticDescriptor rule,
ISymbol symbol,
Compilation compilation,
InterproceduralAnalysisKind defaultValue)
=> TryGetSyntaxTreeForOption(symbol, out var tree)
? options.GetInterproceduralAnalysisKindOption(rule, tree, compilation, defaultValue)
: defaultValue;
private InterproceduralAnalysisConfiguration(
InterproceduralAnalysisKind interproceduralAnalysisKind,
uint maxInterproceduralMethodCallChain,
uint maxInterproceduralLambdaOrLocalFunctionCallChain)
{
InterproceduralAnalysisKind = interproceduralAnalysisKind;
MaxInterproceduralMethodCallChain = maxInterproceduralMethodCallChain;
MaxInterproceduralLambdaOrLocalFunctionCallChain = maxInterproceduralLambdaOrLocalFunctionCallChain;
}
public static InterproceduralAnalysisConfiguration Create(
AnalyzerOptions analyzerOptions,
ImmutableArray <DiagnosticDescriptor> rules,
ControlFlowGraph cfg,
Compilation compilation,
InterproceduralAnalysisKind defaultInterproceduralAnalysisKind,
uint defaultMaxInterproceduralMethodCallChain = DefaultMaxInterproceduralMethodCallChain,
uint defaultMaxInterproceduralLambdaOrLocalFunctionCallChain = DefaultMaxInterproceduralLambdaOrLocalFunctionCallChain)
=> Create(analyzerOptions, rules, cfg.OriginalOperation, compilation, defaultInterproceduralAnalysisKind,
defaultMaxInterproceduralMethodCallChain, defaultMaxInterproceduralLambdaOrLocalFunctionCallChain);
public static InterproceduralAnalysisConfiguration Create(
AnalyzerOptions analyzerOptions,
DiagnosticDescriptor rule,
ControlFlowGraph cfg,
Compilation compilation,
InterproceduralAnalysisKind defaultInterproceduralAnalysisKind,
CancellationToken cancellationToken,
uint defaultMaxInterproceduralMethodCallChain = DefaultMaxInterproceduralMethodCallChain,
uint defaultMaxInterproceduralLambdaOrLocalFunctionCallChain = DefaultMaxInterproceduralLambdaOrLocalFunctionCallChain)
=> Create(analyzerOptions, rule, cfg.OriginalOperation.Syntax.SyntaxTree, compilation, defaultInterproceduralAnalysisKind,
cancellationToken, defaultMaxInterproceduralMethodCallChain, defaultMaxInterproceduralLambdaOrLocalFunctionCallChain);
public static InterproceduralAnalysisConfiguration Create(
AnalyzerOptions analyzerOptions,
ImmutableArray <DiagnosticDescriptor> rules,
ISymbol symbol,
Compilation compilation,
InterproceduralAnalysisKind defaultInterproceduralAnalysisKind,
CancellationToken cancellationToken,
uint defaultMaxInterproceduralMethodCallChain = DefaultMaxInterproceduralMethodCallChain,
uint defaultMaxInterproceduralLambdaOrLocalFunctionCallChain = DefaultMaxInterproceduralLambdaOrLocalFunctionCallChain)
=> Create(analyzerOptions, rules, symbol.Locations[0].SourceTree, compilation, defaultInterproceduralAnalysisKind,
cancellationToken, defaultMaxInterproceduralMethodCallChain, defaultMaxInterproceduralLambdaOrLocalFunctionCallChain);
public static ValueContentAnalysisResult?TryGetOrComputeResult(
ControlFlowGraph cfg,
ISymbol owningSymbol,
WellKnownTypeProvider wellKnownTypeProvider,
AnalyzerOptions analyzerOptions,
DiagnosticDescriptor rule,
PointsToAnalysisKind defaultPointsToAnalysisKind,
InterproceduralAnalysisKind interproceduralAnalysisKind = InterproceduralAnalysisKind.None,
bool pessimisticAnalysis = true)
{
return(TryGetOrComputeResult(cfg, owningSymbol, wellKnownTypeProvider, analyzerOptions, rule,
defaultPointsToAnalysisKind, out var _, out var _, interproceduralAnalysisKind, pessimisticAnalysis));
}
public static ImmutableDictionary <IParameterSymbol, SyntaxNode> GetOrComputeHazardousParameterUsages(
IBlockOperation topmostBlock,
Compilation compilation,
ISymbol owningSymbol,
AnalyzerOptions analyzerOptions,
DiagnosticDescriptor rule,
CancellationToken cancellationToken,
InterproceduralAnalysisKind interproceduralAnalysisKind = InterproceduralAnalysisKind.ContextSensitive,
uint defaultMaxInterproceduralMethodCallChain = 1, // By default, we only want to track method calls one level down.
bool pessimisticAnalysis = true)
{
var interproceduralAnalysisConfig = InterproceduralAnalysisConfiguration.Create(
analyzerOptions, rule, interproceduralAnalysisKind, cancellationToken, defaultMaxInterproceduralMethodCallChain);
return(GetOrComputeHazardousParameterUsages(topmostBlock, compilation, owningSymbol,
interproceduralAnalysisConfig, pessimisticAnalysis));
}
public static ImmutableDictionary<IParameterSymbol, SyntaxNode> GetOrComputeHazardousParameterUsages(
IBlockOperation topmostBlock,
Compilation compilation,
ISymbol owningSymbol,
AnalyzerOptions analyzerOptions,
DiagnosticDescriptor rule,
CancellationToken cancellationToken,
InterproceduralAnalysisKind interproceduralAnalysisKind = InterproceduralAnalysisKind.ContextSensitive,
uint defaultMaxInterproceduralMethodCallChain = 1, // By default, we only want to track method calls one level down.
bool pessimisticAnalysis = true)
{
Debug.Assert(!owningSymbol.IsConfiguredToSkipAnalysis(analyzerOptions, rule, compilation, cancellationToken));
var interproceduralAnalysisConfig = InterproceduralAnalysisConfiguration.Create(
analyzerOptions, rule, topmostBlock.Syntax.SyntaxTree, compilation, interproceduralAnalysisKind, cancellationToken, defaultMaxInterproceduralMethodCallChain);
var performCopyAnalysis = analyzerOptions.GetCopyAnalysisOption(rule, topmostBlock.Syntax.SyntaxTree, compilation, defaultValue: false, cancellationToken);
var nullCheckValidationMethods = analyzerOptions.GetNullCheckValidationMethodsOption(rule, topmostBlock.Syntax.SyntaxTree, compilation, cancellationToken);
return GetOrComputeHazardousParameterUsages(topmostBlock, compilation, owningSymbol, analyzerOptions,
nullCheckValidationMethods, interproceduralAnalysisConfig, performCopyAnalysis, pessimisticAnalysis);
}
public static DisposeAnalysisResult?TryGetOrComputeResult(
ControlFlowGraph cfg,
ISymbol owningSymbol,
WellKnownTypeProvider wellKnownTypeProvider,
AnalyzerOptions analyzerOptions,
DiagnosticDescriptor rule,
ImmutableHashSet <INamedTypeSymbol> disposeOwnershipTransferLikelyTypes,
PointsToAnalysisKind defaultPointsToAnalysisKind,
bool trackInstanceFields,
bool exceptionPathsAnalysis,
CancellationToken cancellationToken,
out PointsToAnalysisResult?pointsToAnalysisResult,
InterproceduralAnalysisKind interproceduralAnalysisKind = InterproceduralAnalysisKind.ContextSensitive,
bool performCopyAnalysisIfNotUserConfigured = false,
InterproceduralAnalysisPredicate?interproceduralAnalysisPredicate = null,
bool defaultDisposeOwnershipTransferAtConstructor = false,
bool defaultDisposeOwnershipTransferAtMethodCall = false)
{
if (cfg == null)
{
throw new ArgumentNullException(nameof(cfg));
}
Debug.Assert(!analyzerOptions.IsConfiguredToSkipAnalysis(rule, owningSymbol, wellKnownTypeProvider.Compilation, cancellationToken));
var interproceduralAnalysisConfig = InterproceduralAnalysisConfiguration.Create(
analyzerOptions, rule, cfg, wellKnownTypeProvider.Compilation, interproceduralAnalysisKind, cancellationToken);
var disposeOwnershipTransferAtConstructor = analyzerOptions.GetDisposeOwnershipTransferAtConstructorOption(
rule, owningSymbol, wellKnownTypeProvider.Compilation, defaultValue: defaultDisposeOwnershipTransferAtConstructor, cancellationToken);
var disposeOwnershipTransferAtMethodCall = analyzerOptions.GetDisposeOwnershipTransferAtMethodCall(
rule, owningSymbol, wellKnownTypeProvider.Compilation, defaultValue: defaultDisposeOwnershipTransferAtMethodCall, cancellationToken);
return(TryGetOrComputeResult(cfg, owningSymbol, analyzerOptions, wellKnownTypeProvider,
interproceduralAnalysisConfig, interproceduralAnalysisPredicate,
disposeOwnershipTransferLikelyTypes, disposeOwnershipTransferAtConstructor,
disposeOwnershipTransferAtMethodCall, trackInstanceFields, exceptionPathsAnalysis,
pointsToAnalysisKind: analyzerOptions.GetPointsToAnalysisKindOption(rule, owningSymbol, wellKnownTypeProvider.Compilation, defaultPointsToAnalysisKind, cancellationToken),
performCopyAnalysis: analyzerOptions.GetCopyAnalysisOption(rule, owningSymbol, wellKnownTypeProvider.Compilation, defaultValue: performCopyAnalysisIfNotUserConfigured, cancellationToken),
isConfiguredToSkipAnalysis: (ISymbol symbol) => analyzerOptions.IsConfiguredToSkipAnalysis(rule, symbol, owningSymbol, wellKnownTypeProvider.Compilation, cancellationToken),
out pointsToAnalysisResult));
}
public static GlobalFlowStateAnalysisResult?TryGetOrComputeResult(
ControlFlowGraph cfg,
ISymbol owningSymbol,
Func <GlobalFlowStateAnalysisContext, GlobalFlowStateDataFlowOperationVisitor> createOperationVisitor,
WellKnownTypeProvider wellKnownTypeProvider,
AnalyzerOptions analyzerOptions,
DiagnosticDescriptor rule,
bool performValueContentAnalysis,
CancellationToken cancellationToken,
out ValueContentAnalysisResult?valueContentAnalysisResult,
InterproceduralAnalysisKind interproceduralAnalysisKind = InterproceduralAnalysisKind.None,
bool pessimisticAnalysis = true,
InterproceduralAnalysisPredicate?interproceduralAnalysisPredicate = null)
{
var interproceduralAnalysisConfig = InterproceduralAnalysisConfiguration.Create(
analyzerOptions, rule, owningSymbol, wellKnownTypeProvider.Compilation, interproceduralAnalysisKind, cancellationToken);
return(TryGetOrComputeResult(cfg, owningSymbol, createOperationVisitor, wellKnownTypeProvider, analyzerOptions,
interproceduralAnalysisConfig, interproceduralAnalysisPredicate, pessimisticAnalysis,
performValueContentAnalysis, out valueContentAnalysisResult));
}
public static InterproceduralAnalysisKind GetInterproceduralAnalysisKindOption(
this AnalyzerOptions options,
DiagnosticDescriptor rule,
InterproceduralAnalysisKind defaultValue,
CancellationToken cancellationToken)
=> options.GetNonFlagsEnumOptionValue(EditorConfigOptionNames.InterproceduralAnalysisKind, rule, defaultValue, cancellationToken);
