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; }