private bool IsAvailable(IInvocationExpression invocationExpression, out string argumentName)
{
argumentName = null;
var contractAssertion = CodeContractAssertion.FromInvocationExpression(invocationExpression) as ContractRequires;
if (contractAssertion == null)
{
return(false);
}
Func <ReferenceArgument, IParameter> paramSelector =
ra =>
{
var r = ra.With(x => x.ReferenceExpression)
.With(x => x.Reference)
.With(x => x.Resolve())
.With(x => x.DeclaredElement as IParameter);
return(r);
};
Func <IParameter, bool> isNullableOrDefault =
pd => pd.IsDefaultedToNull() || pd.HasClrAttribute(typeof(CanBeNullAttribute));
var result =
contractAssertion.Predicates
.Where(p => p.ChecksForNotNull())
.Select(p => p.Argument)
.OfType <ReferenceArgument>()
.FirstOrDefault(p => paramSelector(p).With(x => (bool?)isNullableOrDefault(x)) == true);
argumentName = result.With(x => x.BaseArgumentName);
return(argumentName != null);
}
private bool IsAvailable(IInvocationExpression expression, out MemberWithAccess preconditionContainer,
out MemberWithAccess lessVisibleMember)
{
preconditionContainer = null;
lessVisibleMember = null;
var contractAssertion = CodeContractAssertion.FromInvocationExpression(expression);
if (contractAssertion == null || contractAssertion.AssertionType != ContractAssertionType.Requires)
{
return(false);
}
var preconditionHolder =
expression.GetContainingStatement()
.With(x => x.GetContainingTypeMemberDeclaration())
.With(x => x.DeclaredElement)
.With(MemberWithAccess.FromDeclaredElement);
preconditionContainer = preconditionHolder;
if (preconditionContainer == null)
{
return(false);
}
// Looking for a "enclosing" members that are less visible then a contract holder.
// The only exception is a field with ContractPublicPropertyName attribute.
lessVisibleMember =
ProcessReferenceExpressions(contractAssertion.OriginalPredicateExpression)
.FirstOrDefault(member =>
!FieldFromPreconditionMarkedWithContractPublicPropertyName(member) &&
!AccessVisibilityChecker.Member(member).IsAccessibleFrom(preconditionHolder));
return(lessVisibleMember != null);
}
protected override sealed void Run(IInvocationExpression element, ElementProblemAnalyzerData data, IHighlightingConsumer consumer)
{
var contractAssertion = CodeContractAssertion.FromInvocationExpression(element) as ContractRequires;
if (contractAssertion == null)
{
return;
}
var preconditionContainer = element
.With(x => x.GetContainingStatement())
.With(x => x.GetContainingTypeMemberDeclaration())
.With(x => x.DeclaredElement)
.With(MemberWithAccess.FromDeclaredElement);
if (preconditionContainer == null)
{
return;
}
var highlightings = DoRun(element, contractAssertion, preconditionContainer);
foreach (var highlighting in highlightings)
{
consumer.AddHighlighting(
highlighting, element.GetDocumentRange(), element.GetContainingFile());
}
}
public static Task <ContractBlock> CreateForMethodAsync(BaseMethodDeclarationSyntax methodDeclaration, SemanticModel semanticModel, CancellationToken token = default(CancellationToken))
{
Contract.Requires(methodDeclaration != null);
Contract.Requires(semanticModel != null);
Contract.Ensures(Contract.Result <ContractBlock>() != null);
var contractStatements =
methodDeclaration.DescendantNodes()
.OfType <ExpressionStatementSyntax>()
.Select(e => CodeContractAssertion.Create(e, semanticModel))
.Where(x => x.HasValue)
.Select(x => x.Value)
.ToList();
var preconditions = contractStatements.OfType <IPrecondition>().ToList();
var postconditions = contractStatements.OfType <ContractEnsures>().ToList();
return(Task.FromResult(new ContractBlock(preconditions, postconditions)));
}
