// We have this static as we want to share some code with the AssertionCrawler
public string AddHintsForTheUser(ProofOutcome outcome, string format, Set <WarningContext> context)
{
Contract.Requires(format != null);
Contract.Ensures(Contract.Result <string>() != null);
return(outcome != ProofOutcome.True ? SuggestAddingPrecondition(format, context) : format);
}
protected override void PopulateWarningContextInternal(ProofOutcome outcome)
{
if (outcome == ProofOutcome.Top)
{
this.AdditionalInformationOnTheWarning.AddRange(WarningContextFetcher.InferContext(this.PC, this.index, this.Context, this.DecoderForMetaData.IsBoolean));
}
}
public SearchResult(int line, int col, BaseMethodDeclarationSyntax method, ProofOutcome outcome)
{
this.Line = line;
this.Column = col;
this.Method = method;
this.Outcome = outcome;
}
protected string AddHintsForTheUser(ProofOutcome outcome, string format)
{
Contract.Requires(format != null);
Contract.Ensures(Contract.Result <string>() != null);
return(AddHintsForTheUser(outcome, format, this.AdditionalInformationOnTheWarning));
}
static string CanonicalFormat(string methodName, WarningKind kind, ProofOutcome outcome, string message, int primaryILOffset, int methodILOffset, BaseLiningOptions baselineStrategy)
{
switch (baselineStrategy)
{
case BaseLiningOptions.ilBased:
return(String.Format("{0}:{1} PrimaryIL={2} MethodIL={3}", methodName, message, primaryILOffset, methodILOffset));
case BaseLiningOptions.typeBased:
return(String.Format("{0}:{1}", methodName, kind.ToString()));
case BaseLiningOptions.mixed:
default:
switch (kind)
{
case WarningKind.Invariant:
case WarningKind.Assert:
case WarningKind.Requires:
case WarningKind.Ensures:
return(String.Format("{0} PrimaryIL={1}", message, primaryILOffset));
default:
return(message);
}
}
}
public ProofOutcome AddObjectInvariants(ProofObligation obl, IEnumerable<BoxedExpression> objectInvariants, ProofOutcome originalOutcome)
{
Contract.Requires(obl != null);
Contract.Requires(objectInvariants != null);
return ProofOutcome.Top;
}
public void UpdateCounter(ProofOutcome outcome)
{
Contract.Assert(0 <= outcome);
Contract.Assume((int)outcome < counter.Length);
counter[(int)outcome]++;
}
public void UpdateCounter(ProofOutcome outcome)
{
Contract.Assert(0 <= outcome);
Contract.Assume((int)outcome < this.counter.Length);
this.counter[(int)outcome]++;
}
internal string GetMessageString(ProofOutcome outcome, string p)
{
// var msg = ProofObligationBase<BoxedExpression, Variable>.AddHintsForTheUser(outcome, p, this.GetWarningContext);
// Add some information from the provenance, i.e., a sequence of calls
var msg = ImproveMessageForInferredConditions(p, outcome);
// Get information from the entry state
var msgFromCodeFixes = GetMessageStringFromCodeFixesOrSufficientButNotNecessaryConditions();
// Get information from the output message
var msgViaOutParam = GetMessageFromWarningContexts();
// Now let's build the string
char c;
var sep = (msg != null && ((c = msg[msg.Length - 1]) != '}' && Char.IsPunctuation(c))) ? " " : ". ";
var tempString1 = !string.IsNullOrEmpty(msgFromCodeFixes)
? msg + sep + msgFromCodeFixes
: msg;
return(msgViaOutParam != null
? string.Format("{0}{1}{2}", tempString1, sep, msgViaOutParam)
: tempString1);
}
public override int SwallowedMessagesCount(ProofOutcome outcome)
{
if (ok)
{
return(base.SwallowedMessagesCount(outcome));
}
return(0);
}
public static ProofOutcome Join(this ProofOutcome o1, ProofOutcome o2)
{
if (o1 == o2) return o1;
if (o1 == ProofOutcome.Top || o2 == ProofOutcome.Bottom) return o1;
if (o2 == ProofOutcome.Top || o1 == ProofOutcome.Bottom) return o2;
// different and none is top or bottom, so join of true and false
return ProofOutcome.Top;
}
public static ProofOutcome Join (this ProofOutcome a, ProofOutcome b)
{
if (a == b || a == ProofOutcome.Top || b == ProofOutcome.Bottom)
return a;
if (b == ProofOutcome.Top || a == ProofOutcome.Bottom)
return b;
return ProofOutcome.Top;
}
public ProofOutcome Isinst(E orig, TypeNode type, V dest, E obj, bool polarity)
{
if (!polarity)
{
return(this.analysis.IsNull(this.pc, dest));
}
ProofOutcome outcome = this.analysis.IsNonNull(this.pc, dest);
return(outcome != ProofOutcome.True ? outcome : this.Recurse(true, obj));
}
public Witness(uint?sourceProofObligation, WarningType warning, ProofOutcome outcome, APC PC, Set <WarningContext> context, ClousotSuggestion.Kind?type = null)
{
Contract.Requires(context != null);
this.SourceProofObligationID = sourceProofObligation;
this.PC = PC;
this.Outcome = outcome;
this.Warning = warning;
this.Context = context;
this.TypeOfSuggestionTurnedIntoWarning = type;
}
public static ProofOutcome Meet (this ProofOutcome a, ProofOutcome b)
{
if (a == b)
return a;
if (a == ProofOutcome.Top || b == ProofOutcome.Bottom)
return b;
if (b == ProofOutcome.Top || a == ProofOutcome.Bottom)
return a;
return ProofOutcome.Bottom;
}
protected override void PopulateWarningContextInternal(ProofOutcome outcome)
{
if (this.MethodMayContainUnsafeCode.HasValue && (this.MethodMayContainUnsafeCode.Value == true))
{
this.AdditionalInformationOnTheWarning.Add(new WarningContext(WarningContext.ContextType.InsideUnsafeMethod));
}
if (this.MayBeAStringNullComparisonInASwitchStatement.HasValue && this.MayBeAStringNullComparisonInASwitchStatement.Value)
{
this.AdditionalInformationOnTheWarning.Add(new WarningContext(WarningContext.ContextType.StringComparedAgainstNullInSwitchStatement));
}
}
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 bool CheckPreconditionAndCanAddRequires(BoxedExpression condition, ProofOutcome pre, out ProofOutcome outcome)
{
Contract.Requires(condition != null);
if (!this.mdriver.CanAddRequires())
{
outcome = pre;
return(false);
}
return(base.CheckPrecondition(condition, pre, out outcome));
}
public override ProofOutcome IsNonNull(APC pc, BoxedExpression expr)
{
Variable v;
if (TryVariable(expr, out v))
{
ProofOutcome proofOutcome = this.FactBase.IsNonNull(pc, v);
if (proofOutcome != ProofOutcome.Top)
{
return(proofOutcome);
}
}
if (expr.IsConstant)
{
object constant = expr.Constant;
if (constant == null)
{
return(ProofOutcome.False);
}
if (constant is string)
{
return(ProofOutcome.True);
}
var convertible = constant as IConvertible;
if (convertible != null)
{
try {
return((convertible.ToInt64(null) == 0) ? ProofOutcome.False : ProofOutcome.True);
} catch {
return(ProofOutcome.Top);
}
}
}
BinaryOperator op;
BoxedExpression left;
BoxedExpression right;
if (expr.IsBinaryExpression(out op, out left, out right))
{
if ((op == BinaryOperator.Ceq || op == BinaryOperator.Cobjeq) && IsNull(pc, right) == ProofOutcome.True)
{
return(IsNull(pc, left));
}
if (op == BinaryOperator.Cne_Un && IsNull(pc, right) == ProofOutcome.True)
{
return(IsNonNull(pc, left));
}
}
return(ProofOutcome.Top);
}
public void Add(ProofObligation obl, BoxedExpression exp, ProofOutcome outcome)
{
Contract.Requires(obl != null);
Contract.Requires(exp != null);
this.inferred.Add(new Tuple <BoxedExpression, string, ProofOutcome, List <ProofObligation> >(exp, exp.ToString(), outcome, new List <ProofObligation>()
{
obl
}));
// we added a new condition, let us discare the previous ones
this.preconditions = null;
}
private void EmitOutcomeToBaseLine(WarningKind kind, ProofOutcome outcome, APC pc, string message)
{
int primaryILOffset, methodILOffset;
GetILOffsets(pc, this.currentMethod, out primaryILOffset, out methodILOffset);
xmlWriter.WriteStartElement("Outcome");
xmlWriter.WriteAttributeString("Kind", kind.ToString());
xmlWriter.WriteAttributeString("Outcome", outcome.ToString());
xmlWriter.WriteAttributeString("Message", message);
xmlWriter.WriteAttributeString("PrimaryILOffset", primaryILOffset.ToString("x"));
xmlWriter.WriteAttributeString("MethodILOffset", methodILOffset.ToString("x"));
xmlWriter.WriteEndElement();
}
public override Witness GetWitness(ProofOutcome outcome)
{
var warningType = this.IsConditionCheck? WarningType.TestAlwaysEvaluatingToAConstant: TagToWarningType(this.Tag);
var witness = new Witness(this.ID, warningType, outcome, this.PC, this.AdditionalInformationOnTheWarning);
if (this.ShowInferenceTrace)
{
WalkProvenance(this, 0, witness);
}
return(witness);
}
public static ProofOutcome Join(this ProofOutcome a, ProofOutcome b)
{
if (a == b || a == ProofOutcome.Top || b == ProofOutcome.Bottom)
{
return(a);
}
if (b == ProofOutcome.Top || a == ProofOutcome.Bottom)
{
return(b);
}
return(ProofOutcome.Top);
}
public bool TryLookUp(ProofObligation obligation, BoxedExpression expression, out ProofOutcome outcome)
{
string s = ((object)expression).ToString ();
foreach (Tuple<BoxedExpression, string, ProofOutcome, List<ProofObligation>> item in this.inferred) {
if (item.Item2 == s) {
item.Item4.Add (obligation);
outcome = item.Item4;
return true;
}
}
outcome = ProofOutcome.Top;
return false;
}
public ProofOutcome IsTrueImply(APC pc, LispList <BoxedExpression> positiveAssumptions, LispList <BoxedExpression> negativeAssumptions, BoxedExpression goal)
{
ProofOutcome outcome = IsTrue(pc, goal);
switch (outcome)
{
case ProofOutcome.True:
case ProofOutcome.Bottom:
return(outcome);
default:
return(ProofOutcome.Top);
}
}
public virtual ProofOutcome IsNonNull(APC pc, BoxedExpression expr)
{
Variable v;
if (TryVariable(expr, out v))
{
ProofOutcome outcome = this.FactBase.IsNonNull(pc, v);
if (outcome != ProofOutcome.Top)
{
return(outcome);
}
}
return(ProofOutcome.Top);
}
protected static ClousotRegression.ProofOutcome Translate(ProofOutcome outcome)
{
switch (outcome)
{
case ProofOutcome.Bottom: return(Microsoft.Research.ClousotRegression.ProofOutcome.Bottom);
case ProofOutcome.False: return(Microsoft.Research.ClousotRegression.ProofOutcome.False);
case ProofOutcome.Top: return(Microsoft.Research.ClousotRegression.ProofOutcome.Top);
case ProofOutcome.True: return(Microsoft.Research.ClousotRegression.ProofOutcome.True);
default: throw new NotImplementedException();
}
}
protected bool CheckPrecondition(BoxedExpression simplified, ProofOutcome originalOutcome, out ProofOutcome outcome)
{
Contract.Requires(simplified != null);
outcome = originalOutcome;
if (this.output.LogOptions.PropagateInferredRequires(mdriver.MetaDataDecoder.IsPropertyGetterOrSetter(mdriver.CurrentMethod)))
{
if (this.output.LogOptions.PropagatedRequiresAreSufficient)
{
outcome = ProofOutcome.True;
}
}
return(true);
}
public ProofOutcome AddPreconditionOrAssume(ProofObligation obl, IEnumerable<BoxedExpression> conditions, ProofOutcome outcome = ProofOutcome.Top)
{
Contract.Requires(conditions != null);
Contract.Requires(obl != null);
if (this.CanAddPreconditions)
{
Contract.Assume(this.PreCondition.Dispatch != null);
return this.PreCondition.Dispatch.AddPreconditions(obl, conditions, outcome);
}
else
{
this.Assumptions.AddEntryAssumes(obl, conditions);
this.OverriddenMethodPreconditionDispatcher.AddPotentialPreconditions(obl, conditions);
return outcome;
}
}
public bool TryLookUp(BoxedExpression exp, out ProofOutcome outcome)
{
Contract.Requires(exp != null);
var expStr = exp.ToString();
foreach (var triple in this.inferred)
{
if (triple.Item2 == expStr)
{
outcome = triple.Item3;
return(true);
}
}
outcome = ProofOutcome.Top;
return(false);
}
public static ProofOutcome Join(this ProofOutcome o1, ProofOutcome o2)
{
if (o1 == o2)
{
return(o1);
}
if (o1 == ProofOutcome.Top || o2 == ProofOutcome.Bottom)
{
return(o1);
}
if (o2 == ProofOutcome.Top || o1 == ProofOutcome.Bottom)
{
return(o2);
}
// different and none is top or bottom, so join of true and false
return(ProofOutcome.Top);
}
public static ProofOutcome Negate(this ProofOutcome o)
{
switch (o)
{
case ProofOutcome.Top:
case ProofOutcome.Bottom:
return(o);
case ProofOutcome.True:
return(ProofOutcome.False);
case ProofOutcome.False:
return(ProofOutcome.True);
default:
return(ProofOutcome.Top);
}
}
static string Canonicalize(String methodName, XElement outcomeElement, BaseLiningOptions baselineStrategy)
{
var outcomeKind = (string)outcomeElement.Attribute("Outcome");
if (outcomeKind != null)
{
ProofOutcome outcome = (ProofOutcome)Enum.Parse(typeof(ProofOutcome), (string)outcomeElement.Attribute("Outcome"), true);
WarningKind kind = (WarningKind)Enum.Parse(typeof(WarningKind), (string)outcomeElement.Attribute("Kind"), true);
string message = (string)outcomeElement.Attribute("Message");
int primaryILOffset = Int32.Parse((string)outcomeElement.Attribute("PrimaryILOffset"), System.Globalization.NumberStyles.HexNumber);
int methodILOffset = Int32.Parse((string)outcomeElement.Attribute("MethodILOffset"), System.Globalization.NumberStyles.HexNumber);
return(CanonicalFormat(methodName, kind, outcome, message, primaryILOffset, methodILOffset, baselineStrategy));
}
else
{
return((string)outcomeElement.Attribute("Message"));
}
}
protected ProofOutcome GenericAddPreconditions(ProofObligation obl, IEnumerable <BoxedExpression> preconditions, ProofOutcome originalOutcome,
InferenceDB preconditionDB, PreconditionChecker checkPrecondition)
{
var outcome = originalOutcome;
foreach (var pre in preconditions)
{
if (pre == null)
{
continue;
}
// 1. Simplify the expression
var simplified = SimplifyAndFix(obl.PCForValidation, pre);
if (simplified == null)
{
continue;
}
if (DisjunctivePreconditionsAreDisallowed(simplified))
{
continue;
}
// 2. Have we already seen this precondition?
if (preconditionDB.TryLookUp(obl, simplified, out outcome))
{
continue;
}
else
{
outcome = originalOutcome;
}
// 3. See if it is valid
if (checkPrecondition(simplified, outcome, out outcome))
{
preconditionDB.Add(obl, simplified, outcome);
}
}
return(outcome);
}
public bool TryLookUp(ProofObligation obl, BoxedExpression exp, out ProofOutcome outcome)
{
Contract.Requires(obl != null);
Contract.Requires(exp != null);
var expStr = exp.ToString();
foreach (var quad in this.inferred)
{
if (quad.Item2 == expStr)
{
quad.Item4.Add(obl);
outcome = quad.Item3;
return true;
}
}
outcome = ProofOutcome.Top;
return false;
}
protected string FixedMessages(ProofOutcome outcome)
{
switch (outcome)
{
case ProofOutcome.Bottom:
return("This arithmetic operation is unreached");
case ProofOutcome.False:
return(What + " in the arithmetic operation");
case ProofOutcome.Top:
return("Possible " + what + " in the arithmetic operation");
case ProofOutcome.True:
return("No " + what);
default:
return("unknown outcome");
}
}
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]);
}
}
public bool TryLookUp(ProofObligation obl, BoxedExpression exp, out ProofOutcome outcome)
{
Contract.Requires(obl != null);
Contract.Requires(exp != null);
var expStr = exp.ToString();
foreach (var quad in this.inferred)
{
if (quad.Item2 == expStr)
{
quad.Item4.Add(obl);
outcome = quad.Item3;
return(true);
}
}
outcome = ProofOutcome.Top;
return(false);
}
public bool PrintOutcome(ProofOutcome outcome)
{
switch (outcome) {
case ProofOutcome.True:
return this.show.Contains(ShowOptions.validations);
case ProofOutcome.Bottom:
return
this.show.Contains(ShowOptions.validations) ||
this.show.Contains(ShowOptions.unreached);
case ProofOutcome.False:
case ProofOutcome.Top:
return this.show.Contains(ShowOptions.errors);
default:
return true;
}
}
private double GetScoreForOutcome(ProofOutcome proofOutcome)
{
switch (proofOutcome)
{
#region All the cases
case ProofOutcome.Bottom:
return this.ScoreBottom;
case ProofOutcome.False:
return this.ScoreFalse;
case ProofOutcome.Top:
return this.ScoreTop;
case ProofOutcome.True:
return this.ScoreTrue;
default:
// should be unreachable
#if DEBUG
Contract.Assert(false);
#endif
return 0.0;
#endregion
}
}
public void Add(ProofObligation obl, BoxedExpression exp, ProofOutcome outcome)
{
Contract.Requires(obl != null);
Contract.Requires(exp != null);
this.inferred.Add(new Tuple<BoxedExpression, string, ProofOutcome, List<ProofObligation>>(exp, exp.ToString(), outcome, new List<ProofObligation>() { obl }));
// we added a new condition, let us discare the previous ones
this.preconditions = null;
}
public int GetCounter(ProofOutcome outcome)
{
Contract.Assert(0 <= outcome);
Contract.Assume((int)outcome < counter.Length);
return counter[(int)outcome];
}
public int GetCounter(ProofOutcome outcome)
{
return this.counter[(int) outcome];
}
public void UpdateCounter(ProofOutcome outcome)
{
++this.counter[(int) outcome];
}
public ProofOutcome AddObjectInvariants(ProofObligation obl, IEnumerable<BoxedExpression> objectInvariants, ProofOutcome originalOutcome)
{
generated += objectInvariants.Count();
return this.inner.AddObjectInvariants(obl, objectInvariants, originalOutcome);
}
public void Add(ProofOutcome color, uint howMany = 1)
{
Contract.Requires(howMany > 0);
switch (color)
{
case ProofOutcome.Bottom:
this.Bottom += howMany;
break;
case ProofOutcome.Top:
this.Top += howMany;
break;
case ProofOutcome.True:
this.True += howMany;
break;
case ProofOutcome.False:
this.False += howMany;
break;
}
this.Total += howMany;
}
public ProofOutcome AddPreconditions(ProofObligation obl, IEnumerable<BoxedExpression> preconditions, ProofOutcome originalOutcome)
{
return originalOutcome;
}
public void Add(ProofObligation obligation, BoxedExpression expression, ProofOutcome outcome)
{
this.inferred.Add (new Tuple<BoxedExpression, string, ProofOutcome, List<ProofObligation>> (expression, ((object)expression).ToString (), outcome, new List<ProofObligation> (){obligation}));
this.preconditions = (Dictionary<BoxedExpression, List<ProofObligation>>)null;
}
