private static ImmutableDictionary <IParameterSymbol, SyntaxNode> GetOrComputeHazardousParameterUsages(
IBlockOperation topmostBlock,
Compilation compilation,
ISymbol owningSymbol,
AnalyzerOptions analyzerOptions,
SymbolNamesWithValueOption <Unit> nullCheckValidationMethods,
PointsToAnalysisKind pointsToAnalysisKind,
InterproceduralAnalysisConfiguration interproceduralAnalysisConfig,
bool performCopyAnalysis,
bool pessimisticAnalysis)
{
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,
pointsToAnalysisKind, interproceduralAnalysisConfig, interproceduralAnalysisPredicate: 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 void QualifiedSymbolNamesWithoutPrefixAreIgnored()
{
// Arrange
var compilation = GetCompilation(@"
using System;
public namespace MyNamespace
{
public class MyClass
{
public int MyField;
public int MyProperty { get; set; }
public event EventHandler<EventArgs> MyEvent;
public void MyMethod() {}
}
}");
var symbolNames = ImmutableArray.Create(
"MyNamespace.MySubNamespace",
"MyNamespace.MyClass",
"MyNamespace.MyClass.MyField",
"MyNamespace.MyClass.MyProperty",
"MyNamespace.MyClass.MyEvent",
"MyNamespace.MyClass.MyMethod()");
// Act
var options = SymbolNamesWithValueOption <Unit> .Create(symbolNames, compilation, null, null);
// Assert
Assert.Empty(options.GetTestAccessor().Names);
Assert.Empty(options.GetTestAccessor().Symbols);
Assert.Empty(options.GetTestAccessor().WildcardNamesBySymbolKind);
}
public void WildcardConstructionsWithPrefixAreCorrectlyClassified()
{
// Arrange
var compilation = GetCompilation();
var symbolNames = ImmutableArray.Create(
"N:MyNamespace*",
"T:MyNamespace.MyClass*",
"F:MyNamespace.MyClass.MyField*",
"P:MyNamespace.MyClass.MyProperty*",
"E:MyNamespace.MyClass.MyEvent*",
"M:MyNamespace.MyClass.MyMethod(*");
// Act
var options = SymbolNamesWithValueOption <Unit> .Create(symbolNames, compilation, null, null);
// Assert
Assert.Empty(options.GetTestAccessor().Names);
Assert.Empty(options.GetTestAccessor().Symbols);
Assert.Equal(symbolNames.Length, options.GetTestAccessor().WildcardNamesBySymbolKind.Count);
Assert.True(options.GetTestAccessor().WildcardNamesBySymbolKind[SymbolKind.Namespace].ContainsKey("MyNamespace"));
Assert.True(options.GetTestAccessor().WildcardNamesBySymbolKind[SymbolKind.NamedType].ContainsKey("MyNamespace.MyClass"));
Assert.True(options.GetTestAccessor().WildcardNamesBySymbolKind[SymbolKind.Field].ContainsKey("MyNamespace.MyClass.MyField"));
Assert.True(options.GetTestAccessor().WildcardNamesBySymbolKind[SymbolKind.Property].ContainsKey("MyNamespace.MyClass.MyProperty"));
Assert.True(options.GetTestAccessor().WildcardNamesBySymbolKind[SymbolKind.Event].ContainsKey("MyNamespace.MyClass.MyEvent"));
Assert.True(options.GetTestAccessor().WildcardNamesBySymbolKind[SymbolKind.Method].ContainsKey("MyNamespace.MyClass.MyMethod("));
}
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,
SymbolNamesWithValueOption <Unit> excludedSymbols)
{
return(new DisposeAnalysisContext(
valueDomain, wellKnownTypeProvider, controlFlowGraph,
owningSymbol, analyzerOptions, interproceduralAnalysisConfig, pessimisticAnalysis,
exceptionPathsAnalysis, pointsToAnalysisResultOpt, tryGetOrComputeAnalysisResult,
disposeOwnershipTransferLikelyTypes, disposeOwnershipTransferAtConstructor, disposeOwnershipTransferAtMethodCall,
trackInstanceFields, parentControlFlowGraphOpt: null, interproceduralAnalysisDataOpt: null,
interproceduralAnalysisPredicateOpt, excludedSymbols));
}
public void WildcardConstructionsWithoutPrefixAreCorrectlyClassified()
{
// Arrange
var compilation = GetCompilation();
var symbolNames = ImmutableArray.Create(
"MyNamespace*",
"MyNamespace.MyClass*",
"MyNamespace.MyClass.MyField*",
"MyNamespace.MyClass.MyProperty*",
"MyNamespace.MyClass.MyEvent*",
"MyNamespace.MyClass.MyMethod(*");
// Act
var options = SymbolNamesWithValueOption <Unit> .Create(symbolNames, compilation, null, static name => new SymbolNamesWithValueOption <Unit> .NameParts(name, Unit.Default));
// Assert
Assert.Empty(options.GetTestAccessor().Names);
Assert.Empty(options.GetTestAccessor().Symbols);
Assert.Single(options.GetTestAccessor().WildcardNamesBySymbolKind);
Assert.Equal(symbolNames.Length, options.GetTestAccessor().WildcardNamesBySymbolKind[SymbolNamesWithValueOption <Unit> .AllKinds].Count);
Assert.True(options.GetTestAccessor().WildcardNamesBySymbolKind[SymbolNamesWithValueOption <Unit> .AllKinds].ContainsKey("MyNamespace"));
Assert.True(options.GetTestAccessor().WildcardNamesBySymbolKind[SymbolNamesWithValueOption <Unit> .AllKinds].ContainsKey("MyNamespace.MyClass"));
Assert.True(options.GetTestAccessor().WildcardNamesBySymbolKind[SymbolNamesWithValueOption <Unit> .AllKinds].ContainsKey("MyNamespace.MyClass.MyField"));
Assert.True(options.GetTestAccessor().WildcardNamesBySymbolKind[SymbolNamesWithValueOption <Unit> .AllKinds].ContainsKey("MyNamespace.MyClass.MyProperty"));
Assert.True(options.GetTestAccessor().WildcardNamesBySymbolKind[SymbolNamesWithValueOption <Unit> .AllKinds].ContainsKey("MyNamespace.MyClass.MyEvent"));
Assert.True(options.GetTestAccessor().WildcardNamesBySymbolKind[SymbolNamesWithValueOption <Unit> .AllKinds].ContainsKey("MyNamespace.MyClass.MyMethod("));
}
public void QualifiedSymbolNamesWithPrefixAreProcessedAsSymbols()
{
// Arrange
var compilation = GetCompilation(@"
using System;
public namespace MyNamespace
{
public class MyClass
{
public int MyField;
public int MyProperty { get; set; }
public event EventHandler<EventArgs> MyEvent;
public void MyMethod() {}
}
}");
var symbolNames = ImmutableArray.Create(
"N:MyNamespace",
"T:MyNamespace.MyClass",
"F:MyNamespace.MyClass.MyField",
"P:MyNamespace.MyClass.MyProperty",
"E:MyNamespace.MyClass.MyEvent",
"M:MyNamespace.MyClass.MyMethod()");
// Act
var options = SymbolNamesWithValueOption <Unit> .Create(symbolNames, compilation, null, static name => new SymbolNamesWithValueOption <Unit> .NameParts(name, Unit.Default));
// Assert
Assert.Empty(options.GetTestAccessor().Names);
Assert.Equal(symbolNames.Length, options.GetTestAccessor().Symbols.Count);
Assert.Empty(options.GetTestAccessor().WildcardNamesBySymbolKind);
}
public void WhenNoSymbolNames_ReturnsEmpty()
{
// Arrange & act
var options = SymbolNamesWithValueOption <Unit> .Create(ImmutableArray <string> .Empty, GetCompilation(), null, null);
// Assert
Assert.Equal(SymbolNamesWithValueOption <Unit> .Empty, options);
}
public void WhenNoSymbolNames_ReturnsEmpty()
{
// Arrange & act
var options = SymbolNamesWithValueOption <Unit> .Create(ImmutableArray <string> .Empty, GetCompilation(), null, static name => new SymbolNamesWithValueOption <Unit> .NameParts(name, Unit.Default));
// Assert
Assert.Equal(SymbolNamesWithValueOption <Unit> .Empty, options);
}
private static void AnalyzeSymbol(SymbolAnalysisContext context, ImmutableArray <KeyValuePair <INamedTypeSymbol, INamedTypeSymbol> > interfacePairs,
SymbolNamesWithValueOption <INamedTypeSymbol> userMap)
{
Debug.Assert(interfacePairs.All(kvp => kvp.Key.TypeKind == TypeKind.Interface && kvp.Value.TypeKind == TypeKind.Interface));
var namedTypeSymbol = (INamedTypeSymbol)context.Symbol;
// FxCop compat: only fire on externally visible types by default.
if (!namedTypeSymbol.MatchesConfiguredVisibility(context.Options, Rule, context.CancellationToken))
{
return;
}
using var allInterfaces = PooledHashSet <INamedTypeSymbol> .GetInstance();
foreach (var @interface in namedTypeSymbol.AllInterfaces.Select(i => i.OriginalDefinition))
{
allInterfaces.Add(@interface);
}
// First we need to try to match all types from the user definition...
if (!userMap.IsEmpty)
{
foreach (var @interface in allInterfaces)
{
if ([email protected] &&
userMap.TryGetValue(@interface, out var genericInterface) &&
genericInterface?.IsGenericType == true)
{
ReportDiagnostic(@interface, genericInterface);
return;
}
}
}
// ...Then we can proceed with the hardcoded ones keeping the declaration order
for (int i = 0; i < interfacePairs.Length; i++)
{
var kvp = interfacePairs[i];
if (allInterfaces.Contains(kvp.Key) && !allInterfaces.Contains(kvp.Value))
{
ReportDiagnostic(kvp.Key, kvp.Value);
return;
}
}
return;
void ReportDiagnostic(INamedTypeSymbol @interface, INamedTypeSymbol genericInterface)
{
context.ReportDiagnostic(namedTypeSymbol.CreateDiagnostic(Rule, namedTypeSymbol.Name,
@interface.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat),
genericInterface.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat)));
}
}
public void UnqualifiedSymbolNamesAreProcessedAsNames()
{
// Arrange
// Note that there is no check for the existence of the member
var compilation = GetCompilation();
var symbolNames = ImmutableArray.Create("MyNamespace", "MyClass", "MyMethod()", "MyProperty", "MyEvent", "MyField");
// Act
var options = SymbolNamesWithValueOption <Unit> .Create(symbolNames, compilation, null, null);
// Assert
Assert.Equal(symbolNames.Length, options.GetTestAccessor().Names.Count);
Assert.Empty(options.GetTestAccessor().Symbols);
Assert.Empty(options.GetTestAccessor().WildcardNamesBySymbolKind);
}
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 void UnsupportedWildcardConstructionsAreIgnored()
{
// Arrange
var compilation = GetCompilation();
var symbolNames = ImmutableArray.Create(
"*", // only wildcard symbol
"*a", // wildcard symbol is not last
"a*a", // wildcard symbol is not last
"*a*"); // more than one wildcard symbol
// Act
var options = SymbolNamesWithValueOption <Unit> .Create(symbolNames, compilation, null, null);
// Assert
Assert.Empty(options.GetTestAccessor().Names);
Assert.Empty(options.GetTestAccessor().Symbols);
Assert.Empty(options.GetTestAccessor().WildcardNamesBySymbolKind);
}
public static ParameterValidationAnalysisContext Create(
AbstractValueDomain <ParameterValidationAbstractValue> valueDomain,
WellKnownTypeProvider wellKnownTypeProvider,
ControlFlowGraph controlFlowGraph,
ISymbol owningSymbol,
AnalyzerOptions analyzerOptions,
SymbolNamesWithValueOption <Unit> nullCheckValidationMethods,
InterproceduralAnalysisConfiguration interproceduralAnalysisConfig,
bool pessimisticAnalysis,
PointsToAnalysisResult?pointsToAnalysisResult,
Func <ParameterValidationAnalysisContext, ParameterValidationAnalysisResult?> tryGetOrComputeAnalysisResult)
{
return(new ParameterValidationAnalysisContext(
valueDomain, wellKnownTypeProvider, controlFlowGraph, owningSymbol,
analyzerOptions, nullCheckValidationMethods, interproceduralAnalysisConfig,
pessimisticAnalysis, pointsToAnalysisResult, tryGetOrComputeAnalysisResult, parentControlFlowGraph: null,
interproceduralAnalysisData: null, trackHazardousParameterUsages: false));
}
public void UnfoundQualifiedSymbolNamesWithPrefixAreExcluded()
{
// Arrange
var compilation = GetCompilation();
var symbolNames = ImmutableArray.Create(
"N:MyNamespace",
"T:MyNamespace.MyClass",
"F:MyNamespace.MyClass.MyField",
"P:MyNamespace.MyClass.MyProperty",
"E:MyNamespace.MyClass.MyEvent",
"M:MyNamespace.MyClass.MyMethod()");
// Act
var options = SymbolNamesWithValueOption <Unit> .Create(symbolNames, compilation, null, null);
// Assert
Assert.Empty(options.GetTestAccessor().Names);
Assert.Empty(options.GetTestAccessor().Symbols);
Assert.Empty(options.GetTestAccessor().WildcardNamesBySymbolKind);
}
public void SymbolNamePartsFuncIsCalledForEachSymbol()
{
// Arrange
var callCount = 0;
var symbolNames = ImmutableArray.Create("a", "b");
Func <string, SymbolNamesWithValueOption <Unit> .NameParts> func = symbolName =>
{
if (symbolNames.Contains(symbolName))
{
callCount++;
}
return(new SymbolNamesWithValueOption <Unit> .NameParts(symbolName));
};
// Act
SymbolNamesWithValueOption <Unit> .Create(symbolNames, GetCompilation(), null, func);
// Assert
Assert.Equal(2, callCount);
}
public WellKnownSymbolsInfo(
ImmutableArray <IMethodSymbol> linqChainMethods,
ImmutableArray <IMethodSymbol> noEnumerationMethods,
ImmutableArray <IMethodSymbol> enumeratedMethods,
ImmutableArray <IMethodSymbol> noEffectLinqChainMethods,
ImmutableArray <ITypeSymbol> additionalDeferredTypes,
ImmutableArray <IMethodSymbol> getEnumeratorMethods,
SymbolNamesWithValueOption <Unit> customizedEumerationMethods,
SymbolNamesWithValueOption <Unit> customizedLinqChainMethods,
bool assumeMethodEnumeratesParameters)
{
LinqChainMethods = linqChainMethods;
NoEnumerationMethods = noEnumerationMethods;
EnumeratedMethods = enumeratedMethods;
NoEffectLinqChainMethods = noEffectLinqChainMethods;
AdditionalDeferredTypes = additionalDeferredTypes;
GetEnumeratorMethods = getEnumeratorMethods;
CustomizedEumerationMethods = customizedEumerationMethods;
CustomizedLinqChainMethods = customizedLinqChainMethods;
AssumeMethodEnumeratesParameters = assumeMethodEnumeratesParameters;
}
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,
SymbolNamesWithValueOption <Unit> excludedSymbols,
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);
}
if (cfg == null)
{
Debug.Fail("Expected non-null CFG");
return(null);
}
var analysisContext = DisposeAnalysisContext.Create(
DisposeAbstractValueDomain.Default, wellKnownTypeProvider, cfg, owningSymbol, analyzerOptions, interproceduralAnalysisConfig, interproceduralAnalysisPredicate,
PessimisticAnalysis, exceptionPathsAnalysis, pointsToAnalysisResult, TryGetOrComputeResultForAnalysisContext,
disposeOwnershipTransferLikelyTypes, disposeOwnershipTransferAtConstructor, disposeOwnershipTransferAtMethodCall, trackInstanceFields, excludedSymbols);
return(TryGetOrComputeResultForAnalysisContext(analysisContext));
}
public void WildcardMatch(string patternName, string symbolName)
{
// Arrange
var compilation = GetCompilation(@"
public namespace MyCompany.MyProduct.MyFeature
{
public class MyOuterClass
{
public class MyInnerClass
{
public int MyField;
public MyInnerClass() {}
public MyInnerClass(int i) {}
public int MyProperty { get; set; }
public int this[]
{
get { return 42; }
set {}
}
public int this[string s]
{
get { return 42; }
set {}
}
public event EventHandler<EventArgs> MyEvent;
public void MyMethod() {}
public void MyMethod2(string s) {}
}
}
}");
var symbolNames = ImmutableArray.Create(patternName);
var symbol = FindSymbol(compilation, symbolName);
var options = SymbolNamesWithValueOption <Unit> .Create(symbolNames, compilation, null, null);
// Act
var isFound = options.Contains(symbol);
// Assert
Assert.True(isFound);
Assert.True(options.GetTestAccessor().WildcardMatchResult.ContainsKey(symbol));
private ParameterValidationAnalysisContext(
AbstractValueDomain <ParameterValidationAbstractValue> valueDomain,
WellKnownTypeProvider wellKnownTypeProvider,
ControlFlowGraph controlFlowGraph,
ISymbol owningSymbol,
AnalyzerOptions analyzerOptions,
SymbolNamesWithValueOption <Unit> nullCheckValidationMethods,
InterproceduralAnalysisConfiguration interproceduralAnalysisConfig,
bool pessimisticAnalysis,
PointsToAnalysisResult?pointsToAnalysisResult,
Func <ParameterValidationAnalysisContext, ParameterValidationAnalysisResult?> tryGetOrComputeAnalysisResult,
ControlFlowGraph?parentControlFlowGraph,
InterproceduralParameterValidationAnalysisData?interproceduralAnalysisData,
bool trackHazardousParameterUsages)
: base(valueDomain, wellKnownTypeProvider, controlFlowGraph, owningSymbol, analyzerOptions, interproceduralAnalysisConfig,
pessimisticAnalysis, predicateAnalysis: false, exceptionPathsAnalysis: false,
copyAnalysisResult: null, pointsToAnalysisResult, valueContentAnalysisResult: null,
tryGetOrComputeAnalysisResult, parentControlFlowGraph, interproceduralAnalysisData,
interproceduralAnalysisPredicate: null)
{
TrackHazardousParameterUsages = trackHazardousParameterUsages;
NullCheckValidationMethodNames = nullCheckValidationMethods;
}
public void ValueCanBeAssociatedWithAllSymbolNames()
{
// Arrange
var compilation = GetCompilation(@"
using System;
public namespace MyNamespace
{
public class MyClass {}
}");
var symbolNames = ImmutableArray.Create(
"MyClass->SomeValue1",
"T:MyNamespace.MyClass->SomeValue2",
"MyClass*->SomeValue3",
"T:MyClass*->SomeValue4");
var namedTypeSymbol = (INamedTypeSymbol)compilation.GetSymbolsWithName("MyClass").Single();
// Act
var options = SymbolNamesWithValueOption <string> .Create(symbolNames, compilation, null,
getSymbolNamePartsFunc : symbolName =>
{
var split = symbolName.Split(new[] { "->" }, StringSplitOptions.RemoveEmptyEntries);
return(new SymbolNamesWithValueOption <string> .NameParts(split[0], split[1]));
});
// Assert
Assert.Single(options.GetTestAccessor().Names);
Assert.Equal("SomeValue1", options.GetTestAccessor().Names["MyClass"]);
Assert.Single(options.GetTestAccessor().Symbols);
Assert.Equal("SomeValue2", options.GetTestAccessor().Symbols[namedTypeSymbol]);
Assert.Equal(2, options.GetTestAccessor().WildcardNamesBySymbolKind.Count);
Assert.Single(options.GetTestAccessor().WildcardNamesBySymbolKind[SymbolNamesWithValueOption <Unit> .AllKinds]);
Assert.Equal("SomeValue3", options.GetTestAccessor().WildcardNamesBySymbolKind[SymbolNamesWithValueOption <Unit> .AllKinds]["MyClass"]);
Assert.Single(options.GetTestAccessor().WildcardNamesBySymbolKind[SymbolKind.NamedType]);
Assert.Equal("SomeValue4", options.GetTestAccessor().WildcardNamesBySymbolKind[SymbolKind.NamedType]["MyClass"]);
}
private DisposeAnalysisContext(
AbstractValueDomain <DisposeAbstractValue> valueDomain,
WellKnownTypeProvider wellKnownTypeProvider,
ControlFlowGraph controlFlowGraph,
ISymbol owningSymbol,
AnalyzerOptions analyzerOptions,
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,
SymbolNamesWithValueOption <Unit> excludedSymbols)
: base(valueDomain, wellKnownTypeProvider, controlFlowGraph,
owningSymbol, analyzerOptions, interproceduralAnalysisConfig, pessimisticAnalysis,
predicateAnalysis: false,
exceptionPathsAnalysis,
copyAnalysisResultOpt: null,
pointsToAnalysisResultOpt,
valueContentAnalysisResultOpt: null,
tryGetOrComputeAnalysisResult,
parentControlFlowGraphOpt,
interproceduralAnalysisDataOpt,
interproceduralAnalysisPredicateOpt)
{
DisposeOwnershipTransferLikelyTypes = disposeOwnershipTransferLikelyTypes;
DisposeOwnershipTransferAtConstructor = disposeOwnershipTransferAtConstructor;
DisposeOwnershipTransferAtMethodCall = disposeOwnershipTransferAtMethodCall;
TrackInstanceFields = trackInstanceFields;
ExcludedSymbols = excludedSymbols;
}
internal TestAccessor(SymbolNamesWithValueOption <TValue> symbolNamesWithValueOption)
{
_symbolNamesWithValueOption = symbolNamesWithValueOption;
}
