public override TaintedDataAnalysisContext ForkForInterproceduralAnalysis(
IMethodSymbol invokedMethod,
ControlFlowGraph invokedCfg,
IOperation operation,
PointsToAnalysisResult pointsToAnalysisResultOpt,
DataFlowAnalysisResult <CopyBlockAnalysisResult, CopyAbstractValue> copyAnalysisResultOpt,
DataFlowAnalysisResult <ValueContentBlockAnalysisResult, ValueContentAbstractValue> valueContentAnalysisResultOpt,
InterproceduralTaintedDataAnalysisData interproceduralAnalysisData)
{
Debug.Assert(copyAnalysisResultOpt == null); // Just because we're not passing this argument along.
Debug.Assert(valueContentAnalysisResultOpt == null);
return(new TaintedDataAnalysisContext(
this.ValueDomain,
this.WellKnownTypeProvider,
invokedCfg,
invokedMethod,
this.InterproceduralAnalysisConfiguration,
this.PessimisticAnalysis,
pointsToAnalysisResultOpt,
this.TryGetOrComputeAnalysisResult,
this.ControlFlowGraph,
interproceduralAnalysisData,
this.SourceInfos,
this.SanitizerInfos,
this.SinkInfos));
}
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)));
}
public bool TryGetOrComputeResult(
ImmutableArray <IOperation> operationBlocks,
IMethodSymbol containingMethod,
AnalyzerOptions analyzerOptions,
DiagnosticDescriptor rule,
bool trackInstanceFields,
bool trackExceptionPaths,
CancellationToken cancellationToken,
out DisposeAnalysisResult disposeAnalysisResult,
out PointsToAnalysisResult pointsToAnalysisResult,
InterproceduralAnalysisPredicate interproceduralAnalysisPredicateOpt = null,
bool defaultDisposeOwnershipTransferAtConstructor = false)
{
var cfg = operationBlocks.GetControlFlowGraph();
if (cfg != null)
{
disposeAnalysisResult = DisposeAnalysis.GetOrComputeResult(cfg, containingMethod, _wellKnownTypeProvider,
analyzerOptions, rule, _disposeOwnershipTransferLikelyTypes, trackInstanceFields,
trackExceptionPaths, cancellationToken, out pointsToAnalysisResult,
interproceduralAnalysisPredicateOpt: interproceduralAnalysisPredicateOpt,
defaultDisposeOwnershipTransferAtConstructor: defaultDisposeOwnershipTransferAtConstructor);
return(true);
}
disposeAnalysisResult = null;
pointsToAnalysisResult = null;
return(false);
}
private static DisposeAnalysisResult TryGetOrComputeResult(
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.TryGetOrComputeResult(
cfg, owningSymbol, wellKnownTypeProvider, interproceduralAnalysisConfig,
interproceduralAnalysisPredicateOpt, PessimisticAnalysis, performCopyAnalysis, exceptionPathsAnalysis);
if (pointsToAnalysisResult == null)
{
return(null);
}
var analysisContext = DisposeAnalysisContext.Create(
DisposeAbstractValueDomain.Default, wellKnownTypeProvider, cfg, owningSymbol, interproceduralAnalysisConfig, interproceduralAnalysisPredicateOpt,
PessimisticAnalysis, exceptionPathsAnalysis, pointsToAnalysisResult, TryGetOrComputeResultForAnalysisContext,
disposeOwnershipTransferLikelyTypes, disposeOwnershipTransferAtConstructor, trackInstanceFields);
return(TryGetOrComputeResultForAnalysisContext(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 = 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));
}
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));
}
internal static ValueContentAnalysisResult TryGetOrComputeResult(
ControlFlowGraph cfg,
ISymbol owningSymbol,
AnalyzerOptions analyzerOptions,
WellKnownTypeProvider wellKnownTypeProvider,
InterproceduralAnalysisConfiguration interproceduralAnalysisConfig,
out CopyAnalysisResult copyAnalysisResultOpt,
out PointsToAnalysisResult pointsToAnalysisResultOpt,
bool pessimisticAnalysis = true,
bool performPointsToAnalysis = true,
bool performCopyAnalysis = false,
InterproceduralAnalysisPredicate interproceduralAnalysisPredicateOpt = null)
{
copyAnalysisResultOpt = null;
pointsToAnalysisResultOpt = performPointsToAnalysis ?
PointsToAnalysis.PointsToAnalysis.TryGetOrComputeResult(cfg, owningSymbol, analyzerOptions, wellKnownTypeProvider, out copyAnalysisResultOpt,
interproceduralAnalysisConfig, interproceduralAnalysisPredicateOpt, 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, copyAnalysisResultOpt,
pointsToAnalysisResultOpt, TryGetOrComputeResultForAnalysisContext, interproceduralAnalysisPredicateOpt);
return(TryGetOrComputeResultForAnalysisContext(analysisContext));
}
public static ParameterValidationAnalysisContext Create(
AbstractValueDomain <ParameterValidationAbstractValue> valueDomain,
WellKnownTypeProvider wellKnownTypeProvider,
ControlFlowGraph controlFlowGraph,
ISymbol owningSymbol,
ImmutableArray <string> nullCheckValidationMethods,
InterproceduralAnalysisConfiguration interproceduralAnalysisConfig,
bool pessimisticAnalysis,
PointsToAnalysisResult pointsToAnalysisResultOpt,
Func <ParameterValidationAnalysisContext, ParameterValidationAnalysisResult> tryGetOrComputeAnalysisResult)
{
var nullCheckValidationMethodNames = nullCheckValidationMethods.IsEmpty ?
ImmutableHashSet <string> .Empty :
nullCheckValidationMethods.Where(s => !s.Contains("."))
.ToImmutableHashSet(wellKnownTypeProvider.Compilation.IsCaseSensitive ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase);
var nullCheckValidationMethodSymbols = nullCheckValidationMethods.IsEmpty ?
ImmutableHashSet <IMethodSymbol> .Empty :
nullCheckValidationMethods.Where(s => s.Contains("."))
.Select(s => s.StartsWith("M:", StringComparison.Ordinal) ? s : "M:" + s)
.SelectMany(s => DocumentationCommentId.GetSymbolsForDeclarationId(s, wellKnownTypeProvider.Compilation))
.OfType <IMethodSymbol>()
.WhereNotNull()
.ToImmutableHashSet();
return(new ParameterValidationAnalysisContext(
valueDomain, wellKnownTypeProvider, controlFlowGraph, owningSymbol,
nullCheckValidationMethodNames, nullCheckValidationMethodSymbols, interproceduralAnalysisConfig,
pessimisticAnalysis, pointsToAnalysisResultOpt, tryGetOrComputeAnalysisResult, parentControlFlowGraphOpt: null,
interproceduralAnalysisDataOpt: null, trackHazardousParameterUsages: false));
}
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 abstract TAnalysisContext ForkForInterproceduralAnalysis(
IMethodSymbol invokedMethod,
ControlFlowGraph invokedCfg,
IOperation operation,
PointsToAnalysisResult pointsToAnalysisResultOpt,
CopyAnalysisResult copyAnalysisResultOpt,
InterproceduralAnalysisData <TAnalysisData, TAnalysisContext, TAbstractAnalysisValue> interproceduralAnalysisData);
public override TaintedDataAnalysisContext ForkForInterproceduralAnalysis(
IMethodSymbol invokedMethod,
ControlFlowGraph invokedCfg,
IOperation operation,
PointsToAnalysisResult pointsToAnalysisResultOpt,
DataFlowAnalysisResult <CopyBlockAnalysisResult, CopyAbstractValue> copyAnalysisResultOpt,
DataFlowAnalysisResult <ValueContentBlockAnalysisResult, ValueContentAbstractValue> valueContentAnalysisResultOpt,
InterproceduralTaintedDataAnalysisData interproceduralAnalysisData)
{
return(new TaintedDataAnalysisContext(
this.ValueDomain,
this.WellKnownTypeProvider,
invokedCfg,
invokedMethod,
this.AnalyzerOptions,
this.InterproceduralAnalysisConfiguration,
this.PessimisticAnalysis,
copyAnalysisResultOpt,
pointsToAnalysisResultOpt,
valueContentAnalysisResultOpt,
this.TryGetOrComputeAnalysisResult,
this.ControlFlowGraph,
interproceduralAnalysisData,
this.SourceInfos,
this.SanitizerInfos,
this.SinkInfos));
}
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 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));
}
internal static DisposeAnalysisContext Create(
AbstractValueDomain <DisposeAbstractValue> valueDomain,
WellKnownTypeProvider wellKnownTypeProvider,
ControlFlowGraph controlFlowGraph,
ISymbol owningSymbol,
AnalyzerOptions analyzerOptions,
InterproceduralAnalysisConfiguration interproceduralAnalysisConfig,
InterproceduralAnalysisPredicate interproceduralAnalysisPredicateOpt,
bool pessimisticAnalysis,
bool exceptionPathsAnalysis,
PointsToAnalysisResult pointsToAnalysisResultOpt,
Func <DisposeAnalysisContext, DisposeAnalysisResult> tryGetOrComputeAnalysisResult,
ImmutableHashSet <INamedTypeSymbol> disposeOwnershipTransferLikelyTypes,
bool disposeOwnershipTransferAtConstructor,
bool disposeOwnershipTransferAtMethodCall,
bool trackInstanceFields)
{
return(new DisposeAnalysisContext(
valueDomain, wellKnownTypeProvider, controlFlowGraph,
owningSymbol, analyzerOptions, interproceduralAnalysisConfig, pessimisticAnalysis,
exceptionPathsAnalysis, pointsToAnalysisResultOpt, tryGetOrComputeAnalysisResult,
disposeOwnershipTransferLikelyTypes, disposeOwnershipTransferAtConstructor, disposeOwnershipTransferAtMethodCall,
trackInstanceFields, parentControlFlowGraphOpt: null, interproceduralAnalysisDataOpt: null,
interproceduralAnalysisPredicateOpt));
}
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;
}
public override PropertySetAnalysisContext ForkForInterproceduralAnalysis(
IMethodSymbol invokedMethod,
ControlFlowGraph invokedCfg,
IOperation operation,
PointsToAnalysisResult pointsToAnalysisResultOpt,
CopyAnalysisResult copyAnalysisResultOpt,
ValueContentAnalysisResult valueContentAnalysisResultOpt,
InterproceduralPropertySetAnalysisData interproceduralAnalysisData)
{
Debug.Assert(pointsToAnalysisResultOpt != null);
Debug.Assert(copyAnalysisResultOpt == null);
return(new PropertySetAnalysisContext(
ValueDomain,
WellKnownTypeProvider,
invokedCfg,
invokedMethod,
InterproceduralAnalysisConfiguration,
PessimisticAnalysis,
pointsToAnalysisResultOpt,
valueContentAnalysisResultOpt,
GetOrComputeAnalysisResult,
ControlFlowGraph,
interproceduralAnalysisData,
this.TypeToTrackMetadataName,
this.ConstructorMapper,
this.PropertyMappers,
this.HazardousUsageEvaluators,
this.HazardousUsageTypesToNames));
}
private static void ComputeDiagnostics(
ImmutableDictionary <AbstractLocation, DisposeAbstractValue> disposeData,
ArrayBuilder <Diagnostic> notDisposedDiagnostics,
ArrayBuilder <Diagnostic> mayBeNotDisposedDiagnostics,
DisposeAnalysisResult disposeAnalysisResult,
PointsToAnalysisResult pointsToAnalysisResult,
DisposeAnalysisKind disposeAnalysisKind,
bool isDisposeDataForExceptionPaths)
{
foreach (var kvp in disposeData)
{
AbstractLocation location = kvp.Key;
DisposeAbstractValue disposeValue = kvp.Value;
if (disposeValue.Kind == DisposeAbstractValueKind.NotDisposable ||
location.CreationOpt == null)
{
continue;
}
var isNotDisposed = disposeValue.Kind == DisposeAbstractValueKind.NotDisposed ||
(disposeValue.DisposingOrEscapingOperations.Count > 0 &&
disposeValue.DisposingOrEscapingOperations.All(d => d.IsInsideCatchRegion(disposeAnalysisResult.ControlFlowGraph)));
var isMayBeNotDisposed = !isNotDisposed && (disposeValue.Kind == DisposeAbstractValueKind.MaybeDisposed || disposeValue.Kind == DisposeAbstractValueKind.NotDisposedOrEscaped);
if (isNotDisposed ||
(isMayBeNotDisposed && disposeAnalysisKind.AreMayBeNotDisposedViolationsEnabled()))
{
var syntax = location.TryGetNodeToReportDiagnostic(pointsToAnalysisResult);
if (syntax == null)
{
continue;
}
// CA2000: Call System.IDisposable.Dispose on object created by '{0}' before all references to it are out of scope.
var rule = GetRule(isNotDisposed);
var argument = syntax.ToString();
var diagnostic = syntax.CreateDiagnostic(rule, argument);
if (isNotDisposed)
{
notDisposedDiagnostics.Add(diagnostic);
}
else
{
mayBeNotDisposedDiagnostics.Add(diagnostic);
}
}
}
DiagnosticDescriptor GetRule(bool isNotDisposed)
{
if (isNotDisposed)
{
return(isDisposeDataForExceptionPaths ? NotDisposedOnExceptionPathsRule : NotDisposedRule);
}
else
{
return(isDisposeDataForExceptionPaths ? MayBeDisposedOnExceptionPathsRule : MayBeDisposedRule);
}
}
}
private DisposeAnalysisContext(
AbstractValueDomain <DisposeAbstractValue> valueDomain,
WellKnownTypeProvider wellKnownTypeProvider,
ControlFlowGraph controlFlowGraph,
ISymbol owningSymbol,
InterproceduralAnalysisConfiguration interproceduralAnalysisConfig,
bool pessimisticAnalysis,
bool exceptionPathsAnalysis,
PointsToAnalysisResult pointsToAnalysisResultOpt,
Func <DisposeAnalysisContext, DisposeAnalysisResult> tryGetOrComputeAnalysisResult,
ImmutableHashSet <INamedTypeSymbol> disposeOwnershipTransferLikelyTypes,
bool disposeOwnershipTransferAtConstructor,
bool disposeOwnershipTransferAtMethodCall,
bool trackInstanceFields,
ControlFlowGraph parentControlFlowGraphOpt,
InterproceduralDisposeAnalysisData interproceduralAnalysisDataOpt,
InterproceduralAnalysisPredicate interproceduralAnalysisPredicateOpt)
: base(valueDomain, wellKnownTypeProvider, controlFlowGraph,
owningSymbol, interproceduralAnalysisConfig, pessimisticAnalysis,
predicateAnalysis: false,
exceptionPathsAnalysis,
copyAnalysisResultOpt: null,
pointsToAnalysisResultOpt,
valueContentAnalysisResultOpt: null,
tryGetOrComputeAnalysisResult,
parentControlFlowGraphOpt,
interproceduralAnalysisDataOpt,
interproceduralAnalysisPredicateOpt)
{
DisposeOwnershipTransferLikelyTypes = disposeOwnershipTransferLikelyTypes;
DisposeOwnershipTransferAtConstructor = disposeOwnershipTransferAtConstructor;
DisposeOwnershipTransferAtMethodCall = disposeOwnershipTransferAtMethodCall;
TrackInstanceFields = trackInstanceFields;
}
public override CopyAnalysisContext ForkForInterproceduralAnalysis(
IMethodSymbol invokedMethod,
ControlFlowGraph invokedControlFlowGraph,
IOperation operation,
PointsToAnalysisResult pointsToAnalysisResultOpt,
CopyAnalysisResult copyAnalysisResultOpt,
InterproceduralCopyAnalysisData interproceduralAnalysisData)
{
return(new CopyAnalysisContext(ValueDomain, WellKnownTypeProvider, invokedControlFlowGraph, invokedMethod, InterproceduralAnalysisConfiguration,
PessimisticAnalysis, ExceptionPathsAnalysis, pointsToAnalysisResultOpt, GetOrComputeAnalysisResult, ControlFlowGraph, interproceduralAnalysisData,
InterproceduralAnalysisPredicateOpt));
}
protected AbstractDataFlowAnalysisContext(
AbstractValueDomain <TAbstractAnalysisValue> valueDomain,
WellKnownTypeProvider wellKnownTypeProvider,
ControlFlowGraph controlFlowGraph,
ISymbol owningSymbol,
AnalyzerOptions analyzerOptions,
InterproceduralAnalysisConfiguration interproceduralAnalysisConfig,
bool pessimisticAnalysis,
bool predicateAnalysis,
bool exceptionPathsAnalysis,
CopyAnalysisResult copyAnalysisResultOpt,
PointsToAnalysisResult pointsToAnalysisResultOpt,
ValueContentAnalysisResult valueContentAnalysisResultOpt,
Func <TAnalysisContext, TAnalysisResult> tryGetOrComputeAnalysisResult,
ControlFlowGraph parentControlFlowGraphOpt,
InterproceduralAnalysisData <TAnalysisData, TAnalysisContext, TAbstractAnalysisValue> interproceduralAnalysisDataOpt,
InterproceduralAnalysisPredicate interproceduralAnalysisPredicateOpt)
{
Debug.Assert(valueDomain != null, "valueDomain must not be null for use in ComputeHashCodeParts");
Debug.Assert(controlFlowGraph != null);
Debug.Assert(owningSymbol != null);
Debug.Assert(owningSymbol.Kind == SymbolKind.Method ||
owningSymbol.Kind == SymbolKind.Field ||
owningSymbol.Kind == SymbolKind.Property ||
owningSymbol.Kind == SymbolKind.Event);
Debug.Assert(Equals(owningSymbol.OriginalDefinition, owningSymbol));
Debug.Assert(wellKnownTypeProvider != null);
Debug.Assert(tryGetOrComputeAnalysisResult != null);
Debug.Assert(pointsToAnalysisResultOpt == null ||
pointsToAnalysisResultOpt.ControlFlowGraph == controlFlowGraph);
Debug.Assert(copyAnalysisResultOpt == null ||
copyAnalysisResultOpt.ControlFlowGraph == controlFlowGraph);
Debug.Assert(valueContentAnalysisResultOpt == null ||
valueContentAnalysisResultOpt.ControlFlowGraph == controlFlowGraph);
ValueDomain = valueDomain;
WellKnownTypeProvider = wellKnownTypeProvider;
ControlFlowGraph = controlFlowGraph;
ParentControlFlowGraphOpt = parentControlFlowGraphOpt;
OwningSymbol = owningSymbol;
AnalyzerOptions = analyzerOptions;
InterproceduralAnalysisConfiguration = interproceduralAnalysisConfig;
PessimisticAnalysis = pessimisticAnalysis;
PredicateAnalysis = predicateAnalysis;
ExceptionPathsAnalysis = exceptionPathsAnalysis;
CopyAnalysisResultOpt = copyAnalysisResultOpt;
PointsToAnalysisResultOpt = pointsToAnalysisResultOpt;
ValueContentAnalysisResultOpt = valueContentAnalysisResultOpt;
TryGetOrComputeAnalysisResult = tryGetOrComputeAnalysisResult;
InterproceduralAnalysisDataOpt = interproceduralAnalysisDataOpt;
InterproceduralAnalysisPredicateOpt = interproceduralAnalysisPredicateOpt;
}
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));
}
public override DisposeAnalysisContext ForkForInterproceduralAnalysis(
IMethodSymbol invokedMethod,
ControlFlowGraph invokedControlFlowGraph,
IOperation operation,
PointsToAnalysisResult pointsToAnalysisResultOpt,
CopyAnalysisResult copyAnalysisResultOpt,
InterproceduralDisposeAnalysisData interproceduralAnalysisData)
{
Debug.Assert(pointsToAnalysisResultOpt != null);
Debug.Assert(copyAnalysisResultOpt == null);
return(new DisposeAnalysisContext(ValueDomain, WellKnownTypeProvider, invokedControlFlowGraph, invokedMethod, InterproceduralAnalysisConfiguration, PessimisticAnalysis,
ExceptionPathsAnalysis, pointsToAnalysisResultOpt, GetOrComputeAnalysisResult, DisposeOwnershipTransferLikelyTypes, DisposeOwnershipTransferAtConstructor,
TrackInstanceFields, ControlFlowGraph, interproceduralAnalysisData, InterproceduralAnalysisPredicateOpt));
}
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));
}
public override ValueContentAnalysisContext ForkForInterproceduralAnalysis(
IMethodSymbol invokedMethod,
ControlFlowGraph invokedControlFlowGraph,
IOperation operation,
PointsToAnalysisResult pointsToAnalysisResultOpt,
CopyAnalysisResult copyAnalysisResultOpt,
ValueContentAnalysisResult valueContentAnalysisResultOpt,
InterproceduralValueContentAnalysisData interproceduralAnalysisData)
{
Debug.Assert(valueContentAnalysisResultOpt == null);
return(new ValueContentAnalysisContext(ValueDomain, WellKnownTypeProvider, invokedControlFlowGraph, invokedMethod, AnalyzerOptions, InterproceduralAnalysisConfiguration,
PessimisticAnalysis, copyAnalysisResultOpt, pointsToAnalysisResultOpt, TryGetOrComputeAnalysisResult, ControlFlowGraph, interproceduralAnalysisData,
InterproceduralAnalysisPredicateOpt));
}
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);
}
internal static CopyAnalysisContext Create(
AbstractValueDomain <CopyAbstractValue> valueDomain,
WellKnownTypeProvider wellKnownTypeProvider,
ControlFlowGraph controlFlowGraph,
ISymbol owningSymbol,
InterproceduralAnalysisConfiguration interproceduralAnalysisConfig,
bool pessimisticAnalysis,
bool exceptionPathsAnalysis,
PointsToAnalysisResult pointsToAnalysisResultOpt,
Func <CopyAnalysisContext, CopyAnalysisResult> tryGetOrComputeAnalysisResult,
InterproceduralAnalysisPredicate interproceduralAnalysisPredicateOpt)
{
return(new CopyAnalysisContext(valueDomain, wellKnownTypeProvider, controlFlowGraph, owningSymbol,
interproceduralAnalysisConfig, pessimisticAnalysis, exceptionPathsAnalysis, pointsToAnalysisResultOpt, tryGetOrComputeAnalysisResult,
parentControlFlowGraphOpt: null, interproceduralAnalysisDataOpt: null, interproceduralAnalysisPredicateOpt));
}
protected sealed override void ComputeHashCodeParts(ref RoslynHashCode hashCode)
{
hashCode.Add(ValueDomain.GetHashCode());
hashCode.Add(OwningSymbol.GetHashCode());
hashCode.Add(ControlFlowGraph.GetHashCode());
hashCode.Add(AnalyzerOptions.GetHashCode());
hashCode.Add(InterproceduralAnalysisConfiguration.GetHashCode());
hashCode.Add(PessimisticAnalysis.GetHashCode());
hashCode.Add(PredicateAnalysis.GetHashCode());
hashCode.Add(ExceptionPathsAnalysis.GetHashCode());
hashCode.Add(CopyAnalysisResult.GetHashCodeOrDefault());
hashCode.Add(PointsToAnalysisResult.GetHashCodeOrDefault());
hashCode.Add(ValueContentAnalysisResult.GetHashCodeOrDefault());
hashCode.Add(InterproceduralAnalysisData.GetHashCodeOrDefault());
hashCode.Add(InterproceduralAnalysisPredicate.GetHashCodeOrDefault());
ComputeHashCodePartsSpecific(ref hashCode);
}
protected sealed override void ComputeHashCodeParts(Action <int> addPart)
{
addPart(ValueDomain.GetHashCode());
addPart(OwningSymbol.GetHashCode());
addPart(ControlFlowGraph.GetHashCode());
addPart(AnalyzerOptions.GetHashCode());
addPart(InterproceduralAnalysisConfiguration.GetHashCode());
addPart(PessimisticAnalysis.GetHashCode());
addPart(PredicateAnalysis.GetHashCode());
addPart(ExceptionPathsAnalysis.GetHashCode());
addPart(CopyAnalysisResult.GetHashCodeOrDefault());
addPart(PointsToAnalysisResult.GetHashCodeOrDefault());
addPart(ValueContentAnalysisResult.GetHashCodeOrDefault());
addPart(InterproceduralAnalysisData.GetHashCodeOrDefault());
addPart(InterproceduralAnalysisPredicate.GetHashCodeOrDefault());
ComputeHashCodePartsSpecific(addPart);
}
private CopyAnalysisContext(
AbstractValueDomain <CopyAbstractValue> valueDomain,
WellKnownTypeProvider wellKnownTypeProvider,
ControlFlowGraph controlFlowGraph,
ISymbol owningSymbol,
InterproceduralAnalysisConfiguration interproceduralAnalysisConfig,
bool pessimisticAnalysis,
bool exceptionPathsAnalysis,
PointsToAnalysisResult pointsToAnalysisResultOpt,
Func <CopyAnalysisContext, CopyAnalysisResult> tryGetOrComputeAnalysisResult,
ControlFlowGraph parentControlFlowGraphOpt,
InterproceduralCopyAnalysisData interproceduralAnalysisDataOpt,
InterproceduralAnalysisPredicate interproceduralAnalysisPredicateOpt)
: base(valueDomain, wellKnownTypeProvider, controlFlowGraph, owningSymbol, interproceduralAnalysisConfig, pessimisticAnalysis,
predicateAnalysis: true, exceptionPathsAnalysis, copyAnalysisResultOpt: null, pointsToAnalysisResultOpt, valueContentAnalysisResultOpt: null,
tryGetOrComputeAnalysisResult, parentControlFlowGraphOpt, interproceduralAnalysisDataOpt, interproceduralAnalysisPredicateOpt)
{
}
private PropertySetAnalysisContext(
AbstractValueDomain <PropertySetAbstractValue> valueDomain,
WellKnownTypeProvider wellKnownTypeProvider,
ControlFlowGraph controlFlowGraph,
ISymbol owningSymbol,
AnalyzerOptions analyzerOptions,
InterproceduralAnalysisConfiguration interproceduralAnalysisConfig,
bool pessimisticAnalysis,
PointsToAnalysisResult pointsToAnalysisResult,
ValueContentAnalysisResult valueContentAnalysisResultOpt,
Func <PropertySetAnalysisContext, PropertySetAnalysisResult> tryGetOrComputeAnalysisResult,
ControlFlowGraph parentControlFlowGraphOpt,
InterproceduralPropertySetAnalysisData interproceduralAnalysisDataOpt,
ImmutableHashSet <string> typeToTrackMetadataNames,
ConstructorMapper constructorMapper,
PropertyMapperCollection propertyMappers,
HazardousUsageEvaluatorCollection hazardousUsageEvaluators,
ImmutableDictionary <(INamedTypeSymbol, bool), string> hazardousUsageTypesToNames)
