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));
}
private FlightEnabledAnalysisContext(
AbstractValueDomain <FlightEnabledAbstractValue> valueDomain,
WellKnownTypeProvider wellKnownTypeProvider,
ControlFlowGraph controlFlowGraph,
ISymbol owningSymbol,
ImmutableArray <IMethodSymbol> flightEnablingMethods,
Func <FlightEnabledAnalysisCallbackContext, FlightEnabledAbstractValue> getValueForFlightEnablingMethodInvocation,
AnalyzerOptions analyzerOptions,
InterproceduralAnalysisConfiguration interproceduralAnalysisConfig,
bool pessimisticAnalysis,
PointsToAnalysisResult?pointsToAnalysisResultOpt,
ValueContentAnalysisResult?valueContentAnalysisResultOpt,
Func <FlightEnabledAnalysisContext, FlightEnabledAnalysisResult?> tryGetOrComputeAnalysisResult,
ControlFlowGraph?parentControlFlowGraphOpt,
InterproceduralFlightEnabledAnalysisData?interproceduralAnalysisDataOpt,
InterproceduralAnalysisPredicate?interproceduralAnalysisPredicateOpt)
: base(valueDomain, wellKnownTypeProvider, controlFlowGraph,
owningSymbol, analyzerOptions, interproceduralAnalysisConfig, pessimisticAnalysis,
predicateAnalysis: false,
exceptionPathsAnalysis: false,
copyAnalysisResultOpt: null,
pointsToAnalysisResultOpt,
valueContentAnalysisResultOpt,
tryGetOrComputeAnalysisResult,
parentControlFlowGraphOpt,
interproceduralAnalysisDataOpt,
interproceduralAnalysisPredicateOpt)
{
RoslynDebug.Assert(!flightEnablingMethods.IsDefaultOrEmpty);
FlightEnablingMethods = flightEnablingMethods;
GetValueForFlightEnablingMethodInvocation = getValueForFlightEnablingMethodInvocation;
}
private static GlobalFlowStateAnalysisResult?TryGetOrComputeResult(
ControlFlowGraph cfg,
ISymbol owningSymbol,
Func <GlobalFlowStateAnalysisContext, GlobalFlowStateDataFlowOperationVisitor> createOperationVisitor,
WellKnownTypeProvider wellKnownTypeProvider,
AnalyzerOptions analyzerOptions,
InterproceduralAnalysisConfiguration interproceduralAnalysisConfig,
InterproceduralAnalysisPredicate?interproceduralAnalysisPredicate,
bool pessimisticAnalysis,
bool performValueContentAnalysis,
out ValueContentAnalysisResult?valueContentAnalysisResult)
{
RoslynDebug.Assert(cfg != null);
RoslynDebug.Assert(owningSymbol != null);
PointsToAnalysisResult?pointsToAnalysisResult = null;
valueContentAnalysisResult = performValueContentAnalysis ?
ValueContentAnalysis.ValueContentAnalysis.TryGetOrComputeResult(
cfg, owningSymbol, analyzerOptions, wellKnownTypeProvider,
PointsToAnalysisKind.PartialWithoutTrackingFieldsAndProperties,
interproceduralAnalysisConfig, out _,
out pointsToAnalysisResult, pessimisticAnalysis,
performCopyAnalysis: false, interproceduralAnalysisPredicate) :
null;
var analysisContext = GlobalFlowStateAnalysisContext.Create(
GlobalFlowStateAnalysisValueSetDomain.Instance, wellKnownTypeProvider, cfg, owningSymbol,
analyzerOptions, interproceduralAnalysisConfig, pessimisticAnalysis, pointsToAnalysisResult,
valueContentAnalysisResult, c => TryGetOrComputeResultForAnalysisContext(c, createOperationVisitor), interproceduralAnalysisPredicate);
return(TryGetOrComputeResultForAnalysisContext(analysisContext, createOperationVisitor));
}
private static TaintedDataAnalysisResult GetOrComputeResult(
ControlFlowGraph cfg,
Compilation compilation,
ISymbol containingMethod,
TaintedDataSymbolMap <SourceInfo> taintedSourceInfos,
TaintedDataSymbolMap <SanitizerInfo> taintedSanitizerInfos,
TaintedDataSymbolMap <SinkInfo> taintedSinkInfos,
InterproceduralAnalysisConfiguration interproceduralAnalysisConfig)
{
WellKnownTypeProvider wellKnownTypeProvider = WellKnownTypeProvider.GetOrCreate(compilation);
PointsToAnalysisResult pointsToAnalysisResult = PointsToAnalysis.GetOrComputeResult(
cfg,
containingMethod,
wellKnownTypeProvider,
interproceduralAnalysisConfig,
interproceduralAnalysisPredicateOpt: null,
pessimisticAnalysis: true,
performCopyAnalysis: false);
TaintedDataAnalysisContext analysisContext = TaintedDataAnalysisContext.Create(
TaintedDataAbstractValueDomain.Default,
wellKnownTypeProvider,
cfg,
containingMethod,
interproceduralAnalysisConfig,
pessimisticAnalysis: false,
pointsToAnalysisResult: pointsToAnalysisResult,
getOrComputeAnalysisResult: GetOrComputeResultForAnalysisContext,
taintedSourceInfos: taintedSourceInfos,
taintedSanitizerInfos: taintedSanitizerInfos,
taintedSinkInfos: taintedSinkInfos);
return(GetOrComputeResultForAnalysisContext(analysisContext));
}
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 = true,
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));
}
private static ImmutableDictionary <IParameterSymbol, SyntaxNode> GetOrComputeHazardousParameterUsages(
IBlockOperation topmostBlock,
Compilation compilation,
ISymbol owningSymbol,
InterproceduralAnalysisConfiguration interproceduralAnalysisConfig,
bool pessimisticAnalysis = true)
{
Debug.Assert(topmostBlock != null);
var cfg = topmostBlock.GetEnclosingControlFlowGraph();
var wellKnownTypeProvider = WellKnownTypeProvider.GetOrCreate(compilation);
var pointsToAnalysisResult = PointsToAnalysis.PointsToAnalysis.TryGetOrComputeResult(cfg, owningSymbol, wellKnownTypeProvider,
interproceduralAnalysisConfig, interproceduralAnalysisPredicateOpt: null, pessimisticAnalysis);
if (pointsToAnalysisResult != null)
{
var result = TryGetOrComputeResult(cfg, owningSymbol, wellKnownTypeProvider,
interproceduralAnalysisConfig, pessimisticAnalysis, pointsToAnalysisResult);
if (result != null)
{
return(result.HazardousParameterUsages);
}
}
return(ImmutableDictionary <IParameterSymbol, SyntaxNode> .Empty);
}
internal static DisposeAnalysisContext Create(
AbstractValueDomain <DisposeAbstractValue> valueDomain,
WellKnownTypeProvider wellKnownTypeProvider,
ControlFlowGraph controlFlowGraph,
ISymbol owningSymbol,
AnalyzerOptions analyzerOptions,
InterproceduralAnalysisConfiguration interproceduralAnalysisConfig,
InterproceduralAnalysisPredicate?interproceduralAnalysisPredicate,
bool pessimisticAnalysis,
bool exceptionPathsAnalysis,
PointsToAnalysisResult?pointsToAnalysisResult,
Func <DisposeAnalysisContext, DisposeAnalysisResult?> tryGetOrComputeAnalysisResult,
ImmutableHashSet <INamedTypeSymbol> disposeOwnershipTransferLikelyTypes,
bool disposeOwnershipTransferAtConstructor,
bool disposeOwnershipTransferAtMethodCall,
bool trackInstanceFields,
Func <ISymbol, bool> isConfiguredToSkipAnalysis)
{
return(new DisposeAnalysisContext(
valueDomain, wellKnownTypeProvider, controlFlowGraph,
owningSymbol, analyzerOptions, interproceduralAnalysisConfig, pessimisticAnalysis,
exceptionPathsAnalysis, pointsToAnalysisResult, tryGetOrComputeAnalysisResult,
disposeOwnershipTransferLikelyTypes, disposeOwnershipTransferAtConstructor, disposeOwnershipTransferAtMethodCall,
trackInstanceFields, parentControlFlowGraph: null, interproceduralAnalysisData: null,
interproceduralAnalysisPredicate, isConfiguredToSkipAnalysis));
}
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));
}
private DisposeAnalysisContext(
AbstractValueDomain <DisposeAbstractValue> valueDomain,
WellKnownTypeProvider wellKnownTypeProvider,
ControlFlowGraph controlFlowGraph,
ISymbol owningSymbol,
InterproceduralAnalysisConfiguration interproceduralAnalysisConfig,
bool pessimisticAnalysis,
bool exceptionPathsAnalysis,
PointsToAnalysisResult pointsToAnalysisResultOpt,
Func <DisposeAnalysisContext, DisposeAnalysisResult> getOrComputeAnalysisResult,
ImmutableHashSet <INamedTypeSymbol> disposeOwnershipTransferLikelyTypes,
bool disposeOwnershipTransferAtConstructor,
bool trackInstanceFields,
ControlFlowGraph parentControlFlowGraphOpt,
InterproceduralDisposeAnalysisData interproceduralAnalysisDataOpt,
InterproceduralAnalysisPredicate interproceduralAnalysisPredicateOpt)
: base(valueDomain, wellKnownTypeProvider, controlFlowGraph,
owningSymbol, interproceduralAnalysisConfig, pessimisticAnalysis,
predicateAnalysis: false,
exceptionPathsAnalysis,
copyAnalysisResultOpt: null,
pointsToAnalysisResultOpt,
valueContentAnalysisResultOpt: null,
getOrComputeAnalysisResult,
parentControlFlowGraphOpt,
interproceduralAnalysisDataOpt,
interproceduralAnalysisPredicateOpt)
{
DisposeOwnershipTransferLikelyTypes = disposeOwnershipTransferLikelyTypes;
DisposeOwnershipTransferAtConstructor = disposeOwnershipTransferAtConstructor;
TrackInstanceFields = trackInstanceFields;
}
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));
}
private static DisposeAnalysisResult GetOrComputeResult(
ControlFlowGraph cfg,
ISymbol owningSymbol,
WellKnownTypeProvider wellKnownTypeProvider,
InterproceduralAnalysisConfiguration interproceduralAnalysisConfig,
InterproceduralAnalysisPredicate interproceduralAnalysisPredicateOpt,
ImmutableHashSet <INamedTypeSymbol> disposeOwnershipTransferLikelyTypes,
bool disposeOwnershipTransferAtConstructor,
bool trackInstanceFields,
bool exceptionPathsAnalysis,
bool performCopyAnalysis,
out PointsToAnalysisResult pointsToAnalysisResult)
{
Debug.Assert(cfg != null);
Debug.Assert(wellKnownTypeProvider.IDisposable != null);
Debug.Assert(owningSymbol != null);
pointsToAnalysisResult = PointsToAnalysis.PointsToAnalysis.GetOrComputeResult(
cfg, owningSymbol, wellKnownTypeProvider, interproceduralAnalysisConfig,
interproceduralAnalysisPredicateOpt, PessimisticAnalysis, performCopyAnalysis, exceptionPathsAnalysis);
var analysisContext = DisposeAnalysisContext.Create(
DisposeAbstractValueDomain.Default, wellKnownTypeProvider, cfg, owningSymbol, interproceduralAnalysisConfig, interproceduralAnalysisPredicateOpt,
PessimisticAnalysis, exceptionPathsAnalysis, pointsToAnalysisResult, GetOrComputeResultForAnalysisContext,
disposeOwnershipTransferLikelyTypes, disposeOwnershipTransferAtConstructor, trackInstanceFields);
return(GetOrComputeResultForAnalysisContext(analysisContext));
}
/// <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 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)
{
var interproceduralAnalysisConfig = InterproceduralAnalysisConfiguration.Create(
analyzerOptions, rule, owningSymbol, 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));
}
private static DisposeAnalysisResult?TryGetOrComputeResult(
ControlFlowGraph cfg,
ISymbol owningSymbol,
AnalyzerOptions analyzerOptions,
WellKnownTypeProvider wellKnownTypeProvider,
InterproceduralAnalysisConfiguration interproceduralAnalysisConfig,
InterproceduralAnalysisPredicate?interproceduralAnalysisPredicate,
ImmutableHashSet <INamedTypeSymbol> disposeOwnershipTransferLikelyTypes,
bool disposeOwnershipTransferAtConstructor,
bool disposeOwnershipTransferAtMethodCall,
bool trackInstanceFields,
bool exceptionPathsAnalysis,
PointsToAnalysisKind pointsToAnalysisKind,
bool performCopyAnalysis,
Func <ISymbol, bool> isConfiguredToSkipAnalysis,
out PointsToAnalysisResult?pointsToAnalysisResult)
{
Debug.Assert(wellKnownTypeProvider.TryGetOrCreateTypeByMetadataName(WellKnownTypeNames.SystemIDisposable, out _));
pointsToAnalysisResult = PointsToAnalysis.PointsToAnalysis.TryGetOrComputeResult(
cfg, owningSymbol, analyzerOptions, wellKnownTypeProvider, pointsToAnalysisKind, interproceduralAnalysisConfig,
interproceduralAnalysisPredicate, PessimisticAnalysis, performCopyAnalysis, exceptionPathsAnalysis);
if (pointsToAnalysisResult == null)
{
return(null);
}
var analysisContext = DisposeAnalysisContext.Create(
DisposeAbstractValueDomain.Default, wellKnownTypeProvider, cfg, owningSymbol, analyzerOptions, interproceduralAnalysisConfig, interproceduralAnalysisPredicate,
PessimisticAnalysis, exceptionPathsAnalysis, pointsToAnalysisResult, TryGetOrComputeResultForAnalysisContext,
disposeOwnershipTransferLikelyTypes, disposeOwnershipTransferAtConstructor, disposeOwnershipTransferAtMethodCall, trackInstanceFields, isConfiguredToSkipAnalysis);
return(TryGetOrComputeResultForAnalysisContext(analysisContext));
}
public static TaintedDataAnalysisContext Create(
AbstractValueDomain <TaintedDataAbstractValue> valueDomain,
WellKnownTypeProvider wellKnownTypeProvider,
ControlFlowGraph controlFlowGraph,
ISymbol owningSymbol,
InterproceduralAnalysisConfiguration interproceduralAnalysisConfig,
bool pessimisticAnalysis,
PointsToAnalysisResult pointsToAnalysisResult,
Func <TaintedDataAnalysisContext, TaintedDataAnalysisResult> tryGetOrComputeAnalysisResult,
TaintedDataSymbolMap <SourceInfo> taintedSourceInfos,
TaintedDataSymbolMap <SanitizerInfo> taintedSanitizerInfos,
TaintedDataSymbolMap <SinkInfo> taintedSinkInfos)
{
Debug.Assert(pointsToAnalysisResult != null);
return(new TaintedDataAnalysisContext(
valueDomain,
wellKnownTypeProvider,
controlFlowGraph,
owningSymbol,
interproceduralAnalysisConfig,
pessimisticAnalysis,
pointsToAnalysisResult,
tryGetOrComputeAnalysisResult,
parentControlFlowGraph: null,
interproceduralAnalysisDataOpt: null,
taintedSourceInfos: taintedSourceInfos,
taintedSanitizerInfos: taintedSanitizerInfos,
taintedSinkInfos: taintedSinkInfos));
}
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,
bool defaultDisposeOwnershipTransferAtMethodCall = false)
{
Debug.Assert(!owningSymbol.IsConfiguredToSkipAnalysis(analyzerOptions, rule, wellKnownTypeProvider.Compilation, cancellationToken));
var interproceduralAnalysisConfig = InterproceduralAnalysisConfiguration.Create(
analyzerOptions, rule, interproceduralAnalysisKind, cancellationToken);
var disposeOwnershipTransferAtConstructor = analyzerOptions.GetDisposeOwnershipTransferAtConstructorOption(
rule, defaultValue: defaultDisposeOwnershipTransferAtConstructor, cancellationToken);
var disposeOwnershipTransferAtMethodCall = analyzerOptions.GetDisposeOwnershipTransferAtMethodCall(
rule, defaultValue: defaultDisposeOwnershipTransferAtMethodCall, cancellationToken);
return(TryGetOrComputeResult(cfg, owningSymbol, analyzerOptions, wellKnownTypeProvider,
interproceduralAnalysisConfig, interproceduralAnalysisPredicateOpt,
disposeOwnershipTransferLikelyTypes, disposeOwnershipTransferAtConstructor,
disposeOwnershipTransferAtMethodCall, trackInstanceFields, exceptionPathsAnalysis,
performCopyAnalysis: analyzerOptions.GetCopyAnalysisOption(rule, defaultValue: performCopyAnalysisIfNotUserConfigured, cancellationToken),
out pointsToAnalysisResult));
}
public static PointsToAnalysisResult?TryGetOrComputeResult(
ControlFlowGraph cfg,
ISymbol owningSymbol,
AnalyzerOptions analyzerOptions,
WellKnownTypeProvider wellKnownTypeProvider,
out CopyAnalysisResult?copyAnalysisResultOpt,
InterproceduralAnalysisConfiguration interproceduralAnalysisConfig,
InterproceduralAnalysisPredicate?interproceduralAnalysisPredicateOpt,
bool pessimisticAnalysis = true,
bool performCopyAnalysis = false,
bool exceptionPathsAnalysis = false)
{
copyAnalysisResultOpt = performCopyAnalysis ?
CopyAnalysis.CopyAnalysis.TryGetOrComputeResult(cfg, owningSymbol, analyzerOptions, wellKnownTypeProvider, interproceduralAnalysisConfig,
interproceduralAnalysisPredicateOpt, pessimisticAnalysis, performPointsToAnalysis: true, exceptionPathsAnalysis) :
null;
if (cfg == null)
{
Debug.Fail("Expected non-null CFG");
return(null);
}
var analysisContext = PointsToAnalysisContext.Create(PointsToAbstractValueDomain.Default, wellKnownTypeProvider, cfg,
owningSymbol, analyzerOptions, interproceduralAnalysisConfig, pessimisticAnalysis, exceptionPathsAnalysis, copyAnalysisResultOpt,
TryGetOrComputeResultForAnalysisContext, interproceduralAnalysisPredicateOpt);
return(TryGetOrComputeResultForAnalysisContext(analysisContext));
}
internal static ValueContentAnalysisResult?TryGetOrComputeResult(
ControlFlowGraph cfg,
ISymbol owningSymbol,
AnalyzerOptions analyzerOptions,
WellKnownTypeProvider wellKnownTypeProvider,
PointsToAnalysisKind pointsToAnalysisKind,
InterproceduralAnalysisConfiguration interproceduralAnalysisConfig,
out CopyAnalysisResult?copyAnalysisResult,
out PointsToAnalysisResult?pointsToAnalysisResult,
bool pessimisticAnalysis = true,
bool performCopyAnalysis = false,
InterproceduralAnalysisPredicate?interproceduralAnalysisPredicate = null,
ImmutableArray <INamedTypeSymbol> additionalSupportedValueTypes = default,
Func <IOperation, ValueContentAbstractValue>?getValueContentValueForAdditionalSupportedValueTypeOperation = null)
{
if (cfg == null)
{
throw new ArgumentNullException(nameof(cfg));
}
copyAnalysisResult = null;
pointsToAnalysisResult = pointsToAnalysisKind != PointsToAnalysisKind.None ?
PointsToAnalysis.PointsToAnalysis.TryGetOrComputeResult(cfg, owningSymbol, analyzerOptions, wellKnownTypeProvider, pointsToAnalysisKind, out copyAnalysisResult,
interproceduralAnalysisConfig, interproceduralAnalysisPredicate, pessimisticAnalysis, performCopyAnalysis) :
null;
var analysisContext = ValueContentAnalysisContext.Create(
ValueContentAbstractValueDomain.Default, wellKnownTypeProvider, cfg, owningSymbol, analyzerOptions,
interproceduralAnalysisConfig, pessimisticAnalysis, copyAnalysisResult,
pointsToAnalysisResult, TryGetOrComputeResultForAnalysisContext,
additionalSupportedValueTypes, getValueContentValueForAdditionalSupportedValueTypeOperation,
interproceduralAnalysisPredicate);
return(TryGetOrComputeResultForAnalysisContext(analysisContext));
}
internal static ValueContentAnalysisResult?TryGetOrComputeResult(
ControlFlowGraph cfg,
ISymbol owningSymbol,
AnalyzerOptions analyzerOptions,
WellKnownTypeProvider wellKnownTypeProvider,
PointsToAnalysisKind pointsToAnalysisKind,
InterproceduralAnalysisConfiguration interproceduralAnalysisConfig,
out CopyAnalysisResult?copyAnalysisResult,
out PointsToAnalysisResult?pointsToAnalysisResult,
bool pessimisticAnalysis = true,
bool performCopyAnalysis = false,
InterproceduralAnalysisPredicate?interproceduralAnalysisPredicate = null)
{
copyAnalysisResult = null;
pointsToAnalysisResult = pointsToAnalysisKind != PointsToAnalysisKind.None ?
PointsToAnalysis.PointsToAnalysis.TryGetOrComputeResult(cfg, owningSymbol, analyzerOptions, wellKnownTypeProvider, pointsToAnalysisKind, out copyAnalysisResult,
interproceduralAnalysisConfig, interproceduralAnalysisPredicate, pessimisticAnalysis, performCopyAnalysis) :
null;
if (cfg == null)
{
Debug.Fail("Expected non-null CFG");
return(null);
}
var analysisContext = ValueContentAnalysisContext.Create(
ValueContentAbstractValueDomain.Default, wellKnownTypeProvider, cfg, owningSymbol, analyzerOptions,
interproceduralAnalysisConfig, pessimisticAnalysis, copyAnalysisResult,
pointsToAnalysisResult, TryGetOrComputeResultForAnalysisContext, interproceduralAnalysisPredicate);
return(TryGetOrComputeResultForAnalysisContext(analysisContext));
}
private static ImmutableDictionary <IParameterSymbol, SyntaxNode> GetOrComputeHazardousParameterUsages(
IBlockOperation topmostBlock,
Compilation compilation,
ISymbol owningSymbol,
AnalyzerOptions analyzerOptions,
SymbolNamesWithValueOption <Unit> nullCheckValidationMethods,
InterproceduralAnalysisConfiguration interproceduralAnalysisConfig,
bool performCopyAnalysis,
bool pessimisticAnalysis = true)
{
var cfg = topmostBlock.GetEnclosingControlFlowGraph();
if (cfg == null)
{
return(ImmutableDictionary <IParameterSymbol, SyntaxNode> .Empty);
}
var wellKnownTypeProvider = WellKnownTypeProvider.GetOrCreate(compilation);
var pointsToAnalysisResult = PointsToAnalysis.PointsToAnalysis.TryGetOrComputeResult(cfg, owningSymbol, analyzerOptions, wellKnownTypeProvider,
interproceduralAnalysisConfig, interproceduralAnalysisPredicateOpt: null, pessimisticAnalysis, performCopyAnalysis);
if (pointsToAnalysisResult != null)
{
var result = TryGetOrComputeResult(cfg, owningSymbol, analyzerOptions, wellKnownTypeProvider,
nullCheckValidationMethods, interproceduralAnalysisConfig, pessimisticAnalysis, pointsToAnalysisResult);
if (result != null)
{
return(result.HazardousParameterUsages);
}
}
return(ImmutableDictionary <IParameterSymbol, SyntaxNode> .Empty);
}
public static PropertySetAnalysisContext Create(
AbstractValueDomain <PropertySetAbstractValue> valueDomain,
WellKnownTypeProvider wellKnownTypeProvider,
ControlFlowGraph controlFlowGraph,
ISymbol owningSymbol,
InterproceduralAnalysisConfiguration interproceduralAnalysisConfig,
bool pessimisticAnalysis,
PointsToAnalysisResult pointsToAnalysisResult,
ValueContentAnalysisResult valueContentAnalysisResultOpt,
Func <PropertySetAnalysisContext, PropertySetAnalysisResult> getOrComputeAnalysisResult,
string typeToTrackMetadataName,
ConstructorMapper constructorMapper,
PropertyMapperCollection propertyMappers,
HazardousUsageEvaluatorCollection hazardousUsageEvaluators)
{
return(new PropertySetAnalysisContext(
valueDomain,
wellKnownTypeProvider,
controlFlowGraph,
owningSymbol,
interproceduralAnalysisConfig,
pessimisticAnalysis,
pointsToAnalysisResult,
valueContentAnalysisResultOpt,
getOrComputeAnalysisResult,
parentControlFlowGraphOpt: null,
interproceduralAnalysisDataOpt: null,
typeToTrackMetadataName: typeToTrackMetadataName,
constructorMapper: constructorMapper,
propertyMappers: propertyMappers,
hazardousUsageEvaluators: hazardousUsageEvaluators,
hazardousUsageTypesToNames: hazardousUsageEvaluators.GetTypeToNameMapping(wellKnownTypeProvider)));
}
private PropertySetAnalysisContext(
AbstractValueDomain <PropertySetAbstractValue> valueDomain,
WellKnownTypeProvider wellKnownTypeProvider,
ControlFlowGraph controlFlowGraph,
ISymbol owningSymbol,
InterproceduralAnalysisConfiguration interproceduralAnalysisConfig,
bool pessimisticAnalysis,
PointsToAnalysisResult pointsToAnalysisResult,
ValueContentAnalysisResult valueContentAnalysisResultOpt,
Func <PropertySetAnalysisContext, PropertySetAnalysisResult> getOrComputeAnalysisResult,
ControlFlowGraph parentControlFlowGraphOpt,
InterproceduralPropertySetAnalysisData interproceduralAnalysisDataOpt,
string typeToTrackMetadataName,
ConstructorMapper constructorMapper,
PropertyMapperCollection propertyMappers,
HazardousUsageEvaluatorCollection hazardousUsageEvaluators,
ImmutableDictionary <INamedTypeSymbol, string> hazardousUsageTypesToNames)
: base(valueDomain, wellKnownTypeProvider, controlFlowGraph, owningSymbol, interproceduralAnalysisConfig, pessimisticAnalysis,
predicateAnalysis: false, exceptionPathsAnalysis: false, copyAnalysisResultOpt: null, pointsToAnalysisResult,
getOrComputeAnalysisResult, parentControlFlowGraphOpt, interproceduralAnalysisDataOpt, interproceduralAnalysisPredicateOpt: null)
{
this.ValueContentAnalysisResultOpt = valueContentAnalysisResultOpt;
this.TypeToTrackMetadataName = typeToTrackMetadataName;
this.ConstructorMapper = constructorMapper;
this.PropertyMappers = propertyMappers;
this.HazardousUsageEvaluators = hazardousUsageEvaluators;
this.HazardousUsageTypesToNames = hazardousUsageTypesToNames;
}
private GlobalFlowStateAnalysisContext(
AbstractValueDomain <GlobalFlowStateAnalysisValueSet> valueDomain,
WellKnownTypeProvider wellKnownTypeProvider,
ControlFlowGraph controlFlowGraph,
ISymbol owningSymbol,
AnalyzerOptions analyzerOptions,
InterproceduralAnalysisConfiguration interproceduralAnalysisConfig,
bool pessimisticAnalysis,
PointsToAnalysisResult?pointsToAnalysisResult,
ValueContentAnalysisResult?valueContentAnalysisResult,
Func <GlobalFlowStateAnalysisContext, GlobalFlowStateAnalysisResult?> tryGetOrComputeAnalysisResult,
ControlFlowGraph?parentControlFlowGraph,
InterproceduralGlobalFlowStateAnalysisData?interproceduralAnalysisData,
InterproceduralAnalysisPredicate?interproceduralAnalysisPredicate)
: base(valueDomain, wellKnownTypeProvider, controlFlowGraph,
owningSymbol, analyzerOptions, interproceduralAnalysisConfig, pessimisticAnalysis,
predicateAnalysis: false,
exceptionPathsAnalysis: false,
copyAnalysisResult: null,
pointsToAnalysisResult,
valueContentAnalysisResult,
tryGetOrComputeAnalysisResult,
parentControlFlowGraph,
interproceduralAnalysisData,
interproceduralAnalysisPredicate)
{
}
public static CopyAnalysisResult?TryGetOrComputeResult(
ControlFlowGraph cfg,
ISymbol owningSymbol,
AnalyzerOptions analyzerOptions,
WellKnownTypeProvider wellKnownTypeProvider,
InterproceduralAnalysisConfiguration interproceduralAnalysisConfig,
InterproceduralAnalysisPredicate?interproceduralAnalysisPredicate,
bool pessimisticAnalysis = true,
PointsToAnalysisKind pointsToAnalysisKind = PointsToAnalysisKind.PartialWithoutTrackingFieldsAndProperties,
bool exceptionPathsAnalysis = false)
{
if (cfg == null)
{
Debug.Fail("Expected non-null CFG");
return(null);
}
var pointsToAnalysisResult = pointsToAnalysisKind != PointsToAnalysisKind.None ?
PointsToAnalysis.PointsToAnalysis.TryGetOrComputeResult(cfg, owningSymbol, analyzerOptions,
wellKnownTypeProvider, pointsToAnalysisKind, interproceduralAnalysisConfig,
interproceduralAnalysisPredicate, pessimisticAnalysis, performCopyAnalysis: false, exceptionPathsAnalysis) :
null;
var analysisContext = CopyAnalysisContext.Create(CopyAbstractValueDomain.Default, wellKnownTypeProvider,
cfg, owningSymbol, analyzerOptions, interproceduralAnalysisConfig, pessimisticAnalysis, exceptionPathsAnalysis, pointsToAnalysisResult,
TryGetOrComputeResultForAnalysisContext, interproceduralAnalysisPredicate);
return(TryGetOrComputeResultForAnalysisContext(analysisContext));
}
public static PointsToAnalysisResult TryGetOrComputeResult(
ControlFlowGraph cfg,
ISymbol owningSymbol,
WellKnownTypeProvider wellKnownTypeProvider,
InterproceduralAnalysisConfiguration interproceduralAnalysisConfig,
InterproceduralAnalysisPredicate interproceduralAnalysisPredicateOpt,
bool pessimisticAnalysis = true,
bool performCopyAnalysis = true,
bool exceptionPathsAnalysis = false)
{
return(TryGetOrComputeResult(cfg, owningSymbol, wellKnownTypeProvider,
out var _, interproceduralAnalysisConfig, interproceduralAnalysisPredicateOpt,
pessimisticAnalysis, performCopyAnalysis, exceptionPathsAnalysis));
}
private static ParameterValidationAnalysisResult GetOrComputeResult(
ControlFlowGraph cfg,
ISymbol owningSymbol,
WellKnownTypeProvider wellKnownTypeProvider,
InterproceduralAnalysisConfiguration interproceduralAnalysisConfig,
bool pessimisticAnalysis,
PointsToAnalysisResult pointsToAnalysisResult)
{
Debug.Assert(pointsToAnalysisResult != null);
var analysisContext = ParameterValidationAnalysisContext.Create(ParameterValidationAbstractValueDomain.Default,
wellKnownTypeProvider, cfg, owningSymbol, interproceduralAnalysisConfig, pessimisticAnalysis, pointsToAnalysisResult, GetOrComputeResultForAnalysisContext);
return(GetOrComputeResultForAnalysisContext(analysisContext));
}
private static ParameterValidationAnalysisResult? TryGetOrComputeResult(
ControlFlowGraph cfg,
ISymbol owningSymbol,
AnalyzerOptions analyzerOptions,
WellKnownTypeProvider wellKnownTypeProvider,
SymbolNamesWithValueOption<Unit> nullCheckValidationMethods,
InterproceduralAnalysisConfiguration interproceduralAnalysisConfig,
bool pessimisticAnalysis,
PointsToAnalysisResult pointsToAnalysisResult)
{
var analysisContext = ParameterValidationAnalysisContext.Create(ParameterValidationAbstractValueDomain.Default,
wellKnownTypeProvider, cfg, owningSymbol, analyzerOptions, nullCheckValidationMethods, interproceduralAnalysisConfig,
pessimisticAnalysis, pointsToAnalysisResult, TryGetOrComputeResultForAnalysisContext);
return TryGetOrComputeResultForAnalysisContext(analysisContext);
}
public static ParameterValidationAnalysisContext Create(
AbstractValueDomain <ParameterValidationAbstractValue> valueDomain,
WellKnownTypeProvider wellKnownTypeProvider,
ControlFlowGraph controlFlowGraph,
ISymbol owningSymbol,
InterproceduralAnalysisConfiguration interproceduralAnalysisConfig,
bool pessimisticAnalysis,
PointsToAnalysisResult pointsToAnalysisResultOpt,
Func <ParameterValidationAnalysisContext, ParameterValidationAnalysisResult> getOrComputeAnalysisResult)
{
return(new ParameterValidationAnalysisContext(
valueDomain, wellKnownTypeProvider, controlFlowGraph, owningSymbol, interproceduralAnalysisConfig,
pessimisticAnalysis, pointsToAnalysisResultOpt, getOrComputeAnalysisResult, parentControlFlowGraphOpt: null,
interproceduralAnalysisDataOpt: null, trackHazardousParameterUsages: false));
}
internal static PointsToAnalysisContext Create(
AbstractValueDomain <PointsToAbstractValue> valueDomain,
WellKnownTypeProvider wellKnownTypeProvider,
ControlFlowGraph controlFlowGraph,
ISymbol owningSymbol,
InterproceduralAnalysisConfiguration interproceduralAnalysisConfig,
bool pessimisticAnalysis,
bool exceptionPathsAnalysis,
CopyAnalysisResult copyAnalysisResultOpt,
Func <PointsToAnalysisContext, PointsToAnalysisResult> getOrComputeAnalysisResult,
InterproceduralAnalysisPredicate interproceduralAnalysisPredicateOpt)
{
return(new PointsToAnalysisContext(valueDomain, wellKnownTypeProvider, controlFlowGraph, owningSymbol, interproceduralAnalysisConfig,
pessimisticAnalysis, exceptionPathsAnalysis, copyAnalysisResultOpt, getOrComputeAnalysisResult, parentControlFlowGraphOpt: null,
interproceduralAnalysisDataOpt: null, interproceduralAnalysisPredicateOpt));
}
internal static TaintedDataAnalysisResult?TryGetOrComputeResult(
ControlFlowGraph cfg,
Compilation compilation,
ISymbol containingMethod,
AnalyzerOptions analyzerOptions,
DiagnosticDescriptor rule,
TaintedDataSymbolMap <SourceInfo> taintedSourceInfos,
TaintedDataSymbolMap <SanitizerInfo> taintedSanitizerInfos,
TaintedDataSymbolMap <SinkInfo> taintedSinkInfos)
{
var interproceduralAnalysisConfig = InterproceduralAnalysisConfiguration.Create(
analyzerOptions, rule, cfg, compilation, InterproceduralAnalysisKind.ContextSensitive);
return(TryGetOrComputeResult(cfg, compilation, containingMethod, analyzerOptions, taintedSourceInfos,
taintedSanitizerInfos, taintedSinkInfos, interproceduralAnalysisConfig));
}
public static PointsToAnalysisResult?TryGetOrComputeResult(
ControlFlowGraph cfg,
ISymbol owningSymbol,
AnalyzerOptions analyzerOptions,
WellKnownTypeProvider wellKnownTypeProvider,
PointsToAnalysisKind pointsToAnalysisKind,
InterproceduralAnalysisConfiguration interproceduralAnalysisConfig,
InterproceduralAnalysisPredicate?interproceduralAnalysisPredicate,
bool pessimisticAnalysis = true,
bool performCopyAnalysis = false,
bool exceptionPathsAnalysis = false)
{
return(TryGetOrComputeResult(cfg, owningSymbol, analyzerOptions, wellKnownTypeProvider,
pointsToAnalysisKind, out _, interproceduralAnalysisConfig, interproceduralAnalysisPredicate,
pessimisticAnalysis, performCopyAnalysis, exceptionPathsAnalysis));
}
