private void TryMarkSuggestion(SyntaxNode containingmethod, StatementSyntax statementundertest)
{
Contract.Requires(statementundertest != null);
var si = SematicModel.GetDeclaredSymbol(containingmethod) as ISymbol;
Contract.Assert(si != null);
var dci = si.GetDocumentationCommentId();
//if (dci.Equals(methodname))
foreach (var ann in Suggestions.Where(x => x.MethodName.Equals(dci) && x.Kind != ClousotSuggestion.Kind.ReadonlyField))
{
/* the above conditional can lead to false positives
* You could theoretically have another method called ...ObjectInvariantMethod
* and have Contract.Invariants in it, and have the exact invariant that also generated this
* error and we would errorneously delete your invariant too
* but that seems a pretty extreme edge case.
*/
// this web of ifs could be refactored
// I'm trying to avoid checking every statement against every suggestion
//foreach(var precon in sugs[methodname])
//{
//if (ann.Annotation.Equals(statementundertest.GetText().ToString().Replace(ReviewBot.signature, "")))
//if (ann.Annotation.Equals(statementundertest.GetText().ToString()))
if (statementundertest.GetText().ToString().Contains(ann.Annotation.Replace(Constants.String.Signature, "")))
//if (statementundertest.GetText().ToString().Contains(ann.Annotation))
{
//sugs[methodname].Remove(precon);
//if (ann.Kind == ClousotSuggestion.Kind.ObjectInvariant) { Debugger.Break(); }
//RBLogger.Info("Marking bad: {0}", ann);
//ann.isBad = true;
BadSuggestions.Add(ann);
return;
}
//}
}
var isObjectInvariant = containingmethod is MethodDeclarationSyntax &&
ObjectInvariantHelpers.isObjectInvariantMethod((MethodDeclarationSyntax)containingmethod, SematicModel);
if (isObjectInvariant)
{
foreach (var ann in Suggestions.Where(x => x.Kind == ClousotSuggestion.Kind.ObjectInvariant))
{
if (ann.Annotation.Equals(statementundertest.GetText().ToString().TrimEnd('\r', '\n')))
{
//ann.isBad = true;
BadSuggestions.Add(ann);
}
}
//foreach (var precons in sugs.Values)
//{
// foreach (var precon in precons)
// {
// if (precon.Annotation.Equals(statementundertest.GetText().ToString().TrimEnd('\r', '\n')))
// {
// precon.isBad = true;
// }
// }
//}
}
}
static public TMethodDeclarationSyntax InsertStatements <TMethodDeclarationSyntax>(this TMethodDeclarationSyntax method, StatementSyntax statement, ContractKind kind, bool avoidDuplicates = true)
where TMethodDeclarationSyntax : BaseMethodDeclarationSyntax
{
Contract.Requires(statement != null);
if (method.Body == null)
{
return(null);
}
var oldStatements = method.Body.Statements;
var newStatements = new List <StatementSyntax>();
var conditionText = statement.GetText();
var n = oldStatements.Count;
var i = 0;
// Take a prefix of the oldStatments before inserting "statement".
if (kind == ContractKind.Precondition)
{
// prefix = "precondition" ==> all existing preconditions
while (i < n)
{
if (!oldStatements[i].IsPrecondition())
{
break;
}
if (avoidDuplicates && oldStatements[i].GetText() == conditionText)
{
return(method);
}
newStatements.Add(oldStatements[i]);
i++;
}
newStatements.Add(statement);
while (i < n)
{
newStatements.Add(oldStatements[i]);
i++;
}
}
else if (kind == ContractKind.Postcondition)
{
// prefix = "postcondition" ==> all existing contracts
while (i < n && (oldStatements[i].IsPostcondition() || oldStatements[i].IsPrecondition()))
{
if (avoidDuplicates && oldStatements[i].IsPostcondition() && oldStatements[i].GetText() == conditionText)
{
return(method);
}
newStatements.Add(oldStatements[i]);
i++;
}
while (i < n)
{
if (!oldStatements[i].IsPostcondition())
{
break;
}
if (avoidDuplicates && oldStatements[i].GetText() == conditionText)
{
return(method);
}
newStatements.Add(oldStatements[i]);
i++;
}
newStatements.Add(statement);
while (i < n)
{
newStatements.Add(oldStatements[i]);
i++;
}
}
else
{
newStatements.Add(statement);
newStatements.AddRange(oldStatements);
}
var x = SyntaxFactory.List <StatementSyntax>(newStatements);
if (method is ConstructorDeclarationSyntax)
{
var methodConstructor = method as ConstructorDeclarationSyntax;
return(SyntaxFactory.ConstructorDeclaration(
attributeLists: methodConstructor.AttributeLists,
modifiers: methodConstructor.Modifiers,
identifier: methodConstructor.Identifier,
parameterList: method.ParameterList,
initializer: null,
body: SyntaxFactory.Block(statements: x)
) as TMethodDeclarationSyntax);
}
if (method is ConversionOperatorDeclarationSyntax)
{
throw new NotImplementedException();
}
if (method is DestructorDeclarationSyntax)
{
throw new NotImplementedException();
}
if (method is MethodDeclarationSyntax)
{
var methodMethod = method as MethodDeclarationSyntax;
return(SyntaxFactory.MethodDeclaration(
attributeLists: methodMethod.AttributeLists,
modifiers: methodMethod.Modifiers,
returnType: methodMethod.ReturnType,
explicitInterfaceSpecifier: methodMethod.ExplicitInterfaceSpecifier,
identifier: methodMethod.Identifier,
typeParameterList: methodMethod.TypeParameterList,
parameterList: method.ParameterList,
constraintClauses: methodMethod.ConstraintClauses,
body: SyntaxFactory.Block(statements: x)
) as TMethodDeclarationSyntax);
}
if (method is OperatorDeclarationSyntax)
{
throw new NotImplementedException();
}
throw new NotSupportedException();
}