public override bool IsMasked(Witness witness)
{
if (this.options.MaskedWarnings && this.methodmask != null)
{
var encode = this.suppressWarningsManager.ComputeWarningMask(witness);
// Is it masked?
if (this.methodmask.IsMasked(encode))
{
return(true);
}
// Is it a masked precondition ?
Method m; Type t;
if (witness.PC.InsideRequiresAtCall &&
witness.PC.TryGetContainingMethod(out m))
{
var encodeRequiresAtCall = this.suppressWarningsManager.ComputeWarningMaskAtCallee(witness);
var methodNameContainingRequires = this.mdDecoder.FullName(m);
if (MaskedWarnings.IsMaskedInTheOriginalMethod(m, this.mdDecoder, encodeRequiresAtCall))
{
return(true);
}
}
// Is it a masked postcondition ?
else if (witness.PC.InsideEnsuresInMethod)
{
var encodeEnsures = this.suppressWarningsManager.ComputeWarningMaskForEnsures(witness);
if (encodeEnsures != null)
{
if (this.methodmask.IsMasked(encodeEnsures))
{
return(true);
}
}
if (witness.PC.TryGetContainingMethod(out m))
{
var encodeEnsuresAtCall = this.suppressWarningsManager.ComputeWarningMaskAtBaseMethod(witness);
var methodNameContainingEnsures = this.mdDecoder.FullName(m);
if (MaskedWarnings.IsMaskedInTheOriginalMethod(m, this.mdDecoder, encodeEnsuresAtCall))
{
return(true);
}
}
}
// Is it a masked invariant?
else if (witness.PC.InsideInvariantInMethod &&
witness.PC.TryGetContainingType(out t))
{
var encodeInvariant = this.suppressWarningsManager.ComputeWarningMaskForInvariant(witness);
var typeNameContainingInvariant = this.mdDecoder.FullName(t);
if (MaskedWarnings.IsMaskedInType(t, this.mdDecoder, encodeInvariant))
{
return(true);
}
}
}
return(false);
}
private bool EmitOutcome_Internal(bool emitRelatedToo, Witness witness, string format, params object[] args)
{
Contract.Requires(witness != null);
Contract.Requires(format != null);
string encode = null;
string encodeRequiresAtCall = null;
string methodNameContainingRequires = null;
string encodeEnsures = null;
string encodeEnsuresAtCall = null;
string methodNameContainingEnsures = null;
string encodeInvariant = null;
string typeNameContainingInvariant = null;
if (witness.Outcome != ProofOutcome.True && this.options.MaskedWarnings &&
this.methodmask != null // We add this check as we are not enforcing the typestate
)
{
encode = this.suppressWarningsManager.ComputeWarningMask(witness);
// Is it masked?
if (this.methodmask.IsMasked(encode))
{
this.methodmask.SignalMasked(encode);
this.swallowedCount.UpdateCounter(witness.Outcome);
return(false);
}
// Is it a masked precondition ?
Method m; Type t;
if (witness.PC.InsideRequiresAtCall && witness.PC.TryGetContainingMethod(out m))
{
encodeRequiresAtCall = this.suppressWarningsManager.ComputeWarningMaskAtCallee(witness);
methodNameContainingRequires = this.mdDecoder.FullName(m);
if (MaskedWarnings.IsMaskedInTheOriginalMethod(m, this.mdDecoder, encodeRequiresAtCall))
{
this.methodmask.SignalMasked(encodeRequiresAtCall);
this.swallowedCount.UpdateCounter(witness.Outcome);
return(false);
}
}
// Is it a masked postcondition ?
else if (witness.PC.InsideEnsuresInMethod)
{
encodeEnsures = this.suppressWarningsManager.ComputeWarningMaskForEnsures(witness);
if (encodeEnsures != null)
{
if (this.methodmask.IsMasked(encodeEnsures))
{
this.methodmask.SignalMasked(encodeEnsures);
this.swallowedCount.UpdateCounter(witness.Outcome);
return(false);
}
}
if (witness.PC.TryGetContainingMethod(out m))
{
encodeEnsuresAtCall = this.suppressWarningsManager.ComputeWarningMaskAtBaseMethod(witness);
methodNameContainingEnsures = this.mdDecoder.FullName(m);
if (MaskedWarnings.IsMaskedInTheOriginalMethod(m, this.mdDecoder, encodeEnsuresAtCall))
{
this.methodmask.SignalMasked(encodeEnsuresAtCall);
this.swallowedCount.UpdateCounter(witness.Outcome);
return(false);
}
}
}
// Is it a masked invariant?
else if (witness.PC.InsideInvariantInMethod &&
witness.PC.TryGetContainingType(out t))
{
encodeInvariant = this.suppressWarningsManager.ComputeWarningMaskForInvariant(witness);
typeNameContainingInvariant = this.mdDecoder.FullName(t);
if (MaskedWarnings.IsMaskedInType(t, this.mdDecoder, encodeInvariant))
{
this.swallowedCount.UpdateCounter(witness.Outcome);
return(false);
}
}
}
bool result;
if (emitRelatedToo)
{
result = base.EmitOutcomeAndRelated(witness, format, args);
}
else
{
result = base.EmitOutcome(witness, format, args);
}
if (witness.Outcome != ProofOutcome.True && this.options.OutputWarningMasks)
{
this.WriteLine("Method {0}: To mask the warning {1}{2} add the attribute: {3}",
this.currMethod.ToString(),
witness.PC.HasRealSourceContext?
"at " + witness.PC.PrimaryMethodLocation().PrimarySourceContext():
"",
"\n", // f: using "\n" instead of Environment.NewLine, because the last one caused '\n' to be printed in the output window of VS
encodeEnsures != null?
this.suppressWarningsManager.ComputeSuppressMessage(encodeEnsures) :
this.suppressWarningsManager.ComputeSuppressMessage(encode));
if (encodeRequiresAtCall != null && methodNameContainingRequires != null)
{
this.WriteLine("Method {0}: To mask *all* warnings issued like the precondition {1}{2} add the attribute: {3} to the method {4}",
this.currMethod.ToString(),
witness.PC.HasRealSourceContext ?
"at " + witness.PC.PrimaryMethodLocation().PrimarySourceContext() :
"",
"\n",// f: using "\n" instead of Environment.NewLine, because the last one caused '\n' to be printed in the output window of VS
this.suppressWarningsManager.ComputeSuppressMessage(encodeRequiresAtCall),
methodNameContainingRequires);
}
if (encodeEnsuresAtCall != null && methodNameContainingEnsures != null)
{
this.WriteLine("Method {0}: To mask *all* warnings issued like the postcondition {1}{2} add the attribute: {3} to the method {4}",
this.currMethod.ToString(),
witness.PC.HasRealSourceContext ?
"at " + witness.PC.PrimaryMethodLocation().PrimarySourceContext() :
"",
"\n", // f: using "\n" instead of Environment.NewLine, because the last one caused '\n' to be printed in the output window of VS
this.suppressWarningsManager.ComputeSuppressMessage(encodeEnsuresAtCall),
methodNameContainingEnsures);
}
if (encodeInvariant != null && typeNameContainingInvariant != null)
{
this.WriteLine("Method {0}: To mask *all* warnings issued like the invariant {1}{2} add the attribute: {3} to the type {4}",
this.currMethod.ToString(),
witness.PC.HasRealSourceContext ?
"at " + witness.PC.PrimaryMethodLocation().PrimarySourceContext() :
"",
"\n",// f: using "\n" instead of Environment.NewLine, because the last one caused '\n' to be printed in the output window of VS
this.suppressWarningsManager.ComputeSuppressMessage(encodeInvariant),
typeNameContainingInvariant);
}
}
return(result);
}
public override bool EmitOutcomeAndRelated(Witness witness, string format, params object[] args)
{
return(EmitOutcome_Internal(true, witness, format, args));
}
public override bool EmitOutcome(Witness witness, string format, params object[] args)
{
return(EmitOutcome_Internal(false, witness, format, args));
}
public bool IsMasked(Witness witness)
{
return(this.output.IsMasked(witness));
}
public override bool EmitOutcome(Witness witness, string format, params object[] args)
{
return(EmitOutcomeInternal(Bucket.Kind.EmitOutcome, witness, format, args));
}