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