internal static PointsToAbstractValue Create(AbstractLocation location, bool mayBeNull)
{
Debug.Assert(!location.IsNull, "Use 'PointsToAbstractValue.NullLocation' singleton");
Debug.Assert(!location.IsNoLocation, "Use 'PointsToAbstractValue.NoLocation' singleton");
return(new PointsToAbstractValue(ImmutableHashSet.Create(location), mayBeNull ? NullAbstractValue.MaybeNull : NullAbstractValue.NotNull));
}
public PointsToAbstractValue GetOrCreateDefaultValue(AnalysisEntity analysisEntity)
{
if (!_defaultPointsToValueMapBuilder.TryGetValue(analysisEntity, out PointsToAbstractValue value))
{
if (analysisEntity.SymbolOpt?.Kind == SymbolKind.Local ||
analysisEntity.SymbolOpt is IParameterSymbol parameter && parameter.RefKind == RefKind.Out ||
analysisEntity.CaptureIdOpt != null)
{
return(PointsToAbstractValue.Undefined);
}
else if (!analysisEntity.Type.IsReferenceTypeOrNullableValueType())
{
return(PointsToAbstractValue.NoLocation);
}
else if (analysisEntity.HasUnknownInstanceLocation ||
PointsToAnalysisKind != PointsToAnalysisKind.Complete &&
analysisEntity.IsChildOrInstanceMemberNeedingCompletePointsToAnalysis())
{
return(PointsToAbstractValue.Unknown);
}
value = PointsToAbstractValue.Create(AbstractLocation.CreateAnalysisEntityDefaultLocation(analysisEntity), mayBeNull: true);
_trackedEntitiesBuilder.AddEntityAndPointsToValue(analysisEntity, value);
_defaultPointsToValueMapBuilder.Add(analysisEntity, value);
}
public PointsToAbstractValue GetOrCreateDefaultValue(AnalysisEntity analysisEntity)
{
if (!_defaultPointsToValueMapBuilder.TryGetValue(analysisEntity, out PointsToAbstractValue value))
{
if (analysisEntity.Symbol?.Kind == SymbolKind.Local ||
analysisEntity.Symbol is IParameterSymbol parameter && parameter.RefKind == RefKind.Out ||
analysisEntity.CaptureId != null)
{
return(PointsToAbstractValue.Undefined);
}
else if (analysisEntity.Type.IsNonNullableValueType())
{
return(PointsToAbstractValue.NoLocation);
}
else if (analysisEntity.HasUnknownInstanceLocation)
{
return(PointsToAbstractValue.Unknown);
}
value = PointsToAbstractValue.Create(AbstractLocation.CreateAnalysisEntityDefaultLocation(analysisEntity), mayBeNull: true);
// PERF: Do not track entity and its points to value for partial analysis for entities requiring complete analysis.
if (PointsToAnalysisKind == PointsToAnalysisKind.Complete ||
!analysisEntity.IsChildOrInstanceMemberNeedingCompletePointsToAnalysis())
{
_trackedEntitiesBuilder.AddEntityAndPointsToValue(analysisEntity, value);
_defaultPointsToValueMapBuilder.Add(analysisEntity, value);
}
}
protected override void SetAbstractValue(AbstractLocation location, ParameterValidationAbstractValue value)
{
if (IsTrackedLocation(location))
{
CurrentAnalysisData[location] = value;
}
}
public override PointsToAbstractValue VisitDelegateCreation(IDelegateCreationOperation operation, object argument)
{
var _ = base.VisitDelegateCreation(operation, argument);
AbstractLocation location = AbstractLocation.CreateAllocationLocation(operation, operation.Type);
return(new PointsToAbstractValue(location));
}
public void Configure(AbstractLocation location, List <Job> jobs)
{
this.location = location;
this.jobs = jobs;
Render();
}
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);
}
}
}
protected override void SetAbstractValue(AbstractLocation location, PropertySetAbstractValue value)
{
if (value != PropertySetAbstractValue.Unknown ||
this.CurrentAnalysisData.ContainsKey(location))
{
this.CurrentAnalysisData[location] = value;
}
}
protected override void SetValueForParameterOnEntry(IParameterSymbol parameter, AnalysisEntity analysisEntity)
{
// Create a dummy PointsTo value for each reference type parameter.
if (!parameter.Type.HasValueCopySemantics())
{
var value = new PointsToAbstractValue(AbstractLocation.CreateSymbolLocation(parameter));
SetAbstractValue(analysisEntity, value);
}
}
protected override void SetAbstractValue(AbstractLocation location, DisposeAbstractValue value)
{
Debug.Assert(location.IsNull || location.LocationTypeOpt.IsDisposable(WellKnownTypeProvider.IDisposable));
if (!location.IsNull)
{
CurrentAnalysisData[location] = value;
}
}
public LocationJobIcons Create(AbstractLocation location, List <Job> jobs)
{
locationJobIcons.gameObject.SetActive(false);
var result = container.InstantiatePrefabForComponent <LocationJobIcons>(locationJobIcons, location.transform);
result.Configure(location, jobs);
locationJobIcons.gameObject.SetActive(true);
return(result);
}
protected override void SetValueForParameterOnEntry(IParameterSymbol parameter, AnalysisEntity analysisEntity)
{
// Create a dummy PointsTo value for each reference type parameter.
if (ShouldBeTracked(parameter.Type))
{
var value = PointsToAbstractValue.Create(AbstractLocation.CreateSymbolLocation(parameter), mayBeNull: true);
SetAbstractValue(analysisEntity, value);
}
}
protected override void SetAbstractValue(AbstractLocation location, DisposeAbstractValue value)
{
if (!location.IsNull &&
location.LocationTypeOpt != null &&
!location.LocationTypeOpt.IsValueType &&
location.LocationTypeOpt.IsDisposable(IDisposableNamedType))
{
CurrentAnalysisData[location] = value;
}
}
public void AssignWorker(AbstractLocation location, Job job)
{
if (currentSelected == null)
{
throw new Exception("No worker selected.");
}
currentSelected.Worker.PlaceWorker(location, job);
Deselect();
}
protected override void SetAbstractValue(AbstractLocation location, DisposeAbstractValue value)
{
if (!location.IsNull &&
location.LocationType != null &&
(!location.LocationType.IsValueType || location.LocationType.IsRefLikeType) &&
IsDisposable(location.LocationType))
{
CurrentAnalysisData[location] = value;
}
}
public override PointsToAbstractValue VisitAnonymousObjectCreation(IAnonymousObjectCreationOperation operation, object argument)
{
AbstractLocation location = AbstractLocation.CreateAllocationLocation(operation, operation.Type);
var pointsToAbstractValue = new PointsToAbstractValue(location);
CacheAbstractValue(operation, pointsToAbstractValue);
var _ = VisitArray(operation.Initializers, argument);
return(pointsToAbstractValue);
}
protected override PointsToAbstractValue ComputeAnalysisValueForOutArgument(AnalysisEntity analysisEntity, IArgumentOperation operation, PointsToAbstractValue defaultValue)
{
if (analysisEntity.Type.HasValueCopySemantics())
{
return(PointsToAbstractValue.NoLocation);
}
var location = AbstractLocation.CreateAllocationLocation(operation, analysisEntity.Type);
return(new PointsToAbstractValue(location));
}
protected override PointsToAbstractValue ComputeAnalysisValueForOutArgument(AnalysisEntity analysisEntity, IArgumentOperation operation, PointsToAbstractValue defaultValue)
{
if (!ShouldBeTracked(analysisEntity.Type))
{
return(PointsToAbstractValue.NoLocation);
}
var location = AbstractLocation.CreateAllocationLocation(operation, analysisEntity.Type);
return(PointsToAbstractValue.Create(location, mayBeNull: true));
}
public override PointsToAbstractValue VisitAnonymousObjectCreation(IAnonymousObjectCreationOperation operation, object argument)
{
AbstractLocation location = AbstractLocation.CreateAllocationLocation(operation, operation.Type);
var pointsToAbstractValue = PointsToAbstractValue.Create(location, mayBeNull: false);
CacheAbstractValue(operation, pointsToAbstractValue);
var _ = base.VisitAnonymousObjectCreation(operation, argument);
return(pointsToAbstractValue);
}
private static PointsToAbstractValue VisitInvocationCommon(IOperation operation)
{
if (operation.Type.IsReferenceType)
{
AbstractLocation location = AbstractLocation.CreateAllocationLocation(operation, operation.Type);
return(new PointsToAbstractValue(location));
}
else
{
return(PointsToAbstractValue.NoLocation);
}
}
public override PointsToAbstractValue VisitArrayCreation(IArrayCreationOperation operation, object argument)
{
var pointsToAbstractValue = new PointsToAbstractValue(AbstractLocation.CreateAllocationLocation(operation, operation.Type));
CacheAbstractValue(operation, pointsToAbstractValue);
var unusedDimensionsValue = VisitArray(operation.DimensionSizes, argument);
var initializerValue = Visit(operation.Initializer, argument);
Debug.Assert(operation.Initializer == null || initializerValue == pointsToAbstractValue);
return(pointsToAbstractValue);
}
private static PointsToAbstractValue VisitInvocationCommon(IOperation operation)
{
if (!operation.Type.HasValueCopySemantics())
{
AbstractLocation location = AbstractLocation.CreateAllocationLocation(operation, operation.Type);
return(new PointsToAbstractValue(location));
}
else
{
return(PointsToAbstractValue.NoLocation);
}
}
private PointsToAbstractValue VisitTypeCreationWithArgumentsAndInitializer(IEnumerable <IOperation> arguments, IObjectOrCollectionInitializerOperation initializer, IOperation operation, object argument)
{
AbstractLocation location = AbstractLocation.CreateAllocationLocation(operation, operation.Type);
var pointsToAbstractValue = new PointsToAbstractValue(location);
CacheAbstractValue(operation, pointsToAbstractValue);
var unusedArray = VisitArray(arguments, argument);
var initializerValue = Visit(initializer, argument);
Debug.Assert(initializer == null || initializerValue == pointsToAbstractValue);
return(pointsToAbstractValue);
}
private PointsToAbstractValue VisitInvocationCommon(IOperation operation, IOperation instance)
{
if (ShouldBeTracked(operation.Type))
{
AbstractLocation location = AbstractLocation.CreateAllocationLocation(operation, operation.Type);
var pointsToAbstractValue = PointsToAbstractValue.Create(location, mayBeNull: true);
return(GetValueBasedOnInstanceOrReferenceValue(referenceOrInstance: instance, operation: operation, defaultValue: pointsToAbstractValue));
}
else
{
return(PointsToAbstractValue.NoLocation);
}
}
public override void Initialize(AnalysisContext context)
{
context.EnableConcurrentExecution();
context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
context.RegisterCompilationStartAction(compilationContext =>
{
if (!DisposeAnalysisHelper.TryGetOrCreate(compilationContext.Compilation, out DisposeAnalysisHelper disposeAnalysisHelper))
{
return;
}
compilationContext.RegisterOperationBlockAction(operationBlockContext =>
{
if (!(operationBlockContext.OwningSymbol is IMethodSymbol containingMethod) ||
!disposeAnalysisHelper.HasAnyDisposableCreationDescendant(operationBlockContext.OperationBlocks, containingMethod))
{
return;
}
DataFlowAnalysisResult <DisposeBlockAnalysisResult, DisposeAbstractValue> disposeAnalysisResult;
if (disposeAnalysisHelper.TryGetOrComputeResult(operationBlockContext.OperationBlocks, containingMethod, out disposeAnalysisResult))
{
BasicBlock exitBlock = disposeAnalysisResult.ControlFlowGraph.Exit;
ImmutableDictionary <AbstractLocation, DisposeAbstractValue> disposeDataAtExit = disposeAnalysisResult[exitBlock].OutputData;
foreach (var kvp in disposeDataAtExit)
{
AbstractLocation location = kvp.Key;
DisposeAbstractValue disposeValue = kvp.Value;
if (disposeValue.Kind == DisposeAbstractValueKind.NotDisposable ||
location.CreationOpt == null)
{
continue;
}
if (disposeValue.Kind == DisposeAbstractValueKind.NotDisposed ||
(disposeValue.DisposingOrEscapingOperations.Count > 0 &&
disposeValue.DisposingOrEscapingOperations.All(d => d.IsInsideCatchClause())))
{
// CA2000: In method '{0}', call System.IDisposable.Dispose on object created by '{1}' before all references to it are out of scope.
var arg1 = containingMethod.ToDisplayString(SymbolDisplayFormat.MinimallyQualifiedFormat);
var arg2 = location.CreationOpt.Syntax.ToString();
var diagnostic = location.CreationOpt.Syntax.CreateDiagnostic(Rule, arg1, arg2);
operationBlockContext.ReportDiagnostic(diagnostic);
}
}
}
});
});
}
public PointsToAbstractValue GetOrCreateDefaultValue(AnalysisEntity analysisEntity)
{
Debug.Assert(analysisEntity.Type.IsReferenceTypeOrNullableValueType());
Debug.Assert(_lazyDefaultPointsToValueMap == null);
if (!_defaultPointsToValueMapBuilder.TryGetValue(analysisEntity, out PointsToAbstractValue value))
{
value = analysisEntity.SymbolOpt?.Kind == SymbolKind.Local ?
PointsToAbstractValue.Undefined :
PointsToAbstractValue.Create(AbstractLocation.CreateAnalysisEntityDefaultLocation(analysisEntity), mayBeNull: true);
_defaultPointsToValueMapBuilder.Add(analysisEntity, value);
}
return(value);
}
public void PlaceWorker(AbstractLocation location, Job job)
{
IsReclaimable = true;
// Wait for IsSimulating to be true, and then prevent the ability to remove the bandit from the board.
isSimulatingSubscription = eventDirector.IsSimulating.First(isSimulating => isSimulating).Subscribe(isSimulating =>
{
IsReclaimable = false;
onNotReclaimable.Invoke();
});
this.location.Value = location;
location.PlaceWorker(this, job);
onPlacement.Invoke();
}
private bool IsTrackedLocation(AbstractLocation location)
{
return(CurrentAnalysisData.ContainsKey(location) ||
location.SymbolOpt is IParameterSymbol parameter &&
parameter.Type.IsReferenceType &&
Equals(parameter.ContainingSymbol, GetBottomOfStackOwningSymbol()));
ISymbol GetBottomOfStackOwningSymbol()
{
if (DataFlowAnalysisContext.InterproceduralAnalysisDataOpt == null)
{
return(OwningSymbol);
}
return(DataFlowAnalysisContext.InterproceduralAnalysisDataOpt.MethodsBeingAnalyzed
.Single(m => m.InterproceduralAnalysisDataOpt == null)
.OwningSymbol);
}
}
protected override PointsToAbstractValue ComputeAnalysisValueForReferenceOperation(IOperation operation, PointsToAbstractValue defaultValue)
{
if (!operation.Type.HasValueCopySemantics() &&
AnalysisEntityFactory.TryCreate(operation, out AnalysisEntity analysisEntity))
{
if (!HasAbstractValue(analysisEntity))
{
var value = new PointsToAbstractValue(AbstractLocation.CreateAllocationLocation(operation, operation.Type));
SetAbstractValue(analysisEntity, value);
return(value);
}
return(GetAbstractValue(analysisEntity));
}
else
{
Debug.Assert(!operation.Type.HasValueCopySemantics() || defaultValue == PointsToAbstractValue.NoLocation);
return(defaultValue);
}
}
public override PointsToAbstractValue VisitParameterReference(IParameterReferenceOperation operation, object argument)
{
// Create a dummy PointsTo value for each reference type parameter.
if (!operation.Type.HasValueCopySemantics())
{
var result = AnalysisEntityFactory.TryCreateForSymbolDeclaration(operation.Parameter, out AnalysisEntity analysisEntity);
Debug.Assert(result);
if (!HasAbstractValue(analysisEntity))
{
var value = new PointsToAbstractValue(AbstractLocation.CreateAllocationLocation(operation, operation.Parameter.Type));
SetAbstractValue(analysisEntity, value);
return(value);
}
return(GetAbstractValue(analysisEntity));
}
else
{
return(PointsToAbstractValue.NoLocation);
}
}
public void Post(AbstractLocation loc)
{
var location = loc;
return;
}
