public override PropertySetAbstractValue Merge(PropertySetAbstractValue value1, PropertySetAbstractValue value2)
{
// The PropertySetAbstractValue indexer allows accessing beyond KnownValuesCount (returns Unknown),
// so looping through the max of the two KnownValuesCount.
int maxKnownCount = Math.Max(value1.KnownValuesCount, value2.KnownValuesCount);
using ArrayBuilder <PropertySetAbstractValueKind> builder = ArrayBuilder <PropertySetAbstractValueKind> .GetInstance(maxKnownCount);
for (int i = 0; i < maxKnownCount; i++)
{
builder.Add(MergeKind(value1[i], value2[i]));
}
return(PropertySetAbstractValue.GetInstance(builder));
}
public override PropertySetAbstractValue VisitObjectCreation(IObjectCreationOperation operation, object?argument)
{
PropertySetAbstractValue abstractValue = base.VisitObjectCreation(operation, argument);
if (this.TrackedTypeSymbols.Any(s => operation.Type.GetBaseTypesAndThis().Contains(s)))
{
ConstructorMapper constructorMapper = this.DataFlowAnalysisContext.ConstructorMapper;
if (!constructorMapper.PropertyAbstractValues.IsEmpty)
{
abstractValue = PropertySetAbstractValue.GetInstance(constructorMapper.PropertyAbstractValues);
}
else if (constructorMapper.MapFromPointsToAbstractValue != null)
{
using ArrayBuilder <PointsToAbstractValue> builder = ArrayBuilder <PointsToAbstractValue> .GetInstance();
foreach (IArgumentOperation argumentOperation in operation.Arguments)
{
builder.Add(this.GetPointsToAbstractValue(argumentOperation));
}
abstractValue = constructorMapper.MapFromPointsToAbstractValue(operation.Constructor, builder);
}
else if (constructorMapper.MapFromValueContentAbstractValue != null)
{
Debug.Assert(this.DataFlowAnalysisContext.ValueContentAnalysisResult != null);
using ArrayBuilder <PointsToAbstractValue> pointsToBuilder = ArrayBuilder <PointsToAbstractValue> .GetInstance();
using ArrayBuilder <ValueContentAbstractValue> valueContentBuilder = ArrayBuilder <ValueContentAbstractValue> .GetInstance();
foreach (IArgumentOperation argumentOperation in operation.Arguments)
{
pointsToBuilder.Add(this.GetPointsToAbstractValue(argumentOperation));
valueContentBuilder.Add(this.GetValueContentAbstractValue(argumentOperation.Value));
}
abstractValue = constructorMapper.MapFromValueContentAbstractValue(operation.Constructor, valueContentBuilder, pointsToBuilder);
}
else
{
Debug.Fail("Unhandled ConstructorMapper");
return(abstractValue);
}
PointsToAbstractValue pointsToAbstractValue = this.GetPointsToAbstractValue(operation);
this.SetAbstractValue(pointsToAbstractValue, abstractValue);
}
else
{
if (TryFindNonTrackedTypeHazardousUsageEvaluator(
operation.Constructor,
operation.Arguments,
out HazardousUsageEvaluator? hazardousUsageEvaluator,
out IOperation? propertySetInstance))
{
this.EvaluatePotentialHazardousUsage(
operation.Syntax,
operation.Constructor,
propertySetInstance,
(PropertySetAbstractValue abstractValue) => hazardousUsageEvaluator.InvocationEvaluator !(
operation.Constructor,
abstractValue));
}
}
return(abstractValue);
}