public CSharpSyntaxNode AddRequires(ParameterSyntax parameter, SemanticModel semanticModel)
{
Contract.Requires(parameter != null);
Contract.Requires(semanticModel != null);
if (_method != null)
{
var anchor = GetParentForCurrentParameter(parameter, ContractBlock.CreateForMethodAsync(_method, semanticModel).Result);
return(RequiresUtils.AddRequires(parameter, _method, anchor));
}
var accessors = new SyntaxList <AccessorDeclarationSyntax>();
foreach (var accessor in _indexer.AccessorList.Accessors)
{
var contractBlock = ContractBlock.CreateForMethodAsync(accessor, semanticModel).Result;
var anchor = GetParentForCurrentParameter(parameter, contractBlock);
if (contractBlock.Preconditions.Any(x => x.ChecksForNotNull(parameter)))
{
accessors = accessors.Add(accessor);
}
else
{
var body = RequiresUtils.AddRequires(parameter, accessor.Body, anchor);
accessors = accessors.Add(accessor.WithBody(body));
}
}
return(_indexer.WithAccessorList(_indexer.AccessorList.WithAccessors(accessors)));
}
public async Task TestContractBlockWithRequires()
{
// Arrange
string method =
@"public static void Foo(string s{caret}tr, string anotherStr)
{
Contract.Requires(str != null);
Contract.Requires(str.Length == null);
Contract.Requires(anotherStr != null);
Contract.Requires(anotherStr.Length == 42);
}";
var doc = await ClassTemplate.FromMethodAsync(method, withContractUsings : true);
// Act
var contractBlock = await ContractBlock.CreateForMethodAsync(doc.SelectedMethod(), doc.SemanticModel);
// Assert
Assert.AreEqual(4, contractBlock.Preconditions.Count, "Method should have only one precondition.");
var first = contractBlock.Preconditions[0];
Assert.IsTrue(first.ChecksForNotNull(doc.SelectedNode as ParameterSyntax));
var second = contractBlock.Preconditions[1];
Assert.IsFalse(second.ChecksForNotNull(doc.SelectedNode as ParameterSyntax));
var third = contractBlock.Preconditions[2];
Assert.IsFalse(third.ChecksForNotNull(doc.SelectedNode as ParameterSyntax));
}
private async Task <Option <ExpressionStatementSyntax> > GetLastRequiresStatement(Document document, MethodDeclarationSyntax method, CancellationToken token)
{
var semanticModel = await document.GetSemanticModelAsync(token);
var contractBlock = await ContractBlock.CreateForMethodAsync(method, semanticModel, token);
return(contractBlock.Preconditions.LastOrDefault()?.CSharpStatement);
}
public async Task <bool> CheckedInMethodContract(ParameterSyntax parameter, SemanticModel semanticModel, CancellationToken token = default(CancellationToken))
{
if (_method != null)
{
ContractBlock contractBlock = await ContractBlock.CreateForMethodAsync(_method, semanticModel, token);
return(contractBlock.Preconditions.Any(p => p.ChecksForNotNull(parameter)));
}
return(_indexer.AccessorList.Accessors.All(a =>
{
ContractBlock contractBlock = ContractBlock.CreateForMethodAsync(a, semanticModel, token).Result;
return contractBlock.Preconditions.Any(p => p.ChecksForNotNull(parameter));
}));
}
public IEnumerable <ContractBlock> GetMethodContracts(SemanticModel semanticModel, CancellationToken token)
{
if (_method != null)
{
yield return(ContractBlock.CreateForMethodAsync(_method, semanticModel, token).Result);
}
if (_indexer != null)
{
foreach (var accessor in _indexer.AccessorList.Accessors)
{
yield return(ContractBlock.CreateForMethodAsync(accessor, semanticModel, token).Result);
}
}
}
public async Task TestContractBlockWithRequiresAndEnsures()
{
// Arrange
string method =
@"public static string F{caret}oo(string str)
{
Contract.Requires(str != null);
Contract.Ensures(Contract.Result<string>() != null, ""Message"");
Contract.Ensures(Contract.Result<string>().Length != 0, ""Message"");
Contract.Ensures(Contract.Result<string>() != null || Contract.Result<string>().Length != 0, ""Message"");
}";
var doc = await ClassTemplate.FromMethodAsync(method, withContractUsings : true);
// Act
var contractBlock = await ContractBlock.CreateForMethodAsync(doc.SelectedMethod(), doc.SemanticModel);
// Assert
Assert.AreEqual(3, contractBlock.Postconditions.Count);
Assert.IsTrue(contractBlock.Postconditions[0].HasNotNullCheck());
Assert.IsFalse(contractBlock.Postconditions[1].HasNotNullCheck());
Assert.IsTrue(contractBlock.Postconditions[2].HasNotNullCheck());
}
private Option <ExpressionStatementSyntax> GetParentForCurrentParameter(ParameterSyntax parameter, ContractBlock contractBlock)
{
Option <ParameterSyntax> previousParameter = GetPreviousParameter(parameter);
if (!previousParameter.HasValue)
{
return(new Option <ExpressionStatementSyntax>());
}
return(contractBlock.Preconditions.LastOrDefault(p => p.UsesParameter(previousParameter.Value))?.CSharpStatement);
}
private Option <ExpressionStatementSyntax> GetParentForCurrentParameter(Document document, ContractBlock contractBlock)
{
Option <ParameterSyntax> previousParameter = GetPreviousParameter(_parameter.Value);
if (!previousParameter.HasValue)
{
return(new Option <ExpressionStatementSyntax>());
}
//var semanticModel = await document.GetSemanticModelAsync(token);
//var contractBlock = await ContractBlock.CreateForMethodAsync(method, semanticModel, token);
return(contractBlock.Preconditions.LastOrDefault(p => p.UsesParameter(previousParameter.Value))?.CSharpStatement);
}
