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