internal int SuggestNonNullFieldsForConstructors(APC pc, Type t, IOutputResults output)
{
Contract.Ensures(Contract.Result <int>() >= 0);
var md = this.metadataDecoder;
var count = 0;
// No suggestions for structs
if (md.IsStruct(t))
{
return(count);
}
var result = GenerateObjectInvariantsForType(t);
if (result.Any())
{
foreach (var f in result)
{
var contract = string.Format("Contract.Invariant({0} != null);", md.Name(f.Item1));
var extraInfo = new ClousotSuggestion.ExtraSuggestionInfo()
{
SuggestedCode = contract, TypeDocumentId = md.DocumentationId(t)
};
var str = String.Format("Consider adding an object invariant {0} to the type {1}", contract, md.Name(t));
output.Suggestion(ClousotSuggestion.Kind.ObjectInvariant, ClousotSuggestion.Kind.ObjectInvariant.ToString(), pc, str, null, extraInfo);
count++;
}
}
this.typesWeSuggestedNonNullFields.Add(t);
return(count);
}
public static ClousotAnalysisResults EmitStats(this AnalysisStatistics @this, int swallowedTop, int swallowedBottom, int swallowedFalse, string assemblyName, IOutputResults output)
{
Contract.Requires(swallowedTop >= 0);
Contract.Requires(swallowedBottom >= 0);
Contract.Requires(swallowedFalse >= 0);
Contract.Requires(assemblyName != null);
Contract.Ensures(Contract.Result<ClousotAnalysisResults>() != null);
var result = new ClousotAnalysisResults();
if (@this.Total > 0)
{
var True = @this.True;
var Top = Math.Max(@this.Top - swallowedTop, 0);
var Bottom = Math.Max(@this.Bottom - swallowedBottom, 0);
var False = Math.Max(@this.False - swallowedFalse, 0);
var Total = True + Top + Bottom + False;
var masked = swallowedTop + swallowedFalse + swallowedBottom;
Contract.Assert(masked >= 0);
Contract.Assert(Top >= 0);
Contract.Assert(Bottom >= 0);
Contract.Assert(False >= 0);
var stats = String.Format("Checked {0} assertion{1}: {2}{3}{4}{5}{6}",
@this.Total.ToString(),
@this.Total > 1 ? "s" : "",
True > 0 ? True + " correct " : "",
Top > 0 ? Top + " unknown " : "",
Bottom > 0 ? Bottom + " unreached " : "",
False > 0 ? False + " false" : "",
masked > 0 ? "(" + masked + " masked)" : "");
output.FinalStatistic(assemblyName,stats);
double precision = Total != 0 ? True / (double)Total : 1.0;
output.Statistic("Validated: {0,6:P1}", precision);
// for scripts parsing msbuild output
output.WriteLine(stats);
// Update the result
result.Total = @this.Total;
result.True = True;
result.False = False;
result.Bottom = Bottom;
result.Top = Top;
result.Masked = masked;
}
else
{
output.FinalStatistic(assemblyName, "Checked 0 assertions.");
}
return result;
}
public double Validate(IOutputResults output, ContractInferenceManager inferenceManager, IFactQuery <HighLevelExpression, Variable> query)
{
Contract.Requires(output != null);
Contract.Requires(inferenceManager != null);
Contract.Requires(query != null);
throw new NotImplementedException();
}
public SimpleObjectInvariantDispatcher(
IMethodDriver <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly, Expression, Variable, LogOptions> mdriver,
IOutputResults output, bool allowDisjunctivePreconditions)
: base(mdriver, output, allowDisjunctivePreconditions)
{
Contract.Requires(mdriver != null);
Contract.Requires(output != null);
this.objectInvariants = new InferenceDB(exp => exp.Simplify(mdriver.MetaDataDecoder), exp => true);
}
protected SimpleDispatcherBase(IMethodDriver <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly, Expression, Variable, LogOptions> mdriver,
IOutputResults output, bool allowDisjunctivePreconditions)
{
Contract.Requires(mdriver != null);
Contract.Requires(output != null);
this.mdriver = mdriver;
this.output = output;
this.allowDisjunctivePreconditions = allowDisjunctivePreconditions;
}
public double Validate(IOutputResults output, ContractInferenceManager inferenceManager, IFactQuery <HighLevelExpression, Variable> query)
{
var result = 0.0; // is this used?
foreach (var obl in this.underlying)
{
obl.Validate(output, inferenceManager, query);
}
return(result);
}
public SimplePreconditionDispatcher(
IMethodDriver <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly, Expression, Variable, LogOptions> mdriver,
IOutputResults output)
{
Contract.Requires(mdriver != null);
this.mdriver = mdriver;
this.output = output;
this.preconditions = new InferredPreconditionDB();
}
/// <param name="extraFilter"> extraFilter(e) == true if e should not be suggested</param>
public SimplePreconditionDispatcher(
IMethodDriver <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly, Expression, Variable, LogOptions> mdriver,
IOutputResults output, bool allowDisjunctivePreconditions,
Func <BoxedExpression, bool> extraFilter = null)
: base(mdriver, output, allowDisjunctivePreconditions)
{
Contract.Requires(mdriver != null);
Contract.Requires(output != null);
this.preconditions = new InferenceDB(exp => exp.Simplify(mdriver.MetaDataDecoder), this.IsSuitableInRequires);
this.shouldFilter = extraFilter;
}
public override void EmitOutcome(ProofOutcome outcome, IOutputResults output)
{
// For some reason the EmitOutcome for the other assertions is done externally
if (this.IsConditionCheck)
{
this.PopulateWarningContextInternal(outcome);
var witness = this.GetWitness(outcome);
// new Witness(this.ID, WarningType.TestAlwaysEvaluatingToAConstant, ProofOutcome.Bottom, this.PC)
output.EmitOutcome(witness, MessageString(), this.condition.ToString());
}
}
public SimpleAssumeDispatcher(
IMethodDriver <Local, Parameter, Method, Field, Property, Event, Type, Attribute, Assembly, Expression, Variable, LogOptions> mdriver,
IOutputResults output, bool allowDisjunctivePreconditions, bool aggressiveInference)
: base(mdriver, output, allowDisjunctivePreconditions)
{
Contract.Requires(mdriver != null);
Contract.Requires(output != null);
this.entryAssumptions = new InferenceDB(exp => exp.Simplify(mdriver.MetaDataDecoder), _ => true);
this.calleeAssumptions = new Dictionary <Method, InferenceDB>();
this.calleeAssumptionsPCs = new Dictionary <Method, List <APC> >();
this.AggressiveInferece = aggressiveInference;
}
//This code should be moved in the inference helper
#if false
private bool CanAssumeLowerBoundPrecondition(IOutputResults output, BoxedExpression index)
{
bool hasVariables, hasAccessPath;
BoxedExpression indexInPreState = PreconditionSuggestion.ExpressionInPreState(index, this.Context, this.DecoderForMetaData, out hasVariables, out hasAccessPath, this.PC);
if (indexInPreState == null || !hasVariables)
{
return(false);
}
this.warningContext.Add(new WarningContext(WarningContext.ContextType.PreconditionCanDischarge));
BoxedExpression suggestedPre = BoxedExpression.Binary(
BinaryOperator.Cle, BoxedExpression.Const(0, this.DecoderForMetaData.System_Int32, this.DecoderForMetaData), indexInPreState);
return(InferenceHelper.TryAssumePreCondition(this.PC, suggestedPre, MethodDriver, SuggestedCodeFixes.WARNING_ARRAY_BOUND, "array lower bound", output));
}
public double Validate(IOutputResults output, ContractInferenceManager inferenceManager, IFactQuery <HighLevelExpression, Variable> query)
{
var options = output.LogOptions;
var total_obligations = 0;
var validated = 0;
var outcomes = new List <Pair <ProofObligation, ProofOutcome> >();
foreach (var obl in obligations)
{
if (obl.IsAlreadyValidated)
{
continue;
}
var outcome = obl.Validate(query, inferenceManager, output);
// Discard unreached implicit obligations in contracts
if (outcome == ProofOutcome.Bottom && obl.PC.InsideContract)
{
continue;
}
total_obligations++;
if (outcome == ProofOutcome.True)
{
validated++;
}
this.stats.Add(outcome);
outcomes.Add(new Pair <ProofObligation, ProofOutcome>(obl, outcome));
}
foreach (var pair in outcomes)
{
if (options.PrintOutcome(pair.Two))
{
pair.One.EmitOutcome(pair.Two, output);
}
}
return(total_obligations != 0 ? ((double)validated) / total_obligations : 1.0);
}
public override void EmitOutcome(ProofOutcome outcome, IOutputResults output)
{
Contract.Assume(output != null, "Should be a precondition");
var index = (int)outcome;
if (index < 0 || index >= fixedMessagesWrite.Length)
{
return;
}
if (this.isWrite)
{
output.EmitOutcome(GetWitness(outcome), AddHintsForTheUser(outcome, "{0}"), fixedMessagesWrite[index]);
}
else
{
output.EmitOutcome(GetWitness(outcome), AddHintsForTheUser(outcome, "{0}"), fixedMessagesRead[index]);
}
}
protected override ProofOutcome ValidateInternalSpecific(IFactQuery <BoxedExpression, Variable> query, ContractInferenceManager inferenceManager, IOutputResults output)
{
// We check the condition
var condition = this.Condition;
if (condition == null)
{
return(ProofOutcome.Top);
}
return(query.IsTrue(this.PC, condition));
}
protected override ProofOutcome ValidateInternalSpecific(IFactQuery <BoxedExpression, Variable> query, ContractInferenceManager inferenceManager, IOutputResults output)
{
object minValue;
if (!this.DecoderForMetaData.TryGetMinValueForType(this.TypeOp1, out minValue))
{
return(ProofOutcome.Top);
}
// first, we check that Op1 != MinValue
var condition1 = BoxedExpression.Binary(BinaryOperator.Cne_Un, this.Op1, BoxedExpression.Const(minValue, this.TypeOp1, this.DecoderForMetaData));
var resultOp1 = query.IsTrue(this.PC, condition1);
// second, we check Op2 != -1
var condition2 = BoxedExpression.Binary(BinaryOperator.Cne_Un, this.Op2, BoxedExpression.Const(-1, this.DecoderForMetaData.System_Int32, this.DecoderForMetaData));
var resultOp2 = query.IsTrue(this.PC, condition2);
// One of the two conditions is true, so it is ok!
if (resultOp1 == ProofOutcome.True || resultOp2 == ProofOutcome.True)
{
return(ProofOutcome.True);
}
// Both conditions are false, so division is definitely an overflow
if (resultOp1 == ProofOutcome.False && resultOp2 == ProofOutcome.False)
{
return(ProofOutcome.False);
}
return(ProofOutcome.Top);
}
protected override ProofOutcome ValidateInternalSpecific(IFactQuery <BoxedExpression, Variable> query, ContractInferenceManager inferenceManager, IOutputResults output)
{
return(query.IsNonZero(this.PC, this.denominator));
}
public override void EmitOutcome(ProofOutcome outcome, IOutputResults output)
{
output.EmitOutcome(GetWitness(outcome), this.AddHintsForTheUser(outcome, "{0}"), fixedMessages[(int)outcome]);
}
/// <summary> /// Try to validate the embodied proof obligation and return the outcome. /// The IFactQuery interface is for future logic based implementation of fact querying. /// The validation can make queries or use internal state to answer the outcome. /// </summary> protected abstract ProofOutcome ValidateInternal(IFactQuery <Expression, Variable> query, ContractInferenceManager inferenceManager, IOutputResults output);
public override void EmitOutcome(ProofOutcome outcome, IOutputResults output)
{
output.EmitOutcome(GetWitness(outcome), AddHintsForTheUser(outcome, "{0} of type {1}"), fixedMessages[(int)outcome], nameOfTypeOfArg);
}
public ProofOutcome Validate(IFactQuery <Expression, Variable> query, ContractInferenceManager inferenceManager, IOutputResults output)
{
ProofOutcome outcome;
if (query.IsUnreachable(this.PCForValidation))
{
outcome = ProofOutcome.Bottom;
}
else
{
outcome = ValidateInternal(query, inferenceManager, output);
if (outcome == ProofOutcome.Top || outcome == ProofOutcome.False)
{
if (this.Condition != null && this.TryInferPrecondition && !output.IsMasked(this.GetWitness(outcome)))
{
InferredConditions inferredPreConditions;
var inferencer = inferenceManager.PreCondition.Inference;
if (inferencer.TryInferConditions(this, inferenceManager.CodeFixesManager, out inferredPreConditions))
{
var context = inferredPreConditions.PushToContractManager(inferenceManager, inferencer.ShouldAddAssumeFalse, this, ref outcome, output.LogOptions);
this.HasASufficientAndNecessaryCondition = inferredPreConditions.HasASufficientCondition;
this.AdditionalInformationOnTheWarning.AddRange(context);
}
else if (inferencer.ShouldAddAssumeFalse)
{
inferenceManager.Assumptions.AddEntryAssumes(this, new BoxedExpression[] { BoxedExpression.ConstFalse });
}
}
}
}
this.Outcome = outcome;
return(outcome);
}
protected override ProofOutcome ValidateInternal(IFactQuery <BoxedExpression, Variable> query, ContractInferenceManager inferenceManager, IOutputResults output)
{
return(query.IsTrue(this.PC, this.condition));
}
public override void EmitOutcome(ProofOutcome outcome, IOutputResults output)
{
throw new NotImplementedException();
}
protected override ProofOutcome ValidateInternal(IFactQuery <Exp, Var> query, ContractInferenceManager inferenceManager, IOutputResults output)
{
Contract.Requires(query != null);
Contract.Requires(inferenceManager != null);
throw new NotImplementedException();
}
/// <summary> /// Prints out the outcome of the embodied proof obligation on the given output. /// Note, the code should not make decisions about when to print, as this is done /// by the context. /// </summary> public abstract void EmitOutcome(ProofOutcome outcome, IOutputResults output);
public override void EmitOutcome(ProofOutcome outcome, IOutputResults output)
{
output.EmitOutcome(GetWitness(outcome), AddHintsForTheUser(outcome, "{0}"), FixedMessages(outcome));
}
protected override ProofOutcome ValidateInternalSpecific(IFactQuery <BoxedExpression, Variable> query, ContractInferenceManager inferenceManager, IOutputResults output)
{
// If it is a variable or a constant, then there is nothing to do, and we return true.
if (this.exp.IsConstant || this.exp.IsVariable)
{
return(ProofOutcome.True);
}
return(base.ValidateInternalSpecific(query, inferenceManager, output));
}
public static ClousotAnalysisResults EmitStats(this AnalysisStatistics @this, int swallowedTop, int swallowedBottom, int swallowedFalse, string assemblyName, IOutputResults output)
{
Contract.Requires(swallowedTop >= 0);
Contract.Requires(swallowedBottom >= 0);
Contract.Requires(swallowedFalse >= 0);
Contract.Requires(assemblyName != null);
Contract.Ensures(Contract.Result <ClousotAnalysisResults>() != null);
var result = new ClousotAnalysisResults();
if (@this.Total > 0)
{
var True = @this.True;
var Top = Math.Max(@this.Top - swallowedTop, 0);
var Bottom = Math.Max(@this.Bottom - swallowedBottom, 0);
var False = Math.Max(@this.False - swallowedFalse, 0);
var Total = True + Top + Bottom + False;
var masked = swallowedTop + swallowedFalse + swallowedBottom;
Contract.Assert(masked >= 0);
Contract.Assert(Top >= 0);
Contract.Assert(Bottom >= 0);
Contract.Assert(False >= 0);
var stats = String.Format("Checked {0} assertion{1}: {2}{3}{4}{5}{6}",
@this.Total.ToString(),
@this.Total > 1 ? "s" : "",
True > 0 ? True + " correct " : "",
Top > 0 ? Top + " unknown " : "",
Bottom > 0 ? Bottom + " unreached " : "",
False > 0 ? False + " false" : "",
masked > 0 ? "(" + masked + " masked)" : "");
output.FinalStatistic(assemblyName, stats);
double precision = Total != 0 ? True / (double)Total : 1.0;
output.Statistic("Validated: {0,6:P1}", precision);
// for scripts parsing msbuild output
output.WriteLine(stats);
// Update the result
result.Total = @this.Total;
result.True = True;
result.False = False;
result.Bottom = Bottom;
result.Top = Top;
result.Masked = masked;
}
else
{
output.FinalStatistic(assemblyName, "Checked 0 assertions.");
}
return(result);
}
protected override ProofOutcome ValidateInternalSpecific(IFactQuery <BoxedExpression, Variable> query, ContractInferenceManager inferenceManager, IOutputResults output)
{
// First, we check if arg != MinValue
object value;
if (!this.DecoderForMetaData.TryGetMinValueForType(this.typeOfArg, out value))
{
return(ProofOutcome.Top);
}
var condition = this.Condition;
if (condition != null) // this.Condition may return null
{
var result = query.IsTrue(this.PC, condition);
if (result != ProofOutcome.Top)
{
return(result);
}
}
// We check a sufficient condition: if arg is >= 0, then it is not the negation of a negative "extreme"
var greaterThanZero = query.IsGreaterEqualToZero(this.PC, this.arg);
return((greaterThanZero == ProofOutcome.True || greaterThanZero == ProofOutcome.Bottom)
? greaterThanZero : ProofOutcome.Top);
}
/// <summary>
/// If we cannot validate the precision of the operands, we try to suggest an explicit cast
/// </summary>
protected override ProofOutcome ValidateInternalSpecific(IFactQuery <BoxedExpression, Variable> query, ContractInferenceManager inferenceManager, IOutputResults output)
{
var outcome = query.HaveSameFloatType(PC, this.left, this.right);
switch (outcome)
{
case ProofOutcome.Top:
{
ConcreteFloat leftType, rightType;
if (query.TryGetFloatType(this.PC, this.left, out leftType) && query.TryGetFloatType(this.PC, this.right, out rightType))
{
APC conditionPC;
if (!this.MethodDriver.AdditionalSyntacticInformation.VariableDefinitions.TryGetValue(this.var, out conditionPC))
{
conditionPC = this.PC;
}
if (inferenceManager.CodeFixesManager.TrySuggestFloatingPointComparisonFix(this, conditionPC, this.left, this.right, leftType, rightType))
{
// do something? Returning true seems a bad idea
}
}
return(outcome);
}
default:
{
return(outcome);
}
}
}
public override void ValidateImplicitAssertions(IOutputResults output)
{
throw new Exception("not implemented");
}
public override void EmitOutcome(ProofOutcome outcome, IOutputResults output)
{
output.EmitOutcome(GetWitness(outcome), fixedMessages[(int)outcome]);
}
