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