private MethodDeclarationSyntax ExtractAndAddPsQs(ref CancellationToken cancellationToken, Microsoft.CodeAnalysis.Document localDocument, CompilationUnitSyntax newRoot, MethodDeclarationSyntax newExtractedMethod)
{
// Let Clousot see the rewritten unit
var connectionToClousot = new RoslynToCCICodeModel.ClousotGlue();
foreach (var result in connectionToClousot.AnalyzeMeAUnit(localDocument, newRoot, cancellationToken, this.options,
new string[] { "-extractmethodmode", "-arrays:arraypurity", "-suggest:requires" /*"-memberNameSelect",*/ }))
{
Utils.Trace("Getting Clousot Result");
String condition;
ContractKind kind;
if (result.IsExtractMethodSuggestion && result.Message.TryParseSuggestion(out kind, out condition))
{
Utils.Trace("Inserting Clousot result. New Condition: " + condition);
// Parse the condition
var newContract = SyntaxFactory.ParseStatement(condition + Environment.NewLine);
newExtractedMethod = newExtractedMethod.InsertStatements(newContract, kind);
}
else
{
Utils.Trace("Skipped Clousot output : " + result.Message);
}
}
return(newExtractedMethod);
}
private MethodDeclarationSyntax ExtractAndAddPmQm(ref CancellationToken cancellationToken,
Microsoft.CodeAnalysis.Document localDocument, SyntaxNode oldRoot, MethodDeclarationSyntax newExtractedMethod)
{
var newText = oldRoot.ToFullString();
Utils.DumpCSFile("BeforePmQm.cs", newText);
var newSolution = localDocument.Project.Solution.WithDocumentText(localDocument.Id, new StringText(newText));
//var newSolution = localDocument.Project.Solution.UpdateDocument(localDocument.Id, new StringText(newText));
var newLocalDocument = newSolution.GetDocument(localDocument.Id);
localDocument = null; // to be sure we do not use it
var newTree = newLocalDocument.GetSyntaxTree();
Utils.Trace("Running Clousot to infer <Pm, Qm> and <Pr, Qr>");
var newRoot = (CompilationUnitSyntax)newTree.GetRoot();
if (newRoot.ContainsDiagnostics)
{
Utils.Trace("Aborting: the new tree has syntax errors");
return(null);
}
// Let Clousot see the rewritten unit
var connectionToClousot = new RoslynToCCICodeModel.ClousotGlue();
foreach (var result in connectionToClousot.AnalyzeMeAUnit(newLocalDocument, newRoot, cancellationToken, this.options,
new string[] { "-extractmethodmoderefine", newExtractedMethod.Identifier.ValueText, "-premode", "combined", "-suggest", "methodensures", "-suggest:requires" }))
{
Utils.Trace("Getting Clousot Result");
String condition;
ContractKind kind;
if (result.Message.TryParseSuggestion(out kind, out condition))
{
Utils.Trace("Inserting Clousot result. New Condition: " + condition);
// Parse the condition
var newContract = SyntaxFactory.ParseStatement(condition + Environment.NewLine);
if (!newContract.ContainsDiagnostics)
{
newExtractedMethod = newExtractedMethod.InsertStatements(newContract, kind);
}
else
{
Utils.Trace("\tskipped, as it contains syntax errors");
}
}
}
return(newExtractedMethod);
}
private MethodDeclarationSyntax ExtractAndAddPmQm(ref CancellationToken cancellationToken,
Microsoft.CodeAnalysis.Document localDocument, SyntaxNode oldRoot, MethodDeclarationSyntax newExtractedMethod) {
var newText = oldRoot.ToFullString();
cancellationToken.ThrowIfCancellationRequested();
Utils.DumpCSFile("BeforePmQm.cs", newText);
var newSolution = localDocument.Project.Solution.WithDocumentText(localDocument.Id, SourceText.From(newText));
//var newSolution = localDocument.Project.Solution.UpdateDocument(localDocument.Id, SourceText.From(newText));
var newLocalDocument = newSolution.GetDocument(localDocument.Id);
localDocument = null; // to be sure we do not use it
var newTree = newLocalDocument.GetSyntaxTree();
Utils.Trace("Running Clousot to infer <Pm, Qm> and <Pr, Qr>");
var newRoot = (CompilationUnitSyntax)newTree.GetRoot();
if (newRoot.ContainsDiagnostics) {
Utils.Trace("Aborting: the new tree has syntax errors");
return null;
}
// Let Clousot see the rewritten unit
var connectionToClousot = new RoslynToCCICodeModel.ClousotGlue();
var results = connectionToClousot.AnalyzeMeAUnit(newLocalDocument, newRoot, cancellationToken, this.options,
new string[] { "-extractmethodmoderefine", newExtractedMethod.Identifier.ValueText, "-premode", "combined", "-suggest", "methodensures", "-suggest:requires" });
if (results == null) return null;
foreach (var result in results)
{
cancellationToken.ThrowIfCancellationRequested();
Utils.Trace("Getting Clousot Result");
String condition;
ContractKind kind;
if (result.Message.TryParseSuggestion(out kind, out condition)) {
Utils.Trace("Inserting Clousot result. New Condition: " + condition);
// Parse the condition
var newContract = SyntaxFactory.ParseStatement(condition + Environment.NewLine);
if (!newContract.ContainsDiagnostics) {
newExtractedMethod = newExtractedMethod.InsertStatements(newContract, kind);
} else {
Utils.Trace("\tskipped, as it contains syntax errors");
}
}
}
return newExtractedMethod;
}
private MethodDeclarationSyntax ExtractAndAddPsQs(ref CancellationToken cancellationToken, Microsoft.CodeAnalysis.Document localDocument, CompilationUnitSyntax newRoot, MethodDeclarationSyntax newExtractedMethod)
{
// Let Clousot see the rewritten unit
var connectionToClousot = new RoslynToCCICodeModel.ClousotGlue();
var results = connectionToClousot.AnalyzeMeAUnit(localDocument, newRoot, cancellationToken, this.options,
new string[] { "-extractmethodmode", "-arrays:arraypurity", "-suggest:requires" /*"-memberNameSelect",*/ });
if (results == null) return null;
foreach (var result in results)
{
cancellationToken.ThrowIfCancellationRequested();
Utils.Trace("Getting Clousot Result");
String condition;
ContractKind kind;
if (result.IsExtractMethodSuggestion && result.Message.TryParseSuggestion(out kind, out condition))
{
Utils.Trace("Inserting Clousot result. New Condition: " + condition);
// Parse the condition
var newContract = SyntaxFactory.ParseStatement(condition + Environment.NewLine);
newExtractedMethod = newExtractedMethod.InsertStatements(newContract, kind);
}
else
{
Utils.Trace("Skipped Clousot output : " + result.Message);
}
}
return newExtractedMethod;
}
private IEnumerable <SearchResult> DoTheWorkToSearchTheCallers(string query)
{
// We should move this in the UI
var selectionStart = this.wpfTextView.Selection.Start.Position.Position;
var selectionEnd = this.wpfTextView.Selection.End.Position.Position;
var results = new List <SearchResult>();
if (selectionStart == selectionEnd)
{
Trace.WriteLine(string.Format("Selection: {0}", selectionStart));
var container = wpfTextView.TextBuffer.AsTextContainer();
Workspace workspace;
Workspace.TryGetWorkspace(container, out workspace);
if (workspace != null)
{
Document doc;
var docIds = workspace.GetRelatedDocumentIds(container);
if (docIds.Any())
{
var docId = docIds.First();
doc = Helper.OpenDocument(workspace, docId);
var span = new Microsoft.CodeAnalysis.Text.TextSpan(selectionStart, 0);
var syntaxNode = doc.GetSyntaxTree().GetRoot() as SyntaxNode;
if (syntaxNode != null)
{
var methodFinder = EnclosingMethodFinder.GetMethodSpans(syntaxNode);
BaseMethodDeclarationSyntax method;
if (methodFinder.TryGetValueContainingSpan(span, out method))
{
// Add the precondition
var preAsStr = string.Format(CLOUSOT_QUERY_PRECONDITION, query);
var pre = SyntaxFactory.ParseStatement(preAsStr + Environment.NewLine + Environment.NewLine); // F: adding two newlines as Roslyn for some reason pretty print the text in a different way, and loses one line at the end of the file
var newMethod = method.InsertStatements(pre, ContractKind.Precondition);
var newRoot = ((SyntaxNode)doc.GetSyntaxTree().GetRoot()).ReplaceNode(method, newMethod);
// Create the new Roslyn environment
var newSolution = doc.Project.Solution.WithDocumentText(doc.Id, newRoot.GetText());
//var newSolution = doc.Project.Solution.UpdateDocument(doc.Id, newRoot.GetText());
var locDocument = newSolution.GetDocument(doc.Id);
var newTree = (CompilationUnitSyntax)locDocument.GetSyntaxTree().GetRoot();
try
{
Trace.WriteLine(string.Format("Annotated tree for the state:\n{0}", newRoot.GetText()));
var run = new RoslynToCCICodeModel.ClousotGlue().AnalyzeMeAUnit(locDocument,
newTree,
new System.Threading.CancellationToken(),
this.options,
new string[] { "-warnscores:false", "-sortwarns:false", "-suggest:!!", "-show", "validations" },
false
);
if (run == null)
{
return(new SearchResult[0]);
}
var fullString = preAsStr + Environment.NewLine;
var injectedPrecondition = newRoot.DescendantNodes().OfType <StatementSyntax>().Where(s => s.GetText().ToString().Equals(fullString)).FirstOrDefault();
if (injectedPrecondition == null)
{
return(new SearchResult[0]);
}
var injectedPreconditionSpan = injectedPrecondition.Span;
var newCodeIsBiggerBy = newMethod.FullSpan.Length - method.FullSpan.Length;
foreach (var r in run)
{
Trace.WriteLine(string.Format("{0}: {1}", r.Message, r.outcome));
if (r.outcome.HasValue && // it is not a suggestion
r.startPoint != null &&
r.RelatedLocationsWithSourceContext != null &&
r.RelatedLocationsWithSourceContext.Count() == 1 && // Guess: we want to have to only related to be our new contract
r.Message.Contains("requires") // HACK HACK HACK HACK HACK HACK HACK HACK HACK HACK HACK HACK : We should understand why sometimes r.RelatedLocationsWithSourceContext.Count() == 1, but the proof obligation is a non-null. From debugger seems that the related pc is the same as the original
)
{
var pc = r.RelatedLocationsWithSourceContext.First();
var startIndex = pc.Block.SourceStartIndex(pc);
var length = pc.Block.SourceLength(pc);
if (!injectedPreconditionSpan.Contains(new Microsoft.CodeAnalysis.Text.TextSpan(startIndex, length)))
{
continue;
}
// But if the pc is after the injected precondition, then need to substract off the
// length of the injected text from the start position
var realSpan = (r.Span.Start < startIndex) ? r.Span : new Microsoft.CodeAnalysis.Text.TextSpan(r.Span.Start - newCodeIsBiggerBy, r.Span.Length);
//BaseMethodDeclarationSyntax caller;
var loc = doc.GetSyntaxTree().GetLocation(realSpan);
var caller = syntaxNode.DescendantNodes().OfType <MethodDeclarationSyntax>().Where(m => m.Span.Contains(realSpan)).FirstOrDefault();
if (caller != null)
{
var startLine = doc.GetSyntaxTree().GetLineSpan(realSpan, true).StartLinePosition.Line + 1;
var startColumn = doc.GetSyntaxTree().GetLineSpan(realSpan, true).StartLinePosition.Character + 1;
results.Add(new SearchResult(startLine, startColumn, caller, r.outcome.Value));
}
else
{
Trace.WriteLine("Failed to find the containing method");
}
}
}
}
catch (Exception e)
{
Trace.WriteLine(string.Format("Some exception was thrown inside Clousot...\nDetails:\n{0}", e.ToString()));
}
}
}
}
}
}
return(results);
}
// TODO: refactor this code to share with DoTheWork
private string DoTheWorkToInferInvariants()
{
// We should move this in the UI
var selectionStart = this.wpfTextView.Selection.Start.Position.Position;
var selectionEnd = this.wpfTextView.Selection.End.Position.Position;
if (selectionStart == selectionEnd)
{
Trace.WriteLine(string.Format("Selection: {0}", selectionStart));
var container = wpfTextView.TextBuffer.AsTextContainer();
//var text = wpfTextView.TextBuffer.CurrentSnapshot.AsText();
Workspace workspace;
Workspace.TryGetWorkspace(container, out workspace);
//var workspaceDiscovery = Helper.GetMefService<IWorkspaceDiscoveryService>();
//var workspace = workspaceDiscovery.GetWorkspace(container);
if (workspace != null)
{
Document doc;
var docIds = workspace.GetRelatedDocumentIds(container);
if (docIds.Any())
{
var docId = docIds.First();
doc = Helper.OpenDocument(workspace, docId);
var syntax = doc.GetSyntaxTree();
var source = syntax.GetText().ToString();
// Generate the new text
var newText = GenerateAdornedSource(doc, selectionStart);
var newSolution = doc.Project.Solution.WithDocumentText(doc.Id, SourceText.From(newText));
//var newSolution = doc.Project.Solution.UpdateDocument(doc.Id, StringText.From(newText));
var locDocument = newSolution.GetDocument(doc.Id);
var newTree = (CompilationUnitSyntax)locDocument.GetSyntaxTree().GetRoot();
if (!newTree.ContainsDiagnostics)
{
try
{
Trace.WriteLine(string.Format("Annotated tree for the state:\n{0}", newText));
var clousotConnection = new RoslynToCCICodeModel.ClousotGlue();
var run = clousotConnection.AnalyzeMeAUnit(locDocument,
newTree,
new System.Threading.CancellationToken(),
this.options,
new string[] { "-warnscores:false", "-sortwarns:false", "-suggest:!!", "-invariantsuggestmode:true" },
true // we want to filter all the messages but the answer of Clousot
);
if (run == null)
{
return(null);
}
foreach (var r in run)
{
Trace.WriteLine(string.Format("{0}: {1}", r.Message, r.outcome));
if (r.IsInvariantAtSuggestion)
{
return(PrettyFormat(r.Message));
}
}
}
catch (Exception e)
{
Trace.WriteLine(string.Format("Some exception was thrown inside Clousot...\nDetails:\n{0}", e.ToString()));
}
}
else
{
Trace.WriteLine("Compilation error from Roslyn");
}
}
}
}
else
{
Trace.WriteLine(string.Format("start/end do not match {0} {1}", selectionStart, selectionEnd));
}
return(null);
}
private ProofOutcome?DoTheWork(string query, IEnumerable <CodeAssumption> assumptions)
{
// We should move this in the UI
var selectionStart = this.wpfTextView.Selection.Start.Position.Position;
var selectionEnd = this.wpfTextView.Selection.End.Position.Position;
if (selectionStart == selectionEnd)
{
Trace.WriteLine(string.Format("Selection: {0}", selectionStart));
var container = wpfTextView.TextBuffer.AsTextContainer();
//var text = wpfTextView.TextBuffer.CurrentSnapshot.AsText();
Workspace workspace;
Workspace.TryGetWorkspace(container, out workspace);
//var workspaceDiscovery = Helper.GetMefService<IWorkspaceDiscoveryService>();
//var workspace = workspaceDiscovery.GetWorkspace(container);
if (workspace != null)
{
Document doc;
var docIds = workspace.GetRelatedDocumentIds(container);
if (docIds.Any())
{
var docId = docIds.First();
doc = Helper.OpenDocument(workspace, docId);
var syntax = doc.GetSyntaxTree();
var source = syntax.GetText().ToString();
var newText = GenerateInstrumentedSourceText(query, assumptions, selectionStart, source);
var newSolution = doc.Project.Solution.WithDocumentText(doc.Id, SourceText.From(newText));
//var newSolution = doc.Project.Solution.UpdateDocument(doc.Id, StringText.From(newText));
var locDocument = newSolution.GetDocument(doc.Id);
var newTree = (Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax)locDocument.GetSyntaxTree().GetRoot();
var adornedSource = GenerateAdornedSource(doc, selectionStart);
if (!newTree.ContainsDiagnostics)
{
try
{
var clousotConnection = new RoslynToCCICodeModel.ClousotGlue();
var run = clousotConnection.AnalyzeMeAUnit(locDocument,
newTree,
new System.Threading.CancellationToken(),
this.options,
new string[] { "-warnscores:false", "-sortwarns:false", "-show:validations", "-show:unreached" },
true // we want to filter all the messages but the answer of Clousot
);
if (run == null)
{
return(null);
}
foreach (var r in run)
{
Trace.WriteLine(string.Format("{0}: {1}", r.Message, r.outcome));
// if we have a non-null, then this is the outcome
// We can have outcome == null for e.g., suggestions.
// In this case we simply ignore them
if (r.outcome.HasValue)
{
return(r.outcome);
}
}
}
catch (Exception e)
{
Trace.WriteLine(string.Format("Some exception was thrown inside Clousot...\nDetails:\n{0}", e.ToString()));
}
}
else
{
Trace.WriteLine("Compilation error from Roslyn");
}
}
}
}
else
{
Trace.WriteLine(string.Format("start/end do not match {0} {1}", selectionStart, selectionEnd));
}
return(null);
}
private IEnumerable <SearchResult> DoTheWorkToSearchTheCallers(string query)
{
// We should move this in the UI
var selectionStart = this.wpfTextView.Selection.Start.Position.Position;
var selectionEnd = this.wpfTextView.Selection.End.Position.Position;
var results = new List <SearchResult>();
if (selectionStart == selectionEnd)
{
Trace.WriteLine(string.Format("Selection: {0}", selectionStart));
var container = wpfTextView.TextBuffer.AsTextContainer();
EditorWorkspace workspace;
EditorWorkspace.TryGetWorkspace(container, out workspace);
if (workspace != null)
{
Document doc;
DocumentId docId;
if (workspace.TryGetDocumentId(container, out docId))
{
doc = Helper.OpenDocument(workspace, docId);
var span = new Microsoft.CodeAnalysis.Text.TextSpan(selectionStart, 0);
var syntaxNode = doc.GetSyntaxTree().GetRoot() as SyntaxNode;
if (syntaxNode != null)
{
var methodFinder = EnclosingMethodFinder.GetMethodSpans(syntaxNode);
BaseMethodDeclarationSyntax method;
if (methodFinder.TryGetValueContainingSpan(span, out method))
{
// Add the precondition
var preAsStr = string.Format(CLOUSOT_QUERY_PRECONDITION, query);
var pre = SyntaxFactory.ParseStatement(preAsStr + Environment.NewLine + Environment.NewLine); // F: adding two newlines as Roslyn for some reason pretty print the text in a different way, and loses one line at the end of the file
var newMethod = method.InsertStatements(pre, ContractKind.Precondition);
var newRoot = ((SyntaxNode)doc.GetSyntaxTree().GetRoot()).ReplaceNode(method, newMethod);
// Create the new Roslyn environment
var newSolution = doc.Project.Solution.WithDocumentText(doc.Id, new StringText(newRoot.GetText().ToString()));
//var newSolution = doc.Project.Solution.UpdateDocument(doc.Id, new StringText(newRoot.GetText()));
var locDocument = newSolution.GetDocument(doc.Id);
var newTree = (CompilationUnitSyntax)locDocument.GetSyntaxTree().GetRoot();
try
{
Trace.WriteLine(string.Format("Annotated tree for the state:\n{0}", newRoot.GetText()));
var run = new RoslynToCCICodeModel.ClousotGlue().AnalyzeMeAUnit(locDocument,
newTree,
new System.Threading.CancellationToken(),
this.options,
new string[] { "-warnscores:false", "-sortwarns:false", "-suggest:!!", "-show", "validations" },
false
);
foreach (var r in run)
{
Trace.WriteLine(string.Format("{0}: {1}", r.Message, r.outcome));
if (r.outcome.HasValue && // it is not a suggestion
r.startPoint != null &&
r.Message.Contains("Contract.Requires") && r.Message.Contains(query)) // we should do better than chekcing the string. This is very weak
{
BaseMethodDeclarationSyntax caller;
if (methodFinder.TryGetValueContainingSpan(r.Span, out caller))
{
var pair = r.startPoint;
results.Add(new SearchResult(pair.Item1, pair.Item2, caller, r.outcome.Value));
}
else
{
Trace.WriteLine("Failed to find the containing method");
}
}
}
}
catch (Exception e)
{
Trace.WriteLine(string.Format("Some exception was thrown inside Clousot...\nDetails:\n{0}", e.ToString()));
}
}
}
}
}
}
return(results.Distinct());
}